문제

📌 파이썬 으로 풀이

📌 문제 링크 :

📌 문제 설명 :

JadenCase란 모든 단어의 첫 문자가 대문자이고, 그 외의 알파벳은 소문자인 문자열입니다. 단, 첫 문자가 알파벳이 아닐 때에는 이어지는 알파벳은 소문자로 쓰면 됩니다. (첫 번째 입출력 예 참고)
문자열 s가 주어졌을 때, s를 JadenCase로 바꾼 문자열을 리턴하는 함수, solution을 완성해주세요.

📌 제한 사항

• s는 길이 1 이상 200 이하인 문자열입니다.
• s는 알파벳과 숫자, 공백문자(" ")로 이루어져 있습니다.
  • 숫자는 단어의 첫 문자로만 나옵니다.
  • 숫자로만 이루어진 단어는 없습니다.
  • 공백문자가 연속해서 나올 수 있습니다.

📌 입출력 예

풀이

추측) 

공백 단위로 배열을 자르고 앞자리를 대문자로 만들어 다시 문자열로 붙여준다.

마지막 인덱스가 아닐 경우에는 공백을 추가하여 붙여준다.

숫자는 소문자나 대문자나 같으니 첫문자가 숫자인 경우를 예외처리할 필요 없다.

아니 잠깐.. 공백문자가 여러개 나올 수 있다라...

소스코드) 

* 1차) 실패 : 44.4 (많은 런타임 에러)

def solution(s):
    answer = ''
    string_arr = [one.lower() for one in s.split(" ")]
    for i in range(0,len(string_arr)) :
        first_str = string_arr[i][0]
        answer += string_arr[i].replace(first_str, first_str.upper(), 1)
        if i != len(string_arr)-1 :
            answer += " "
        
    return answer

* 2차) 성공

def solution(s):
    answer = ''
    flag = False
    for one in s :
        if one == ' ' :
            flag = False
            answer += one
        else :
            if one != ' ' and flag == False :
                flag = True
                answer += one.upper()
            else :
                answer += one.lower()
        
    return answer

리뷰) 

1차 피드백)

1차에 일단 공백문자 여러개일 경우를 생각안하고 해본 경우는 44.4점.. 게다가 런타임 에러 흠

공백을 기준으로 자르기 보다는 문자 그자체를 판단하는 방식으로 가는게 맞을 거 같다.

방식을 완전히 바꿔 문자열 하나하나 판단하는 방법으로 해보자

2차에서는 flag를 하나 준다

공백을 만나면 false로 전환해서 그다음 만나는 문자가 첫문자다 라는 걸 알리는 방식

문자를 만나면 True로 전환해서 이미 첫문자를 만났다라는 것을 알린다

그래서 각 문자 하나하나 for문을 돌려서 공백과 문자열을 판별해가며 flag를 전환하고 

flag가 False라 아직 첫문자를 안 만난상태에 그리고 글자가 공백이 아닌 경우가 바로 첫글자라 판단하여 해당 문자를 대문자로 전환하고 나머지는 모두 소문자화 시킨다.

문제

📌 파이썬 으로 풀이

📌 문제 링크 :

📌 문제 설명 :

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

예를 들어, 4개의 문서(A, B, C, D)가 순서대로 인쇄 대기목록에 있고 중요도가 2 1 3 2 라면 C D A B 순으로 인쇄하게 됩니다.

내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 알고 싶습니다. 위의 예에서 C는 1번째로, A는 3번째로 인쇄됩니다.

현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

📌 제한 사항

• 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
• 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
• location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

📌 입출력 예

풀이

추측) 

나중에 같은 숫자끼리 위치정보 헷갈리지 않게 우선순위의 숫자들과 인덱스를 짝을 지어주고 다시 배열로 만듬

그리고 그 배열를 큐처럼 일단 front에서 하나 pop해서 우선순위의 맥스 값이랑 비교

맥스값이랑 동일하지 않으면

 -     다시 배열에 append해서 뒤로 보내고

맥스값이랑 동일하면 그대로 프린트!

 -     프린트된 순서 카운트를 올림

 -     우선순위에서 해당 숫자를 pop해주어 다음 순번을 찾을 수 있게 해준다.

 -     프린트가 됬을 때의 인덱스가 location과 일치한다면 그 카운트를 반환

소스코드) 

* 1차) 

def solution(priorities, location):
    answer = 0 
    queue = [(i,priorities[i]) for i in range(0,len(priorities))]
    
    while True: 
        one = queue.pop(0)
        max_num = max(priorities)
        if one[1] != max_num :
            queue.append(one)
        else :
            priorities.pop(priorities.index(max_num))
            answer += 1
            if location == one[0] :
                return answer

리뷰) 

우선순위에서 맥스값을 pop할 때 순간 그럼 같은 max값이 있는 경우엔 어떻게 하지라는 의문이 생겼었는데

생각해보니 모든 맥스값을 삭제하는 게 아니라 index함수는 가장 먼저 검색되는 인덱스 하나만을 검색해 주는거라

맥스값 여러개 있으면 처음꺼만 삭제하고 다시 max 함수를 하면 동일한 값이지만 다른 맥스값이 검색되므로 문제 없었다. 

📌 파이썬 으로 풀이

📌 문제 링크 :

📌 문제 설명 :

정수 n, left, right가 주어집니다. 다음 과정을 거쳐서 1차원 배열을 만들고자 합니다.

1. n행 n열 크기의 비어있는 2차원 배열을 만듭니다.
2. i = 1, 2, 3, ..., n에 대해서, 다음 과정을 반복합니다.
   • 1행 1열부터 i행 i열까지의 영역 내의 모든 빈 칸을 숫자 i로 채웁니다.
3. 1행, 2행, ..., n행을 잘라내어 모두 이어붙인 새로운 1차원 배열을 만듭니다.
4. 새로운 1차원 배열을 arr이라 할 때, arr[left], arr[left+1], ..., arr[right]만 남기고 나머지는 지웁니다.

정수 n, left, right가 매개변수로 주어집니다. 주어진 과정대로 만들어진 1차원 배열을 return 하도록 solution 함수를 완성해주세요.

📌 제한 사항

• 1 ≤ n ≤ 107
• 0 ≤ left ≤ right < n2
• right - left < 105

📌 입출력 예

추측) 

n행 n열로 숫자를 채울때 1행 1열은 1, 2행 2열까지 2, 3행 3열까지 3을 채운 다음

그걸 행을 기준으로 잘라 한행으로 붙이고 그 전체 배열에서 left부터 right까지의 인덱스에 해당하는 배열을 return하면 되는 문제

그럼 여기서 일단 n행 n열을 채워주는 방법

n이 6일라고 하면

1, 2, 3, 4, 5, 6

2, 2, 3, 4, 5, 6

3, 3, 3, 4, 5, 6

4, 4, 4, 4, 5, 6

5, 5, 5, 5, 5, 6

6, 6, 6, 6, 6, 6

1, 2, 3, 4, 5, 6 / 2, 2, 3, 4, 5, 6 / 3, 3, 3, 4, 5, 6 / 4, 4, 4, 4, 5, 6 / 5, 5, 5, 5, 5, 6 / 6, 6, 6, 6, 6, 6

패턴을 보면 1번 행은 1이 1번까지, 2번 행은 2까지 모두 2, 3번 행은 3까지 3 이런식의 패턴을 반복한다. 

그럼 i번 행일 경우 i까지 i를 반복 나머지는 +1씩하여 그리고 n이 되면 한 행을 완성 시키는 방식으로 행을 만든다. 

그리고 필요한 부분의 배열만 잘라 return

소스코드) 

* 1차) 실패 : 45점 하나빼고 모두 시간초과

def solution(n, left, right):
    answer = []
    
    for i in range(0,n) :
        for j in range(0,n) :
            if j < i :
                answer.append(i+1)
            else:
                answer.append(j+1)
        
        if len(answer) > right+1 :
            return answer[left:right+1]

* 2차) 성공 

def solution(n, left, right):
    answer = []

    for i in range(left, right+1) :
        
        remain = (i % n) + 1
        share = int(i / n) + 1
        
        if remain > share :
            answer.append(remain)
        else :
            answer.append(share) 
    
    return answer

리뷰) 

1차)

시간 초과를 안하게 하려면 일단 어떻게 해야할까 

n이 일단 10의 7승까지 가능하단 걸 생각하면 모든 배열을 정리하고 하는 방식이 시간 초과에 지대한 영향을 미칠 것으로 보인다. 

딱 left와 right 사이만 판단하는 방법이 없을까? 

어휴 삽질 많이 했다 ㅠ

처음엔 3부분으로 나눠서 (처음줄, 반복줄, 마지막줄) for문으로 배열을 만들어 그 배열들을 또 붙이는 방식으로도 해봤다.

근데 일단 정확도도 안맞고 방식이 너무 지저분하다는 느낌이 들어서 최대한 모든 수를 같은 방식으로 판별하는 방법을 고민하게 되었다. 

아예 left ~ right 사이의 인덱스 값을 받게 되면 인덱스 값으로 해당 수를 판단할 수 있게 만들고 바로 append하는 방식으로 진행! 성공!!

📌 파이썬 으로 풀이

📌 문제 링크 :

📌 문제 설명 :

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

• ["방향 거리", "방향 거리" … ]

예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

• 주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
• 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.

위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다.

공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

📌 제한 사항

• 3 ≤ park의 길이 ≤ 50
  • 3 ≤ park[i]의 길이 ≤ 50
    • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
      • S : 시작 지점
      • O : 이동 가능한 통로
      • X : 장애물
  • park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
  • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
  • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
  • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
    • op는 다음 네 가지중 하나로 이루어져 있습니다.
      • N : 북쪽으로 주어진 칸만큼 이동합니다.
      • S : 남쪽으로 주어진 칸만큼 이동합니다.
      • W : 서쪽으로 주어진 칸만큼 이동합니다.
      • E : 동쪽으로 주어진 칸만큼 이동합니다.
    • 1 ≤ n ≤ 9

📌 입출력 예

추측) 

일단 현재 위치에 대한 배열을 저장 [열, 행] 기본 [0,0]

그리고 park 배열에서 S의 위치를 찾아 현재 위치를 갱신해 준다. 

그리고 routes를 for문으로 돌려 하나씩 빼와서 현재위치를 이동을 시키는 데

먼저 판별부터 한다.

1. E나 W면 현재 위치의 열에서 n만큼 E면 +, W면 -  시키고 해당 값(x1)이 park 인덱스 하나의 길이보다 길어지면 해당 routes는 cotinue로 바로 넘어감

2. N나 S면 현재 위치의 행에서 n만큼 S면 +, N이면 -  시키고 해당 값(y1)이 park 전체 길이보다 길어지면 해당 routes는 cotinue로 바로 넘어감

위의 2가지 판별이 모두 통과하면

이제 중간 장애물 판정을 해야함

위에서 길이 판별할때 저장해 놓은 값을 가지고 

1. E나 W면 park 해당 x번째 인덱스 값에서 현재 위치의 x값과 이동후 값인 x1값 문자열 순서 사이에 X가 포함되어 있으면 routes는 cotinue로 바로 넘어감

2. N나 S면 현재 위치의 y값과 이동후 값인 y1값 사이에 인덱스 값의 x번째 문자열에 X가 포함되어 있으면 routes는 cotinue로 바로 넘어감

이마저도 다 통과하면

현재 위치를 x1과 y1으로 변경하고 다음 routes로 넘어간다. 

소스코드) 

* 1차)  실패: 정확도 80점 

def solution(park, routes):
    now = [0,0]
    
    # 시작점 
    for i in range(0,len(park)):
        if 'S' in park[i]:
            now[0] = i                      # 행
            now[1] = park[i].index('S')     # 열
            
            
    x1 = y1 = 0
    # Route 판별
    for route in routes :
        
        # 공원 밖인지 판별
        if route[0] == 'E' :
            x1 = now[1] + int(route[2])
            if x1 > len(park[0])-1 :
                continue
        elif route[0] == 'W' :
            x1 = now[1] - int(route[2])
            if x1 < 0 :
                continue
        elif route[0] == 'S' :
            y1 = now[0] + int(route[2])
            if y1 > len(park)-1 :
                continue
        elif route[0] == 'N' :
            y1 = now[0] - int(route[2])
            if y1 < 0 :
                continue
                

        b_x = b_y = a_x = a_y = 0    
        # 장애물 판별
        if route[0] == 'E' or route[0] == 'W' :
            if now[1] > x1 :
                b_x = x1
                a_x = now[1]
            else :
                b_x = now[1]
                a_x = x1
                
            if 'X' in park[now[0]][b_x:a_x]:
                continue
            else :
                now[1] = x1
        else :  
            
            if now[0] > y1 :
                b_y = y1
                a_y = now[0]
            else :
                b_y = now[0]
                a_y = y1
            
            if 'X' in [ park[j][now[1]] for j in range(b_y,a_y) ]:
                continue
            else :
                now[0] = y1
                
    
    return now

* 2차) 성공

def solution(park, routes):
    now = [0,0]
    
    # 시작점 
    for i in range(0,len(park)):
        if 'S' in park[i]:
            now[0] = i                      # 행
            now[1] = park[i].index('S')     # 열
            
    x1 = y1 = 0
    # Route 판별
    for route in routes :
        
        # 공원 밖인지 판별
        if route[0] == 'E' :
            x1 = now[1] + int(route[2])
            if x1 > len(park[0])-1 :
                continue
        elif route[0] == 'W' :
            x1 = now[1] - int(route[2])
            if x1 < 0 :
                continue
        elif route[0] == 'S' :
            y1 = now[0] + int(route[2])
            if y1 > len(park)-1 :
                continue
        elif route[0] == 'N' :
            y1 = now[0] - int(route[2])
            if y1 < 0 :
                continue

        b_x = b_y = a_x = a_y = 0    
        # 장애물 판별
        if route[0] == 'E' or route[0] == 'W' : 
            if now[1] > x1 :
                b_x = x1
                a_x = now[1]
            else :
                b_x = now[1]+1
                a_x = x1+1
                
            if 'X' in park[now[0]][b_x:a_x]:
                continue
            else :
                now[1] = x1
        else :  
            if now[0] > y1 :
                b_y = y1
                a_y = now[0]
            else :
                b_y = now[0]+1
                a_y = y1+1

            if 'X' in [ park[j][now[1]] for j in range(b_y,a_y) ]:
                continue
            else :
                now[0] = y1
                
    return now

리뷰) 

1차에서 실패했던 관건은 X 가 어디에 있는지 판별하는 구역을 잘 파악했어야 했다는 점이었다.

현재 위치는 판별에서 제외했어야 했는데 ㅠ

특히 사방팔방 다 장애물이라 움직이지 못할 때 이 문제가 발생했다.

현재 위치를 포함 시켜 버리면서 S는 X가 아니다 보니 X판별할 때 OK X없음 해버리고 움직여버리는 사태가!

그래서 X판별할때 현재 위치를 제외하니 모두 통과했다

그리고 분명 더 좋은 방법이 있을거 같아 찾아보니 BFS로 푸는 방법이 있다고 한다. BFS를 공부해서 다시 풀어보는 걸로

📌 파이썬 으로 풀이

📌 문제 링크 :

📌 문제 설명 :

어느 학교에 페인트가 칠해진 길이가 n미터인 벽이 있습니다. 벽에 동아리 · 학회 홍보나 회사 채용 공고 포스터 등을 게시하기 위해 테이프로 붙였다가 철거할 때 떼는 일이 많고 그 과정에서 페인트가 벗겨지곤 합니다. 페인트가 벗겨진 벽이 보기 흉해져 학교는 벽에 페인트를 덧칠하기로 했습니다.

넓은 벽 전체에 페인트를 새로 칠하는 대신, 구역을 나누어 일부만 페인트를 새로 칠 함으로써 예산을 아끼려 합니다. 이를 위해 벽을 1미터 길이의 구역 n개로 나누고, 각 구역에 왼쪽부터 순서대로 1번부터 n번까지 번호를 붙였습니다. 그리고 페인트를 다시 칠해야 할 구역들을 정했습니다.

벽에 페인트를 칠하는 롤러의 길이는 m미터이고, 롤러로 벽에 페인트를 한 번 칠하는 규칙은 다음과 같습니다.

• 롤러가 벽에서 벗어나면 안 됩니다.
• 구역의 일부분만 포함되도록 칠하면 안 됩니다.

즉, 롤러의 좌우측 끝을 구역의 경계선 혹은 벽의 좌우측 끝부분에 맞춘 후 롤러를 위아래로 움직이면서 벽을 칠합니다. 현재 페인트를 칠하는 구역들을 완전히 칠한 후 벽에서 롤러를 떼며, 이를 벽을 한 번 칠했다고 정의합니다.

한 구역에 페인트를 여러 번 칠해도 되고 다시 칠해야 할 구역이 아닌 곳에 페인트를 칠해도 되지만 다시 칠하기로 정한 구역은 적어도 한 번 페인트칠을 해야 합니다. 예산을 아끼기 위해 다시 칠할 구역을 정했듯 마찬가지로 롤러로 페인트칠을 하는 횟수를 최소화하려고 합니다.

정수 n, m과 다시 페인트를 칠하기로 정한 구역들의 번호가 담긴 정수 배열 section이 매개변수로 주어질 때 롤러로 페인트칠해야 하는 최소 횟수를 return 하는 solution 함수를 작성해 주세요.

📌 제한 사항

• 1 ≤ m ≤ n ≤ 100,000
• 1 ≤ section의 길이 ≤ n
  • 1 ≤ section의 원소 ≤ n
  • section의 원소는 페인트를 다시 칠해야 하는 구역의 번호입니다.
  • section에서 같은 원소가 두 번 이상 나타나지 않습니다.
  • section의 원소는 오름차순으로 정렬되어 있습니다.

📌 입출력 예

추측) 

m 롤러 길이가 중요한 문제 인거 같다. 

일단 m이 1일때는 section 길이 만큼을 바로 반환

m이 1이 아닌 경우에는 

m 길이 안에 영역으로 들어오는 경우는 카운트 하지 않고 영역 밖으로 넘어가면 카운트를 하는 방식으로 하면 될 듯!

section 배열을 for문 돌려 일단 처음 수에서 카운트를 올린다. 

그리고 처음수를 저장해 그 다음수에서 처음수를 뺏을 때 m보다 작으면 카운트를 올리지 않고  m보다 큰 순간 처음수를 새로 갱신하고 카운트를 올린다. 

이걸 섹션 끝까지 반복하면 될듯하다. 

소스코드) 

* 1차) 성공!! 

def solution(n, m, section):
    answer = 0
    if m == 1 :
        return len(section)
    
    first_num = 0
    for i in range(0, len(section)) :
        if i == 0 : 
            first_num = section[i]
            answer += 1
        
        if m <= section[i] - first_num :
            answer += 1
            first_num = section[i]       
    
    return answer

리뷰) 

추측한대로 풀려서 매우 기분 좋음!