팰린드롬

실습 설명

"토마토"나 "기러기"처럼 거꾸로 읽어도 똑같은 단어를 '팰린드롬(palindrome)'이라고 부릅니다.

팰린드롬 여부를 확인하는 함수 is_palindrome을 작성하려고 하는데요. is_palindrome은 파라미터 word가 팰린드롬이면 True를 리턴하고 팰린드롬이 아니면 False를 리턴합니다.

예를 들어서 "racecar"과 "토마토"는 거꾸로 읽어도 똑같기 때문에 True가 출력되어야 합니다. 그리고 "hello"는 거꾸로 읽으면 "olleh"가 되기 때문에 False가 나와야 하는 거죠.

실습 결과

True
False
True
True
False

출처 : 코드잇

---

def is_palindrome(word):
    # 여기에 코드를 작성하세요
    list_word = list(word)
    for i in range(len(word)//2):
        if list_word[i] != list_word[-i-1]:
            return False
    return True

# 테스트 코드
print(is_palindrome("racecar"))
print(is_palindrome("stars"))
print(is_palindrome("토마토"))
print(is_palindrome("kayak"))
print(is_palindrome("hello"))

혹은

def is_palindrome_simple(word):
    return word == word[::-1]

---

# --- is_palindrome 함수를 가장 간단하게 푸는 방법 (슬라이싱 사용) ---

# '가장 간단한 힌트'는 'word[::-1]'를 사용하는 것이었습니다.

# 이는 파이썬의 '슬라이싱(slicing)' 기능을 이용해 문자열을 뒤집는 방법입니다.

# 'word[::-1]'의 의미:

# [::]는 문자열 전체를 의미하고, 마지막의 -1은 역순을 의미합니다.

# 따라서 word[::-1]는 word 문자열을 거꾸로 뒤집은 새로운 문자열이 됩니다.

# 예: word가 "hello" 라면 word[::-1]는 "olleh"가 됩니다.

# 회문(palindrome)은 거꾸로 읽어도 똑같은 단어이므로,

# 원본 단어(word)와 뒤집은 단어(word[::-1])가 같은지만 비교하면 됩니다.

파이썬 슬라이싱 (Slicing)

 슬라이싱은 리스트, 튜플, 문자열 같은 시퀀스(sequence) 자료형의 일부를 원하는 대로 잘라내어 새로운 자료형을 만드는
  기능입니다.

 기본 문법: variable[start:stop:step]

   * start: 슬라이싱을 시작할 인덱스입니다. 생략하면 처음부터 시작합니다.
   word[2:5]: 인덱스 2부터 4까지의 요소를 가져옵니다.

자주 사용하는 슬라이싱 예시
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

1. `letters[2:5]`
       - 인덱스 2부터 5 앞까지 (`c`, `d`, `e`)
       - 결과: `['c', 'd', 'e']`
2. `letters[:4]`
       - 처음부터 인덱스 4 앞까지 (`a`, `b`, `c`, `d`)
       - 결과: `['a', 'b', 'c', 'd']`
3. `letters[6:]`
       - 인덱스 6부터 끝까지 (`g`, `h`, `i`, `j`)
       - 결과: `['g', 'h', 'i', 'j']`
4. `letters[::2]`
       - 처음부터 끝까지 2칸씩 건너뛰며 (`a`, `c`, `e`, `g`, `i`)
       - 결과: `['a', 'c', 'e', 'g', 'i']`
5. `letters[::-1]`
       - 처음부터 끝까지 거꾸로 (`j`부터 `a`까지)
       - 결과: `['j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']`

---

슬라이싱 미니 퀴즈
아래 코드의 실행 결과를 예상해보세요.

`quiz_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]`
`quiz_str = "Hello, Gemini!"`

문제 1: `print(quiz_list[3:8])`
정답: 

문제 2: `print(quiz_list[:5])`
정답:

문제 3: `print(quiz_list[7:])`
정답:

문제 4: `print(quiz_list[::3])`
정답:

문제 5: `print(quiz_str[::-1])`
정답:

문제 6 (응용): `print(quiz_list[8:2:-2])`
정답:

[40, 50, 60, 70, 80]
[10, 20, 30, 40, 50]
[80, 90, 100]
[10, 40, 70, 100]
!inimeG ,olleH
[90, 70, 50]

# --- 슬라이싱 심화 설명: quiz_list[8:2:-2] --

# `quiz_list[8:2:-2]`의 실제 결과가 `[90, 70, 50]`이 되는 이유:

# (주석에 적힌 정답 `90, 70, 50, 30, 10`은 오타입니다. `stop` 인덱스 `2`는 포함되지 않기 때문입니다.)

 

# 이 슬라이싱은 `[start:stop:step]` 형식에 따라 다음과 같이 해석됩니다.

# - start = 8 (8번 인덱스에서 시작)

# - stop = 2 (2번 인덱스 앞에서 종료)

# - step = -2 (2칸씩 거꾸로 이동)

 

# 동작 순서:

# 1. 시작(start): 인덱스 8에서 시작합니다. `quiz_list[8]`의 값은 90입니다.

# 2. 증감(step): step이 -2이므로 인덱스를 2만큼 '거꾸로' 이동합니다. (8 -> 6). `quiz_list[6]`의 값은 70입니다.

# 3. 증감(step): 다시 인덱스를 2만큼 거꾸로 이동합니다. (6 -> 4). `quiz_list[4]`의 값은 50입니다.

# 4. 종료(stop): 다시 인덱스를 2만큼 거꾸로 이동하면 2가 됩니다. 이 값은 stop 인덱스 2와 같으므로 슬라이싱이 멈춥니다.

#    (stop 인덱스는 결과에 포함되지 않으므로 `quiz_list[2]`인 30은 결과에 들어가지 않습니다.)

#

# 따라서 최종 결과는 [90, 70, 50]이 됩니다.