수테크📱⌚️👀

문제😂

bfs(V, E, R) {  # V : 정점 집합, E : 간선 집합, R : 시작 정점
    for each v ∈ V - {R}
        visited[v] <- NO;
    visited[R] <- YES;  # 시작 정점 R을 방문 했다고 표시한다.
    enqueue(Q, R);  # 큐 맨 뒤에 시작 정점 R을 추가한다.
    while (Q ≠ ∅) {
        u <- dequeue(Q);  # 큐 맨 앞쪽의 요소를 삭제한다.
        for each v ∈ E(u)  # E(u) : 정점 u의 인접 정점 집합.(정점 번호를 오름차순으로 방문한다)
            if (visited[v] = NO) then {
                visited[v] <- YES;  # 정점 v를 방문 했다고 표시한다.
                enqueue(Q, v);  # 큐 맨 뒤에 정점 v를 추가한다.
            }
    }
}

내 풀🦷

# 24444. 알고리즘 수업 - 너비 우선 탐색1
from collections import deque # 요거 안하고 그냥 stack으로 하면 에러 나요...
import sys  
input = sys.stdin.readline

def bfs(R, V): # V: 정점 개수, E 간선, R : 시작 정점
    global visited
    visited = [0] * (V+1)
    q = deque([R])   # deque = deque() => 비어있는 큐 만들기
    visited[R] = 1
    order = 1   # 몇번째인지 알기위해서 순서를 1로 초기화해주고
    while q:
        t = q.popleft() # pop(0)
        # num[t].sort()
        for i in num[t]:
            # for i in sorted(num[t]): #sorted를 쓸꺼면 이렇게!!!
            if visited[i] == 0:
                q.append(i)
                order += 1 # 찾을떄마다 순서를 1씩 더해준다
                visited[i] = order


N, M, R = map(int, input().split())
num = [[] for _ in range(N+1)]

for _ in range(M):
    v1, v2 = map(int, input().split())
    num[v1].append(v2)
    num[v2].append(v1)

for k in num:
    k.sort()

bfs(R, N)

for s in visited[1::]:
    print(s)

문제 풀면서 어려웠던 점...

1. 시간초과 => import collections import deque와 import sys로 해결!!

- deque와 stack과 다른 점들... 

• deque = deque() => 비어 있는 큐 만들어주기  (stack은 q = [])
• popleft() => 제일 첫 값 빼주기 (stack은 pop(0))

2. 오름차순으로 뽑아 입력받은것들을 오름차순으로 정렬 (나는 입력 받은 순 고대로 만들어서 계속 정답이 안 나왔다...)

• num[t].sort()
• for i in sorted(num[t])
• for k in num: k.sort() .... 등등 여러 방법이 있다(이차원 배열이라 쉽지않음..)

참고하면 좋을 개념들 ✍️

1) BFS(너비우선탐색)

: 그래프와 트리의 가까운 노드부터 탐색하는 알고리즘.. 큐의 자료구조를 이용

- 동작과정

• 탐색 시작 노드를 큐에 삽입하고 방문 처리
• 큐에서 노드를 꺼내 해당 노드의 인접 노드 중 방문하지 않은 곳을 큐에 삽입하고 방문처리
• 큐가 없어질 때까지 반복!!

def bfs(s, V): # 시작 정점 s, 마지막 정점 V
    # visited 생성 => 이 순서 기억하기!!!!!
    visited = [0] * (V + 1)
    # 큐생성
    q = []  # 이 타이밍에 q = [s] 해도 됩니당
    # 시작점 인큐
    q.append(s)
    # 시작점 방문 표시
    visited[s] = 1
    while q: # 큐에 정점이 남아있으면 계속 진행... (front != rear 라고도 사용가능!! 같으면 빈거니까
        t = q.pop(0) # 디큐, 앞에서 뽑아야겟쥬
        print(t)    # 방문한 정점에서 할일
        # 인접한 정점 중 인큐되지 않은 정점 w가 있으면
        for w in adj_l[t]:
            if visited[w] == 0:
                # w를 인큐, 인큐 되었음을 표시
                q.append(w)
                # visited[w] = 1
                visited[w] = visited[t] + 1 #### 최소거리를 구할 때 좋아용 ###
    # print(visited[1:])

저희 시험이 import를 사용할 수 가 없어가지구...

문제 풀때 deque를 쓰지 않아 생소한데요... 데크 쓰는 법은 👇👇

from collections import deque

def bfs(start):
    global graph, visited
    
    queue = deque([start]) # 시작점을 큐에 넣어줍니다
    visited[start] = True  # 방문 표시를 해줍니다
    
    while queue: # 큐에 남아있는 값이 없을 떄까지 반복!!
        v = queue.popleft() # 큐의 첫번째 값을 빼옵니다
        print(v, end = '') # 어떤 경로로 방문했는지 적어줍니다
        
        for i in graph[v]:  # v에 인접한 곳을 돌면서
            if not visited[i]: # 방문하지 않았다면
                queue.append(i) # 큐에 넣어주고
                visited[i] = True # 방문 표시를 해줍니다

bfs(1) # 1은 그냥 시작점 예를 1로 든거..

문제😂

내 풀🦷

# 4875. 미로
# 출발지에서 목적지에 도착하는 경로가 존재하는지 확인

# 사방 탐색
dx = [0, 1, 0, -1] # 범위 제대로 확인
dy = [-1, 0, 1, 0]
def miro(i, j):
    global result # 결과값 전역변수로 설정해주기
    visited[i][j] = True # 방문한 곳 true로 바꿔주기
    for k in range(4): # 사방탐색 진행
        di = i + dx[k]
        dj = j + dy[k] # 하나하나 신경써서 적기
        if 0 <= di < N and 0 <= dj < N and not visited[di][dj]:

            # 0이라 갈수 있는데 아직 방문을 안했다면 새롭게 그 지점을 다시 방문해야 하니까 재귀
            if arr[di][dj] == 0:
                miro(di, dj) # 재귀랄^^;;;;;

            # 3 도착하면 성공
            elif arr[di][dj] == 3:
                result = 1 # 결과값 성공으로 바꾸기
                break


T = int(input())
for tc in range(1, T + 1):
    N = int(input()) # 미로의 크기
    arr = [list(map(int, input().strip())) for _ in range(N)]
    # 방문 검사
    visited = [[False for _ in range(N)] for _ in range(N)]
    result = 0 # 결과값 (일단 실패)

    for i in range(N-1, -1, -1):
        for j in range(N-1, -1, -1):
            if arr[i][j] == 2:
                miro(i, j) # 함수에 시작점 넣어주기

    print(f'#{tc} {result}')

내가 잘 못 풀었던 점...

1. 사방 탐색 범위 확인!!! : 잘못 적었드래요.. 꼭 확인하고 적기;;;

2. Runtime error : strip()을 사용해 주어야 한다고 그러는데...

    우리 눈에는 안 보이지만 \n 이 포함 되어 있을지도 모른다고하네요....

    그리고 input()은 알아서 공백을 제거해주지만

    sys를 사용할 떄는 그런 기능이 없어서sys.stdin.readline().strip() 같이 무조건 써줘야 한데요!! 😵‍💫

참고함면 좋을 개념들 ✍️

1) 탐색

: 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정

 ex) DFS, BFS

2) DFS(깊이 우선 탐색)

• 스택 자료구조에 기초한다..
• 실재로는 스택보다는 재귀 함수를 이용하여 간결하게(?) 구현할 수 있다
• 시간 복잡도 : O(N)

# dfs & 재귀 함수
def dfs(v): # v : 시작점
    global visited, graphs  # 함수 안에서 만들어준게 아니라 안정성을 위해 전역변수로 설정해주었다
    visited[v] = True
    
    for i in graphs[v]: # 인접해 있는 곳 중에 
        if not visited[i]: # 방문을 안했다면
            dfs(i)  # 그 곳을 탐색!!
        
        else:
            continue # 이미 방문한 곳 패스 # 이 부분 안 적어줘도 된다
            
graph = [] # 그래프를 표현하는 인접 리스트(인접 행렬 어려움 ㅜㅜ)
visited = [] # 각 노드가 방문된 정보를 표현하는 1 차원 리스트(true, flase/ 0,1로 구문)

dfs(0)

 => 경로가 있는지 확인할 떄는 dfs 를 사용하는 것이 더 좋다고 하네요..

문제 😂

Forth라는 컴퓨터 언어는 스택 연산을 기반으로 하고 있어 후위 표기법을 사용한다. 예를 들어 3+4는 다음과 같이 표기한다.
 

3 4 + .
 

Forth에서는 동작은 다음과 같다.
 

숫자는 스택에 넣는다.

연산자를 만나면 스택의 숫자 두 개를 꺼내 더하고 결과를 다시 스택에 넣는다.

‘.’은 스택에서 숫자를 꺼내 출력한다.

Forth 코드의 연산 결과를 출력하는 프로그램을 만드시오. 만약 형식이 잘못되어 연산이 불가능한 경우 ‘error’를 출력한다.
 

다음은 Forth 연산의 예이다.
 

[입력]
 

첫 줄에 테스트 케이스 개수 T가 주어진다.  1≤T≤50
 

다음 줄부터 테스트 케이스의 별로 정수와 연산자가 256자 이내의 연산코드가 주어진다. 피연산자와 연산자는 여백으로 구분되어 있으며, 코드는 ‘.’로 끝난다.

나눗셈의 경우 항상 나누어 떨어진다.

[출력]
 

#과 1번부터인 테스트케이스 번호, 빈칸에 이어 계산결과를 정수로 출력하거나 또는 ‘error’를 출력한다.

내 풀🦷

# 4874. Forth

# 입력받기
T = int(input())
for tc in range(1, T + 1):
    # 여기서 문자로 받아서 나중에 숫자로 따로 바꿔줘야 함
    susik = input().split()
    # 마지막에 점이 있어서 미리 지워줌
    susik.pop()
    # 연산을 담아줄 리스트 만들기
    num = []
    # 결과값 1로 초기화, 0이면 에러로 출력, 1이면 리스트의 마지막 값 출력
    result = 1

    # 수식을 도는 동안
    for i in range(len(susik)):
        # 수식이 피연산자면
        if susik[i] not in ['+','-','*','/']:
            # 수식에 그 숫자를 정수로 바꿔서 넣어준다
            num.append(int(susik[i]))

        # 수식이 연산자면
        else:
            # 숫자가 두개 이상 남아있어야 연산자를 처리해 주는데 아니면
            # 맞는 수식이 아니니까 틀렸으므로 결과값을 0으로 바꿔준다
            if len(num) < 2:
                result = 0
                break

            else: # 리스트의 길이가 2 이상이면 맞는 수식이므로 진행
                n1 = num.pop() # 두가지 숫자를 뽑는거는 모든 과정에서 진행되므로 미리 뽑아줌
                n2 = num.pop()
                new = 0

                if susik[i] == '*':
                    new = n2 * n1
                    num.append(new) # 연산 후 다시 리스트에 넣어준다
                    # num.append(n2*n1) # => 이런식으로 바로 처리하는게 더 좋은 듯
                elif susik[i] == '+':
                    new = n2 + n1
                    num.append(new)
                elif susik[i] == '-':
                    new = n2 - n1
                    num.append(new)
                elif susik[i] == '/':
                    new = n2 // n1 
                    ####### 이떼 몫 연산자로 안해주면 나중에 .0이 나오는 케이스가 발생한다!!####
                    num.append(new)

    # 리스트의 길이가 1이 아니면 연산자와 숫자가 남아있거나
    # 아니면 아예 없어지는 틀린 수식이다
    if len(num) != 1:
            result = 0

    if result:
        print(f'#{tc} {num[-1]}')
    else:
        print(f'#{tc} error')

#####

이 문제 풀면서 2가지를 잘못했는데....

- 숫자를 정수로 안 받았으면서 나중에 int로 값을 넣지 않은 것..

- 나누기 연산자를 사용하면 딱 정수로 나눠 떨어지는 것이 아닌 경우도 발생하므로 // 몫 연산자를 사용해주어야 한다..

참고함면 좋을 개념들 ✍️

중위 표기법(infix notation)

: 연산자를 피연산자의 가운데 표기하는 방법

  ex) A + B (우리가 평소에 사용하는 방법)

후위 표기법(postfix notation)

: 연산자를 피연산자 뒤에 표기하는 방법

 ex) AB + (컴퓨터가 사용하는 방법)

후위 표기법의 수식을 스택을 이용해서 계산하기

1.  피연산자를 만나면 스택 push
2. 연산자를 만나면 필요한 만큼의 피연산자를 스택에서 pop 하여 연산하고, 연산결과를 다시 스택에 push
3. 수식이 끝나면, 마지막으로 스택을 pop하여 출력!!!

5
4 1 5 2 3
5
1 3 7 9 5

1
1
0
0
1

틀린 내 풀🦷

# 1920. 수찾기
import sys
input = sys.stdin.readline

N = int(input())
arr = list(map(int, sys.stdin.readline().split()))

M = int(input())
arr_2 = list(map(int, sys.stdin.readline().split()))
result = []

for j in range(M):
    one = []
    for i in range(N):
        if arr[i] == arr_2[j]:
            one.append(1)
            break
        else:
            one.append(0)

    # print(one)
    cnt = 0
    for k in one:
        if k == 1:
            cnt += 1
    if cnt >= 1:
        result.append(1)
    else:
        result.append(0)

for k in result:
    print(k)

구직구직하게 짜기 달인이 되버린 나,,,,

단계별 풀이로 안들어가고 성공률로 들어가서 안 풀어져 있는거 풀어가지고

어떤 방식으로 풀어야하는지 힌트(이차원 배열이다, 정렬이다, 이진탐색이다 이런거)가 없어서 어카지 하다가

찾아야할 값이 주어진 arr_2 리스트를 돌라면서 arr을 돌리는 완전 탐색으로 찾아서 있으면 더해주면 되겠다..

싶었고 무슨일로 인덱스 아웃오브레인지도 안나고 한번에 성공했는디.... 했는데.... 제출했는데...

했는데 시간초과가 나버렸다 ㅋㅋ 혹시나 몰라서 import sys로도 바꿔봤는데 실패....ㅜㅜ

수정된 내 풀🦷

백준에서 풀다가 막히면 질문게시판 들어가서 종종 힌트를 얻는데

나처럼 구질구질하게 푸는 사람이 없었고 ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

set을 사용하여 입력받아 시간을 적게 걸리게 하는 방법이나 이진 탐색을 사용하였다!!

그러고 보니 이진 탐색을 이용하면 되었는데 혼자서 브로노마스(무지성)으로 하고있었다....

그래서 먼저 해본 set() 으로 입력 받기 =>

N = int(input())
arr = set(map(int, input().split())) # 출력 시간을 줄이기 위해 set 받음

M = int(input())
arr_2 = list(map(int, input().split()))

for i in arr_2:
    if i in arr: print(1)
    else: print(0)

결과는 성공~~~~~

set을 자주 안 쓰다보니 어떤 부분에서 쓸지 몰랐는데

입력을 set으로 받아 사용한다는 점을 알게 되었다!!

이진탐색으로 풀은 내 풀🦷

또 다른 방법중에 하나인 바이너리 서치를 통한 방법도 많이 보여서 도전해 보았다~~

N = int(input())
arr = list(map(int, input().split()))
arr.sort() # 이진탐색은 정렬된 것들 탐색하는데 이 부분 기억을 못해서 무한 루프로 몇번 다녀왔다
M = int(input())
arr_2 = list(map(int, input().split()))

for i in arr_2:
    # 바이너리 서치 활용하기(이진탐색)
    result = False 
    start = 0 # 시작 인덱스
    end = N - 1 # 끝 인덱스

    while start <= end:
        mid = ((start + end) // 2) # 중간값의 위치에 해당하는 수와 목표 비교해 나감
        if i == arr[mid]: # 중간값과 목표값이 같다면
            result = True
            break
        elif i > arr[mid]:
            start = mid + 1
        else:
            end = mid - 1

    if result:
        print(1)
    else:
        print(0)

시험에도 나오기는 했지만 오랜만에 이진탐색을 사용해서 계속 틀린값이 나오고

무한루프로 잠시 먼나라이웃나라 다녀왔다....

중간값과 목표값을 비교하면서 시작점이 마지막점보다 넘어서면 종료되는 기저조건을 설정하였다!!!!

참고함면 좋을 개념들 ✍️

1) 이진 검색(Binary Search)

:  자료의 가온데에 있는 항목의 키 값과 비교하여 다음 검색의 위치를 결정하고 검색을 계속 진행하는 방법

 => 목적 키를 찾을 때까지 이진 검색을 순환적으로 반복 수행함으로써 검색 범위를 반으로 줄여가면서 보다 빠르게 검색을 수행한다

- 이진 검색을 하기 위해서는 자료가 정렬된 상태여야 한다(정렬이 아니라 뒤에 수가 앞에 수보다 커버리면 오바자나.. 찾을 수가 없음!!!!!! 주의!!!!!!!!1..)

- 검색 과정

1. 자료의 중앙에 있는 원소를 고른다
2. 중앙 원소의 값과 찾고자 하는 목표 값을 비교한다
3. 목표값이 중앙 원소의 값보다 작으면 자료의 왼쪽 반에 대해서 새로 검색을 수행, 크다면 자료의 오른쪽 반에 대해서 세로 검색을 수행
4. 찾고자 하는 값을 찾을 떄까지 1~3의 과정을 반복한다
5. 찾는다면 성공, 못 찾으면 실패

- 구현

• 검색 범위의 시작점과 종료점을 이용하여 검색을 반복 수행한다 => while의 종료 조건을 잘 설정하기
• 이진 검색의 경우, 자료에 삽입이나 삭제가 발생했을 때 배열의 상태를 항상 정렬 상태로 유지하는 추가 작업이 필요

# 이진 검색 알고리즘
def binarySweach(a, N, key):
	start = 0  # 시작점 
    end = N -1  # 종료점
    while start <= end:
    	middle = (start + end) // 2 # 몫으로 하는 이유 : 나누기 연산자를 사용하면 .0으로 float되걸랑
        if a[middle] == key: # 검색 성공
        	 return true
        elif a[middle] > key:
        	 end = middle - 1
        else:
        	start = middle + 1
    return flase # while 문을 다 돌았는데도 찾지못한다면 검색 실패

문제🤔

NxN 크기의 미로에서 출발지에서 목적지에 도착하는 경로가 존재하는지 확인하는 프로그램을 작성하시오. 도착할 수 있으면 1, 아니면 0을 출력한다.

주어진 미로 밖으로는 나갈 수 없다.

다음은 5x5 미로의 예이다.
 

13101

10101

10101

10101

10021

마지막 줄의 2에서 출발해서 0인 통로를 따라 이동하면 맨 윗줄의 3에 도착할 수 있는지 확인하면 된다.

[입력]
 

첫 줄에 테스트 케이스 개수 T가 주어진다.  1<=T<=50
 

다음 줄부터 테스트 케이스의 별로 미로의 크기 N과 N개의 줄에 걸쳐 미로의 통로와 벽에 대한 정보가 주어진다. 0은 통로, 1은 벽, 2는 출발, 3은 도착이다. 5<=N<=100

[출력]
 

각 줄마다 "#T" (T는 테스트 케이스 번호)를 출력한 뒤, 계산결과를 정수로 출력하거나 또는 ‘error’를 출력한다.

내 풀🦷

# 4875. 미로
# 출발지에서 목적지에 도착하는 경로가 존재하는지 확인
# 마지막 줄의 2에서 출발, 0인 통로를 따라 이동하면 맨 윗줄의 3에 도착하는지
# 사방 탐색
dx = [0, 1, 0, -1] # 범위 제대로 확인
dy = [-1, 0, 1, 0]
def miro(i, j):
    global result # 결과값 전역변수로 설정해주기
    visited[i][j] = True
    for k in range(4):
        di = i + dx[k]
        dj = j + dy[k] # 하나하나 신경써서 적기
        if 0 <= di < N and 0 <= dj < N and not visited[di][dj]:
            # 탐색안했고 0이면 재귀
            if arr[di][dj] == 0:
                miro(di, dj)
            # 3 도착하면 성공
            elif arr[di][dj] == 3:
                result = 1 # 결과값 성공으로 바꾸기
                break

T = int(input())
for tc in range(1, T + 1):
    N = int(input()) # 미로의 크기
    arr = [list(map(int, input().strip())) for _ in range(N)]
    # 방문 검사
    visited = [[False for _ in range(N)] for _ in range(N)]
    result = 0 # 결과값

    for i in range(N-1, -1, -1):
        for j in range(N-1, -1, -1):
            if arr[i][j] == 2:
                miro(i, j) # 함수에 시작점 넣어주기

    print(f'#{tc} {result}')

벽이 없는곳을 피해서 가야한다고라고라고라파덕 혼자 이러고 있다가..

뭔가 오늘 시험에서 사용한(?) 델타 + dfs에서 배운 개념들 + 재귀 다 쓰면 해결할 듯(?)으로 생각해보았습니다아 🤔

중간에 실수한 부분들 😵‍💫

- 델타 범위 (취중 코딩해서 그런가 잘못 적음;;;;

- dj = i + dk[k] (역시 잘못 적음....)

- 입력 받을 때 strip() 써주지 않아서 런타임에러 발생.... => 사실 아직도 잘 모르겠음 왜인지...

strip()은 공백을 제거하면 되는거자나요??

split()을 안 적어주면 된다 아닌가요??

아시는 멋진분의 댓글 기다리고 있겠습니다...

참고함면 좋을 개념들 ✍️

1) 델타를 이용한 2차 배열 탐색

: 2차 배열의 한 좌표에서 4방향의 인접 배열 요소를 탐색하는 방법(8방도 가능)

arr[0...N-1][0...N-1] # N * N 배열
di = [0, 1, 0, -1] # 하, 우, 상, 좌
dj = [1, 0, -1, 0]
for i in range(N):
	for j in range(N): # 여기까지는 우리가 흔히아는 이차원 배열
    	for k in range(4): # 델차를 이용
        	ni = i + di[k]
            nj = j + dj[k]
            if 0 <= ni < N and 0 <= nj < N: # 범위에 안에 들어있는 인덱스면...
            	f(arr[ni][nj]) # 이 점을 기준으로 더해주든 개수를 세주던 더 나아가던 무궁무진한 문제들이 나올 수 있다

2) 재귀를 활용한 dfs

: 재귀를 활용함으로써 쉽게 dfs를 구현할 수 있다(내용은 안쉬움... 이해하기 힘들었음..)

def dfs(v):
    global visited
    # print(v, "-", end='')
    visited[v] = True # 이거에 해당하면 진행
    # v 노드에서 갈 수 있는 노드를 확인 (인접한 노드)
    for u in graphs[v]:
        if visited[u] == True:  # 방문을 했다면
            continue
        # 방문을 하지 않았다면 방문을 진행
        else: # u가 visited안에 들어있지 않다면 u를 다시 dfs 해주면 된다
            dfs(u)  # 모든 요소가 다 돌아가서 모든 요소가 트루로 바뀌면 끝난다.

오늘은 싸피에서 스택에 관해 배웠다

복습으로는 백준에 있는 스택 문제 풀기..

다 풀고 싶었는데 어제 풀다 만 브루투토스에 체스가 너무 오래 걸려서 2문제 남았다...

내일 해야지;;;;; 다음에 체스도 시간나면 적어보는걸로

서론이 너무 길었고 오늘 소개해 드릴 문제는 백준 9012. 괄호입니다!!!

오늘 swea에서도 비슷한 문제를 풀었는데 조금 쉬운 버전입니다 ^^

그럼 고 🌟🌟

6
(())())
(((()())()
(()())((()))
((()()(()))(((())))()
()()()()(()()())()
(()((())()(

NO
NO
YES
NO
YES
NO

# 9012. 괄호 - 오늘 나를 지겹게 한 ^^ : 오늘 학교에서 이거 비슷한 문제 한 2시간 머리 싸맸거덩요...
stack = [] 						# 괄호를 담을 리스트를 만들어 줬습니다
def gal(text): 					# 함수로 만드는게 조금 편해져서 만들었습니다
    for ch in text: 			# 텍스트 내부를 순회하면서
        if ch == '(': 			# 문자'('가 있으면
            stack.append(ch)	# 문자를 리스트에 추가해줍니다
        elif ch == ')':			# 문자')'가 있으면
            if len(stack) == 0: # 리스트의 길이를 확인해줘야 하는데 0이라면 열린기호가 없어서 틀린 text입니당
                return 'NO'		# 고로 NO를 반환해 줬어요
            else:				# 길이가 0이 아니라면...
                if stack[-1] == '(': 	# 스택의 마지막에 (가 있으면 
                    stack.pop()			# 마지막 (를 삭제하고
                    continue			# 계속해서 다음 문자를 확인해 줬습니다
                else:
                    return 'NO'			# 하지만 열린기호 '('가 아닌 다른게 들어있으면 틀린 문장이겠죠

    if len(stack) == 0: # 결론적으로 ')'가 나올떄 '('을 지웠으므로 쌍이 맞는다면 
    					#스택에 남아있는게 없어야 하니까
        return 'YES'	# YES를 반환합니다
    else:
        return 'NO' 	# 아니면 'NO'

import sys						# 스택 문제를 풀고 처음으로 시간초과가 떠서 알아왔습니다.. 
T = int(sys.stdin.readline())
for _ in range(T):
    bracket = sys.stdin.readline()
    stack = []  ########사실 저 위에 함수가 아니라 이부분이 틀렸는데요....
    #스택을 할때마다 초기화해줘야해요.... 틀린 값이 들어있다면 다음 사례도 틀리거등요..... 기초적인 부분이니까 꼭 기억하기!!!!

    result = gal(bracket)
    print(result)

오랜만에 백준 풀이로 돌아왔습니다 ~~~~

풀다가 제 이름 나와서 반가웠걸랑여 ^ ___________- ^

1 3 -1 4 1 7

2 -1

2 5 8 3 -4 -11

-1 2

내풀 🦷

# 19532. 수학은 비대면 강의입니다
# 연립방정식의 x, y 값을 구하라
a, b, c, d, e, f = map(int, input().split())
x = -999
y = -999
answer = []
for x in range(-999, 1000):
    for y in range(-999, 1000):
        if a * x + b * y == c and d * x + e * y == f:
            answer.append(x)
            answer.append(y)

result = ' '.join(map(str, answer))
print(result)

너무 무식하게 브루트 포스를 잘 적용해야 했다고 해야하나요 ㅋㅋㅋㅋㅋㅋㅋㅋㅋ 환장..

-999부터 999까지 중에 있다고 해서 한번 넣어봤어라 ㅋㅋㅋㅋㅋㅋ

x, y에 해당하는 값을 answer 리스트에 넣어줬고요

리스트의 대괄호 없이 나와야 하니까 조인함수를 통해 풀어줬습니다...

다른 분들 풀이를 보니까 

x와 y를 a, b, c, d, e, f를 사용해서 한쪽으로 분배를 한 후에 

for 문 없이 바로 푸셨더라구요 !!

한 수 배웠습니다👍👍

2차원 배열에서 오늘 수업 복습용으로 스터디원이 추천해줘서 풀어봤는데..

재밌는(?) 문제였습니다 🤣🤣🤣🤣🤣🤣🤣

오늘 배웠던 브루트 포스에 관해 잠시 소개해 드리며는...

고지식한 알고리즘(Brute Force)

  : 문자열을 처음부터 끝까지 차례대로 순회하면서 패턴 내의 문자들을 일일이 비교하는 방식으로 동작

 +) 고지식한 패턴 검색 알고리즘의 시간 복잡도

  : 최악의 경우 시간 복잡도는 텍스트의 모든 위치에서 패턴을 비교해야 하므로 O(MN)이 됨

  M : 찾을 패턴의 길이 / N : 전체 텍스트의 길이

# 브루토 포스 함수로 구현하기
def BruteForce(p, t):
    M = len(p)
    N = len(t)
    for i in range(N-M+1):
        for j in range(M): # 패턴의 길이만큼 순회
            # 패턴 매칭
            if t[i + j] != p[j]:
                break  # 매칭 실패
            else:
                # 검색 성공
                return i  # t인덱스 반환

    # 검색 실패
    return -1

p = 'is'
t = 'This is a book~!'

result = BruteForce(p, t) 
print(result) # 2

다음에 또 재밌는 문제 가지고 돌아올께영

6단계를 마무리하면 실버를 받을 수 있다는 말을 들었는데 드디어 6단계를 시작하게 되었습니다 ㅎㅎㅎ

어제 스터디 하시는분이 2차원 배열 엄청 어렵다고 하셨는데,,, 일단 실버부터 달고 생각하겠습니다 

오늘 소개 문제는 팰린드놈...아니고 롬인지 확인하기 입니다 😂😂

level

1

팰린드롬이 뭐가 있는지 알고 문제 이름만 보고 겁먹고 들어갔는데 

생각보다 크게 어려운 문제는 아니더라구요 ㅎㅎㅎ

거꾸로가 똑같으면 1을 출력?? 거꾸로 슬라이싱 하면 될거 같은데?? 왜 심화지?? 생각이 들었습니다 🤔

# 슬라이싱
word = input()
p_word = word[::-1]
if word == p_word:
    print(1)
else:
    print(0)

결과는 🥕 통과 입니다 ㅎㅎㅎ

여러 방법으로 풀어봐야 담주 월말평가때 도움 될거 같아서 2가지 방법으로 더 풀어봤습니다!!!

# reversed 함수 사용
word = list(input())
if word == list(reversed(word)):
    print(1)
else:
    print(0)

두번짼 reverse 함수를 사용했습니다!!! 

이번 결과도 🥕🥕 통과 입니다~~~

# 숏코딩 도전
word = input()
print(1 if word == word[::-1] else 0 )

마지막은 숏코딩 순위권 도전(?)을 위해 삼항 조건식을 써보았는데요... 

숏코딩 순위권은 택도 없었지만 ㅋㅋㅋㅋ 앞에있는 코드길이 보다는 반으로 줄일 수 있었습니다~~~

마지막으로 삼항 조건식에 대해 간략히 설명 드리자면❣️

삼항 연산자라고도 하는 삼항 조건식은 한줄의 코드로 간단한 if-else 논리를 표현하는 간결한 방법입니다 <value_if_true> if <condition> else <value_if_false>

삼항 연산자 예제
x = 10
result = "Even" if x % 2 == 0 else "Odd"
print(result)  # Output: "Even"