8.1.화요일

8.1

 

코딧 강의와 프로그래머스 문제 다 풀었다, 아니다,  다 건들여는  봤다. 한 공식적으로는 15개 다시 도전해야하고, 나머지 한 15개 정도는 다시 풀어야 한다. 거의 쳇 gpt 도움으로 해결했으니까. 

이렇게 나를 변하게 해준 스터디에 감사함, 정말 한달 동안 정신없이 나름대로 했다. 많이 모자라지만 다른 스타디원 발목을 붙잡고 싶지 않았다. 

코딧 강의는 아직 좀 남았다.

 

• 211//20 배열 조각하기// 틀렸다
• 
  문제 설명

정수 배열 arr와 query가 주어집니다.

query를 순회하면서 다음 작업을 반복합니다.

• 짝수 인덱스에서는 arr에서 query[i]번 인덱스를 제외하고 배열의 query[i]번 인덱스 뒷부분을 잘라서 버립니다.
• 홀수 인덱스에서는 arr에서 query[i]번 인덱스는 제외하고 배열의 query[i]번 인덱스 앞부분을 잘라서 버립니다.

위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성해 주세요.

 

제한사항

• 5 ≤ arr의 길이 ≤ 100,000
• 1 ≤ query의 길이 < min(50, arr의 길이 / 2)

 

입출력 예

arr	query	result
[0, 1, 2, 3, 4, 5]	[4, 1, 2]	[1, 2, 3]

입출력 예 설명

입출력 예 #1

• 이번에 매번 처리할 query의 값과 처리 전후의 arr의 상태를 표로 나타내면 다음과 같습니다.

query의 값	query 처리 전	query 처리 후	비고
4	[0, 1, 2, 3, 4, 5]	[0, 1, 2, 3, 4]	0번 인덱스의 쿼리이므로 뒷부분을 자른다.

• 따라서 [1, 2, 3]을 return 합니다.

 

def solution(arr, query):

    for i in range(len(query)):

        if query[i] % 2 == 0:

            arr = arr[:query[i] + 1]

        else:

            arr = arr[query[i]:]

    return arr

 

남의 답

int* solution(int arr[], size_t arr_len, int query[], size_t query_len) {

    int start = 0, end = arr_len;

    for(int i = 0; i < query_len; i++) {

        if(i & 1) start += query[i];

        else end = start + query[i];

    }

    if(start == end) {

        int* answer = (int*)malloc(sizeof(int));

        answer[0] = -1;

        return answer;

    }

    int* answer = (int*)malloc((end - start) * sizeof(int));

    int cnt = 0;

    for(int i = start; i < end; i++) answer[cnt++] = arr[i];

    return answer;

}

 

int start = 0, end = arr_len;

for(int i = 0; i < query_len; i++) {

    if(i & 1) start += query[i];

    else end = start + query[i];

}

int start = 0, end = arr_len;

for(int i = 0; i < query_len; i++) {

    if(i & 1) start += query[i];

    else end = start + query[i];

}

우선 start와 end를 초기화합니다. start는 0으로, end는 arr_len으로 설정합니다. 그리고 query 배열을 순회하면서, 홀수 인덱스에 해당하는 값을 start에 더하고, 짝수 인덱스에 해당하는 값을 end와 더해서 다시 end에 저장합니다.

 

예를 들어, arr이 [1, 2, 3, 4, 5]이고, query가 [1, 2, 3]이라면, 다음과 같은 순서로 start와 end가 변경됩니다.

 

i = 0: start = 0, end = 1

i = 1: start = 2, end = 3

i = 2: start = 5, end = 8

if(start == end) {

    int* answer = (int*)malloc(sizeof(int));

    answer[0] = -1;

    return answer;

}

int* answer = (int*)malloc((end - start) * sizeof(int));

int cnt = 0;

for(int i = start; i < end; i++) answer[cnt++] = arr[i];

return answer;

이제 start와 end 사이에 있는 arr의 요소들을 구해서 반환합니다. 만약 start와 end가 같다면, 즉 구간의 길이가 0이라면 -1을 담은 크기 1의 배열을 반환합니다. 그렇지 않다면, end - start만큼의 크기를 가진 배열을 동적으로 할당하고, arr에서 해당 구간의 요소들을 복사해서 저장합니다. 마지막으로 answer 배열을 반환합니다.

 

예를 들어, 위에서 사용한 예시에서는 start가 5이고, end가 8입니다. 따라서 answer 배열은 [5, 4, 5]가 됩니다.

 

int* solution(int arr[], size_t arr_len, int query[], size_t query_len) {

    int start = 0, end = arr_len;

    for(int i = 0; i < query_len; i++) {

        if(i & 1) start += query[i];

        else end = start + query[i];

    }

여기서 int*에서 *은 무슨 뜻이야?

`int*`는 포인터를 나타내는 자료형입니다. 포인터는 메모리 주소를 저장하는 변수로, 해당 주소에 저장된 값을 참조할 수 있습니다. 이 함수에서 `int*` 자료형은 `answer`와 같은 동적으로 할당된 배열을 가리키기 위해 사용됩니다. 

 

예를 들어, `int* answer = (int*)malloc((end - start) * sizeof(int));`은 `end - start`개의 `int` 자료형을 저장할 수 있는 크기의 배열을 동적으로 할당하고, 그 배열의 첫 번째 요소의 주소를 `answer`에 저장합니다. 

 

그래서 이 함수에서 `int*` 자료형은 배열을 가리키기 위해 사용되며, `*` 기호는 해당 포인터가 가리키는 값을 참조하겠다는 의미입니다. 즉, `answer[i]`는 `*(answer + i)`와 같은 의미를 갖습니다.

 

 

 

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

// arr_len은 배열 arr의 길이입니다.

// query_len은 배열 query의 길이입니다.

int* solution(int arr[], size_t l, int q[], size_t ql) {

    int c,d,e;

    static int ans[100000] = {0,};

 

    for(c = 0;c < ql;c++) {

        if(c%2) {

            for(d=0;!~arr[d];d++);

            for(d += q[c]-1;d >= 0;d--) {

                arr[d] = -1;

            }

        } else {

            for(d=0;!~arr[d];d++);

            for(d +=q[c]+1;d < l;d++) arr[d] = -1;

        }

    }

    for(c=d=0;c < l;c++) {

        ~arr[c]?ans[d++]=arr[c]:0;

    }    

    return ans;

}

 

 

• 211//19 다음에 올 숫자

 

문제 설명

등차수열 혹은 등비수열 common이 매개변수로 주어질 때, 마지막 원소 다음으로 올 숫자를 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 2 < common의 길이 < 1,000
• -1,000 < common의 원소 < 2,000
• 등차수열 혹은 등비수열이 아닌 경우는 없습니다.
• 등비수열인 경우 공비는 0이 아닌 정수입니다.

 

입출력 예

common	result
[1, 2, 3, 4]	5
[2, 4, 8]	16

입출력 예 설명

입출력 예 #1

• [1, 2, 3, 4]는 공차가 1인 등차수열이므로 다음에 올 수는 5이다.

입출력 예 #2

• [2, 4, 8]은 공비가 2인 등비수열이므로 다음에 올 수는 16이다.

 

def solution(common):

    if len(common) == 2:

        return common[-1] + (common[-1] - common[-2])

    else:

        if common[1] - common[0] == common[2] - common[1]:

            return common[-1] + (common[-1] - common[-2])

        else:

            return common[-1] * (common[-1] // common[-2])

 

 

def solution(common):

    answer = 0

    a,b,c = common[:3]

    if (b-a) == (c-b):

        return common[-1]+(b-a)

    else:

        return common[-1] * (b//a)

    return answer

 

 

def solution(common):

 

    if common[2]-common[1]==common[1]-common[0]:

        return common[-1]+common[2]-common[1]

    elif common[2]/common[1]==common[1]/common[0]:

        return common[-1]*common[2]/common[1]

 

 

• 212//18.  연속된 수의 합
•  

문제 설명

연속된 세 개의 정수를 더해 12가 되는 경우는 3, 4, 5입니다. 두 정수 num과 total이 주어집니다. 연속된 수 num개를 더한 값이 total이 될 때, 정수 배열을 오름차순으로 담아 return하도록 solution함수를 완성해보세요.

 

제한사항

• 1 ≤ num ≤ 100
• 0 ≤ total ≤ 1000
• num개의 연속된 수를 더하여 total이 될 수 없는 테스트 케이스는 없습니다.

 

입출력 예

num	total	result
3	12	[3, 4, 5]
5	15	[1, 2, 3, 4, 5]
4	14	[2, 3, 4, 5]

입출력 예 설명

입출력 예 #1

• num = 3, total = 12인 경우 [3, 4, 5]를 return합니다.

입출력 예 #2

• num = 5, total = 15인 경우 [1, 2, 3, 4, 5]를 return합니다.

입출력 예 #3

• 4개의 연속된 수를 더해 14가 되는 경우는 2, 3, 4, 5입니다.

입출력 예 #4

 

 

def solution(num, total):

    answer = []

    start = (2 * total - num * (num - 1)) // (2 * num)

    for i in range(num):

        answer.append(start + i)

    return answer

 

위 코드에서 num은 연속된 수의 개수를, total은 연속된 수의 합을 나타냅니다.

 먼저, 첫 번째 원소를 구하기 위해 등차수열의 합 공식을 이용하여 start를 계산합니다. 

, start부터 num개의 숫자를 리스트에 추가하여 반환합니다.

 

 

def solution(num, total):

    return [(total - (num * (num - 1) // 2)) // num + i for i in range(num)]

 

 

def solution(num, total):

    answer = []

    var = sum(range(num+1))

    diff = total - var

    start_num = diff//num

    answer = [i+1+start_num for i in range(num)]

    return answer

 

 

def solution(num, total):

    if num % 2 == 1:

        return list(range(total//num-num//2, total//num+num//2+1))

    else:

        return list(range(total//num-num//2+1, total//num+num//2+1))

 

• 213//17안전지대
•  

문제 설명

다음 그림과 같이 지뢰가 있는 지역과 지뢰에 인접한 위, 아래, 좌, 우 대각선 칸을 모두 위험지역으로 분류합니다.

 

지뢰는 2차원 배열 board에 1로 표시되어 있고 board에는 지뢰가 매설 된 지역 1과, 지뢰가 없는 지역 0만 존재합니다.
지뢰가 매설된 지역의 지도 board가 매개변수로 주어질 때, 안전한 지역의 칸 수를 return하도록 solution 함수를 완성해주세요.

제한사항

• board는 n * n 배열입니다.
• 1 ≤ n ≤ 100
• 지뢰는 1로 표시되어 있습니다.
• board에는 지뢰가 있는 지역 1과 지뢰가 없는 지역 0만 존재합니다.

 

입출력 예

board	result
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]	16
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0]]	13
[[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]]	0

입출력 예 설명

입출력 예 #1

• (3, 2)에 지뢰가 있으므로 지뢰가 있는 지역과 지뢰와 인접한 위, 아래, 좌, 우, 대각선 총 8칸은 위험지역입니다. 따라서 16을 return합니다.

입출력 예 #2

• (3, 2), (3, 3)에 지뢰가 있으므로 지뢰가 있는 지역과 지뢰와 인접한 위, 아래, 좌, 우, 대각선은 위험지역입니다. 따라서 위험지역을 제외한 칸 수 13을 return합니다.

입출력 예 #3

• 모든 지역에 지뢰가 있으므로 안전지역은 없습니다. 따라서 0을 return합니다.

 

def solution(board):

    answer = 0

    n = len(board)

    

    for i in range(n):

        for j in range(n):

            if board[i][j] == 1:

                # 지뢰가 있는 경우

                for x in range(i-1, i+2):

                    for y in range(j-1, j+2):

                        if 0 <= x < n and 0 <= y < n and board[x][y] == 0:

                            # 범위 내에 있고 지뢰가 아닌 경우

                            board[x][y] = -1 # 위험지역으로 분류

                            

    for i in range(n):

        for j in range(n):

            if board[i][j] == 0:

                answer += 1

                

    return answer

 

 

def solution(board):

    n = len(board)

    danger = set()

    for i, row in enumerate(board):

        for j, x in enumerate(row):

            if not x:

                continue

            danger.update((i+di, j+dj) for di in [-1,0,1] for dj in [-1, 0, 1])

    return n*n - sum(0 <= i < n and 0 <= j < n for i, j in danger)

 

 

def solution(board):

    answer = 0

 

    for col in range(len(board)):

        for row in range(len(board[col])):

            if board[row][col] == 1:

                for j in range(max(col-1,0),min(col+2,len(board))):

                    for i in range(max(row-1,0),min(row+2,len(board))):

                        if board[i][j] == 1:

                            continue

                        board[i][j] = -1

    for i in board:

        answer += i.count(0)

 

    return answer

 

 

import numpy as np

 

def solution(board):

    expansion_board = np.zeros((len(board)+2, len(board)+2))

    expansion_board[1:-1, 1:-1] = board

    for i, col in enumerate(board):

        for j, dot in enumerate(col):

            if dot == 1:

                expansion_board[(i+1)-1:(i+1)+2, (j+1)-1:(j+1)+2]=[[1, 1, 1],[1, 1, 1],[1, 1, 1]]

 

    answer = len(board)*len(board) - expansion_board[1:-1, 1:-1].sum()

 

    return answer

 

 

• 214//16.   주사위 게임 3 pass

문제 설명

1부터 6까지 숫자가 적힌 주사위가 네 개 있습니다. 네 주사위를 굴렸을 때 나온 숫자에 따라 다음과 같은 점수를 얻습니다.

• 네 주사위에서 나온 숫자가 모두 p로 같다면 1111 × p점을 얻습니다.
• 세 주사위에서 나온 숫자가 p로 같고 나머지 다른 주사위에서 나온 숫자가 q(p ≠ q)라면 (10 × p + q)2 점을 얻습니다.
• 주사위가 두 개씩 같은 값이 나오고, 나온 숫자를 각각 p, q(p ≠ q)라고 한다면 (p + q) × |p - q|점을 얻습니다.
• 어느 두 주사위에서 나온 숫자가 p로 같고 나머지 두 주사위에서 나온 숫자가 각각 p와 다른 q, r(q ≠ r)이라면 q × r점을 얻습니다.
• 네 주사위에 적힌 숫자가 모두 다르다면 나온 숫자 중 가장 작은 숫자 만큼의 점수를 얻습니다.

네 주사위를 굴렸을 때 나온 숫자가 정수 매개변수 a, b, c, d로 주어질 때, 얻는 점수를 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• a, b, c, d는 1 이상 6 이하의 정수입니다.

 

입출력 예

a	b	c	d	result
2	2	2	2	2222
4	1	4	4	1681
6	3	3	6	27
2	5	2	6	30
6	4	2	5	2

입출력 예 설명

입출력 예 #1

• 예제 1번에서 네 주사위 숫자가 모두 2로 같으므로 1111 × 2 = 2222점을 얻습니다. 따라서 2222를 return 합니다.

입출력 예 #2

• 예제 2번에서 세 주사위에서 나온 숫자가 4로 같고 나머지 다른 주사위에서 나온 숫자가 1이므로 (10 × 4 + 1)2 = 412 = 1681점을 얻습니다. 따라서 1681을 return 합니다.

입출력 예 #3

• 예제 3번에서 a, d는 6으로, b, c는 3으로 각각 같으므로 (6 + 3) × |6 - 3| = 9 × 3 = 27점을 얻습니다. 따라서 27을 return 합니다.

입출력 예 #4

• 예제 4번에서 두 주사위에서 2가 나오고 나머지 다른 두 주사위에서 각각 5, 6이 나왔으므로 5 × 6 = 30점을 얻습니다. 따라서 30을 return 합니다.

입출력 예 #5

• 예제 5번에서 네 주사위 숫자가 모두 다르고 나온 숫자 중 가장 작은 숫자가 2이므로 2점을 얻습니다. 따라서 2를 return 합니다.

 

Chat but error

def solution(a, b, c, d):

    answer = 0

    nums = [a, b, c, d]

    nums.sort()

    

    # 1. 네 주사위에서 나온 숫자가 모두 같은 경우

    if nums.count(nums[0]) == 4:

        answer = nums[0] * 1111

    # 2. 세 주사위에서 나온 숫자가 같은 경우

    elif nums.count(nums[0]) == 3 or nums.count(nums[1]) == 3:

        if nums.count(nums[0]) == 3:

            p = nums[0]

            q = nums[3]

        else:

            p = nums[3]

            q = nums[0]

        answer = (10 * p + q) ** 2

    # 3. 두 쌍의 주사위에서 나온 숫자가 같은 경우

    elif nums.count(nums[0]) == 2 and nums.count(nums[3]) == 2:

        if nums.count(nums[1]) == 2:

            p = nums[1]

            q = nums[3]

        else:

            p = nums[0]

            q = nums[2]

        answer = (p + q) * abs(p - q)

    # 4. 두 주사위에서 나온 숫자가 같은 경우

    elif nums.count(nums[0]) == 2 or nums.count(nums[1]) == 2 or nums.count(nums[2]) == 2:

        if nums.count(nums[0]) == 2:

            p = nums[0]

            q = nums[2] if nums.count(nums[2]) == 2 else nums[3]

        elif nums.count(nums[1]) == 2:

            p = nums[1]

            q = nums[3] if nums.count(nums[3]) == 2 else nums[0]

        else:

            p = nums[2]

            q = nums[0] if nums.count(nums[0]) == 2 else nums[1]

        answer = p * q

   

 

 

• 215//16. 겹치는 선분의 길이 pass
• 
  문제 설명

선분 3개가 평행하게 놓여 있습니다. 세 선분의 시작과 끝 좌표가 [[start, end], [start, end], [start, end]] 형태로 들어있는 2차원 배열 lines가 매개변수로 주어질 때, 두 개 이상의 선분이 겹치는 부분의 길이를 return 하도록 solution 함수를 완성해보세요.

lines가 [[0, 2], [-3, -1], [-2, 1]]일 때 그림으로 나타내면 다음과 같습니다.

 

선분이 두 개 이상 겹친 곳은 [-2, -1], [0, 1]로 길이 2만큼 겹쳐있습니다.

 

제한사항

• lines의 길이 = 3
• lines의 원소의 길이 = 2
• 모든 선분은 길이가 1 이상입니다.
• lines의 원소는 [a, b] 형태이며, a, b는 각각 선분의 양 끝점 입니다.

 

입출력 예

lines	result
[[0, 1], [2, 5], [3, 9]]	2
[[-1, 1], [1, 3], [3, 9]]	0
[[0, 5], [3, 9], [1, 10]]	8

입출력 예 설명

입출력 예 #1

• 두 번째, 세 번째 선분 [2, 5], [3, 9]가 [3, 5] 구간에 겹쳐있으므로 2를 return 합니다.

입출력 예 #2

• 겹친 선분이 없으므로 0을 return 합니다.

입출력 예 #3

• 첫 번째와 두 번째 선분이 [3, 5] 구간에서 겹칩니다.
• 첫 번째와 세 번째 선분 [1, 5] 구간에서 겹칩니다.
• 두 번째와 세 번째 선분 [3, 9] 구간에서 겹칩니다.
• 따라서 [1, 9] 구간에 두 개 이상의 선분이 겹쳐있으므로, 8을 return 합니다.

 

def solution(lines):

    answer = 0

    points = []

    

    # 선분의 모든 점을 구해서 points에 저장

    for line in lines:

        for point in line:

            if point not in points:

                points.append(point)

    

    # 모든 점에 대해 겹치는 선분의 개수를 구해서 answer에 더함

    for point in points:

        count = 0

        for line in lines:

            if point >= line[0] and point <= line[1]:

                count += 1

        if count >= 2:

            answer += 1

    

    return answer

 

 

• 216//16 평행
•  

문제 설명

점 네 개의 좌표를 담은 이차원 배열  dots가 다음과 같이 매개변수로 주어집니다.

• [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]

주어진 네 개의 점을 두 개씩 이었을 때, 두 직선이 평행이 되는 경우가 있으면 1을 없으면 0을 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• dots의 길이 = 4
• dots의 원소는 [x, y] 형태이며 x, y는 정수입니다.
• 서로 다른 두개 이상의 점이 겹치는 경우는 없습니다.
• 두 직선이 겹치는 경우(일치하는 경우)에도 1을 return 해주세요.
• 임의의 두 점을 이은 직선이 x축 또는 y축과 평행한 경우는 주어지지 않습니다.

입출력 예

dots	result
[[1, 4], [9, 2], [3, 8], [11, 6]]	1
[[3, 5], [4, 1], [2, 4], [5, 10]]	0

입출력 예 설명

입출력 예 #1

• 점 [1, 4], [3, 8]을 잇고 [9, 2], [11, 6]를 이으면 두 선분은 평행합니다.

입출력 예 #2

• 점을 어떻게 연결해도 평행하지 않습니다.
• 217//16정수를 나선형으로 배치하기
• 
  문제 설명

양의 정수 n이 매개변수로 주어집니다. n × n 배열에 1부터 n2 까지 정수를 인덱스 [0][0]부터 시계방향 나선형으로 배치한 이차원 배열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 1 ≤ n ≤ 30

 

입출력 예

n	result
4	[[1, 2, 3, 4], [12, 13, 14, 5], [11, 16, 15, 6], [10, 9, 8, 7]]
5	[[1, 2, 3, 4, 5], [16, 17, 18, 19, 6], [15, 24, 25, 20, 7], [14, 23, 22, 21, 8], [13, 12, 11, 10, 9]]

 

입출력 예 설명

입출력 예 #1

• 예제 1번의 n의 값은 4로 4 × 4 배열에 다음과 같이 1부터 16까지 숫자를 채울 수 있습니다.

• 따라서 [[1, 2, 3, 4], [12, 13, 14, 5], [11, 16, 15, 6], [10, 9, 8, 7]]를 return 합니다.	• 0	• 1	• 2	• 3
• 0	• 1	• 2	• 3	• 4
• 1	• 12	• 13	• 14	• 5
• 2	• 11	• 16	• 15	• 6
• 3	• 10	• 9	• 8	• 7

입출력 예 #2

• 예제 2번의 n의 값은 5로 5 × 5 배열에 다음과 같이 1부터 25까지 숫자를 채울 수 있습니다.

• 따라서 [[1, 2, 3, 4, 5], [16, 17, 18, 19, 6], [15, 24, 25, 20, 7], [14, 23, 22, 21, 8], [13, 12, 11, 10, 9]]를 return 합니다.	• 0	• 1	• 2	• 3	• 4
• 0	• 1	• 2	• 3	• 4	• 5
• 1	• 16	• 17	• 18	• 19	• 6
• 2	• 15	• 24	• 25	• 20	• 7
• 3	• 14	• 23	• 22	• 21	• 8
• 4	• 13	• 12	• 11	• 10	• 9

 

쳇거

 

def solution(n):

    answer = [[0] * n for _ in range(n)]

    num = 1

    x, y = 0, 0

    dx, dy = [0, 1, 0, -1], [1, 0, -1, 0]

    direction = 0

    

    # answer 배열에 숫자를 채워넣음

    while num <= n**2:

        answer[x][y] = num

        num += 1

        nx, ny = x + dx[direction], y + dy[direction]

        if nx < 0 or nx >= n or ny < 0 or ny >= n or answer[nx][ny] != 0:

            direction = (direction + 1) % 4

            nx, ny = x + dx[direction], y + dy[direction]

        x, y = nx, ny

    

    return answer

 

다른 사람 풀이

 

def solution(n):

    answer = [[None for j in range(n)] for i in range(n)]

    move = [[0, 1], [1, 0], [0, -1], [-1, 0]]

    x, y, m = 0, 0, 0

    for i in range(1, n**2 + 1):

        answer[y][x] = i

        if y + move[m][0] >= n or x + move[m][1] >= n or answer[y + move[m][0]][x + move[m][1]]:

            m = (m + 1) % len(move)

        y, x = y + move[m][0], x + move[m][1]

    return answer

 

 

 

def solution(n):

    return [[ 4*i*(n-i) + (1+x+y - 2*i if (x==i or y==n-i-1) else (4*n - 6*i - x - y -3))  for i,x,y in row]   for row in [[(min(n-x-1,x,n-y-1,y),x,y) for y in range(n)] for x in range(n)]]

 

 

dx=(0,1,0,-1)

dy=(1,0,-1,0)

 

def solution(n):

    board=[[0]*n for i in range(n)]

    x,y=0,0

    board[0][0]=1

    now=2

    d=0

    while now<=n*n:

        nx,ny=x+dx[d],y+dy[d]

        if not (0<=nx<n and 0<=ny<n) or board[nx][ny]:

            d=(d+1)%4

            continue

        x,y=nx,ny

        board[x][y]=now

        now+=1

    return board

 

 

def solution(n):

    dy = [0, 1, 0, -1]

    dx = [1, 0, -1, 0]

    y, x = 0, -1

 

    arr = [[0] * n for _ in range(n)]

    cnt = 1

    direction = 0

    while cnt <= n**2:

        ny, nx = y + dy[direction], x + dx[direction]

        if 0 <= ny < n and 0 <= nx < n and not arr[ny][nx]:

            arr[ny][nx] = cnt

            cnt += 1

            y, x = ny, nx

        else:

            direction = (direction + 1) % 4

 

    return arr

 

 

 

• 218//15.             옹알이 (1)  pass

문제 설명

머쓱이는 태어난 지 6개월 된 조카를 돌보고 있습니다. 조카는 아직 "aya", "ye", "woo", "ma" 네 가지 발음을 최대 한 번씩 사용해 조합한(이어 붙인) 발음밖에 하지 못합니다. 문자열 배열 babbling이 매개변수로 주어질 때, 머쓱이의 조카가 발음할 수 있는 단어의 개수를 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 1 ≤ babbling의 길이 ≤ 100
• 1 ≤ babbling[i]의 길이 ≤ 15
• babbling의 각 문자열에서 "aya", "ye", "woo", "ma"는 각각 최대 한 번씩만 등장합니다.
• 문자열은 알파벳 소문자로만 이루어져 있습니다.

 

입출력 예

babbling	result
["aya", "yee", "u", "maa", "wyeoo"]	1
["ayaye", "uuuma", "ye", "yemawoo", "ayaa"]	3

입출력 예 설명

입출력 예 #1

• ["aya", "yee", "u", "maa", "wyeoo"]에서 발음할 수 있는 것은 "aya"뿐입니다. 따라서 1을 return합니다.

입출력 예 #2

• ["ayaye", "uuuma", "ye", "yemawoo", "ayaa"]에서 발음할 수 있는 것은 "aya" + "ye" = "ayaye", "ye", "ye" + "ma" + "woo" = "yemawoo"로 3개입니다. 따라서 3을 return합니다.

 

유의사항

• 네 가지를 붙여 만들 수 있는 발음 이외에는 어떤 발음도 할 수 없는 것으로 규정합니다. 예를 들어 "woowo"는 "woo"는 발음할 수 있지만 "wo"를 발음할 수 없기 때문에 할 수 없는 발음입니다.

 

쳇 오답

def solution(babbling):

    answer = 0

    

    # 각 문자열에서 가능한 부분 문자열을 모두 구하고, 이 중에서 "aya", "ye", "woo", "ma"가 한 번씩만 등장하는 경우 answer를 1 증가시킴

    for word in babbling:

        for i in range(len(word)):

            for j in range(i+1, len(word)+1):

                sub = word[i:j]

                if sub.count("aya") == 1 and sub.count("ye") == 1 and sub.count("woo") == 1 and sub.count("ma") == 1:

                    answer += 1

                    break

    

    return answer