s1="Hello"
s2="World"
s3="Python"
정답:
Hello World
Pyth3n
hello //lower() 모든 문자열을 소문자로 바꿔라!
파이썬 재귀함수 문제
def calc(n)
if n<=1
return n
else
if n%2==0
return n*calc(n-1)
else
return n+calc(n-1)
| 5 5+c(4)=25 |
| 4 4*c(3)=20 |
| 3+c(2)=5 |
| 2*c(1)=2 |
| 6*c(5)=150 |
| 5+c(4)=25 |
| 4*c(3)=20 |
| 3+c(2)=5 |
| 2*c(1)==2 |
결과 = calc(5)
print(f"5를 넣으면: {결과}")
결과=calc(6)
print(f"6을 넣으면: {결과}")
정답:
5를 넣으면: 25
6을 넣으면: 150
리스트 컴프리헨션
[]리스트 만들기!
s=[x**2 for x in range(5)] // range(5 ) 는 0부터 4까지.
print ("Squares:", squares)
| x**2 |
| 0의 제곱=0 |
| 1의 제곱=1 |
| 2 의 제곱=4 |
| 3 의 제곱=9 |
| 4 의 제곱=16 |
정답:
Squares: [0,1,4,9,16]
e=[x for x in range(10) if x %2 ==0] [:5] //range(10)은 0부터 9까지. [:5] 슬라이싱. 0부터 4까지 나타내라.
print("Evens:", evens)
| x %2 ==0 |
| 0 %2 ==0 참 |
| 1 %2 ==0 거짓 |
| 2 %2 ==0 참 |
| 4 %2 ==0 참 |
| 6 %2 ==0 참 |
| 8 %2 ==0 참 |
0,2,4,6,8
[0][1][2][3][4]
정답:
Evens: [ 0,2,4,6,8 ]
Squares: [0,1,4,9,16]
Evens: [ 0,2,4,6,8 ]
sum=[s[i]+e[i] for in range(5)] //0부터 4까지.
정답:
[0,3,8,15,24]
def p(n)
d=[i for i in range(1,n) if n%i==0]
return sum(d)==n
| range(1,1) | 1%1==0 | |||
| range(1,2) | 2%1==0 | d=[1] | sum(d)==2 | 거짓 |
| range(1,3) | 3%1==0 | d=[1] | sum(d)==3 | 거짓 |
| 3%2==0 | ||||
| range(1,4) | 4%1==0 | d=[1,2] | sum(d)==4 | 거짓 완전수 찾기. 자기자신 뺀 나머지 약수 다 더해서 내가 나오면 완전수. |
| 4%2==0 | ||||
| 4%3==0 | ||||
summ=0
for num in range(1,51) //1에서 50까지.
if p(num) 참이면
summ= summ+num
print(f"완전수 합: {summ}")
정답:
완전수 합: 34
완전수
6은 123 더하면 6나옴. 완전수
8은 124
10은 125
12은 12346
14는 127
16은 1248
18은 129
20은 124510
22은 1211
24는 12346812
26은 1,2,13
28은 124714=28. 완전수
30은 123561015
32은 124816
34은 1217
36은 123491218
38은 1219
40은 1241020
42은 123671421
44는 1241122
46은 1223
48은 124681224
50은 1251025
차라리 외워. 완전수는 6하고 28이야.
파이썬 딕셔너리. 사전형태.
과일=["사과", "바나나", "파인애플"] //["키", "키"] 안에 들어있는 게 키임.
야채=["당근", "오이", "양배추"]
내 사전={
"사과":45,
"바나나":67,
"파인애플": 89,
"당근": 23,
"오이": 54,
"양배추": 32
}
전부 더함=0
반목문 for key, value in 내 사전.items(): //메소드임. items() 메소드는 key하고 value의 쌍을 가져옴.
if key in 과일: //과일에만 있는 것을 키로 쓰겠다는말. 참이면 아래 수행.
전부 더함= 전부 더함+ value
print(f"sum: {전부 더함}")
//45+67+89=112+89=201
정답:
sum: 201
집합의 연산. set. 중복값을 허용하지 않는다!!!
야채{"당근", "브포콜리", "시금치", "당근", "양상추"}
야채2={"브로콜리", "양배추", "오이"}
i=야채.intersection(야채2) //인터섹션. 교집합. {'브로콜리'}
u=야채. union(야채2) //유니온. 합집합. {'당근', '브포콜리', '시금치', '당근', '양상추', '양배추', '오이'}
d=야채. difference(야채2) "디퍼런스. 차집합. 야채-야채2={'당근', '시금치', '양상추'}
전부=len(i)+len(u)+len(d) //길이는 10
print(total)
정답:
10
a=[1,2,3]
b=a
c=a[:] //전체 슬라이싱. 복사개념.
print(a is b) //같은 리스트를 가리키니?
print(a == c) //값이 같니?
print(a is c) //c가 a를 복사했음. 복사한 경우는 다른 객체.
정답:
True
True
False
문자열 슬라이싱
| a | b | c | d | e | f | g | h | i | j |
| [0] | |||||||||
| -5 | -4 | -3 | -2 | -1 |
| k | l | m | n | o | p | q | r | s | t |
| [0] | [1] | [2] | [3] | [4] | [5] |
| u | v | w | x | y | z | a | b | c | d |
| [0] | [1] | [2] | [3] | [4] | [5] | [6] | [7] | [8] | [9] |
str1[-5:] //-5부터 시작해서 끝까지.-1까지. fghij
str2[:5] // 0부터 시작해서 4까지. klmno
str3[2:7] // 2부터 시작해서 6까지. wxyza
람다 람다 다람쥐~~ 익명함수. 이름없는 함수. 람다함수.
add=lambda x, y: x+y
mul=lambda x, y: x*y
def calc(func, x, y)
결과=func(x,y)
print(f"Result: {결과}")
num1=5
num2=3
calc(add, num1, num2)
calc(mul, num1, num2)
정답:
Result: 8
Result: 15
def 함수(lst):
first=lst[0]
count=0
for문 i in range(1, len(lst)): //1에서 4까지.
count= count+lst[i].count(first) // lst[i]안에 first가 총 몇 번 나오는지?
return count
| 0+lst[1].count(first) | 사과 파이. count(사과) |
| 1+lst[2].count(사과) | 사과 주스. count(사과) |
| 2+lst[3].count(사과) | |
| 2+lst[4].count(사과) | |
| 3 |
lst=["사과", "사과 파이", "사과 주스", "바나나", "사과 타르트"]
결과=함수(lst)
횟수: 결과
정답:
횟수: 3
def 내(lst):
결과=0
for문 i in range(len(lst)) //길이는 5. 0부터 4까지.
if문 lst[i] %2==0
참이면 결과=결과+lst[i]//2 //목 정수값만 취한다. 소숫점은 버린다!!!!
else
결과= 결과+lst[i]*2
return 결과
| i=0 | 3 %2==0 거짓 | 0+6=6 |
| i=1 | 6 %2==0 참 | 6+3=9 |
| 2 | 8 %2==0 참 | 9+4=13 |
| 3 | 5 %2==0 거짓 | 13+10=23 |
| 4 | 10 %2==0 참 | 23+5=28 |
넘버=[3,6,8,5,10]
| 3 | 6 | 8 | 5 | 10 |
| [0] | [1] | [2] | [3] | [4] |
print(내(넘버)) //함수 호출.
정답:
28
결과 = 7/2 #정답은 3.5
결과= 7//2 #정답은 3
def 콘(lst):
결과=" " //빈 문자열.
for문 i in lst:
if문 type(i)==str //스트링 str. 문자열을 뜻함.
결과=결과+i+"-"
else
결과= 결과+str(i) //문자로 바꿔줘.
return 결과[:-1] //처음부터 -1 전까지 출력. 마지막 - 제거하기 위함.
데이터=["사과", 3, "바나나", 7, "수박"] //문자열과 숫자가 섞임.
print(콘(데이터)) //함수 호출.
정답:
사과-3바나나-7수박
파이썬 built in function
빌트인 함수
def 맥스(arr):
return max(arr)-min(arr) //맥시멈 최댓값, 미니멈 최솟값.
arr=[17,29,4,13,5]
print(맥스(arr)) #함수호출.
#29-4=25
정답:
25
튜플. 값을 재할당 하지 않는다. (set은 {}, 튜플은 ())
def 파(arr):
for문 i in range(len(arr)): #길이는 5. 0부터 4까지.
for문 j in range(i+1, len(arr)):
if문 arr[i]+arr[j]==10:
return(i,j) //(값, 값)은 튜플형태를 나타냄.
return-1 //위에서 리턴이 되는 순간. 파(arr)함수는 끝나버리는 것임. 리턴되면 여기까지 실행이 안 됨.
| i | j | arr[i]+arr[j]==10 | (i,j) |
| 0 | range(1,5) | 2+5=7 2+7=9 2+3=5 2+8=10 참 |
(0, 4) //리턴하는 순간 함수는 끝나게 된다. 더이상 아래 안해도 됨. |
| 1 | range(2,5) | 5+7 5+3 5+8 |
|
| 2 | range(3,5) | 7+3=10 참 | (2,3) |
| 3 | range(4,5) | 3+8 | |
| 4 | range(5,5) | 8+8 |
arr=[2,5,7,3,8]
print(파(arr)) //반환 값이 튜플 형태로 오게됨.
정답:
(0,4)
<<틀리기 쉬운 문제>>
isinstance 함수. 이즈인스턴스
def 과정(data):
결과="" #빈 문자열
if문 isinstance (item, int):
결과=결과+str(item*2)
| ""+str(6)=6 |
| 6olleh314 |
elif isinstance (item, str):
결과=결과+item[::-1]
| 6olleh |
| 6olleh3dlrow |
elif isinstance (item, list):
결과=결과+str(len(item))
| 6olleh3 |
| 6olleh3dlrow2 |
return 결과
data=[3, "hello", [1,2,3], 7, "world", [4,5]]
| h | e | l | l | 0 | \n |
| [-5] | [-4] | [-3] | [-2] | [-1] |
과정(data) #함수 호출.
정답:
6olleh3dlrow2
리스트 스텝 (step)
def 팔(s)
s=s.lower().replace(" " , "")
#전체를 소문자로 만들어라. 앞에있는 문자를 뒤에있는 문자로 대체하라. (띄어쓰기 없애라는말) # asantaatnasa
return s == s[::-1] #슬라이싱. [처음:끝:스텝] 처음부터 끝까지 뒤에서부터 하나하나 적어라=거꾸로 적어라. #asantaatnasa
s="A Santa at NASA"
프린트(팔(s)) #팔 함수 호출.
정답:
True
<<틀리기 쉬운 문제>>
set과 list 조합문제. set은 중복 허용 안해.
def 팔(arr)
seen=set() #객체를 만든다는 뜻. 빈 set 형태의 데이터를 넣는다.
duplicates=set()
for문 num in arr
if문 num in seen #num(처음은 리스트1)이 seen이라는 곳에 있나요? 없음. false.
duplicates.add(num) #참이면,,duplicate에 num을 넣어라.
seen.add(num) #거짓이면,, seen에 num을 넣어라.
return list(dupicates) #리스트 형태로 반환해요.
| seen={1} |
| seen={1,3} |
| seen={1,3,5} |
| seen={1,3,5,2} |
| duplicates={3} |
| seen={1,3,5,2,8} |
| duplicates={3,5} |
arr=[1,3,5,2,3,8,5] #리스트.
프린트(팔(arr))
정답:
[3, 5]
def 판(arr)
arr.sort() #솔트. 작은것~큰것 순서로 정렬하라. [3,4,7,12,19]
return arr[len(arr)//2] #5//2=2 #arr[2]=7
arr=[12,3,5,7,19]
프린트(판(arr)) #함수 호출.
프린트(12/5)
정답:
7
2.4
<<틀리기 쉬운 문제>> dic 형태 {}형태. 재귀함수. 사전은 키와 값으로 구성됨.
def 알(d) # d={"n":4, "memo":{}}
n=d["n"] #d=사전. 사전 안에 "n"에 접근한다는 말. n의 값은 4.
memo=d["memo"]
if문 n in memo
참이면 return memo[n]
if문 n<=1 #탈출조건. n이 1보다 같거나 작으면 1을 반환한다.
참이면 return 1
결과=알({"n":n-3, "memo":memo}) + 알({"n":n-1, "memo":memo}) #재귀함수 형태인걸 알수 있음.
memo[n]=결과
return 결과
| 알 ({"n":4, "memo":{}}) | memo[4]=4 memo={2:2, 3:3, 4:4} |
||
| {"n":n-3, "memo":memo} | {"n":n-1, "memo":memo} | ||
| {"n":1, "memo":memo} 1반환 |
{"n":3, "memo":memo} | memo[3]=3 memo={2:2, 3:3} |
|
| {"n":0, "memo":memo} 1반환 |
{"n":2, "memo":memo} | memo[n]=결과 memo[2]=2 memo={2:2} 2가 키고 2가 값. |
|
| {"n":-1, "memo":memo} 1반환 |
{"n":1, "memo":memo} 1반환 |
num=4
memo사전={"n":num, "memo":{}} # {"n":4, "memo":{}} #{ } 빈 중괄호는 dict(사전) 형태임.
프린트(f"결과: {알(memo사전)}, {memo사전['memo']}") #알 ({"n":4, "memo":{}}) 함수 호출.
# memo사전['memo'] 는 memo사전 안에 있는 'memo'의 값에 접근한 것임.
정답:
결과: 4, {2:2, 3:3, 4:4}
'정보처리기사 필답 실기. 코딩 문제.' 카테고리의 다른 글
| 삽입정렬 (0) | 2025.05.23 |
|---|---|
| c언어 짚고가기 (0) | 2025.05.19 |
| 자바 코드 문제 (1) | 2025.05.18 |
| c언어 코드문제 (0) | 2025.05.18 |
| 정처기 24년 3회 코드 기출문제 (0) | 2025.05.15 |
댓글