[코딩테스트][프로그래머스]🔥 "양궁대회" 문제: Python과 Java로 완벽 해결하기! 🔥

김상욱·2024년 7월 18일
0
post-thumbnail

🔗 문제 링크

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

🕒 Python 풀이시간: 40분

from itertools import product

def solution(n, info):
    answer = []
    answerList=[]
    maxDiffScore=0
    
    cases=list(product(range(0,2),repeat=11))
    for case in cases:
        lionScore=0
        appeachScore=0
        lionShot=n
        caseTf=True
        caseResult=[]
        for i in range(11):
            if case[i]==1:
                if lionShot>info[i]:
                    lionShot-=info[i]+1
                    lionScore+=(10-i)
                    caseResult.append(info[i]+1)
                else:
                    caseTf=False
                    break
            else:
                if info[i]>0:
                    appeachScore+=(10-i)
                caseResult.append(0)
        if caseTf and lionScore>appeachScore:
            index=10
            while lionShot>0:
                if case[index]==1:
                    lionShot-=1
                    caseResult[index]+=1
                else:
                    if info[i]>caseResult[i]+1:
                        lionShot-=1
                        caseResult[i]+=1
                    else:
                        index-=1
            if maxDiffScore<abs(lionScore-appeachScore):
                maxDiffScore=abs(lionScore-appeachScore)
                answerList=[caseResult]
            elif maxDiffScore==abs(lionScore-appeachScore):
                answerList.append(caseResult)
    
    if maxDiffScore==0:
        return [-1]
    
    strList=[]
    for k in answerList:
        t=""
        for i in range(11):
           t=t+str(k[i])
        strList.append(t[::-1])
    strList.sort(reverse=True)
    for i in strList[0][::-1]:
        answer.append(int(i))
    
    return answer

🕒 Java 풀이시간: 45분

import java.util.*;

class Solution {
    public List<int[]> generateProducts(int[] arr, int repeat){
        List<int[]> products =new ArrayList<>();
        int[] product =new int[repeat];
        generateProduct(arr,products,product,repeat,0);
        return products;
    }
    public void generateProduct(int[] arr,List<int[]> products, int[] product, int repeat, int index){
        if(repeat==index){
            products.add(product.clone());
            return;
        }
        for(int i=0;i<arr.length;i++){
            product[index]=arr[i];
            generateProduct(arr,products,product,repeat,index+1);
        }
    }
    
    public int[] solution(int n, int[] info) {
        int[] answer = new int[11];
        int maxDiffScore=0;
        int[] arr={0,1};
        List<List<Integer>> answerList=new ArrayList<>();
        List<int[]> caseList=generateProducts(arr,11);
        for(int[] oneCase : caseList){
            int lionScore=0;
            int appeachScore=0;
            int lionShot=n;
            boolean caseTf=true;
            List<Integer> caseResult=new ArrayList<>();
            for(int i=0;i<11;i++){
                if(oneCase[i]==1){
                    if(lionShot>info[i]){
                        lionShot-=info[i]+1;
                        lionScore+=(10-i);
                        caseResult.add(info[i]+1);
                    }else{
                        caseTf=false;
                        break;
                    }
                }else{
                    if(info[i]>0){
                        appeachScore+=(10-i);
                    }
                    caseResult.add(0);
                }
            }
            if(caseTf&&lionScore>appeachScore){
                int index=10;
                while(lionShot>0){
                    if(oneCase[index]==1){
                        lionShot-=1;
                        caseResult.set(index,caseResult.get(index)+1);
                    }else{
                        if(info[index]>caseResult.get(index)+1){
                            lionShot-=1;
                            caseResult.set(index,caseResult.get(index)+1);
                        }else{
                            index-=1;
                        }
                    }
                }
                if(maxDiffScore<Math.abs(lionScore-appeachScore)){
                    maxDiffScore=Math.abs(lionScore-appeachScore);
                    answerList=new ArrayList<>();
                    answerList.add(caseResult);
                }else if(maxDiffScore==Math.abs(lionScore-appeachScore)){
                    answerList.add(caseResult);
                }
            }
        }
        
        if(maxDiffScore==0){
            return new int[]{-1};
        }
        
        List<StringBuilder> strList=new ArrayList<>();
        for(List<Integer> k : answerList){
            StringBuilder t=new StringBuilder();
            for(int i=0;i<11;i++){
                t=t.append(k.get(i));
            }
            t.reverse();
            strList.add(t);
        }
        Collections.sort(strList,new Comparator<StringBuilder>(){
            @Override
            public int compare(StringBuilder sb1,StringBuilder sb2){
                return sb1.toString().compareTo(sb2.toString());
            }
        }.reversed());
        int index=0;
        for(String i:strList.get(0).reverse().toString().split("")){
            answer[index++]=Integer.parseInt(i);
        }
        return answer;
    }
}

🎯 양궁대회 문제 해결 접근법

이번 섹션에서는 프로그래머스 양궁대회 문제를 해결하기 위한 기본 전략을 소개하겠습니다. 이 방법은 중복순열을 통해 가능한 모든 점수 조합을 탐색하는 데 중점을 두고 있습니다.

🔄 중복순열을 통한 경우의 수 생성

먼저, 중복순열을 활용하여 라이언이 받을 수 있는 모든 점수 조합을 생성합니다. 이 단계에서 중요한 점은 단순히 점수를 계산하는 것이 아니라, 어피치를 이길 수 있는지를 판단하여 경우의 수를 단순화하는 것입니다. 이렇게 하면 더 효율적으로 문제를 접근할 수 있습니다.

📊 어피치 점수와의 비교

각 경우마다 라이언의 점수와 어피치의 점수를 비교합니다. 라이언이 어피치보다 하나 더 많은 점수를 얻을 수 있다면, 해당 점수에 필요한 화살의 수를 증가시킵니다. 반대로, 점수가 0인 경우에는 화살을 부여하지 않도록 합니다. 이 과정에서 각 점수를 더해가며 최종 점수를 계산합니다.

🔍 최대 점수 찾기

모든 경우에 대해 최대 점수를 찾는 과정에서는 남은 화살을 뒤쪽에 배분하여 경우가 깨지지 않도록 합니다. 이렇게 함으로써, 낮은 점수를 더 많이 맞춘 경우를 확보할 수 있습니다. 이는 최종적으로 라이언이 어피치를 이길 수 있는 최적의 조합을 찾기 위한 중요한 단계입니다.

🏆 최종 결과 도출

마지막으로, 모든 경우를 정답 리스트에 담은 후 각 자리를 비교하여 뒷자리가 더 큰 경우를 찾아 최종 결과로 출력합니다. 이렇게 하면 라이언이 어피치를 이길 수 있는 가장 유리한 점수 조합을 구할 수 있습니다.

이렇게 Python과 Java로 프로그래머스의 "양궁 대회"를 해결해보았습니다. 코드와 개념 설명을 참고하여 문제를 해결하는 데 도움이 되셨길 바랍니다! 😊

0개의 댓글