1. 첫 번째 코드 (정답 코드)

#괄호 균형 판단 프로그램
#(), []

while(True):
    tf=0
    line = input()
    small=0#괄호가 열리면 +1, 닫히면 -1
    large=0
    #<괄호의 균형을 맞춰야하는 문제 해결 방법>
        #문이 열릴 때마다,색을 칠해준다.
        #닫을 때 칠해진 색과 닫을 색이 일치하지 않으면 break
        #일치하면 그 색을 뽑아버린다.
    color=[]
    if len(line)==1 and line[-1]=='.':#.이 들어오면 정지
        break

    else:
        for i in line:
            if i == '(':
                small+=1
                color.append('small')
            elif i==')':
                small-=1
                if small <0: #한 번이라도 이런 경우가 생기면 에러처리를 위해 tf=-1로 변경.
                    tf=-1
                    break
                if color[-1] !='small':
                    tf=-1
                    break
                else:
                    color.pop()
            elif i=='[':
                large+=1
                color.append('large')
            elif i==']':
                large-=1
                if large <0:
                    tf=-1
                    break
                if color[-1] !='large':
                    tf=-1
                    break
                else:
                    color.pop()

    if small == 0 and large == 0 and tf==0:
        print('yes')
    else:
        print('no')

#마지막에 .을 넣어도 끝나지 않음
    #=> while문 안의 for문이 아니라, for문 시작 전에 if break문을 넣어줬음.

 

2. 정리한 코드(정답 코드)

위의 코드가 조금 지저분한 것 같아서 정리 필요.

while(True):
    tf=0 #오답이 확정일 때 -1로 구분지어주는 역할.
    
    line = input() #입력 받기

    #<괄호의 균형을 맞춰야하는 문제 해결 방법>
        #가장 최근에 열린 괄호가, 자신의 짝과 일치하는지 확인한다.
            #일치하지 않으면 break
            #일치하면 그 색을 뽑아버린다.
    stack=[]
    
    if len(line)==1 and line[-1]=='.':#.이 들어오면 정지
        break

    else:
        for i in line:
            if i == '(' or i=='[':
                stack.append(i)
            elif i==')':
                if len(stack)==0 or stack[-1] !='(':
                    tf=-1
                    break
                else:
                    stack.pop()
            elif i==']':
                if len(stack)==0 or stack[-1] !='[':
                    tf=-1
                    break
                else:
                    stack.pop()

    if len(stack)==0 and tf!=-1:
        print('yes')
    else:
        print('no')

 

3. 최종 코드 : import sys 입력만 더 효율적으로

import sys
input=sys.stdin.readline
#readline은 공백도 받으므로, rstrip()로 공백 제거.
while(True):
    tf=0 #오답이 확정일 때 -1로 구분지어주는 역할.
    
    line = input().rstrip() #입력 받기

    #<괄호의 균형을 맞춰야하는 문제 해결 방법>
        #가장 최근에 열린 괄호가, 자신의 짝과 일치하는지 확인한다.
            #일치하지 않으면 break
            #일치하면 그 색을 뽑아버린다.
    stack=[]
    
    if len(line)==1 and line[-1]=='.':#.이 들어오면 정지
        break

    else:
        for i in line:
            if i == '(' or i=='[':
                stack.append(i)
            elif i==')':
                if len(stack)==0 or stack[-1] !='(':
                    tf=-1
                    break
                else:
                    stack.pop()
            elif i==']':
                if len(stack)==0 or stack[-1] !='[':
                    tf=-1
                    break
                else:
                    stack.pop()

    if len(stack)==0 and tf!=-1:
        print('yes')
    else:
        print('no')

이때 readline은 공백도 받으므로, rstrip()로 공백을 제거해줘야한다.

1. 시간 초과 코드

첫 번째로 풀었을 때 시간 초과  코드. 시간 초과 될 것은 알았지만, 일단 써보자라고 생각하고 작성했다. 역시나 시간 초과.

import sys
input=sys.stdin.readline

m, n = map(int, input().split())

for i in range(m, n+1):
    cnt=False #합성수 수
    for j in range(2, 1000001):
        if i % j ==0 and i !=j:
            cnt=True
    if cnt == False:
        print(i)

에라토스테네스의 체를 활용하여 경우의 수를 확 줄여서 문제를 푸는 것이었다.

결국 1~100 사이의 소수를 찾는다면, 루트 100 = 10 까지만 나눠서 확인해보면(2~10의 배수가 아닌 것이 확인되면)

소수라는 것을 확신할 수 있다는 뜻이다. 2의 배수, 3의 배수, 4의 배수 ... 차례로 모두 제거한다고 생각해보면, 10의 배수까지만 제거할 수 있다. 11*1~11*10까지는 이미 1~10의 배수에서 걸러졌고, 다음 11*11 부터는 해당 범위를 초과해서 볼 필요도 없다.

[에라토스테네스의 체 내용 참고]

https://namu.wiki/w/%EC%97%90%EB%9D%BC%ED%86%A0%EC%8A%A4%ED%85%8C%EB%84%A4%EC%8A%A4%EC%9D%98%20%EC%B2%B4

 

코드는 다음과 같다.

import sys
input=sys.stdin.readline
m, n = map(int, input().split())

for i in range(m, n+1):
	if i == 1: #1제거
    	continue
    for j in range(2, int(i**0.5) + 1): # 해당 수의 제곱근까지만 확인해주면 됨.
    	if i % j == 0: #나누어지면 멈추고,
        	break
    else:
    	print(i) #나누어지지 않으면 출력한다.

 

오랜 시간의 고민 끝에, k층의 n호는, k-1층의 1호부터 n호까지의 합만큼의 인원이 산다는 것을 파악하였다.

그래서 재귀함수로 아래와 같은 코드를 짰는데, 시간 초과가 떴다.

 

1.재귀함수 이용

1) 1층과 2층 요소 출력을 위한 sigma 구현 공부

처음에 이 함수를 짜기 위해서, python 내에서 sigma를 정의하는 방법을 공부했다.

###sigma k : 1층의 n호 요소 출력하기

def sigma(n):
	result=0
    for k in range(1, n+1): #1부터 n까지
    	result +=k #1부터 n까지를 계속 더한다. 1+2+3+...+n
    return result

print(sigma(3)) #1층의 3호 요소 출력하기 : 1+2+3

###sigma k(k+1)/2 : 2층의 n호 요소 출력하기

def sigma2(n):
	result=0
    for i in range(1, n+1): #1부터 n까지
    	result += sigma(i)
    return result

print(sigma2(3)) #2층의 3호 요소 출력하기 : sigma(1)+ sigma(2) + sigma(3)

이렇게 계속 정의해 나가면 되겠지만, 입력 범위가 넓기 때문에 이렇게 계속 만드는 것은 불가능하다.

따라서 재귀함수로 만들어보고자 하여 아래와 같은 코드를 완성했다.

 

2) 재귀 함수 코드

import sys

input=sys.stdin.readline

T=int(input())
for _ in range(T):
    k=int(input()) #k층. 단계. sigma 횟수. 0층이 요소. 1층=1번 시그마, 2층=2번 시그마
    n=int(input()) #n호. 해당 시그마에서 n번까지 더해야함.
    
    def sigma_depth(k, n):
        if k==1: #초항 정의
            result=0
            for i in range(1, n+1): #i부터 n까지
                result +=i #다 더한다.1+2+...+n
            # print(k,'일 때 result=',result)
            return result
        else:
            result=0
            for i in range(1, n+1): #1부터 n까지
                result += sigma_depth(k-1, i) #아래층의 i까지의 합을 다 더한 것.
                # print(k,'일 때',i,'번째')
            # print(k,'일 때 result=',result)
            return result
            
	print(sigma_depth(k, n))

위 코드는 아래와 같은 원리로 정답이다.

그런데, 예시 1번에서는 계산이 얼마 되지 않아서 괜찮지만, 예시 2번부터는 굉장히 많은 계산이 이루어진다. 심지어 이미 계산했던 것들도 반복해서 계산해야하는 비효율적인 계산이 이루어진다.

=> 이를 행렬에 저장해놓고 인덱스로 가져다가 쓰는 방법으로 해결할 수 있을까 싶다. 인덱스의 시간 복잡도가 O(1)인 것을 확인하였다.

하지만 생각보다 복잡하다.

 

2. 간단한 점화식을 활용하여 계산하기

그래서 차분하게 써놓고 생각해보니

 matrix[k][n]=matrix[k-1][n]+matrix[k][n-1]과 같다.

그런데 결국 마지막 값만 출력하면 되기 때문에, 모든 층의 값들을 저장해둘 필요가 없다.

쉽게 생각하면 [바로 앞 호수 + 아래 층의 같은 호수]이기 때문에, 한 층을 한 호수씩 업데이트 해나간다고 생각하면 아래와 같이 코드를 간결하게 짤 수 있다.

 

import sys
input=sys.stdin.readline

t=int(input())

for _ in range(t):
	floor = int(input()) #층수
    num = int(input()) #호수
    f0 = [x for x in range(1, num+1): #0층 리스트. 1~n호까지
    for k in range(floor): #층 수 만큼 반복
    	for i in range(1, num): #1~n-1까지
        	f0[i] +=f0[i-1]
    print(f0[-1])

정답만 출력해내면 된다는 것을 기억하자.

 

 

 

 

풀 수 있는 방법은 여러가지다.

1. factorial을 직접 재귀함수로 만들어서 계산

2. import math as m 로 m.factorial(n)을 활용하여 계산

3. 인수 중 2와 5의 개수를 찾아내서 계산

4. 단순히 5의 개수를 찾아내서 계산(입력 값의 범위가 적기 때문에 가능)

 

- 전체적으로 pypy3가 아닌, python3로 제출해야 메모리초과가 뜨지 않는다는 것을 알 수 있었다.

: pypy3가 메모리를 정말 많이 잡아먹는구나! 이 둘의 차이점을 조금 더 공부해야할 것 같다.

- 인덱싱에서 뒤에서부터 숫자를 비교할 때, for문의 range를 -1를 걸어서 거꾸로 찾는게 아니라, 그냥 -i로 소환해버리는 마이너스 인덱싱 방법을 배웠다.

1. factorial을 직접 재귀함수로 만들어서 계산
import sys

sys.setrecursionlimit(10**6)
input=sys.stdin.readline

n=int(input())

def factorial(x):
    if x == 0 or x == 1:
        result = 1
        return result
    elif x > 0:
        result = x * factorial(x-1)
        return result
    else:
        print('프로그램을 다시 실행해주세요')
        
sep_n=list(str(factorial(n))) #n! 계산값을 문자열로 바꾸어서 리스트로 넣는다.

cnt=0

for i in range(1, len(sep_n)+1):
    if sep_n[-i]=='0': #-1부터 ~-길이 만큼, 뒤에서부터 0이 있으면 개수 카운트
        cnt+=1
    else:
        break
        
print(cnt)

 

2. import math as m 로 m.factorial(n)을 활용하여 계산

위의 코드보다 길이가 짧아지는 것을 알 수 있다.

import sys
import math as m

sys.setrecursionlimit(10**6)
input=sys.stdin.readline

n=int(input())
sep_n = list(str(m.factorial(n)))

cnt=0

for i in range(1, len(sep_n)+1):
    if sep_n[-i]=='0': #-1부터 ~-길이 만큼, 뒤에서부터 0이 있으면 개수 카운트
        cnt+=1
    else:
        break
        
print(cnt)

 

3. 인수 중 2와 5의 개수를 찾아내서 계산
import sys
import math as m

sys.setrecursionlimit(10**6)
input=sys.stdin.readline

n=int(input())

N1=m.factorial(n)
N2=m.factorial(n)

cnt=0
while(N1>=5):
    if N1 % 5 == 0 :
        N1=N1//5
        cnt+=1
    else:
        break

cnt2=0
while(N2>=2):
    if N2 % 2 == 0:
        N2=N2//2
        cnt2+=1
    else:
        break

print(min(cnt,cnt2))

 

4. 단순히 5의 개수를 찾아내서 계산(입력 값의 범위가 적기 때문에 가능)
#5의 개수를 찾으면 된다. 0이 늘어나는 순간은 10이 곱해지는 순간이기 때문.
#해당 범위 내에서는 5가 생기는 순간에서 2의 개수는 당연히 5의 개수보다 많기 때문에 이렇게 되는 듯.
N=int(input())
print(N//5 + N//25 + N//125)

1. 버전 업그레이드

n, nvm으로 올리면

node로 명령어를 실행했을 경우와

/user/local/bin/node 간의 명령어가 꼬이는 경우가 발생할 수 있다고 한다. 이 경우 EACCES가 발생할 수 있다.

*EACCES : npm install 시 permission denied 발생 가능

 

따라서 기존의 모든 node를 지우고, curl로 node를 직접 받는 것이 낫다.

#node 설치 장소 확인
whereis node

# node 관련 모든 경로 삭제
rm -rf /usr/bin/node


#윈도우 명령어
sudo apt-get remove nodejs
sudo apt-get remove npm

mac 이면 위에 2개 입력하고, 홈페이지가서 직접 설치하면 됨.

https://nodejs.org/download/release/v18.17.1/

 

Index of /download/release/v18.17.1/

 

nodejs.org

apt-get: command not found 오류뜨면 아래방식으로

#윈도우
sudo yum remove <package이름>

 

https://ondemand.tistory.com/176

mac os에서는 apt-get이나 yum이 없다. 이것의 대체가 homevrew.

 

참고한 블로그. 상세하게 나와있는데 아직 모르는 내용이 많다. 차근히 공부해보자.

https://velog.io/@djunnni/Node.js-12%EC%97%90%EC%84%9C-16%EB%A1%9C-%ED%95%9C%EB%B2%88%EC%97%90-%EC%97%85%EB%8D%B0%EC%9D%B4%ED%8A%B8-%EC%A0%81%EC%9A%A9%ED%9B%84%EA%B8%B0-%ED%99%98%EA%B2%BD-%EC%84%B8%ED%8C%85%ED%8E%B8\

N=int(input())
char_list = list(input())
num_list=list(map(int, char_list))
print(sum(num_list))

Q. N개의 숫자가 공백 없이 쓰여있다. 이 숫자를 모두 합해서 출력하는 프로그램을 작성하시오.
- 입력 : 첫째 줄에 숫자의 개수 N (1 ≤ N ≤ 100)이 주어진다. 둘째 줄에 숫자 N개가 공백없이 주어진다.
- 출력 : 입력으로 주어진 숫자 N개의 합을 출력한다.

1. 첫 시도 - 오류, split() 함수

split() 함수는 문자열을 괄호 안에 넣은 값을 기준으로 쪼개주기 때문에, 나는 당연히 연결된 문자열을 쪼개기 위해서 split('')을 사용하였다.

N=int(input())
num_list=list(map(int, input().split('')))
print(sum(num_list))

위와 같이 코드를 작성하고, 원하는 대로 실행되기를 바랬으나
empty separator
와 같은 오류가 발생했다. 찾아보니, 파이썬 내장함수 split()은 연속된 글자를 쪼개는 기능을 제공하지 않는다. 

왜 그런가 잠시 이유를 생각해봤는데, 단순히

list(문자열)

방법만으로도 원하는 결과를 얻을 수 있기 때문에, 굳이 제공하지 않는 것 같다. 그리고 사용자가 실제로 원하는 값이 맞는지 확인하기 어렵기도 하고, 그래서가 아닐까 에측해본다.

 *참고로 split은 축약형부터 완성형까지 다음과 같이 사용된다.

문자열.split()

문자열.split('구분자')

문자열.split('구분자', 분할횟수)

문자열.split(sep='구분자', maxsplit=분할횟수)

궁금해서 마지막 완성 형태로도 작성해봤는데, 역시 연속된 문자열은 제공하지 않는다.

 

2. 두 번째 시도 - 오류, list 내의 모든 요소들의 자료형 변환 시도
N=int(input())
char_list = list(input())
num_list=int(char_list)
print(sum(num_list))

혹시 int(리스트명)의 방식으로, 리스트 내의 모든 문자열 요소들을 int로 바꿀 수 있는지 시도해봤다.

하지만 다음과 같은 오류가 떴으며, list에 대해서는 이와 같은 type 변경을 제공하지 않는다.

int() argument must be a string, a bytes-like object or a number, not 'list'
*list의 type변경 방법
list_int= list(map(int, list_str)) # 정수로 변환
list_str = list(map(str, list_int)) # 문자열로 변환
기존에 사용하던 map() 함수를 사용하면 된다. 

왜 map()을 사용해도 되는거지?하고 부족한 map() 함수의 개념을 채워봤다.

*map() 함수
map(함수, 반복 가능한 자료형)
- 반복 가능한 자료형 : 리스트, 튜플 형태
- 함수 : 리스트 혹은 튜플의 각 요소들을 꺼내서, 함수를 적용시키고, map요소 형태로 반환한다.
*map요소 형태로 반환하기 때문에, 리스트로 만들고 싶다면 다시 list()로 감싸줘야한다.

그렇군! 그동안 map() 함수를 왜 사용하는지 모르고 사용했었는데, 이번에 확실히 알게됐다.

그러면 이제 코드를 완성시켜보자.

 

3. 세 번째 시도
원리 이해를 위해 풀어본 코드
char_list = list(input())
print(char_list)
num_list=list(map(int, char_list))
print(num_list)
print(sum(num_list))​

 

실행 결과는 다음과 같이 나온다.
5
12345
['1', '2', '3', '4', '5']
[1, 2, 3, 4, 5]
15​
답안
N=int(input())
char_list = list(input())
num_list=list(map(int, char_list))
print(sum(num_list))​

사실 이렇게 작성했을 때, N이 필요가 없다. 근데 대부분의 답안 사이트는 N을 무시하기 때문에 우선은 납둔다.

나중에는 N의 개수와 ,len(num_list)가 맞지 않으면, 다시 입력하라는 방식으로 N을 적용시킬 수 있을 것 같다.

문제 자체는 가볍지만 무언가 많이 배웠다 ㅎㅎ

글 작성하는게 목적이 아니라, 공부하는게 목적이기 때문에 틀린 내용을 발견한다면 언제든 댓글 부탁드린다.

오늘도 파이팅

Q. 문제

상근이는 매일 아침 알람을 듣고 일어난다. 알람을 듣고 바로 일어나면 다행이겠지만, 항상 조금만 더 자려는 마음 때문에 매일 학교를 지각하고 있다.

상근이는 모든 방법을 동원해보았지만, 조금만 더 자려는 마음은 그 어떤 것도 없앨 수가 없었다.

이런 상근이를 불쌍하게 보던 창영이는 자신이 사용하는 방법을 추천해 주었다.

바로 "45분 일찍 알람 설정하기"이다.

이 방법은 단순하다. 원래 설정되어 있는 알람을 45분 앞서는 시간으로 바꾸는 것이다. 어차피 알람 소리를 들으면, 알람을 끄고 조금 더 잘 것이기 때문이다. 이 방법을 사용하면, 매일 아침 더 잤다는 기분을 느낄 수 있고, 학교도 지각하지 않게 된다.

현재 상근이가 설정한 알람 시각이 주어졌을 때, 창영이의 방법을 사용한다면, 이를 언제로 고쳐야 하는지 구하는 프로그램을 작성하시오.

 

예제 입력 

0 30

예제 출력

23 45

 

새롭게 정리한 사실

1.문자열.split( )

사용했을 때, 자동으로 list 안에 값들을 담아준다. 문자열만 쪼갤 수 있다.

input_time=int(input())
hour=input_time.split(' ')[0]

바보 같이 이렇게 실행했다가 오류났는데, int안에 있는 여백은 쪼갤 수 없어 ..!

 

2. python 내장 map() 함수

- 사용하는 때 : 공백으로 구분된 여러가지 값을 입력 받고, list에 담아서 차례대로 인덱싱을 활용해 변수들에 매칭해줄 때. 게다가 type을 변환해줄 때

items = input().split(' ')
#사용자가 '255 255 255 255'를 입력했을 때
item1 = int(items[0])
item2 = int(items[1])
item3 = int(items[2])
item4 = int(items[3])

이렇게 하지 않고, 입력값을 바로 변환하여 list에 담거나

 

a=list(map(자료형, input().split(' ')))

print(a)

#[1, 2, 3, 4, 5]

 

각각의 단어에 매칭시켜줄 수 있다.

a, b, c, d, e = map(int, input().split(' '))

#사용자가 1 2 3 4 5 입력하면

print(a)
#결과 : 숫자 1

 

따라서 이번 문제의 코드도

input_time=input().split()
hour=int(input_time[0])
min=int(input_time.split[1])

이렇게 세 줄의 코드를, 다음과 같이 1 줄로 만들어줄 수 있었다.

H, M=map(int, input().split(' '))

 

최종 결과 코드

H, M=map(int, input().split(' '))

sum_M=H*60+M-45

new_H=sum_M//60
if (new_H < 0):
    new_H= 24+new_H
new_M=sum_M%60

print(new_H)
print(new_M)

Q. 첫 줄에는 정수 x가 주어진다. (−1000 ≤ x ≤ 1000; x ≠ 0), 다음 줄에는 정수 y가 주어진다. (−1000 ≤ y ≤ 1000; y ≠ 0)

 

일단 처음 작성한 코드

x와 y의 범위를 모두 고려하여 작성하였다. 0이 되면 안된다는 조건이 있기 때문에 조금 지저분하게 범위가 작성되었다.

input_x=int(input())
input_y=int(input())

if (input_x>0 and input_x<=1000):
    if(input_y>0 and input_y<=1000):
        print(1)
    elif(input_y>=-1000 and input_y<0):
        print(4)
elif(input_x>=-1000 and input_y<0):
    if(input_y>0 and input_y<=1000):
        print(2)
    elif(input_y>=-1000 and input_y<0):
        print(3)

처음에 작성했을 때,

또 함수도 없는데 return 쓰고 있어서 진짜 바보인가 싶었다.

그래도 이제는 안틀릴 것 같다.

 

다른 사람들의 코드를 참고해서 공부해보고 온 결과 ...

문제에서 x와 y는 -1000와 1000사이지만 0은 아닌 수라는 조건을 줬는데, 이런 숫자 조건들은 다 무시하는지 모르겠다.

알아봐야겠다.

 

 

어쨌든 최대한 간결하게 다시 작성해보면,

x=int(input())
y=int(input())

if (x>0 and y>0):
    print(1)
elif (x<0 and y>0):
    print(2)
elif (x<0 and y<0):
    print(3)
else :
    print(4)

 

참고로, x=int(input())과 같은 식으로 작성하면, 문자를 작성했을 때 오류가 뜬다고 한다. 우리가 관리할 때 편한 것 뿐만 아니라, 입력 받는 자료형까지 지정해버리는 것이었다.

이 문제는 어떤 언어를 공부하던지 간에, 항상 나오는 것 같다.

분명 옛날 옛적, 한국에 코딩 교육이 들어온지 얼마 안됐을 때 만들어졌고

지금까지도 활용되는 문제인 것이 분명하다.

'제발 그만 좀 나와!' 가 아니고, 나와도 이제는 아무렇지 않게 풀 수 있을 수 있도록 문제를 완전히 풀어버리겠다.

Q. 연도가 주어졌을 때, 윤년이면 1, 아니면 0을 출력하는 프로그램을 작성하시오.
조건) 윤년은 연도가 4의 배수이면서, 100의 배수가 아닐 때 또는 400의 배수일 때이다.

예를 들어, 2012년은 4의 배수이면서 100의 배수가 아니라서 윤년이다.
1900년은 100의 배수이고 400의 배수는 아니기 때문에 윤년이 아니다.
하지만, 2000년은 400의 배수이기 때문에 윤년이다.

입력) 첫째 줄에 연도가 주어진다. 연도는 1보다 크거나 같고, 4000보다 작거나 같은 자연수이다.

*윤년 : 2월 29일이 존재하는 달

 

1. 코드 작성

input_year=int(input())
if (input_year%4==0 and input_year%100!=0 or input_year%400==0):
  return 1
else :
  return 0

계속 'return' outside function 오류가 난다.

 

으악 함수가 없는데 무슨 return이야... 조건문에서는 return을 쓰지 않아...

return은 함수에서만 사용 된다.

 

수정해보자.

 

input_year=int(input())
if (input_year%4==0 and input_year%100!=0) or (input_year%400==0):
  print(1)
else :
  print(0)

맞았다! 연산자를 사용할 때 괄호로 적절히 순서를 구분하는 것 잊지 말자.

 

바보 같은 실수와 함께 교훈도 얻었고,

코드도 짧게 잘썼다는 칭찬을 하게 된 문제.

 

2. python 에서의 나누기 관련 연산자

/ 기본 float형 나눗셈
// 몫
% 나머지
a, b = divmod(c, d) : 몫과 나머지를 튜플 형식으로 가지고 옴

🐸  코딩혜영의 소소한 이야기

요즘 백준 문제를 풀기 시작했다.

정말 부담 가지지 않고, 생각날 때 마다 몇 문제 씩 풀고 있다.

 

난이도 별로 나열해서 기초부터 풀고 있는데,

관련된 지식까지 복습하면서 가기에는 꽤 유용하다.


❓ 백준 9498 python : 시험성적

시험 점수를 입력받아 90 ~ 100점은 A, 80 ~ 89점은 B, 70 ~ 79점은 C, 60 ~ 69점은 D, 나머지 점수는 F를 출력하는 프로그램을 작성하시오.


🚀  본격 문제 풀이

내가 처음 작성했던 코드는 다음과 같다.

input_score=int(input())

if (input_score>=90 and input_score<=100):
    print('A')
elif (input_score>=80 and input_score<=89):
    print('B')
elif (input_score>=70 and input_score<=79):
    print('C')
elif (input_score>=60 and input_score<=69):
    print('D')
else :
    print('F')

 쓰면서도 상당히 비효율적임을 느꼈다. 문제 그대로 범위를 설정해줬는데, 어차피 if문은 순차적으로 넘어가면서 읽히기 때문에 이렇게 작성할 필요가 없다.

input_score=int(input())

if (input_score>=90) :
    print('A')
elif (input_score>=80):
    print('B')
elif (input_score>=70):
    print('C')
elif (input_score>=60):
    print('D')
else :
    print('F')

문제가 더욱더 복잡해졌을 때, 이와 같은 실수를 반복하지 말아야겠다는 생각이 들었다.

 

또한 더 좋은 코드를 찾다가,

삼항표현식 이라는 개념을 공부하게 되었다.

 

➕개념) 삼항표현식

true_value if 조건식 else false_value

조건식이면 true_value

조건식거짓이면 false_value를 반환한다.

 

- 잘 사용하면 if-else 조건식보다 더 깔끔하게 표현할 수 있다.

- 한 줄로 코드 작성 가능

#삼항표현식
value = true_value if condition else false_value

#if-else 조건식
if condition:
	value = true_value
else:
	value=false_value

 

이 문제도 삼항표현식으로 풀 수 있다.

input_score=int(input())
print('A') if input_score>=90 else print('B') if input_score>=80 else print('C') if input_score>=70 else print('D') if input_score>=60 else print('F')

볼 때는 굉장히 복잡해보이지만, 실제로 작성할 때는 오히려 편하다. 하지만 가독성은 확실히 떨어지는 것 같다.

 

+관련지식1) 삼항연산자

조건식 ? true_value : false_value

 

+관련지식2) 중첩 삼항 표현식

true_value if 조건식 else 삼항표현식삽입

false_value 자리에 삼항표현식을 n번 삽입해서 중첩에 중첩을 시킬 수 있다.

+ Recent posts