코테를 위한 JAVA 정리

// 홀수만 넣기
    public ArrayList solution(int n) {
        ArrayList<Integer> answer = new ArrayList<Integer>(); // 리스트 생성
        for(int i = 1; i <= n; i++){
            if(i % 2 != 0){ // 홀수만 넣기
                answer.add(i);
            }
        }
        return answer;
    }

// 오름차순

    public static void main(String[] args)  {
        int arr[] = {4,23,33,15,17,19};
        Arrays.sort(arr);
        
        for (int i : arr) {
            System.out.print("["+i+"]");
        }
    }

// 문자열 포함여부 확인
    public int solution(String str1, String str2) {
        int answer = 0;
        if(str1.contains(str2)) answer = 1;
        else answer = 2;
        return answer;
    }

// 문자열 분리, 내림차순

    public String solution(String s) {
        String answer = "";
        // 각 문자 저장
        String str[] = s.split("");
 
        // 내림차순
        Arrays.sort(str, Collections.reverseOrder());
          
        for(int i = 0; i < str.length; i++){
            answer += str[i];
            //System.out.println(str[i]);
        }
         
        return answer;
    }

// 숫자만 있는 문자열 찾기 + 길이 4 or 6

    public boolean solution(String s) {
        //boolean answer = true;

        int len = s.length();
        if(len != 4 && len != 6) return false;


        for(int i = 0; i < s.length(); i++){  
            if(s.charAt(i) < '0' || s.charAt(i) > '9') return false; 
        } 

        return true;
 
    }

// n진법을 10진법으로 바꾸기

    public int solution(int n) {
        int answer = 0; 
        String result = ""; 
        while(n > 0){ // 3진법 변경 -> 앞뒤 반전
            result += (n % 3); 
            n /= 3;
        }
        answer = Integer.parseInt(result,3); // 3진법 -> 10진법
        return answer;
    }

// 문자열 뒤집기 reverse()

1. StringBuilder 사용
	public static void main(String[] args)  {	
        String input = "Hello World!";

        // StringBuilder 선언
        StringBuilder input1 = new StringBuilder();
 
        // StringBuilder에 입력
        input1.append(input);
 
        // reverse 메서드 사용
        input1.reverse();
 
        // 결과 출력
        System.out.println(input1);
	}

2. StringBuffer 사용
	public static void main(String[] args)  {	
        String str = "Hello World!";

        // StringBuilder 선언 및 입력
        StringBuffer sbr = new StringBuffer(str);

        // reverse 메서드 사용
        sbr.reverse();

        // 결과 출력
        System.out.println(sbr);
	}

// 예산 문제(예산 차감 + 중단 아이디어)

  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++; // count
        }

        return answer;
  }

// 비밀지도(카카오 인턴 문제)

    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];
        for(int i = 0; i < n; i++){
            String result = ""; 
            // 이진수로 변환
            String two1 = Integer.toBinaryString(arr1[i]); // 1001
            String two2 = Integer.toBinaryString(arr2[i]); // 1110 
            // 자리수 맞추기
            while(two1.length() != n) two1 = "0"+two1;
            while(two2.length() != n) two2 = "0"+two2; 

            for(int j = 0; j < n; j++){   
                if(two1.charAt(j) == '1' || two2.charAt(j) == '1'){
                    result += "#"; // n번까지
                }else result += " ";  
            }
            answer[i] = result;
        }
        return answer;
    }

// 최소직사각형(완전탐색)

    public int solution(int[][] sizes) {
        int answer = 0;
        int max = 0;
        int min = 0;
        for(int i = 0; i < sizes.length; i++){
            int x = Math.max(sizes[i][0], sizes[i][1]);
            int y = Math.min(sizes[i][0], sizes[i][1]);
            if(max < x) max = x;
            if(min < y) min = y;  
        }
        answer = max * min;
        return answer;
    }

// 순서 내 맘대로 정렬하기

    public String[] solution(String[] strings, int n) {
        String[] answer = new String[strings.length];
        ArrayList<String> arr = new ArrayList<String>(); // arrayList는 add로 추가
        String str = ""; // 문자열 크기는 size(), list 크기는 length
        for(int i = 0; i < strings.length; i++){
            arr.add(strings[i].charAt(n) + strings[i]);
        }

        Collections.sort(arr); // arrayList 정렬
        
        for(int i = 0; i < arr.size(); i++){
            answer[i] = arr.get(i).substring(1); // index = 1~
        }  
 
        return answer;
    }

// k번째 수
    public ArrayList solution(int[] array, int[][] commands) {
        ArrayList<Integer> answer = new ArrayList<Integer>();  
        for(int i = 0; i < commands.length; i++){ //commands.length
             ArrayList<Integer> result = new ArrayList<Integer>();
             for(int j = commands[i][0]-1; j < commands[i][1]; j++){  
                 result.add(array[j]); 
             }
             Collections.sort(result); // 정렬 
             int target = commands[i][2]-1; 
             int a = result.get(target); 
             answer.add(a); 
        }
        return answer;

/* 깔끔한 풀이
        int[] answer = new int[commands.length]; // 길이 알면 배열 초기화
        int a = 0;
        for(int[] info : commands){ // 오 이렇게도..
            int i = info[0]; // 각 값 저장
            int j = info[1];
            int k = info[2];

            int[] buf = Arrays.copyOfRange(array,i-1,j); // 오호라..
            Arrays.sort(buf); // 정렬
            answer[a] = buf[k-1];
            a++;
        }

        return answer;
*/
    }

// 카카오

    public int solution(String s) {
        int answer = 0;

        String[] words = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"}; // 배열 초기화
        for(int i = 0; i < words.length; i++){
            String j = String.valueOf(i); // string으로 형변환
            s = s.replace(words[i], j);
        }
        answer = Integer.parseInt(s); // return값은 정수로 형변환!
        return answer;
    }

    public static int[] removeElement(int[] arr, int index) { // 배열에서 특정 index 값 삭제
        int[] result = new int[arr.length - 1];
        System.arraycopy(arr, 0, result, 0, index);
        if (arr.length != index) {
            System.arraycopy(arr, index + 1, result, index, arr.length - index - 1);
        }
        return result;
    }

    public ArrayList solution(int[] numbers) {
        int[] answer = {};
        int len = numbers.length;
        ArrayList<Integer> sum = new ArrayList<Integer>();
        for(int i = 0; i < len; i++){ 
            for(int j = 0; j < numbers.length-1; j++){
                if(!sum.contains(numbers[0] +numbers[j+1])) // 중복제거
                    sum.add(numbers[0] +numbers[j+1]);  
            }
            numbers = removeElement(numbers, 0); // index 0 제거 
        }
        Collections.sort(sum);
        return sum;
    }

// 포켓몬 - 해쉬셋(중복 제거)

    public int solution(int[] nums) {

            HashSet<Integer> hs = new HashSet<>();

            for(int i =0; i<nums.length;i++) {
                hs.add(nums[i]);
            }

            if(hs.size()>nums.length/2)
                return nums.length/2;

            return hs.size();
    }

// 내코드

    public int solution(int[] nums) {
        int answer = 0;
        ArrayList<Integer> arr = new ArrayList<Integer>();
        int max = nums.length/2;
        for(int i : nums){
            if(!arr.contains(i)) arr.add(i); 
        }
        if(max >= arr.size()) answer = arr.size();
        else answer = max;

        return answer;
    }

// 수포자 문제

    public int[] solution(int[] answers) {
        int[] answer = {};
        // 수포자1: 1 2 3 4 5 -> 5개
        // 수포자2: 2 1 2 3 2 4 2 5 -> 8개
        // 수포자3: 3 3 1 1 2 2 4 4 5 5 -> 10개
        int[] one = {1, 2, 3, 4, 5};
        int[] two = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] three = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        int count1 = 0;
        int count2 = 0;
        int count3 = 0; 

        for(int i =0; i < answers.length; i++){
            if(one[i%one.length] == answers[i]) count1++;
            if(two[i%two.length] == answers[i]) count2++;
            if(three[i%three.length] == answers[i]) count3++;
        }
        int max = Math.max(Math.max(count1, count2), count3); // 수식 이용(max찾기) 

        ArrayList<Integer> list = new ArrayList<Integer>();

        if(max==count1) list.add(1); //max값이랑 같으면 넣기
        if(max==count2) list.add(2);
        if(max==count3) list.add(3);
        
        answer = new int[list.size()];
        
        for(int i =0; i < answer.length; i++) { // 값 넣기
        	answer[i] = list.get(i);
        }
        return answer;
    }

// 베열에서 3개 수 골라서 합 소수판별

    public boolean check(int sum){ // 소수 판별 
        boolean result = true;
        for(int i = 2; i < sum; i++){
            if(sum % i == 0){
                result = false;
                break;
            }  
        }
        return result;  
    }

    public int solution(int[] nums) {
        int answer = 0;
        for(int i = 0; i < nums.length; i++){
            for(int j = i+1; j < nums.length; j++){ // 중복제거(i+1)
                for(int k = j+1; k < nums.length; k++){ // 중복제거
                    int sum = nums[i] + nums[j] + nums[k];
                    
                    if(check(sum)){ // 소수인경우
                        //System.out.println("i: " + i + "j: " + j + "k: " + k);
                        //System.out.println("sum: " + sum);
                        answer++;
                    }
                }
            }
        }
        return answer;
    }

System.out.println(String.format("%.3f", result) + "%"); // 소수점 출력 방법