TIL_240214

라미·2024년 2월 14일

TIL

목록 보기

13/25

정수 내림차순으로 배치하기

❤️문제

함수 solution은 정수 n을 매개변수로 입력받아, n의 각 자릿수를 큰것부터 작은 순으로 정렬한 새로운 정수를 리턴해주세요. 예를들어 n이 118372면 873211을 리턴하면 됩니다.

📝풀이

// 1. 정수를 string으로 변환 후 string 배열로 저장하기
public static long solution(long n){
    long answer = 0;
    String result="";
    //1. long 을 스트링으로 변환 하여 배열로 저장
    String[] strNum = String.valueOf(n).split("");
    Arrays.sort(strNum);
    for(int i=strNum.length-1; i>=0; i--){
        result += strNum[i];
    }


    return Long.parseLong(result);
}

// 2. 정수를 쪼개서 리스트에 저장하기
public static long solution2(long n) {
    // 속도측면에서 훨씬 빠름
    // 1. while % -> 각 자리수를
    // 2. LongStream 으로 .char
    // 3. String -> int -> Arr -> sort
    List<Long> arr = new ArrayList<Long>();

    while (n > 0) {
        Long digit = n % 10;
        n /= 10;
        arr.add(digit);
    }
//            Collections.reverse(arr);
    Collections.sort(arr, Collections.reverseOrder());

    long answer = 0;
    for(int i =0; i<arr.size(); i++){
        answer = (answer * 10) + arr.get(i) ; // 인덱스 값 하나씩 가져옴
    }
    return answer;
    }

👍새로 알게 된 점

- List의 정렬인 Collection.sort 사용법은 Arrays.sort와 동일하다.
- 두개의 코드를 모두 돌려봤을 때 결과는 동일하지만 변환과정이 줄어들어서인지 Long list에 담아서 sort 한게 훨씬 빠른걸 확인 할 수 있었다.

📝다른 풀이

//첫 번째 코드를 개선시킨 수 있는 방법 ( 1+ 2가 합쳐져서 List가 아닌 배열에 값을 저장하였다.)
public static long solution(long n){

    // 각 자릿수를 배열에 저장하고 직접 정렬하여 결과 계산
    String[] strNum = String.valueOf(n).split("");
    int len = strNum.length;
    int[] intArray = new int[len];

    for (int i = 0; i < len; i++) {
        intArray[i] = Integer.parseInt(strNum[i]);
    }

    Arrays.sort(intArray);

    long answer = 0;
    for (int i = len - 1; i >= 0; i--) {
        answer = answer * 10 + intArray[i];
    }

    return answer;
}

실행해본 결과 속도는 비슷하게 나왔다. 결과적으로 string을 정렬한 후 연산하여 변환하는 것보다 List나 배열에 담은 후 sort 하는게 훨씬 빠르다.

하샤드 수

❤️문제

양의 정수 x가 하샤드 수이려면 x의 자릿수의 합으로 x가 나누어져야 합니다. 예를 들어 18의 자릿수 합은 1+8=9이고, 18은 9로 나누어 떨어지므로 18은 하샤드 수입니다. 자연수 x를 입력받아 x가 하샤드 수인지 아닌지 검사하는 함수를 완성

📝풀이

public static boolean solution(int x) {
    int originNum = x;
    int sum = 0;
    while ( x > 0 ) {
        sum += x % 10; // sum에 나머지 저장 x가 998 이라면 8 저장
        x = x / 10; // x / 10 함 x가 998 이었다면 x = 99
    }
    return originNum % sum == 0 ? true : false;
    }

정수 x가 0보다 큰 동안 while문이 반복 되도록 구현하였다.
sum 에 x % 10 을 하여 1의 자리의 나머지 값을 저장한 후 x / 10 을 x 에 저장해 주어 x 의 값을 계속 줄여줬다.
sum에는 계속하여 x의 1의 자리 수(각 자리 수의 합)이 중첩 된 후 x 가 0 보다 작아지면 종료된다.
하샤드 수인지 검사하기 위해 x의 원본 값과 sum의 값을 나누어 떨어진다면 true 아니면 false 를 반환하는 함수를 구현하였다.

👍새로 알게 된 점

//GPT가 알려줬는데 return 부분에서 삼항연산자를 사용하지않고 바로 조건식을 사용해 줘도 된다고 한다.
//생각해보니 true 일때 true를 반환해주는 거면 그냥 결과를 바로 리턴해줘도 상관이 없구나!!
return originNum % sum == 0;

두 정수 사이의 합

❤️문제

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요.
예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

📝풀이

//1. if 문을 사용하여
public long solution(int a, int b) {
    long answer = 0;
    
    // a, b 사이에 속한 모든 정수의 합
    if(a>b){
        for(long i = b; i<= a; i++){
        answer += i;
        }
    }
    else {
        for(long i = a; i<= b; i++){
            answer += i;
        }
    }    
    return answer;
}

//2. 삼항연산자를 사용
public long solution(int a, int b) {
    long answer = 0;
    
    for(int i =0; i<= (a < b ? b-a : a-b); i++){
        answer += a < b ? a+i : a-i;
    }

    
    return answer;
}

삼항연산자를 사용한게 훨씬 간결하고 가독성이 좋은 코드이긴 했지만 채점해본 결과 미세하게 if문을 사용했을때의 결과가 더 빠른 속도를 가지고 있었다.
궁금해서 GPT 에게 물어보니 실제로 코테에서는 속도보다 명확성과 가독성이 중요한 경우도 있다고 한다니까 참고해야지...!

📝다른 풀이


    public long solution(int a, int b) {
        return sumAtoB(Math.min(a, b), Math.max(b, a));
    }

    private long sumAtoB(long a, long b) {
        //a : 최소값, b: 최대값
        return (b - a + 1) * (a + b) / 2;
    }

👍새로 알게 된 점

- 등차수열 공식을 활용하여 반복문 없이 문제를 푸셨다...등차수열이라니...등차수열이라니...!!
등차수열 공식 : 등차수열 첫째항부터 제 n항까지의 합 sum(내 편의상)
- 첫째항 a, n항이 l 일때 a~n항까지의 합 sum = n(a+l)/2
- 첫째항 a, 공차(항간의 차이)가 d일 때 s, sum = n(2a+(n-1)d)/2
- 등차수열 합 공식: n*(n+1)/2 | r= 차수 n=count

- Math.min()/ Math.max() 메서드

Math.min() / Math.max()

정수 및 실수를 비교하여 최솟값 또는 최댓값을 반환한다.
Math.min(int a, int b) : a, b 를 비교하여 최솟값을 반환해 준다.
Math.max(int a, int b) : a, b 를 비교하여 최댓값을 반환해 준다.

int minInt = Math.min(10, 20); // minInt는 10
double minDouble = Math.min(3.14, 2.71); // minDouble은 2.71

int maxInt = Math.max(10, 20); // maxInt는 20
double maxDouble = Math.max(3.14, 2.71); // maxDouble은 3.14

콜라츠 추측

❤️문제

주어진 수가 1이 될때까지 반복
입력된 수가 짝수라면 2로 나눈다
입력된 수가 홀수라면 3을 곱하고 1을 더한다
결과로 나온 수에 같은 작업을 1이 될때까지 반복한다.
주어진 수가 1 -> 0 / 반복 500 이상한다면 -1 return

📝풀이

public int solution(int num) {
    int answer = 0;
    long colNum = num;
    
    // num 이 1 이면 0 return 해야 하기 때문에 1이 아닌동안 반복문 실행
    while(colNum != 1){
        // if문 삼항연산식으로 표현시
        // num = (num % 2 == 0 )? num / 2 : num * 3 + 1; 
        if (colNum % 2 == 0) { // 짝수일 때 계산
            colNum /= 2;
        } else { // 홀수일 때 계산
            colNum = colNum * 3 + 1;
        }
        answer++; // 횟수 추가
        
        //500번 시도하면 -1 return
        if(answer == 500){
            return -1;
        }
    }
    
    return answer;
}

📝다른 풀이

public int collatz(int num) {
    long n = (long)num;
    for(int i=0; i<500; i++){
        if(n==1) return i; 
      n = (n%2==0) ? n/2 : n*3+1;
    }

        return -1;
    }

👍새로 알게 된 점

다른 사람의 풀이에서 이미 반복의 최대 횟수가 주어졌기에 for문을 
사용해서 반복을 하는 것도 좋은 선택지라는 생각이 들었다.

나누어 떨어지는 숫자 배열

❤️문제

array의 각 element 중 divisor로 나누어 떨어지는 값을 오름차순으로 정렬한 배열을 반환하는 함수, solution을 작성해주세요.
divisor로 나누어 떨어지는 element가 하나도 없다면 배열에 -1을 담아 반환하세요.

📝풀이

// 1. array의 length를 구하여 정렬하기
class Solution {
    public int[] solution(int[] arr, int divisor) {
        int answer[];
        int arrLength = 0;
        
        //arr을 divisor 을 나누어서 오름차순 정렬        
        for(int i : arr){
            if(i%divisor == 0){
                arrLength++;                
            }
        }

        if(arrLength == 0){
            answer = new int[]{-1};
        }else{
            answer = new int[arrLength];
            int index = 0;
            for(int i : arr){
                if(i % divisor == 0){
                    answer[index++] = i;
                }
            }
            //정렬
            Arrays.sort(answer);
        }

        return answer;
    }
}


// 2.List에 배열을 담아서 정렬해주기
class Solution {
    public int[] solution(int[] arr, int divisor) {
        List<Integer> result = new ArrayList<>();

        //arr length 만큼 반복
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % divisor == 0) {
                result.add(arr[i]);
            }
        }
        /* 향상된 for 문으로 변경
        for (int num : arr) {
            if (num % divisor == 0) {
                result.add(num);
            }
        }
        */
        if (result.isEmpty()) { // list가 비어있다면
            int[] answer = {-1};
           return answer;
        } else { // 배열에 리스트 넣어주기
            int[] answer = new int[result.size()];
            for(int i=0; i<result.size(); i++){
                answer[i] = result.get(i);
            }
            Arrays.sort(answer);
            return answer;
        }
    }
}

👍새로 알게 된 점

배열의 길이를 알 수 없는 상황에서는 역시 리스트를 사용하는게 더 효울적인 방법 인 것 같다.
하지만 다시 Array로 변환해야 하는 것도 염두해야 하는 것 같다.

핸드폰 번호 가리기

❤️문제

프로그래머스 모바일은 개인정보 보호를 위해 고지서를 보낼 때 고객들의 전화번호의 일부를 가립니다.
전화번호가 문자열 phone_number로 주어졌을 때, 전화번호의 뒷 4자리를 제외한 나머지 숫자를 전부 *으로 가린 문자열을 리턴하는 함수, solution을 완성해주세요.

📝풀이

class Solution {
    public String solution(String phone_number) {
        int strLength =  phone_number.substring(0,phone_number.length()-4).length();
        String star = "*".repeat(strLength);
        String backNumber = phone_number.substring(phone_number.length()-4);

        return star+backNumber;
    }
}

📝다른 풀이

class Solution {
  public String solution(String phone_number) {
     char[] ch = phone_number.toCharArray();
     for(int i = 0; i < ch.length - 4; i ++){
         ch[i] = '*';
     }
     return String.valueOf(ch);
  }
}

👍새로 알게 된 점

- 나는 substring를 사용하여 풀었지만 풀고 나서 다른 분이 푼 것을 봣는데 charArray로 변경한뒤 뒤에 4자리를 제외한 나머지를 '*'로 변경해 주고 다시 String으로 변환해주는 풀이었다.
훨씬 깔끔하고 코드를 실행해봤을때 속도면에서 더 빠른 것 같다. api 사용보다 for문과, 형변환, 사용을 좀 더 공부해야 할 것 같다.

정수 내림차순으로 배치하기

❤️문제

정수를 저장한 배열, arr 에서 가장 작은 수를 제거한 배열을 리턴하는 함수, solution을 완성해주세요. 단, 리턴하려는 배열이 빈 배열인 경우엔 배열에 -1을 채워 리턴하세요. 예를들어 arr이 [4,3,2,1]인 경우는 [4,3,2]를 리턴 하고, [10]면 [-1]을 리턴 합니다.

📝풀이

import java.util.*;
class Solution {
    public int[] solution(int[] arr) {
        //가장 작은 수를 제거한 배열을 리턴, 빈 배열일 경우 -1 채워서 리턴
        if (arr.length == 1) {
            return new int[]{-1};
        }
        
        //원본 배열의 -1 만큼 배열 카피
        int[] answer = Arrays.copyOf(arr, arr.length - 1);
        
        
        int minIdx = 0;
        for(int i =0; i < arr.length; i++){
            if(arr[i] < arr[minIdx]){
                //minIdx에 i를 저장
                minIdx = i;
            }
        }
        
        for(int i = minIdx; i < answer.length; i++){
            answer[i] = arr[i +1];
        }
        return answer;
    }
}

👍코드 설명

배열에 가장 작은 수를 제거하는 문제였다.
1. 원본 배열의 길이가 1일 경우 배열의 원소 -1 return 해주기
2. 원본 배열 길이의 -1 만큼 복사하기
3. 원본 배열의 최솟값을 가지는 원소의 인덱스 구하기
4. 복사한 배열에 최소값 인덱스 자리부터 인덱스+1 로 변경해주기
-> 이렇게 구성했다. 흠...LinkedList 를 쓰는건 어떨까 생각도 든다

📝GPT가 보완해 준 코드

class Solution {
    public int[] solution(int[] arr) {
        // 배열의 길이가 1일 경우 -1을 가진 배열 반환
        if (arr.length == 1) {
            return new int[]{-1};
        }

        // 최솟값의 인덱스를 찾기
        int minIdx = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[minIdx]) {
                minIdx = i;
            }
        }

        // 새로운 배열 생성
        int[] answer = new int[arr.length - 1];

        // 최솟값을 제외하고 요소 이동
        for (int i = 0, j = 0; i < arr.length; i++) {
            if (i != minIdx) {
                answer[j++] = arr[i];
            }
        }

        return answer;
    }
}

👍새로운 점

지피티가 코드 보완을 해줬다.
-배열 복사 과정을 삭제한 후 새로운 배열에 직접 요소 이동을 하는 방법을 알려줬다.
for 문 선언부 초기화 부에 두개를 동시에 초기화 할 수 있다는게 너무 신기했다.

가운데 글자 가져오기

❤️문제

단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다

📝풀이

public static String solution(String s) {

    String answer = "";
    String[] strArr = s.split("");
    //단어의 길이가 짝수면 가운데 두글자 반환
    // s 길이 1 이상 100 이하
    int len = s.length();
    if( !(len % 2 == 0)){//홀수일때
//            char ch = s.charAt(len/2);
        answer = strArr[len/2];
    }else{ //짝수는 가운데 두개 0123 2,1
        answer = strArr[len/2-1] + strArr[len/2] ;

    }

흠...정말 지저분하게 풀었다

📝다른 풀이

String getMiddle(String word){

return word.substring((word.length()-1)/2, word.length()/2 + 1);
}

👍새로 알게 된 점

다른 분의 풀이를 보는 중 너무 깔끔해서 한번 적어본다.
substring을 사용하여 시작인덱스와 (length.-1 /2) 끝인덱스(word.length()/2 + 1) 범위를 지정해줬다.
흠....너무 창피해지는 지저분한 나의 풀이...

약수의 개수와 덧셈

❤️문제

두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

📝풀이

public int solution(int left, int right) {
    int answer = 0;
    //13,14,15,16,17 까지 
    for(int i = left; i<= right; i++){//left~right 까지의 수들
        //약수의 개수를 return 받아야 한다.
        //i = left i 별로 count 필요
        int count=0;
        for(int j=1; j<=i; j++){
            if(i % j ==0){
                count++;
            }
        }
        System.out.println(i+" : 약수개수 : "+count);
        
        if(count % 2 == 0){ //약수개수가 짝수
            answer += i;
        }else{
            answer -= i;
        }
        
    }
    return answer;
}

📝다른 풀이

class Solution {
    public int solution(int left, int right) {
        int answer = 0;

        for (int i=left;i<=right;i++) {
            //제곱수인 경우 약수의 개수가 홀수
            if (i % Math.sqrt(i) == 0) {
                answer -= i;
            }
            //제곱수가 아닌 경우 약수의 개수가 짝수
            else {
                answer += i;
            }
        }

        return answer;
    }
}

👍새로 알게 된 점

제곱수의 경우 약수의 개수가 홀수라는 사실로 코드가 아주 간결해졌다!!

최대공약수와 최소공배수

❤️문제

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

📝풀이

public int[] solution(int a, int b) {

    int answer[] = new int[2];

    //최대 공약수 두수의 최대 공약수
    //최소공배수 = 두자연수의 곱 / 최대공약수
    int max = Math.max(a, b);
    int min = Math.min(a, b);

    while (min != 0) {
        //호제법 사용 하여 max % mix 을 해줌
        int temp = min;
        min = max % min;
        max = temp;
    }
    //최대 공약수
    answer[0]=max;

    //최소공배수
    answer[1] = a*b/ max;
    return answer;
}

📝다른 풀이

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

👍새로 알게 된 점

두 수의 최대공약수를 구하는 `유클리드 호제법` 이란 알고리즘을 알았다.

최대공약수 & 최소공배수 구하기

1. 유클리드 호제법

2개 수의 최대 공약수를 구하는 방법(알고리즘).
자연수 a,b에 대하여 a를 b로 나눈 나머지를 r 이라고 할때, a,b의 최대 공약수는 b,r의 최대 공약수와 같다.
따라서 r을 구하고 b를 r로 나눈 후 나머지를 구한다.
나머지가 0일때 나누었던 b가 최대 공약수.

최대 공약수 : 두 수 이상의 여러 수의 공약수 중 최대인 수
- GCD 라고 한다. (Greatest Common Divisor)
- 구하는 방법은 반복문 사용, 재귀 함수 사용 2가지가 존재한다!

//for문 사용
public static int gcdFor(int a, int b) {
    int answer = 0; // 최대 공약수

    //두 수 중 큰 값과 작은값을 구하기
    int max = Math.max(a, b);
    int min = Math.min(a, b);

    // 두 수를 각각 i로 나눠서 두수의 나머지가 0일때 -> 두수의 최대 공약수
    for (int i = 1; i <= min; i++) {
        if (a % i == 0 && b % i == 0) {
            answer = i;
        }
    }
    return answer;
}

//재귀함수 사용
public static int gcdRec(int a, int b) {
    // 나머지가 0일 경우 최대 공약수는 b이다.
    if (a % b == 0) {
        return b;
    }
    // 재귀 호출을 통하여 해결.
    return gcdRec(b, a % b);
}

최소공배수 공식

최소공배수 = 두 자연수(a,b)의 곱 나누기 최대 공약수

private static int min(int a, int b, int max) {
    return (a * b) / max; // max : 최대 공약수
}

시저 암호

❤️문제

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

📝풀이

public static String solution(String s, int n) {
    String answer = "";
    char[] chArr = s.toCharArray();
    // AB 1만큼 밀면 BC
    // Z 1 밀면 A
    // 대문자,소문자, 공백
    for(char ch : chArr){
        if('a'<=ch && ch<='z'){ //ch가 소문자일때
            answer += (char)(ch + n) > 'z' ? (char)(ch - 26 + n) : (char)(ch + n);
            // ch + n > z ? ch - z + n : ch + n
        }
        else('A'<=ch && ch<='Z') { //ch가 대문자일때
            answer += (char)(ch + n) > 'Z' ? (char)(ch - 26 + n) : (char)(ch + n);
        }else { // 공백일때는 공백 유지
            answer += " ";
        }
    }
    return answer;
}

📝다른 풀이

String caesar(String s, int n) {
    String result = "";
    n = n % 26;
for (int i = 0; i < s.length(); i++) {
    char ch = s.charAt(i);
    if (Character.isLowerCase(ch)) {
    ch = (char) ((ch - 'a' + n) % 26 + 'a');
    } else if (Character.isUpperCase(ch)) {
    ch = (char) ((ch - 'A' + n) % 26 + 'A');
    }
    result += ch;
}
    return result;
}

프로그래머스에 다른분이 푼 코드 가져와 봤다.

n = n % 26 을 통하여 n이26 보다 큰 경우에도 알파벳의 범위내에서 동작하게 보장 됐다. (26 : 아스키 코드 알파벳 주기)
문자의 대소문자 여부를 확인한다.
(char) ((ch - 'a' + n) % 26 + 'a')
1. ch - 'a': ch가 'a'를 기준으로 몇번째에 있는지 나타낸다
2. +n : 이동하고자 하는 위치를 구하기 위해 더해준다
3. % 26 : 역시 범위를 벗어나지 않게 한다.
4. +'a' 다시 'a'를 더해줘서 'a'를 기준으로 이동한 위치에 해당하는 새로운 소문자를 얻을 수 있다.
  👍새로 알게 된 점

- Character.isLowerCase() & Character.isLowerCase() : char 타입 문자의 대소문자 여부를 확인하여 true or flase를 반환하여 준다.
- 알파벳 주기를 + 나머지 연산을 사용하여 보다 간결한 코드를 구현할 수 있다는 사실을 알았다.

흠...알고리즘 너무 어렵다 아직 컴퓨터적 사고가 부족한 것 같다.