[Python, Go] 백준 1436번 풀이

영화감독 숌

• 숫자 6이 연속해서 3번 나타나는 수를 구하는 문제이다.

• 666, 1666, … , 5666, 의 다음은 6660, 6661, … 이다

• 666 부터 시작해서 수를 1씩 늘려가면서 모두 확인한다.

• 해당 수를 string으로 바꾸고 for문을 통해 6이 나왔을때 그 다음의 수도 6인지 그리고 그 다음 숫자도 6인지 확인하는 check 변수를 사용했다.

• 만약 check가 3이되면 해당 숫자는 6이 연속해서 3번 들어갔으므로 count를 1 증가시키고 주어진 목표만큼 count가 증가하면 종료, 출력했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

n = int(input())

name = 666
count = 0

while True:
    if count == n:
        print(name-1)
        break
    else:
        check = 0
        for i in str(name):
            if i == "6":
                check += 1
                if check == 3:
                    count += 1
                    continue
                else: pass
            else:
                check = 0
        name += 1

• Go도 같은 방식의 풀이지만, string을 for문에 돌릴때 반환되는 값은 포인터 값이므로 string(x) 로 바꿔주는것만 주의 참조

• string을 int로 바꿀때 strconv.ParseInt 를 사용했으나 strconv.Atoi를 사용해도됨

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var n int
	count := 0
	name := 666
	fmt.Scanf("%d", &n)

	for {
		if count == n {
			fmt.Printf("%d", name-1)
			break
		} else {
			check := 0
			for _, k := range strconv.Itoa(name) {
				v, _ := strconv.ParseInt(string(k), 10, 8)
				if v == 6 {
					check += 1
					switch check {
					case 3:
						count += 1
					}
				} else {
					check = 0
				}
			}
		}
		name += 1
	}
}

• check 값이 3인지 확인할때 if문을 사용해도 괜찮지만 switch문을 사용해보았다.

Full Code

Full Code - Python

Full Code - Go

[Python, Go] 백준 10828번 풀이

스택

• 주어지는 명령에 따라 스택을 처리하는 문제이다. 파이썬은 큐나 스택을 지원하는 라이브러리가 있지만 사용하지 않고 리스트를 통해 구현했으며, Go는 슬라이스를 통해 구현했다.

• 스택을 초기화할 필요가 있는 문제가 아니었으므로 하나의 파이썬의 경우 하나의 for문안에서 처리하고 Go는 각각의 명령에 따른 함수를 만들어 사용했다.

• Python 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import sys

n = int(sys.stdin.readline())

stack = []

# n = int(input())

for i in range(n):

    order = sys.stdin.readline().rstrip()
    # print(order)
    if len(order.split()) == 2:
        stack.insert(0,int(order.split()[1]))

    else:
        if order == "pop":
            if stack == []:
                print(-1)
            else:
                print(stack[0])
                stack.pop(0)
        elif order == "size":
            print(len(stack))
        elif order == "empty":
            if stack == []:
                print(1)
            else:
                print(0)
        # top
        else:
            if not stack == []:
                print(stack[0])
            else:
                print(-1)

• Go를 통해 슬라이스를 다룰때 파이썬의 pop과 같은 내장함수가 없다.

  • 따라서, 슬라이스에서 하나를 제거할 때 슬라이스의 길이가 1인경우와 1이 아닌경우를 나눠서 생각했다.

  • 슬라이스의 길이가 1인경우, 남아있는 하나를 제거하고 empty slice를 만들기 위해 nil 처리

  • 슬라이스의 길이가 1이 아닌 경우, 슬라이스의 가장 끝의 하나를 제거하면 되므로 슬라이스의 길이 L 을 구하고 L-1 까지의 슬라이스만을 가져간다.

• Go 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var s []int

func s_push(x int) {
	s = append(s, x)
}

func s_pop() {

	if s == nil {
		fmt.Printf("%d\n", -1)
	} else if len(s) == 1 {
		top := s[0]
		fmt.Printf("%d\n", top)
		s = nil
	} else {
		l := len(s)
		top := s[l-1]
		fmt.Printf("%d\n", top)
		s = s[:l-1]
	}
}

func s_size() {
	l := len(s)
	fmt.Printf("%d\n", l)
}

func s_empty() {
	if s == nil {
		fmt.Printf("%d\n", 1)
	} else {
		fmt.Printf("%d\n", 0)
	}
}

func s_top() {
	if s == nil {
		fmt.Printf("%d\n", -1)
	} else {
		l := len(s)
		top := s[l-1]
		fmt.Printf("%d\n", top)
	}
}

func main() {
	var n int
	inputReader := bufio.NewReader(os.Stdin)
	fmt.Scanf("%d", &n)

	for i := 0; i < n+1; i++ {
		input, _ := inputReader.ReadString('\n')

		order := strings.Split(input, " ")

		action := strings.TrimSpace(order[0])

		if len(order) == 2 {
			n := strings.TrimSpace(order[1])
			num, _ := strconv.Atoi(n)
			s_push(num)
		} else {
			switch action {
			case "pop":
				s_pop()
			case "size":
				s_size()
			case "empty":
				s_empty()
			case "top":
				s_top()
			}
		}
	}
}

Full Code

Full Code - Python

Full Code - Go

[Python] 백준 2798번 풀이

블랙잭

1.모든 조합의 경우의 수를 따지는 문제이다.
파이썬에서는 itertools의 combinations를 이용해 조합을 따질 수 있다.

itertools.combinations에서 확인할 수 있다.

2.combinations는 combinations object를 리턴하는데 이를 for루프에 돌려 하나의 조합을 확인하게되면 튜플 을 리턴한다.
예를들어,

1
2
3
4

li = [3,4,5]
for i in itertools.combinations(li,2):
	print(i)
## >> (3,4) , (3,5) , (4,5) 를 출력한다.

3.따라서 입력받은 N개의 숫자 리스트로부터 모든 조합을 따지면서 그 값이 상한값을 넘지않는 경우 새로운 변수에 입력해주면 된다.

1
2
3
4
5
6
7

com_li = 0

for i in itertools.combinations(li,3):
    s = sum(i)
    if s > com_li and s <= m:
        com_li = s
    else: pass

Full Code

Full Code

[Python] 백준 3053번 풀이

택시 기하학

1.택시 기하학에서 원이 어떻게 정의되는지 이해하면 매우 간단한 문제이다.
    아래의 그림을 통해 택시 기하학에서의 원을 살펴볼 수 있다.

직교 좌표계에서 같은 거리에 있는 점들의 집합을 원이라고 정의하므로 위와같이 나타낼 수 있다.

따라서 빨간 점들을 살펴보면 정사각형을 이루는것을 알 수 있고 정사각형의 넓이는 반지름 r이 주어졌을때 다음과 같이 구할 수 있다.

1

k = 2*(r**2) ## 피타고라스 정리에 의해 c^2 = a^2 + b^2 = a^2 + a^2 = 2*a^2

Full Code

Full Code

[Python] 백준1011번 풀이

Fly me to the Alpha Centauri

1.거리에 따른 이동 규칙을 찾는 문제였다. 마지막 거리1을 제외한 나머지 거리를 역으로 탐색하는 방법을 생각했지만 규칙성을 찾아서 해결하는 문제에 옳지 못한 방법이었다.
   타 게시판에서 힌트를 찾을 수 있었는데, 일정 거리를 지속적으로 늘려가다가 결국 마지막 1광년을 가기 위해 어느 시점부터 다시 지속적으로 움직이는 거리를 줄여야 한다는것이다.

2.그렇다면 어느 시점부터 다시 움직이는 거리를 줄이는 것일까?
   이에 대한 해답은 총 이동거리에 따라서 어떻게 움직여야하는지 표를 그려 파악할 수 있었다.

3.위의 표를 살펴보면 제곱수가 되는 K(볼드체가 표시되어 있는 2,3,4….) 를 기준으로 움직인 회수가 바뀌는것을 확인할 수 있다.
   다시말해, 우리가 움직여야하는 거리가 주어졌을 때 가장 가까운 제곱수로 나타낼 수 있는 값 K를 찾아야한다.

1
2
3
4
5

x, y = map(int, input().split())
stand = 0
if math.sqrt(y-x) - math.floor(math.sqrt(y-x)) < 0.5:
	stand = math.floor(math.sqrt(y-x))
else: stand = math.ceil(math.sqrt(y-x))

총 움직여야하는 거리 y-x 에 대해
   sqrt값과 sqrt의 floor값 차이를 구해 이 값이 0.5 보다 작다면 기준이 되는 K값(위의 코드에서는 stand값)은 sqrt의 floor값이라고 할 수 있다.
반대로, 0.5보다 크다면 K값은 sqrt의 ceil값이 될 것이다.

4.기준이 되는 값 K를 구했다면 K와 움직인 횟수와의 관계를 살펴봐야 한다.
   우리가 움직인 거리와 K의 제곱값을 비교하면 알 수 있다.
   만약, y-x가 K의 제곱보다 크다면 움직인 횟수는 K2이며
   y-x가 k의 제곱보다 작거나 같다면 움직인 횟수는 k2-1의 규칙을 따르는 것을 확인할 수 있다.

1
2
3
4

if y-x > stand**2:
	print(stand*2)
elif y-x <= stand**2:
	print(stand*2-1)

Full code

Full code

14499번 문제 풀이

주사위가 좌표면을 움직일때마다 윗면에 쓰여있는 숫자를 출력하는 문제이다.

1.규칙에 따라 주사위와 좌표면의 숫자들이 바뀌므로 바뀌는 주사위 면의 숫자들을 저장하고자 했다.

   따라서, 아래와 같이 dice라는 리스트를 주사위값 저장에 사용했다.

1

dice = [0,0,0,0,0,0] #위0 아래1 동2 서3 남4 북5 순서로 값

2.주사위가 움직이는 지도가 어떻게 생겼는지를 알아야했다.

   따라서, 아래와 같이 입력받은 크기에 맞는 지도를 생성했다.

1
2
3
4
5

field = []

for row in range(rows):
    li = list(map(int, input().split()))
    field.append(li)

3.주어지는 움직임대로 주사위를 움직이고 그에따라 지도의 값과 dice의 값을 바꿔주어야한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

for i in range(len(moves)):
    temp = 0
    if moves[i] == 1:
        if position_y + 1 < columns:
            position_y += 1
            temp = dice[2]
            field_num = field[position_x][position_y]
            if field_num == 0:
                dice[2] = dice[0]
                dice[0] = dice[3]
                dice[3] = dice[1]
                dice[1] = temp
                field[position_x][position_y] = temp

            else:
                dice[2] = dice[0]
                dice[0] = dice[3]
                dice[3] = dice[1]
                dice[1] = field[position_x][position_y]
                field[position_x][position_y] = 0
        else : continue

주사위가 특정 방향으로 움직이기전에, temp값에 바닥을 향할 주사위 값을 미리 저장해주었다.

그리고 주사위가 움직일때, 현재 좌표값들을 변경시켜준다.

이때 주의할점은 우리는 문제에서 값을 입력받을때 세로크기를 먼저받고 그 다음으로 가로 크기를 받는다는 점이다.

즉 동쪽으로 움직이면 y좌표가 늘어난다.

주사위가 굴렀다면, dice 리스트에 값들을 바꿔줘야한다.

위와같이 동쪽으로 굴렀다면, 위를 바라보던 주사위 면은 동쪽을 바라보게 될테고

서쪽을 바라보던 주사위면은 위를 바라보게 될 것이다.

이와 같이 주사위 면의 값들을 dice에 바꿔서 입력한다.

이 과정을 동,서,남,북에 나눠서 처리하고 그때마다 주사위 윗면의 값을 프린트해주면 된다.

Full Code

Full Code