[프로그래머스, LV.0] 배열 만들기 2

목차

#1 배열 만들기 2

문제 설명

:정수 l과 r이 주어졌을 때, l 이상 r이하의 정수 중에서 숫자 "0"과 "5"로만 이루어진 모든 정수를 오름차순으로 저장한 배열을 return 하는 solution 함수를 완성해 주세요. 만약 그러한 정수가 없다면, -1이 담긴 배열을 return 합니다.

 

제한 사항

:1 <= l <= r <= 1,000,000

 

입출력 예

#2 코드 및 알고리즘

import java.util.*;

class FirstJava {
    public static void main(String[] args) {
        int l = 5, r = 555, count = 0, jj = 1, len = 1;
        String nb = Integer.toString(r);
        for(int i = 1; i <= nb.length(); i++)
            len *= 2;
        String[] binary = new String[len - 1];
        if(l % 5 == 0){
            for (int j = 0; j < len - 1; j++) {
                if(j == 0) {
                    binary[j] = Integer.toBinaryString(j << 0) + Integer.toBinaryString(1);
                    continue;
                }
                if(j >= 3){
                    binary[j] = Integer.toBinaryString(j - jj << 0) + Integer.toBinaryString(0);
                    binary[j + 1] = Integer.toBinaryString(j - jj<< 0) + Integer.toBinaryString(1);
                    jj++;
                } else {
                    binary[j] = Integer.toBinaryString(j << 0) + Integer.toBinaryString(0);
                    binary[j + 1] = Integer.toBinaryString(j << 0) + Integer.toBinaryString(1);
                }
                j++;
            }
            int[] arr = new int[binary.length];
            for(int i = 0; i < binary.length; i++)
                arr[i] = Integer.parseInt(binary[i]);
            System.out.println("변환 결과 :" + Arrays.toString(arr));
        } else {
            int[] arr = {-1};
            System.out.println(Arrays.toString(arr));
        }
        /*System.out.print(" " + Integer.toBinaryString( 0 << 0) + Integer.toBinaryString(1) + " "); // 01
        System.out.print(Integer.toBinaryString(1 << 0) + Integer.toBinaryString(0) + " ");// 10
        System.out.print(Integer.toBinaryString(1 << 0) + Integer.toBinaryString(1) + " ");// 11
        System.out.print(Integer.toBinaryString(2 << 0) + Integer.toBinaryString(0) + " ");// 100
        System.out.print(Integer.toBinaryString(2 << 0) + Integer.toBinaryString(1) + " ");// 101
        System.out.print(Integer.toBinaryString(3 << 0) + Integer.toBinaryString(0) + " ");// 110
        System.out.print(Integer.toBinaryString(3 << 0) + Integer.toBinaryString(1) + " ");// 111*/
    }
}
-----------------------------------------------------------------------------
변환 결과 :[1, 10, 11, 100, 101, 110, 111]

위의 코드는 처음에 시도했던 방법이다.. 대학교에서 컴퓨터 구조, 마이크로프로세서 시간에 배운 카운터가 생각이 나서 한번 시도해봤다..

위에 코드는 무시하는걸로 .. 매우 정답률이 처참하다. 따라서 다른 메소드를 이용한 방법을 찾아 봤는데...

import java.util.*;

class Solution {
    public int[] solution(int l, int r) {
        List<Integer> list = new ArrayList<>(); 
        int count = 0
        for(int i = l; i<=r; i++) {
            String str = i + "";
            for(int j = 0; j < str.length(); j++) {
                if(str.charAt(j) == 48 || str.charAt(j) == 53) {
                    count ++;
                }
            }
            if(count == str.length()) {
                list.add(i);
            }
            count = 0;
        }
        int[] answer = list.stream().mapToInt(i->i).toArray();
        int[] empty = {-1};
        if(answer.length == 0) return empty;
        return answer;
    }
}
-------------------------------------------------------------
정확성  테스트
테스트 1 〉	통과 (12.20ms, 72.1MB)
테스트 2 〉	통과 (10.33ms, 75.7MB)
테스트 3 〉	통과 (19.62ms, 81.2MB)
테스트 4 〉	통과 (19.15ms, 76.1MB)
테스트 5 〉	통과 (19.20ms, 76.6MB)
테스트 6 〉	통과 (10.35ms, 78.1MB)
테스트 7 〉	통과 (39.34ms, 90.6MB)
테스트 8 〉	통과 (63.02ms, 86.8MB)
테스트 9 〉	통과 (53.52ms, 81.6MB)
테스트 10 〉	통과 (118.56ms, 101MB)
테스트 11 〉	통과 (53.19ms, 87MB)
테스트 12 〉	통과 (9.34ms, 78.5MB)
테스트 13 〉	통과 (17.59ms, 80.6MB)
테스트 14 〉	통과 (19.52ms, 82.6MB)
테스트 15 〉	통과 (13.67ms, 85MB)
테스트 16 〉	통과 (9.65ms, 77.9MB)
테스트 17 〉	통과 (11.82ms, 72.9MB)
테스트 18 〉	통과 (37.47ms, 79.8MB)
테스트 19 〉	통과 (18.44ms, 78MB)
테스트 20 〉	통과 (34.29ms, 93.2MB)
테스트 21 〉	통과 (80.79ms, 96.7MB)
테스트 22 〉	통과 (27.65ms, 89.6MB)
채점 결과
정확성: 100.0
합계: 100.0 / 100.0

풀이:

• i를 주어진 r까지 반복하면서 아스키 코드로 48이거나 53 둘 중 하나라도 만족하는 순간 count를 증가하며
• 만약 카운트된 숫자와 string에 저장된 문자열의 길이가 같다면 list 배열에 저장하고 카운트를 초기화한다.
• 그리고 그렇게 리스트에 담은 것들을 정수 배열로 바꾸어 리턴한다.

#3 List 클래스

리스트란 배열처럼 순서가 있는 데이터를 저장하기위해 사용하는 자료구조이다!

일반적인 배열은 한번 크기를 지정하면 고정이되어 변경이 불가능하다는 점에서 리스트는 넣는 만큼 자동적으로 크기가 늘어나기 때문에

동적으로 사용할 때 좋다.

이러한 리스트(List)에는 2개의 종류가 있는데...

1. ArrayList(배열로 이루어진 리스트) / 2.LinkedList(노드)가 있다.

리스트는 초기 선언 시 크기를 지정하지 않아도 되며 추가는 공간을 늘리며 삭제는 공간을 지우는 것이다.

 

선언 방법

List<자료형> 이름 = new ArrayList<자료형 / 생략 가능>();
List<자료형> 이름 = new LinkedList<자료형 / 생략 가능>();

리스트 사용 방법 대표적인 메소드

add, get, set, clear, size, contains, remove

 

#3-1 List.add(value),  List.add(idx, value)

add -> 스택처럼 맨 뒤에 차례대로 삽입.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(3); // 1번 인덱스
        list.add(4); // 2번 인덱스
        System.out.println("출력 결과 :" + list);
    }
}
------------------------------------------
출력 결과 :[1, 3, 4]

add 중간 삽입 -> 원하는 위치에 삽입 가능.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(3); // 1번 인덱스
        list.add(4); // 2번 인덱스
        System.out.println("출력 결과 :" + list);
        list.add(1,2); // 중간에 값을 넣으면 원래 그 자리에 있던 값들은 뒤로 한칸 씩 밀려난다.
        System.out.println("중간 삽입 결과 :" + list);
    }
}
----------------------------------------
출력 결과 :[1, 3, 4]
중간 삽입 결과 :[1, 2, 3, 4]

#3-2 List.get(idx)

idx 위치에 있는 원소 값을 출력.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        System.out.println("0번 인덱스 원소 출려 결과 : " + list.get(0));
        System.out.println("1번 인덱스 원소 출려 결과 : " + list.get(1));
        System.out.println("2번 인덱스 원소 출려 결과 : " + list.get(2));
        System.out.println("3번 인덱스 원소 출려 결과 : " + list.get(3));
    }
}
------------------------------------------------------------------
0번 인덱스 원소 출려 결과 : 1
1번 인덱스 원소 출려 결과 : 2
2번 인덱스 원소 출려 결과 : 3
3번 인덱스 원소 출려 결과 : 4

#3-3 List.set(idx, value)

idx 위치에 있는 원소 값을 변경. 즉 치환.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        System.out.println("0번 인덱스 원소 출려 결과 : " + list.get(0));
        System.out.println("1번 인덱스 원소 출려 결과 : " + list.get(1));
        System.out.println("2번 인덱스 원소 출려 결과 : " + list.get(2));
        System.out.println("3번 인덱스 원소 출려 결과 : " + list.get(3));

        list.set(0, 4); // 0번 인덱스의 원소 값을 4로 치환.
        list.set(1, 3); // 1번 인덱스의 원소 값을 3로 치환.
        list.set(2, 2); // 2번 인덱스의 원소 값을 2로 치환.
        list.set(3, 1); // 3번 인덱스의 원소 값을 1로 치환.
        System.out.println("0번 인덱스 원소 출려 결과 : " + list.get(0));
        System.out.println("1번 인덱스 원소 출려 결과 : " + list.get(1));
        System.out.println("2번 인덱스 원소 출려 결과 : " + list.get(2));
        System.out.println("3번 인덱스 원소 출려 결과 : " + list.get(3));
    }
}
--------------------------------------------------------------------
0번 인덱스 원소 출려 결과 : 1
1번 인덱스 원소 출려 결과 : 2
2번 인덱스 원소 출려 결과 : 3
3번 인덱스 원소 출려 결과 : 4
0번 인덱스 원소 출려 결과 : 4
1번 인덱스 원소 출려 결과 : 3
2번 인덱스 원소 출려 결과 : 2
3번 인덱스 원소 출려 결과 : 1

#3-4 List.size()

리스트의 크기를 반환.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        System.out.println("리스트의 크기 :" + list.size());
    }
}
-----------------------------------------
리스트의 크기 :4

#3-5 List.clear()

모든 원소를 삭제. 초기화

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        System.out.println("리스트의 크기 :" + list.size());
        list.clear();
        System.out.println("리스트의 크기 :" + list.size());
    }
}
---------------------------------
리스트의 크기 :4
리스트의 크기 :0

#3-6 List.contains(value)

리스트에 value가 있는지 없는지 검사 있다면 true를 반환 없다면 false를 반환.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        System.out.println("리스트에 포함되어 있는지 ? :" + list.contains(1));
        System.out.println("리스트에 포함되어 있는지 ? :" + list.contains(5));
    }
}
----------------------------------------------
리스트에 포함되어 있는지 ? :true
리스트에 포함되어 있는지 ? :false

#3-7 List.remove(idx)

idx 위치에 있는 원소 값을 삭제한다. -> idx 위치의 원소 값을 삭제하면 idx + 1 위치에 있는 원소 값이 idx 위치로 (앞으로) 한칸 씩 이동한다.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 0번 인덱스
        list.add(2); // 1번 인덱스
        list.add(3); // 2번 인덱스
        list.add(4); // 3번 인덱스
        list.remove(0);
        System.out.println("0번 인덱스 원소 출려 결과 : " + list.get(0));
        System.out.println("1번 인덱스 원소 출려 결과 : " + list.get(1));
        System.out.println("2번 인덱스 원소 출려 결과 : " + list.get(2));
    }
}
---------------------------------------
0번 인덱스 원소 출려 결과 : 2
1번 인덱스 원소 출려 결과 : 3
2번 인덱스 원소 출려 결과 : 4

#4-1 LinkedList 사용.

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1); // ex) 0번지 원소의 값은 1  -> 번지수는 쉽게 이해하기 위해서 임의로 적어놨다.
        list.add(2); // ex) 1번지 원소의 값은 2
        list.add(3); // ex) 2번지 원소의 값은 3
        list.add(4); // ex) 3번지 원소의 값은 4
        list.add(5); // ex) 4번지 원소의 값은 5
        for(int i = 0; i < list.size(); i++) // for문을 이용해 리스트 값 출력.
            System.out.println(i + "번지의 원소 값 :" + list.get(i));
        for(int l : list) // iterator를 이용해 리스트 값 출력
            System.out.print(l + "\t");
    }
}
----------------------------------------

0번지의 원소 값 :1
1번지의 원소 값 :2
2번지의 원소 값 :3
3번지의 원소 값 :4
4번지의 원소 값 :5
1	2	3	4	5

class FirstJava {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1); // ex) 0번지 원소의 값은 1  -> 번지수는 쉽게 이해하기 위해서 임의로 적어놨다.
        list.add(2); // ex) 1번지 원소의 값은 2
        list.add(3); // ex) 2번지 원소의 값은 3
        list.add(4); // ex) 3번지 원소의 값은 4
        list.add(5); // ex) 4번지 원소의 값은 5

        for(int l : list) // iterator를 이용해 리스트 값 출력
            System.out.print(l + "\t");
        System.out.println();
        list.set(2, 0); // 2번지 주소의 원소 값을 0으로 수정.

        System.out.print("수정된 값: ");
        for (int l : list) { // iterator를 이용해 리스트에 값 출력
            System.out.print(l + "\t");
        }
        System.out.println();

        list.remove(1); // 1번지 주소와 원소 값 삭제.

        System.out.print("삭제된 값: ");
        for (int i = 0; i < list.size(); i++) { // 일반 for를 이용해서 반복
            System.out.print(list.get(i) + "\t"); // .get() 메서드를 이용해 리스트에 값 출력
        }
        System.out.println();
    }
}
---------------------------------------------------
1	2	3	4	5	
수정된 값: 1	2	0	4	5	// set 메소드를 통해 원소 값 삭제.
삭제된 값: 1	0	4	5       // remove 메소드를 통해 노드 연결을 해제

stream API에 대해서는 여기에서 정리 중... https://sun-dori.tistory.com/13