**** APPLICATION FAILED TO START ****
Description: Web server failed to start. Port 8080 was already in use.

🤔이유

포트가 제대로 종료되지 않았거나, 실행중인 상태에서 프로젝트를 실행했을 때 발생하는 에러

💡해결

1. 명령 프롬포트(CMD) 실행
2. 현재 8080 포트를 사용 중인 네트워크 정보 출력

   netstat -ano | findstr 8080

3. 강제 종료할 프로세스의 PID를 입력

   taskkill /F /pid PID

   
   

예전에는 운영체제에서 크로아티아 알파벳을 입력할 수가 없었다. 따라서, 다음과 같이 크로아티아 알파벳을 변경해서 입력했다. 예를 들어, ljes=njak은 크로아티아 알파벳 6개(lj, e, š, nj, a, k)로 이루어져 있다. 단어가 주어졌을 때, 몇 개의 크로아티아 알파벳으로 이루어져 있는지 출력한다.
dž는 무조건 하나의 알파벳으로 쓰이고, d와 ž가 분리된 것으로 보지 않는다. lj와 nj도 마찬가지이다. 위 목록에 없는 알파벳은 한 글자씩 센다.

🧑🏻‍💻 나의 풀이

import java.util.Scanner;

class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int ans = 0;

        if(str.length()==1) {
            ans=1;
            System.out.println(ans);
            return;
        }

        for(int i=str.length()-1; i>0; i--) {
            char c1 = str.charAt(i);
            char c2 = str.charAt(i-1);

            if(c1=='=') {
                if(i>1 && (c2=='z' && str.charAt(i-2)=='d')) {
                    i-=2;
                } else if(c2=='c' || c2=='s' || c2=='z') {
                    i--;
                }
            }

            else if(c1=='-' && (c2=='c' || c2=='d')) {
                    i--;
            }

            else if(c1=='j' && (c2=='l' || c2=='n')) {
                    i--;
            }

            if(i==1) {
                ans++;
            }

            ans++;

        } //for

        System.out.println(ans);

    }

}

오답1 c2 = str.charAt(i-1)이기 때문에 for문의 범위를 i>0으로 잡았더니, 1,2번째 문자가 팰린드롬인 경우 0번째 문자가 카운트되지 않는 문제가 생겼다. 0번째 문자가 있는 경우 ans++가 되도록 if(i=1){ ans++; }문을 추가했다.

오답2 채점 중 100%가 되기 직전에 오답이 떴다. 어디서 틀린 건지 감이 안 와 반례를 찾아봤더니, 'a'와 같이 입력값이 한 자리수일 때 정답은 1인데 출력값이 0으로 나오는 것을 발견할 수 있었다. str.length()==1이면 ans=1을 출력하고 동작을 멈추도록 if문을 추가했다.

🔗 문제 링크

https://www.acmicpc.net/problem/2941

알파벳 소문자로만 이루어진 단어가 주어진다. 이때, 이 단어가 팰린드롬인지 아닌지 확인하는 프로그램을 작성하시오.
팰린드롬이란 앞으로 읽을 때와 거꾸로 읽을 때 똑같은 단어를 말한다. level, noon은 팰린드롬이고, baekjoon, online, judge는 팰린드롬이 아니다.
첫째 줄에 팰린드롬이면 1, 아니면 0을 출력한다.

🧑🏻‍💻 나의 풀이

import java.util.Scanner;

class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int len = str.length()-1;

        for(int i=0; i<str.length()/2; i++) {
            if(str.charAt(i)!=str.charAt(len)) {
                System.out.println(0);
                return;
            }
            len--;
        }

        System.out.println(1);
    }

}

str의 맨 앞과 맨 뒤의 글자를 비교한다. 하나라도 다른 경우, 0을 출력하고 동작을 종료한다.

🔗 문제 링크

https://www.acmicpc.net/problem/10988

예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요. 첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.

🧑🏻‍💻 나의 풀이

import java.util.Scanner;

class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        // 별 증가 for문
        for(int i=1; i<=n; i++) {
            for(int j=1; j<=n-i; j++) {
                System.out.print(" ");
            }
            for(int j=1; j<=2*i-1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        // 별 감소 for문
        for(int i=n-1; i>=1; i--) {
            for(int j=1; j<=n-i; j++) {
                System.out.print(" ");
            }
            for(int j=1; j<=2*i-1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

}

🔗 문제 링크

https://www.acmicpc.net/problem/2444

세준이는 기말고사를 망쳤다. 세준이는 점수를 조작해서 집에 가져가기로 했다. 일단 세준이는 자기 점수 중에 최댓값을 골랐다. 이 값을 M이라고 한다. 그리고 나서 모든 점수를 점수/M100으로 고쳤다.
예를 들어, 세준이의 최고점이 70이고, 수학점수가 50이었으면 수학점수는 50/70100이 되어 71.43점이 된다.
세준이의 성적을 위의 방법대로 새로 계산했을 때, 새로운 평균을 구하는 프로그램을 작성하시오.

🧑🏻‍💻 나의 풀이

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int cnt = sc.nextInt();
        int[] arr = new int[cnt];

        for(int i=0;i<cnt;i++) {
            arr[i] = sc.nextInt();
        }
        Arrays.sort(arr);

        int max = arr[cnt-1];
        double sum = 0;

        for(int i=0;i<cnt;i++) {
            sum += (double)arr[i]/max*100;
        }

        System.out.println(sum/cnt);

    }
}

🔗 문제 링크

https://www.acmicpc.net/problem/1546

첫째 줄에는 별 1개, 둘째 줄에는 별 2개, N번째 줄에는 별 N개를 찍는 문제

🧑🏻‍💻 나의 풀이

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        for(int i=0;i<n;i++) {
            for(int j=0;j<=i;j++) {
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

🔗 문제 링크

https://www.acmicpc.net/problem/2438

인하대학교 컴퓨터공학과를 졸업하기 위해서는, 전공평점이 3.3 이상이거나 졸업고사를 통과해야 한다. 그런데 아뿔싸, 치훈이는 깜빡하고 졸업고사를 응시하지 않았다는 사실을 깨달았다! 치훈이의 전공평점을 계산해주는 프로그램을 작성해보자.
전공평점은 전공과목별 (학점 × 과목평점)의 합을 학점의 총합으로 나눈 값이다. 인하대학교 컴퓨터공학과의 등급에 따른 과목평점은 다음 표와 같다. P/F 과목의 경우 등급이 P또는 F로 표시되는데, 등급이 P인 과목은 계산에서 제외해야 한다. 과연 치훈이는 무사히 졸업할 수 있을까?

🧑🏻‍💻 나의 풀이

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

public class Main {

    public static void main(String[] args) throws IOException {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);

            double creditSum = 0;
            double sum = 0;

            for(int i=0;i<20;i++) {
                String str = br.readLine();

                String grade = str.substring(str.lastIndexOf(" ")+1);
                String creditStr = str.substring(str.indexOf(" ")+1,str.lastIndexOf(" "));
                Double credit = Double.parseDouble(creditStr);

                switch(grade) {
                    case "A+": sum += credit*4.5; break;
                    case "A0": sum += credit*4.0; break;
                    case "B+": sum += credit*3.5; break;
                    case "B0": sum += credit*3.0; break;
                    case "C+": sum += credit*2.5; break;
                    case "C0": sum += credit*2.0; break;
                    case "D+": sum += credit*1.5; break;
                    case "D0": sum += credit*1.0; break;
                    case "F": sum += credit*0.0; break;
                    default: continue;
                }

                creditSum += credit;
            }

            double average = sum/creditSum;
            System.out.println(average);
            br.close();
    }
}

🔗 문제 링크

https://www.acmicpc.net/problem/25206

ORA-02270: 이 열목록에 대해 일치하는 고유 또는 기본 키가 없습니다. 02270. 00000 - "no matching unique or primary key for this column-list"

🤔 이유

테이블 생성 후 FK 설정 과정에서 오류가 발생했다. 참조하려는 테이블의 PK가 하나인 줄 알았는데, FK를 포함해 총 2개였기 때문이었다.

💡 해결

ALTER TABLE 추가할테이블명
ADD CONSTRAINT FK명
FOREIGN KEY(참고PK키1, 참고PK키2)
REFERENCES 참고할테이블명(참고PK키1, 참고PK키2);

위와 같이 PK를 모두 포함해줬더니 오류 없이 FK 추가에 성공했다.

ORA-00903: 테이블명이 부적합합니다 00903. 00000 - "invalid table name"

🤔이유

컬럼을 추가하는 과정에서 오류가 발생했다. 이유는 오라클에서 사용하는 예약어를 테이블명으로 지정했기 때문

💡해결

내 경우엔 테이블명으로 USER를 사용한 것 때문이었다. 테이블명을 TBL_USER, USER, MEMBER 등으로 수정하면 해결된다.

*오라클 예약어 * CREATE, TABLE, USER, PRIMARY, KEY ···

자연수 n이 매개변수로 주어집니다. n을 3진법 상에서 앞뒤로 뒤집은 후, 이를 다시 10진법으로 표현한 수를 return 하도록 solution 함수를 완성해주세요.

🧑🏻‍💻 나의 풀이

class Solution {
    public int solution(int n) {
        String answer = "";
        String str = Integer.toString(n,3);

        for(int i=str.length();i>0;i--) {
            answer += str.substring(i-1,i);
        }

        return Integer.parseInt(answer,3);
    }
}

🔗 문제 링크

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

슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다. 이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라. 전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.

• 실패율은 다음과 같이 정의한다.
  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

🧑🏻‍💻 나의 풀이

import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        Map<Integer,Double> map = new HashMap<>();
        int user = stages.length;

        for(int i=0;i<N;i++) {
            int cnt = 0;
            for(int j=0;j<stages.length;j++) {
                if(stages[j]==i+1) {
                    cnt++;
                }
            }
            map.put(i+1, cnt==0? 0.0:(double)cnt/user);
            user -= cnt;
        }

        List<Map.Entry<Integer, Double>> list = new LinkedList<>(map.entrySet());
        list.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));

        for(int i=0;i<N;i++) {
            answer[i] = list.get(i).getKey();
        }

        return answer;
    }
}

map에 <스테이지,실패율>을 반복문으로 담아준다. 실패율이 높은 스테이지부터 내림차순으로 정렬하기 위해서는 map의 value를 기준으로 answer에 담아야한다. 이를 위해 Map.entrySet()으로 List 형태로 저장해준다. List<Map.Entry<Integer, Double>> list = new LinkedList<>(map.entrySet());

그 후 comparingByValue() 함수로 정렬하는데, 내림차순 정렬을 위해 Comparator.reverseOrder()을 사용했다. list.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));
+ 문제를 푸는 중 1,6,7,9,13,23,24번이 계속 실패하길래 질문게시판을 찾아봤더니 "스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다." 라는 조건이 맞지 않아 오류가 나는 것이라고 한다. cnt==0? 0.0:(double)cnt/user 부분을 수정했더니 통과!

💡학습하기

배열 → List 변환

• Arrays.asList()
• new ArrayList<>(Arrays.asList())
• Collectors.toList()

List → 배열 변환

• toArray()

Map → List 변환

• Stream 이용 (변환 시 Map의 key-value값 유지 가능)

  List<Map.Entry<>> list = map.enrtySet().stream().collect(Collectors.toList())

• key, value List

  List<> key = new ArrayList(map.keySet())
  List<> value = new ArrayList(map.valueSet())

HashMap을 value 기준으로 정렬 List<Map.Entry<>> list = new LinkedList<>(map.entrySet()); 으로 Map의 Entry set을 List 형태로 저장했음이 선행되어야 함

• Entry 내장 함수

  list.sort(Map.Entry.comparingByValue())

• comparator

  list.sort(new Comparator<Map.Entry<>>(){
    @Override
    public int compare(Map.Entry<> map1, Map.Entry<> map2){
    // 오름차순
    return map1.getValue() - map2.getValue();
    // 내림차순
    return map2.getValue() - map1.getValue();
    }
  });
  

// 람다식 사용 list.sort(((map1, map2) -> map.get(map1.getKey()) - map2.get(map2.getKey())));

```

🔗 문제 링크

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

💻 참고 블로그

https://hianna.tistory.com/551 https://developer-talk.tistory.com/394 https://velog.io/@cgw0519/Java-HashMap-Value-기준으로-정렬하기

신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.

• 각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
  • 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
  • 한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.
• k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
  • 유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.

다음은 전체 유저 목록이 ["muzi", "frodo", "apeach", "neo"]이고, k = 2(즉, 2번 이상 신고당하면 이용 정지)인 경우의 예시입니다.

각 유저별로 신고당한 횟수는 다음과 같습니다.

위 예시에서는 2번 이상 신고당한 "frodo"와 "neo"의 게시판 이용이 정지됩니다. 이때, 각 유저별로 신고한 아이디와 정지된 아이디를 정리하면 다음과 같습니다.

따라서 "muzi"는 처리 결과 메일을 2회, "frodo"와 "apeach"는 각각 처리 결과 메일을 1회 받게 됩니다. 이용자의 ID가 담긴 문자열 배열 id_list, 각 이용자가 신고한 이용자의 ID 정보가 담긴 문자열 배열 report, 정지 기준이 되는 신고 횟수 k가 매개변수로 주어질 때, 각 유저별로 처리 결과 메일을 받은 횟수를 배열에 담아 return 하도록 solution 함수를 완성해주세요.

🧑🏻‍💻 나의 풀이

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
       int[] answer = new int[id_list.length];

        //유저 신고 기록
        HashMap<String,Set<String>> reportList = new HashMap<>();
        //유저 신고 횟수
        HashMap<String,Integer> mailCnt = new HashMap<>();

        for(int i=0;i<id_list.length;i++) {
            reportList.put(id_list[i], new HashSet<>());
            mailCnt.put(id_list[i], 0);
        }

        //신고 기록
        for(int i=0;i<report.length;i++) {
            int n = report[i].indexOf(" ");
            String reportUser = report[i].substring(0,n);
            String reportedUser = report[i].substring(n+1);

            reportList.get(reportedUser).add(reportUser);
        }

        //신고 횟수
        for(int i=0;i<id_list.length;i++) {
            if(reportList.get(id_list[i]).size()>=k) {
                for(int j=0;j<id_list.length;j++) {
                    if(reportList.get(id_list[i]).contains(id_list[j])==true) {
                        mailCnt.put(id_list[j], mailCnt.get(id_list[j])+1);
                    }
                }
            }
        }

        //정리
        for(int i=0;i<id_list.length;i++) {
            answer[i] = mailCnt.get(id_list[i]).intValue();
        }

        return answer;
    }
}

1. answer[]: 신고 처리 결과 메일 횟수
2. reportList: key=유저, value=해당 유저를 신고한 유저 (동일 유저에 대한 신고 횟수는 1회로 처리되기 때문에 중복값이 허용되지 않는 Set<>을 이용)
3. mailCnt: key=유저, value=신고 처리 결과 메일 횟수

유저 아이디가 담긴 id_list를 reportList, mailCnt의 key값으로 넣어준다. // 신고 기록 report의 문자열을 공백 기준으로 잘라 reportUser(신고한 유저) / reportedUser(신고당한 유저) 구분 reportList.get(reportedUser) 신고당한 유저를 key로 갖는 값을 찾아 .add(reportUser) 신고한 유저를 value에 추가한다. // 신고 횟수 value.size()를 이용해 해당 유저를 신고한 유저의 수를 구한다. 만약 k보다 크거나 같은 경우, mailCnt에서 신고한 유저와 매치되는 key를 찾아 value에 1을 더해준다. // 정리 mailCnt.get(id_list[i]).intValue();를 사용해 id_list 순대로 메일 횟수를 정렬해준다. HashMap에는 primitive type인 int 자료형을 넣지 못하기 때문에 intValue()를 사용해 Interger → int로 변환한다.

🧑🏻‍💻 다른 사람의 풀이

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        List<String> list = Arrays.stream(report).distinct().collect(Collectors.toList());
        HashMap<String, Integer> count = new HashMap<>();
        for (String s : list) {
            String target = s.split(" ")[1];
            count.put(target, count.getOrDefault(target, 0) + 1);
        }

        return Arrays.stream(id_list).map(_user -> {
            final String user = _user;
            List<String> reportList = list.stream().filter(s -> s.startsWith(user + " ")).collect(Collectors.toList());
            return reportList.stream().filter(s -> count.getOrDefault(s.split(" ")[1], 0) >= k).count();
        }).mapToInt(Long::intValue).toArray();
    }
}

1. Arrays.stream(report).distinct()를 이용해 배열의 중복 값을 바로 제거했다. 이후 .collect(Collectors.toList())로 Stream을 List로 변환

2. split(" ")[1]로 공백으로 문자열을 나눠 target을 신고당한 유저로 초기화 HashMap count에 key로 target을 삽입해 getOrDefault(target,0)+1 해당 키의 값이 존재하면 값+1, 존재하지 않으면 default로 0을 설정해 +1

3. 하나씩 천천히 보자면 (여러 블로그들을 참고하여 풀이했는데, 스트림은 미숙하기 때문에 틀린 부분이 있을 수도 있다.)

final String user = _user; List<String> reportList = list.stream(id_list).filter(s -> s.startWith(user + " ")).collect(Collectors.toList());

• id_list를 스트림으로 변환한 후 filter()로 조건에 따라 요소를 걸러낸다.
• 조건: startsWith(user + " ") 신고한 유저의 ID
• 요소의 가공이 끝나면 Collect()을 통해 List 형태로 변환하여 reportList에 대입

return reportList.stream().filter(s -> count.getOrDefault(s.split(" ")[1], 0) >= k).count();

• reportList에 있는 신고한 유저에게 보낼 정지당한 유저의 수를 구한다.
• HashMap인 count에서 신고당한 수가 k보다 많거나 같은 유저를 찾아 count()로 그 수를 카운팅한다.

Arrays.stream(id_list).map(생략).mapToInt(Long::intValue).toArray()

• id_list 배열을 stream으로 변환 후 map에 있는 요소들을 int 자료형, Array로 변환

import java.util.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        int[] answer = new int[id_list.length];
        ArrayList<User> users = new ArrayList<>();
        HashMap<String,Integer> suspendedList = new HashMap<>(); //<이름>
        HashMap<String,Integer> idIdx = new HashMap<String,Integer>(); // <이름, 해당 이름의 User 클래스 idx>
        int idx = 0;

        for(String name : id_list) {
            idIdx.put(name,idx++);
            users.add(new User(name));
        }

        for(String re : report){
            String[] str = re.split(" ");
            //suspendedCount.put(str[0], suspendedCount.getOrDefault(str[0],0)+1);
            users.get( idIdx.get(str[0])).reportList.add(str[1]);
            users.get( idIdx.get(str[1])).reportedList.add(str[0]);
        }

        for(User user : users){
            if(user.reportedList.size() >= k)
                suspendedList.put(user.name,1);
        }

         for(User user : users){
             for(String nameReport : user.reportList){
                 if(suspendedList.get(nameReport) != null){
                     answer[idIdx.get(user.name)]++;
                 }
             }
        }
        return answer;
    }
}

class User{
    String name;
    HashSet<String> reportList;
    HashSet<String> reportedList;
    public User(String name){
        this.name = name;
        reportList = new HashSet<>();
        reportedList = new HashSet<>();
    }
}

컬렉션으로 유저 객체를 생성하여 작업한 객체지향적 코드

💡학습하기

스트림 (Stream) Stream은 컬렉션, 배열 등의 저장 요소를 하나씩 참조하며 반복적으로 처리할 수 있도록 하는 기능이다. 람다식을 적용한다.

• *map : *특정 조건에 해당하는 요소들을 값으로 변환한다. 스트림의 각 요소를 연산하는데 쓰인다.
• *filter : *조건에 맞는 요소만 걸러낸다.
• *sorted : * 요소들을 정렬한다.
• *distinct : *중복을 제거한다.
• *collect : * 가공이 끝난 뒤 리턴해줄 결과를 만든다.
• *count(), min(), max(), sum(), average() : * 최종 연산이다. 앞서 함수가 적용된 스트림에 있는 요소들에 대한 작업이 이루어진다.
  

🔗 문제 링크

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

💻 참고 블로그

https://dpdpwl.tistory.com/81 https://kedric-me.tistory.com/entry/JAVA-%EB%9E%8C%EB%8B%A4%EC%8B%9D-map-filter-reduce-collect https://jeong-pro.tistory.com/165

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.
아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.

가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.
모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

🧑🏻‍💻 나의 풀이

class Solution {
    public int solution(int[][] sizes) {
        int answer = 0;
        int[][] arr = new int[sizes.length][2];
        int width = 0;
        int length = 0;

        for(int i=0;i<sizes.length;i++) {
            arr[i][0] = Math.max(sizes[i][0], sizes[i][1]);
            arr[i][1] = Math.min(sizes[i][0], sizes[i][1]);

            width = arr[i][0]>width ? arr[i][0] : width;
            length = arr[i][1]>length ? arr[i][1] : length;
        }

        return answer = width*length;
    }
}

한 명함의 가로세로 중 긴 부분은 arr[i][0], 짧은 부분은 arr[i][1]에 담아 지갑의 크기를 최소로 구할 수 있도록 한다.

💡학습하기

Arrays.deepToString() 다차원 배열의 값을 문자열로 리턴받아 출력 가능 (값 출력용으로 사용)

🔗 문제 링크

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

자연수 n이 주어졌을 때, n의 다음 큰 숫자는 다음과 같이 정의 합니다.

• 조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.
• 조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.
• 조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는 수 중 가장 작은 수 입니다.
  예를 들어서 78(1001110)의 다음 큰 숫자는 83(1010011)입니다. 자연수 n이 매개변수로 주어질 때, n의 다음 큰 숫자를 return 하는 solution 함수를 완성해주세요.

🧑🏻‍💻 나의 풀이

class Solution {
    public int solution(int n) {
        int answer = 0;
        // Integer.bitCount(i): 주어진 수에서 true(=1)의 수를 반환하는 함수
        int bitCnt = Integer.bitCount(n);

        for(int i=n+1;i<2*n;i++) {
            if(Integer.bitCount(i)!=bitCnt) {
                continue;
            } 
            answer = i; 
            break;
        }

        return answer;
    }
}

주어진 수 n의 1의 갯수를 Integer.bitCount()를 이용해 bitCnt에 담는다. 반복문에서 i가 가진 1의 수가 bitCnt와 일치할 경우 i를 결과값으로 리턴한다.

🧑🏻‍💻 다른 사람의 풀이

class TryHelloWorld {
    public int nextBigNumber(int n) {
        int postPattern = n & -n, smallPattern = ((n ^ (n + postPattern)) / postPattern) >> 2;
        return n + postPattern | smallPattern;
    }
    public static void main(String[] args) {
        int n = 78;
        System.out.println(new TryHelloWorld().nextBigNumber(n));
    }
}

비트연산을 사용한 코드 postPattern, smallPattern을 나눠 하나씩 보고 비트연산을 하여 2진수로 비교해가며 코드를 해석한다 비트연산 정말 어렵다..🤯

💡학습하기 - 비트연산

AND 연산 (&) : 두 수가 둘 다 1인 경우 1로 변환 OR 연산 (|) : 두 수 중 하나만 1이면 1로 변환 XOR 연산 (^) : 두 수가 다르면 1로 변환 NOT 연산 (~) : 각 자리수를 반대로 변환

🔗 문제 링크

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

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 "AB"는 1만큼 밀면 "BC"가 되고, 3만큼 밀면 "DE"가 됩니다. "z"는 1만큼 밀면 "a"가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

🧑🏻‍💻 나의 풀이

class Solution {
    public String solution(String s, int n) {
        String answer = "";

        for(int i=0;i<s.length();i++) {
            char c = s.charAt(i);

            if(c==' ') {
                answer += " ";
            } else if('A'<=c && c<='Z') {
                answer += c+n>'Z' ? (char)(c+n-26) : (char)(c+n);
            } else if('a'<=c && c<='z') {
                answer += c+n>'z' ? (char)(c+n-26) : (char)(c+n);
            }
        }
        return answer;
    }
}

c+n이 z나 Z보다 큰 경우 (아스키코드의 소문자/대문자 범위를 벗어난 경우) 26을 제하여 맞춰줬다.

🧑🏻‍💻 다른 사람의 풀이

if (Character.isLowerCase(ch)) {
        ch = (char) ((ch - 'a' + n) % 26 + 'a');
      } else if (Character.isUpperCase(ch)) {
        ch = (char) ((ch - 'A' + n) % 26 + 'A');
      }

풀이방식은 비슷하지만 if 조건문에서 isLowerCase(), isUpperCase()를 사용해 소문자/대문자를 구별했다.

🔗 문제 링크

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

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 자연수 n을 연속한 자연수들로 표현 하는 방법이 여러개라는 사실을 알게 되었습니다. 예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다. 1 + 2 + 3 + 4 + 5 = 15 4 + 5 + 6 = 15 7 + 8 = 15 15 = 15 자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

🧑🏻‍💻 나의 풀이

class Solution {
    public int solution(int n) {
        int answer = 0;

        for(int i=1;i<=n;i++) {
            int sum = 0;

            for(int j=i;j<=n;j++) {
                sum += j;

                if(sum==n) {
                    answer++; 
                    break;
                } else if(sum>n) {
                    break;
                }
            }
        }
        return answer;
    }
}

이중 for문을 사용해 i가 1일 때 j for문에서는 sum에 1+2+3+...+n이 담긴다. sum==n이면 answer++, sum>n이면 탈출해 다음 i를 받는다.

🧑🏻‍💻 다른 사람의 풀이

public class Expressions {

    public int expressions(int num) {
        int answer = 0;
         for (int i = 1; i <= num; i += 2) 
             if (num % i == 0) 
                 answer++;

             return answer;
        }
}    

홀수의 약수를 세는 방법이라고 하는데 이해가 잘 가지 않아 검색을 해봤다. 주어진 자연수를 연속된 수의 합으로 표현하는 방법의 수는 주어진 수의 홀수 약수의 개수와 같다는 정수론 정리가 있다고 한다. 문제에서 주어진 수인 15를 예시로 들자면

1. 약수 1: 15 = 15
2. 약수 3: 5+5+5 = 4+5+6 = 15
3. 약수 5: 5+5+5+5+5 = 1+2+3+4+5 = 15
4. 약수 15: 홀수 2n+1은 n+(n+1)의 합으로 표현할 수 있기 때문에 7+8 = 15

🔗 문제 링크

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

💻 참고 블로그

https://velog.io/@injoon2019/알고리즘-프로그래머스-숫자의-표현

두 수를 입력받아 두 수의 최대공약수와 최소공배수를 반환하는 함수, solution을 완성해 보세요. 배열의 맨 앞에 최대공약수, 그다음 최소공배수를 넣어 반환하면 됩니다. 예를 들어 두 수 3, 12의 최대공약수는 3, 최소공배수는 12이므로 solution(3, 12)는 [3, 12]를 반환해야 합니다.

🧑🏻‍💻 나의 풀이

class Solution {
    public int[] solution(int n, int m) {
        int[] answer = new int[2];

        //최대공약수
        for(int i=1;i<=Math.min(n, m);i++) {
            if(n%i==0 && m%i==0) {
                answer[0] = i;
            }
        }

        //최소공배수
        answer[1] = n*m/answer[0];

        return answer;
    }
}

🧑🏻‍💻 다른 사람의 풀이

import java.util.Arrays;

class TryHelloWorld {
      public int[] gcdlcm(int a, int b) {
        int[] answer = new int[2];

          answer[0] = gcd(a,b);
        answer[1] = (a*b)/answer[0];
        return answer;
    }

   public static int gcd(int p, int q)
   {
    if (q == 0) return p;
    return gcd(q, p%q);
   }
}  

재귀함수를 이용한 코드 최대공약수를 구하기 위해 gcd()에서 p%q가 0이 될 때까지 자기자신을 호출한다.

🔗 문제 링크

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

S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다. 물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다. 부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원할 수 있는지 return 하도록 solution 함수를 완성해주세요.

🧑🏻‍💻 나의 풀이

import java.util.Arrays;

class Solution {
    public int solution(int[] d, int budget) {
        int answer = 0;
        int sum = 0;

        Arrays.sort(d);

        for(int i=0;i<d.length;i++) {
            sum += d[i];
            if(sum<=budget) {
                answer++;
            } else {
                break;
            }
        }

        return answer;
    }
}

최대한 많은 부서의 물품을 구매하기 위해 Arrays.sort()로 신청 금액이 적은 순으로 정렬

🧑🏻‍💻 다른 사람의 풀이

import java.util.*;

class Solution {
  public int solution(int[] d, int budget) {
      int answer = 0;

        Arrays.sort(d);

        for (int i = 0; i < d.length; i++) {
            budget -= d[i];

            if (budget < 0) break;

            answer++;
        }

        return answer;
  }
}

나는 sum+=d[i]로 budget과 비교했는데 이 코드에서는 budget-=d[i] 바로 차감하는 방식을 사용했다.

🔗 문제 링크

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

문자열 s는 한 개 이상의 단어로 구성되어 있습니다. 각 단어는 하나 이상의 공백문자로 구분되어 있습니다. 각 단어의 짝수번째 알파벳은 대문자로, 홀수번째 알파벳은 소문자로 바꾼 문자열을 리턴하는 함수, solution을 완성하세요.

• 문자열 전체의 짝/홀수 인덱스가 아니라, 단어(공백을 기준)별로 짝/홀수 인덱스를 판단해야합니다.
• 첫 번째 글자는 0번째 인덱스로 보아 짝수번째 알파벳으로 처리해야 합니다.

🧑🏻‍💻 나의 풀이

class Solution {
    public String solution(String s) {
        String answer = "";
        String[] arr = s.split("");

        int n = 1;

        for(int i=0;i<arr.length;i++) {
            if(arr[i].equals(" ")) {
                answer += " ";
                n = 1;
                continue;
            }
            answer += n%2==1 ? arr[i].toUpperCase() : arr[i].toLowerCase();
            n++;
        }

        return answer;
    }
}

1. if문을 사용해 arr[i]가 공백인 경우 n을 1로 초기화시켜준다. (공백 기준으로 짝/홀수를 판단하기 때문)
2. n이 홀수이면 toUpperCase() 대문자, 짝수이면 toLowerCase() 소문자로 변환한다.
   

🔗 문제 링크

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

배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다. 예를 들면, arr = [1, 1, 3, 3, 0, 1, 1] 이면 [1, 3, 0, 1] 을 return 합니다. arr = [4, 4, 4, 3, 3] 이면 [4, 3] 을 return 합니다. 배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

🧑🏻‍💻 나의 풀이

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        List<Integer> list = new ArrayList<>();
        list.add(arr[0]);

        for(int i=1;i<arr.length;i++) {
            if(list.get(list.size()-1) != arr[i]) {
                list.add(arr[i]);
            }
        }

        int[] answer = new int[list.size()];
        for(int i=0;i<list.size();i++) {
            answer[i] = list.get(i);
        }

        return answer;
    }
}

List에 arr[0]값을 담는다. list.get(list.size()-1) 리스트의 마지막 값을 구해 arr[i]와 비교하고, 값이 같지 않으면 리스트에 추가한다.

🧑🏻‍💻 다른 사람의 풀이

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        ArrayList<Integer> tempList = new ArrayList<Integer>();
        int preNum = 10;
        for(int num : arr) {
            if(preNum != num)
                tempList.add(num);
            preNum = num;
        }       
        int[] answer = new int[tempList.size()];
        for(int i=0; i<answer.length; i++) {
            answer[i] = tempList.get(i).intValue();
        }
        return answer;
    }
}

배열 arr 원소의 크기가 0~9이기 때문에 preNum을 중복되지 않게 10으로 선언해준다. 첫 번째 값 추가 후 preNum을 num으로 변경해 다음 arr값과 중복 체크를 한다.

🔗 문제 링크

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