** [1차시도]**

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String S = br.readLine();
        Deque<String> deque = new ArrayDeque<String>();
        int cnt = S.length();

        for (String s : S.split("")) {
            deque.addLast(s);
        }

        while (!deque.isEmpty()){

            if (!deque.peekFirst().equals(deque.peekLast())){
                deque.addLast(deque.peekFirst());
                cnt++;
                System.out.println(deque);

            } else if (deque.peekFirst().equals(deque.peekLast())){
                deque.pollFirst();
                deque.pollLast();
                System.out.println(deque);
            }
        }
        System.out.println(cnt);
    }
}

예제는 모두 맞았는데 오류가 나서 다른 반례를 찾아보니 'aabca' 실제 답은 'aabcacbaa'로 9가 나와야 하지만 코드 상 첫번째 a와 마지막 a가 소거되어 답이 7이 나왔다

열심히 만든 코드인데 다른 점을 잘 못찾겠어서 다른 분들의 해설을 좀 참고해 보니, deque를 사용하지 않고 그냥 문자열 안에서 palindrome이 가능한 부분을 제외하고 아닌 부분을 더해주는 방법으로 푸셨길래 따라해 보았다!
** [2차시도]**

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String S = br.readLine();
        int cnt = S.length();

        for (int i = 0; i < S.length(); i++) {
            if (isPalindrome(S.substring(i))){
                break;
            }
            cnt++;
        }
        System.out.println(cnt);
    }

    public static boolean isPalindrome (String S){
        int start = 0 ;
        int end = S.length()-1;
        while (start <= end){
            if (S.charAt(start) != S.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
}

** 👍 내생각** 구글링이 가능한 것에 감사하며,,

① isPalindrome이라는 함수를 만들어서 맨 뒤와 맨 앞의 글자가 같은지 체크해줌 ② 주어진 글자수를 substring하면서 팰린드롬이 맞는 부분을 찾는다. ③ 팰린드롬이 아니면 정답으로 출력될 cnt에 1씩 더해준다. (즉 팰린드롬이 되려면 뒤에 다른 글자가 하나 붙어야 된다는 의미) ④ 기존 cnt값은 주어진 문자열의 길이로 설정해준다.
🤔배운내용 팰린드롬이라는 단어를 보자마자 무슨 파블로프의 개처럼 deque를 떠올리지 말자.. 문제를 보다 쉽게 풀 수 있는 방법이 있을지 많이 고민하자 (때로는 쉬운 방법으로 풀 수 있다)

사실 지금 푼 코드가 생각을 못해낼 정도는 아니였는데, 생각의 틀에 갇혀버린거 같다 아직은 시간에 촉박해 하지 말고, 문제를 열심히 푸는 걸로!

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        ArrayList arr = new ArrayList();

        int result = 0;

        for (int i = 0; i < n; i++) {
            int A = Integer.parseInt(br.readLine());
            arr.add(A);
        } 
// 각 입력값을 ArrayList에 저장함

        for (int i = 0; i < arr.size(); i++) {
            for (int j = i + 1; j < arr.size(); j++) {
                result += Integer.parseInt(String.valueOf(arr.get(i))) ^ Integer.parseInt(String.valueOf(arr.get(j)));
            }
        }
// for문을 2번 돌면서 2진법 XOR연산자로 비교해주고 result에 해당 값을 더해준다.
        System.out.println(result);
    }
}

                                           <br><br>

** 👍 내생각** 2진법 관련된 문제를 풀어본 적이 없어서 감이 안잡혔다 요 문제 풀 때 가장 헤맨 부분은 ① 10진법 숫자를 어떻게 2진법으로 나눠줘야 하나 고민했다 toBinary 명령어에 대해서 무지했다. ② XOR 연산자 (^)를 쓰기 위해서는 10진법 숫자를 2진법으로 바꿔줘야 되는 줄 알았다. 이 과정에서 int, Integer, String 사이에서 형변환 해주느냐고 아주 진땀을 뺐다 ③ 예제 문제까지는 다 원하는 값이 출력되는 코드를 짰지만 시간초과가 생겼다.

  <br><br>

🤔배운내용

1. 시간초과 ( 시간복잡도는 코드의 생명이란다 ) 난 아직 이거까지는 모르겠고,, 다른 방법은 더 생각해봐야겠다
2. 10진법 -> 2진법 은 toBinary 명령어 사용
3. 2진법 -> 10진법 은 Integer.parseInt(숫자, 2진법)
4. bufferedReader 사용법

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Hashtable;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
// 입력 배열의 size를 정해준다.


        StringTokenizer st = new StringTokenizer(br.readLine());
// 입력된 배열의 값을 나눠서 저장한다 (split이랑 비슷한 개념)

        int V = Integer.parseInt(br.readLine());
        int cnt = 0;
        int arr[] = new int [N];


        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

//각 입력값을 arr 배열에 넣어준다.

        for (int i = 0; i < N; i++) {
            if (arr[i] == V) {
                cnt++;
            }
        }
  // 배열의 i번째 값이 V랑 같으면 cnt증가

        System.out.println(cnt);
    }
}

** 👍 내생각** 어제 쪼까 헤맨 문제가 있었는데, 나중에는 scanner함수보다 bufferedReader을 더 많이 쓴다고 한다 (시간초과 때문이라고..) 그래서 나중에 가서 헤매기 보다 빨리 익숙해져야겠다 싶어서 오늘 부지런히 공부해보았다! 생각보다 쉬운 개념이어서 요리조리 따라해보니 괜찮았던거 같다.

일단 HashTable을 사용하라고 해서, 각 값을 ht.key와 value에 맞춰서 add하는것 까지는 해냈는데, 도저히 ht.key값에 따라 value에 접근하는 걸 못하겠더라..

어디 구글에서는 foreach문을 사용하라던데 난 아직 그 개념이 조금 어려웠다. 처음에는 ht.key가 i번째일 때 ht.containsValue가 V이면 cnt ++ 로 구현하려고 했는데 저 "ht.key가 i번째" 이 부분 구현이 불가했다.

1시간 조금 넘게 알아보다가 우선은 그래도 자신있는 배열과 ArrayList 로 고민해보자 싶어서 배열로 시도하였고 성공!

🤔배운내용

1. bufferedReader 사용방법

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        String s=scanner.nextLine();
        for(int i=0;i<n;i++) {
            String str="";
            str=scanner.nextLine();

// 해당 부분을 놓쳐서 n개의 괄호모음이 나와야 된다는 부분을 간과했었다. for문으로 전체 코드를 반복해주는 걸로 해결완료!


            boolean isVps = false;
            boolean isContinue = false;
// 다른 분들 코드보니까 isVps = false로 if문에서 끝나던데 난 안 끝나서 아예 boolean을 하나 더 추가해두었다. if문 안에서 비교하기 위해서!


            String arr[] = str.split("");
            Stack<String> stack = new Stack<>();

            for (int j = 0; j < arr.length; j++) {
                if (arr[j].equals("(")) {
                    stack.push("(");
                    isContinue = true;

// 입력된 값을 arr 배열에 넣고 그값이 ( <- 여는 괄호라면 stack에 넣는다. )


                } else if (arr[j].equals(")") && !stack.isEmpty()) {      
                    stack.pop();
  // stack이 비어있지 않고, arr이 ) <- 닫는 괄호라면 stack 값을 뺀다 (pop)

                    isContinue = true;
                } else if (arr[j].equals(")") && stack.isEmpty()) {
                    isContinue = false;
                    break;
// stack에 아무 값도 없이 ) <- 닫는 괄호만나왔을 때는 볼 것도 없이 false라는 부분을 isVps로 조건을 추가해주려고 했는데 위에 조건이랑 자꾸 충돌해서 그런지,, 적용이 안되더라!  그래서 다른 boolean값 넣어주기


                }
            }
            if (stack.isEmpty() && isContinue == true) {
                isVps = true;
            } else if (isContinue == false) {
                isVps = false;
            }
//위에서 정해준 다른 boolean값으로 isVps 정의해주고, 


            System.out.println(isVps ? "YES" : "NO");

 // 이게 뭐라고 했지 여튼 true, false로 나눠서 return 값을 정해준다
        }
    }
}

** 👍 내생각** 그래도 고민 많이 하면서 해냈다.. 일단 요 괄호 문제는 강의 시간에 강사님께서 한번 풀이 해주셨던 문제로 기억하기 때문에, "이걸 못풀면 난 2주동안 아무것도 안한거다" 요런 느낌으로 앉은 자리에서 슉슉 풀었다. 물론 boolean 값주는 거에서 조금 헤매긴 했지만 그래도 2주만에 백준 문제를 쇼쇽 풀어내니 다음 2주 후에는 난 얼마나 성장해있을까 기대도 된다

<br><br>

🤔배운내용

1. stack 개념 복습 (pop은 값설정 X / push는 데이터 줘야함)
2. 백준 문제 맨 처음에 N (횟수)를 무시하지 말것
3. stack에 emptyStack오류를 방지하기 위해 뭐라도 넣던지, emptyStack에 대해서 지정해줄 것

import java.util.Scanner;
import java.util.Stack;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            arr[i] = sc.nextInt();
        }
        // 입력값 모두 변수로 바꿔줌

        Stack<Integer>[] stacks = new Stack[4];
        for (int i = 0; i < 4; i++) {
            stacks[i] = new Stack<>();
            stacks[i].push(0);
        }
          // 만들어야 하는 4개의 스택을 stacks라는 배열로 만들어 준다.
             다만 만들어둔 스택이 아무 값도 안들어 있을수 있으니 0이라는 값을 넣어준다.
             emptyStack오류를 방지해준다 --> 실제로 이 오류때문에 많이 헤맸다

        boolean result = true; 
          // 청소 가능여부를 판별해준 boolean형식의 result 변수를 만든다.

        for (int i : arr) {
            boolean inStack = false;
          // 일단 stacks에 arr배열값을 넣어도 될지 여부는 false로 초기화해준다.

            for (int j = 0; j < 4; j++) {
                if (i > stacks[j].peek()) {
                    stacks[j].push(i);
                    inStack = true;
                    break;
                }
            }
          // for문을 돌면서 만약 arr의 i 원소가 stacks[j]의 stack.peek값(가장 위의 값)보다 크다면 
             해당 stacks에 i원소를 더한다. 그리고 false로 초기화 해준 inStack의 값을 true로 바꾼다.

                if (!inStack){
                    result = false;
                    break;
                }
          // 만약 inStack이 불가하다면, result(청소 가능여부) 는 false로 바뀐다.

            }
            System.out.println(result ? "YES" : "NO");
          // result가 true라면 YES를, false라면 NO를 반환해준다.

        }
    }

 <br><br>

** 👍 내생각** 우선 해당 문제는 내가 혼자 힘으로 코드를 짤 수 없을거 같아서 어떻게 구현할지 생각만 해보고 구글링을 통해 해결했다. 내가 생각한 부분은, ① 입력값을 배열로 만들자 ② 청소가능 여부를 판단해줄 boolean 변수를 만들자 ③ for문으로 입력값 배열을 돌면서, stack의 가장 마지막 값이 입력값 원소보다 작은지 판단하자 요 3가지 정도였고,

4가지 스택을 for문을 통해 배열로 만든 부분은 생각해내지 못했다. 스택을 4개로 모두 stack1, stack2, stack3, stack4로 만들어서 코드를 짜보려고 했는데, 각 스택의 peek를 비교하는 부분에서 for문이 적용되지 않아서 막혔다.

<br><br>

🤔배운내용

1. for문으로 stacks 배열을 만들어서 각 stack을 배열에 넣는 구현법
2. stack에 들어갈 수 있는지 여부와 청소 가능 여부는 각기 다른 boolean변수를 가지고 있어야 한다.
3. result의 true, false값에 따라 출력값을 다르게 설정한 부분
4. stack 개념

1차 시도

class Solution {
    public double solution(int[] numbers) {
        double answer = 0;
        double sum = 0;
        for (int i = 0; i < numbers.length ; i++){
            sum+=numbers[i];
        }
        answer = sum/numbers.length;
        return answer;
    }
}

** 👍 내생각** sum이라는 double형 변수를 만들어주고 , numbers 배열의 값을 순회 하면서 sum에 더해주는 방법을 생각해냈다. 분명 지난주에는 저 += 적용법이 많이 어려웠는데 가면 갈수록 혼자 쓸 수 있게끔 실력이 는다는 점이 매우매우 흥미롭다!

🤔배운내용

1) +=; 를 써서 sum이라는 변수에 누적값을 더해주는 방법 2) answer과 sum값을 모두 double형 인수로 만들어야 소수점 아래까지 모두 출력이 가능하다.

1차 시도

class Solution {
    public int solution(int slice, int n) {
        int answer = 0;

        if ( n % slice == 0){
            answer = n/slice;
        }else {
            answer = (n-n%slice)/slice + 1; 
        }
        return answer;
    }
}

 <br><br>

** 👍 내생각** 이것도 1번 나눠먹기랑 비슷한 방법으로 수학적으로(?) 접근하여 풀었다 !

n이 나눠 떨어지면 몫을 답으로, 나눠 떨어지지 않을 경우 n에 나머지를 빼고 다시 나눠준 후 몫에 1을 더해주었다.

🤔배운내용 1번을 풀고 풀어서인지 쉽게 풀렸다!

1차 시도

class Solution {
    public int solution(int n) {
        int answer = 0;
        for (int i = 1 ; i<=6*n ; i++){
            if ((6*i)% n == 0){
                answer = i ;
                break;
            }  
        }
        return answer;
    }
}

** 👍 내생각** 처음에는 최소공배수를 구할 생각을 했는데, 그럴려니까 약수 -> 최대공약수 -> 최소공배수를 구해야 해서 코드 매우 길어지고 직접 쓰기 어려워졌다. 다른 방법을 찾아보니, 그냥 단순하게 6 * answer이 n으로 나눠 떨어지는 배수를 구하면 되는 것이였다!! 이 문제는 내 생각에 갇혀서 별 방법을 다 써보고 시간을 생각보다 많이 쏟았다. 그래도 그 와중에 공부를 좀 한거 같아서 보람차다

🤔배운내용

1) 문제를 읽고 방법을 생각하는 것도 좋지만, 생각해낸 방법으로 코드를 짜기 어렵다면 빠르게 다른 방법을 생각해보자! 2) for문 안에 if문을 이제 안정적이게 넣을 수 있게 되었다 아자아자

1차 시도

class Solution {
    public int solution(int n) {
        int answer = 0;
        if (n % 7 == 0 ){
            answer = n/7;

        }else if (n< 7){
            answer = 1;
        }else {answer = (n-(n%7))/7 + 1;
              }
        return answer;
    }
}

** 👍 내생각**

모든 사람이 1조각 이상 먹기 위해서는 주어진 n(인원수)에 n을 7로 나눴을 때의 나머지를 우선 빼줘서 몫만 구한 후에 +1판 해주면 된다 (요게 배열을 이용해서 푼게 맞나..)

🤔배운내용

1) if문을 길게 써보았는데도 문제가 생기지 않았다! 2) 정말 천천히 아주 조금씩 실력이 늘고 있는게 살짝 실감난다!

1차 시도

class Solution {
    public int[] solution(int[] arr, int divisor) {
        int cnt = 0;
        int j = 0;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % divisor == 0) {
                cnt++;
            }
            if (cnt == 0) {
                int[] answer = {-1};
                return answer;
            }
        }

   // result 배열의 크기 구하기



        int[]answer = new int[cnt];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % divisor == 0) {
                 answer[j] = arr[i];
                j++;
            }
        }
            Arrays.sort(answer);
            return answer;
    }
}

 // 구한 크기로 for문 돌면서 arr[i]번째 값을 answer에 값에 넣기

2차 시도

import java.util.ArrayList;
import java.util.Arrays;


class Solution {
    public int[] solution(int[] arr, int divisor) {
        int answer[] = {};
        ArrayList<Integer> tmp = new ArrayList<Integer>();

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % divisor == 0) {
                tmp.add(arr[i]);
            }

        }
        if (tmp.isEmpty()){
            tmp.add(-1);
        }
        answer = new int[tmp.size()];
        for (int i = 0; i <tmp.size(); i++){
            answer[i] = tmp.get(i);
        }

        Arrays.sort(answer);

        return answer;
    }
}

** 👍 내생각** 왜 자꾸 코드 실행은 되는데 제출 후 채점하면 오류가 날까 이 문제 말고 다른 문제들도 실행은 되는데 채점은 안된다

for문을 사용해서 각 배열/ArrayList를 돌면서 divisor이랑 나눠지는지 확인하고 true면 result 배열/ArrayList에 추가할 수 있도록 하였다.

🤔배운내용 for문 쓰는게 그래도 어느정도 익숙해지고 있는거 같다 아직 다중 for문은 조금 헷갈리기는 한다

2차시도 때는 배열에 별도로 값을 추가해주는 것이 아니라 ArrayList를 활용해서 문제를 풀었다 배열은 사이즈가 정해져있기 때문에 데이터를 마음대로 추가할 수 없으나 ArrayList는 add 매서드를 활용해서 추가 가능하다. ArrayList 자체에 sort를 사용할 수 없으니, tmp(ArrayList)를 만들어 값들을 tmp에 저장해놓고, 저장된 값을 다시 answer이라는 배열에 추가하는 방식으로 구현했다.

import java.util.Arrays; import java.util.Arrays; 요거를 맨 위에 안 써줘서 한 10분동안 내 코드를 의심하는 시간을 가졌다..