개발자가 된 핏짜

문제설명

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

제한 사항

x는 1 이상, 10000 이하인 정수입니다.

문제 풀이

1. int x 값을 String 타입으로 바꾼후 .split()을 이용해서 배열로 만든다.

2. 각 인덱스 값을 더해준다. -> int sum 

3. x를 sum으로 나눈 나머지가 ==0 이면 true, 아니면 false 를 리턴한다.

public class harshadNumber {
    public boolean solution(int x) {
        boolean answer = true;

        String num = String.valueOf(x);
        String[] numbers = num.split("");

        int sum =0;

        for (String number : numbers) {
            sum += Integer.parseInt(number);
        }
        
        if(x%sum==0){
            return answer;
        } else{
            answer=false;
            return answer;
        }

    }

    public static void main(String[] args) {
        harshadNumber method = new harshadNumber();
        System.out.println(method.solution(18));
    }
}

처음에 기본 for문을 사용했다가 향상된 for문을 사용해봤습니다.

훨씬 편하네요. 

문제 설명

1937년 Collatz란 사람에 의해 제기된 이 추측은, 주어진 수가 1이 될 때까지 다음 작업을 반복하면, 모든 수를 1로 만들 수 있다는 추측입니다. 작업은 다음과 같습니다.

1-1. 입력된 수가 짝수라면 2로 나눕니다. 
1-2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다. 
2. 결과로 나온 수에 같은 작업을 1이 될 때까지 반복합니다. 

예를 들어, 주어진 수가 6이라면 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야 하는지 반환하는 함수, solution을 완성해 주세요. 단, 주어진 수가 1인 경우에는 0을, 작업을 500번 반복할 때까지 1이 되지 않는다면 –1을 반환해 주세요.

제한 사항

입력된 수, num은 1 이상 8,000,000 미만인 정수입니다.

문제 풀이

❗😱매개변수 num의 자료형을 int->long으로 변환하지 않으면 테스트3의 결과가 -1이 아닌 488로 다르게 나온다. 
😱😱😱😱연산 과정에서 오버플로우가 발생하기 때문이다. 따라서, public int solution(long num) 으로 바꿔야한다.

public class Collatz {

    public int solution(long num) {
            int answer = 0;

            if(num==1){
                answer =0;
            }

            while(num!=1){

                if(num%2==0){
                    num/=2;
                } else{
                    num = (num * 3) + 1;
                }

                answer++;

                if(answer>500){
                    return -1;
                }

            }

          return answer;

        }


    public static void main(String[] args) {
        Collatz method = new Collatz();
        System.out.println(method.solution(626331));
    }
}

오버플로우

선언 된 데이터 유형 범위를 벗어난 값을 할당 할 때 발생

연산과정에서 int 타입의 범위(-2^31 ( -2,147,483,648 )에서 2^31 -1( 2,147,483,647))를 벗어나면 계산이 안되고 멈춘다. 

num = 626311 에 대한 answer 값이 488 계속 나오길래 뭐가 잘못된 건가 Collatz의 추측이 맞았나 했는데

연산 값을 찍어보면, 104번째가 음수 -1085063658 으로 출력되었다. 

오버플로우로 값이 초과되서 음수로 표현이 되는 것이다.

103번째 num의 값은 홀수 이므로 1069967879*3+1 이 104번째 num값이 되어야하는데 int의 범위를 초과하는 것이다.

그래서 int타입을 long으로 변환해야 된다.

문제 설명

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

제한 사항

• arr은 길이 1 이상인 배열입니다.
• 인덱스 i, j에 대해 i ≠ j이면 arr[i] ≠ arr[j] 입니다.

문제 풀이

1. 최솟값 int min 을 구한다.  for문을 돌린다. 

2. min과 같지 않은 수들로만 이루어진 배열을 새로 만든다. int[] num = new int[arr.length-1];

import java.util.Arrays;

import static java.util.Arrays.fill;

public class elimination {
    public int[] solution(int[] arr) {
        if(arr.length<=1){
        int[] answer = {-1};
        return answer;
        }

        int min = arr[0];

        for(int i=arr.length-1; i>0; i--){
            if(arr[i]<min){
                min = arr[i];
            }
        }
        System.out.println(min);

        int[] answer = new int[arr.length-1];
        int index=0;
        for(int i=0; i<arr.length;i++){
            if(arr[i]!=min){
            answer[index++]=arr[i];
        }

        }

        return answer;
    }

    public static void main(String[] args) {
        elimination method = new elimination();
        System.out.println(Arrays.toString(method.solution(new int[]{5,6,7,8})));
    }
}

문제 설명

임의의 양의 정수 n에 대해, n이 어떤 양의 정수 x의 제곱인지 아닌지 판단하려 합니다.n이 양의 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 양의 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요.

제한 사항

n은 1이상, 50000000000000 이하인 양의 정수입니다.

문제 풀이

if else문을 사용하면 될 것 같습니다...?

1.  x*x == n 이면 (x+1)*(x+1) 을 리턴하고 else -1을 리턴한다.

2. sqrt(n) = x 

public class Squareroot {
    public long solution(long n) {
        long answer = 0;
        long x = 0;
        x = (long) Math.sqrt(n);
        if(x*x ==n){
            answer = (x+1)*(x+1);
        } else {
            answer = -1;
        }
        return answer;
    }

    public static void main(String[] args) {
        Squareroot method = new Squareroot();
        System.out.println(method.solution(121));
    }
}

문제 설명

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

제한 사항

n은 1이상 8000000000 이하인 자연수입니다.

문제 풀이

Arrays.sort() 사용하면 되겠다~😎

근데 얘는 오름차순으로 배열하는 메서드이니까 for문을 사용해서 다시 배열 해주자.

1. 문자열로 전환하기 String.valueOf() 메서드 사용

2. split() 메서드 사용해서 나눈 값으로 배열 만들기

3. Arrays.sort() 사용해서 오름차순으로 배열하기

4. for문을 사용해서 내림차순으로 배열하기

5. long 타입으로 변환해서 answer에 저장하기

import java.util.Arrays;

public class descendingOrder {

        public long solution(long n) {
            long answer = 0;
            String str = String.valueOf(n);         //String 타입 변환
            String[] nums = str.split("");          //String 배열 만들기
            Arrays.sort(nums); //[1,1,2,3,7,8]      //오름차순으로 정렬하기
            long[] num = new long[nums.length];
            for(int i=0; i<nums.length; i++){       //내림차순으로 정렬하기
                num[i]= Long.parseLong(nums[nums.length-1-i]);
            }

            String almostanswer = "";     //거의 다왔어요! String으로 만들었다가
            for(int i=0; i<num.length;i++){
                almostanswer += num[i];
            }
            answer = Long.parseLong(almostanswer); //Long 타입으로 변환하기!
            return answer;
        }


    public static void main(String[] args) {
        descendingOrder method = new descendingOrder();
        System.out.println(method.solution(118372));
    }
}

문제 설명

자연수 n을 뒤집어 각 자리 숫자를 원소로 가지는 배열 형태로 리턴해주세요. 예를들어 n이 12345이면 [5,4,3,2,1]을 리턴합니다.

제한 사항

n은 10,000,000,000이하인 자연수입니다.

문제 풀이

1. 문자열로 변환 String.valueOf.

2. split() 메서드 사용해서 나눈 값으로 배열 만들기

2. for문 이용해서 새로운 배열 만들어주기

import java.util.Arrays;

public class backwardNumbers {
        public int[] solution(long n) {

            String s = String.valueOf(n);
            String[] arr = s.split("");

            int[] answer = new int[arr.length];
            for(int i=0; i<arr.length; i++){
                answer[i] =Integer.parseInt(arr[arr.length-1-i]);
            }


            return answer;
        }

    public static void main(String[] args) {
        backwardNumbers method = new backwardNumbers();
        System.out.println(Arrays.toString(method.solution(12345)));

    }
}

answer를 저대로 프로그래머스에 입력하면 알아서 전환을 해줘서 배열이 출력되지만 

IntelliJ에서는 Arrays.toString(answer) 사용해서 출력해야합니다.

문제설명

자연수 N이 주어지면, N의 각 자릿수의 합을 구해서 return 하는 solution 함수를 만들어 주세요.
예를들어 N = 123이면 1 + 2 + 3 = 6을 return 하면 됩니다.

제한사항

N의 범위 : 100,000,000 이하의 자연수

문제 풀이

1. integer를 string으로 변환

2. string 문자열을 배열로 변환

3. 배열을 integer로 변환해서 더해주기

public class addNumbers {
    public int solution(int n) {
        int answer = 0;
        String num = String.valueOf(n);
        String[] add = num.split("");
        for(int i=0; i<add.length; i++){
            answer += Integer.parseInt(add[i]);
        }
        return answer;
    }

    public static void main(String[] args) {
        addNumbers method = new addNumbers();
        System.out.println(method.solution(123));
    }
}

문제설명

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

제한 사항

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

문제 풀이

1. String s를 각 문자로 나눠서 배열에 저장한다.

2. 각 인덱스 값을 매길 변수 int index =0; ->홀수 짝수를 나타내기 위해

3. 공백이 생길 때마다 index 값을 초기화 한다.

4. 홀수이면 toLowerCase() 사용, 짝수이면 toUpperCase() 사용한다.

5. 변환한 글자를 answer에 저장한다.

public class weirdo {

    public String solution(String s) {
        String answer = "";

        String[] word = s.split(""); //s를 한글잘씩 잘라 word 배열에 담습니다.
        int index = 0;         //홀수, 짝수를 나타나기 위한 index 변수입니다.
        int length = word.length; //word 배열의 길이

        for (int i = 0; i < length; i++) {
            if (word[i].equals(" ")){
                word[i] = " ";
                index = 0;      //공백이후 index 값 초기화 ==0이 된다.
            }else {
                if (index % 2 != 0) {
                    word[i] = word[i].toLowerCase();
                    index++;
                } else if (index % 2 == 0) {
                    word[i] = word[i].toUpperCase();
                    index++;
                }
            }
            answer = answer + word[i];
        }
        return answer;
    }




    public static void main(String[] args) {
        weirdo method = new weirdo();
        System.out.println(method.solution("I love a pizza"));
    }
}

출력값

I LoVe A PiZzA

피자를 사랑합니다🍕🍕😘

문제 설명

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.
마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

제한 사항

마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
completion의 길이는 participant의 길이보다 1 작습니다.
참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
참가자 중에는 동명이인이 있을 수 있습니다.

문제 풀이

1. participant에는 있지만 completion에는 없는 값을 찾으면 된다.

2. 동명이인은 어떻게 처리하지? 

3. 오름차순으로 정렬한 후 이름이 같은지 확인하고 아니라면 answer +=;

import java.util.Arrays;

public class unfinished {
    public static void main(String[] args) {
        String [] participant ={"marina", "josipa", "nikola", "vinko", "filipa"};
        String [] completion = {"josipa", "filipa", "marina", "nikola"};
        String answer ="";

        Arrays.sort(participant);
        System.out.println(Arrays.toString(participant));
        Arrays.sort(completion);
        System.out.println(Arrays.toString(completion));

        for(int i =0; i< completion.length;i++){
            if(!(participant[i].equals(completion[i]))){
                answer = participant[i];
                break;
            }else{
                answer = participant[i+1];
            }

        }
        System.out.println(answer);
    }
}

문제 설명

길이가 n이고, "수박수박수박수...."와 같은 패턴을 유지하는 문자열을 리턴하는 함수, solution을 완성하세요. 예를들어 n이 4이면 "수박수박"을 리턴하고 3이라면 "수박수"를 리턴하면 됩니다.

제한 조건

n은 길이 10,000이하인 자연수입니다.

문제 풀이

1. 홀수 이면 '수', 짝수이면 '박'을 출력하기

2. for(int i=1; i<=n; i++){ if(i%2!=0){ answer+='수';} else{ answer+='박';}

import java.util.Scanner;

public class soovak {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = 0;
        String answer = "";
        n = scanner.nextInt();
        for(int i=1; i<=n; i++){
            if(i%2!=0){
                answer +='수';
            } else{
                answer +='박';
            }
        }
        System.out.println(answer);
    }
}

매우 간단한 문제!

삼항연산자를 쓰면 더 좋았을 것 같네요.