develop_C

프로그래머스 : 후보키 (2019 KAKAO BLIND RECRUITMENT)

chan20 — Sun, 9 Jan 2022 17:05:12 +0900

Code

import java.util.*;
class Solution {
    Comparator<Integer> comp = new Comparator<Integer>() {
        int countBits(int n){
            int ret = 0 ;
            while(n!=0){
                if((n&1) != 0) ++ ret;
                n = n >>1;
            }
            return ret;
        }
        @Override
        public int compare(Integer o1, Integer o2) {
            int x = countBits(o1), y= countBits(o2);
            return x-y;

        }
    };
    public int solution(String[][] relation){
        int answer = 0;
        int row = relation.length;
        int cols = relation[0].length;
        List<Integer> candidates = new LinkedList<>();

        for(int i = 1 ; i < 1 << cols; ++i){
            if(check(relation, row, cols, i)){
                candidates.add(i);
            }
        }
        Collections.sort(candidates, comp);

        while(candidates.size() != 0) {
            int n = candidates.remove(0);
            ++answer;
            for(Iterator<Integer> it = candidates.iterator(); it.hasNext();){
                int c = it.next();
                if((n & c) == n)
                    it.remove();
            }
        }
        return answer;
    }
    boolean check(String[][] relation, int row, int cols, int subset){
        for( int a = 0 ; a < row-1 ; a++){
            for(int b= a + 1 ; b < row;b++){
                boolean check = true;
                for(int k = 0; k < cols; k++){
                    if((subset & 1 << k)==0) continue;
                    if(!relation[a][k].equals(relation[b][k])){
                        check = false;
                        break;
                    }
                }
                if(check) return false;
            }
        }
        return true;
    }
}

Link

https://programmers.co.kr/learn/courses/30/lessons/42890

프로그래머스 : 프린터

chan20 — Sun, 9 Jan 2022 17:05:08 +0900

Link

코딩테스트 연습 - 프린터

Code

import java.util.*;
class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0 ;
        PriorityQueue<Integer> queue = new PriorityQueue<>(Collections.reverseOrder());
        for(int i : priorities){
            queue.add(i);
        }


        int count = 0 ;
        while(!queue.isEmpty()){
            for(int i =0 ; i < priorities.length; i++){
                if(priorities[i] == queue.peek()){
                    count++;
                    queue.poll();
                    if(i == location){
                        answer =  count;
                        queue.clear();
                        break;
                    }
                }

            }
        }
        return answer;
    }
}

Explain

1. 우선순위가 높은 순으로 찾기 위해 우선순위 큐를 사용 2. 우선순위큐에서 priorities 순서대로 같은 것을 찾으면서 우선순위큐 하나씩 지운다 3. 만약 location과 priorities의 순서가 같다면 모두 종료

프로그래머스: 스킬트리

chan20 — Sun, 9 Jan 2022 17:05:03 +0900

Link

코딩테스트 연습 - 스킬트리

Code

class Solution {
   public int solution(String skill, String[] skill_trees) {
        int answer = 0;
        Skilldata[] skillPrev = new Skilldata[skill_trees.length];
        for(int i =0 ; i < skillPrev.length ; i++){
            skillPrev[i] = new Skilldata();
        }


        for(int i = 0 ; i<skill.length() ; i++){
            for(int j =0 ; j< skill_trees.length; j++){
                for(int k = 0 ; k< skill_trees[j].length();k++){
                    if(skill_trees[j].charAt(k) == skill.charAt(i)){
                        if(i == 0 ){
                            skillPrev[j].skill =  skill.charAt(i);
                            skillPrev[j].date = k;
                        }
                        else{
                             if(skill.charAt(i-1)==skillPrev[j].skill && skillPrev[j].date <k){
                                skillPrev[j].skill =  skill.charAt(i);
                                skillPrev[j].date = k;
                            }
                            else{
                                skillPrev[j].bool = true;
                            }
                        }

                    }
                }
            }
        }
        for(int i = 0 ; i< skillPrev.length; i++){
             if(!skillPrev[i].bool){
                answer++;
            }
        }
        return answer;
    }
}

class Skilldata{
    char skill;
    int date;
    boolean bool;
    
}

Explain

1. Class를 생성하여 배운 스킬을 순서대로 입력할 skill 그것의 위치 date 정상적인 스킬을 찍었는지 확인하는 bool을 Class를 생성

2. Skill_trees들은 각각 Skilldata Class로 판단해야기 때문에 Skill_trees크기만큼 선언

3. 첫 스킬은 누구나 다 배울 수 있으므로 입력하고 다음 스킬 부터 이전 스킬에 무엇을 선택했는지 파악과 이전 스킬이 이후 스킬보다 나중에 찍었는지 파악하여 거짓이라면 boolean으로 분별

4. boolean으로 참인 데이터만 count

프로그래머스 : 메뉴 리뉴얼 (2021 KAKAO BLIND RECRUITMENT)

chan20 — Sun, 9 Jan 2022 17:04:59 +0900

Link

코딩테스트 연습 - 메뉴 리뉴얼

Code

import java.util.*;
class Solution {
     public String[] solution(String[] orders, int[] course) {
        String[] answer = {};
        HashMap<String, Integer> map = new HashMap<>();

        for(int i = 0 ; i < orders.length; i++){
            HashSet<String> set = new HashSet<>();
            char[] charArr = orders[i].toCharArray();
            Arrays.sort(charArr);
            String result = new String(charArr);
            solve(set, course, result);
            for(String s : set){

                if(map.get(s)==null){
                    map.put(s,1);
                }
                else{
                    map.put(s,map.get(s)+1);
                }
            }
        }
        HashMap<Integer, String> map2 = new HashMap<>();
        HashMap<Integer, Integer> map3 = new HashMap<>();
        for(String s : map.keySet()){
               for(int i : course){

                   if(i == s.length() && map.get(s) != 1){

                       System.out.println("map: " + s +"- "+ map.get(s) + " map2: " + map2.get(i) + " map3: " + map3.get(i)  );
                       if(map2.get(i)== null){
                           map2.put(i , s);
                           map3.put(i , map.get(s));
                       }else{
                           if(map3.get(i) > map.get(s)){
                           }else if(map3.get(i) == map.get(s)){
                               map2.put(i, map2.get(i) +"-"+s);
                           }else{
                               map2.put(i , s);
                               map3.put(i , map.get(s));
                           }
                       }
                   }
               }
        }
        ArrayList<String> list = new ArrayList<>();
        for(int i : map2.keySet()){
            String[] s = map2.get(i).split("-");
            for(int j = 0 ; j < s.length ; j++){
                if(map3.get(i)!=1) {
                    list.add(s[j]);
                }
            }
        }
        answer = new String[list.size()];
        for(int i = 0 ; i < answer.length ; i ++){
            answer[i] = list.get(i);
        }

        Arrays.sort(answer);
        return answer;
    }
    public void solve(HashSet<String> set, int[] course, String data){

        if(data.length() == 1){
            return;
        }

        for(int j : course){
            if(j == data.length()){
                set.add(data);
            }
        }
        for(int i = 0 ; i <data.length(); i++){
            String data2 = data.substring(0, i) + data.substring(i+1);
            solve(set, course, data2);
        }
    }
}

Explain

윗 그림과 같이 메뉴의 조합을 DFS로 모든 경우의 수를 구하여 중복된 값이 있을 수도 있으니 HashSet에 저장함 (course에 있는 길이만)

HashSet에 있는 값을 Map에 Key : 음식 조합 Value : 몇번을 택했는지? orders에 있는 값들을 전부 정리한다.

다 끝난 후 메뉴 갯수 마다 최대 단골 메뉴를 선정해야하기 때문에 Key: 메뉴 갯수 value: 메뉴 이름과 Key: 메뉴 갯수 value: 메뉴 선택한 갯수를 선언하여 하나씩 처리해주고 만약 같은 선택한 갯수가 있을 경우 String에 ","을 붙쳐서 추가로 추가한다
끝난 후 answer에 하나씩 삽입하여 이름 순서대로 출력하기 때문에 정렬사용

프로그래머스 : 다리를 지나는 트럭

chan20 — Sun, 9 Jan 2022 17:04:55 +0900

Link

코딩테스트 연습 - 다리를 지나는 트럭

Code

import java.util.*;
class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int answer = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        Queue<Integer> queue = new LinkedList<>();
        Queue<Integer> queue2 = new LinkedList<>();
        for (int i = 0; i < truck_weights.length; i++) {
            map.put(i,0);
            queue.add(truck_weights[i]);
            queue2.add(truck_weights[i]);
        }
        int current = 0 ;
        int prev = 0 ;

        while(!queue2.isEmpty()){
            answer ++ ;
            int Q = 0 ;
            int W = 0 ;
            if(queue.isEmpty()){

            }

            else if(weight- queue.peek() >= 0 ){
                if(W!=1) {
                    current++;
                    weight = weight - queue.poll();
                    Q++;
                }else{
                    W=0;
                }
            }
            for(int i =prev ; i <current; i++){
                if(map.get(i) < bridge_length){
                    map.put(i, map.get(i)+1);
                }
                else if(map.get(i) == bridge_length){
                    map.put(i, map.get(i)+1);
                    weight = weight + queue2.poll();
                    prev ++;
                    if(queue.isEmpty()){

                    }
                    else if(weight- queue.peek() >= 0 ){
                        if(Q!=1) {
                            current++;
                            weight = weight - queue.poll();
                            W++;
                        }{
                            Q=0;
                        }
                    }
                }
            }
        }
        return answer;
    }
}

Explain

1. 트럭이 지났는지 안지났는지 확인하기위해 안지나간 트럭 Queue, 지나간 트럭 Queue 생성하고 다리에 있을때는 map에 넣는다.

2. map에 들어왔을 때는 안지나간 트럭에서 무게만큼 더함

3. map에서는 다리에서 1씩 증가하고 길이가 되었을 시 map에 나갈때는 무게만큼 뺌

4. answer은 행동이 시작할 때 부터 1씩 증가

투포인터 (Two-Pointer)

chan20 — Sun, 9 Jan 2022 16:55:05 +0900

리스트에 순차적으로 접근해야 할 때 두 개의 점의 위치를 기록하면서 처리하는 알고리즘

Two Pointers 알고리즘의 시간복잡도는 O(n)

start, end라는 두 개의 포인터를 사용합니다.

start는 부분배열의 앞 쪽을 가르키는 인덱스, end는 부분배열의 뒤 쪽을 가르키는 인덱스입니다.

맨 처음에 두 포인터는 0에서 시작하며 항상 start<=end를 만족해야합니다.

그리고 매 순간마다 부분합 배열의 합과 구해야하는 값을 비교하여 포인터를 이동하게 됩니다.

부분합 배열의 합 < 구해야하는 값end를 오른쪽으로 한 칸 이동하여 부분합 배열의 크기를 증가시킵니다.

부분합 배열의 합 >= 구해야하는 값start를 오른쪽으로 한 칸 이동하여 부분합 배열의 크기를 감소시킵니다.

문자열 총 정리

chan20 — Sun, 9 Jan 2022 16:55:01 +0900

문자찾기

indexOf

indexOf() 는 특정 문자나 문자열이 앞에서부터 처음 발견되는 인덱스를 반환하며

만약 찾지 못했을 경우 "-1"을 반환합니다.

indexOf(String str)

indexOf(char ch)

indexOf(char ch, int fromIndex)

indexOf(String str, int fromIndex)

역순으로 할 때는 lastIndexOf()로 똑같이 하면된다.

매개변수에 str 값을 넣어주면 해당 문자의 위치를 알려준다.

두번 째 매개변수 fromIndex에 넣으면 해당 위치부터 str을 찾아준다.

contains

문자열을 검색할 때 효율 적이며 만약 문자열이 있을 경우 true 없을경우 false를 출력

ex)

String value = "abcdef"
System.out.println(value.contains("abc")) // true
System.out.println(value.contains("abcf")) // false

matches

정규식을 이용하여 문자열을 찾아 주는 메서드 영문자 표현식이 대상 문자열에 포함되어 있는지 아닌지에 따라서 true false를 출력

대소문자 변환

내장 라이브러리를 이용 할 때

toUpperCase( ) : 문자열을 모두 대문자로 변환해준다.

toLowerCase( ) : 문자열을 모두 소문자로 변환해준다.

내장 라이브러리를 이용 하지 않을 때

문자열을 문자 하나하나 마다 아스키코드 차이 값 32 를 빼주거나 더해줘서

조건에 따라 소문자, 대문자 변환이 가능하다.

대소문자 무시하고 비교

equalsIgnoreCase를 이용하면 대소문자 상관없이 비교한다.

단어 뒤집기

public static void main(String[] args) 
{ 
		String str = "abcde"; // reverse 
		StringBuffer sb = new StringBuffer(str); 
		String reversedStr = sb.reverse().toString(); 
		System.out.println(reversedStr); // edcba 
}

주로 StringBuffer를 이용하여 reverse로 뒤집어준다.

public class String_Reverse_Practice 
{
 public static void main(String[] args) 
	{ 
		String str = "abcde"; 
		char[] arr = str.toCharArray(); // String -> char[] 
		char[] reversedArr = new char[arr.length]; 
		for(int i=0; i<arr.length; i++){ 
			reversedArr[arr.length-1-i] = arr[i]; 
		} 
		String reversedStr = new String(reversedArr); 
		System.out.println(reversedStr); // edcba 
	} 
}

순수하게 char 로 변경하여 역순으로 변경시켜주는 방법이다.

마지막 방법은 List<Character>를 사용하여 reverse 메서드를 이용한다.

해당 방법보다는 StringBuilder 방법이 효율적인 것같다.

동적 계획법(Dynamic Programming)

chan20 — Sun, 9 Jan 2022 16:54:57 +0900

큰 문제를 작은 문제로 나누어서 푸는 방식

처음 주어진 문제를 더 작은 문제들로 나눈 뒤 각 조각의 답을 계산

답들로 부터 원래 문제에 대한 답을 계산해 낸다는 점에서 분할 정복(Divide & Conquer, D&C)과 비슷
- 가장 큰 차이점은 동적 계획법에서는 쪼개진 작은 문제가 중복되지만, 분할 정복은 절대로 중복될수가 없다는 점이다

조건

두 가지 속성을 만족해야 동적 계획법으로 문제를 풀 수 있다.

Overlapping Subproblem : 겹치는 부분(작은) 문제

Optimal Substructure : 최적 부분구조

겹치는 부분 문제

어떤 문제가 여러개의 부분문제(subproblem)으로 쪼개질 수 있을때 사용하는 용어이다. 이때 '부분 문제'란, 항상 새로운 부분 문제를 생성해내기 보다는 계속해서 같은 부분 문제가 여러번 재사용되거나 재귀 알고리즘을 통해 해결되는 문제를 가리킨다.

최적 부분구조

어떤 문제의 최적의 해결책이 그 부분 문제의 최적의 해결책으로 부터 설계될 수 있는 경우를 말한다. 즉, 최적 부분구조 일때 문제의 정답을 작은 문제의 정답에서 부터 구할 수 있다. 이 속성은 동적 계획법이나 그리디 알고리즘의 유용성을 판별하는데 사용되기도 한다.

메모이제이션(Memoization)

동적 계획법에서 각 문제는 한 번만 풀어야 한다. 중복되는 부분 문제를 여러번 풀지 않는다는 뜻이다. Optimal Substructure를 만족하기 때문에 같은 문제는 구할 때마다 정답이 같다. 따라서 정답을 한 번 구했으면 그 정답을 캐시에 메모해놓는다. 이렇게 메모하는 것을 코드의 구현에서는 배열에 저장하는 것으로 할 수 있다. 이를 메모이제이션(Memoization)이라고 한다.

구현 방식

동적 계획법의 구현 방식에는 두 가지 방법이 있다.

Top-down : 큰 문제를 작은 문제로 쪼개면서 푼다. 재귀로 구현

Bottom-up : 작은 문제부터 차례대로 푼다. 반복문으로 구현

Top-down

큰 문제를 작은 문제로 나눈다.

작은 문제를 푼다.

작은 문제를 풀었으니, 이제 큰 문제를 푼다.

Buttom-up

문제를 크기가 작은 문제부터 차례대로 푼다.

문제의 크기를 조금씩 크게 만들면서 문제를 점점 푼다.

작은 문제를 풀면서 왔기 때문에, 큰 문제는 항상 풀 수 있다.

반복하다 보면 가장 큰 문제를 풀 수 있다.

greedy (탐욕)

chan20 — Sun, 9 Jan 2022 16:54:46 +0900

"가장 맨 앞에 보이는 최적의 상황을 쫓는 알고리즘"

"근사치 추정"

단순한 형태의 알고리즘

여러 경우 중 하나를 결정해야 할 때마다 그 순간에 최적이라고 생각되는 것을 선택해 나가는 방식

적용 가능한 곳

크루스칼 알고리즘
- 그래프의 모든 간선 중에 가중치가 가장 작은 것 부터 차례대로 선택 (사이클이 만들어지면 안됨)

프림 알고리즘
- 임의의 정점에서 가중치가 가장 작은 간선을 선택 (가중치가 작은 것들을 선택, Cycle X)

데이크스트라 알고리즘
- 가중치가 있는 방향그래프에서 임의의 두 노드 사이의 최단거리를 구하는 알고리즘

이외 거스름돈 나눠주기, 일 스케줄링 등 있다.

ref

chan20 — Sun, 9 Jan 2022 16:19:18 +0900

특정 DOM에 작업을 해야 할 때 ref를 사용하는 것인데 DOM을 꼭 직접적으로 건드려야 할 때 쓰인다. 마치 HTML의 id라고 보면 된다.

ref를 사용하려면 Hooks를 사용해야한다.

DOM을 꼭 사용해야 하는 상황 : 필요한 기능을 state를 통해서 개발 했지만 해결 할 수 없는 기능들이 있다 이럴 때 접근 해야 하는 것들 1. 특정 input에 포커스 주기 2. 스크롤 박스 조작하기 3. Canvas 요소에 그림 그리기

ref사용

콜백 함수를 통한 ref 설정

<input ref={(ref) => {this.input=ref}} />

이렇게하면 ref의 이름은 원하는 것으로 자유롭게 지정할 수 있다.

createRef를 통한 ref 설정

import React, { Component } from 'react';   class RefSample extends Component {   input = React.createRef(); 	handleFocus = () => {     this.input.current.focus();   }    render() {     return (       <div>         <input ref={this.input} />       </div>     );   } }

16.3 버전 부터 사용 할 수 있으며 createRef를 사용하여 ref를 만들려면 우선 컴포넌트 내부에 멤버 변수로 React.createRef()를 담아 줘야 하며 ref를 달고자 하는 요소에 ref props를 넣어주면 ref 설정이 된다.

컴포넌트 ref

<MyComponent     ref={(ref) => {this.myComponent=ref}} />

이런 식으로 작성을 하면 내부의 메서드 및 멤버 변수에도 접근할 수 있습니다. 즉, 내부의 ref에도 접근할 수 있습니다

컴포넌트 만들기

컴포넌트에 ref 달기

ref를 이용하여 컴포넌트 내부 메서드 호출

Uploaded by Notion2Tistory v1.1.0