시도했던 틀린 답

def solution(prices):
    stack = []
    n = len(prices)
    answer = [0]*n
    for i in range(n):
          while stack :
            j = stack.pop()
               if prices[i] >= prices[j]:
                  answer[j] += 1
            else:
                  if prices[j] != 10001:
                        answer[j] += 1
                    prices[j] = 10001     
      stack = [j for j in range(i+1)]

우선 시간 상관없이 답이 나오도록 짜보았다 i가 0일 경우 stack에 0을 넣음 그 뒤로는 stack에 prices[i]보다 앞에 있는 원소들을 모두 넣은 뒤 하나씩 꺼내어서 prices[i]와 비교하여 만약 prices[i]가 크다면 answer에 1씩 더하고 stack 원소가 클 경우, answer에 1을 더하고 다음 prices 원소들과 비교할 수 없도록 stack 원소가 최대값인 10000보다 큰 수로 바꾼다. prices 배열 값 변경, for문으로 stack 배열을 만드니깐 시간초과가 나왔다. stack 배열을 따로 만들지 않고 prices배열만을 사용하여 풀 수 있도록 해봄

from collections import deque 
def solution(prices):
    prices = deque(prices)
    n = 0
    answer = [0]*l
    while prices:
        price = prices.popleft()
        if not prices : break
        for i in prices:
            if i >= price :
                answer[n] += 1
            else : 
                answer[n]+=1
                break
        print(answer)
        n+=1       
    return answer

price의 가장 왼쪽 원소를 popleft()로 삭제하고 while문으로 뒤에 원소들과 하나씩 비교하여 만약 같거나 작다면 answer에 1을 더하고 크다면 break로 while문을 벗어나도록 함

def solution(numbers):
    answer = [-1]*len(numbers)
    stack = []
    for i in range(len(numbers)):
        while stack and numbers[stack[-1]] < numbers[i]:
            answer[stack.pop()] = numbers[i]
        stack.append(i)      
    return answer

처음엔 아무생각없이 2중 for문으로 돌리니깐 시간복잡도가 무지막지하게 커져서 시간초과가 나옴 힌트보고 스택사용해서 겨우 풀었다.

def solution(n):
    if n == 1 or n == 2 :
        return n
    data = [1,2]
    for i in range(2,n):
        data.append(data[i-1]+data[i-2])

    return data[-1]%1234567

재귀적으로 푸는데 계속 시간초과가 나오길래 다른 풀이방법을 찾아보니 피보나치 수를 구하는거였음 바로 답이 나오길래 허무했다 정말 문제패턴 찾는게 중요하구나 느낌

def solution(s):   
    data = []

    for i in s :
        if i == ')' and data:
            data.pop()
        else : data.append(i)

    return True if not data else False

스택으로 구현 자꾸 런타임에러가 나길래 한참 고민했는데 스택이 빈 경우를 체크하지 않아서 생기는 에러였다.😞

def solution(s):
    s = s[2:-2].split('},{')
    data = []

    for i in s:
        n = list(map(int, i.split(',')))
        data.append(sum(n))

    data.sort()

    return  [ data[i] if i == 0 else data[i]-data[i-1]  for i in range(len(data)) ]

def solution(arr, divisor):
    answer = [i for i in arr if i % divisor == 0]
    return [-1] if len(answer) == 0 else sorted(answer)

리스트 표현식을 얼마나 잘 쓸 수 있는지가 중요한 듯

Lv1

def solution(players, callings):
    l = 0
    name = ''
    dic1 = {}
    dic2 = dict()

    for i in range(len(players)):
        dic1[i] = players[i]
        dic2[players[i]] = i


    for i in callings :
        l = dic2[i] # i 위치가져오기
        name = dic1[l-1]
        dic1[l-1], dic1[l] = dic1[l],dic1[l-1]
        dic2[i],dic2[name] = dic2[name], dic2[i]


    answer = list(dic1.values())
    return answer

lv1이길래 쉽게 swap 사용해서 풀었더니 시간초과가 나왔다. 최대길이가 callings가 1,000,000 players가 50,000 이기 때문에 시간 복잡도를 중요하게 생각하고 풀어야했다. index함수를 for문이랑 함께 썼더니 시간복잡도가 O(NM)으로 엄청 커져버렸다. 힌트들을 보니 딕셔너리 사용을 해야한다고 해서 어찌저찌 풀어봄 시간복잡도 다시 공부해야지...

객체 기반의 스크립트 프로그래밍 언어

웹사이트상에서 동적 상호작용성을 제공할 수 있는 완전한 동적 프로그래밍 언어

비동기 처리

동기(Synchronous) :  모든 작업이 동시에 일어난다. 요청과 결과가 동시에 일어남
비동기(Asynchronous) : 하나의 작업이 끝날 때까지 다른 작업은 기다린다. 요청과 결과가 동시에 일어나지 않음

사용방법 <script src="js파일위치/js파일명"></script>

📑 변수 선언 

 1. var

전역 범위 또는 함수 범위로 지정된다. 즉 함수 밖에서 선언되면 전역 변수, 함수 내에서 선언되면 지역변수
변수 선언과 동시에 초기화가 이루어짐
변수의 중복 선언, 재할당이 가능

👉 선언 방법

/* 선언 후 초기화 */
var n;
n = 123

/* 선언과 초기화 같이 */
var n = 123

/* 여러 변수를 한번에 선언 */
var n= 123, m = 456, 7 = 'js]

👉 중복선언

var n = 'hello'
var n = 'hi'

👉 재할당

var n  = 'hello'
n = 'hi'

2. let

변수가 선언된 블록 내에서만 사용 가능
재할당만 가능, 중복선언은 X 
각각 다른 범위에서 중복선언은 가능

👉 선언 방법

/* 선언 후 초기화 */
let n;
n = 123

/* 선언과 초기화 같이 */
let n = 123

/* 여러 변수를 한번에 선언 및 초기화 */
let n= 123, m = 456, 7 = 'js]

👉 재할당, 중복선언

/* 재할당 가능 */
let n ='1234'
n = '567'

/* 중복 선언 불가 */
let n = 'hello'
// let n = 'hi'  불가능 
if(true){
    let n = 'hi'  //다른 범위이므로 선언 가능
    }

3. const

** ▪ 상수 ( 변하지 않는 값)**

재할당과 중복선언이 불가능하다.

const n = '12345'
// const n = '67890' 중복선언x
// n = '1123123' 재할당 x

👉 배열, 객체의 경우 주소값을 할당받기 때문에 요소나 속성의 추가가 가능하다.

변수가 가질 수 있는 자료형  :  문자열, 숫자, Boolean, 배열, 객체

📑 주석 

// 이 줄만 주석처리

/* 여기부터
   ~~~
   여기까지 
   주석처리 */

📑 연산자

👉 문자열 연산자 + 

문자열을 연결한다.

1) 문자열 + 문자열 var n = 'hi'; var m = 'hello'; hihello 2) 문자열 + 숫자 var n = 'hi'+9; hi9

** 👉 산술 연산자** 

+ 더하기

- 빼기

* 곱하기

/ 나누기

% 나머지

** : 거듭제곱

** 👉 증감연산자 **

++ :  1증가

--   : 1감소

*👉 대입연산자 = *

let n = 'hi';

👉 비교 연산자

👉 논리 연산자

👉 삼항 연산자

(조건식)? 참일 경우 반환할 값  : 그 외 반환할 값

ex)
var n = 1;
(n > 2 )? console.log('2보다 크다'):console.log('2보다 작다')
> 2보다 작다

📑 제어문

👉조건문

◼ if문

 if(조건식){  
 조건식이 참일 경우 수행할 실행문  
 }

▪ if ~ else문

 if(조건식){  
 조건식이 참일 경우 수행할 코드  
 }else{  
 조건식이 거짓일 경우 수행할 코드  
 }

 if(조건식1){  
  조건식1이 참일 경우 수행할 코드  
 }else if(조건식2){  
 조건식1이 거짓이고 조건식2이 참일 경우 수행할 코드  
 }else{  
    조건문이 거짓일 경우 수행할 코드  
 }

◼ switch문

 switch(변수){  
     case 1 :  
         변수의 값이 1일 때 실행되는 코드  
     break;  
     case 2 :  
         변수의 값이 2일 때 실행되는 코드  
     break;  
     case 3 :  
         변수의 값이 3일 때 실행되는 코드  
     break;  
     deafult :  
          해당하는 case가 없을 경우 실행되는 코드  
     break;

👉 반복문

** ◻ for문**

 for(초기식;  조건식; 증감식 ){  
    조건식이 참일 경우 실행되는 코드  
 }

 ---

 ex) 1부터 10까지 출력하는 for문  
 for( var i = 1 ; i < 11 ; i++){  
     console.log(i)  
 }

◻ while문

 while(조건식){  
 조건식이 참일 경우 실행되는 코드  
 }  

 ---

 ex) 1부터 10까지 출력하는 while문  
 var n = 1;  
 while(n <11){  
    console.log(n);  
    n++;  
    }

◻ do~while문

 do{  
 실행할 코드  
 }while(조건식)

👀 while문과 do~while문의 차이? while문은 조건식 참이면 실행하지만
do while은  실행문이 조건식보다 앞에 위치하기 때문에 조건식이 거짓이라도 무조건 1번은 실행함

◻ for in문

for(변수 in 객체){

}

◻ for of문

for(변수 of 객체){

}

📑 함수(functions)

** 👉함수 선언**

** 1️⃣ Function 생성자**

function 함수명([매개변수1, 매개변수2, ...매개변수N]){

        실행 코드(statements)
}

생성된 함수는 함수객체로 일반적인 기능 외에 모든 속성, 메서드, 객체의 행위특성 을 갖는다.

호이스팅 영향 o 

매개변수(parameter) : 함수로 전달되는 인수를 함수에서 사용하기 위해 사용하는 변수
인수(argument) : 함수가 호출될 때 전달되는 값

**2️⃣ 함수 표현식(function expression)**

함수 리터럴로 생성한 함수를 변수에 할당한 표현식

 let 이름 = function [함수명](매개변수1,매개변수2, ... 매개변수N){
 실행 코드(statements) 
 };

3️⃣ 화살표 함수(arrow functions)

(매개변수1, 매개변수2,...매개변수N)) => { 실행 코드 }

(매개변수1, 매개변수2,...매개변수N)) => 표현식

매개변수가 1개이면 괄호가 없어도 됨

매개변수 => { 실행 코드 }

매개변수가 없으면 괄호가 있어야 됨

() => { 실행 코드 }

🔷 함수 리터럴(function literal)
     이름없이 몸체만 있는 익명 함수, 변수와 동일한 문법과 구조를 사용해 함수를 생성

👀 IIFE(Immediately Invoked Function Expression) : 즉시 실행 함수

▪ 정의와 동시에 실행되는 함수

 ( function() {
          실행 코드 
})();

첫 번째 괄호 () : 익명함수(Anonymous Function) 두 번째 괄호 ()  : 즉시 실행 함수를 생성하는 괄호. 이 괄호를 통해 자바스크립트 엔진(JavaScript engine)은 함수를 즉시 해석해서 실행한다.

익명함수(Anonymous Function) : 리터럴 방식의 함수

📑 이벤트

이벤트소스
이벤트리스너
이벤트객체
이벤트핸들러
이벤트흐름

순열

numbers = []
def Permutation(array, depth, n, k):
  # array 배열 depth 깊이 n:배열길이 k뽑아낼 숫자개수
    if depth == k:  # 뽑아낼 숫자개수만큼 깊이
        numbers.append(int(''.join(array[:k])))
    for i in range(depth, n):
        array[depth], array[i] = array[i], array[depth]
        Permutation(array, depth + 1, n, k)
        array[depth], array[i] = array[i], array[depth] # 배열 되돌리기

def PrimeN(n):
    for i in range(2,n):
        if n % i == 0:
            return False
    return True

def solution(number):
    array = list(number)
    for i in range(1,len(array)+1):
        Permutation(array, 0, len(array), i)
    s = set(numbers)

    #소수 구하기
    cnt = 0
    for i in s:
        if i == 0 or i == 1:
            continue
        if PrimeN(i):
            cnt+=1    
    return cnt

  ╰┳┳╯    ╰┳┳╯

   o 　    　　o

 o   　   　　o

    ╰┈┈╯

  o ╭━━━━━╮　 o

      ┈┈┈┈

　　o     　　o

한시간 동안 눈물 닦고 바로 쓰는 따끈따끈한 후기 망함 망해서 더 적을게 없음 문제는 오〰〰〰〰〰할만한데? 했는데 왜 대체 왜 답이 안나옴 긴장해서 머리는 안돌고 정말 손에 땀띠 나는줄.. 생각하면 슬프니깐 이제 그냥 잊어버려야지,, 더 슬픈건 끝나고 다시 풀어보니 20분컷이더라..

T= int(input())
for test_case in range(1, T+1):
    score = list(map(int, input().split()))
    for i in range(len(score)):
        if score[i] < 40 :
            score[i] = 40
    print('#'+str(test_case), sum(score)//len(score))

난이도 D1

T = int(input())
for test_case in range(1, T + 1):
    n = int(input())
    mlist = []
    m = (n-1)//2
    sumn = 0
    cnt = 1
    for i in range(n):
        s = ''
        p = str(input())
        mlist.append(list(p))

        p1,p2 =0,0
        if i == 0 or i == n - 1:
            sumn += int(mlist[i][m])
        elif i > m:
            p1 = list(map(int, mlist[i][cnt:m]))
            p2 = list(map(int, mlist[i][m+1:m+1+len(p1)]))
            sumn += sum(p1+p2)+int(mlist[i][m])
            cnt += 1
        else:
            p1 = list(map(int, mlist[i][m - i:m]))
            p2 = list(map(int, mlist[i][m+1:m + i +1]))
            sumn += sum(p1+p2)+int(mlist[i][m])
    print('#' + str(test_case), sumn)

T = int(input())
# 여러개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
for test_case in range(1, T + 1):
    n = int(input())
    s = 0
    for i in range(n):
        x, y = map(float, input().split())
        s += x*y
    print("{:.6f}".format(s))

소수점 N자리까지 출력 "{:.Nf}".format(숫자) round(숫자)반올림 maht.ceil 올림 math.floor 내림 math.trunc 소수점 버리기

👉 Java

import java.util.Scanner;
import java.io.FileInputStream;
import java.util.Arrays;

class Solution
{
    public static void main(String args[]) throws Exception
    {

        Scanner sc = new Scanner(System.in);
        int T;
        int cnt;
        T=sc.nextInt();
        int[] num;
        for(int test_case = 1; test_case <= T; test_case++)
        {
            cnt = 0;
            int n = sc.nextInt();
            num = new int[n];
            for (int i = 0; i < n ; i++){
                num[i] = sc.nextInt();
               // System.out.println(integer[i]);
            }
            Arrays.sort(num);
            for ( int i = 0; i< n; i++){
                if( i == n-1){
                    cnt += num[i]*2+1;
                }else{
                    cnt += num[i]+1;
                }
            }

            System.out.println('#'+String.valueOf(test_case)+' '+cnt);

        }
    }
}

👉 python

T = int(input())

for test_case in range(1, T + 1):
    N = int(input())
    mlist = list(map(int, input().split()))
    mlist.sort()
    cnt = 0
    for i in range(len(mlist)):
        if i == N-1 :
            cnt+= mlist[i]*2+1
        else :
            cnt+=mlist[i]+1

    print('#' + str(test_case), cnt)

nlist = [2,3,5,7,11]
T = int(input())

for test_case in range(1, T + 1):
    N = int(input())
    print('#' + str(test_case), end=' ')
    cnt, x = 0, 0

    for i in range(len(nlist)):
        if N % nlist[i] == 0:
            x = nlist[i]
            while N % x == 0 :
                x *= nlist[i]
                cnt+=1
            N //= (nlist[i]**cnt)
        print(cnt, end=' ')
        cnt = 0
    print()

T = 10
for test_case in range(1, T+1):
    N, M = map(str, input().split()) # N : 문자열의 총 수  M : 문자열
    toggle = True
    while toggle:
        s = ''
        for i in range(len(M)-1): 
            s = M[i]
            if s == M[i+1] :
                M = M.replace(M[i:i+2],'')
                break
            elif i == len(M)-2 :
                toggle = False

    print('#'+str(test_case),M)

T = int(input())
for test_case in range(1, T+1):
    N, M = map(int, input().split()) # N : 배열크기 NXN  M : 파리채크기 MxM
    mlist = []
    max = 0
    for i in range(N):
        mlist.append(list(map(int, input().split())))
    for i in range(N-M+1):
        for j in range(N-M+1):
            s = 0
            for k in range(M):
                for l in range(M):
                    s += mlist[i+k][j+l]
                    # print(s)
            if max < s : max = s
    print('#'+str(test_case),max)

4중 for문이라니... 이렇게 풀면 안될 것 같지만 우선 당장 풀 수 있는 방법으로 해봄 테스트 케이스 5개가 자꾸 틀리길래 고생했는데 파리채 행렬이 1번 덜 움직여서 였다. +1하니깐 답나옴ㅠ

T = int(input())
for test_case in range(1, T+1):
    print('#'+str(test_case))
    N = int(input())
    nlist = [] # 회전한 배열 저장 할 리스트
    mlist = [] # 입력 받은 배열 저장 리스트
    slist = [['0']*3 for _ in range(N)]
    for _ in range(N):
        mlist.append(list(map(str, input().split())))
    for i in range(3): # 90 / 180 / 270 . 3번 회전
        mlist = list(map(list, zip(*mlist[::-1]))) # 배열 거꾸로 만든 후 행렬 바꾸기
        for j in mlist:
            nlist.append(j)
    nlist = nlist[::-1] # 배열 순서 바꾸기 deque 사용시 안바꿔도됨
    for i in range(3):
        for j in range(N):
            s = nlist.pop() # 가장 뒤쪽부터 뽑아냄
            slist[j][i] = ''.join(s)
    for i in range(N):
        print(' '.join(slist[i]), end=' ')
        print()

배열 행렬 바꾸기 list(map(list, zip(*mylist))) 배열 거꾸로 출력 list[::-1] # 문자열도 가능

T = int(input())
for test_case in range(1, T+1):
    print('#'+str(test_case))
    N = int(input())
    mlist = [[0]*N for _ in range(N)]
    p1,p2 = 0,0
    d = 0
    chk = []
    for i in range(1,N*N+1):
        if mlist[p1][p2] == 0  :
            mlist[p1][p2] = i
        chk.append(i)
        # 방향 알기
        if d == 0 : #오
            p2 +=1
            if p2 == N or mlist[p1][p2] in chk :
                p2 -=1
                p1 +=1
                d = 1
        elif d == 1 : #아래
            p1 += 1
            if p1 == N or mlist[p1][p2] in chk :
                p1 -= 1
                p2 -= 1
                d = 2
        elif d == 2 : # 왼
            p2 -= 1
            if p2 < 0 or mlist[p1][p2] in chk :
                p2 +=1
                p1 -=1
                d = 3
        elif d == 3 : #위
            p1 -= 1
            if p1 < 0 or mlist[p1][p2] in chk:
                p1 +=1
                p2 +=1
                d = 0

    for i in mlist:
        for j in i:
            print(j, end=' ')
        print()

무식하게 풀어봄 dfs이용해서 다시 풀어보기

day = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

T = int(input())
for test_case in range(1, T + 1):
    n1, n2, m1, m2 = map(int, input().split())
    d1 = sum(day[:n1-1])+n2
    d2 = sum(day[:m1-1])+m2
    print(d2-d1+1)