1. 시간

테스트 1 〉	통과 (0.29ms, 88.9MB)
테스트 2 〉	통과 (0.92ms, 76.1MB)
테스트 3 〉	통과 (0.32ms, 72.6MB)
테스트 4 〉	통과 (3.35ms, 78.8MB)
테스트 5 〉	통과 (0.24ms, 85.9MB)
테스트 6 〉	통과 (0.26ms, 78.8MB)
테스트 7 〉	통과 (0.93ms, 80.9MB)
테스트 8 〉	통과 (0.30ms, 82.3MB)
테스트 9 〉	통과 (0.79ms, 85.7MB)
테스트 10 〉	통과 (1.31ms, 74.6MB)
테스트 11 〉	통과 (1.44ms, 76.6MB)
테스트 12 〉	통과 (0.22ms, 85MB)
테스트 13 〉	통과 (0.66ms, 79.8MB)

2. 풀이

합집합, 교집합을 구하면 되는 문제인데, 처음엔 Set을 이용할까 했다.

but,

A = {1, 1, 2, 2, 3}, 다중집합 B = {1, 2, 2, 4, 5}라고 하면, 교집합 A ∩ B = {1, 2, 2}, 합집합 A ∪ B = {1, 1, 2, 2, 3, 4, 5}

이렇게 해야 한다. 그래서 Map을 이용했다.

A의 다중 집합, B의 다중 집합을 Map<String, Integer>에 저장했다.

• key: 두글자
• value: 개수

1. 합집합 구하기

합집합 Map<String, Integer> temp;

A의 다중 집합에 있는 특정 String의 개수랑 B의 다중 집합에 있는 특정 String 개수의 최대치를 저장하면 된다.

temp[”find”]=Math.max(A[”find”],B[”find”])

1. 교집합 구하기

교집합의 경우는 반대로, 최소치를 저장하면 된다.

temp[”find”]=Math.min(A[”find”],B[”find”])

3. 코드

⭕ 정답

import java.util.*;

class Solution {
    
    HashMap<String, Integer> A, B, hap, cross;
    
    public int solution(String str1, String str2) {
        A=new HashMap<>();
        B=new HashMap<>();
        hap=new HashMap<>();
        cross=new HashMap<>();
        
        A=count(str1);
        B=count(str2);
        
        int cro=getCross();
        int h=getHap();
        
        if(cro==h) return 65536;
        
        long value=cro*65536;
        int answer = (int) (value/h);
        
        return answer;
    }
    
    public int getCross(){
        HashMap<String, Integer> temp=new HashMap<>();
        
        for(Map.Entry<String, Integer> entry : A.entrySet()){
            String s=entry.getKey();
            int cnt=entry.getValue();
            
            temp.put(s, Math.min(A.get(s), B.getOrDefault(s,0)));
        }
        
        int ans=0;
        for(Map.Entry<String, Integer> entry : temp.entrySet()){
            ans+=entry.getValue();
        }
        
        return ans;
    }
    
    public int getHap(){
        HashMap<String, Integer> temp=new HashMap<>();
        
        for(Map.Entry<String, Integer> entry : A.entrySet()){
            String s=entry.getKey();
            int cnt=entry.getValue();
            
            temp.put(s, Math.max(A.get(s), temp.getOrDefault(s,0)));
        }
        
        for(Map.Entry<String, Integer> entry : B.entrySet()){
            String s=entry.getKey();
            int cnt=entry.getValue();
            
            temp.put(s, Math.max(B.get(s), temp.getOrDefault(s,0)));
        }
        
        int ans=0;
        for(Map.Entry<String, Integer> entry : temp.entrySet()){
            ans+=entry.getValue();
        }
        
        System.out.println(ans);
        
        return ans;
    }
    
    public HashMap<String, Integer> count(String str){
        int sz=str.length();
        HashMap<String, Integer> t=new HashMap<>();
        
        for(int i=0;i<sz-1;i++){
            StringBuilder s=new StringBuilder();
            for(int j=0;j<2;j++){
                char c=str.charAt(i+j);
                if(c>='A'&&c<='Z'||c>='a'&&c<='z'){
                    s.append(c);
                }
                else break;
            }
            
            if(s.length()==2){
                String temp=new String(s).toLowerCase();
                t.put(temp, t.getOrDefault(temp,0)+1);
            }
        }
        
        return t;
    }
    
}

링크

https://school.programmers.co.kr/learn/courses/30/lessons/64065

1. 시간

테스트 1 〉	통과 (0.73ms, 82MB)
테스트 2 〉	통과 (0.63ms, 77.6MB)
테스트 3 〉	통과 (0.65ms, 96.5MB)
테스트 4 〉	통과 (1.14ms, 84.6MB)
테스트 5 〉	통과 (2.64ms, 78.7MB)
테스트 6 〉	통과 (3.85ms, 82.3MB)
테스트 7 〉	통과 (31.52ms, 76.7MB)
테스트 8 〉	통과 (49.23ms, 90.2MB)
테스트 9 〉	통과 (51.67ms, 101MB)
테스트 10 〉	통과 (62.25ms, 87.4MB)
테스트 11 〉	통과 (68.06ms, 94.6MB)
테스트 12 〉	통과 (97.66ms, 100MB)
테스트 13 〉	통과 (101.94ms, 126MB)
테스트 14 〉	통과 (94.41ms, 117MB)
테스트 15 〉	통과 (0.61ms, 75.5MB)

2. 풀이

카카오 문제는 입력부터가 쉽지 않다. 일단 입력 부분에서 한번 꼬는 건 기본인 것 같다.

입력 예시: "{{2},{2,1},{2,1,3},{2,1,3,4}}”

일단 고려할 사항

1. 로직
2. 입력

로직

로직은 쉬웠다. 각 괄호 안의 숫자들의 개수에 따라 정렬하고, 순차적으로 탐색한다.

없는 원소일 경우 그 원소의 다음 번호를 부여하면 되는 방식이다.

예를 들어, 입력이 이렇게 있을 경우

튜플이 (3,2,4,1)이다.

그 이유는,

이기 때문에, {3}이 있으므로 3이 튜플의 가장 첫번째 원소여야 한다. 그 다음 {2,3}에서 3은 이미 첫번째 원소이기 때문에 2는 2번째 원소가 된다. 즉, 집합의 길이별 오름차순 정렬을 먼저 해주고, 각 집합의 원소 중 번호가 부여 안된 원소가 있다면 번호를 부여하면 된다. (번호가 몇번째 원소인지)

이건 HashMap으로 처리해줬다.

입력

솔직히 입력 어떻게 해야하는지 생각한게 더 오래 걸렸다.

split으로 하려고 했는데, 집합 안에도 ,가 있어서 제대로 안나올 것 같았다.

그래서 스택으로 괄호 문제 했던 것처럼,

입력을 순차 탐색해서

1. {가 나올 경우, 집합의 원소를 담을 ArrayList 생성
2. }가 나올 경우, ArrayList를 저장
3. ,가 나올 경우, 앞의 문자를 숫자로 변환해 ArrayList에 저장
4. 숫자가 나올 경우, StringBuilder에 추가

3. 코드

⭕ 정답

import java.util.*;

class Solution {
    
    ArrayList<ArrayList<Integer>> infos;
    ArrayList<Integer> arr;
    HashMap<Integer, Integer> chk;
    
    public int[] solution(String s) {
        init(s);
        return proc();
    }
    
    public void init(String s){
        infos=new ArrayList<>();
        chk=new HashMap<>();
        
        StringBuilder num=new StringBuilder();
        for(int i=1;i<s.length()-1;i++){
            if(s.charAt(i)=='{'){
                arr=new ArrayList<>();
            }
            else if(s.charAt(i)==','){
                if(num.length()>0){
                    arr.add(Integer.parseInt(num.toString()));
                    num=new StringBuilder();
                }
                
            }
            else if(s.charAt(i)=='}'){
                arr.add(Integer.parseInt(num.toString()));
                num=new StringBuilder();
                infos.add(arr);
            }
            else{
                num.append(s.charAt(i));
            }
        }
        
    }
    
    public int[] proc(){
        infos.sort((a,b)->Integer.compare(a.size(),b.size()));
        int idx=0;
        
        for(ArrayList<Integer> temp: infos){
            for(int num: temp){
                //System.out.print(num+" ");
                if(!chk.containsKey(num)){
                    chk.put(num,idx++);
                }
            }
            System.out.println();
        }
        
        int[] ans=new int[chk.size()];
        
        for(Map.Entry<Integer, Integer> info: chk.entrySet()){
            ans[info.getValue()]=info.getKey();
        }
        
        return ans;
    }
}

2019 KAKAO BLIND RECRUITMENT 후보키 문제를 풀어보겠다.

1. 문제

이런 테이블(2차원 배열)이 주어질 때, 후보키가 될 수 있는 개수를 구하는 문제다.

2. 링크

프로그래머스 2019 KAKAO BLIND - 후보키 문제 링크

3. 풀이

문제에서 유일성, 최소성 2가지 조건을 만족해야 한다.

최소 뽑을 수 있는 것부터 유일성을 검사한 후, 유일성 통과가 안될 시에 뽑는 개수를 한 개씩 늘려가면서 유일성을 만족하는 걸 찾는다.

1. 유일성 만족 확인
   • 각 컬럼의 문자를 공백을 사이에 두고 하나의 문자열로 통합 (공백을 둔 이유는 혹시나 서로 다른 컬럼인데 이어졌을 때, 같아질 때를 방지하기 위한 것, ex) abs, sbs / ab, ssbs => abssbs 로 같아지게 된다.
   • 이 문자들의 유일성 검사를 hashSet을 이용함.
   • 행에 속하는 문자들 통합이 hashSet에 있을 경우, 유일성을 만족 못함, 만족할 경우 hashSet에 넣음
2. 최소성 만족 확인(정답 코드의 경우)
   • bit 마스킹을 이용해 만족하는지 확인
   • (뽑은 컬럼 값의 bit 마스크 & 정답 후보에 있는 bit 마스크) = 정답 후보에 있는 bit 마스크 일 경우, 최소성 만족을 못함

여기서 (3, 2) 이런 식으로 (2, 3)의 순서만 바뀐 조합은 안 나오게 한다.

1) 오답

처음 코드에서는 42.9점으로 오답이 나왔었다. 이유는 다음과 같은 반례 때문이다.

반례
[["1", "2", "3"], ["2", "3", "1"], ["2", "3", "3"]]
정답: 2 => (0,2), (1,2)
return 3 => (0,1,2), (0,2), (1,2)

최소성을 보장 못한다.
이 코드의 경우 dfs 방식으로 뽑은 개수별로 순차적으로 확인하지를 않는다.
예를 들어, 컬럼 (1,3)의 조합이 유일성을 만족한다고 했을 때, 탐색을 다음과 같이 하게 된다.

(1) → (1,2) → (1,2,3) ⇒ 유일성 만족, 정답 개수++

    → (1,3) → 유일성 만족, 정답 개수++

이때 (1,2,3)은 (1,3)이 이미 후보키이기 때문에 최소성을 만족하지 못한다.
⇒ 개수를 순차적으로 뽑는 bfs 방법을 사용해야 한다.

• 코드

import java.util.*;
class Solution {

    int ans=0, row, col;
    String[][] rel;

    public int solution(String[][] relation) {
        rel=relation;
        row=relation.length;
        col=relation[0].length;

        proc(0,new ArrayList<>());

        return ans;
    }

    //유일성을 못 맞출 경우, 컬럼 조합을 늘려간다.
    public void proc(int cnt, ArrayList<Integer> combi){
        // if(cnt>=col) return;

        int start=combi.isEmpty()?0:combi.get(combi.size()-1)+1;

        for(int j=start;j<col;j++){
            boolean chk=true;
            HashSet<String> hs=new HashSet<>();

            for(int i=0;i<row;i++){
                StringBuilder sb=new StringBuilder();
                for(int k=0;k<cnt;k++){
                    sb.append(rel[i][combi.get(k)]+" ");
                }

                sb.append(rel[i][j]);

                String result=new String(sb);

                if(hs.contains(result)){
                    chk=false;

                    ArrayList<Integer> temp=new ArrayList(combi);
                    temp.add(j);
                    proc(cnt+1, temp);

                    break;
                }

                hs.add(result);
            }

            if(chk){
                ans++;
            }

        }  
    }


}

2) 정답

bfs 방식으로 바꾸고, 비트마스킹 사용
유일성을 만족했을 시, 비트마스킹을 통해 부분 집합이 이미 유일성을 만족하지 않는지 확인한다.

예를 들어, 아까와 같은 예시로 컬럼 (1,3)의 조합이 유일성을 만족한다고 했을 때를 생각해본다.
지금 같은 bfs 방식일 경우, 다음과 같이 검사를 한다.

⭕: 유일성 만족, ❌: 유일성 불만족
1 ❌→ 2 ❌ → 3 ❌ → (1, 2) ❌ → (1, 3) ⭕ → (1, 4) ❌→ (2, 3) ❌ → (1, 2, 3) ⭕

유일성을 만족하는 조합은 (1, 3), (1, 2, 3), 이렇게 2가지다.

여기서 (1, 2, 3)은 이미 (1, 3)이 후보키이기 때문에 최소성이 만족하지 못한다. 따라서 부분 집합이 이미 후보키일 경우, 걸러줘야 한다.

비트마스킹으로 보면,

(1, 2, 3) ⇒ 0111
(1, 3) ⇒ 0101
& ⇒ 0101 == 0101

따라서 & 연산을 했을 때, 후보키랑 같은 게 나오면 최소성을 불만족하게 된다.

만약, (1, 4), (1, 2, 3) 이 후보키인게 있다고 하자. 그러면

(1, 2, 3) ⇒ 0111
(1, 4) ⇒ 1001
& ⇒ 0001 ≠ 1001

(1, 4)는 (1, 2, 3)의 부분 집합이 아닌걸로 정확하게 나온다.

• 코드

class Solution {
    int row, col;
    String[][] rel;

    public int solution(String[][] relation) {
        rel=relation;
        row=relation.length;
        col=relation[0].length;

        int ans=proc();

        return ans;
    }

    //유일성을 못 맞출 경우, 컬럼 조합을 늘려간다.
    public int proc(){
        ArrayDeque<int[]> q=new ArrayDeque<>(); // 비트마스킹, 맨 뒤 idx
        q.add(new int[]{0,-1});
        ArrayList<Integer> ans=new ArrayList<>();

        while(!q.isEmpty()){
            int[] info=q.poll();
            int start=info[1]+1;

            for(int j=start;j<col;j++){
                boolean chk=true;
                HashSet<String> hs=new HashSet<>();
                int bit=info[0]|1<<j;

                for(int i=0;i<row;i++){

                    StringBuilder sb=new StringBuilder();

                    for(int k=0;k<8;k++){
                        if((info[0]&1<<k)!=0){
                            sb.append(rel[i][k]+" ");
                        }
                    }

                    sb.append(rel[i][j]);
                    String result=new String(sb);

                    if(hs.contains(result)){
                        chk=false;

                        q.add(new int[]{bit, j});

                        break;
                    }

                    hs.add(result);
                }

                if(chk){
                    boolean isHubo=true;

                    for(int hubo : ans){
                        if((hubo&bit)==hubo){
                            isHubo=false;
                            break;
                        }
                    }

                    if(isHubo) {
                        ans.add(bit);
                    }
                }

            }  
        }

        return ans.size();

    }

}

• 실행 시간

테스트 1 〉	통과 (2.70ms, 87.5MB)
테스트 2 〉	통과 (2.44ms, 86.2MB)
테스트 3 〉	통과 (2.19ms, 85.8MB)
테스트 4 〉	통과 (2.88ms, 91.1MB)
테스트 5 〉	통과 (2.62ms, 75.3MB)
테스트 6 〉	통과 (0.44ms, 82MB)
테스트 7 〉	통과 (0.40ms, 67.9MB)
테스트 8 〉	통과 (2.71ms, 75.9MB)
테스트 9 〉	통과 (4.11ms, 84.7MB)
테스트 10 〉	통과 (0.59ms, 87.5MB)
테스트 11 〉	통과 (3.46ms, 86.6MB)
테스트 12 〉	통과 (3.63ms, 75.8MB)
테스트 13 〉	통과 (3.78ms, 72.3MB)
테스트 14 〉	통과 (4.25ms, 83.8MB)
테스트 15 〉	통과 (2.14ms, 87.4MB)
테스트 16 〉	통과 (2.51ms, 74.8MB)
테스트 17 〉	통과 (3.15ms, 75.8MB)
테스트 18 〉	통과 (4.32ms, 77.7MB)
테스트 19 〉	통과 (3.38ms, 90.8MB)
테스트 20 〉	통과 (4.50ms, 75.6MB)
테스트 21 〉	통과 (4.58ms, 90.5MB)
테스트 22 〉	통과 (4.84ms, 93.6MB)
테스트 23 〉	통과 (2.25ms, 84.1MB)
테스트 24 〉	통과 (3.79ms, 85MB)
테스트 25 〉	통과 (4.65ms, 73.1MB)
테스트 26 〉	통과 (4.68ms, 87.5MB)
테스트 27 〉	통과 (2.99ms, 90.9MB)
테스트 28 〉	통과 (4.26ms, 84.9MB)

4. 시간 개선(문자열 체이닝)

StringBuilder 같은 클래스에서 append() 메서드를 연달아 이어서 호출하는 방식

1) 기존 코드 (임시 문자열 생성)

sb.append(rel[i][k] + " ");

rel[i][k] + " " 때문에, rel[i][k]와 " "을 합친 새로운 String 객체가 매번 만들어지고, 그다음에야 append()가 호출된다.
즉, 매번 불필요한 중간 문자열 객체가 생겨 성능 저하로 이어진다.

2) 문자열 체이닝 방식

sb.append(rel[i][k]).append(' ');

여기서는 먼저 rel[i][k]를 붙이고, 곧바로 ' '(공백 문자)를 붙인다.
그러면, 중간에 임시 String 객체가 전혀 안 생기고, StringBuilder 내부 버퍼에 바로 기록된다.

import java.util.*;
class Solution {
    int row, col;
    String[][] rel;

    public int solution(String[][] relation) {
        rel=relation;
        row=relation.length;
        col=relation[0].length;

        int ans=proc();

        return ans;
    }

    //유일성을 못 맞출 경우, 컬럼 조합을 늘려간다.
    public int proc(){
        ArrayDeque<int[]> q=new ArrayDeque<>(); // 비트마스킹, 맨 뒤 idx
        q.add(new int[]{0,-1});
        ArrayList<Integer> ans=new ArrayList<>();

        while(!q.isEmpty()){
            int[] info=q.poll();
            int start=info[1]+1;

            for(int j=start;j<col;j++){
                boolean chk=true;
                HashSet<String> hs=new HashSet<>();
                int bit=info[0]|1<<j;

                for(int i=0;i<row;i++){

                    StringBuilder sb=new StringBuilder();

                    for(int k=0;k<8;k++){
                        if((info[0]&1<<k)!=0){
                            sb.append(rel[i][k]).append(" "); // 체이닝 사용
                        }
                    }

                    sb.append(rel[i][j]);
                    String result=new String(sb);

                    if(hs.contains(result)){
                        chk=false;

                        q.add(new int[]{bit, j});

                        break;
                    }

                    hs.add(result);
                }

                if(chk){
                    boolean isHubo=true;

                    for(int hubo : ans){
                        if((hubo&bit)==hubo){
                            isHubo=false;
                            break;
                        }
                    }

                    if(isHubo) {
                        ans.add(bit);
                    }
                }

            }  
        }

        return ans.size();

    }

}

• 실행 시간

테스트 1 〉	통과 (0.13ms, 75.3MB)
테스트 2 〉	통과 (0.14ms, 85MB)
테스트 3 〉	통과 (0.15ms, 72.9MB)
테스트 4 〉	통과 (0.16ms, 84.7MB)
테스트 5 〉	통과 (0.16ms, 73.9MB)
테스트 6 〉	통과 (0.10ms, 74.5MB)
테스트 7 〉	통과 (0.09ms, 80.8MB)
테스트 8 〉	통과 (0.10ms, 89.7MB)
테스트 9 〉	통과 (0.17ms, 79.6MB)
테스트 10 〉	통과 (0.15ms, 88.9MB)
테스트 11 〉	통과 (0.29ms, 78MB)
테스트 12 〉	통과 (0.75ms, 79.6MB)
테스트 13 〉	통과 (0.46ms, 85.9MB)
테스트 14 〉	통과 (0.15ms, 90MB)
테스트 15 〉	통과 (0.10ms, 84.8MB)
테스트 16 〉	통과 (0.17ms, 76.4MB)
테스트 17 〉	통과 (0.18ms, 76.5MB)
테스트 18 〉	통과 (1.51ms, 87.9MB)
테스트 19 〉	통과 (1.37ms, 74.8MB)
테스트 20 〉	통과 (1.35ms, 70.5MB)
테스트 21 〉	통과 (2.55ms, 85.3MB)
테스트 22 〉	통과 (1.64ms, 85.7MB)
테스트 23 〉	통과 (0.15ms, 82MB)
테스트 24 〉	통과 (0.61ms, 91.7MB)
테스트 25 〉	통과 (1.98ms, 80.9MB)
테스트 26 〉	통과 (1.53ms, 83.2MB)
테스트 27 〉	통과 (0.80ms, 90.2MB)
테스트 28 〉	통과 (0.71ms, 78.5MB)

5. 참고

비트마스킹을 안쓰고 했을 때 코드도 남겨놓겠다.
비트마스킹 대신 *10, +를 사용했다.
예를 들어, 뽑는 컬럼이 1, 2, 3이면 123이 된다.

• 코드

import java.util.*;

class Solution {  
int row, col;  
String[][] rel;

public int solution(String[][] relation) {
    rel=relation;
    row=relation.length;
    col=relation[0].length;

    int ans=proc();

    return ans;
}

//유일성을 못 맞출 경우, 컬럼 조합을 늘려간다.
public int proc(){
    ArrayDeque<int[]> q=new ArrayDeque<>(); // 뽑은 조합, 맨 뒤 idx
    q.add(new int[]{0,-1});
    ArrayList<Integer> ans=new ArrayList<>();

    while(!q.isEmpty()){
        int[] info=q.poll();
        int start=info[1]+1;

        for(int j=start;j<col;j++){
            boolean chk=true;
            HashSet<String> hs=new HashSet<>();
            int bit=info[0]*10+(j+1);

            for(int i=0;i<row;i++){

                StringBuilder sb=new StringBuilder();
                int num=info[0];

                while(num>0){
                    int idx=num%10;
                    num/=10;
                    sb.append(rel[i][idx-1]+" ");
                }

                sb.append(rel[i][j]);
                String result=new String(sb);

                if(hs.contains(result)){
                    chk=false;

                    q.add(new int[]{bit, j});

                    break;
                }

                hs.add(result);
            }

            if(chk){
                boolean isHubo=true;

                for(int hubo : ans){
                    int num=hubo;
                    boolean isSub=true;

                    // 부분 집합이 이미 있는지 확인
                    while(num>0){
                        int ele=num%10;
                        num/=10;
                        boolean isExist=false;

                        int num2=bit;
                        while(num2>0){
                            int ele2=num2%10;
                            num2/=10;

                            if(ele==ele2){
                                isExist=true;
                                break;
                            }
                        }

                        if(!isExist){
                            isSub=false;
                            break;
                        }
                    }


                    if(isSub){
                        isHubo=false;
                        break;
                    }
                }

                if(isHubo) {
                    ans.add(bit);
                }
            }

        }  
    }

    return ans.size();

  }

}

• 실행 시간
  비트마스킹 썼을 때와 차이가 나지 않는다.

테스트 1 〉 통과 (1.99ms, 91.7MB)
테스트 2 〉 통과 (1.96ms, 72.7MB)
테스트 3 〉 통과 (2.10ms, 79.4MB)
테스트 4 〉 통과 (1.80ms, 93.7MB)
테스트 5 〉 통과 (2.08ms, 84.5MB)
테스트 6 〉 통과 (0.11ms, 82.4MB)
테스트 7 〉 통과 (0.09ms, 69.4MB)
테스트 8 〉 통과 (1.98ms, 76.1MB)
테스트 9 〉 통과 (2.25ms, 77.7MB)
테스트 10 〉 통과 (0.13ms, 82.8MB)
테스트 11 〉 통과 (2.23ms, 86.4MB)
테스트 12 〉 통과 (4.12ms, 87MB)
테스트 13 〉 통과 (2.70ms, 97.4MB)
테스트 14 〉 통과 (1.84ms, 77.1MB)
테스트 15 〉 통과 (1.79ms, 85.3MB)
테스트 16 〉 통과 (2.98ms, 84.3MB)
테스트 17 〉 통과 (2.07ms, 85.4MB)
테스트 18 〉 통과 (3.43ms, 89MB)
테스트 19 〉 통과 (3.08ms, 75.3MB)
테스트 20 〉 통과 (3.53ms, 82.9MB)
테스트 21 〉 통과 (4.11ms, 87.8MB)
테스트 22 〉 통과 (4.46ms, 92MB)
테스트 23 〉 통과 (1.93ms, 83.6MB)
테스트 24 〉 통과 (4.33ms, 83.5MB)
테스트 25 〉 통과 (5.04ms, 79.7MB)
테스트 26 〉 통과 (3.50ms, 86.9MB)
테스트 27 〉 통과 (2.63ms, 72.9MB)
테스트 28 〉 통과 (3.20ms, 85.6MB)

​

#include <stdio.h>

int main(){ 
	//int: 32비트(4바이트), 정수를 담는 데 쓰임 
    int a=5; 
    int b=3; 
    
    int hap=a+b; 
    int cha=a-b; 
    int gop=a*b; 
    int mok=a/b;//정수/정수=정수 
    int namuji=a%b; 
    
    printf("%d+%d=%d\n",a,b,hap); 
    printf("%d-%d=%d\n",a,b,cha); 
    printf("%d*%d=%d\n",a,b,gop); 
    printf("%d/%d=%d\n",a,b,mok); 
    printf("%d %% %d=%d\n",a,b,namuji);//%하나만 쓰면 잘 출력이 안돼서 2개 씀. 
    }

int main(){ 
	//float: 32비트(4바이트), 실수를 담는 데 쓰임 
    float a = 9.8; 
    float b = 3.14; 
    
    float hap = a + b; 
    float cha = a - b; 
    float gop = a * b; 
    float mok = a / b; 
    
    printf("%f+%f=%f\n", a, b, hap); 
    printf("%f-%f=%f\n", a, b, cha); 
    printf("%f*%f=%f\n", a, b, gop); 
    printf("%f/%f=%f\n", a, b, mok); 
    }

실수를 저장하기 위해 float를 사용하면 공간을 많이 필요로 하기 때문에 오차가 발생한다.

->double을 사용함.

int main(){ 
	//double: 64비트(8바이트), 실수를 담는 데 쓰임 
    double a = 9.8; 
    double b = 3.14; 
    
    double hap = a + b; 
    double cha = a - b; 
    double gop = a * b; 
    double mok = a / b; 
    
    printf("%f+%f=%f\n", a, b, hap); 
    printf("%f-%f=%f\n", a, b, cha); 
    printf("%f*%f=%f\n", a, b, gop); 
    printf("%f/%f=%f\n", a, b, mok); 
    //부동소수점(floating point) 
 }

부동소수점: 소수점이 움직임(막 떠다닐 수 있음)

double은 float의 비트가 2배여서 double

​

☆2진법, 자료형 총정리

​

10진법

12345=10000+2000+300+30+3

=1*10^4+2*10^3....

​

2진법-0,1로만 구성

100110(2)=1*2^5 + 1*2^2 + 1*2^1 = 38

​

int - 32비트 = 4바이트

0(부호 저장 양수: 0, 음수: 1)0000000 00000000 00000000 00000000

1111111 11111111 11111111 11111111 = -1

5=101(2)

37=100101(2)

​

8비트=1바이트

바이트: 컴퓨터에서 데이터를 처리하는 가장 작은 단위

​

자료형 - 정수형, 실수형

​

정수형

char (1바이트, 8비트) - 문자를 담는 데 쓰임

short (2바이트)

long (4바이트) -2147483648(-2^31) ~ +2147483648(2^31)

long long (8바이트)

int (시스템에 따라서 자동결정, 대체로 long)

​

실수형

float (4바이트)

double (8바이트)

​

unsigned(부호 무시), signed

unsigned int a; 0 ~ 2147483648*2-1

​

void: 리턴값이 없는 함수의 자료형

​

bool: 참, 거짓을 저장하는 자료형 (=char)

​

실습 링크

https://repl.it/@hobby0519/Learn-C-1

​

출처: https://www.inflearn.com/course/c%EC%96%B8%EC%96%B4-%EB%91%90%EB%93%A4%EB%82%99%EC%84%9C/lecture/2773

글자 출력, printf로 다양한 데이터 출력하기, 변수에 대한 내용입니다.

#include <stdio.h> 

int main(){ 
	printf("Hello world!\n"); 
   }

함수: 어떤 명령어를 수행

-괄호가 있으면 함수라고 봄

-값을 집어 넣으면 새로운 값이 나옴

printf(): 괄호 안의 값을 똑같이 출력, 문자열이면 ""붙여주어야 함

\n: enter키

;(세미콜론): 문장의 마침표 같은 역할★꼭 붙여야 함!! 잊지 말기!!

int main(){
	//주석입니다 

	//%d:정수 출력(1,2,3,4,5,6,...,0,-1,-2) 
	printf("%d+%d=%d\n",2,3,5); 

	//%f: 실수 출력(3.14, -2.0,...)
	printf("%f\n",3.14); 
	printf("%.2f\n",3.141592); //소수점 둘째자리까지만 출력(반올림함) 

	//%g: 실수 출력(지수 형태로도 출력)(유효숫자를 따짐, 명시안하면 6개까지) 
	printf("%g\n", 3.141592); 
	printf("%.3g\n", 8723984712.12345678);//8.72e+09인데 여기서 e+09는 10의 9승이라는 뜻 

	//%c: 문자 출력(''표시)(알파벳, 숫자, 몇몇 기호, \n)-한글, 한자, 유니코드x )
	printf("%c %c %c\n", 97,'b','c');//a b c a는 97이라는 숫자를 가지고 있음 

	//%s: 문자열 출력(""표시)(문자들이 열거)-한글o 
	printf("%s","안녕\n"); 
}

위에 헤더 파일 있으니까 따로 쓰진 않을게요.

//: 주석

%d:정수 출력(1,2,3,4,5,6,...,0,-1,-2)

%f: 실수 출력(3.14, -2.0,...)

%g: 실수 출력(지수 형태로도 출력)(유효숫자를 따짐, 명시안하면 6개까지)

%c: 문자 출력(''표시)(알파벳, 숫자, 몇몇 기호, \n)-한글, 한자, 유니코드x

%s: 문자열 출력(""표시)(문자들이 열거)-한글o

​

int main(){ 
	int a=2; 
    int b=3; 
    printf("%d+%d=%d\n",a,b,a+b); 
	//변수 이름: 알파벳 대소문자,_, 숫자(첫번째 글자로는 쓸 수 x)) 
}

​

​

​

​

실습 링크:

https://repl.it/@hobby0519/Learn-C

​

출처: https://www.inflearn.com/course/c%EC%96%B8%EC%96%B4-%EB%91%90%EB%93%A4%EB%82%99%EC%84%9C/lecture/2769

C 와 C++ 을 동시에 배워보자 - 두들낙서의 C/C++ | 02 – Hello, World! 해석하기 - 인프런

c언어 입문

www.inflearn.com

​