pado0711.log

[Do it! 알고리즘 코딩테스트 파이썬 편] 1주차

lVlina — Sun, 1 Mar 2026 23:44:33 +0900

[Do it! 알고리즘 코딩테스트 파이썬 편] 의 1주차 동안 학습한 내용을 정리하였습니다!

1. 코딩테스트의 핵심 : 시간복잡도를 고려한 알고리즘 선택

시간 복잡도란?

: 주어진 문제를 해결하기 위한 연산 횟수!

1초 : 2,000만 번 ~ 1억 번의 연산

(일반적인 파이썬 프로그램 기준!)

시간 복잡도를 정의하는 유형 3가지
- 빅 - 오메가 : ‘최선의 경우’의 연산 횟수
- 빅 - 세타 : ‘보통의 경우’ 의 연산 횟수 (최선 - 최악의 케이스의 절반)
- 빅 - 오 : ‘최악의 경우’ 의 연산 횟수

1-1 시간복잡도 표기법 알아보기

코테에서 빅-오 표기법을 사용해야 하는 이유

→ 다양한 테스트 케이스를 수행해 모든 케이스를 통과해야만 하므로, 판단시 최악의 케이스를 염두에 둬야 한다!

빅 - 오 표기법의 시간 복잡도

데이터 크기 (N) 의 증가에 따른 성능(수행 시간)ㅇ

효율 제일 좋음 O(logN)

:	O(N)
:	O(NlogN)
:	O(N^2)
:	O(2^n)
제일 느림	O(N!)

1-2 시간 복잡도 활용하기

문제 000: 수 정렬하기
- 버블 정렬의 시간 복잡도: O(n^2)
- 병합 정렬의 시간 복잡도: O(nlogn)
  - 시간 제한 2초 (= 1초 2,000만 번 기준, 2초에 4,000만 번 )
  - 40,000,000
- 입력N개의 줄에 숫자 주어짐 ( |N| ≤ 백 만 번 ) - 수는 중복되지 않음
- 1번째 줄 부터 ~ N개의 줄에 오름차순 정렬한 결과를 1줄에 1개씩 출력한다
N 개의 수가 주어졌을 대, 이를 오름차순 정렬하는 프로그램을 작성하시오

연산 횟수 계산 방법

연산 횟수 = 알고리즘 시간 복잡도 n값에 데이터의 최대 크기를 대입하여 도출함

알고리즘 적합성 평가

: 데이터의 크기(N)를 단서로 사용해야하는 알고리즘 추측 가능

버블 정렬 = (1,000,000)^2 = 1,000,000,000,000 (약 1조) > 40,000,00 → 부적합 알고리즘!
병합 정렬 = $1000000\log_{2}{1000000}$ $\approx$ 200,000,000 < 40,000,00 → 적합! 알고리즘$\log_{2}{10} \approx 3.322$
[참고!]

시간 복잡도 바탕으로 코드 로직 개선하기

Step1. 가장 먼저, 코드의 시간 복잡도를 도출한다

→ 그러려면 시간복잡도 도출 기준을 알아야 함!

도출 기준 고려해야한다!

상수는 시간 복잡도 계산에서 제외한다코드에 반복문이 3개가 각각 있어서 연산 횟수가 3N이 되더라도,
상수를 무시하고 둘 다 시간 복잡도는 O(n) 으로 같음!
→ 반복문 하나의 연산 횟수는 N번
가장 많이 중첩된 반복문의 수행 횟수가 시간 복잡도의 기준이 된다이중 for문 1개로 인한 N^2 이다!
→ 일반 for문이 10개, 이중 for 문이 1개 있다고 하면, 여기에서의 시간 복잡도는

Step2. 연산이 가장 큰 부분을 찾아서 연산에 더욱 효율적인 구조로 수정!

2. 코드의 논리오류 잡는 법: 디버깅

2-1. 디버깅이 중요한 이유

디버깅이란

debugging : 프로그램에서 발생하는 문법 오류나 논리 오류를 찾아 바로잡는 과정!

문법 오류는 컴파일러가 자동으로 찾아줌, 주로 논리 오류를 찾기 위함이다!

디버깅은 코딩 테스트에 필요한 기술이고, 그냥 알아 두기만 하면 되는 것이 아니라, 문제를 풀면서 반드시 해야하는 과정이다!

방법

코드에서 디버깅하고자 하는 줄에 중단점(breakpoint)을 설정한다
IDE의 디버깅 기능을 실행하면, 코드를 1줄씩 실행하거나 , 다음 중단점까지 실행 가능!
(이 과정에서 추적할 변숫값도 지정 가능!), 변수의 값 변화 따라가면서 파악하기
변수값 이외에도 원하는 수식을 입력해 논리 오류 파악 가능!

2-2. 디버깅 활용 사례 살피기

오류 점검방안

1. 변수 초기화 오류를 범하지 않았는지 체크

→ 모든 변수가 정상적으로 초기화 되고 있는지, 디버깅을 이용해 확인해보기

2. 반복문 인덱스 범위 넘어가지 않았는지 체크

→ 반복문에서 반복 범위를 잘못 지정하거나,

비교 연산자를 잘못 사용하는 경우

배열 인덱스가 0부터 시작하는 사실을 간과하거나,

반복문을 N까지 반복하도록 설정해야 하는데, 비교 연산자를 잘못 입력하여 N-1 까지 반복하도록 설정하는 때도 있다

반복문을 사용할 때 마다, 범위와 시작 인덱스를 꼼꼼하게 확인하고,

혹시 모를 입력 실수를 대비해 디버깅하는 습관을 들일 것!

3. 잘못된 변수 사용 체크

4. 파이썬 자동 형 변환 체크

파이썬에서의 나누기는 / 연산자와, // 연산자 두 가지 이다!

/ 연산: 나눗셈의 결과값을 float 형으로 출력 → 소수점의 결과까지 보여준다!
// 연산: 나눗셈을 한 결괏값을 int 형으로 출력 → 몫의 결과만 보여준다!
% 연산: 나눗셈을 한 후 나눈 나머지 값을 보여준다!

Chapter 2 목표: 다양한 알고리즘에 관련된 핵심 이론과, 이를 바탕으로 실전 문제를 해결하는 방법 알아보기

미리 보는 코딩 테스트 오답 노트

목표: 문제 풀이에서 자주 실수하는 유형, 팁 으로 미리 익혀두기!

1. 시간 초과의 원인을 찾아 해결하기

해결 방법 1. 풀이 로직의 시간 복잡도 허용 범위 다시 점검하기

문제 풀이를 설계 할 때,

해당 방식이 시간 복잡도를 고려하여 제한 시간 범위 내에 들어가는지를 먼저 체크하고 들어가야함!

→ 시간 복잡도가 너무 높다면 풀이 알고리즘 자체를 수정해야할 필요가 있다

해결 방법 2. 입/출력 최적화!

입출력 최적화 방법:sys.stdin.readline() 과 sys.stdout.write()를 활용하면 처리 속도를 크게 향상시킬 수 있다!
input() , print() 대신,
이걸 쓰면 얼만큼 시간을 단축시킬 수 있는지?
- 1,000,000개의 정수 입출력 시간 차이 비교 표방식 입력 속도(초) 출력 속도(초) 총 소요 시간(초)
  
  input()과 print() 1.8 1.2 3
  
  sys.stdin.readline()과 sys.stdout.write() 0.3 0.3 0.6
- → 총 소요시간에서 큰 차이가 생긴다! (실제 환경에 따라 달라질 순 있음)
각각의 작동 원리 차이[비교]
- input() 은 호출될 때 마다 한 줄을 읽어 → 끝의 개행 문자를 제거한 문자열을 반환
- (숫자 변환 등 추가 파싱은 직접 처리해야함!)
- print()는 기본적으로 출력 내용을 버퍼에 모았다가 상황에 따라 비운다
- → 반복 호출이 많으면 작은 단위의 잦은 쓰기로 인해 성능이 저하될 수 있음!
입출력 데이터의 양이 많아지면, 큰 성능 차이가 발생할 수 있기 때문에!

sys.stdin.readline() 은 입력 버퍼에서 한 줄 전체를 그대로 읽음
→ 대량 입력에서 더 빠른 성능을 낼 수 있다!
sys.stdout.write() : 개행 문자를 자동으로 붙이지 않음!(문자열만 출력할 수 있으므로, 정수는 str() 로 변환하여 출력!)
→ 여러 출력을 모아 한 번에 출력하면 큰 속도향상 가능!

2. 인덱스에 의미 부여하여 풀어 보기

인덱스의 역할

몇 번째 데이터인지 나타내는 역할
인덱스를 순서가 아니라, 해당 숫잣값 자체에 의미를 부여하여 사용하는 방식!
→ 해싱 개념을 적용하자!

인덱스에 해싱 개념 적용

적용 예시A[1] : A라는 배열의 1번 인덱스의 값을 나타낼 수도 있지만,1이라는 값이 몇 개 있는지를 저장한다고도 사용가능
- A[1] = 2, 1이라는 값이 2개 있다는 뜻으로 사용 가능0 1 2 3 4
  
  5 2 1 6 9
인덱스를 순서가 아니라, 해당 숫잣값 자체에 의미를 부여하는 상황을 가장 자주 사용한다
→ 숫자값으로 의미를 부여한 경우,
언제 적용하면 좋은가?→ 1초 안에 정렬이 어렵다
인덱스를 값 자체로 활용하면, 계수 정렬과 같은 방식으로 제한 시간 내에 정렬할 수 있다!
예) 1000보다 작은 자연수 10,000,000개를 1초 안에 정렬해야 하는 상황,
인덱스에 의미를 부여한 대표 사례 - [계수 정렬]→ 여기서 count 리스트의값은 해당 숫자의 등장 횟수!
인덱스는 숫자 자체
import sys N = int(sys.stdin.readline()) count = [0]* 1001 numbers = list(map(int, sys.stdin.readline().split())) for number in numbers: **count[number] += 1 #인덱스에 숫자값으로 의미를 부여하여 데이터를 저장!** for i in range(1001): #0~1000 중에 if count[i] != 0: #i값이 0개인 수면 for _ in range(count[i]): #0부터 count[i]의 개수-1까지 sys.stdout.write(str(i)+ ' ')

비교 연산을 따로 하지 않아도 10,000,000개의 숫자를 1초 안에 빠르게 정렬할 수 있다!

실제 코테 상황에서는, 요구 사항에 따라 인덱스에 적절한 의미를 직접 부여해야 하는 문제도 자주 출제되므로,

⇒ 인덱스를 단순히 ‘몇 번째 순서’ 로만 생각하지 말고

문제 상황에 따라 다양한 의미로 변환해 보는 연습이 중요하다!!

3. 나머지 연산의 중요성 알아보기

나머지 연산이 왜 중요한가?

정답을 OO으로 나눈 나머지를 출력해라 → 나머지 연산을 언제 하느냐가 속도 차이를 만든다!

분배 법칙 활용의 중요성!분배 법칙을 통해 값을 중간중간씩 연산하는 것이 연산 속도를 줄인다!
또한 매우 큰 값을 한 번에 연산하기 보다,

나머지 연산이 자주 활용되는 분배 법칙

주의! 나눗셈은 분배 법칙이 성립하지 않는다

덧셈의 분배 법칙 : (A+B) % C = (A%C + B%C)%C
뺄셈의 분배 법칙 : (A-B) % C = (A%C - B%C)%C
곱셈의 분배 법칙 : (A*B)%C = (A%C * B%C) %C

→ 나눗셈은 나머지 연산의 분배 법칙이 성립하지 않는다. 나머지(덧셈, 뺄셈, 곱셈은 성립)

큰 값을 한 번에 나머지 연산 하면 시간 초과의 위험이 있다! → 분배 법칙을 잘 활용하자

파이썬에서는 int형이 자동으로 확장되므로, 정수 오버플로는 발생하지 않는다.

하지만 숫자가 매우 커지면, 계산 속도가 급격히 느려지고, 시간 초과에 걸릴 수 있다!

마지막에만 %연산을 적용해도 정답 계산이 가능하지만,

채점 서버에서는 시간 초과로 처리되어 오답이 될 수 있다!

활용 예시 : [1부터 100,000까지 곱한 값을 1,000,000,007로 나눈 나머지를 구하시오]

import time

MOD = 1000000007
answer = 1
start = time.time()

"""
for i in range(1,100001):
	answer *= i 

result = answer % 1000000007 #곱한 결과를 한 번에 나머지 연산 하기보다는,
"""
**for i in range(1,100001):
	answer = (answer *i)%MOD**
# 반복문 한 숫자 마다 곱셉, 나머지 연산을 하는 것이 훨씬 속도 향상된다

즉, 정답을 OO으로 나눈 나머지를 출력해라 에서 정답을 구한 후 마지막에 나머지 연산을 구하는 경우 , 시간 초과의 위험이 있다!

⇒ 분배 법칙을 통해, 곱셈, 덧셈 등 중간 계산을 할 때 마다 나머지 연산을 적용하는 습관이 필수이다!

4. 정렬 기초 다지기

정렬 기초를 다져야 하는 이유?
1. 이진 탐색 과 같은 특정 알고리즘은 정렬된 데이터에만 적용될 수 있기 때문!
2. 또한, 정렬은 그리디 알고리즘, 투 포인터, 우선순위 큐 문제에서도 전처리 시 반드시 해야함!

오름차순 정렬 : 작은 값 to 큰 값

데이터의 원본이 유지되어야 하는지의 여부에 따라 다른 방식 사용!

방식1: 파이썬 .sort() 이용한 정렬!

#원본 리스트 선언
A = [5,3,2,4,1]

# 방식1 : list.sort() : 리스트 자체를 정렬 (in-place)
A.sort()

= 리스트(원본) 자체를 정렬! (in-place 정렬) : 반환값 None

방식2 : 파이썬 sorted() 이용한 정렬!

#원본 리스트 선언
A = [5,3,2,4,1]

# 방식2 : sorted(list) : 리스트의 정렬된 복사본을 반환 (원본은 유지)
B = sorted(A)

= 정렬된 복사본을 반환!

내림차순 정렬 : 큰 값 to 작은 값

reverse=True 옵션 추가해서 내림차순 정렬 구현!

#원본 리스트 선언
A = [5,3,2,4,1]

# 방식1에 내림차순 옵션 추가
A.sort**(reverse=True)**
print("내림차순 결과:",A)

# 정렬된 복사본 반환(원본 유지)
B = sorted**(A, reverse=True)**
print("내림차순 복사본:",B)

추가) 정렬 함수를 직접 제어할 수 없는 경우 : 부호를 일시적으로 반전!

#원본 리스트 선언
A = [5,3,2,4,1]

**#부호를 반전시키고, 오름차순으로 정렬한 후, 다시 부호 되돌리기!**
A = [-x for x in A] #부호 반전 : [-5,-3,-2,-4,-1]
A.sort() # 이때의 A는 [-5,-4,-3,-2,-1]

A = [-x for x in A] # 부호 반전 : [5,4,3,2,1] -> 내림차순!이 됨

5. 다중 조건 정렬 익히기

다중 조건 정렬이란? : 여러개의 조건에 따라 정렬하는 것
대표적으로 튜플 기반 정렬과, 딕셔너리 기반 정렬이 있다

튜플 기반 정렬

튜플 기반 방식 : 데이터를 튜플로 구성 후→ .sort() 나 sorted() 의 key인자에 lambda를 사용해 정렬 기준을 지정
튜플 형태로 하는 이유?
정렬 기준을 튜플로 묶으면, 앞에 있는 조건부터 차례로 여러 조건을 적용할 수 있음!
예시 - 영어 점수 내림차순 정렬, 동점인게 있으면 수학점수 내림차수도 고려하는 정렬
- socres.sort(key=lambda x: (-x[0], -x[1]))
  - key=lambda x:튜플의 각 요소를 x 라고 부르고,
  - 그 x를 어떻게 변형한 값을 기준으로 정렬할지 정해준다!
  - → 정렬 기준을 커스텀(사용자 정의) 하겠다는 의미!
  - (-x[0], -x[1])-x[0] : 첫 번째 요소에 마이너스 붙여서 정렬<aside>
    - 영어는 내림차순(높은 순) → 수학은 오름차순(낮은 순) 으로 정렬하고 싶다면?
    - scores.sort(key=lambda x: (-x[0], x[1]))
    </aside>
  - -x[1] : 두 번째 요소에 마이너스 붙여서 정렬!
  - 기본 정렬은 오름차순인데, 마이너스를 붙여서 순서를 뒤집음!
# 영어, 수학 순서로 튜플 데이터 저장 scores = [ (80,100), (100,50), (70,100), (80,90), ] #1순위: 영어 내림차순 -> 동점인게 있으면 2순위: 수학 내림차순 **scores.sort(key=lambda x: (-x[0],-x[1]))** for s in scores: print(f"english={s[0]}, math={s[1]}")
추가) 람다 함수 lambda 이해하기! : 람다 함수는 정렬시 참고하기 위한 기준만 보기 위함임!sort(key=...) 함수에서 key에 전달하는 람다 함수는정렬할 때만 참고하는 '임시 기준값'을 만드는 역할을 합니다.
1. 기준표 작성: 파이썬이 정렬하기 전에 각 요소 옆에 포스트잇을 하나씩 붙인다고 상상해 보세요.
  - (80, 100) 옆에는 (-80, -100)이라는 포스트잇을 붙입니다.
  - (100, 50) 옆에는 (-100, -50)이라는 포스트잇을 붙입니다.
2. 순서 정하기: 파이썬은 실제 데이터가 아니라, 이 포스트잇에 적힌 숫자들을 비교해서 오름차순으로 순서를 정합니다.
  - 100이 80보다 작으므로, 100 포스트잇이 붙은 데이터가 가장 앞으로 갑니다.
3. 결과 출력: 순서가 다 정해지면 포스트잇은 떼어버리고, 원래 있던 실제 데이터(100, 50 등)만 남겨서 리스트를 재배치합니다.
파이썬 내부에서 sort가 돌아갈 때의 논리 구조는 다음과 같습니다:결국 lambda 함수는 "어떤 기준으로 줄 세울까?"라는 질문에 답하기 위해 잠깐 계산해 보는 식일 뿐, 원본 데이터를 수정(Modify)하는 명령이 아닙니다!
</aside>
# 내부적인 가상의 동작 과정 temp_keys = [] for x in scores: temp_keys.append((-x[0], -x[1])) # 정렬을 위한 "임시 키" 생성 # 이 temp_keys를 기준으로 전체 데이터의 순서를 결정 (실제 데이터는 변하지 않음) # 순서 결정 완료 후 리스트 재배치`
작동 원리를 비유로 설명하면 이렇습니다:
실제 리스트의 값을 바꾸는 것이 아니라,
<aside>

딕셔너리 기반 정렬

딕셔너리 기반 방식 : 데이터를 딕셔너리로 구성 후→ .sort() 나 sorted() 의 key인자에 lambda를 사용해 정렬 기준을 지정
딕셔너리 형태로 하는 이유?
정렬 기준을 딕셔너리 형태로 묶으면, 키(key)의 이름으로 값을 찾기 때문에, 데이터에 새로운 항목이 추가되거나 순서가 바뀌어도 정렬 코드를 고칠 필요가 없다!
예시 - 수학 점수 내림차순 정렬, 동점인게 있으면 영어 점수 내림차수도 고려하는 정렬
- socres.sort(key=lambda x: (-x[0], -x[1]))
  - key=lambda x:튜플의 각 요소를 x 라고 부르고,
  - 그 x를 어떻게 변형한 값을 기준으로 정렬할지 정해준다!
  - → 정렬 기준을 커스텀(사용자 정의) 하겠다는 의미!
  - (-x[0], -x[1])-x[0] : 첫 번째 요소에 마이너스 붙여서 정렬<aside>
    - 영어는 내림차순(높은 순) → 수학은 오름차순(낮은 순) 으로 정렬하고 싶다면?
    - scores.sort(key=lambda x: (-x[0], x[1]))
    </aside>
  - -x[1] : 두 번째 요소에 마이너스 붙여서 정렬!
  - 기본 정렬은 오름차순인데, 마이너스를 붙여서 순서를 뒤집음!
# 영어, 수학 순서로 튜플 데이터 저장 scores = [ {'english':80, 'math':100 }, {'english':100 , 'math': 50}, {'english':70, 'math': 100}, {'english':80, 'math': 90}, ] #1순위: 영어 내림차순 -> 동점인게 있으면 2순위: 수학 내림차순 **scores.sort(key=lambda x: (-x['math'],-x['english']))** for s in scores: print(s)

두 정렬 방식의 차이

어떤 상황에 활용하는가?짧고 간단해서 더 빠르다딕서너리 기반 정렬: 데이터에 새로운 항목이 추가되거나 순서가 바뀌어도 정렬 코드를 고칠 필요가 없다!
구조화되어 가독성이 좋다
→ 조건이 많아지면, 딕셔너리로 해야 가독성이 더 좋음!
튜플 기반 정렬: 적은 조건일 때!, (단순 계산용), 단순 입력처리 일 때!

6. 이차원 리스트 제대로 다루기

이차원 리스트는 어디에 사용하는가? : 그래프의 구조 표현특히 인접 리스트 방식으로 그래프를 표현할 때,
이차원 리스트의 선언,데이터 저장, 활용 방법을 정확히 이해하고 있어야 시험장에서 당황하지 않고 문제를 풀 수 있다!
→ 코테 문제에서는 그래프 관련 알고리즘이 많이 등장하는데, 이 때 그래프의 구조를 표현하는데 많이 사용하는 것이 이차원 리스트이다!

이차원 리스트를 이용한 그래프 구현 방법

[Step 1. 이차원 리스트 선언과 초기화]

파이썬 리스트 안에 또 다른 리스트를 넣는 방식으로 이차원 리스트를 구성한다!

보통 노드 번호는 1번부터 시작 하므로, 인덱스 0 사용x, N+1 크기로 리스트 초기화 한다
# 정점이 3개 있다고 가정 (1~3번 사용!) N =3 **graph = [[] for _ in range(N+1)]**

→ 이렇게 만든 graph[1], graph[2], graph[3] 각각이 각 정점의 인접 리스트 역할을 한다!

[Step 2. 그래프 데이터 저장하기]

문제 예시) 아래의 간단한 그래프에 입력값 저장하기<aside>
- 왼쪽 그래프를 표현하기 위한 입력값
3 4 (→ 노드가 3개, 에지가 4개인 그래프)2 1 103 2 6
- 그래프 데이터를 이차원 리스트 자료구조를 이용하여 저장하기
```
# 정점 수와 간선 수 입력
N,E = map(int, input().split()) #정점=3, E 간선(edge)=4

# 간선 정보를 입력받아 저장
for _ in range(E): #저장할 에지의 개수만큼 반복 (1~4까지)
	s,e,w = map(int,input().split())
	**graph[s].append((e,w)) #이차원 리스트에 그래프 데이터 저장!	
			# (e,w) 는 (도착 노드, 가중치) 임!**
```
- 연결 정보는 (도착 노드, 가중치) 형태의 튜플로 저장한다
- 실제 이차원 리스트에 데이터 저장 형태[1] → [2,4] [3,7][3] → [2,6]
- [2] → [1,10]
- [시작노드] → [도착노드, 가중치] 형태!
</aside>
1 3 7
1 2 4 ( 1번 노드에서 2번 노드로 가는 가중치 4의 에지가 있음 )
flowchart LR 1 -- 7 --> 3 3 -- 6 --> 2 1 -- 4 --> 2 2 -- 10 --> 1

[Step 3. 그래프 데이터 가져오기]

1번 노드에서 시작되는 에지 데이터를 가져오기!이 코드를 사용하면
[2,4] 랑 [3,7] 의 2개의 에지 데이터를 가져올 수 있다
for nextNode, weight in graph[1]: print(f"next Node {nextNode}, weight= {weight}")

→ 그래프 문제에서 이차원 리스트가 필요할 때 적절하게 활용하여 문제를 해결하자!

[문자열 압축]

lVlina — Wed, 27 Nov 2024 20:19:56 +0900

import java.io.BufferedReader;
import java.io.InputStreamReader;


public class Main {

    public void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();

        StringBuilder sb = new StringBuilder();

        //charAt(i) = charAt(i+1) 같으면
        for(int i=0; i <=str.length();i++){
            sb.append(str.charAt(i)); 
           if(i==str.length()-1){  
               break;
           }else{
               if(str.charAt(i) == str.charAt(i+1)) {
                   int repeatedCount =1;
                   while(str.charAt(i) == str.charAt(i+1)){
                       repeatedCount++;
                       i++;
                   }
                   sb.append(repeatedCount);
               }
           }
        }

        System.out.println(sb);
    }

    public static void main(String[] args) throws Exception{
        new Main().solution();
    }
}

-> 이렇게 실했했더니 런타임 에러가 뜸

조금 더 간단한 방식을 생각해 봐야 한다!

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

    public void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        StringBuilder sb = new StringBuilder();
        int cnt=1;
        for(int i=0; i < str.length()-1;i++){
            if(str.charAt(i)==str.charAt(i+1)) cnt++;
            else {
                sb.append(str.charAt(i));
                if(cnt>1) sb.append(String.valueOf(cnt));
            }
        }

        System.out.println(sb);
    }

    public static void main(String[] args) throws Exception{
        new Main().solution();
    }
}

[Spring Security in Action] 1장

lVlina — Thu, 14 Nov 2024 18:17:54 +0900

읽계 된 계기:

로그인 기능을 구현하면서 로그인이 어떻게 이루어지는지를 이해하고 싶어서 학교 도서관에서 이 책을 빌렸다!

1장 내용 요약

* 스프링 시큐리티의 개념과 이를 이용해 해결할 수 있는 문제
* 소프트웨어 애플리케이션에서 보안의 의미
* 소프트웨어 보안이 중요한 이유와 관심을 가져야 하는 이유
* 애플리케이션 수준의 일반적인 취약성

[소프트웨어의 비기능적 요구사항의 중요성]

일반적으로 개발자는 애플리케이션의 목적이 비즈니스 문제를 해결하는 것임을 배우는 것으로 시작한다.

-> 이러한 소프트웨어 개발의 관점에는 프로세스의 관행이 잘 드러나지 않는다는 문제가 있다

성능, 확장성, 가용성, 보안과 같은 소프트웨어의 비기능적 특징은 시간이 지남에 따라 단기적 영향과 장기적 영향을 미칠 수 있다

소프르웨어의 비기능적 특징들을 무시하면 DDos(분산 서비스 거부) 공격에 원치 않게 참여하는 등, 다른 시스템 오류도 발생할 수 있다. 비기능적 요구사항의 숨겨진 측면 (누락되거나 숨겨진 것을 찾기 어려움) 때문에 이러한 문제는 더 위험하다

소프트웨어 시스템을 다룰 때는 여러 비기능적 측면을 고려해야 한다. 이러한 비기능적 측면도 모두 중요하며 소프트웨어 개발 프로세스에서 책임감 있게 다뤄야 한다

[1.1 스프링 시큐리티 : 개념과 장점]

- 스프링 시큐리티와 스프링 간의 관계 알아보기

https://spring.io/projects/spring-security

Spring Security

Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications. Spring Security is a framework that focuses on providing both authentication and authoriz

spring.io

-> 스프링 시큐리티를 인증과 접근 제어를 위해 세부적인 맞춤 구성이 가능한 강력한 프레임워크, 스프링 애플리케이션에 보안을 적용하는 과정을 크게 간소화하는 프레임워크이다,

스프링 애플리케이션에서 애플리케이션 수준의 보안을 구현할 때, 가장 우선적인 선택이며 인증, 권한 부여 및 일반적인 공격에 대한 방어를 구현하는 세부적인 맞춤 구성 방법을 제공한다.

https://github.com/spring-projects/spring-security/

[스프링 시큐리티 소스 코드]

스프링 시큐리티는 스프링 애플리케이션에서 애플리케이션 수준 보안을 구현하기 위핸 사실상의 표준이다. 하지만 스프링 시큐리

를 이용해도 애플리케이션이 자동으로 보호되는 것은 아니다. -> 애플리케이션의 필요에 맞게 스프링 시큐리티를 구성하고 맞춤 구성하는 방법을 알아야함

스프링 애플리케이션에 스프링 시큐리티를 어떻게 이용하면 좋을까?

-> 일반적으로 애플리케이션 수준에서 가장 흔한 보안의 활용 사례는 누가 작업을 수행할 수 있는지, 특정 데이터를 이용할 수 있는지를 결정하는 것이다. 구성을 기반으로 요청을 가로채고 권한을 가진 사용자만 보호된 리소스에 접근할 수 있도록 스프링 시큐리티 구성 요소를 작성한다. 개발자는 원하는 것을 정확하게 수행하도록 구성 요소를 구성한다. (집(애플리케이션)에 경보시스템을 설치한다면 문에만 설치하고 끝낼 것이 아니라 창문에도 설치하는 것이 개발자의 역할!)

[1.2 소프트웨어 보안이란?]

- 광범위하게 표현한 보안의 의미 -

현재의 소프트웨어 시스템은 특히 GDPR(General Data Protection Regulations; 일반 데이터 보호 규정) 요구사항을 고려할 때 상당 부분이 민감한 정보일 수 있는 대량의 데이터를 관리한다. 사용자가 개인적이라고 생각하는 모든 정보는 소프트웨어 애플리케이션에서 민감한 정보가 된다.

민감한 정보에는 전화번호, 이메일 주소 또는 식별 번호와 같은 무해한 정보도 있지만, 유출됐을 때 위험성이 높은 신용 카드 정보 등의 정보는 더 중요하게 고려해야 한다.

애플리케이션은 이러한 정보에 접근, 변경 또는 가로챌 기회가 없게 해야 하며 의도된 사용자 이외의 대상은 어떤 식으로든 데이터와 상호 작용할 수 없게 해야 한다.

보안은 계층별로 적용해야 하며, 각 계층에 다른 접근 방식이 필요하다.

해커는 앱이 보호하는 리소스를 획득하기 위해 여러 장애물을 통과해야 한다. 각 계층을 더 잘 보호할수록 악의적인 대상이 데이터에 접근하거나 무단 작업을 수행할 가능성이 낮아진다

소프트웨어 시스템에서 보안은 애플리케이션 수준에만 적용되는 것이 아니다

-> 예) 네트워킹의 경우 여러 문제를 고려하고 특정한 관행을 적용해야 하며 스토리지에도 완전히 다른 사항이 적용된다

- 보안 수준이 무엇이고 어떤 의미가 있는가?

애플리케이션 수준 보안

: 애플리케이션이 실행되는 환경과 애플리케이션이 처리하고 저장하는 데이터를 보호하기 위해 해야 하는 모든 것을 나타낸다.

애플리케이션에 사용되고 영향을 받는 데이터에만 국한되는 문제가 아니다. 애플리케이션에 악의적인 개인이 전체 시스템에 영향을 줄 수 있는 취약성이 있을 수 있다

보안은 각 계층에 적용되고 각 계층은 그 아래의 계층에 의존한다. 스프링 시큐리티 -> 최상층에서 애플리케이션 수준의 보안을 구현

힌 계층의 보안 문제를 해결할 때에는 되도록 위 계층이 존재하지 않는다고 가정하는 것이 바람직하다

[스프링 시큐리티 인증 프로세스]

대부분의 시스템에서는 회원을 관리하고 있고, 그에 따른 인증(Authentication) 과 인가(Authorization) 에 대한 처리를 해야한다!

** 인증(Authentication) : 해당 사용자가 본인이 맞는지 확인하는 과정

** 인가(Authorization) : 해당 사용자가 요청하는 자원을 실행할 수 있는 권한이 있는가를 확인하는 과정

[자세한 내용은 조금 더 공부한 후에 설명하도록 하겠습니다!!]

[ 중복문자제거 ]

lVlina — Wed, 13 Nov 2024 19:53:07 +0900

public class Main {
    public void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        //charAt()활용
        String answer ="";
        for(int i=0; i<input.length();i++){
            if(input.indexOf(input.charAt(i))==i) answer += input.charAt(i);
        }
        System.out.println(answer);
    }

    public static void main(String[] args) throws Exception{
        new Main().solution();
    }
}

.indexOf() 메서드 활용

=> 해당 문자가 가장 처음 발견되는 인덱스를 반환하는 메서드

+) HashSet 사용

문자열의 길이가 길어질수록 시간 복잡도가 크게 증가하며, 중복된 문자가 많을 경우에는 중복 체크로 인해 불필요한 반복이 발생하게 된다. => 중복을 허용하지 않는 HashSet 사용하여 효과적으로 제거 가능

Set이란?

-> Set 인터페이스 구현 클래스에서는 객체를 중복해서 저장할 수 없으며, 하나의 null 값만 저장할 수 있다

또한 중복을 자동으로 제공해준다!

Set는 비선형구조이다!

Heap 영역에 존재하며, 비선형구조이기 때문에 순서의 개념과 인덱스가 존재하지 않는다!

-> 때문에 값을 추가/삭제 하는 경우, set 내부에 해당 값을 검색하여 해당 기능을 수행해야 한다

이로 인해 처리 속도가 List 구조에 비해 느리다는 단점이 있다

HashSet 이란?

-> Set 인터페이스에서 지원하는 구현 클래스이다 (Set의 성질 그대로 상속받음)

즉, 다음의 성질을 가진다

1. HashSet은 중복된 값을 허용하지 않는다

2. List 등과는 다르게 저장한 순서가 보장되지 않는다 (저장 순서를 유지하려면 LinkedHashSet 사용)

3. null을 값으로 허용한다

// 타입을 지정 가능
HashSet<String> animals1 = new HashSet<String>();

// 타입을 생략하여 사용 가능 -> 빈 HashSet생성 시 사용
HashSet<String> animals2 = new HashSet<>();  

// 초기 용량(Capacity) 설정
HashSet<String> animals3 = new HashSet<>(10); 

 // animal의 모든 값을 가진 HashSet 생성 
HashSet<String> animals4 = new HashSet<>(animals1);

//초기값 지정 가능
HashSet<String> animals5 = new HashSet<>(Arrays.asList("tiger", "lion", "fox"));

HashSet 요소에 add() 메소드를 호출하여 값을 추가 가능하다!

HashSet<String> animals = new HashSet<>()
	animals.add("tiger");
    animals.add("lion");
    animals.add("fox");

HashSet은 저장 순서가 보장되지 않기에 특정 위치에 값을 추가하거나 할 수 없다!!

입력되는 값이 HashSet내부에 존재하지 않으면, 값을 HashSet에 추가한 후 true 반환 / 내부에 존재한다면 false를 반환한다

size() 메소드를 사용하여 Hash의 크기를 구할 수 있다

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));

//set 크기 : 3
System.out.println(set.size());

remove(), clear() 메소드를 사용하여 Hash값을 제거할 수 있다

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));

//값1 제거
set.remove(2);

//모든 값을 제거

set.clear();

원하는 값에 대해 contains(value) 메소드를 통해 Hash 내부에 존재하는지 확인이 가능하다

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));

//set 내부에 값 1이 있다면 -> true/ 없다면 false 출력
System.out.println(set.contains(1));

HashSet 을 적용해서 바꾼 코드

public class Main {
    public void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();

        StringBuilder sb = new StringBuilder();
        Set<Character> set = new HashSet<>();

        for (int i = 0; i < str.length(); i++) {

            char c = str.charAt(i);

            if (!set.contains(c)) {
                sb.append(c);
                set.add(c);
            }
        }
        System.out.println(sb);
    }

    public static void main(String[] args) throws Exception{
        new Main().solution();
    }
}

자바(Java) 알고리즘 문제풀이 입문 10. 문자거리

lVlina — Wed, 2 Oct 2024 20:10:57 +0900

[문제 분석]

* 문자열 s (길이 100이하)

* 문자 t

예시 입력1에서, 문자열 s = teachermode , 문자열 t = e

예시 출력 1

1 // s[0] = t 와 s[1] = e 사이의 거리 = 1
0 // s[1] = e와 s[1] = e 사이의 거리 = 0
1 // s[2] = a 와 s[1] = e 사이의 거리 = 1
2 // s[3] = c 와 s[1] = e 사이의 거리 = 2
1 // s[4] = h 와 s[5] = e 사이의 거리 = 1
0 // s[5] = e와 s[5] = e 사이의 거리 = 0
1 // s[6] = r 와 s[5] = e 사이의 거리 = 1
2 // s[7] = m 와 s[5] = e 사이의 거리 = 2
2 // s[8] = o 와 s[10] = e 사이의 거리 = 2
1 // s[9] = d 와 s[10] = e 사이의 거리 = 1
0 // s[10] = e 와 s[10] = e 사이의 거리 = 0

[문제 해결]

문자간의 최소 거리를 구하는 방법

탐색을 할 때, 해당 문자열의 앞에 있는 'e' 와의 거리 와, 문자열 뒤에 있는 'e'와의 거리를 비교해서 최소한의 거리를 구해야함

1. for 문 > 해당 문자열의 앞에있는 e 와의 거리 구하기

2. for문 > 문자열 뒤에 있는 'e'와의 거리와 비교해서 더 적은 값

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public void solution() throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        String s = st.nextToken();
        char t = st.nextToken().charAt(0); // Convert the string token to a char


        int[] answer = new int[s.length()];
        int p = 1000;   //일단 처음 값을 1000으로 두기
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == t) {
                p = 0;
                answer[i] = p;
            } else {
                p++;
                answer[i] = p;
            }
        }

        p = 1000;
        for (int i = s.length() - 1; i >= 0; i--) {
            if (s.charAt(i) == t) {
                p = 0;
            } else {
                p++;
                answer[i] = Math.min(answer[i], p);
            }
        }

        for (int i : answer) {
            System.out.print(i + " ");
        }
    }

    public static void main(String[] args) throws Exception {
        new Main().solution();
    }
}

[INFCON 2024] 첫 인프콘 서포터즈 후기

lVlina — Wed, 14 Aug 2024 10:24:49 +0900

참가 계기

매번 신청하지만 참가해본 적은 없는 인프콘..

이번 인프런 워밍업 클럽에서 백엔드 스터디를 참여한 이후 처음으로 인프콘 2024 서포터로써 활동할 기회가 생겼다!

현업 개발자의 세션을 들을 수 있다니..나에겐 정말 흔치 않은 좋은 기회라고 생각하고 광주에서 새벽 5시 기차를 타고 이동했다

서포터 준비

인프콘은 코엑스 아셈볼룸(북문 방향)에서 진행되었는데,

1층 인프런 존에는 각 기업 파트너 부스와 인프런 존에서 진행하는 이벤트를 참여할 수 있고, 네트워킹을 위한 사전예약을 할 수 있다!

또한, 1층에서 각 트랙의 세션이 진행된 후에는, 2층 201호에서 각 세션 스피커와 질의응답을 진행할 수 있었다.

오후에는 세션 스피커 이외에 라이트닝 토크로 짧은 시간동안 개인 세션을 진행할 수 있고, 현업 개발자와의 네트워킹 파티에도 참여할 수 있었다! 이번에 서포터 활동으로는 각 세션장과 발표 질의응답 위주로 돌아다닐 예정이였다

인프콘을 제대로 즐기기 위한 준비

인프콘을 제대로 즐기기 위해

인프콘 2024 홈페이지에서 서포터로 참여하게 될 세션의 개요를 미리 볼 수 있고, 이를 토대로 시간표를 작성해 볼 수 있다!

미리 세션의 스피커와 어떤 주제로 진행될 지를 알아놓고 가니, 세션을 진행할 때에 더욱 집중해서 들을 수 있었던 것 같다

혹시라도 내년 인프콘 혹은 인프콘 서포터에 참여할 생각이 있다면 미리 세션을 톺아보고, 시간표까지 짜보고 가는 것을 추천한다

인프콘 서포터 ot

인프콘 서포터 OT를 위해 오프닝 시간보다 2시간 전에 모였다!! 서포터 한정 굿즈와 귀여운 인프런 사탕,서포터 티셔츠까지 받았다!! 이번 티셔츠 디자인이 너무 예뻐서 만족!! 사탕은 먹기 아까워서 소장하는걸로

간단하게 서포터 활동 OT 및 안내사항을 숙지한 후,

본격적으로 서포터 활동 시간표에 따라서 이동!!

서포터 활동의 또 다른 장점??

사람들이 와글와글 몰리기 전 시간에 미리 기업부스를 둘러볼 수 있다는 점이다 ㅎㅎ

부스 투어

빠르게 기업 부스 돌아보기!

기업 부스에서 이벤트를 참여하고 각종 굿즈들을 쓸어올 수 있다!

또한 참여하는 기업에서 네트워킹 타임 테이블도 볼 수 있다!

네트워킹에 참여하고 싶다면 인프런 존에서 네트워킹 사전예약을 한 이후에 참여할 수 있다

이번에는 서포터활동을 하면서 세션장 위주로 활동할 예정이기 때문에 아쉽지만 네트워킹은 내년 인프콘을 기약하는 걸로..ㅎㅎ

사람이 몰리기 전 인프런 존에서 세컷 사진도 찍었다!!

인프콘 2024 오프닝

인프콘 오프닝에서는

인프런의 비전, 성장과정, 인프콘에서 새롭게 적용된 기술들을 엿볼 수 있었다

제일 신기했던 부분은 더빙 다국어 기능이였다!! 김영한 님의 목소리로 영어 더빙을 들을 수 있다니..정말 신기했다

글로벌 온라인 교육 플랫폼으로써의 도약이 기대되는 인프런의 오프닝 세션이였다

오프닝이 끝난 후

벌써 아셈볼룸에는 인프콘을 찾아온 많은 사람들로 북적였다

기업 부스는 한가할 때 충분히 돌아봤으므로 , 서포터 활동 전에 미리 짜온 시간표대로 세션을 하나 듣기로 했다

세션 참여

인프콘 세션을 참여하면서 인프콘 발표자들의 문제 해결에 대한 열정과 노력을 느낄 수 있었다!!

디자인 시스템, 데이터를 활용한 ux 전략, 바이트 플러그 만들기 등 다양한 분야의 세션을 들었는데 하나같이 개발자로서 견문을 넓히는데에 도움이 되는 분야라고 생각이 들었고, 발표자들의 개발에 대한 열정에 자극을 받을 수 있었던 시간이였다

또한 인프콘 세션에서

목적 조직 구조 안에서 개발팀이 어떻게 일하는지도 알아볼 수 있었다

소규모의 인원들로 진행되는 프로젝트 안에서 각자가 하나의 목표를 가지고 열정적으로 임하는 모습을 볼 수 있었다

질의응답존

각 세션이 마무리 된 후에는 발표자와의 질의응답에 참여할 수 있는데, 서포터로 참여한 덕분에 각 질의응답 세션에 참여할 수 있었던 점이 좋았다ㅎㅎ 세션 초반부에는 멀리서 가만히 듣고있었는데 후반부에는 아예 의자를 가지고 앉아서 질문자로 같이 참여했다ㅋㅋㅋ 서포터 활동을 위해 일정상 질의응답 시간 중간에 이동해야 했지만, 질의응답에 끝까지 참여하지 못한게 아쉬울 정도로 도움이 되는 시간이였다

참여 후기

이런 오프라인 세션에 참여할 수 있다는 것 만으로도 충분히 코엑스까지 올 가치가 있다고 생각했는데, 각 세션을 들으면서 얻은 개발에 대한 조언과 인사이트들을 통해 개발자로 성장하는데에 큰 도움이 될 것 같다고 느꼇다!! 일반 참가자가 아닌 인프런 서포터로 참여하는 좋은 기회가 생긴 덕분에 인프콘을 200% 즐길 수 있었다고 생각했다✨

일정상 네트워킹에는 참여할 수 없었지만, 내년에 또 서포터로 참여할 수 있는 기회가 주어진다면 네트워킹에도 참여해보고 싶다 벌써 인프콘 2025가 기대된다!!

[2018] - 수들의 합 5 : 투 포인터

lVlina — Mon, 12 Aug 2024 16:32:50 +0900

1. 문제설명

시간제한 2초

자연수 N(1<=N<=백만) N을 몇 개의 연속된 자연수의 합으로 나타내는 가지수

사용하는 자연수는 N 이하여야함

예) 15 -> 15, 7+8, 1+2+3+4+5 (4가지)

10 -> 10, 1+2+3+4

구간합 이용?

[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ]

2. 문제 분석

이 문제는 시간 복잡도 분석으로 사용할 알고리즘의 범위를 줄여야한다!

문제에 주어진 시간은 2초인데, N의 최댓값은 10,000,000으로 매우 크게 잡혀있다 => 이런 상황에서는 O(NlogN) 의 시간 복잡도 알고리즘을 사용하면 제한 시간을 초과하므로 O(N)의 시간 복잡도 알고리즘을 사용해야 한다

이런 경우 자주 사용하는 방법이 투 포인터이다

연속된 자연수의 합을 구하는 것이 문제이므로, 시작 인덱스와 종료 인덱스를 지정하여 연속된 수를 표현할 수 있다

투 포인터 이동 원칙을 활용해 배열의 끝까지 탐색하면서 합이 N이 될 경우의 수를 구한다

start_index를 오른쪽으로 한 칸 이동하는 것은 연속된 자연수에서 왼쪽 값을 삭제하는 것과 효과가 같으며, end_index를 오른쪽으로 한 칸 이동하는 것은 연속된 자연수의 범위를 한칸 더 확장하는 의미이다. 같을 때는 경우의 수를 1 증가시키고, end_index를 오른쪽으로 이동시킨다

투 포인터 이동 원칙
* sum > N : sum = sum- start_index; start_index++;
* sum < N : end_index++; sum= sum + end_index;
* sum == N : end_index++; sum = sum + end_index; count++;

3. 수도 코드

N 변수 저장
사용 변수 초기화 (coutn =1, start_index=1; end_index = 1; sum=1)
whlie(end_index != N){
if(sum==N) count 증가, end_index 증가, sum 값 변경
else if(sum > N ) sum 값 변경, start_index 증가
else if(sum < N ) end_index 증가 , sum 값 변경
}
count 값 출력하

4. 코드 작성

import java.io.BufferedReader;

public class Main {

    public void solution()  throws Exception {
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       int N = Integer.parseInt(br.readLine());
       int count =1;
       int start_index = 1;
       int end_index =1;
       int sum =1;

       while(end_index !=N){
           if (sum == N){
               count++; end_index++; sum += end_index;
           } else if (sum > N) {
               sum -= start_index;
           } else {
               end_index++; sum += end_index;
           }
       }
        System.out.println(count);

    }
    public static void main(String[] args) throws Exception {
        new Main().solution();
    }
}

[ 투 포인터 원리 이해하기]

https://www.youtube.com/watch?v=SrMk-EdWRUE

[ Do it! 알고리즘 코딩테스트 with JAVA ] - 구간합

lVlina — Mon, 12 Aug 2024 15:00:59 +0900

[부분 합 (Partial sum)]

: 부분 합이란 구간 합과 달리 처음부터 특정 인덱스까지의 합을 의미한다 (Array[i] 부터 Array[j]까지의 합)

[구간 합(Prefix sum)]

-> 합 배열을 이용하여 시간복잡도를 더 줄이기 위해 사용하는 특수한 목적의 알고리즘

보통 1차원 배열에서 i~k 인덱스 사이의 값들의 합을 구하는데 사용한다

(코딩테스트에서 사용 빈도가 높으니 꼭 알아두어야 한다!)

- 구간 합 알고리즘을 활용하려면 먼저 합 배열을 구해야 한다!

[합 배열 S의 정의]

S[i] = A[0] + A[1] + A[2] + ... + A[i-1] + A[i] //A[0] 부터 A[i] 까지의 합

합 배열은 기존의 배열을 전처리한 배열이라고 생각하면 된다.

이렇게 합 배열을 미리 구해놓으면 기존 배열의 일정 범위의 합을 구하는 시간 복잡도가 O(N)에서 O(1)로 감소한다

예를 들어서, S(t) = 배열A의 A[0] + A[1] + A[2] + A[3] + A[4] 의 값이다.

A[i] 부터 A[j]까지의 배열 합을 합 배열 없이 구하는 경우, 최악의 경우는 i가 0이고, j가 N인 경우로, 시간 복잡도는 O(N)이다. => 합 배열을 사용하면 O(1) 안에 답을 구할 수 있음

[합 배열 S를 만드는 공식]

S[i] = S[i-1] + A[i]

[구간 합을 구하는 공식]

S[j] - S[i-1] //i에서 j까지의 구간 합

[A[2] 부터 A[5]까지의 구간 합을 합 배열로 구하는 과정]

S[5] = A[0] + A[1] + A[2] + A[3] + A[4]+ A[5]

S[1] = A[0] + A[1]

S[5] - S[1] = A[2] + A[3] + A[4]+ A[5]

https://velog.io/@leeeeeyeon/%EA%B5%AC%EA%B0%84-%ED%95%A9-%EB%B6%80%EB%B6%84-%ED%95%A9-%EB%88%84%EC%A0%81-%ED%95%A9

구간 합, 부분 합, 누적 합

배열의 일부 구간에 대한 합을 매우 빠르게 구해보자

velog.io

[ Do it! 알고리즘 코딩테스트 with JAVA ] - 시간복잡도

lVlina — Mon, 12 Aug 2024 14:10:32 +0900

[시간복잡도]

-> 알고리즘에서 시간 복잡도는 주어진 문제를 해결하기 위한 연산 횟수를 말한다.

일반적으로 수행 시간은 1억번의 연산을 1초의 시간으로 간주하여 예측한다

[시간복잡도 유형]

* 빅-오메가 : 최선일 때(best case)의 연산 횟수를 나타낸 표기법

* 빅- 세타 : 보통일 때(average case)의 연산 횟수를 나타낸 표기법

* 빅 - 오: 최악일 때(worst case)의 연산 횟수를 나타낸 표기법

예제

- 0~99사이의 무작윗값을 찾아 출력하는 코드

빅- 오메가 표기법의 시간복잡도는 1번 , 빅-세타 표기법의 시간 복잡도는 2/N 번 , 빅 - 오 표기법의 시간 복잡도는 N번이다

public class timeComplexityEx {
	public static void main(String[] args){
    	// 1~100 사이의 랜덤 값 선택
        int findNum = (int)(Math.random() * 100); //여기서 N = 100
        for(int i=0; i<100;i++){
        	if(i==findNum){
            	System.out.println(i);
                break;
            }
        }
    }
}

여기서 N= 100이고,

평균적으로 50번만에 문제를 해결 가능 -> 빅-세타는 N/2

99번째까지 값을 찾지 못하고, 마지막에서야 값을 찾는 경우(최악의 경우) -> 빅 오는 N (100)

실제로 코딩테스트를 할 때에는 3가지 유형 중 빅-오(최악의 경우)를 생각해야한다!

-> 코딩테스트의 test set은 input이 여러 케이스가 있기 때문에 항상 가장 최악의 경우를 염두해두어야한다

예를 들어

logN 의 시간복잡도를 가진 연산은

100번 이 필요하다고 할 때 ... 2^6 = 64, 2^7 = 128, 즉 7번 만에 값을 찾을 수 있다

[시간복잡도 활용하기]

예) N개의 수가 주어졌을 때 이를 오름차순 정렬하는 프로그램을 작성하시오

- 입력: 1번째 줄에 수의 개수 N(1 <= N <= 1,000,000), 2번째 줄부터는 N개의 줄에 숫자가 주어진다. 이 수는 절대값이 1,000,000보다 작거나 같은 정수이다. 수는 중복되지 않는다(시간제한 2)

-> 테스트 케이스의 숫자범위가 작을지라도, 백만까지의 수를 염두해두고 풀어야한다

시간제한이 2초이므로, 이 조건을 만족하려면 2억번 이하의 연산 횟수로 문제를 해결해야한다

따라서 문제에서 주어진 시간 제한과 데이터 크기를 바탕으로 어떤 정렬 알고리즘을 사용해야 할 것인지르 판단할 수 있다

(연산 횟수는 1초에 1억번 연산하는 것을 기준으로 생각하기, 시간 복잡도는 항상 최악일때,= 데이터의 크기가 가장 클 때를 기준으로 합니다)

- 연산횟수 계산 방법

연산 횟수 = 알고리즘 시간 복잡도 X 데이터의 크기

- 알고리즘 적합성 평가

* 버블 정렬(N^2) = (1,000,000)^2 = 1,000,000,000,000 > 2,000,000,000 => 부적합 알고리즘

* 병합 정렬(NlogN) = 1,000,000 log(1,000,000) = 약 6,000,000 < 200,000,000 => 적합 알고리즘

[시간 복잡도 도출 고려사항 ]

1. 상수는 시간 복잡도 계산에서 제외한다

2. 가장 많이 중첩된 반복문의 수행 횟수가 시간 복잡도의 기준이 된다

- 연산 횟수가 N인 경우

public class 시간복잡도_판별원리1 {
	public static void main(String){
    	int N = 100000;
        int count =0;
        for(int i=0; i<N; i++){
        	System.out.println("연산 횟수:", cnt++);
        }
    }
}

-> 이 코드의 시간복잡도는 O(N)

    public static void main(String[] args){
        int N  = 100000;
        int count =0;

        for(int i=0; i<N; i++){
            System.out.println("연산 횟수: "+ count++);
        }
        for(int i=0; i<N; i++){
            System.out.println("연산 횟수: "+ count++);
        }
        for(int i=0; i<N; i++){
            System.out.println("연산 횟수: "+ count++);
        }
    }
}

-> 일차원 for문을 3번 돌림 -> 시간복잡도 O(3N)

그런데 시간복잡도 상으로 O(N) 과 O(3N) 은 별로 차이가 나지 않는다!

결론적으로 시간복잡도는 O(N)으로 똑같다고 본다

그런데, 이중 for문의 경우 연산 횟수가 N X N => 연산 횟수가 N^2 이다

-> 시간복잡도는 가장 많이 중첩된 반복문을 기준으로 도출하므로 이 코드에서는 이중 for문이 전체 코드의 시간 복잡도 기준이 된다. 만약 일반 for문이 10개 더 있다 하더라도 도출 원리의 기준에 따라 시간 복잡도의 변화 없이 N^2 으로 유지된다

이와 같이 자신이 작성한 코드의 시간 복잡도를 노출할 수 있다면, 실제 코딩테스트에서 시간 초과가 발생했을 때, 이 원리를 바탕으로 문제가 되는 코드 부분은 도출할 수 있고, 이 부분을 연산에 더욱 효율적인 구조로 수정하는 작업으로 문제를 해결할 수 있다

차세대 프로젝트 : 회사의 중요한 업무 시스템을 외부 회사에 개발을 맡겨서 완전히 새롭게 만드는 일

lVlina — Mon, 5 Aug 2024 17:50:06 +0900

[용어가 쓰인 부분]

차세대 프로젝트가 실패하는 이유
(중략)
생각이 미친 김에 다시 한번 글을 빌어 왜 차세대 프로젝트를 하지 말아야 하는지 말씀드리려고 한다.
차세대 프로젝트는 외부인력이 주도하여 문제를 파악하고 시스템을 완전히 새로 만드는 방법을 취한다. 하지만, 현재 존재하는 시스템에 깊이 침투하여 문제 자체를 명확하게 학습하지 못하면, 해결책을 얻을 수 없다. 문제를 모르는데, 어떻게 해결한다는 말인가? 한국에서 지난 10여년 상식처럼 여겨졌던 차세대 프로젝트는 열심히 하고 못하고를 떠나, 차세대 프로젝트를 한다는 그 자체로 이미 잘못된 길을 가는 것이다. Solution-First라고 불러도 좋을 외산 방법론(CBD, MDD 방법론, MDM 등)이나 솔루션(SAP, Oracle, 미들웨어 등) 납품을 우선해서 시스템을 구축하는 과거의 접근은 문제 파악에는 아무런 도움이 되지 않는다. 어떤 솔루션을 도입했는지에 관계 없이 문제 파악을 충분히 하지 않고, 다시 만들면 문제를 지극히 피상적[3]으로만 파악한 후 해답을 찾으려하여, 결과적으로 도리어 문제를 회피하는 효과를 낳는다.
외산 기술을 빠르게 모방하는 소프트웨어 후진국의 과오를 빨리 인지하고, 이제는 우리의 문제를 정확히 인지하고 자신들의 노하우를 소프트웨어 형태로 축적하는 방법을 익혀야 한다. 그런 이들만이 과거를 빠져나와 후진을 면할 수 있다.

https://www.popit.kr/%EB%8B%A4%EC%96%91%ED%95%9C-%EC%95%84%EA%B8%B0%EB%B0%9C%EA%B1%B8%EC%9D%8C%EC%9C%BC%EB%A1%9C-%EB%B0%B0%EC%9A%B0%EA%B8%B0/

다양한 아기발걸음으로 배우기 | Popit

지난 주에 있던 일이다. 동료 중국 개발자에게 모듈 개념 구현을 설명하기 위해 코드 리뷰를 했다. 코드를 보며 다룬 대화의 내용을 대략 묘사하면 아래 그림과 같다. [caption id="attachment_13446" align

input()과 print()	1.8	1.2	3
sys.stdin.readline()과 sys.stdout.write()	0.3	0.3	0.6