6092. 정보 선생님은 수업을 시작하기 전에 이상한 출석을 부른다.

선생님은 출석부를 보고 번호를 부르는데,
학생들의 얼굴과 이름을 빨리 익히기 위해 번호를 무작위(랜덤)으로 부른다.

그리고 얼굴과 이름이 잘 기억되지 않는 학생들은 번호를 여러 번 불러
이름과 얼굴을 빨리 익히려고 하는 것이다.

출석 번호를 n번 무작위로 불렀을 때, 각 번호(1 ~ 23)가 불린 횟수를 각각 출력해보자.

예시
n = int(input())      #개수를 입력받아 n에 정수로 저장
a = input().split()  #공백을 기준으로 잘라 a에 순서대로 저장

for i in range(n) :  #0부터 n-1까지...
  a[i] = int(a[i])       #a에 순서대로 저장되어있는 각 값을 정수로 변환해 다시 저장

d = []                     #d라는 이름의 빈 리스트 [ ] 변수를 만듦. 대괄호 기호 [  ] 를 사용한다.
for i in range(24) :  #[0, 0, 0, ... , 0, 0, 0] 과 같이 24개의 정수 값 0을 추가해 넣음
  d.append(0)        #각 값은 d[0], d[1], d[2], ... , d[22], d[23] 으로 값을 읽고 저장할 수 있음.

for i in range(n) :    #번호를 부를 때마다, 그 번호에 대한 카운트 1씩 증가
  d[a[i]] += 1

for i in range(1, 24) :  #카운트한 값을 공백을 두고 출력
  print(d[i], end=' ')

 

참고
- d = []              #어떤 데이터 목록(list) 을 순서대로 저장하기 위해 아무것도 없는 리스트 변수 만들기
- d.append(값)  #d 리스트의 마지막에 원하는 값을 추가(append)해 넣음 
- d[a[i]] += 1     #2중 리스트 참조 : 만약 a[i]의 값이 1이었다면? d[1] += 1 이 실행되는 것이다. 1번 카운트 1개 증가..

어떤 값을 기록했다가 다시 사용할 필요가 있을 때, 필요한 변수(variable)를 만들어 사용하는 것처럼,
여러 개의 값을 하나로 묶어 목록으로 기록했다가 다시 사용할 필요가 있을 때, 리스트(list)를 만들어 사용할 수 있다.
리스트는 변수들을 모아 놓은 변수라고 생각할 수도 있고, 참조번호를 이용해 간단하고 편리하게 사용할 수 있다.

n = int(input())
a = input().split()

for i in range(n):
  a[i] = int(a[i])

d = []
for i in range(24):
  d.append(0)

for i in range(n):
  d[a[i]] += 1

for i in range(1, 24):
  print(d[i], end = ' ')

 

6093. 정보 선생님은 수업을 시작하기 전에 이상한 출석을 부른다.

학생들의 얼굴과 이름을 빨리 익히기 위해 번호를 무작위(랜덤)으로 부르는데,
영일이는 선생님이 부른 번호들을 기억하고 있다가 거꾸로 불러보는 것을 해보고 싶어졌다.

출석 번호를 n번 무작위로 불렀을 때, 부른 번호를 거꾸로 출력해 보자.

예시
...
for i in range(n-1, -1, -1) :
  print(a[i], end=' ')
...

참고
번호를 부른 순서를 리스트에 순서대로 기록해 두었다가, 기록한 값들을 거꾸로 출력하면 된다.
range(시작, 끝, 증감) #시작 수는 포함, 끝 수는 포함하지 않음. [시작, 끝)
range(n-1, -1, -1) #n-1, n-2, ..., 3, 2, 1, 0

n = int(input())
a = input().split()

for i in range(n):
  a[i] = int(a[i])

for i in range(n-1, -1, -1):
  print(a[i], end = ' ')

 

6094. 정보 선생님은 오늘도 이상한 출석을 부른다.

영일이는 오늘도 다른 생각을 해보았다.
출석 번호를 다 부르지는 않은 것 같은데... 가장 빠른 번호가 뭐였지?

출석 번호를 n번 무작위로 불렀을 때, 가장 빠른 번호를 출력해 보자.

단, 
첫 번째 번호와 마지막 번호가 몇 번인지는 아무도 모른다.
음수(-) 번호, 0번 번호도 있을 수 있다.

참고
리스트에 출석 번호를 기록해 두었다가, 그 중에서 가장 작은 값을 찾아내면 된다.
그런데, 가장 작은 값은 어떻게 어떤 것과 비교하고, 어떻게 찾아야 할까?

n = int(input())        # 번호를 몇 번 부르는지 입력 받기
a = input().split()     # 어떤 번호들을 부를건지 입력받기

for i in range(n):      # a 배열 int 선언
  a[i] = int(a[i])

for i in range(n-1):    # a 배열에 있는 숫자들을 비교
  if (a[i] < a[i+1]):   # 앞에 칸이 뒤에 칸보다 작다면
    a[i+1] = a[i]       # 앞에 칸 값을 뒤에 칸 값으로 넣어준다.
						# 만약, 앞에 칸이 뒤에 칸보다 크거나 같으면 그 값은 내둠
print(a[n-1])           # 최종적으로 남은 숫자가 마지막 배열칸에 입력되어 있을 것이다.
                        # 이것을 출력

6095. 기숙사 생활을 하는 학교에서 어떤 금요일(전원 귀가일)에는 모두 집으로 귀가를 한다.

오랜만에 집에 간 영일이는 아버지와 함께 두던 매우 큰 오목에 대해서 생각해 보다가
"바둑판에 돌을 올린 것을 프로그래밍 할 수 있을까?"하고 생각하였다.

바둑판(19 * 19)에 n개의 흰 돌을 놓는다고 할 때,
n개의 흰 돌이 놓인 위치를 출력하는 프로그램을 작성해보자.

예시
d=[]                        #대괄호 [ ] 를 이용해 아무것도 없는 빈 리스트 만들기
for i in range(20) :
  d.append([])         #리스트 안에 다른 리스트 추가해 넣기
  for j in range(20) : 
    d[i].append(0)    #리스트 안에 들어있는 리스트 안에 0 추가해 넣기

n = int(input())
for i in range(n) :
  x, y = input().split()
  d[int(x)][int(y)] = 1

for i in range(1, 20) :
  for j in range(1, 20) : 
    print(d[i][j], end=' ')    #공백을 두고 한 줄로 출력
  print()                          #줄 바꿈

참고
리스트가 들어있는 리스트를 만들면?
가로번호, 세로번호를 사용해 2차원 형태의 데이터처럼 쉽게 기록하고 사용할 수 있다.
리스트이름[번호][번호] 형식으로 저장되어있는 값을 읽고 쓸 수 있고, 더 확장한 n차원의 리스트도 만들 수 있다.

...
d=[]
for i in range(20) : 
  d.append([])
  for j in range(20) :  
    d[i].append(0)
... 

위와 같이, 모두 0이 채워진 2차원 리스트를 만드는 코드를 아래와 같은 방법으로 짧게 만들 수도 있다.
... [0 for j in range(20)]  #20개의 0이 들어간 [0, 0, 0, ... , 0, 0, 0] 리스트 
아래처럼 작성하면 위와 같은 리스트가 20개가 들어간 리스트를 한 번에 만들어 준다.

d = [[0 for j in range(20)] for i in range(20)]

이러한 리스트 생성 방식을 List Comprehensions 라고 한다.

d = [[0 for i in range(20)] for j in range(20)] # 19x19 배열을 선언과 동시에 각 자리에 0 대입 후,  d에 저장
n = int(input())                                # 몇 개의 돌을 받을 것이지 입력받기

for i in range(n):                                  
  x, y = input().split()                        # 배열 몇 번째 열과 행에 돌을 놓을 것인지 입력받기.
  d[int(x)][int(y)] = 1                         # 해당 자리에 돌 놓기 (1 대입)

for i in range(1, 20):                          # 19 x 19 배열 칸 모두 출력 / 빈자리는 0, 돌이 놓인 자리는 1
  for j in range(1, 20):
    print(d[i][j], end = ' ')
  print()                                       # 행에 있는 수를 다 출력하면 다음 행으로 이동

 

6096. 부모님을 기다리던 영일이는 검정/흰 색 바둑알을 바둑판에 꽉 채워 깔아 놓고 놀다가...

"십(+)자 뒤집기를 해볼까?"하고 생각했다.

십자 뒤집기는
그 위치에 있는 모든 가로줄 돌의 색을 반대(1->0, 0->1)로 바꾼 후, 
다시 그 위치에 있는 모든 세로줄 돌의 색을 반대로 바꾸는 것이다.
어떤 위치를 골라 집자 뒤집기를 하면, 그 위치를 제외한 가로줄과 세로줄의 색이 모두 반대로 바뀐다.

바둑판(19 * 19)에 흰 돌(1) 또는 검정 돌(0)이 모두 꽉 채워져 놓여있을 때,
n개의 좌표를 입력받아 십(+)자 뒤집기한 결과를 출력하는 프로그램을 작성해보자.

예시
...
for i in range(n) :
  x,y=input().split()
  for j in range(1, 20) :
    if d[j][int(y)]==0 :
      d[j][int(y)]=1
    else :
      d[j][int(y)]=0

    if d[int(x)][j]==0 :
      d[int(x)][j]=1
    else :
      d[int(x)][j]=0
...

참고
리스트가 들어있는 리스트를 만들면?
가로번호, 세로번호를 사용해 2차원 형태의 데이터처럼 쉽게 기록하고 사용할 수 있다.
리스트이름[번호][번호] 형식으로 저장되어있는 값을 읽고 쓸 수 있다.

d = [list(map(int, input().split())) for _ in range(1, 20)] # 19 x 19 배열 생성
n = int(input())                                            # 입력받을 좌표 횟수 입력받기    

for i in range(n):
  x, y = map(int, input().split()) # 좌표 입력받기
  for j in range(19):
    if(d[x-1][j] == 0):            # 해당 좌표 열에 해당하는 수 뒤집기
      d[x-1][j] = 1
    else:
      d[x-1][j] = 0
  for j in range(19):              # 해당 좌표 행에 해당하는 수 뒤집기
    if(d[j][y-1] == 0):
      d[j][y-1] = 1
    else:
      d[j][y-1] = 0
  
for k in range(19):                # 배열 출력
  for l in range(19):
    print(d[k][l], end = ' ')
  print()

 

6097. 부모님과 함께 놀러간 영일이는
설탕과자(설탕을 녹여 물고기 등의 모양을 만든 것) 뽑기를 보게 되었다.

길이가 다른 몇 개의 막대를 바둑판과 같은 격자판에 놓는데,

막대에 있는 설탕과자 이름 아래에 있는 번호를 뽑으면 설탕과자를 가져가는 게임이었다.
(잉어, 붕어, 용 등 여러 가지가 적혀있다.)

격자판의 세로(h), 가로(w), 막대의 개수(n), 각 막대의 길이(l),
막대를 놓는 방향(d:가로는 0, 세로는 1)과
막대를 놓는 막대의 가장 왼쪽 또는 위쪽의 위치(x, y)가 주어질 때,

격자판을 채운 막대의 모양을 출력하는 프로그램을 만들어보자.

h,w = map(int,input().split())
n = int(input())

board=[[0]*w for _ in range(h)]

for i in range(n):
    l,d,x,y = map(int,input().split())
    if(d==0):
        for j in range(l):
            board[x-1][y-1+j]=1
    else:
        for j in range(l):
            board[x-1+j][y-1]=1
            

for i in range(h):
    for j in range(w):
        print(board[i][j],end=' ')
    print()

 

6098. 영일이는 생명과학에 관심이 생겨 왕개미를 연구하고 있었다.

왕개미를 유심히 살펴보던 중 특별히 성실해 보이는 개미가 있었는데,
그 개미는 개미굴에서 나와 먹이까지 가장 빠른 길로 이동하는 것이었다.

개미는 오른쪽으로 움직이다가 벽을 만나면 아래쪽으로 움직여 가장 빠른 길로 움직였다.
(오른쪽에 길이 나타나면 다시 오른쪽으로 움직인다.)

이에 호기심이 생긴 영일이는 그 개미를 미로 상자에 넣고 살펴보기 시작하였다.

미로 상자에 넣은 개미는 먹이를 찾았거나, 더 이상 움직일 수 없을 때까지
오른쪽 또는 아래쪽으로만 움직였다.

미로 상자의 구조가 0(갈 수 있는 곳), 1(벽 또는 장애물)로 주어지고,
먹이가 2로 주어질 때, 성실한 개미의 이동 경로를 예상해보자.

단, 맨 아래의 가장 오른쪽에 도착한 경우, 더 이상 움직일 수 없는 경우, 먹이를 찾은 경우에는
더이상 이동하지 않고 그 곳에 머무른다고 가정한다.

미로 상자의 테두리는 모두 벽으로 되어 있으며,
개미집은 반드시 (2, 2)에 존재하기 때문에 개미는 (2, 2)에서 출발한다.

board=[[]*10 for _ in range(10)]
for i in range(10):
    board[i]=list(map(int,input().split()))
x=1
y=1
board[x][y]=9

while True:
    if(board[x][y]==2):
        board[x][y]=9
        break
    if(board[x][y+1]!=1):
        board[x][y]=9
        y+=1
    else:
        if(board[x+1][y]!=1):
            board[x][y]=9
            x+=1
        else:
          board[x][y]=9
          break

for i in range(10):
    for j in range(10):
        print(board[i][j],end=' ')
    print()

6086. 1, 2, 3 ... 을 순서대로 계속 더해 합을 만드는데,
그 합이 입력한 정수보다 작을 동안만 계속 더하는 프로그램을 작성해보자.

즉, 1부터 n까지 정수를 하나씩 더해 합을 만드는데,
어디까지 더해야 입력한 수보다 같거나 커지는지 알아보고자 하는 문제이다.

하지만, 이번에는 그 때 까지의 합을 출력해야 한다.

예를 들어, 57을 입력하면
1+2+3+...+8+9+10=55에서 그 다음 수인 11을 더해 66이 될 때,
그 값 66이 출력되어야 한다.

예시
...
while True :
  s += c
  c += 1
  if s>=n :
    break

print(s)

참고
조건문이나 반복문의 코드블록 안에서 break 가 실행되면,
반복실행을 중단(break)하고, 가장 가까운 반복 블록의 밖으로 빠져나간다.

a = int(input())
s = 0
c = 0

while True:
  s = s + c
  c = c + 1
  if s >= a:
    break

print(s)

 

6087. 1부터 입력한 정수까지 1씩 증가시켜 출력하는 프로그램을 작성하되,
3의 배수인 경우는 출력하지 않도록 만들어보자.

예를 들면,
1 2 4 5 7 8 10 11 13 14 ...
와 같이 출력하는 것이다.

예시
...
for i in range(1, n+1) :
  if i%2==0 :
    continue            #다음 반복 단계로 넘어간다.
  print(i, end=' ')    #i가 짝수가 아닐 때만 실행된다.
...
위 코드는 홀 수만 출력하는 예시이다.

참고
조건문이나 반복문의 코드블록 안에서 continue 가 실행되면,
반복 블록 안에 있는 나머지 부분을 실행하지 않고, 다음 반복 단계로 넘어간다.
즉, 반복 블록의 나머지 부분은 실행되지 않고, 다음 단계의 반복을 계속(continue)하는 것이다.

a = int(input())

for i in range(1, a+1):
  if i % 3 == 0:
    continue        # 다음 반복 단계로 넘어감
  print(i, end=' ') # i가 짝수가 아닐 때만 실행

 

6088. 어떤 규칙에 따라 수를 순서대로 나열한 것을 수열(sequences)이라고 한다.

예를 들어
1 4 7 10 13 16 19 22 25 ... 은
1부터 시작해 이전에 만든 수에 3을 더해 다음 수를 만든 수열이다.
이러한 것을 수학에서는 앞뒤 수들의 차이가 같다고 하여

등차(차이가 같다의 한문 말) 수열이라고 한다. (등차수열 : arithmetic progression/sequence)
수열을 알게 된 영일이는 갑자기 궁금해졌다.

"그럼.... 123번째 나오는 수는 뭘까?"

영일이는 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.

시작 값(a), 등차(d), 몇 번째인지를 나타내는 정수(n)가 입력될 때
n번째 수를 출력하는 프로그램을 만들어보자.

 

a, d, n = map(int, input().split())
print(a+(d*(n-1)))

항의 개수에서 -1 을 해준 뒤 곱을 해야 제대로 된 값이 나옴 ->초기값은 포함하면 안되기 때문

 

6089. 어떤 규칙에 따라 수를 순서대로 나열한 것을 수열(sequences)이라고 한다.

예를 들어
2 6 18 54 162 486 ... 은
2부터 시작해 이전에 만든 수에 3을 곱해 다음 수를 만든 수열이다.

이러한 것을 수학에서는 앞뒤 수들의 비율이 같다고 하여
등비(비율이 같다의 한문 말) 수열이라고 한다. (등비수열 : geometric progression/sequence)

등비 수열을 알게된 영일이는 갑자기 궁금해졌다.
"그럼.... 13번째 나오는 수는 뭘까?"
영일이는 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.

시작 값(a), 등비(r), 몇 번째인지를 나타내는 정수(n)가 입력될 때
n번째 수를 출력하는 프로그램을 만들어보자.

a, d, n = map(int, input().split()) # 정수를 받는다. 1. 초기값, 2. 공비, 3. 항의 개수
count=1                             # count 변수 선언

while(count<n):                     
  a *= d                            # 항에 공비를 곱해준다.
  count+=1                          # 항에 공비를 곱할때마다 count가 올라간다.

print(a)                            # 마지막 값을 출력해준다.

 

6090. 어떤 규칙에 따라 수를 순서대로 나열한 것을 수열(sequences)이라고 한다.

예를 들어
1 -1 3 -5 11 -21 43 ... 은
1부터 시작해 이전에 만든 수에 -2를 곱한 다음 1을 더해 다음 수를 만든 수열이다.

이런 이상한 수열을 알게 된 영일이는 또 궁금해졌다.
"그럼.... 13번째 나오는 수는 뭘까?"

영일이는 물론 수학을 아주 잘하지만 이런 문제는 본 적이 거의 없었다...
그래서 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.

시작 값(a), 곱할 값(m), 더할 값(d), 몇 번째인지를 나타내는 정수(n)가 입력될 때,
n번째 수를 출력하는 프로그램을 만들어보자.

a, m, d, n = map(int, input().split())    # 1.시작할 값, 2.곱할 값, 3. 더할값, 4. 항 개수
count = 1                                 # count 변수 선언
while(count<n):
  a=(a*m+d)                               # 연산 후 다음항으로 넘어가기
  count+=1                                # count 올리기
print(a)

 

6091. 온라인 채점시스템에는 초등학생, 중고등학생, 대학생, 대학원생,
일반인, 군인, 프로그래머, 탑코더 등 아주 많은 사람들이 들어와 문제를 풀고 있는데,

실시간 채점 정보는 메뉴의 채점기록(Judge Status)을 통해 살펴볼 수 있다.

자! 여기서...잠깐..
같은 날 동시에 가입한 3명의 사람들이 온라인 채점시스템에 들어와 문제를 푸는 날짜가
매우 규칙적이라고 할 때, 다시 모두 함께 문제를 풀게 되는 그날은 언제일까?

예를 들어 3명이 같은 날 가입/등업하고, 각각 3일마다, 7일마다, 9일마다
한 번씩 들어온다면, 처음 가입하고 63일 만에 다시 3명이 함께 문제를 풀게 된다.

갑자기 힌트?
왠지 어려워 보이지 않는가?
수학에서 배운 최소공배수를 생각한 사람들도 있을 것이다. 하지만, 정보에서 배우고 경험하는
정보과학의 세상은 때때로 컴퓨터의 힘을 빌려 간단한 방법으로 해결할 수 있게 한다.

아래의 코드를 읽고 이해한 후 도전해 보자.
day는 날 수, a/b/c는 방문 주기이다.
...
d = 1
while d%a!=0 or d%b!=0 or d%c!=0 :
  d += 1
print(d)
...

물론, 아주 많은 다양한 방법이 있을 수 있다.

정보과학의 문제해결에 있어서 정답은?
하나가 아니라 주어진 시간/기억공간으로 정확한 결과를 얻을 수 있는 모든 방법이다.

따라서, 모든 문제들에는 정답이 하나뿐만이 아니다.
새로운, 더 빠른, 더 간단한 방법을 다양하게 생각해보고 여러가지 방법으로 도전해 볼 수 있다.

h1, h2, h3 = map(int, input().split())
day = 1

while(day%h1 != 0 or day%h2 != 0 or day%h3 != 0): # 3명의 사람이 모두 해당되는 날을 찾음
  day += 1
print(day)

6081. 16진수 구구단 출력하기

16진수(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F)를 배운
영일이는 16진수끼리 곱하는 16진수 구구단?에 대해서 궁금해졌다.

A, B, C, D, E, F 중 하나가 입력될 때,
1부터 F까지 곱한 16진수 구구단의 내용을 출력해보자.
(단, A ~ F 까지만 입력된다.)

예시
...
  print('%X'%n, '*%X'%i, '=%X'%(n*i), sep='')
...

참고
print('%X'%n)    #n에 저장되어있는 값을 16진수(hexadecimal) 형태로 출력
작은 따옴표 2개를 사용해서 print(..., sep='') 으로 출력하면, 공백없이 모두 붙여 출력된다.
작은 따옴표 2개 '' 또는 큰 따옴표 2개 "" 는 아무 문자도 없는 빈문자열(empty string)을 의미한다.

a = input()

for i in range(1, 16):
  print( '%s*%s=%s' %(a, hex(i)[2:].upper(), hex(int(a, 16) *i )[2:].upper()))

 

6082. 3 6 9 게임의 왕이 되자


친구들과 함께 3 6 9 게임을 하던 영일이는 잦은 실수 때문에 계속해서 벌칙을 받게 되었다.
3 6 9 게임의 왕이 되기 위한 369 마스터 프로그램을 작성해 보자.

** 3 6 9 게임은?
여러 사람이 순서를 정한 후, 순서대로 수를 부르는 게임이다.
만약 3, 6, 9 가 들어간 수를 자신이 불러야 하는 상황이라면, 수를 부르는 대신 "박수(X)" 를 쳐야 한다.
33과 같이 3,6,9가 두 번 들어간 수 일때, "짝짝"과 같이 박수를 두 번 치는 형태도 있다. 

참고 
...
for i in range(1, n+1) :
  if i%10==3 :
    print("X", end=' ')    #출력 후 공백문자(빈칸, ' ')로 끝냄
...

a = int(input())

for i in range(1, a+1):
  if (i % 10 == 3 or i % 10 == 6 or i % 10 == 9):
    print('X', end= ' ')
    continue
    
  print(i, end= ' ')

 

6083. 빨강(red), 초록(green), 파랑(blue) 빛을 섞어 여러 가지 다른 색 빛을 만들어 내려고 한다.

빨강(r), 초록(g), 파랑(b) 각 빛의 가짓수가 주어질 때,
주어진 rgb 빛들을 섞어 만들 수 있는 모든 경우의 조합(r g b)과 만들 수 있는 색의 가짓 수를 계산해보자.  

**모니터, 스마트폰과 같은 디스플레이에서 각 픽셀의 색을 만들어내기 위해서 r, g, b 색을 조합할 수 있다.
**픽셀(pixel)은 그림(picture)을 구성하는 셀(cell)에서 이름이 만들어졌다.
 

r, g, b = input().split()

r = int(r)
g = int(g)
b = int(b)

for i in range(0, r):
  for j in range(0, g):
    for k in range(0, b):
      print(i, j, k)

print(r*g*b)

 

6084. 소리가 컴퓨터에 저장될 때에는 디지털 데이터화 되어 저장된다.

마이크를 통해 1초에 적게는 수십 번, 많게는 수만 번 소리의 강약을 체크하고,
한 번씩 체크할 때 마다 그 값을 정수값으로 바꾸어 저장하는 방식으로 소리를 파일로 저장할 수 있다.

값을 저장할 때에는 비트를 사용하는 정도에 따라 세세한 녹음 정도를 결정할 수 있고,
좌우(스테레오) 채널로 저장하면 2배… 5.1채널이면 6배의 저장공간이 필요하고,
녹음 시간이 길면 그 만큼 더 많은 저장공간이 필요하다.

1초 동안 마이크로 소리강약을 체크하는 횟수를 h
(헤르쯔, Hz 는 1초에 몇 번? 체크하는가를 의미한다.)

한 번 체크한 값을 저장할 때 사용하는 비트수를 b
(2비트를 사용하면 0 또는 1 두 가지, 16비트를 사용하면 65536가지..)

좌우 등 소리를 저장할 트랙 개수인 채널 개수를 c
(모노는 1개, 스테레오는 2개의 트랙으로 저장함을 의미한다.)

녹음할 시간(초) s가 주어질 때,

필요한 저장 용량을 계산하는 프로그램을 작성해보자.

실제로, 일반적인 CD 음질(44.1KHz, 16bit, 스테레오)로 1초 동안 저장하려면
44100 * 16 * 2 * 1 bit의 저장공간이 필요한데,
44100*16*2*1/8/1024/1024 로 계산하면 약 0.168 MB 정도가 필요하다.

이렇게 녹음하는 방식을 PCM(Pulse Code Modulation) 방법이라고 하는데,
압축하지 않은 순수한(raw) 소리 데이터 파일은 대표적으로 *.wav 가 있다.

**
      8 bit(비트)           = 1byte(바이트)       # 8bit=1Byte
1024 Byte(210 byte) = 1KB(킬로 바이트)  # 1024Byte=1KB
1024 KB(210 KB)      = 1MB(메가 바이트)
1024 MB(210 MB)     = 1GB(기가 바이트)
1024 GB(210 GB)      = 1TB(테라 바이트)

h, b, c, s = input().split()

h = int(h)
b = int(b)
c = int(c)
s = int(s)

print(round(h*b*c*s/8/1024/1024, 1), "MB")

 

6085. 이미지가 컴퓨터에 저장될 때에도 디지털 데이터화 되어 저장된다.

가장 기본적인 방법으로는 그림을 구성하는 한 점(pixel, 픽셀)의 색상을
빨강(r), 초록(g), 파랑(b)의 3가지의 빛의 세기 값으로 따로 변환하여 저장하는 것인데,

예를 들어 r, g, b 각 색에 대해서 8비트(0~255, 256가지 가능)씩을 사용한다고 하면,

한 점의 색상은 3가지 r, g, b의 8비트+8비트+8비트로 총 24비트로 표현해서
총 2^24 가지의 서로 다른 빛의 색깔을 사용할 수 있는 것이다.

그렇게 저장하는 점을 모아 하나의 큰 이미지를 저장할 수 있게 되는데,
1024 * 768 사이즈에 각 점에 대해 24비트로 저장하면 그 이미지를 저장하기 위한
저장 용량을 계산할 수 있다.

이렇게 이미지의 원래(raw) 데이터를 압축하지 않고 그대로 저장하는 대표적인 이미지 파일이
*.bmp 파일이며, 비트로 그림을 구성한다고 하여 비트맵 방식 또는 래스터 방식이라고 한다.

이미지의 가로 해상도 w, 세로 해상도 h, 한 픽셀을 저장하기 위한 비트 b 가 주어질 때,
압축하지 않고 저장하기 위해 필요한 저장 용량을 계산하는 프로그램을 작성해 보자.

예를 들어
일반적인 1024 * 768 사이즈(해상도)의 각점에 대해
24비트(rgb 각각 8비트씩 3개)로 저장하려면
1024 * 768 * 24 bit의 저장공간이 필요한데,
1024*768*24/8/1024/1024 로 계산하면 약 2.25 MB 정도가 필요하다.

실제 그런지 확인하고 싶다면, 간단한 그림 편집/수정 프로그램을 통해 확인할 수 있다.

**
      8 bit(비트)           = 1byte(바이트)     #       8bit=1Byte
1024 Byte(210 byte) = 1KB(킬로 바이트)  # 1024Byte=1KB
1024 KB(210 KB)      = 1MB(메가 바이트)
1024 MB(210 MB)     = 1GB(기가 바이트)
1024 GB(210 GB)      = 1TB(테라 바이트)

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

totalbit = a * b * c
totalbyte = totalbit / 8
totalkb = totalbyte / 1024
totalmb = totalkb / 1024

print("%0.2f MB" % totalmb)

6077. 정수(1 ~ 100) 1개를 입력받아 1부터 그 수까지 짝수의 합을 구해보자.

예시
#다음 코드는 홀 수만 더해 출력한다.
n = int(input())
s = 0
for i in range(1, n+1) :
  if i%2==1 :
    s += i

print(s)

참고
while 이나 for 반복실행구조를 이용할 수 있다.
다른 방법이나 while 반복실행구조를 이용해서도 성공시켜 보자.

n = int(input())
s = 0

for i in range( 1, n + 1 ):
  if i % 2 == 0:
    s += i

print(s)

 

6078. 영문 소문자 'q'가 입력될 때까지 입력한 문자를 계속 출력하는 프로그램을 작성해보자.

while True:
  a = input()
  print(a)

  if a == 'q':
    break

 

6079. 1, 2, 3 ... 을 계속 더해 나갈 때,
그 합이 입력한 정수(0 ~ 1000)보다 같거나 작을 때까지만
계속 더하는 프로그램을 작성해보자.

즉, 1부터 n까지 정수를 계속 더해 나간다고 할 때,
어디까지 더해야 입력한 수보다 같거나 커지는 지를 알아보고자하는 문제이다.

end_point = int(input())

total = 0 

for i in range(1, end_point+1):
  total += i
  if total >= end_point: 
    break
print(i)

 

6080. 1부터 n까지, 1부터 m까지 숫자가 적힌 서로 다른 주사위 2개를 던졌을 때,
나올 수 있는 모든 경우를 출력해보자.

예시
...
for i in range(1, n+1) :
  for j in range(1, m+1) :
    print(i, j)
...

참고
위 코드는
바깥쪽의 i 값이 1부터 n까지 순서대로 바뀌는 각각의 동안에
안쪽의 j 값이 다시 1부터 m까지 변하며 출력되는 코드이다.

조건선택 실행구조 안에 다른 조건선택 실행구조를 넣어 처리할 수 있는 것과 마찬가지로
반복 실행구조 안에 다른 반복 실행구조를 넣어 처리할 수 있다.

원하는 형태로 실행 구조를 결합하거나 중첩시킬 수 있다.

a, b = map(int, input().split())

for a in range(1, a+1):
  for b in range(1, b+1):
    print(a, b)

6071. 임의의 정수가 줄을 바꿔 계속 입력된다.
-2147483648 ~ +2147483647, 단 개수는 알 수 없다.

0이 아니면 입력된 정수를 출력하고, 0이 입력되면 출력을 중단해보자.

예시
...
n = 1      #처음 조건 검사를 통과하기 위해 0 아닌 값을 임의로 저장
while n!=0 :
  n = int(input())
  if n!=0 :
    print(n)
...

참고
if 조건식 :
  ...
  ...


구조를 사용하면,
주어진 조건식의 평가 결과가 True 인 경우에만, 들여쓰기로 구분된 코드블록이 실행된다.

if 를 while 로 바꾸면?

while 조건식 :
  ...
  ...

와 같은 방법으로 반복해서 실행시킬 수 있다.

실행되는 과정은
1. 조건식을 평가한다.
2. True 인 경우 코드블록을 실행한다.
3. 다시 조건식을 평가한다.
4. True 인 경우 코드블록을 실행한다.
...
... 조건식의 평가 값이 False 인 경우 반복을 중단하고, 그 다음 명령을 실행한다.

조건식의 평가 결과가 True 동안만 반복 실행된다. 

반복실행구조 안에 다른 조건/선택실행구조를 넣을 수도 있고...
조건/선택실행구조 안에 다른 반복실행구조를 넣을 수도 있다.

while True:
  a = int(input())
  if a == 0:
    break
  else:
    print(a)

 

6072. 정수(1 ~ 100) 1개가 입력되었을 때 카운트다운을 출력해보자.

while 조건식 :
  ...
  ...
반복 실행구조를 사용해 보자.

예시
...
while n!=0 :
  print(n)
  n = n-1
...

참고
n = n-1  #n에 저장되어있던 값에서 1만큼 뺀 후, 그 값을 다시 n에 저장시킨다.
n -= 1 과 같이 짧게 작성할 수도 있다. n -= 1 은 n = n-1 과 같은 의미이다.
이렇게 산술연산자(+, -, *, / ... )와 대입 연산자(=)를 함께 쓰는 것을 복합대입연산자라고도 부른다.
같은 방법으로 +=, *=, /=, //=, %=, &=, |=, ^=, >>=, <<=, **= 등과 같이 짧게 작성할 수 있다.

처음에 조건식을 검사하고, 그 다음에 실행하고, 그 다음에 값을 바꾸고...
다시 조건식을 검사하고, 실행하고, 값을 바꾸고...

a = int(input())

while True:
  print(a)
  a = a - 1
  if (a == 0):
    break

 

6073. 정수(1 ~ 100) 1개가 입력되었을 때 카운트다운을 출력해보자.

while 조건식 :
  ...
  ...

반복 실행구조를 사용해 보자.

참고
조건검사, 출력, 감소의 순서와 타이밍을 잘 생각해보자.

a = int(input())

while True:
  a = a - 1
  print(a)
  if(a == 0):
    break

 

6074. 영문 소문자(a ~ z) 1개가 입력되었을 때,
a부터 그 문자까지의 알파벳을 순서대로 출력해보자.

예시
c = ord(input())
t = ord('a')
while t<=c :
  print(chr(t), end=' ')
  t += 1

참고
알파벳 문자 a의 정수값은 ord('a')로 알아낼 수 있다.
chr(정수값)을 이용하면 유니코드 문자로 출력할 수 있다.
print(..., end=' ') 와 같이 작성하면 값 출력 후 공백문자 ' '를 출력한다. 즉, 마지막에 줄을 바꾸지 않고 빈칸만 띄운다.
(end='\n'로 작성하거나 생략하면, 값을 출력한 후 마지막(end)에 줄바꿈(newline)이 된다.)

a = ord(input())

for i in range(97, a+1):
  print(chr(i), end=' ')

ord() 함수 - 문자를 아스키 코드 값으로 변환

chr() 함수 - 아스키 코드 값을 문자로 변환

print(chr(i), end=' ') -> end = ' ' 를 통해 공백을 두고 한 줄로 출력이 가능

 

6075. 정수(0 ~ 100) 1개를 입력받아 0부터 그 수까지 순서대로 출력해보자.

a = int(input())

i = 0
while a >= 0:
  print(i)
  i += 1
  a -= 1
a = int(input())
for i in range(0, a+1):
  print(i)

 

6076. 정수(0 ~ 100) 1개를 입력받아 0부터 그 수까지 순서대로 출력해보자.

예시
n = int(input())
for i in range(n+1) :
  print(i)

참고
range(n) 은 0, 1, 2, ... , n-2, n-1 까지의 수열을 의미한다.
예를 들어 range(3) 은 0, 1, 2 인 수열을 의미한다.

for i in range(n) :    #range(n)에 들어있는(in) 각각의 수에 대해서(for) 순서대로 i에 저장해 가면서...
이때의 for는 각각의 값에 대하여... 라는 for each 의 의미를 가진다고 생각할 수 있다.

range(끝)
range(시작, 끝)
range(시작, 끝, 증감)
형태로 수열을 표현할 수 있다. 시작 수는 포함이고, 끝 수는 포함되지 않는다. [시작, 끝)
증감할 수를 작성하지 않으면 +1이 된다.

반복 실행구조에 반복 횟수를 기록/저장하는 변수로 i를 자주 사용하는데,
i 는 반복자(iterator)를 나타내는 i라고 생각할 수 있다. i, j, k ... 알파벳 순으로 사용하기도 한다.

a = int(input())
for i in range(a+1):
  print(i)

 

6065. 3개의 정수(a, b, c)가 입력되었을 때, 짝수만 출력해보자.

예시
a, b, c = input().split()

a = int(a)
b = int(b)
c = int(c)

if a%2==0 :  #논리적으로 한 단위로 처리해야하는 경우 콜론(:)을 찍고, 들여쓰기로 작성 한다.
  print(a)

if b%2==0 :
  print(b) 

if c%2==0 :
  print(c) 

참고 
if 조건식 :
  실행1  #조건식의 평가값이 True 인 경우 실행시킬 명령을 들여쓰기를 이용해 순서대로 작성한다.
  실행2
실행3  #들여쓰기를 하지 않은 부분은 조건식에 상관이 없음 

python 에서는 논리적 실행단위인 코드블록(code block)을 표현하기 위해 들여쓰기를 사용한다.
들여쓰기 방법은 탭(tab), 공백(space) 4개 등 여러 가지 방법을 사용할 수 있지만
한 소스코드 내에서 들여쓰기 길이와 방법은 똑같아야 한다.

a%2==0 은 (a%2)가 먼저 계산된 후 그 결과를 정수 0과 비교한 결과값이다.
a를 2로 나눈 나머지가 0, 즉 짝수이면 True 가 되고, 아니면 False 로 계산된다.
따라서,
if a%2==0 : #a가 짝수라면 ... 
와 같은 의미가 된다. 짝수가 아니라면 들여쓰기로 작성된 부분들은 실행되지 않는다.

a, b, c = map(int, input().split())
if a % 2 == 0 :
  print(a)
if b % 2 == 0 :
  print(b)
if c % 2 == 0 :
  print(c)
a, b, c = map(int, input().split())
print( *filter(lambda num: not num%2, [a, b, c]))

 

6066. 3개의 정수(a, b, c)가 입력되었을 때, 짝(even)/홀(odd)을 출력해보자.

예시
...
if a%2==0 :
  print("even")
else :
  print("odd") 
...

참고 
if 조건식 :  #조건식을 평가해서...
  실행1      #True 인 경우 실행시킬 명령들...
  실행2
else :        
  실행3      #False 인 경우 실행시킬 명령들...
  실행4
실행5       #조건식과 상관없는 다음 명령
...

else 는 if 없이 혼자 사용되지 않는다.
또한, else 다음에는 조건식이 없는 이유는? True(참)가 아니면 False(거짓)이기 때문에... 
조건식의 평가 결과는 True 아니면 False 로 계산되기 때문이다.

python 에서는 들여쓰기를 기준으로 코드블록을 구분하므로, 들여쓰기를 정확하게 해주어야 한다.

a, b, c = map(int, input().split())
if a % 2 == 0:
  print("even")
else:
  print("odd")
if b % 2 == 0:
  print("even")
else:
  print("odd")
if c % 2 == 0:
  print("even")
else:
  print("odd")
a, b, c = map(int, input().split())
print('odd' if a%2 else 'even')
print(b%2 and 'odd or 'even')
print( ['even', 'odd'][c%2] )
a, b, c = map(int, input().split())
print(  *map(lambda num: 'odd' if num%2 else 'even', [a, b, c]) )

 

6067. 0이 아닌 정수 1개가 입력되었을 때, 음(-)/양(+)과 짝(even)/홀(odd)을 구분해 분류해보자.
음수이면서 짝수이면, A
음수이면서 홀수이면, B
양수이면서 짝수이면, C
양수이면서 홀수이면, D
를 출력한다.

예시
...
if n<0 :
  if n%2==0 :
    print('A')      #주의 : 변수 A와 문자열 'A' / "A" 는 의미가 완전히 다르다. 
  else :
    print('B')
else :
  if n%2==0 :
    print('C')
  else :
    print('D')
...

참고
조건/선택 실행구조 안에 다시 조건/선택 실행구조를 "중첩"할 수가 있다.

또한, 중첩된 조건은
...
if (n<0) and (n%2==0) :
    print('A')

...

와 같이 논리연산자(not, and, or)를 이용해 합쳐 표현할 수도 있다.
비교연산(<, >, <=, >=, ==, !=) 의 계산 결과는 True 또는 False 의 불(boolean) 값이고,
불 값들 사이의 논리연산(not, and, or)의 결과도 True 또는 False 의 불 값이다.

a = int(input())

if a < 0:
  if(a % 2 == 0):
    print('A')
  else:
    print('B')
else:
  if(a % 2 == 0):
    print('C')
  else:
    print('D')

 

6068. 점수(정수, 0 ~ 100)를 입력받아 평가를 출력해보자.

평가 기준
점수 범위 : 평가
 90 ~ 100 : A
 70 ~   89 : B
 40 ~   69 : C
   0 ~   39 : D
로 평가되어야 한다.

예시
...
if n>=90 :
  print('A')
else :
  if n>=70 :
    print('B')
  else :
    if n>=40 :
      print('C')
    else :
      print('D') 
...

참고
여러 조건들을 순서대로 비교하면서 처리하기 위해서 조건문을 여러 번 중첩할 수 있다.

if 조건식1 :
  ...
else :
  if 조건식2 :
    ...
  else :
    if 조건식3 :
      ...
    else :

      ...

...
와 같이 조건/선택 실행 구조를 겹쳐 작성하면 순서대로 조건을 검사할 수 있다.
어떤 조건이 참이면 그 부분의 내용을 실행하고 전체 조건/선택 구조를 빠져나가게 된다.

if 조건식1 : 
  ... 
elif 조건식2 : 
  ... 
elif 조건식3 : 
  ... 
else : 
  ...
도 똑같은 기능을 한다. elif는 else if 의 짧은 약어라고 생각해도 된다.
elif 를 사용하면 if ... else ... 구조를 겹쳐 사용할 때처럼, 여러 번 안 쪽으로 들여쓰기 하지 않아도 된다.

a = int(input())

if a >=90:
  print('A')
else:
  if a>=70:
    print('B')
  else:
    if a>=40:
      print('C')
    else:
      print('D')

 

6069. 평가를 문자(A, B, C, D, ...)로 입력받아 내용을 다르게 출력해보자.

평가 내용
평가 : 내용
A : best!!!
B : good!!
C : run!
D : slowly~
나머지 문자들 : what?

a = input()
if a == 'A':
  print('best!!!')
elif a == 'B':
  print('good!!')
elif a == 'C':
  print('run!')
elif a == 'D':
  print('slowly~')
else:
  print('what?')

 

6070. 월이 입력될 때 계절 이름이 출력되도록 해보자.

월 : 계절 이름
12, 1, 2 : winter
  3, 4, 5 : spring
  6, 7, 8 : summer
  9, 10, 11 : fall

예시
...
if n//3==1 :
  print("spring")
...

참고
때때로 수들의 특징을 관찰하고 이용하면 매우 간단히 해결할 수도 있다.

a = int(input())
if a == 12 or a == 1 or a == 2:
  print('winter')
elif a == 3 or a == 4 or a == 5:
  print('spring')
elif a == 6 or a == 7 or a == 8:
  print('summer')
else:
  print('fall')
a = int(input())
if a in [12, 1, 2]:
	print('winter')
elif a in [3, 4, 5]:
	print('spring')
elif a in [6, 7, 8]:
	print('summer')
else:
	print('fall')
a = int(input())
if a//3==1:
	print('winter')
elif a//3==2:
	print('spring')
elif a//3==3:
	print('summer')
else:
  print('fall')

 

6063. 입력된 두 정수(a, b) 중 큰 값을 출력하는 프로그램을 작성해보자.
단, 3항 연산을 사용한다.

예시
a, b = input().split()
a = int(a)  #변수 a에 저장되어있는 값을 정수로 바꾸어 다시 변수 a에 저장
b = int(b)
c = (a if (a>=b) else b)
print(int(c))

참고
3개의 요소로 이루어지는 3항 연산은
"x if C else y" 의 형태로 작성이 된다.
- C : True 또는 False 를 평가할 조건식(conditional expression) 또는 값
- x : C의 평가 결과가 True 일 때 사용할 값
- y : C의 평가 결과가 True 가 아닐 때 사용할 값

조건식 또는 값이 True 이면 x 값이 사용되고, True가 아니면 y 값이 사용되도록 하는 코드이다.

예를 들어
0 if 123>456 else 1
과 같은 표현식의 평가값은 123 > 456 의 비교연산 결과가 False 이므로 1이 된다.

예시 코드에서
a>=b 의 결과가 True(참) 이면 (a if (a>=b) else b)의 결과는 a가 되고,
a>=b 의 결과가 False(거짓)이면 (a if (a>=b) else b)의 결과는 b가 된다.

a, b = map(int, input().split())
print(a>b and a or b)

 

6064. 입력된 세 정수 a, b, c 중 가장 작은 값을 출력하는 프로그램을 작성해보자.
단, 3항 연산을 사용한다.

참고
프로그래밍언어 소스코드 작성시 모든 요소들은
"순서에 따라 한 단계씩 실행"
"미리 정해진 순서에 따라 하나씩 연산 수행"
"그 때까지 연산된 결과를 이용해 다시 순서에 따라 하나씩 연산"
...
등의 원리가 적용된다.

따라서 3항 연산을 중첩해(괄호로 묶는 등..) 이용하면 여러 값들을 순서대로 비교해 가장 큰/작은 값을 계산할 수 있다.

예를 들어
(a if a>b else b) if ((a if a>b else b)>c) else c
와 같은 계산식은 a, b, c 의 값 중 가장 큰 값으로 계산된다.

잘 이해가 되지 않는다면 어떤 순서에 따라 계산될 지 생각해보고
여러 가지 연산자가 동시에 사용된 식이 있을 때, 어떤 우선순위에 따라 순서대로 계산이 되는지 찾아보도록 한다.
“연산자 우선순위”를 검색하면 우선순위와 결합방향이 나온다.
예를 들어 변수에 어떤 값을 대입하는 대입(assign) 연산자 = 의 우선순위는 가장 낮고, 오른쪽에서 왼쪽의 결합방향을 가진다.

** 3항 연산은 자주 사용되지는 않지만,
복잡한 계산식이나 조건 처리, 비교 구조를 간단히 표현할 수 있게 해준다.

a, b, c  = map(int, input().split())
d = a < b and a or b
print(d < c and d or c)
a, b, c  = map(int, input().split())
num = a if a < b else b
print( num if num < c  else c)

 

a, b = input().split()
print(bool(int(a)) or bool(int(b)))

6052. 정수가 입력되었을 때, True/False 로 평가해주는 프로그램을 작성해보자.

예시
n = int(input())
print(bool(n))

참고
bool( ) 을 이용하면 입력된 식이나 값을 평가해 불 형의 값(True 또는 False)을 출력해준다.
식이나 값을 계산해서 결과값이 만들어지는 것을 평가(evaluate)라고 한다. 

python 언어에서 정수값 0은 False(거짓)로 평가되고, 그 외의 값들은 모두 True(참)로 평가된다.
** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로 True(참)/False(거짓) 값만 가지는 논리값과 그 값들 사이의 연산을 다룬다.

a = int(input())
print(bool(a))

 

6053. 정수값이 입력될 때, 그 불 값을 반대로 출력하는 프로그램을 작성해보자.

예시
a = bool(int(input()))
print(not a)

참고
a = bool(int(input()))
와 같은 형태로 겹쳐 작성하면, 한 번에 한 단계씩 계산/처리/평가된다.
위와 같은 명령문의 경우 input( ), int( ), bool( ) 순서로 한 번에 한 단계씩 계산/처리/평가된다.

어떤 불 값이나 변수에 not True, not False, not a 와 같은 계산이 가능하다.

참 또는 거짓의 논리값을 역(반대)으로 바꾸기 위해서 not 예약어(reserved word, keyword)를 사용할 수 있다.

이러한 논리연산을 NOT 연산(boolean NOT)이라고도 부르고,
프라임 '(문자 오른쪽 위에 작은 따옴표), 바(기호 위에 가로 막대), 문자 오른쪽 위에 c(여집합, complement) 등으로 표시한다.
모두 같은 의미이다.

참, 거짓의 논리값 인 불(boolean) 값을 다루어주는 예약어는 not, and, or 이 있고,
불 값들 사이의 논리(not, and, or) 연산 결과도 마찬가지로 True 또는 False 의 불 값으로 계산 된다.

정수값 0은 False 이고, 나머지 정수 값들은 True 로 평가된다.
빈 문자열 "" 나 ''는 False 이고, 나머지 문자열들은 True 로 평가된다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로 True(참)/False(거짓) 값만 가지는 논리값과 그 값들 사이의 연산을 다룬다.

a = bool(int(input()))
print(not a)

 

6054. 2개의 정수값이 입력될 때, 그 불 값이 모두 True 일 때에만 True 를 출력하는 프로그램을 작성해보자.

예시
a, b = input().split()
print(bool(int(a)) and bool(int(b)))

참고
and 예약어는 주어진 두 불 값이 모두 True 일 때에만 True 로 계산하고, 나머지 경우는 False 로 계산한다.
이러한 논리연산을 AND 연산(boolean AND)이라고도 부르고, · 으로 표시하거나 생략하며, 집합 기호 ∩(교집합, intersection)로 표시하기도 한다. 
모두 같은 의미이다.

참, 거짓의 논리값 인 불(boolean) 값을 다루어주는 예약어는 not, and, or 이 있고,
불 값들 사이의 논리(not, and, or) 연산 결과도 마찬가지로 True 또는 False 의 불 값으로 계산된다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로 True(참)/False(거짓) 값만 가지는 논리값과 그 값들 사이의 연산을 다룬다.

 

a, b = input().split()
print(bool(int(a)) and bool(int(b)))

 

6055. 2개의 정수값이 입력될 때, 그 불 값이 하나라도 True 일 때에만 True 를 출력하는 프로그램을 작성해보자.

참고
or 예약어는 주어진 두 불 값 중에서 하나라도 True 이면 True 로 계산하고, 나머지 경우는 False 로 계산한다.
이러한 논리연산을 OR 연산(boolean OR)이라고도 부르고, + 로 표시하거나, 집합 기호 ∪(합집합, union)로 표시하기도 한다.
모두 같은 의미이다.

참, 거짓의 논리값 인 불(boolean) 값을 다루어주는 예약어는 not, and, or 이 있고,
불 값들 사이의 논리(not, and, or) 연산 결과도 마찬가지로 True 또는 False 의 불 값으로 계산된다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로 True(참)/False(거짓) 값만 가지는 논리값과 그 값들 사이의 연산을 다룬다.

a, b = input().split()
print(bool(int(a)) or bool(int(b)))

 

6056. 2개의 정수값이 입력될 때, 그 불 값(True/False) 이 서로 다를 때에만 True 를 출력하는 프로그램을 작성해보자.

예시
...
c = bool(int(a))
d = bool(int(b))
print((c and (not d)) or ((not c) and d))

참고
참 거짓이 서로 다를 때에만 True 로 계산하는 논리연산을 XOR(exclusive or, 배타적 논리합) 연산이라고도 부른다.

논리연산자는 사칙(+, -, *, /) 연산자와 마찬가지로 여러 번 중복해서 사용할 수 있는데, 
사칙 연산자와 마찬가지로 계산 순서를 표시하기 위해 괄호 ( )를 사용할 수 있다.
괄호를 사용하면 계산 순서를 명확하게 표현할 수 있다.

수학 식에서는 소괄호 (), 중괄호 {}, 대괄호 []를 사용하기도 하지만, 프로그래밍언어에서는 소괄호 ( ) 만 사용한다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로 True(참)/False(거짓) 값만 가지는 논리값과 그 값들 사이의 연산을 다룬다.

a, b = input().split()
a = bool(int(a))
b = bool(int(b))
print(a and (not b) or (not a) and b)

 

6057. 2개의 정수값이 입력될 때,
그 불 값(True/False) 이 서로 같을 때에만 True 를 출력하는 프로그램을 작성해보자.

a, b = input().split()
a = bool(int(a))
b = bool(int(b))
print(not(a) and not(b) or a and b)

 

6058. 2개의 정수값이 입력될 때,
그 불 값(True/False) 이 모두 False 일 때에만 True 를 출력하는 프로그램을 작성해보자.

a, b = input().split()
a = bool(int(a))
b = bool(int(b))
print((not a) and (not b))

6048. 두 정수(a, b)를 입력받아 a가 b보다 작으면 True 를, a가 b보다 크거나 같으면 False 를 출력하는 프로그램을 작성해보자.

예시
print(123<456)  #비교 연산자 < 의 계산 결과인 True(참)가 출력된다.
(123, 456 은 숫자로 작성된 단어이기 때문에 10진수로 인식된다.)

참고
어떤 값을 비교하기 위해 비교/관계(comparison/relational) 연산자(operator)를 사용할 수 있다.

비교/관계연산자 < (less than sign) 는
왼쪽의 값이 오른쪽 값 보다 작은 경우 True(참)로 계산하고,
그 외의 경우에는 False(거짓)로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 True(참), 또는 False(거짓)로 계산해 주는 연산자이다.

비교/관계연산자는 <, >, <=, >=, ==(같다), !=(다르다) 6개가 있다.

True(참) 또는 False(거짓) 값으로만 표현하고 저장하는 값을 불(bool)/불리언(boolean) 값이라고 한다.
정수, 실수, 문자, 문자열과 마찬가지로 또 다른 형태의 데이터형(data type)이다.

a, b = map(int, input().split())
if a < b:
  print(True)
elif a >= b:
  print(False)

* if / else / elif 비교

if     => 만약에

else => 만약에 그렇지 않으면

elif  => else if => 만약 그렇지 않으면 이건 어때?

출처: https://blockdmask.tistory.com/372 [개발자 지망생]


6049. 두 정수(a, b)를 입력받아 a와 b의 값이 같으면 True 를, 같지 않으면 False 를 출력하는 프로그램을 작성해보자.

참고
어떤 값을 비교하기 위해 비교/관계(comparison/relational) 연산자(operator)를 사용할 수 있다.

비교/관계연산자 == (equal sign 2개) 는
왼쪽의 계산 결과값과 오른쪽의 계산 결과값이 같은 경우 True(참)로 계산하고,
그 외의 경우에는 False(거짓)로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 True(참), 또는 False(거짓)로 계산해 주는 연산자이다.

비교/관계연산자는 <, >, <=, >=, ==(같다), !=(다르다) 6개가 있다.

** 수학에서 왼쪽과 오른쪽의 계산 결과가 같음(동치)을 나타내는 기호 =(equal sign) 1개는
프로그래밍언어에서는 전혀 다른 의미로 사용된다.

a = 1 와 같은 표현은 a와 1의 값이 같다는 의미가 아니라
오른쪽의 계산 결과값인 1을 왼쪽의 변수 a에 저장하라는 의미이다.

a, b = map(int, input().split())
if a == b :
  print(True)
elif a != b :
  print(False)

 

6050. 두 정수(a, b)를 입력받아 b의 값이 a의 값 보다 크거나 같으면 True 를, 같지 않으면 False 를 출력하는 프로그램을 작성해보자.

참고
어떤 값을 비교하기 위해 비교/관계(comparison/relational) 연산자(operator)를 사용할 수 있다.

비교/관계연산자 <= 는
오른쪽의 계산 결과값이 왼쪽의 계산 결과값보다 크거나 같은 경우 True(참)로 계산하고,
그 외의 경우에는 False(거짓)로 계산한다.

<=, >= 연산자는 같음(==)을 포함한다. 따라서 “작다/크다” 거나 "같다”는 의미를 가진다.
작다(<)/크다(>)/다르다(!) 기호는 등호(=)와 함께 왼쪽에 붙여써야 한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 True(참), 또는 False(거짓)로 계산해주는 연산자이다.
비교/관계연산자는 <, >, <=, >=, ==(같다), !=(다르다) 6개가 있다.

a , b  = map(int, input().split())
if b >= a:
  print(True)
elif b != a:
  print(False)

 

6051. 두 정수(a, b)를 입력받아 a의 값이 b의 값과 서로 다르면 True 를, 같으면 False 를 출력하는 프로그램을 작성해보자.

참고
어떤 값을 비교하기 위해 비교/관계(comparison/relational) 연산자(operator)를 사용할 수 있다.

비교/관계연산자 != 는
왼쪽의 계산 결과값이 오른쪽의 계산 결과값이 서로 다른 경우 True(참)로 계산하고,
그 외의 경우에는 False(거짓)로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 True(참), 또는 False(거짓)로 계산해주는 연산자이다.
비교/관계연산자는 <, >, <=, >=, ==(같다), !=(다르다) 6개가 있다.

a, b = map(int, input().split())
if a != b:
  print(True)
elif a == b:
  print(False)

6046. 정수 1개를 입력받아 2배 곱해 출력해보자.

참고
*2 를 계산한 값을 출력해도 되지만,
정수를 2배로 곱하거나 나누어 계산해 주는 비트단위시프트연산자 <<, >>를 이용할 수 있다.
컴퓨터 내부에는 2진수 형태로 값들이 저장되기 때문에,
2진수 형태로 저장되어 있는 값들을 왼쪽(<<)이나 오른쪽(>>)으로
지정한 비트 수만큼 밀어주면 2배씩 늘어나거나 1/2로 줄어드는데,

왼쪽 비트시프트(<<)가 될 때에는 오른쪽에 0이 주어진 개수만큼 추가되고,
오른쪽 비트시프트(>>)가 될 때에는 왼쪽에 0(0 또는 양의 정수인 경우)이나 1(음의 정수인 경우)이 개수만큼 추가되고,
가장 오른쪽에 있는 1비트는 사라진다.

예시
n = 10
print(n<<1)  #10을 2배 한 값인 20 이 출력된다.
print(n>>1)  #10을 반으로 나눈 값인 5 가 출력된다.
print(n<<2)  #10을 4배 한 값인 40 이 출력된다.
print(n>>2)  #10을 반으로 나눈 후 다시 반으로 나눈 값인 2 가 출력된다.

정수 10의 2진수 표현은 ... 1010 이다.
10 << 1 을 계산하면 ... 10100 이 된다 이 값은 10진수로 20이다.
10 >> 1 을 계산하면 ... 101 이 된다. 이 값은 10진수로 5이다.

n = 10 과 같이 키보드로 입력받지 않고 직접 작성해 넣은 코드에서, 숫자로 시작하는 단어(식별자, identifier)는 자동으로 수로 인식된다.  

n = 10 에서 10 은 10진수 정수 값으로 인식된다.
변수 n 에 문자열을 저장하고 싶다면, n = "10" 또는 n = '10'으로 작성해 넣으면 되고,

 

n = 10.0 으로 작성해 넣으면 자동으로 실수 값으로 저장된다.
n = 0o10 으로 작성해 넣으면 8진수(octal) 10으로 인식되어 10진수 8값이 저장되고,
n = 0xf 나 n = 0XF 으로 작성해 넣으면 16진수(hexadecimal) F로 인식되어 10진수 15값으로 저장된다.

** python에서 실수 값에 대한 비트시프트 연산은 허용되지 않고 오류가 발생한다.
(실수 값도 컴퓨터 내부적으로는 2진수 형태로 저장되고 비트시프트 처리가 될 수 있지만, python 에서는 허용하지 않는다.) 

a = int(input())
print(a<<1)

 

6047.  정수 2개(a, b)를 입력받아 a를 2b배 곱한 값으로 출력해보자.
0 <= a <= 10, 0 <= b <= 10

예시
a = 2
b = 10
print(a << b)  #210 = 1024 가 출력된다.

참고
예를 들어 1 3 이 입력되면 1을 23(8)배 하여 출력한다.

a, b = map(int, input().split())
print( a<<b )

6043. 실수 2개(f1, f2)를 입력받아 f1 을 f2 로 나눈 값을 출력해보자. 이 때 소숫점 넷째자리에서 반올림하여 무조건 소숫점 셋째 자리까지 출력한다.

(참고)
python 언어에는 나눗셈(division)을 계산하는 연산자(/)가 있다.

컴퓨터 프로그래밍에서 실수 변환이나 실수를 사용하는 계산은 
정확하게 변환되거나 계산되는 것이 아니라, 거의 모두 근사값으로 계산되는 것이라고 할 수 있다.  

실수가 컴퓨터로 저장되기 위해서는 디지털방식으로 2진 정수화되어 저장되어야 하는데, 
그 과정에서 아주 작은 부분이 저장되지 않고 사라지는 잘림(truncation) 오차가 자주 발생하기 때문이다.

계산 결과값 중에서 믿을 수 있는 숫자의 개수를 의미하는, 유효숫자에 대해 찾아보자. 
과학실험에서 온도나 부피를 측정할 때에도 유효숫자는 중요하다. 

f1, f2 = map(float, input().split()) 
print(format((f1/f2), ".3f"))

 

6044. 정수 2개(a, b)를 입력받아 합, 차, 곱, 몫, 나머지, 나눈 값을 자동으로 계산해보자.
단 0 <= a, b <= 2147483647, b는 0이 아니다.

a, b = map(int, input().split())
print(a+b)
print(a-b)
print(a*b)
print(a//b)
print(a%b)
print((round(a/b, 2)))

round()는 반올림하는 함수이다.

ex) print((round(a/b, 2)))

 

6045. 정수 3개를 입력받아 합과 평균을 출력해보자.

(참고)
공백으로 구분된 한 줄로 값들을 입력받기 위해서는
a, b, c = input().split()
과 같은 방법이 가능하고,

공백으로 구분해 두 값을 출력하기 위해서는
print(d, e)
와 같은 방법이 가능하다.

잘라낸 값들은 그 값의 특성(정수, 실수, 문자, 문자열 ...)에 따라 명확하게 변환시킨 후 사용하는 것이 좋다.

python 프로그래밍을 처음 배울 때 좋은 습관(단계)
1. 입력된 문자열을 정확하게 잘라낸다.(공백, 줄바꿈, 구분문자 등에 따라 정확하게 잘라낸다.)
2. 잘라낸 데이터들을 데이터형에 맞게 변환해 변수에 저장한다. (정수, 실수, 문자, 문자열 등에 따라 정확하게 변환한다.)
3. 값을 저장했다가 다시 사용하기 위해, 변수를 이용해 값을 저장하고, 변수를 이용해 계산을 한다.
4. 원하는 결과 값을 필요한 형태로 만들어 출력한다.(공백, 줄바꿈, 구분자, 등에 따라 원하는 형태로 만들어 출력한다.)

a, b, c = map(int, input().split())  
d = (a+b+c)/3
print(a+b+c, format(d, ".2f"))

 

6042. 실수 1개를 입력받아 소숫점 이하 두 번째 자리까지의 정확도로 반올림한 값을 출력해보자.


(예시)

a=float(input())
print( format(a, ".2f") )


(참고)
format(수, ".2f") 를 사용하면 원하는 자리까지의 정확도로 반올림 된 실수 값을 만들어 준다. 

여기서 만들어진 값은 소수점 아래 3번째 자리에서 반올림한 값이다.

컴퓨터 프로그래밍에서 실수 변환이나 실수를 사용하는 계산은
정확하게 변환되거나 계산되는 것이 아니라, 거의 모두 근사값으로 계산되는 것이라고 할 수 있다. 

실수가 컴퓨터로 저장되기 위해서는 디지털방식으로 2진 정수화되어 저장되어야 하는데,
그 과정에서 아주 작은 부분이 저장되지 않고 사라지는 잘림(truncation) 오차가 자주 발생하기 때문이다.

a = round(float(input()), 2)
print(a)

# a = float(input())
# print(format(a, ".2f"))

+ Recent posts