문제 주소
https://school.programmers.co.kr/learn/courses/30/lessons/138477
프로그래머스
코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.
programmers.co.kr
문제 설명
"명예의 전당"이라는 TV 프로그램에서는 매일 1명의 가수가 노래를 부르고, 시청자들의 문자 투표수로 가수에게 점수를 부여합니다. 매일 출연한 가수의 점수가 지금까지 출연 가수들의 점수 중 상위 k번째 이내이면 해당 가수의 점수를 명예의 전당이라는 목록에 올려 기념합니다. 즉 프로그램 시작 이후 초기에 k일까지는 모든 출연 가수의 점수가 명예의 전당에 오르게 됩니다. k일 다음부터는 출연 가수의 점수가 기존의 명예의 전당 목록의 k번째 순위의 가수 점수보다 더 높으면, 출연 가수의 점수가 명예의 전당에 오르게 되고 기존의 k번째 순위의 점수는 명예의 전당에서 내려오게 됩니다.
이 프로그램에서는 매일 "명예의 전당"의 최하위 점수를 발표합니다. 예를 들어, k = 3이고, 7일 동안 진행된 가수의 점수가 [10, 100, 20, 150, 1, 100, 200]이라면, 명예의 전당에서 발표된 점수는 아래의 그림과 같이 [10, 10, 10, 20, 20, 100, 100]입니다.
명예의 전당 목록의 점수의 개수 k, 1일부터 마지막 날까지 출연한 가수들의 점수인 score가 주어졌을 때, 매일 발표된 명예의 전당의 최하위 점수를 return하는 solution 함수를 완성해주세요.
제한사항
- 3 ≤ k ≤ 100
- 7 ≤ score의 길이 ≤ 1,000
- 0 ≤ score[i] ≤ 2,000
입출력 예
k score result
| 3 | [10, 100, 20, 150, 1, 100, 200] | [10, 10, 10, 20, 20, 100, 100] |
| 4 | [0, 300, 40, 300, 20, 70, 150, 50, 500, 1000] | [0, 0, 0, 0, 20, 40, 70, 70, 150, 300] |
입출력 예 설명
입출력 예 #1
- 문제의 예시와 같습니다.
입출력 예 #2
- 아래와 같이, [0, 0, 0, 0, 20, 40, 70, 70, 150, 300]을 return합니다.
풀이과정
Java collection max가 있으면 편할듯
매번 배열 원소 바꿔주기 귀찮아서
List<Integer> numbers = List.of(4, 0, 5, 2, 7, 1, 8, 6, 9, 3);
int max = numbers.isEmpty() ? -1 : Collections.max(numbers);
System.out.println("Max: " + max); // Max: 9
List<Integer> numbers = List.of(4, 0, 5, 2, 7, 1, 8, 6, 9, 3);
int min = numbers.isEmpty() ? -1 : Collections.min(numbers);
System.out.println("Min: " + min); // Min: 0
List<Integer> numbers = List.of(4, 0, 5, 2, 7, 1, 8, 6, 9, 3);
int max = numbers.stream().max(Integer::compare).orElse(-1);
System.out.println("Max: " + max); // Max: 9
아 근데 저게 더 이상한 거 같아
3이 최소값인거 알고있으면 되는건데
min을 매번 구하느냐 배열 원소를 매번 갈아끼우느냐 그것이 문제로다
그냥 배열 순회하는게 나을지경인데 갈아끼우는것보다 ㅋㅋㅋㅋ
ㄴㄴ 그냥 배열 바꾸는게 제일 간편함
ㄴㄴ remove() 하고 add() 를 index로 하는게 제일 간편함
List add by index
list.add(3, "D");
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
ArrayList<Integer> grand = new ArrayList<Integer>();
for(int i = 0; i < score.length ; i++){
if(grand.size()<k){
grand.add(score[i]);
answer[i] = score[i];
}else{
int min = grand.get(0);
for(int j = 0; j < grand.size() ; j++){
if(grand.get(j)<score[i]){
grand.remove(i);
grand.add(score[i],j);
}
if(min>grand.get(j)){
min = grand.get(i);
}
}
}
}
return answer;
}
}
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 3 out of bounds for length 3
grand에서 에러났나
if(grand.size()<k){ -> if(grand.size()<=k){
grand.add(score[i]);
answer[i] = score[i];
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
ArrayList<Integer> grand = new ArrayList<Integer>();
for(int i = 0; i < score.length ; i++){
if(grand.size()<=k){
grand.add(score[i]);
answer[i] = score[i];
}else{
int min = grand.get(0);
for(int j = 0; j < grand.size() ; j++){
if(grand.get(j)<score[i]){
grand.remove(i);
grand.add(score[i],j);
}
if(min>grand.get(j)){
min = grand.get(i);
}
}
}
}
return answer;
}
}
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 5 out of bounds for length 4
아 뭔가 복잡해서 전처리과정을 분리함
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
ArrayList<Integer> grand = new ArrayList<Integer>();
for(int i = 0; i<=k;i++){
grand.add(score[i]);
answer[i] = score[i];
}
for(int i = k+1; i < score.length ; i++){
int min = grand.get(0);
for(int j = 0; j < grand.size() ; j++){
if(grand.get(j)<score[i]){
grand.remove(i);
grand.add(score[i],j);
}
if(min>grand.get(j)){
min = grand.get(i);
}
}
}
return answer;
}
}
grand.remove(i) → grand.remove(j);
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
ArrayList<Integer> grand = new ArrayList<Integer>();
for(int i = 0; i<=k;i++){
grand.add(score[i]);
answer[i] = score[i];
}
for(int i = k+1; i < score.length ; i++){
int min = grand.get(0);
for(int j = 0; j < grand.size() ; j++){
if(grand.get(j)<score[i]){
grand.remove(j);
grand.add(score[i],j);
}
if(min>grand.get(j)){
min = grand.get(i);
}
}
}
return answer;
}
}
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 100, Size: 3
헤엑 인덱스 100이 어케나온 숫자여
size가 나온거 보니까 List를 잘못읽고있나본데
List size 지정해봄
ArrayList<Integer> grand = new ArrayList<Integer>(k);
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 70, Size: 4
인덱스가 왜저러는데 대체
for(int j = 0; j < k ; j++){
로 바꿈
grand.add(score[i],j);
min = grand.get(j); i였던거 바꿈
grand.add(score[i],j); → grand.add(j,score[i]);
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
ArrayList<Integer> grand = new ArrayList<Integer>(k);
for(int i = 0; i<=k;i++){
grand.add(score[i]);
answer[i] = score[i];
}
for(int i = k+1; i < score.length ; i++){
int min = grand.get(0);
for(int j = 0; j <= k ; j++){
if(grand.get(j)<score[i]){
grand.remove(j);
grand.add(j,score[i]);
}
if(min>grand.get(j)){
min = grand.get(j);
}
}
answer[i] = min;
}
return answer;
}
}
드디어 에러 사라짐
테스트 1
입력값 〉3, [10, 100, 20, 150, 1, 100, 200]
기댓값 〉[10, 10, 10, 20, 20, 100, 100]
실행 결과 〉실행한 결괏값 [10,100,20,150,10,10,100]이 기댓값 [10,10,10,20,20,100,100]과 다릅니다.
테스트 2
입력값 〉4, [0, 300, 40, 300, 20, 70, 150, 50, 500, 1000]
기댓값 〉[0, 0, 0, 0, 20, 40, 70, 70, 150, 300]
실행 결과 〉실행한 결괏값 [0,300,40,300,20,0,70,150,150,500]이 기댓값 [0,0,0,0,20,40,70,70,150,300]과 다릅니다.
생각해보니 grand에 넣으면서 min을 판별하면 과정이 꼬일거같음 grand에 제일 큰거 넣는거랑 min을 answer에 넣는 걸 분리함
아 근데 하다보니 저게 더 비효율적이고 이상한 거 같아서 그냥 배열로 하기로 함 ㅋㅋ
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];
}
for(int i = grand.length; i < score.length ; i++){
System.out.println("score"+i+" : "+score[i]);
for(int j = 0; j <grand.length ; j++){
System.out.println("grand"+j+" : "+grand[j]);
if(grand[j]<score[i]){
grand[j] = score[i];
}
}
int min = grand[0];
for(int j = 0; j <grand.length ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
return answer;
}
}
score4 : 1
grand0 : 150
grand1 : 150
grand2 : 150
break를 넣어줘야할듯 한번만 삽입해야지…
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];
}
for(int i = grand.length; i < score.length ; i++){
System.out.println("score"+i+" : "+score[i]);
for(int j = 0; j <grand.length ; j++){
System.out.println("grand"+j+" : "+grand[j]);
if(grand[j]<score[i]){
grand[j] = score[i];
break;
}
}
int min = grand[0];
for(int j = 0; j <grand.length ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
return answer;
}
}
실행한 결괏값 [0,0,0,20,20,100,100]이 기댓값 [10,10,10,20,20,100,100]과 다릅니다.
아까 분리했던 grand[i] = score[i] 다시 넣음 ㅋㅋ
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
for(int i = grand.length; i < score.length ; i++){
System.out.println("score"+i+" : "+score[i]);
for(int j = 0; j <grand.length ; j++){
System.out.println("grand"+j+" : "+grand[j]);
if(grand[j]<score[i]){
grand[j] = score[i];
break;
}
}
int min = grand[0];
for(int j = 0; j <grand.length ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
return answer;
}
}
테스트 1입력값 〉3, [10, 100, 20, 150, 1, 100, 200]기댓값 〉[10, 10, 10, 20, 20, 100, 100]실행 결과 〉테스트를 통과하였습니다.
출력 〉
score3 : 150
grand0 : 10
score4 : 1
grand0 : 150
grand1 : 100
grand2 : 20
score5 : 100
grand0 : 150
grand1 : 100
grand2 : 20
score6 : 200
grand0 : 150
테스트 2입력값 〉4, [0, 300, 40, 300, 20, 70, 150, 50, 500, 1000]기댓값 〉[0, 0, 0, 0, 20, 40, 70, 70, 150, 300]
실행 결과 〉실행한 결괏값 [0,0,0,0,20,40,40,50,50,50]이 기댓값 [0,0,0,0,20,40,70,70,150,300]과 다릅니다.
출력 〉
score4 : 20
grand0 : 0
score5 : 70
grand0 : 20
score6 : 150
grand0 : 70
score7 : 50
grand0 : 150
grand1 : 300
grand2 : 40
score8 : 500
grand0 : 150
score9 : 1000
grand0 : 500
grand가 왜 하나뿐이여
break 했으니까요
if(grand[j]<score[i]){
grand[j] = score[i];
break;
}
아 뭔가 근본적으로 잘못됐음
크면 바로 삽입해 버리니까 0이 아래에 있다면 위만 바뀌고 0은 그대로 가는거임 바로 바꾸지 말고 min이랑 교체해야지
근데 그럼 지금 방식으로 하면
기존 min 구하려고 for문 한번 돌리고
넣고
새 min구하려고 for문 한번 돌려야 함
for(int i = grand.length; i<score.length;i++){
int minIdx = 0;
boolean isBigger = false;
for(int j = 0; j < grand.length ; j++){
if(score[i]>grand[j]){
isBigger = true;
}
if(grand[minIdx]>grand[j]){
minIdx = j;
}
}
if(isBigger){
grand[minIdx]=score[i];
}
answer[i] = grand[minIdx];
}
if(isBigger){
grand[minIdx]=score[i];
}
answer[i] = grand[minIdx];
이러면 최솟값이 아니라 최신값만 리턴되잖아요…
Arrays.sort로 정렬해서 넣자 ㅎ
Arrays.sort(a, Collections.reverseOrder());
sort없이 풀 수 없는 문제를 sort없이 풀겠다고 난리쳐서 이렇게 풀이과정이 길어진듯함 ㅎㅎ
import java.util.Arrays;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
for(int i = grand.length; i<score.length;i++){
int minIdx = 0;
boolean isBigger = false;
for(int j = 0; j < grand.length ; j++){
if(score[i]>grand[j]){
isBigger = true;
}
if(grand[minIdx]>grand[j]){
minIdx = j;
}
}
if(isBigger){
grand[minIdx]=score[i];
}
Arrays.sort(grand);
answer[i] = grand[0];
}
return answer;
}
}
테스트 9 〉 실패 (런타임 에러)
| 테스트 10 〉 | 통과 (0.05ms, 75.9MB) |
| 테스트 11 〉 | 실패 (런타임 에러) |
런타임 에러는 인덱스 잘못 읽었을때 뜰 확률이 높던데
대체 어디서 런타임 에러가 날까?
의문입니다
/*처음에는 거르는거 없이 다 넣음*/
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];//런타임에러 생각해봐 score이 grand보다 작으면 여기서 나겠지
여태까지 당연하게 score이 클거라 생각했는데 ..? 그런 조항 딱히 없는거 같기도 하고
/*처음에는 거르는거 없이 다 넣음*/
if(score.length>grand.length){
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];//런타임에러 생각해봐 score이 grand보다 작으면 여기서 나겠지
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
}
이렇게 묶어서 넘겼더니 런타임 에러 사라짐
테스트 1 〉 통과 (0.56ms, 76.3MB)
| 테스트 2 〉 | 통과 (4.71ms, 79.9MB) |
| 테스트 3 〉 | 통과 (0.53ms, 78.4MB) |
| 테스트 4 〉 | 통과 (0.46ms, 73.5MB) |
| 테스트 5 〉 | 통과 (0.57ms, 73.6MB) |
| 테스트 6 〉 | 통과 (0.50ms, 89MB) |
| 테스트 7 〉 | 통과 (0.50ms, 73MB) |
| 테스트 8 〉 | 통과 (0.53ms, 72.9MB) |
| 테스트 9 〉 | 실패 (0.02ms, 66.8MB) |
| 테스트 10 〉 | 실패 (0.02ms, 71.9MB) |
| 테스트 11 〉 | 실패 (0.01ms, 64.8MB) |
| 테스트 12 〉 | 통과 (4.25ms, 79MB) |
| 테스트 13 〉 | 통과 (2.72ms, 78.6MB) |
| 테스트 14 〉 | 통과 (2.39ms, 78.7MB) |
| 테스트 15 〉 | 통과 (5.68ms, 85.5MB) |
| 테스트 16 〉 | 통과 (4.35ms, 82MB) |
| 테스트 17 〉 | 통과 (4.62ms, 78.8MB) |
| 테스트 18 〉 | 통과 (5.38ms, 78.4MB) |
| 테스트 19 〉 | 통과 (0.86ms, 77.6MB) |
| 테스트 20 〉 | 통과 (0.82ms, 66.3MB) |
| 테스트 21 〉 | 통과 (1.02ms, 85.7MB) |
| 테스트 22 〉 | 통과 (0.90ms, 77.3MB) |
| 테스트 23 〉 | 통과 (1.00ms, 83.8MB) |
| 테스트 24 〉 | 통과 (1.02ms, 82.4MB) |
| 테스트 25 〉 | 통과 (0.98ms, 79.4MB) |
| 테스트 26 〉 | 통과 (0.47ms, 68.9MB) |
import java.util.Arrays;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
/*처음에는 거르는거 없이 다 넣음*/
if(score.length>grand.length){
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];//런타임에러 생각해봐 score이 grand보다 작으면 여기서 나겠지
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
}else{//score이 grand보다 작으면 어떤 식으로 등록해야 할까
for(int i = 0; i<grand.length;i++){
if(i<score.length){
grand[i] = score[i];//런타임에러 생각해봐 score이 grand보다 작으면 여기서 나겠지
}else{
grand[i] = score[score.length-1];//어차피 들어있는 값이겠지...
}
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
}
/*이제 min보다 크다면 min빼고 넣음*/
for(int i = grand.length; i<score.length;i++){
int minIdx = 0;
boolean isBigger = false;
for(int j = 0; j < grand.length ; j++){
if(score[i]>grand[j]){
isBigger = true;
}
if(grand[minIdx]>grand[j]){
minIdx = j;
}
}
if(isBigger){
grand[minIdx]=score[i];
}
Arrays.sort(grand);
answer[i] = grand[0];
}
return answer;
}
}
한줄씩 주석처리하고 제출해서 어디서 런타임에러가 나는지 알아보기로 함
else{//런타임에러와 상관있다
for(int i = 0; i<grand.length;i++){
if(i<score.length){
//grand[i] = score[i];//런타임에러 생각해봐 score이 grand보다 작으면 여기서 나겠지 그래서 if문 줬잖
}else{
grand[i] = score[0];//여기서 런타임 에러가 나나요???? 0넣어도 마찬가지같은데 한번 바꿔봄 여기가 문제가 아닌거같음
}
int min = grand[0];
for(int j = 0; j <=i ; j++){//여기도 생각하셔야 합니다 아하,, 이건 grand만 읽는뎁쇼
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
}
런타임에러 아직 난다
테스트 9 〉 실패 (런타임 에러)
| 테스트 10 〉 | 실패 (0.06ms, 67.6MB) |
| 테스트 11 〉 | 실패 (런타임 에러) |
}else{//런타임에러와 상관있다
for(int i = 0; i<grand.length;i++){
if(i<score.length){
grand[i] = score[i];//런타임제외
}else{
grand[i] = score[0];//런타임제외
}
int min = grand[0];
for(int j = 0; j <=i ; j++){//여기도 생각하셔야 합니다 아하,, 이건 grand만 읽는뎁쇼
if(min>grand[j]){
min = grand[j];//런타임 제외
}
}
//answer[i] = min;
}
}
와 생각지도 못한
//answer[i] = min;
여기를 제외했더니 런타임 에러 사라짐
테스트 9 〉 실패 (0.06ms, 78.6MB)
| 테스트 10 〉 | 실패 (0.06ms, 73.1MB) |
| 테스트 11 〉 | 실패 (0.07ms, 67MB) |
else{//런타임에러와 상관있다
for(int i = 0; i<grand.length;i++){
if(i<score.length){
grand[i] = score[i];
}else{
grand[i] = score[0];
}
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
if(i<score.length){
answer[i] = min;
}else{
//안 넣으면 되지 않을까... 이미 다 찼을테니까
}
//answer[i] = min;//런타임에러 발생지 매우 당황스러워요 지금 ..? scope안에 min이 있는데요???? 그럼 i가 없나봄 아하
}
저 부분도 케이스분리했더니 통과됨
와 score이 grand보다 작은 경우는 생각도 못했는데 충격적임 매우
제출 코드
import java.util.Arrays;
import java.util.Collections;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
int[] grand = new int[k];
/*처음에는 거르는거 없이 다 넣음*/
if(score.length>grand.length){
for(int i = 0; i<grand.length;i++){
grand[i] = score[i];
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
answer[i] = min;
}
}else{
for(int i = 0; i<grand.length;i++){
if(i<score.length){
grand[i] = score[i];
}else{
grand[i] = score[0];
}
int min = grand[0];
for(int j = 0; j <=i ; j++){
if(min>grand[j]){
min = grand[j];
}
}
if(i<score.length){
answer[i] = min;
}
}
}
/*이제 min보다 크다면 min빼고 넣음*/
for(int i = grand.length; i<score.length;i++){
int minIdx = 0;
boolean isBigger = false;
for(int j = 0; j < grand.length ; j++){
if(score[i]>grand[j]){
isBigger = true;
}
if(grand[minIdx]>grand[j]){
minIdx = j;
}
}
if(isBigger){
grand[minIdx]=score[i];
}
Arrays.sort(grand);
answer[i] = grand[0];
}
return answer;
}
}
뭔가 쓸데없이 복잡하게 됨
다른 사람의 풀이
import java.util.*;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
int temp = 0;
for(int i = 0; i < score.length; i++) {
priorityQueue.add(score[i]);
if (priorityQueue.size() > k) {
priorityQueue.poll();
}
answer[i] = priorityQueue.peek();
}
return answer;
}
}import java.util.*;
class Solution {
public int[] solution(int k, int[] score) {
int[] answer = new int[score.length];
PriorityQueue<Integer> pq = new PriorityQueue<>();
for(int i=0; i<score.length; i++){
if(pq.size()==k){
if(pq.peek()<score[i]){
pq.poll();
pq.offer(score[i]);
}
}else{
pq.offer(score[i]);
}
answer[i] = pq.peek();
}
return answer;
}
}자료구조를 잘 쓰자...
class solution{
public intll solution(int k, int] score) {
int[] answer = new int[score.length];
List<Integer> scoreList = new ArrayList<>();
for (int i = 0; i < score. length; i++) {
scoreList. add( score[i]);
if (scoreList. size) > k) {
scoreList. remove(Collections. min(scoreList));
}
answer[i] = Collections.min(scoreList);
}
return answer;
}
}k번까지 넣는거 케이스분류 따로 할 필요도 없고 sort할 필요도 없어서 굉장히 좋은 풀이라고 생각함
'Coding Test' 카테고리의 다른 글
| [프로그래머스] 카드 뭉치 (0) | 2023.11.30 |
|---|---|
| [프로그래머스]과일장수 (1) | 2023.11.30 |
| [프로그래머스]기사단원의 무기 (1) | 2023.11.30 |
| [프로그래머스]소수 만들기 (2) | 2023.11.29 |
| [프로그래머스]모의고사 완전탐색 (1) | 2023.11.29 |