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받긴함

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

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

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

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

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

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

앵커와 별칭

resource_prefix: &resourceprefix Search

yaml내에서 위와 같은 구문이 있을 때, 

resource_prefix 부분은 키에 해당하며, python등 외부 프로그램에서 이 키로 조회하면 맨 오른쪽 Search가 조회된다.

resourceprefix 부분은 앵커에 해당하면 yaml파일내에서 *resourceprefix로 표현하면 Search로 대체된다.

Search부분은 밸류에 해당

즉 &로 표현된 앵커가 빠지면 일반적인 yaml key-value설정인데 중간에 앵커가 들어가서 yaml내 alias기능을 추가했다고 보면 된다. 

INNER JOIN

기존의 where절을 사용하여 두 테이블을 결합하는 방식과 동일

SELECT *
FROM table1, table2
WHERE table1.id = table2.id;

예를 들어 과거방식으로 위처럼 하는것도 inner join이며 아래처럼 명시적으로 INNER JOIN키워드를 사용할수도 있다.

SELECT *
FROM table1
INNER JOIN table2 ON table1.id = table2.id;

내가 볼때는 가독성 측면에서 오히려 퇴화한것 같기는 하지만 아래 소개할 다른 조인과의 통일성 측면에서 이해하면 좋을듯 하다.

LEFT JOIN

그냥 INNER JOIN과 다르게 null허용 조인으로 이해하면 편하다.

예를들어 다음과 같은 쿼리를 생각해보자.

SELECT a.name, b.department
FROM employee_table a
LEFT JOIN department_table b
ON a.department_id = b.department_id;

그럴경우 다음처럼 특정인물이 아직 부서배치 받기 전이더라도 NULL일지언정 조회가 된다(inner조인이었으면 조회에 포함이 안됐을것)

여기 참조

단순 인덱싱을 넘어서는 고급 인덱싱의 한 형태로, 검색어를 통한 indirect 인덱싱형태로 다른 정보들을 가져올때 사용한다.

즉, 검색어를 일종의 포인터 삼아서 다른곳에서 값들을 가져오는것.

주요포인트

• 키워드에 대해서 문서범위를 넘어서는 글로벌 범위에서 가중치를 부여하는게 아님(문서 내 가중치)
• 반환되는 문서의 개수나 종류는 키워드 매칭에 기반하고, payload는 순서나 가중치에만 영향을 줄 수 있음
• 주로 색인시 할당되며, 정적인 정보를 처리한다. 실시간 처리에는 다른 방식이 권장된다.

예시: 뉴스검색

1. Payload를 사용하지 않는 경우 (단순 인덱싱)
검색 쿼리: 사용자가 "블록체인"이라는 키워드로 뉴스 기사를 검색합니다.
인덱싱: 모든 기사에서 "블록체인"이라는 키워드를 포함하는 부분을 색인합니다. 색인은 키워드의 존재 여부에 초점을 맞춥니다.
검색 결과: "블록체인" 키워드를 포함하는 모든 기사가 결과로 반환됩니다. 결과는 키워드의 빈도수나 기사의 일반적인 인기도에 따라 정렬됩니다.
결과의 특징: 반환된 기사들은 "블록체인"이라는 키워드를 포함한다는 공통점이 있지만, 키워드의 위치나 문서 내의 중요도에 따른 차별화된 가중치는 고려되지 않습니다.

2. Payload를 사용하는 경우 (고급 인덱싱)
검색 쿼리: 동일하게 사용자가 "블록체인"이라는 키워드로 뉴스 기사를 검색합니다.
인덱싱과 Payload: 기사 내에서 "블록체인" 키워드가 나타나는 위치(예: 제목, 첫 문단, 본문)에 따라 다른 payload 값을 부여합니다. 제목에 나타날 경우 높은 가중치를, 본문에만 나타날 경우 낮은 가중치를 부여합니다.
검색 결과와 Payload 활용: 검색 결과는 "블록체인" 키워드를 포함하지만, payload 값을 기반으로 정렬됩니다. 이를 통해 제목에 "블록체인"을 포함한 기사가 본문에만 해당 키워드가 있는 기사보다 더 높은 순위에 배치됩니다.
결과의 특징: 검색 결과는 단순히 키워드의 존재 여부를 넘어서, 키워드의 위치와 문서 내 중요도에 따라 세밀하게 조정됩니다. 사용자는 주제에 대해 더 중요하고 관련성 높은 기사를 우선적으로 볼 수 있습니다.

결론
Payload를 사용하지 않는 경우, 검색 결과는 단순히 키워드의 존재와 빈도에 의존합니다. 반면, payload를 사용하는 경우,

검색 결과의 순위나 가중치가 키워드의 문서 내 위치와 맥락에 따라 조정되어 사용자에게 더 관련성 높은 정보를 제공합니다.

영단어 Facet은 보석세공후 한 단면을 의미. Solr에서는 여기서 하나의 측면이라는 의미를 따 왔다.

페이싯 기능은 통계적 정보를 검색결과에 추가한다고 이야기할 수 있으며, 사용자가 대량의 데이터 속에서 필요한 정보를 빠르고 정확하게 찾을 수 있도록 도와주는 강력한 도구로 활용될수 있다.

솔라검색 예시

검색: http://localhost:8983/solr/컬렉션명/select?q=과학&facet=true&facet.field=장르

출력:

{
  "responseHeader":{
    "status":0,
    "QTime":10
  },
  "response":{"numFound":123,"start":0,"docs":[
      {
        "제목":"천체물리학 입문",
        "저자":"스티븐 호킹",
        "장르":"천문학",
        "가격":20000
        // 기타 도서 정보
      },
      // 검색된 다른 책들의 정보
    ]
  },
  "facet_counts":{
    "facet_fields":{
      "장르":[
        "천문학", 34,
        "생물학", 29,
        "물리학", 20,
        "지질학", 10,
        // 기타 장르 및 해당 장르의 책 개수
      ]
    }
  }
}

위에서 facet_counts부분이 facet과 관련되어 추가된 부분이다.

가격관련 facet예시

검색: http://localhost:8983/solr/컬렉션명/select?q=노트북&facet=true&facet.range=가격&facet.range.start=0&facet.range.end=2000000&facet.range.gap=500000

q=노트북: "노트북"이라는 키워드로 검색합니다.
facet=true: 페이싯 기능을 활성화합니다.
facet.range=가격: "가격" 필드를 기준으로 범위 페이싯을 적용합니다.
facet.range.start=0: 가격 범위의 시작을 0원으로 설정합니다.
facet.range.end=2000000: 가격 범위의 끝을 2,000,000원으로 설정합니다.
facet.range.gap=500000: 가격 범위의 간격을 500,000원으로 설정합니다.

출력:

{
  "responseHeader":{
    "status":0,
    "QTime":15
  },
  "response":{"numFound":250,"start":0,"docs":[
      {
        "제품명":"모델 A 노트북",
        "브랜드":"브랜드X",
        "가격":1500000
        // 기타 제품 정보
      },
      // 검색된 다른 노트북들의 정보
    ]
  },
  "facet_counts":{
    "facet_ranges":{
      "가격":{
        "counts":[
          "0-500000", 25,
          "500000-1000000", 75,
          "1000000-1500000", 100,
          "1500000-2000000", 50
        ]
      }
    }
  }
}

다음 코드를 보자(주석을 주의깊게 볼 것)

package org.example;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
public class Main {
	public static void main(String[] args) {
		Flux.just("a", "b", "c", "d")  // 1,2,3,4 네개의 아이템을 순차적으로 방출하는 단일 스트림 생성
			.map(s -> {  // 스레드 분기 없이 호출 스레드에서 해당 스트림 아이템에 대해서 대문자변환 연산수행(아래 .subscribe를 만나기 전까지 지연됨!)
				System.out.println("Map 1 - Thread: " + Thread.currentThread().getName());
				return s.toUpperCase();
			})
			.publishOn(Schedulers.boundedElastic())  //이후 작업은 boundedElastic이라는 사전정의된 별도 스레드에서 하도록 지정함!
			.map(s -> {
				System.out.println("Map 2 - Thread: " + Thread.currentThread().getName());
				return s + "!";
			})
			.subscribe(  // 지연 실행을 시작하는 시점이며, 마지막 스케줄러 지정이 boundedElastic이라 boundedElastic 스레드를 통해 수행됨
				s -> System.out.println("Received " + s + " on Thread: " + Thread.currentThread().getName()));
	}
}

실행결과

> Task :Main.main()
Map 1 - Thread: main
Map 1 - Thread: main
Map 1 - Thread: main
Map 1 - Thread: main
Map 2 - Thread: boundedElastic-1
Received A! on Thread: boundedElastic-1
Map 2 - Thread: boundedElastic-1
Received B! on Thread: boundedElastic-1
Map 2 - Thread: boundedElastic-1
Received C! on Thread: boundedElastic-1
Map 2 - Thread: boundedElastic-1
Received D! on Thread: boundedElastic-1

예제를 조금 수정한 코드를 보자.

package org.example;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
public class Main {
	public static void main(String[] args) {
		Flux.just(1, 2, 0, 4)  // 1,2,0,4 네개의 아이템을 순차적으로 방출하는 단일 스트림 생성
			.map(n -> {  // 스레드 분기 없이 호출 스레드에서 해당 스트림 아이템에 대해서 나누기변환 연산수행(아래 .subscribe를 만나기 전까지 지연됨!)
				System.out.println("Map 1 - Thread: " + Thread.currentThread().getName());
				return 10 / n;
			})
			.publishOn(Schedulers.boundedElastic())  //이후 작업은 boundedElastic이라는 사전정의된 별도 스레드에서 하도록 지정함!
			.map(s -> {
				System.out.println("Map 2 - Thread: " + Thread.currentThread().getName());
				return s + "!";
			})
			.doOnNext(s -> {  // 스트림에 영향을 주지 않으면 로깅등 부가작업을 할때 사용
				System.out.println("doOnNext - Thread: " + Thread.currentThread().getName() + " with value: " + s);
			})
			.doOnError(error -> {  // Exception이 발생한 경우만 여기로 떨어진다.
				System.out.println("Error occurred - Thread: " + Thread.currentThread().getName() + " with error: " + error.getMessage());
			})
			.subscribe(  // 지연 실행을 시작하는 시점이며, 마지막 스케줄러 지정이 boundedElastic이라 boundedElastic 스레드를 통해 수행됨
				s -> System.out.println("Received " + s + " on Thread: " + Thread.currentThread().getName()));
		// boundElastic스레드로 중간에 분기되기 때문에 이 출력이 마지막 줄이 아닐 수 있다!
		// 자바에서는 main함수가 종료되더라도 다른 스레드가 강제종료되지 않는다!
		System.out.println("main end");
	}
}

실행결과

> Task :Main.main()
Map 1 - Thread: main
Map 1 - Thread: main
Map 1 - Thread: main
Map 2 - Thread: boundedElastic-1
doOnNext - Thread: boundedElastic-1 with value: 10!
Received 10! on Thread: boundedElastic-1
Map 2 - Thread: boundedElastic-1
doOnNext - Thread: boundedElastic-1 with value: 5!
Received 5! on Thread: boundedElastic-1
main end
Error occurred - Thread: boundedElastic-1 with error: / by zero

이 예시에서는 onDoNext, onDoError, main end시 스레드 종료 개념을 추가적으로 배울 수 있다.

주석을 주의깊에 보면 되기 때문에 따로 설명은 안하겠다.