Sevity Blog

인풋파싱

아래는 4개 숫자를 stdin에서 읽어오는 코드

import sys
input = sys.stdin.readline

# 입력 받기: H, W, N, M
H, W, N, M = map(int, input().split())

숫자하나 + 문자열리스트

3
MBC
KBS1
KBS2

인풋이 위와 같을때

import sys
input = sys.stdin.readline

# 채널의 수 N을 입력받음
N = int(input().strip())

# N개의 채널 이름을 리스트로 입력받음
channels = [input().strip() for _ in range(N)]

기본문법

기본 for루프

for y in range(H):

N+1개씩 건너뛰기

for y in range(0, H, N+1):  # 행을 N+1씩 건너뛰며 반복

주의사항들

재귀관련해서 메모아이제이션과 호출깊이가 깊을때 조정코드(N=1000이라도 아래코드 필요)

import sys
sys.setrecursionlimit(10**6)  #여기1

from functools import lru_cache
input = sys.stdin.readline

N = int(input().strip())

@lru_cache(maxsize=None) #여기2
def go(remain):
    if remain == 0:
        return False
    if not go(remain-1):
        return True
    if remain >=3 and not go(remain-3):
        return True
    return False
    
print("SK" if go(N) else "CY")

단순구현부터 해봤는데 역시 TLE난다.

#include <string>
#include <vector>

using namespace std;
typedef long long ll;

// 뭐지 단순 구현문제인가.. long long이라 아닐거 같기도 하고 흠..
long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    //일단 단순 구현해보자.
    for(ll a=0;a<1000000;a++)for(ll b=0;b<1000000;b++){
        if(k*k*a*a+k*k*b*b<=d*d) {
            //printf("(%d,%d),", a*k,b*k);
            answer++;
        }
        else break;
    }
    return answer;
}

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

// 뭐지 단순 구현문제인가.. long long이라 아닐거 같기도 하고 흠..
long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    //일단 단순 구현해보자.
    for(ll a=0;a<1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) continue;
        double bb = sqrt((double)s)/(double)k;
        //if(bb<0) continue;
        //printf("%lld\n", bb);
        answer+=bb+1;
    }
    return answer;
}

이건 일부 케이스WA나네..

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    for(ll a=0;a<=1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) break;
        ll bb = sqrt(s)/k;
        answer+=bb+1;
    }
    return answer;
}

뭐지? 1000000포함안시킨거랑 double연산 때문에 WA났던거네?

double연산시 오류나는건 좀 그렇네.. 흠..

아이디어 자체는 chatGPT랑 동일하다.

#include <string>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

long long solution(int _k, int _d) {
    ll k=_k,d=_d;
    ll answer = 0;
    for(ll a=0;a<=1000000;a++) {
        ll s = d*d-a*a*k*k;
        if(s<0) break;
        double bb = (double)sqrt(s)/k;
        answer+=(ll)(bb+1e-9)+1;
    }
    return answer;
}

double은 위처럼 하면 되는거 보니, 형변환시 문제인거 같다. 2.0이 1.999로 되는등..

으허.. 머리에 쥐나긴했는데.. chatGPT한테 힌트 받고 스스로 풀긴했다 ㄷ

재귀를 통해서 하는건데.. 알아두면 두고두고 써먹을거 같긴하다.

#include <bits/stdc++.h>
using namespace std;

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

typedef long long ll;

ll length[21];
ll val[21];//val[3]이면 F(3)일때 1의 개수

ll solution_sub(int n, ll l, ll r) {
    if (n <= 0) return 1;
    ll answer = 0;
    if (n == 1) {
        for (int i = l; i <= r; i++) {
            if (i != 3) answer += 1;
        }
        return answer;
    }

    //n에 대해서 5등분 해서 재귀로 들어가면 되지 않을까?
    ll lx = (l - 1) / length[n - 1] + 1;
    ll rx = (r - 1) / length[n - 1] + 1;

    ll nl = l - length[n - 1] * ((l - 1) / length[n - 1]);
    ll nr = r - length[n - 1] * ((r - 1) / length[n - 1]);


    if (lx == rx) {
        if(lx!=3) answer += solution_sub(n - 1, nl, nr);
    } else {
        //왼쪽

        //answer += solution_sub(n - 1, l - length[n-1]*((l-1)/length[n-1]), r - length[n - 1] * ((r - 1) / length[n - 1]));
        ll nl = l - length[n - 1] * ((l - 1) / length[n - 1]);
        ll nr = r - length[n - 1] * ((r - 1) / length[n - 1]);
        ll a = ((l - 1) / length[n - 1] + 1) * length[n - 1];
        ll rv = nr; if (r > a) rv = length[n - 1];
        if(lx!=3) answer += solution_sub(n - 1, nl, rv);

        //오른쪽
        a = ((r - 1) / length[n - 1]) * length[n - 1];
        ll lv = nl; if (l < a) lv = 1;
        if(rx!=3) answer += solution_sub(n - 1, lv, nr);

        //중간
        for (int i = lx + 1; i < rx; i++) {
            if (i != 3) answer += val[n - 1];
        }

    }
    return answer;
}


ll solution(int n, ll l, ll r) {
    length[1] = 5; for (int i = 2; i <= 21; i++) length[i] = length[i - 1] * 5;
    val[1] = 4; for (int i = 2; i <= 21; i++) val[i] = val[i - 1] * 4;

    return solution_sub(n, l, r);
}

int main() {
    cout << solution(3, 35, 102) << endl;
    // 예시 입력: n = 2, l = 4, r = 17 → 결과는 8이어야 함
    cout << solution(2, 4, 17) << endl;

    return 0;
}

초기구현.. 거의 한번에 AC받긴함

1. RDD
   • 초창기 Spark가 제공하던 가장 기본적인 분산 데이터 구조
   • 스키마/최적화 부재 → 낮은 수준의 유연성은 높지만, 최적화 성능은 DataFrame/Dataset보다 떨어질 수 있음
2. DataFrame
   • 스키마가 있는 구조화된 데이터셋(Dataset[Row])
   • SQL-like 문법, Catalyst 최적화로 사용 편의성 및 성능 측면에서 개선
   • 컬럼 접근 시 컴파일 타임 타입 체크가 안 됨 → 런타임 오류 가능성
3. Dataset
   • DataFrame의 장점(스키마, 최적화) + RDD의 장점(타입 안정성)을 모두 제공
   • 스칼라의 케이스 클래스 등에 매핑해 사용하면 컴파일 시점에 타입을 체크
   • Spark SQL의 강력한 최적화 엔진(Catalyst) 적용 가능

결국, 데이터에 스키마가 있고 SQL 연산을 자주 사용한다면 DataFrame/Dataset을 추천하고, 추가로 컴파일 시점의 타입 안전성을 원한다면 Dataset을 사용하는 편이 좋습니다. 아직도 아주 범용적이거나, 스키마 없이 자유로운 처리가 필요한 상황(저수준 제어 등)에서는 RDD를 쓰기도 하지만, 일반적인 애플리케이션에서는 주로 DataFrame/Dataset을 사용해 개발/성능 양쪽을 만족시킵니다.

RDD와 List자료구조와의 차이

“방대하게 분산 처리되는 부분”이나 “불변(Immutable)” 같은 특성을 잠시 제쳐두고, 코드를 짤 때 RDD를 다루는 경험적 관점으로 보자면, 일반적인 컬렉션(List나 Seq 같은)을 ‘함수형 스타일’로 조작하는 느낌과 꽤 유사합니다.

• filter, map, flatMap, reduce 등 함수형 연산을 체인으로 연결해 쓰는 방식이, 스칼라의 List나 Seq에 있는 메서드와 유사하기 때문입니다.
• 다만 RDD는 **‘지연 평가(Lazy Evaluation)’**라서, map, filter 등으로 변환(Transformation)을 쌓아두다가, 최종적으로 collect(), count() 등의 **액션(Action)**을 호출할 때 한 번에 계산을 실행한다는 점이 가장 다른 부분입니다.

그래서 “분산, 불변” 등을 빼고 보면, 개발자 입장에서 연산을 작성하는 흐름은 오히려 스칼라의 List/Seq보다 스칼라의 Stream(Lazy)이나 자바의 Stream API 같은 지연성 컬렉션에 더 가깝다고 볼 수도 있습니다.

1. 함수형 메서드 체인
   • map, filter, flatMap 식으로 컬렉션을 변환하는 점은 List나 Seq와 유사
2. 지연 평가
   • RDD는 변환을 쌓아두고, 액션을 만나야 계산을 실행하는 특성이 있으므로,
   • 일반적인 즉시 평가형 List보다는 지연(Lazy) 컬렉션 혹은 자바의 Stream에 더 가깝다.
3. 불변/분산을 배제한다 해도, “RDD = 일종의 큰 컬렉션을 함수형 연산으로 다룬다”는 점에서,
   • 개발자 입장에서는 ‘(Lazy)Seq’나 ‘Stream’을 다루는 것과 유사한 경험이 될 것이다.

결국, “방대한 분산 처리”나 “불변”을 잠시 잊고, 코드를 작성·사용하는 관점만 놓고 보면,

• 스칼라의 List/Seq에 함수형 메서드를 적용하는 방식과 상당히 닮았고,
• 평가 시점이 지연된다는 점에서는 **Lazy 컬렉션(Stream류)**에 더 가깝다고 볼 수 있습니다.

Competitive Progrmming Helper의 약자로 백준같은 사이트에서 testcase같은걸 긁어다가 vscode에서 할 수 있게 해준다.

chrome에서도 확장프로그램을 설치해야하고(Competitive Companion)

vscode에서도 확장을 설치해야한다(Competitive Programming Helper)

원격ssh로 실행하는 경우는 포트전달이 필요할수도 있다.

왼쪽 하단 SSH부분 클릭해서 연결정보를 설정해준다.

처음에 Linux냐 Windows냐 mac이냐를 묻는 화면이 지속적으로 나온다면 Ctrl+,를 누른다음 위처럼 remote.ssh.remotePlatform을 검색해서 해당 ip에 대한 값을 linux등으로 정해주면 된다.

https://www.coupang.jobs/en/jobs/job/senior-staff-back-end-engineer-advertiser-platform-5673805/?gh_jid=5673805

여기, 여기가 이해하기 쉬운편

다만 TF-IDF실제 계산 수치가 따로 해보면 똑같이 잘 안나온다.

Q. TF-IDF계산하면 원본 문장에서 단어별로 TF-IDF스칼라 값이 하나 나온다?

A. 맞다.

TF-IDF는 여기 참조

예시코드

from sklearn.feature_extraction.text import TfidfVectorizer
text_data = ['사과 바나나 자동차', '바나나 자동차 기차',
    '자동차 기차 사과 포도', '바다 사과 기차 여름']
    
tfidfvec = TfidfVectorizer()

tfidfvec.fit(text_data)
print("Vocabulary: ", tfidfvec.vocabulary_)


sentence = [text_data[0]]
print(sentence)
print(tfidfvec.transform(sentence).toarray())

결과

Vocabulary:  {'사과': 3, '바나나': 1, '자동차': 5, '기차': 0, '포도': 6, '바다': 2, '여름': 4}
['사과 바나나 자동차']
[[0.         0.65782931 0.         0.53256952 0.         0.53256952
  0.        ]]

보면 알겠지만 '사과 바나나 자동차' 입력 문장에서의 단어개수가 아닌 전체 단어개수(기차0부터 포도6까지 7개)에 해당하는 벡터가 생성된다.

직접 tf-idf값을 계산해보려면 아래 참조

여기참조

from sklearn.feature_extraction.text import CountVectorizer

documents = [
    'Hello, how are you? hello',
    'I am fine, thank you.'
]

# CountVectorizer 인스턴스 생성
vectorizer = CountVectorizer()

# 문서를 피팅하고 변환
X = vectorizer.fit_transform(documents)

# 결과를 배열로 변환
X_array = X.toarray()

# 어휘 출력
print("Vocabulary: ", vectorizer.vocabulary_)

# 문서-단어 행렬 출력
print("Document-Term Matrix:\n", X_array)

결과

Vocabulary:  {'hello': 3, 'how': 4, 'are': 1, 'you': 6, 'am': 0, 'fine': 2, 'thank': 5}
Document-Term Matrix:
 [[0 1 0 2 1 0 1]
 [1 0 1 0 0 1 1]]

Vocabulary는 단어별로 인덱스를 생성해주는 과정이고,

Document-Term Matrix를 통해 문자열을 벡터화 해준다. 

벡터화 방법은 인덱스 위치별 등장횟수를 카운팅하는 단순한 방법이다.

특징

* 단어를 벡터로 표현한게 아니라. 문장(또는 문서) 전체가 하나의 벡터로 표현된다.

CountVector를 통한 스펨메일분류기 만들기

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# 샘플 데이터: 이메일 텍스트와 스팸 여부
emails = ["Free money now!!!", "Hi Bob, how about a game of golf tomorrow?", "Exclusive offer, limited time only"]
labels = [1, 0, 1]  # 1: 스팸, 0: 비스팸

# CountVectorizer로 텍스트 벡터화
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(emails)
# 결과를 배열로 변환
X_array = X.toarray()

# 어휘 출력
print("Vocabulary: ", vectorizer.vocabulary_)

# 문서-단어 행렬 출력
print("Document-Term Matrix:\n", X_array)

y = labels

# 데이터를 훈련 세트와 테스트 세트로 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# 로지스틱 회귀 모델 훈련
model = LogisticRegression()
model.fit(X_train, y_train)

# 스팸 탐지 테스트
print(model.score(X_test, y_test))

결과

Vocabulary:  {'free': 3, 'money': 9, 'now': 10, 'hi': 6, 'bob': 1, 'how': 7, 'about': 0, 'game': 4, 'of': 11, 'golf': 5, 'tomorrow': 15, 'exclusive': 2, 'offer': 12, 'limited': 8, 'time': 14, 'only': 13}
Document-Term Matrix:
 [[0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0]
 [1 1 0 0 1 1 1 1 0 0 0 1 0 0 0 1]
 [0 0 1 0 0 0 0 0 1 0 0 0 1 1 1 0]]
1.0

문장에서 벡터로 변환하는 방법이 단순하여 실용성은 적다.

하지만 자주 등장하는 단어가 주요하게 쓰이는 경우도 있고, 특징 추출의 기본이기 때문에 알아두어야한다.