스프링부트로 프로젝트를 하면서 공부를 하려고합니다. 김영한님의 스프링 입문 강의로 시작합니다.

1.  IDE 준비하기

기존에 IntelliJ를 사용중이기에 따로 설치하지 않고 바로 이용합니다. 개인 상황에 맞추어 IntelliJ나 Eclipse를 설치합니다. 요즘 추세로는 IntelliJ가 편리하여 주로 사용된다고 합니다.

2. 자바 11 설치하기

프로젝트에서 Java 11을 사용하기 위해서 JDK 11 버전을 다운받습니다.

저는 Window 환경이라 아래의 블로그를 참고하여 설치를 하였습니다. 개인 컴퓨터 환경에 따라 설치를 진행하시면 됩니다.

- (참고) https://crazykim2.tistory.com/478

3. Springboot 프로젝트 만들기

- Spring Initializr에서 프로젝트를 만들어줍니다. 

- https://start.spring.io/

- 위, 사이트는 스프링부트를 기반으로 스프링 프로젝트를 만들어주는 사이트입니다.

- Maven / Gradle :  필요한 라이브러리를 관리하고, 빌드 라이프 사이클을 관리해주는 도구

- 요즘은 Gradle 을 주로 사용한다고 합니다.

- 언어와 버전은 위와 같이 설정하였습니다. 

라이브러리를 추가합니다.

- Spring Web: 웹 프로젝트를 진행하기 때문에 추가

- Thymeleaf: html을 만들어주는 템플릿 엔진

- GENERATE 하여 다운로드 받고 인텔리제이에서  프로젝트를 실행하여줍니다.

4. 프로젝트 실행

프로젝트를 열면 라이브러리들을 받느라 시간이 소요됩니다. 잠시 기다리면서 JDK와 Bjild and run 설정을 확인해줍니다.

- Build and run을 위처럼 IntelliJ IDEA로 설정해 줍니다.

- Project Settings 에서  SDK  버전을 확인해 줍니다. 저는 18로 설정되어있어 11로 변경해주었습니다.

- 메인함수를 실행하고 localhost:8080에 아래와 같은 화면이 뜨면 성공입니다.

이 글은 김영한 님의 스프링 입문 강의를 복습하기 위해 작성된 글 입니다.

참고: https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

이 글에서는 Java의 등장배경을 살펴보고, 자바 코드의 실행과정과 JVM 동작원리 및 개념을 살펴보려고 합니다.

JAVA 등장배경

JAVA는 가전제품 내에 탑재해 동작하는 프로그램을 위해 개발한 언어라고 합니다. 개발 당시에는 UNIX 기반의 배경을 가지고 있었기 때문에 C/C++ 특성상 여러 하드웨어를 커버하기에는 같은 기능의 소스를 각 하드웨어에 맞게 작성해야하는 번거로움이 있어 JAVA를 개발하게 되었다고 합니다.

이러한 배경에서 탄생한 언어인 JAVA는 어느 하드웨어(CPU)던, 어느 운영체제(OS)이던 상관없이 컴파일된 코드(바이트코드)가 플랫폼에 독립적인 특징을 갖습니다. 즉, 어느 플랫폼이던 작성한 소스를 변경할 필요 없이 다 실행시킬 수 있다는 장점을 갖게됩니다.

이러한 특징은 JVM(Java VIrtual Machine)이 있기 때문에 가능합니다. 그렇다면 JVM(Java Virtual Machine)의 어떠한 기능 때문에 OS에 독립적으로 실행시킬 수 있는지 자바 코드의 실행과정을 통해 알아보겠습니다. 

JAVA 코드의 실행과정

JVM 자바 가상 머신을 단순하게 말하면 컴파일된 코드(바이트코드)를 실행시켜주는 가상의 컴퓨터라고 생각하면 이해하기 쉽습니다. JVM 을 파악하기 전에 소스코드가 JVM에 전달되어 실행되는 과정을 먼저 정리해보겠습니다.

[컴파일 타임 환경]

1. 자바 클래스 파일 (.java) 을 자바 컴파일러를 통해 자바 바이트 코드 (.class)로 컴파일합니다. 

[런타임 환경]

2. 컴파일된 바이트코드를 JVM의 클래스로더(Class Loader)에게 전달합니다. 

3. 클래스 로더는 동적로딩(Dynamic Loading)을 통해 필요한 클래스들을 로딩 및 링크하여 런타임 데이터 영역(Rumtime Data area), 즉 JVM의 메모리에 올립니다.

* 클래스 로더 세부 동작
1. 로드: 클래스 파일을 가져와서 JVM의 메모리에 로드
2. 검증: 자바 언어 명세(Java Language Specification) 및 JVM 명세에 명시된 대로 구성되어 있는지 검사
3. 준비: 클래스가 필요로 하는 메모리를 할당 (필드, 메서드, 인터페이스 등)
4. 분석: 클래스의 상수 풀 내 모든 심볼릭 레퍼런스를 다이렉트 레퍼런스로 변경
5. 초기화: 클래스 변수들을 적절한 값으로 초기화 (static 필드)

4. 실행엔진(Execution Engine)은 JVM 메모리에 올라온 바이트 코드들을 명령어 단위로 하나씩 가져와서 실행. 이때 실행 엔진은 두가지 방식으로 변경

1. 인터프리터: 바이트 코드 명령어를 하나씩 읽어서 해석하고 실행. 
    - 하나하나의 실행은 빠르나, 전체적인 실행속도가 느린다는 단점이 있음
2. JIT 컴파일러(Just-In-Time Compiler): 인터프리터의 단점을 보완하기 위해 도입된 방식으로 바이트 코드 전체를 컴파일하여 바이너리 코드로 변경하고 이후에는 해당 메서드를 더이상 인터프리팅 하지 않고, 바이너리 코드로 직접 실행하는 방식. 
    - 하나씩 인터프리팅하여 실행하는 것이 아니라 바이트 코드 전체가 컴파일된 바이너리 코드를 실행하는 것이기 때문에 전체적인 실행속도는 인터프리팅 방식보다 빠름

[참고 자료]

- https://steady-snail.tistory.com/67

- https://aljjabaegi.tistory.com/387

- https://gyoogle.dev/blog/computer-language/Java/%EC%BB%B4%ED%8C%8C%EC%9D%BC%20%EA%B3%BC%EC%A0%95.html

프로그래밍이란 무엇인가?

프로그램은 어떤 값을 입력하고, 결과를 제공해주는 것이다.

프로그램을 만들려면 언어가 필요하다.

사람과 컴퓨터 사이에 소통하기 위한 언어를 '프로그래밍 언어'라고 하며 Java도 프로그래밍 언어 중 하나이다.

객체지향 프로그래밍 언어란 무엇인가?

자바와 같은 언어를 객체지향 언어라고 한다.

지금까지 대부분의 프로그래밍 언어들은 현실과 동떨어져 있었다. 하지만 객체지향 언어의 등장으로 현실 세계를 프로그램으로 표현할 수 있게 된다. 

class로 현실에 있는 사물 혹은 추상적인 것을 표현하게된다.

클래스란 무엇인가?

자바의 가장 작은 단위이다.

상태(state)와 행동(behavior)을 가지고 있다.

클래스 안에 변수를 선언하면 이를 상태라 하고 메소드를 선언하면 행동이라고 볼 수 있다.​

메소드란 무엇인가?

클래스 내에서 행동에 속하는 부분으로 특정한 작업을 수행하는 단위이다.

코드로 이해하기

/*형식*/
[접근 제어자] class [클래스 이름] {
	
	[접근 제어자] [리턴 타입] [메소드 이름] ([매개 변수]) {
	// 중간 내용
	}
}

public class Calculator{
	public int add(int num1, int num2){
    	 int sum;
         sum = num1 + num2;
         return sum;    
    }
}

Intro

코딩테스트를 준비하다보면 아래의 경우를 고려하여 완전 탐색해야하는 문제를 쉽게 만날 수 있습니다. 

1) 서로 다른 N개중 순서를 생각하지 않고 M개를 선택하는 경우의 수

2) 서로 다른 N개중 순서를 생각하지 않고 중복을 허용하여 M개를 선택하는 경우의 수 

3) 서로 다른 N개중 순서를 생각하고 M개를 선택하는 경우의 수

4) 서로 다른 N개중 순서를 생각하고 중복을 허용하여 M를 선택하는 경우의 수

따라서, 위의 경우를 효율적으로 탐색하기 위해서 시간 복잡도와 모듈을 활용한 탐색 방법을 정리해 두려고 합니다.

저는 주로 python3를 사용하여 ps하기 때문에 itertools 패키지 사용법과 함께 정리하겠습니다.

위의 경우를 순서대로 알아보겠습니다.

1) 조합 (combiantions)

시간복잡도: nCr = n!/(n-r)!r!

from itertools import combinations

nums = [1,2,3]
for i in range(1, len(nums)+1):
	print(list(combinations(nums,i)))
    
# [(1,), (2,), (3,)]
# [(1, 2), (1, 3), (2, 3)]
# [(1, 2, 3)]

2) 중복 조합

시간복잡도: nHr=n+r−1Cr = (n+r-1)! / r!

from itertools import combinations_with_replacement

nums = [1,2,3]
for i in range(1, len(nums)):
	print(list(combinations_with_replacement(nums, i)))
    
# [(1,), (2,), (3,)]
# [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]

3) 순열

시간복잡도: nPr = n!/(n-r)!

from itertools import permutations

nums = [1,2,3]
for i in range(1, len(nums)):
	print(list(permutations(nums, i)))
    
# [(1,), (2,), (3,)]
# [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

4) 중복 순열

시간복잡도: n∏r = n^r

from itertools import product

nums = [1,2,3]
for i in range(1, len(nums)):
	print(list(product(nums, repeat = i)))
    
# [(1,), (2,), (3,)]
# [(1, 1), (1, 2), (1, 3),(2, 1), (2, 2), (2, 3),(3, 1), (3, 2), (3, 3)]

문제보러가기

- https://school.programmers.co.kr/learn/courses/30/lessons/43238

풀이

• 이 문제는 입국심사를 기다리는 사람이 1,000,000,000 명인 경우를 고려해 이진 탐색 방법을 떠올려야한다.
• 10억인 경우를 완전탐색 할 수 없다. 이진 탐색을 할경우 O(log2(N))으로 약 30 번만에 탐색이 가능하다.
• 우리가 찾으려는 시간은 주어진 심사대를 모두 사용하여 가장 빨리 입국심사를 마무리할 수 있는 시간이다.
• 따라서, 가장 빠른 시간을 찾기 위해서는 각 심사대에서 처리한 사람수의 합이 주어진 n과 같아지는 경우를 찾아야 한다.
• 이를 코드로 구현하면 boared += mid//time으로 식을 세우고, 이를 만족하는 경우를 찾아 이진 탐색을 하면 된다.

코드

def solution(n, times):
    answer = 0

    left = 0
    right = max(times)*n

    while left <= right:
        mid = (left + right) // 2
        boarded = 0
        for time in times:
            boarded += mid//time
        if boarded >= n:
            right = mid - 1
        else:
            left = mid +1
    answer = left
    return answer

문제보러가기

- https://school.programmers.co.kr/learn/courses/30/lessons/84512

풀이

• 시간복잡도: 중복조합 2**i (i=1~5) => 32임으로 모든 경우 탐색 가능
• 순서를 구하기 위해 먼저 모음 길이가 다른 모음 단어를 모두 조합하여 단어장에 추가하여줍니다.
• 모듬은 중복될 수 있으며, 길이가 1~5까지의 단어임으로 파이썬 itertools의 product를 사용하여 중복 조합을 하였습니다.
• 모든 단어를 구한 후 단어장을 오름차순으로 정렬하고, 주어진 word의 순서를 반환합니다.

코드

from itertools import product

def solution(word):

    alphabet = ['A','E','I','O','U']
    all_word = []
    for i in range(1,6):
        for p in product(alphabet,repeat=i):
            p = ''.join(p)
            all_word.append(p)

    all_word.sort()

    return all_word.index(word)+1

문제보러가기

- https://tech.kakao.com/2021/01/25/2021-kakao-recruitment-round-1/

풀이

• 기출을 통해 느낀바로는 카카오는 시간 혹은 기간을 사용한 문제를 좋아하는 것 같습니다.
• 이 문제 또한 주어진 String 값을 시간(초)으로 변환하고, 주어진 포맷으로 반환하여야 합니다.
• 따라서 strTosec, secTostr 함수를 구현하여 주어진 값을 활용할 수 있도록 했습니다.
• 또한, 주어진 범위가 00:00:01 이상 99:59:59 임으로 100시간 즉 360,000초 입니다.
• 즉, 영상 시간의 초 단위 사이즈로 배열을 잡는데 무리가 없음을 알 수 있습니다.
  • view = [0 for _ in range(play_sec+1)]
• logs를 순회하며 i초에 시청하는 사람수를 업데이트 하고 구간합을 구하는 방법을 우선적으로 떠올리게 됩니다.
• 하지만 그렇게 구현을 하게되면 logs를 순회하며 업데이트를 할때O(len(logs)시청시간) = 300,000*360,000 => 약 1000억으로 시간복잡도를 통과하지 못하게 된다.
• 따라서, 구간의 시작(+1), 구간의 끝(-1)을 len(logs) 만큼 표시하고 view[i] = view[i] +view[i-1]으로 한번에 구간별 시청자 수를 업데이트 하게되면 O(len(logs) + 영상시간) = 300,000 +360,000 으로 개선할 수 있다.
• 여기서 수학적 인사이트가 필요합니다.
• 최종적으로 광고를 가장 많이 시청한 구간을 찾기위해서 우리는 i 시간에서 i+adv_sec 사이의 시청자수가 가장 많은 구간을 찾아야 합니다.
• 이를 위해서, 위의 식을 다시 한번 사용하여 모든 구간의 시청자를 누적합니다.
• 그리고, view[i] - view[i-adv_sec] (구간 누적 시청자) 가 가장 많은 시간을 탐색합니다.

코드

def strTosec(s):
    return int(s[:2])*3600 + int(s[3:5])*60 + int(s[6:]) 

def secTostr(n):
    return f'{str(n//3600).zfill(2)}:{str((n%3600)//60).zfill(2)}:{str((n%3600)%60).zfill(2)}'

def solution(play_time, adv_time, logs):

    play_sec = strTosec(play_time)
    adv_sec = strTosec(adv_time)

    view = [0 for _ in range(play_sec+1)]

    for log in logs:
        start_sec = strTosec(log[:8])
        end_sec = strTosec(log[9:])
        view[start_sec] +=1
        view[end_sec] -=1

    for i in range(1, len(view)):
        view[i] += view[i-1]

    for i in range(1, len(view)):
        view[i] += view[i-1]

    max_view = view[adv_sec-1]
    answer = 0

    for i in range(adv_sec, play_sec):
        tmp = view[i]-view[i-adv_sec]
        if max_view < tmp:
            max_view = tmp
            answer = i-adv_sec+1

    return secTostr(answer)

문제보러가기

- https://tech.kakao.com/2021/01/25/2021-kakao-recruitment-round-1/

풀이

• 주어진 쿼리 조건에 따라 정보를 완전탐색하면 정확성 TC는 통과합니다.
• 하지만,효율성 TC를 통화하기 위해서는 기존 탐색의 시간복잡도 O(len(query)len(info)) = 100,00050,000 => 50억 에서 개선이 필요합니다.
  • 탐색의 시간 복잡도를 줄이기 info의 모든 카테고리를 key로 갖고 int[]를 value로 갖는 딕셔너리를 만들고, info의 점수를 list에 담아줍니다.
  • 여기서, 점수 조건을 탐색하는 방법으로 이진탐색을 사용하여 O(len(qeury)log2(len(info)) = 100,00016 => 160만으로 시간 복잡도를 개선할 수 있습니다.
  • 애초에 주어진 조건을 읽고 100,000과 50,000를 보고 효율성 TC를 통과할 수 있는 접근법을 떠올리고 접근해야하는 문제였다는 것을 알 수 있습니다.
• 이진 탐색을 직접 구현할 수도 있지만, 파이썬에서는 bisect 모듈을 사용할 수 있습니다.
• query의 점수 이상인 사람들을 탐색하여야 함으로 disect_left를 사용해 lower boud 이진 탐색을 하면 조건을 만족하는 사람의 수를 구할 수 있습니다.
  
  

코드

from bisect import bisect_left
from itertools import combinations
from collections import defaultdict

def solution(info, query):
    answer = []
    dic = defaultdict(list)
    for i in info:
        i =i.split()
        condition = i[:-1]
        score = int(i[-1])
        for n in range(5):
            case = list(combinations([0,1,2,3],n))
            for c in case:
                tmp = condition.copy()
                for idx in c:
                    tmp[idx] = '-'
                key = "".join(tmp)
                dic[key].append(score)

    for value in dic.values():
        value.sort()

    for q in query:
        q = q.replace("and", "").split()
        target_key = "".join(q[:-1])
        target_score = int(q[-1])
        cnt = 0
        if target_key in dic:
            target_list = dic[target_key]
            idx = bisect_left(target_list, target_score)
            cnt = len(target_list)-idx
        answer.append(cnt)

BOJ_2217 로프 -Python3

문제분석

1. 관찰
- n개의 로프 중 k 개의 로프를 선택하는 모든 경우를 탐색한다.
- K개의 로프중 '가장 w가 작은 로프'에 '로프개수'를 곱한값. 즉, '최소값*로프개수'이 최대 감당 가능한 무게가 된다.

이를 시간 복잡도를 고려해 구현하면
내림차순으로 로프를 정렬하여
'k번째 로프(최소값)*k개의 로프'로 '최대 감당 가능 무게'를 갱신해 값을 구한다.  

2. 복잡도
- O(N) = 1만 가능

3. 자료구조
- 로프 int[]

해결코드

import sys
si = sys.stdin.readline

n = int(si())
ropes = [int(si()) for _ in range(n)]
ropes.sort(reverse=True)
values = []

for i in range(n):
    values.append(ropes[i]*(i+1)) # 최소값*로프개수 
print(max(values))

BOJ_1463 1로 만들기 -Python3

문제분석

1. 관찰
- 입력: 1000000 => 백만
- N%3 == 0 => nxt = N / 3
- N%2 == 0 => nxt = N / 2
- nxt = N - 1
- 출력: N을 1로 만드는 연산의 최소 횟수 

- 3 으로 나누기, 2로 나누기, 1빼기 순으로 진행할 수로 연산을 줄일 수 있다.

구하려는 값은 N을 1로 만드는 연산의 최소 횟수이다.
N이 1이 될때연산의 횟수는 이전의 연산에 영향을 받는다.
=> dp   1~N까지 기억하여 연산, cnt는 1,2,3이 되는데 필요한 연산 횟수를 초기화 하고 N이 될때 필요한 연산을 1에서 부터 N이 될때 까지 보텀엄 방식으로 연산한다.
dp  : 0 1 2 3 4 5 6 7 ...
cnt : 0 0 1 1 ... 점화식

보텀업 방식으로 연산

2. 복잡도
- O(N) = 10**6 >> 10만 가능

3. 자료구조
- dp : int[]

해결코드

import sys
si = sys.stdin.readline

N = int(si())
dp = [0 for _ in range(N+1)]  

for n in range(2,N+1): # 2부터 N이 될때 까지 필요한 연산횟수 리턴
    # 1을 더하는 방식 2,3을 곱하는 방식 연산 횟수 비교하여 초기화
    if n%3==0 and n%2==0: 
        dp[n] = min(dp[n-1], dp[n//2], dp[n//3])+1
    elif n%3==0 and n%2!=0:
        dp[n] = min(dp[n-1], dp[n//3])+1
    elif n%3!=0 and n%2==0:
        dp[n] = min(dp[n-1], dp[n//2])+1
    else:
        dp[n] = dp[n-1] + 1 # dp[2], dp[3] 각각 연산횟수 1,1로 초기화됨
print(dp[N]) 

배운점

다이나믹 프로그래밍은 
1. 큰 문제를 작은 문제로 나눌 수 있다.
2. 작은 문제에서 구한 정답은 그것을 포함하는 문제에서도 동일하다.
는 규칙을 만족하는데

이 문제를 계속 고민하다보니 

1을 만들기 위한 최소연산 횟수는 이전의 연산 횟수를 구하는 것의 반복임을 발견하게 되었다.

맨 처음에는 dp 배열을 연산에서 어떻게 활용하여야 하나 고민되었는데,
문제에서 구하려는 값이 N을 1로 만드는데 필요한 최소연산 횟수 임으로 
N+1길이의 dp 배열에서 연산횟수를 기록하여 연산을 할 수 있다는 것을 이해하였다.

[BOJ_2164 카드2 -Python3](https://www.acmicpc.net/problem/2164

문제분석

1. 관찰
- queue 에서 두개를 빼서 첫번째 장은 버리고, 두번째 장은 뒤로 보낸다.
- 마지막 한장인 경우 출력한다.

2. 복잡도
- O(n) = 500000 >> 50만 가능

3. 자료구조
- 카드 순서 : int queue

해결코드

import sys
from collections import deque
si = sys.stdin.readline

N = int(si())
Q = deque([i for i in range(1,N+1)])

while Q:
    first = Q.popleft()
    if not Q:
        print(first)
        break
    second = Q.append(Q.popleft())

BOJ_2864 5와 6의 차이 -Python3

문제분석

1. 관찰
- 5를 5나 6으로 보고, 6을 5나 6으로 본다.
- 최소값: 6을 5로 바꾼경우
- 최대값: 6을 5로 바꾼경우

2. 복잡도
- O(len(A)+len(B)) = 7+7 >> 매우가능

3. 자료구조
- 5,6 의 자리수 check: int[]

해결코드

import sys
si = sys.stdin.readline

A,B = map(list,si().strip().split())
check_a = [0 for _ in range(len(A))]
check_b = [0 for _ in range(len(B))]

for i,v in enumerate(A):
    if v=='5' or v=='6':
        A[i]=0
        check_a[i]=1

for i,v in enumerate(B):
    if v=='5' or v=='6':
        B[i]=0
        check_b[i]=1

min_a = int("".join(map(str,A)))+5*int("".join(map(str,check_a)))
max_a = int("".join(map(str,A)))+6*int("".join(map(str,check_a)))

min_b = int("".join(map(str,B)))+5*int("".join(map(str,check_b)))
max_b = int("".join(map(str,B)))+6*int("".join(map(str,check_b)))

print(min_a+min_b, max_a+max_b)

BOJ_5585 거스름돈 -Python3

문제분석

1. 관찰
- 500, 100, 10, 5, 1 로 거스름돈을 받는다.
- 1000엔을 냈을 때 받는 잔돈의 개수를 구해야한다.
- 거스름돈 개수가 가장 적은 경우에 개수를 출력한다.

- 거스름돈이 가장 적은 경우는
- 큰돈부터 차례대로 값을 채워나가는 경우이다

2. 복잡도
- 사칙연산 

3. 자료구조
- 거스름 최소경우 : int[]

해결코드

import sys
si = sys.stdin.readline

pay = int(si())
m = 1000-pay

payback = [m//500,m%500//100,m%500%100//50,m%500%100%50//10,m%500%100%50%10//5,m%500%100%50%10%5]
print(sum(payback))

BOJ_10162 전자레인지 -Python3

문제분석

1. 관찰
- 3개의 버튼
- 300초, 60초, 10초
- A,B,B를 눌러 T초가 되도록하는 최소버튼 조작의 경우를 출력한다.

2. 복잡도
- O((T*T*T)//(300*60*10)) = (10000*10000*10000)//(300*60*10) >> 약 천만 가능

3. 자료구조
- 조합: int[]

해결코드

import sys
si = sys.stdin.readline

T = int(si())
flag = float('inf')
ans = [0,0,0]

for i in range(T//300+1):
    for j in range(T//60+1):
        for k in range(T//10+1):
            if 300*i + 60*j +10*k == T:
                flag = min(flag, i+j+k)
                if flag == i+j+k: # 가장 작은 경우 정답리스트 업데이트
                    ans[:]=[i,j,k]

if flag==float('inf'):
    print(-1)
else:
    print(*ans)

배운점

브론즈 4 문제인데 왜 이렇게 어렵게 풀었나 싶어서, 다른 코드를 살펴보았다.
다른 코드를 보고나니 내가 for문의 상한선으로 지정한 부분이 최소값이 된다는 사실을 알게됐다.
loop을 돌릴 필요가 없었다 ㅎㅎ

추가로, 보고서 감탄한 코드를 남긴다.
리스트 뒤에 조건문을 붙인 형식으로 출력을 했는데, 처음 보는 문법이라 신기했다.
해당 문법은 찾아봐야겠다.

참고코드

n=int(input());a=n//300;n%=300;b=n//60;n%=60;print(*[[-1],[a,b,n//10]][n//10==n/10])

BOJ_1120 문자열 -Python3

문제분석

1. 관찰
- 길이가 다른 두 문자열의 길이를 같게 만들면서 차이를 최소로한다.
- A,B 가 길이가 같도록 만든다

- case1) A, B 길이가 같다.
- case2) A가 들어갈 수 있는 모든 경우를 탐색하여 차이가 가장 적은 경우 출려한다.


2. 복잡도
- O((len(B)-len(A))*len(A)) = 50*50 >> 가능

3. 자료구조
- ans : float -> int
- 두 문자: str[]

해결코드

import sys 
si = sys.stdin.readline

a_list, b_list = map(list, si().strip().split()) 
a_len, b_len = len(a_list), len(b_list)
ans=float('inf')

if a_len == b_len:
    tmp = 0
    for i in range(a_len):
        if a_list[i]!=b_list[i]:
            tmp+=1
    ans = tmp
else:
    tmp = 0
    for i in range(b_len-a_len+1):
        for j in range(a_len):
            b_tmp = b_list[i:i+a_len]
            if a_list[j] != b_tmp[j]:
                tmp += 1
        ans = min(tmp, ans)
        tmp=0
print(ans)