적당히를 위한 열심히

문제 설명

스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다.

예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.

종류 이름
얼굴 동그란 안경, 검정 선글라스
상의 파란색 티셔츠
하의 청바지
겉옷 긴 코트
스파이가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

나의 풀이 (java)

import java.util.HashMap;
class Solution {
    public int solution(String[][] clothes) {
        int answer = 1;
        HashMap<String, Integer> clothesMap = new HashMap<>();
        // Hash로 저장
        for (int i = 0; i < clothes.length; i++) {
            clothesMap.put(clothes[i][1], clothesMap.get(clothes[i][1])==null ? 2:clothesMap.get(clothes[i][1])+1);
        }

        // Hash를 이용해 key(카테고리), value(count++) 해서 count 계산
        for (String category :clothesMap.keySet()) {
            answer *= clothesMap.get(category);
        }

        // count들 끼리 곱 한후 -1 (모두 0을 고른 경우)
        return answer-1;
    }
}

풀이 방법 = 다른사람의 풀이 (java)

Godd Idea :

• Hash로 중복 제거
• Hash를 이용해 key(카테고리), value(count++) 해서 count 계산
• 경우의수 구하기 : 수학적 접근 (n+1) * (m+1) * (o+1)... -1

느낀점

HsahMap은 key, value로 이루어지는데, key가 중복되지 않는걸 이용해서 중복제거, key별로 관리하는 방식으로 사용 (count)

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

• 구조대 : 119
• 박준영 : 97 674 223
• 지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

나의 풀이 (java)

import java.util.Arrays;

public class Phonebook {

    public static void main(String[] args) {
        String[] phone_book = {"12", "123", "1235", "567", "88"};
        System.out.println("###    RESULT  : "+ solution(phone_book));
    }

    // String 정렬(12,123,1235,222,..) 후 비교
    public static boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);
        for (int i = 0; i < phone_book.length-1; i++) {
            if(phone_book[i+1].startsWith(phone_book[i])) return false;
        }
        return true;
    }

    // 이중 for문 사용 - 효율성 테스트에서 걸림
    public static boolean solution2(String[] phone_book) {
        for (int i = 0; i < phone_book.length; i++) {
            for (int j = 0; j < phone_book.length; j++) {
                if(i != j && phone_book[i].startsWith(phone_book[j])) return false;
            }
        }
        return true;
    }
}

풀이 방법

예전에 다른 사람의 풀이를 봤던게 어렴풋이 기억에 남아서 비슷하게 사용한 것 같다

중요 아이디어는 

• startWith : 문자열의 prefix(접두사) 확인 가능
• Array.Sort(문자) : 문자를 비교하면 1, 12, 123 이런식으로 정렬된다는 특징을 사용

다른사람의 풀이 (java) 

class Solution {
    public boolean solution(String[] phoneBook) {
        Arrays.sort(phoneBook);
        boolean result = true;
        for (int i=0; i<phoneBook.length-1; i++) {
            if (phoneBook[i+1].contains(phoneBook[i])) {
                result = false;
                break;
            }
        }
        return result;
    }
}

Godd Idea : String 정렬의 특징을 이용한 비교

느낀점

• 해시를 사용하기전 Sorting을 통해 성능만 높이는게 성능을 위한 옵션이 아니라, 
  필수 사항이 되기도 한다

문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

나의 풀이 (java)

import java.util.ArrayList;
import java.util.List;

public class StockPrices {

    public static void main(String[] args) {
        int[] arr = {1,2,3,2,3};
        solution(arr);
    }

    public static int[] solution(int[] prices) {
        List<Integer> secondsArr = new ArrayList<>();
        for (int i = 0; i < prices.length; i++) {
            int seconds = 0;
            for (int j = i; j < prices.length; j++) {
                if (prices[i] > prices[j] || j == prices.length-1) {
                    secondsArr.add(seconds);
                    break;
                }else{
                    seconds ++;
                }
            }
        }
        return secondsArr.stream().mapToInt(Integer::intValue).toArray();
    }
}

풀이 방법

특별히 어려운 로직은 없고, 스택/큐의 문제임을 무시하고, 이중 for문으로 해결 가능

• List -> Array
  list.stream().mapToInt(Integer::intValue).toArray();

다른사람의 풀이 (java) 

class Solution {
    public int[] solution(int[] prices) {
        int len = prices.length;
        int[] answer = new int[len];
        int i, j;
        for (i = 0; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                answer[i]++;
                if (prices[i] > prices[j])
                    break;
            }
        }
        return answer;
    }
}

Godd Idea : 거의 비슷. seconds 변수를 사용하지 않고 바로 index로 접근해서 카운트하고, 조건문이 조금 다른게 차이

느낀점

• 스택/큐를 사용하지 않는대신, 아래 2가지 방법을 사용 가능
  • temp 변수에 이전 값 or 이전까지의 특정값(최대값 등)을 저장해서 비교/처리 가능
  • 이중 for문 등을 사용하되, list의 index로 값에 직접 접근 : arr[i]++;
• 물론 코드 짜고, 정리하지 않아 지저분한걸 감안해도, 코드가
  가독성이 떨어지고,
  그렇다고 재사용성이 좋지도 않고,
  아이디어가 좋은 것도 아니고,
  그냥 문제를 푼 느낌이 없지 않아 있다
• 하지만, 코드를 직독직해 하듯이 풀었기에, 초보자가 보기에는 오히려 편할수도?!

문제 설명

배열 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 함수를 완성해 주세요.

나의 풀이 (java)

import java.util.ArrayList;
import java.util.List;

public class DeleteDuplicate {

    public static void main(String[] args) {
        int[] arr = {1,1,3,3,0,1,1};
        solution(arr);
    }

    public static int[] solution(int []arr) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(i == 0 || arr[i] != arr[i-1]) {
                list.add(arr[i]);
            }
        }
        // Stream을 이용한 List -> int[]
        return list.stream().mapToInt(Integer::intValue).toArray();
    }

}

풀이 방법

특별히 어려운 로직은 없고, 아래 2가지만 잘 생각하면 된다

• 중복 여부 확인 : arr의 index로 이전 값으로 접근해서 중복 여부 체크
• list <-> array 변환 : 기본형(Integer)이 아닌 int형의 배열로 바꾸기 위해 Stream 사용 

다른사람의 풀이 (java) 

    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;
    }

Godd Idea : 중복 여부를 확인할때, arr의 인덱스가 아닌 이전 값 체크용(preNum) 변수 사용하는게 키포인트

느낀점

• Array <-> List 변환 방법 정리
• https://fire-programmer.tistory.com/129

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.
0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

다른사람의 풀이 (java) = 나의 풀이

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public String solution(int[] numbers) {

        // 숫자를 문자열로 변환
        String[] result = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            result[i] = String.valueOf(numbers[i]);
        }

        // 정렬
        Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2));

        // 0만 여러개 있는 배열의 경우 하나의 0만 리턴
        if (result[0].equals("0")) {
            return "0";
        }

        String answer = "";
        // 정렬된 문자 하나로 합치기
        for (String a : result) {
            answer += a;
        }
        return answer;
    }
}

풀이 방법

몇몇 테스트 케이스를 통과하지 못하고.. 1시간 정도 고민하다가, 결국 다른 사람의 풀이를 보고 풀었다

관건은 실제로 정렬을 구현하는 부분이었다. 

혼자 힘으로 풀때는 문자 3 vs 30 이 나올때 330이 출력되도록 하는 로직 고민하다가 시간을 다 써버림..

중요 포인트 - 두개의 문자를 합쳐 만드는 수의 대소 비교

Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2))

느낀점

• Array 정렬 방법
  • 단순 정렬시 - Array.sort(arr)
  • 복잡 정렬시 - Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2))

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.
0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

나의 풀이 = 다른사람의 풀이(java)

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public String solution(int[] numbers) {

        // 숫자를 문자열로 변환
        String[] result = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            result[i] = String.valueOf(numbers[i]);
        }

        // 정렬
        Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2));

        // 0만 여러개 있는 배열의 경우 하나의 0만 리턴
        if (result[0].equals("0")) {
            return "0";
        }

        String answer = "";
        // 정렬된 문자 하나로 합치기
        for (String a : result) {
            answer += a;
        }
        return answer;
    }
}

풀이 방법

몇몇 테스트 케이스를 통과하지 못하고.. 1시간 정도 고민하다가, 결국 다른 사람의 풀이를 보고 풀었다

관건은 실제로 정렬을 구현하는 부분이었다. 

혼자 힘으로 풀때는 문자 3 vs 30 이 나올때 330이 출력되도록 하는 로직 처리하다가 너무 복잡해짐

결론
Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2))

느낀점

• Array 정렬 방법
  • 단순 정렬시 - Array.sort(arr)
  • 복잡 정렬시 - Arrays.sort(result, (o1, o2) -> (o2 + o1).compareTo(o1 + o2))

문제 설명

public class StringExercise {

    public static void main(String[] args) {
        String str = "912345";
        System.out.println("RESULT : "+ solution(str) );
    }

    public static boolean solution(String s) {
        boolean answer = false;
        try {
            if(s.length()==4 || s.length()==6){
                Integer number = Integer.parseInt(s);
                if(number > 0)
                    answer = true;
            }
        }catch (Exception e){ e.printStackTrace(); }
        return answer;
    }
}

    // 정규식을 활용한 다른 사람의 풀이
    public static boolean solution2(String s) {
        boolean answer = false;
        if(s.length()==4 || s.length()==6){
            String pattern = "^[0-9]*$";
            return s.matches(pattern);
        }
        return answer;
    }

문제 설명

import java.util.stream.IntStream;

public class NumberOfRemainingOne {

    public static void main(String[] args) {
        int n = 12;
        solution(n);
    }

    public static int solution(int n) {
        int answer = 0;
        while(true){
            if(n % ++answer == 1) break;
        }
        return answer;
    }
}

    // Stream 을 활용한 다른사람의 풀이
    public static int solution(int n) {
        return IntStream.range(2,n).filter(i -> n % i == 1).findFirst().orElse(0);
    }

문제 설명

0부터 9까지의 숫자 중 일부가 들어있는 정수 배열 numbers가 매개변수로 주어집니다. numbers에서 찾을 수 없는 0부터 9까지의 숫자를 모두 찾아 더한 수를 return 하도록 solution 함수를 완성해주세요.

문제 보러 가기

나의 풀이

import java.util.ArrayList;

public class AddingSomeNumbers {

    public static void main(String[] args) {
        int[] numbers = {1,2,3,4,6,7,8,0};
        solution(numbers);
    }

    public static int solution(int[] numbers) {
        int answer = 0;
        ArrayList<Integer> numbersList = new ArrayList<>();

        for (int number : numbers) {
            numbersList.add(number);
        }
        for(int i = 0; i < 10; i++){
            if(!numbersList.contains(i))
                answer += i;
        }

        return answer;
    }
}

접근

나의 풀이 방법 - Count는 ArrayList의 contains를 활용

그렇다면, 풀어야 할 문제는 2가지 : Array(int[])를 ArrayList로 어떻게 바꿀것인가?

• Count를 할 방법을 정해놓으니까, Array(int[])를 ArrayList로 변경만 하면 된다.
  쉬운 방법 - https://fire-programmer.tistory.com/115

다른 사람의 풀이

// 1 - for 사용하지만, 문제에 대한 깊은 이해로 인해 모두 더한 수를 생각해 냄
class Solution {
    public int solution(int[] numbers) {
        int sum = 45;
        for (int i : numbers) {
            sum -= i;
        }
        return sum;
    }
}

// 2 - 45(모두 더한 수)와 stram 객체를 활용한 방법으로, Stream을 익히는게 좋을듯 
import java.util.Arrays;

class Solution {
    public int solution(int[] numbers) {
        return 45-Arrays.stream(numbers).sum();
    }
}

오랜만에 풀어서 그런지 45를 생각해내지 못했다

게다가 Stream도 익숙지 않아서 생각하지 못해 아쉽다

느낀점

• Count할 방법을 미리 정해놓으니까, 문제의 접근 방식이 제한돼서 오히려 돌아서 푼 느낌

문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

문제 보러 가기

나의 풀이

import java.util.ArrayList;
import java.util.List;

class Solution {
    
    public static List<Integer> solution(int[] answers) {
        List<Integer> answer = new ArrayList();
        int[] personA = {1, 2, 3, 4, 5}; // length:5
        int[] personB = {2, 1, 2, 3, 2, 4, 2, 5}; // length:8
        int[] personC = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5}; // length:10

        int[] hits = {0,0,0};

        for (int i = 0; i <answers.length; i++) {
            if(answers[i] == personA[i%personA.length]) hits[0]++;
            if(answers[i] == personB[i%personB.length]) hits[1]++;
            if(answers[i] == personC[i%personC.length]) hits[2]++;
        }

        int max = 0;
        for (int i = 0; i < hits.length; i++) {
            if(max < hits[i]){
                max = hits[i];
                answer =  new ArrayList();
                answer.add(i+1);
            } else if(max == hits[i]){
                answer.add(i+1);
            }
        }

        return answer;
    }
}

접근

풀어야 할 문제는 2가지 : 맞힌 문제 수 구하기 & 가장 많이 맞힌 사람 구하기

• 맞힌 문제 수 구하기
  의외로 이 문제는 조건절 + %(나머지 연산자)를 사용하면 어렵지 않게 구할 수 있다 (= hits)
• 가장 많이 맞힌 사람 구하기
  이게 관건인데, 
  확장성있게 리팩토링한 후에 좀 맘에 들게 바뀌었는데.. (첫 정답으로 자동 제출되는걸 몰라서 아쉽,,)
  최대 맞힌 수를 저장하는 max와 hits를 하나씩 비교하면서 비교하면서 결과를 도출하는 것이 주효했다.
  • 핵심 풀이
    최대 맞힌 개수보다 크면, 최대 맞힌 개수를 갱신하고, 결과용 리스트를 초기화 + 현재 값을 추가
    최대 맞힌 개수와 같으면, 현재 값만 추가

다른 사람의 풀이

import java.util.*;

class Solution {
    public static int[] solution(int[] answers) {
        int[][] patterns = {
                {1, 2, 3, 4, 5},
                {2, 1, 2, 3, 2, 4, 2, 5},
                {3, 3, 1, 1, 2, 2, 4, 4, 5, 5}
        };

        int[] hit = new int[3];
        for(int i = 0; i < hit.length; i++) {
            for(int j = 0; j < answers.length; j++) {
                if(patterns[i][j % patterns[i].length] == answers[j]) hit[i]++;
            }
        }

        int max = Math.max(hit[0], Math.max(hit[1], hit[2]));
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < hit.length; i++)
            if(max == hit[i]) list.add(i + 1);

        int[] answer = new int[list.size()];
        int cnt = 0;
        for(int num : list)
            answer[cnt++] = num;
        return answer;
    }
}

나와 다른 접근은 이중배열을 활용한 방법인데, 최대 개수를 구하는 로직보단,

맞힌 개수를 구할때, 이중 배열을 활용하는 접근법이 새로웠다

느낀점

• 리팩토링의 중요성