LeeJinSol

문제

타로는 자주 JOI잡화점에서 물건을 산다. JOI잡화점에는 잔돈으로 500엔, 100엔, 50엔, 10엔, 5엔, 1엔이 충분히 있고, 언제나 거스름돈 개수가 가장 적게 잔돈을 준다. 타로가 JOI잡화점에서 물건을 사고 카운터에서 1000엔 지폐를 한장 냈을 때, 받을 잔돈에 포함된 잔돈의 개수를 구하는 프로그램을 작성하시오.

예를 들어 입력된 예1의 경우에는 아래 그림에서 처럼 4개를 출력해야 한다.

입력

입력은 한줄로 이루어져있고, 타로가 지불할 돈(1 이상 1000미만의 정수) 1개가 쓰여져있다.

출력

제출할 출력 파일은 1행으로만 되어 있다. 잔돈에 포함된 매수를 출력하시오.

예제 입력 1

380

예제 출력 1

4

생각)

문제는 제목을보자마자 대충 어떠한 문제인지 느낌이왔고

어떻게 풀어야할지 대충 감이잡히는 쉬운문제....하지만 if문으로 하나하나 노가다코딩을 했지만 시간초과

scanner대신 버퍼를 사용했고 if문 여러개를 for문과 if문한개로 loop한바퀴로 끝낼수있도록 코드를짬

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
	public static void main(String[] args) throws IOException
	{
		
		
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			int cost = Integer.parseInt(br.readLine());
			int[] coin = {500, 100, 50, 10, 5, 1};
			cost = 1000-cost;  
			int num =0;
			
			for(int i=0; i<6; i++){
				if(cost/coin[i]>0){
					num =num + cost/coin[i]; //동전개수
					cost = cost%coin[i]; //
				}
			}
			System.out.println(num);
	}
}

1931.

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

예제 입력 

11

1 4

3 5

0 6

5 7

3 8

5 9

6 10

8 11

8 12

2 13

12 14

예제 출력 

4

해결방법)

우선 핵심해결방법은 시작시간에 집중하는게 아니라 회의 종료시간에 우선적으로 집중해야된다

즉 배열 한쌍 arr[0][0](0번쨰 회의시작시간) arr[0][1](0번째 회의종료시간)에서  배열 한쌍을 회의 종료시간오름차순으로 정렬시킨후. 종료시간이 같은 회의는 시작시간을 오름차순으로 회의를 정렬한다.

1 2

3 2

3 4

1 5

1 7

2 8

6 8

9 10 이런식으로 정렬이 되었다고 치자

1,2 > 3,2는(앞 종료시간이 뒤 시작시간보다 크므로 count x ) > 3,4 (count ) > 1,5 count x > 1,7 count x > 2,8 count x > 6,8 count > 9,10 count

if문으로 시작시간 종료시간 최소 최대값을 잘 설정하여 카운팅해주면 될거같다.

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int temp = 0;
		int demp=0;
		int [][]arr = new int[N][2];
      		
        for (int i = 0; i < N; i++)
        {
            arr[i][0] = sc.nextInt(); //i번쨰 회의시작시간
            arr[i][1] = sc.nextInt(); //i번쨰 회의종료시간
        }
        /* 정렬전
        for(int i=0; i<N; i++) {
        	System.out.printf("arr[%d][%d] : %d   ",i,0,arr[i][0]);
        	System.out.printf("arr[%d][%d] : %d\n",i,1,arr[i][1]);
        }
        */
        
        for(int i=0; i<N; i++) 
        {
        	for(int j=0; j<N-i-1; j++)
        	{
        		if(arr[i][1] > arr[i+1][1])
        		{
        			temp = arr[i][1];
        			arr[i][1] = arr[i+1][1];
        			arr[i+1][1] = temp;
        			
        			demp = arr[i][0];
        			arr[i][0] = arr[i+1][0];
        			arr[i+1][0] = demp;		
        		}  		
        	}       	        	
        }
        /*
        System.out.println("------- 정렬후-----------");
        for(int i=0; i<N; i++) {
        	System.out.printf("arr[%d][%d] : %d ",i,0,arr[i][0]);
        	System.out.printf(" arr[%d][%d] : %d \n",i,1,arr[i][1]);
        }
*/
        
        int count = 0;    // 최대값 변수 
        int end = -1;    // 다음시작 시간과 비교할 변수
        for (int i = 0; i < N; i++) {
            //현재 시작시간이 이전 종료시간보다 늦을 경우 
            if (arr[i][0] >= end) {
                //System.out.println(arr[i][0] + " " + arr[i][1]);
                end = arr[i][1];    //현재 종료시간을 다음 시작시간과 비교하기위해 저장 
                count++;
            }
        }
        System.out.println(count);
	
	
	
}

}

 첫번째 코드는 출력결과값은 맞지만 시간초과가 나서 제출이안된다...

package tutorial1;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int temp = 0;
		int demp=0;
		int [][]arr = new int[N][2];
      		
        for (int i = 0; i < N; i++)
        {
            arr[i][0] = sc.nextInt(); //i번쨰 회의시작시간
            arr[i][1] = sc.nextInt(); //i번쨰 회의종료시간
        }
        
        for(int i=0; i<N; i++) {
        	System.out.printf("arr[%d][%d] : %d   ",i,0,arr[i][0]);
        	System.out.printf("arr[%d][%d] : %d\n",i,1,arr[i][1]);
        }
        
        
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] start, int[] end) {
                //start[0], end[0] 배열은 arr[][] 의 첫번째 라인(시작시간)이다.
                //start[1], end[0] 배열은 arr[][] 의 두번째 라인(종료시간)이다.
                if(start[1]==end[1]){
                    //만약 비교하는 값의 종료시간이 같을 경우 시작시간으로 정렬한다.
                    return Integer.compare(start[0], end[0]);
                }
                //종료시간에 따라 정렬한다.
                return Integer.compare(start[1], end[1]);
            }
 
        });
        /*
        System.out.println("------- 정렬후-----------");
        for(int i=0; i<N; i++) {
        	System.out.printf("arr[%d][%d] : %d ",i,0,arr[i][0]);
        	System.out.printf(" arr[%d][%d] : %d \n",i,1,arr[i][1]);
        }
*/
        
        int count = 0;    // 최대값 변수 
        int end = -1;    // 다음시작 시간과 비교할 변수
        for (int i = 0; i < N; i++) {
            //현재 시작시간이 이전 종료시간보다 늦을 경우 
            if (arr[i][0] >= end) {
                //System.out.println(arr[i][0] + " " + arr[i][1]);
                end = arr[i][1];    //현재 종료시간을 다음 시작시간과 비교하기위해 저장 
                count++;
            }
        }
        System.out.println(count);
	
	
	
}

}

1095

package com.algo.controller;

import java.util.Scanner;

public class Code{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
    
        System.out.print("무작위로 부른 번호 : ");
        String num = sc.nextLine();
            
        String [] arr = num.split(" ");
        
        int [] narr = new int[arr.length];
        
        //String 배열 int배열로 형변환 하기
        for(int i=0; i<arr.length; i++) {
            narr[i] = Integer.parseInt(arr[i]);
        }
        
        //변수에 10을 넣는다
        int min = narr[0];
        
        //narr 배열중에서 10보다 작은수가 있으면  min에 넣는다
        for(int i=0; i<arr.length; i++) {
            if(narr[i]<min) {
                min = narr[i];
            }
        }
        
        System.out.println(min);
        
    }  
}

1096

import java.util.Scanner;

public class Code{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
    
        int arr[][]= new int[20][20];
        int x,y;
        
        System.out.print("흰돌의 개수 : ");
        int n = sc.nextInt();
        
        for(int i=0; i<n; i++) {
            System.out.print("돌 놓을 좌표 : ");
            x = sc.nextInt();
            y = sc.nextInt();
            //한칸씩 땡겨서 입력되있으므로 -1을 해준다
            arr[x-1][y-1] = 1;  
    }  
        for(int i=0; i<arr.length-1; i++) { //행
            for(int j=0; j<arr.length-1; j++) { //열
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }   
    }   
}  

1097

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

public class Code{
    public static void main(String[] args) throws IOException{
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        try {
        String[][] arr = new String[19][19];
        
        //바둑알이 깔려있는 상황 19*19를 입력받는다
        for(int i=0; i<arr.length; i++) {
            //String 배열에 " "을 기준으로 하나씩 잘라서 모두 담는다
            String[] ar1 = br.readLine().split(" ");
            for(int j=0; j<arr.length; j++) {
                //[행][열] 잘라진 숫자들을 열인 [j]기준으로 모두 담는다
                arr[i][j] = ar1[j];
            }
        }
        
        //십자 뒤깁기 횟수(n)을 입력받는다 
        int n = Integer.parseInt(br.readLine());  
        
        ArrayList<String> list = new ArrayList();
        
        //십자 뒤깁지 좌표가 횟수(n)만큼 입력된다
        for (int i = 0; i < n; i++) {
            list.add(br.readLine());
            //list에 [10 10, 12 12] 저장
        }
        System.out.println(list);
        
        for (int i = 0; i < list.size(); i++) {
            
            //String 배열에 " "을 기준으로 좌표를 잘라서 저장한다
            String[] point = list.get(i).split(" ");
            
            int x = Integer.parseInt(point[0]);
            int y = Integer.parseInt(point[1]);
            
            for (int j = 0; j < 19; j++) {
                if(arr[x-1][j] == "0"){ //x가 0이면
                    arr[x-1][j] = 1 + ""; //1을 넣어준다
                }else{
                    arr[x-1][j] = 0 + ""; //아니면 0을 넣어준다
                }
            }
            for (int j = 0; j < 19; j++) {
                if(arr[j][y-1] == "0"){ //y가 0이면
                    arr[j][y-1] = 1 + ""; //1을 넣어준다
                }else{
                    arr[j][y-1] = 0 + ""; //아니면 0을 넣어준다
                }
            }
        }
        
        //전체 출력 for문
        for (int i = 0; i <arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        
        
        }catch(NumberFormatException e) {
            e.printStackTrace();
        }
    }

1098

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

public class Code{
    public static void main(String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        try {
            //가로 세로 길이를 입력받는다
            String[] hw = br.readLine().split(" ");
            //height=5 / width=5
            int height = Integer.parseInt(hw[0]);
            int width = Integer.parseInt(hw[1]);
            
            //입력값의 정의역
            if (height > 0 && height <= 100 &&
                    width > 0 && width <= 100) {
                
                //[5][5] 크기의 배열을 만든다
                String[][] arr = new String[height][width];
                
                //막대의 개수를 입력받는다.
                int n = Integer.parseInt(br.readLine());
                
                if (n >= 1 && n <=10) {
                    
                    for (int i = 0; i < n; i++) {
                        //막대의 정보를 String배열에 입력받는다
                        //막대의길이 (length) 방향(d) 0이면 가로로 1이면 세로로
                        //좌표 (x) (y)
                        String[] stick = br.readLine().split(" ");
                        
                        int length = Integer.parseInt(stick[0]);
                        int d = Integer.parseInt(stick[1]);
                        int x = Integer.parseInt(stick[2])-1;
                        int y = Integer.parseInt(stick[3])-1;
                        
                        //2 0 1 1로 예를 들면
                        if (d == 0) { //막대 방향이 가로일때
                            for (int j = y; j < y + length; j++) {
                                //int j=0; j<2; j++
                                if (j < width) {
                                    //[0][0] 과 [0][1]에 1을 넣어준다
                                    arr[x][j] = "1";
                                }                               
                            }
                        //3 1 2 3으로 예를 들면
                        }else{ //막대 방향이 세로일때
                            for (int j = x; j < x + length; j++) {
                                //int j=1; j<4; j++
                                if (j < height) {
                                    //[1][2],[2][2],[3][2]에 1을 넣어준다
                                    arr[j][y] = "1";
                                }                               
                            }
                        }
                    }
                    
                    //전체 출력 for문
                    for (int i = 0; i < arr.length; i++) {
                        for (int j = 0; j < arr[i].length; j++) {
                            if (arr[i][j] == null) {//위에 해당되는 값이 없어서 null이면
                                arr[i][j] = "0"; //0을 넣어준다
                            }
                            System.out.print(arr[i][j] + " ");
                        }
                        System.out.println();
                    }
                }else{
                    System.out.println("1 >= stick num <= 10");
                }
            }else{
                System.out.println("1 >= width & height <= 100");
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
    }

1099

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

public class Code{
    public static void main(String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        try {
            String[][]arr = new String[10][10];
            //10*10크기의 미로 상자 구조와 먹이 위치를 입력받는다
            for(int i=0; i<arr.length; i++) {
                //String 배열에 입력받는 값을 모두 잘라서 넣는다
                String[] y = br.readLine().split(" ");
                
                 //[행][열] 잘라진 숫자들을 열인 [j]기준으로 모두 담는다
                for(int j=0; j<y.length; j++) {
                    arr[i][j] = y[j];
                }
            }
            
            int flag = 1; //벽
            int end = 0; //갈수있는곳
            
            for(int i=1; i<arr.length; i++) {
                if(end !=1) { //벽이 아니면
                    
                    for(int j=flag; j<arr[i].length; j++) {
                        if(arr[i][j].equals("0")) {
                            arr[i][j] = "9";
                            
                        }else if(arr[i][j].equals("2")) { //먹이발견하면
                            arr[i][j] = "9";
                            end = 1; 
                            break; //더이상 움직이지 않고 머무른다
                        }else { 
                            flag = j-1;
                            break;
                        }
                    }
                }else {
                    break;
                }
            }
        
            //전체 출력 for문
            for(int i=0; i<arr.length; i++) {
                for(int j=0; j<arr.length; j++) {
                    System.out.print(arr[i][j]+" ");
                }
                System.out.println();
            }
        
        }catch(NumberFormatException e) {
            e.printStackTrace();
        }
            
    }
}   

1090

어떤 규칙에 따라 수를 순서대로 나열한 것을 수열이라고 한다.

예를 들어
2 6 18 54 162 486 ... 은
2부터 시작해 이전에 만든 수에 3을 곱해 다음 수를 만든 수열이다.

이러한 것을 수학에서는 앞뒤 수들의 비율이 같다고 하여
등비(비율이 같다의 한문 말) 수열이라고 한다.


등비 수열을 알게된 영일이는 갑자기 궁금해졌다.

"그럼.... 13번째 나오는 수는 뭘까?"

영일이는 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.


시작 값(a), 등비(r), 몇 번째인지를 나타내는 정수(n)가 입력될 때
n번째 수를 출력하는 프로그램을 만들어보자.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        long r = sc.nextLong();
        long n = sc.nextLong();
    
        //2 3 4  2> 6> 18> 54
        
        System.out.printf("%.0f",a*Math.pow(r,n-1));  
    }

}

1091

어떤 규칙에 따라 수를 순서대로 나열한 것을 수열이라고 한다.

예를 들어
1 -1 3 -5 11 -21 43 ... 은
1부터 시작해 이전에 만든 수에 -2를 곱한 다음 1을 더해 다음 수를 만든 수열이다.

이런 이상한 수열을 알게 된 영일이는 또 궁금해졌다.

"그럼.... 13번째 나오는 수는 뭘까?"

영일이는 물론 수학을 아주 잘하지만 이런 문제는 본 적이 거의 없었다...

그래서 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.


시작 값(a), 곱할 값(m), 더할 값(d), 몇 번째인지를 나타내는 정수(n)가 입력될 때,
n번째 수를 출력하는 프로그램을 만들어보자.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        long m = sc.nextLong();
        long d = sc.nextLong();
        long n = sc.nextLong();
        for(int i=1; i<n; i++) {
            a = (a*m)+d;
        }
        System.out.println(a);
        //시작값  곱할값 더할값 n번째 
    }

}

1092

온라인 채점시스템에는 초등학생, 중고등학생, 대학생, 대학원생,
일반인, 군인, 프로그래머, 탑코더 등 아주 많은 사람들이 들어와 문제를 풀고 있는데,

실시간 채점 정보는 메뉴의 채점기록(Judge Status)을 통해 살펴볼 수 있다.

자! 여기서...잠깐..
같은 날 동시에 가입한 3명의 사람들이 온라인 채점시스템에 들어와 문제를 푸는 날짜가
매우 규칙적이라고 할 때, 다시 모두 함께 문제를 풀게 되는 그날은 언제일까?

예를 들어 3명이 같은 날 가입/등업하고, 각각 3일마다, 7일마다, 9일마다
한 번씩 들어온다면, 처음 가입하고 63일 만에 다시 3명이 함께 문제를 풀게 된다.


갑자기 힌트?

왠지 어려워 보이지 않는가?

수학에서 배운 최소공배수를 생각한 사람들도 있을 것이다. 하지만, 정보에서 배우고 경험하는
정보과학의 세상은 때때로 컴퓨터의 힘을 빌려 간단한 방법으로 해결할 수 있게 한다.

아래의 코드를 읽고 이해한 후 도전해 보자.

day는 날 수, a/b/c는 방문 주기이다.
...
day=1;
while(day%a!=0 || day%b!=0 || day%c!=0) day++; //이게 무슨 의미일까?

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
       
        int day = 1;
        
        //a,b,c의 최소 공배수 찾기
        //a,b,c가 모두 만족하는 day가 되었을 때 반복문 종료하기
        while(day%a!=0 || day%b!=0 || day%c!=0) {
            day++;
        }
        System.out.print(day);
    }

}

1093

import java.util.Scanner;

public class Code{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
            
    
        System.out.print("무작위로 부른 번호 : ");
        String num = sc.nextLine();
        
        //10개의 무작위로 부른 번호가 들어간 배열 1 3 2 2 5 6 7 4 5 9
        String [] arr = num.split(" ");
                
        int total[] = new int[23];
        for(int i=0; i<arr.length; i++) {
            //arr[0]번에는 1번이 1번불려서 1이 저장된다.
            //arr[1]번에는 2번이 2번불려서 2가 저장된다.
            //...arr[9] 한칸씩 밀려서 저장되기때문에 -1을 해준다.
            total[Integer.parseInt(arr[i])-1] +=1;
        }
        
        for(int i=0; i<total.length; i++) {
            System.out.print(total[i]+" ");
        }
    }   
}  

1094

package com.algo.controller;

import java.util.Scanner;

public class Code{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
    
        System.out.print("무작위로 부른 번호 : ");
        String num = sc.nextLine();
        
        //10개의 무작위로 부른 번호가 들어간 배열 
        String [] arr = num.split(" ");
                    
        for(int i=arr.length-1; i>=0; i--) {
            System.out.print(arr[i]+" ");
        }
    }  
}  

d-12

1085

소리가 컴퓨터에 저장될 때에는 디지털 데이터화 되어 저장된다.

마이크를 통해 1초에 적게는 수십 번, 많게는 수만 번 소리의 강약을 체크해
그 값을 정수값으로 바꾸고, 그 값을 저장해 소리를 파일로 저장할 수 있다.

값을 저장할 때에는 비트를 사용하는 정도에 따라 세세한 녹음 정도를 결정할 수 있고,
좌우(스테레오) 채널로 저장하면 2배… 5.1채널이면 6배의 저장공간이 필요하고,
녹음 시간이 길면 그 만큼 더 많은 저장공간이 필요하다.

1초 동안 마이크로 소리강약을 체크하는 수를 h
(헤르쯔, Hz 는 1초에 몇 번? 체크하는가를 의미한다.)

한 번 체크한 결과를 저장하는 비트 b
(2비트를 사용하면 0 또는 1 두 가지, 16비트를 사용하면 65536가지..)

좌우 등 소리를 저장할 트랙 개수인 채널 c
(모노는 1개, 스테레오는 2개의 트랙으로 저장함을 의미한다.)

녹음할 시간 s가 주어질 때,

필요한 저장 용량을 계산하는 프로그램을 작성해보자.

실제로 일반적인 CD 음질(44.1KHz, 16bit, 스테레오)로 1초 동안 저장하려면
44100 * 16 * 2 * 1 bit의 저장공간이 필요하다.

이렇게 녹음하는 방식을 PCM(Pulse Code Modulation) 방법이라고 하는데,
압축하지 않은 순수한(raw) 소리 데이터 파일은 대표적으로 *.wav 가 있다.

**
      8 bit(비트)           = 1byte(바이트)     //       8bit=1Byte
1024 Byte(210 byte) = 1KB(킬로 바이트) // 1024bit=1KB
1024 KB(210 KB)      = 1MB(메가 바이트)
1024 MB(210 MB)     = 1GB(기가 바이트)
1024 GB(210 GB)      = 1TB(테라 바이트)

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
        
        long h = sc.nextLong();
        long b = sc.nextLong();
        long c = sc.nextLong();
        long s = sc.nextLong();
        double total = 0;
        
           total = h*b*c*s;
        
      

        double result = ((total/8)/Math.pow(2, 10)/Math.pow(2, 10));
        System.out.format("%.1f MB",result);
	}

}

1086

이미지가 컴퓨터에 저장될 때에도 디지털 데이터화 되어 저장된다.

가장 기본적인 방법으로는 그림을 구성하는 한 점(pixel, 픽셀)의 색상을
빨강(r), 초록(g), 파랑(b)의 3가지의 빛의 세기 값으로 따로 변환하여 저장하는 것인데,

예를 들어 r, g, b 각 색에 대해서 8비트(0~255, 256가지 가능)씩을 사용한다고 하면,

한 점의 색상은 3가지 r, g, b의 8비트+8비트+8비트로 총 24비트로 표현해서
총 2^24 가지의 서로 다른 빛의 색깔을 사용할 수 있는 것이다.

그렇게 저장하는 점을 모아 하나의 큰 이미지를 저장할 수 있게 되는데,
1024 * 768 사이즈에 각 점에 대해 24비트로 저장하면 그 이미지를 저장하기 위한
저장 용량을 계산할 수 있다.

이렇게 이미지의 원래(raw) 데이터를 압축하지 않고 그대로 저장하는 대표적인 이미지 파일이
*.bmp 파일이며, 비트로 그림을 구성한다고 하여 비트맵 방식 또는 래스터 방식이라고 한다.

이미지의 가로 해상도 w, 세로 해상도 h, 한 픽셀을 저장하기 위한 비트 b 가 주어질 때,
압축하지 않고 저장하기 위해 필요한 저장 용량을 계산하는 프로그램을 작성해 보자.


예를 들어
일반적인 1024 * 768 사이즈(해상도)의 각점에 대해
24비트(rgb 각각 8비트씩 3개)로 저장하려면 1024 * 768 * 24 bit의 저장 용량이 필요하다.

실제 그런지 확인하고 싶다면, 간단한 그림 편집/수정 프로그램을 통해 확인할 수 있다.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
        
        long r = sc.nextLong();
        long g = sc.nextLong();
        long b  = sc.nextLong();

        
        double f = (double)r*g*b/8/1024/1024;
        
        System.out.printf("%.2f MB",f);
	}

}

1087

1, 2, 3 ... 을 순서대로 계속 더해나갈 때,
그 합이 입력한 정수보다 작을 동안만 계속 더하는 프로그램을 작성해보자.

즉, 1부터 n까지 정수를 계속 더한다고 할 때,
어디까지 더해야 입력한 수보다 같거나 커지는지 알아보고자 하는 문제이다.

하지만, 이번에는 그 때의 합을 출력해야 한다.

예를 들어 57을 입력하면
1+2+3+...+8+9+10=55에 다시 11을 더해 66이 될 때,
그 값 66이 출력되어야 한다.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        long sum=0;
        for(int i =1; i<10000000; i++) {
        	
        	sum = sum+i;
        	
        	if(sum>= a) {
        		System.out.println(sum);
        		break;
        	}
        }
    
	}

}

1088

1부터 입력한 정수까지 1씩 증가시켜 출력하는 프로그램을 작성하되,
3의 배수인 경우는 출력하지 않도록 만들어보자.

예를 들면,
1 2 4 5 7 8 10 11 13 14 ...
와 같이 출력하는 것이다.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        
        for(int i =1; i<=a; i++) {
        	if(i%3==0)continue;
        	System.out.printf("%d ",i);
        }
	}

}

1089

떤 규칙에 따라 수를 순서대로 나열한 것을 수열(series)이라고 한다.

예를 들어
1 4 7 10 13 16 19 22 25 ... 은
1부터 시작해 이전에 만든 수에 3을 더해 다음 수를 만든 수열이다.
이러한 것을 수학에서는 앞뒤 수들의 차이가 같다고 하여

등차(차이가 같다의 한문 말) 수열이라고 한다.
수열을 알게 된 영일이는 갑자기 궁금해졌다.

"그럼.... 123번째 나오는 수는 뭘까?"

영일이는 프로그램을 만들어 더 큰 수도 자동으로 계산하고 싶어졌다.

시작 값(a), 등차(d), 몇 번째인지를 나타내는 정수(n)가 입력될 때
n번째 수를 출력하는 프로그램을 만들어보자.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        long d = sc.nextLong();
        long n = sc.nextLong();
        
     
       System.out.print(a+ d*(n-1));
	}

}

scpc d13   84번문제 시간초과가뜬다...

1080

1, 2, 3 ... 을 계속 더해 나갈 때,
그 합이 입력한 정수(0 ~ 1000)보다 같거나 작을 때까지
계속 더하는 프로그램을 작성해보자.

즉, 1부터 n까지 정수를 계속 더한다고 할 때,
어디까지 더해야 입력한 수보다 같거나 커지는지 알아보고자 하는 문제이다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		int  n = sc.nextInt();
		int sum =0;
		int i=0;
		for(i =0; i<100000000; i++) {
			sum = sum+i;
			
			if(sum>=n)break;
		}
		System.out.println(i);
	}
}

1081

1부터 n까지, 1부터 m까지 숫자가 적힌
서로 다른 주사위 2개를 던졌을 때 나올 수 있는 모든 경우를 출력해보자.

참고
중첩의 원리...
반복 실행 구조도 조건 실행 구조와 마찬가지로 중첩의 원리가 적용된다.
반복 실행 구조를 중첩하면 원하는 반복 구조를 다양하게 만들어 낼 수 있다.

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        for(int i=1; i<=a; i++) 
        {
            for(int n=1; n<=b; n++) 
            {
                System.out.println(i+" "+n);
            }
        }
               
    }
}

1082

16진수(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F)를 배운
영일(01)이는 16진수끼리 곱하는 16진수 구구단?에 대해서 궁금해졌다.

A, B, C, D, E, F 중 하나가 입력될 때,
1부터 F까지 곱한 16진수 구구단의 내용을 출력해보자.
(단, A ~ F 까지만 입력된다.)

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		String  a = sc.nextLine();
		
		int num = Integer.parseInt(a,16);
		
		 for(int i=1; i<16; i++) {
                
                System.out.format("%X*%X=%X%n",num,i,num*i);
            }
	}
}

1083

3 6 9 게임을 하던 영일이는 3 6 9 게임에서 잦은 실수로 계속해서 벌칙을 받게 되었다.
3 6 9 게임의 왕이 되기 위한 마스터 프로그램을 작성해 보자.

참고
중첩의 원리
반복 실행 구조 안에 선택 실행 구조를 자유롭게 중첩할 수 있다.

예시
int i;
for(i=1; i<=100; i++) //1부터 100까지 반복
{
  if(i%3==0 || i%5==0) printf("%d ", i); //3또는 5의 배수인 경우 그 수 출력
}

** 3 6 9 게임은?
여러 사람이 순서를 정해 순서대로 수를 부르는 게임이다.
만약 3, 6, 9 가 들어간 수를 자신이 불러야 하는 상황이면, 대신 "박수" 를 쳐야 한다.
33까지 진행했다면? "짝짝"과 같이 박수를 두 번 치는 형태도 있다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		int  a = sc.nextInt();
		
		for(int i=1; i<=a; i++) {
			if(i%3 ==0) {
				System.out.print("X ");
			}else{
				System.out.print(i+" ");
			}
		}
	}
}

1084

빨강(red), 초록(green), 파랑(blue) 빛을 섞어
여러 가지 빛의 색을 만들어 내려고 한다.

빨강(r), 초록(g), 파랑(b) 각각의 빛의 개수가 주어질 때,
(빛의 강약에 따라 0 ~ n-1 까지 n가지의 빛 색깔을 만들 수 있다.)

주어진 rgb 빛들을 다르게 섞어 만들 수 있는 모든 경우의 조합(r g b)과
총 가짓 수를 계산해보자.

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
			Scanner sc =new Scanner(System.in);
		
		   int r = sc.nextInt();
	       int g = sc.nextInt();
	       int b = sc.nextInt();
	       
	       int count = 0;
	       
	       for(int i=0; i<r; i++) {
	    	   for(int j=0; j<g; j++) {
	    		   for(int q =0; q<b; q++) {
	    			   System.out.printf("%d %d %d\n",i,j,q);
	    			   count++;
	    		   }
	    	   }
	       }
	       
	       System.out.println(count);
	}

}

scpc d13

1075

정수(1 ~ 100) 1개가 입력되었을 때 카운트다운을 출력해보자

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		int n = sc.nextInt();
		for(int i=n-1; i>=0; i--) {
			System.out.println(i);
		}
		
	}
}

1076

영문자(a ~ z) 1개가 입력되었을 때 그 문자까지의 알파벳을 순서대로 출력해보자.

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    
    Scanner sc = new Scanner(System.in);

    char s  = sc.nextLine().charAt(0);

    for(int i=97; i<=(int)s; i++ ){
      System.out.print((char)i+" ");
    }
  }
}

1077

정수(0 ~ 100) 1개를 입력받아 0부터 그 수까지 순서대로 출력해보자.

for((반복전 실행/준비 내용); (조건 검사 내용); (한번 실행한 후 처리할 작업))
{ //코드블록
  ...
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		int n = sc.nextInt();
		
		for(int i=0; i<=n; i++){
		    System.out.println(i);
		}
		
		
		
	}
}

1078

정수(1 ~ 100) 1개를 입력받아 1부터 그 수까지 짝수의 합을 구해보자.

import java.util.Scanner;
//sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf8')

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
    	
    	int n = sc.nextInt();
    	int sum =0;
    	for(int i=0; i<=n; i++){
    	    
    	    if(i%2 ==0){
    	        sum = sum+i;
    	    }
    	    
    	}
		System.out.println(sum);
		
		
	}
}

1079

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
        
        
       while(true) 
       {
           char a = sc.next().charAt(0);
           
             if(a=='q') 
                {
                   System.out.println(a);break;
                }
           
           System.out.println(a);
		
        }   
    }
}

scpc  d-13

1070

월이 입력될 때 계절 이름이 출력되도록 해보자.

예
월 : 계절 이름
12, 1, 2 : winter
  3, 4, 5 : spring
  6, 7, 8 : summer
  9, 10, 11 : fall

참고
swtich( ).. case ... break; 제어문에서
break;를 제거하면 멈추지 않고 다음 명령이 실행되는 특성을 이용할 수 있다.

switch(a)
{
  ...
  case 3:
  case 4:
  case 5:
    printf("spring");
  break;
  ...
}
로 작성하면, 3, 4, 5가 입력되었을 때 모두 "spring"이 출력된다.

** 12, 1, 2 는 어떻게 처리해야 할지 여러 가지로 생각해 보아야 한다.

1071

정수가 순서대로 입력된다.
-2147483648 ~ +2147483647, 단 개수는 알 수 없다.

0이 아니면 입력된 정수를 출력하고, 0이 입력되면 출력을 중단해보자.
while( ), for( ), do~while( ) 등의 반복문을 사용할 수 없다.


참고
goto 명령문을 사용하면 간단한 반복 실행을 만들 수 있다.
반복 실행 부분을 빠져나오기 위해(즉 무한 반복을 방지하기 위해)
반복 실행 되는 도중에 조건을 검사해야 한다.

goto 이름:
이 명령은 이름: 이 작성된 곳으로 프로그램의 실행 흐름을 바꾸어 준다.

"이름:" 과 같이 콜론(:)이 붙어있는 부분을 이름표(label, 레이블)라고 한다.
레이블은 특별한 선언 없이 사용할 수 있으며 언더바(_)나 영문자로 시작하면 된다.
레이블은 한 단어처럼 공백없이 모두 붙여 써야 한다.

switch( ) ... case ... : ... break; 에서
case ... : 도 일종의 레이블이라고 생각할 수 있다.

goto 레이블:
명령을 사용하면 반복되는 부분을 여러 개 자유롭게 만들 수 있다.

goto 명령은 반복 실행을 만들어낼 수 있는 가장 간단한 명령이지만,
복잡하게(스파게티 코드) 사용하는 경우, 이해가 어렵고 오류가 생기기 쉽다.


예시
  int n;
reload: //레이블은 콜론(:)으로 끝내고, 일반적으로 들여쓰기를 하지 않는다.
  scanf("%d", &n);
  printf("%d", n);
  if(n!=0) goto reload; //reload라고 적혀있는 레이블로 실행 이동

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int arr;
		int count=0;
		while(true) {
				
			
			arr = sc.nextInt();
			
			if(arr ==0)break;
			
			System.out.println(arr);
			}
		}
	   //0입력될떄까지 무한입력
	}

1072

n개의 정수가 순서대로 입력된다.
-2147483648 ~ +2147483647, 단 n의 최대 개수는 알 수 없다.

n개의 입력된 정수를 순서대로 출력해보자.

while( ), for( ), do~while( ) 등의 반복문을 사용할 수 없다.


예시
  int n, m;
  scanf("%d", &n);
reget: //레이블은 콜론( : ) 으로 끝난다.
  scanf("%d", &m);
  printf("%d\n", m);
  if(n-- != 0) goto reget; //reget:으로 이동, n의 값 1만큼 감소

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		int size = sc.nextInt();
		
		for(int i=0; i<size; i++) {
			int a  = sc.nextInt();
			System.out.println(a);
			}
	}
}

1073

정수가 순서대로 입력된다.
-2147483648 ~ +2147483647, 단 개수는 알 수 없다.

0이 아니면 입력된 정수를 출력하고, 0이 입력되면 출력을 중단해보자.


if(조건)
{ //코드블록
  ...;
}
구조를 사용하면 주어진 조건이 참인 경우만 코드블록 부분이 실행된다.

비슷하게 어떤 조건에 따라 반복적으로 실행시킬 때에는 if를 while로 바꾸기만 하면

while(조건)
{ //코드블록
  ...;
}

와 같은 방법으로 코드블록의 내용을 반복적으로 수행시킬 수 있다.

수행되는 과정은
1. 먼저 조건을 검사한다.
2. 코드블록을 실행한다.
3. 다시 조건을 검사한다.
4. 코드블록을 실행한다.
...

와 같이 주어진 조건이 참인 동안 계속적으로 반복 실행한다.
이렇게 while(조건){...}을 이용하면 goto 명령을 사용하지 않고
반복을 만들어낼 수 있다.

예시
int n=1; //처음 조건 검사를 넘어가기 위해 0이 아닌 값 입력
while(n!=0)
{
  scanf("%d", &n);
  printf("%d", n);
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
		for(;;) {
			int a = sc.nextInt();
			
			if(a==0)break;
			System.out.println(a);
		}
		
	}
}

1074

정수(1 ~ 100) 1개가 입력되었을 때 카운트다운을 출력해보자.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc =new Scanner(System.in);
		
	    int c = sc.nextInt();
	    
	    for(int i=c; i>0; i--){
	        System.out.println(i);
	    }
	}
}

scpc - d13

1065

세 정수 a, b, c가 입력되었을 때, 짝수만 출력해보자.


참고
if(조건)
{ //조건이 참일 때에만 실행되는 구역(코드블록의 시작)
  실행1;
  실행2;
  ...
} //코드블록의 끝

의 조건/선택 실행 구조는
주어진 “조건”을 검사해 그 결과가 참인 경우에만 코드블록 안에 작성된 내용들을 순서대로 실행한다.


예시
if(a%2==0)
{
  printf(“%d”, a);
}

if(b%2==0)
{
  printf(“%d”, b);
}

if(c%2==0)
{
  printf(“%d”, c);
}

** a%2==0 은 a%2가 먼저 수행되고 그 결과를 0과 비교한 참/거짓 값을 계산한다.

a%2==0의 의미는 a를 2로 나눈 나머지를 0과 비교한 결과 값(참/거짓)이다.
따라서, if(a%2 == 0) 는 “a가 짝수라면?” 이라는 의미로 해석할 수 있다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int []arr = new int[3];
       
		for(int i=0; i<3; i++) {
			arr[i]= scanner.nextInt();
			if(arr[i]%2 ==0) {
				System.out.println(arr[i]);
			}
		}
        
        
	}
}

1066

세 정수 a, b, c가 입력되었을 때, 짝(even)/홀(odd)을 출력해보자.


참고
if(조건)
{ //코드블록1 시작
  ... 실행...;
  ...
}
else
{ //코드블록2 시작
  ... 다른실행...;
  ...
}
의 조건/선택 실행구조는 주어진 “조건”을 검사해 참인 경우에는 코드블록1을 실행하고,
거짓인 경우에는 코드블록2를 실행한다.

예시
if(a%2==0)
{
  printf(“%s”, “even”);
}
else
{
  printf(“%s”, “odd”);
}

** else는 if 없이 혼자 사용되지 않는다. 또한, else 다음에 조건이 없는 이유는?
참이 아니면 거짓이고, 거짓이 아니면 참이기 때문에...
즉 if문의 조건식의 판별 결과는 2가지 경우(참 또는 거짓)로 계산되는데,
else 부분은 if문의 조건식의 결과가 거짓인 경우에 해당하기 때문이다.

** 실행해야 할 명령들이 여러 개일 때 코드블록 기호 { }로 묶어 주는데,
코드블록의 내용이 논리적으로 1개 단위라면 코드블록 기호를 생략할 수 있다.

if(a%2==0) printf("%s", "even");
else printf("%s", "odd");

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int []arr = new int[3];
       
		for(int i=0; i<3; i++) {
			arr[i]= scanner.nextInt();
			if(arr[i]%2 ==0) {
				System.out.println("even");
			}
			else {
				System.out.println("odd");
			}
		}
        
        
	}
}

1067

정수 1개가 입력되었을 때, 음(minus)/양(plus)과 짝(even)/홀(odd)을 출력해보자.


참고
조건/선택 실행 구조의 안에 조건/선택 실행 구조를 다시 "중첩"할 수 있다.
이는 "중첩(nested)"의 원리가 적용되는 내용으로 아래와 같은 구조가 가능하다.

if(조건1)
{
  if(조건2) //조건문의 중첩
  {
    ...
  }
  else
  {
    ...
  }
}
else
{
  if(조건2)
  {
    ...
  }
  else
  {
    ...
  }
}

위와 같은 조건/선택 실행구조는 조건/선택 실행구조를 중첩해
서로 다른 4가지(2가지*2가지)의 경우에 대해 다른 실행을 할 수 있도록 해준다.

** 어떤 조건들이 맞았을 때에는 해당부분의 코드블록 내용만 실행되고,
전체 조건/선택 실행구조를 빠져나간다. 즉, 다른 부분들은 실행되지 않는다.

** 소스코드의 들여쓰기는 사람이 보고 이해하기 쉽도록 하는 것으로써
들여쓰기나 줄바꿈을 하지 않더라도 동일하게 컴파일된다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt();
       
		if(a >0){
		    System.out.println("plus");
		}else{
		    System.out.println("minus");
		}
        if(a%2 ==0){
            System.out.println("even");
        }
        else{
            System.out.println("odd");
        }
	}
}

1068

점수(정수, 0 ~ 100)를 입력받아 평가를 출력해보자.


평가 기준
점수 범위 : 평가
 90 ~ 100 : A
 70 ~   89 : B
 40 ~   69 : C
   0 ~   39 : D
로 평가되어야 한다.

참고
여러 조건들을 순서대로 비교하면서 처리하기 위해서 조건문을 중첩할 수 있다.
만약, 순서대로 검사하고 실행하기 위해 아래와 같이 중첩 시킨다면,

if(조건1)
{
  ...
}
else
{
  if(조건2)
  {
    ...
  }
  else
  {
    ...
  }
}

중첩된 구조는 논리적으로 1단위이기 때문에 코드블록 기호를 생략하면
아래와 같은 구조로 다시 표현될 수 있다.

if(조건1) { ... ; }
else if(조건2) { ... ; }
else { ...; }

이와 같이 조건을 계속 붙여나가면..

if(조건1) { ... ; }
else if(조건2) { ... ; }
else if(조건3) { ... ; }
else if(조건4) { ... ; }
else if(조건5) { ... ; }
else if(조건6) { ... ; }
else if(조건...) { ... ; }
else { ... ; }

위와 같은 구조를 만들어 순서대로 조건을 검사할 수 있다.
어떤 조건이 참이면, 그 부분의 내용을 실행하고 조건/선택 구조를 빠져나간다.

이렇게 조건들을 순서대로 검사할 때에는
중간에 범위가 빠지지 않았는지 꼼꼼하게 생각하고 조건들을 만드는 것이 중요하다.
이는 마치 수학에서 빠진 범위 없이 부등식을 만드는 것과 유사하다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt();
		
		
		if(a >= 90) {
			System.out.println("A");
		}else if(a >=70) {
			System.out.println("B");
		}else if(a>=40 ) {
			System.out.println("C");
		}else {
			System.out.println("D");
		}
        
	}
}

1069

평가를 문자(A, B, C, D, ...)로 입력받아 내용을 다르게 출력해보자.

평가 내용
평가 : 내용
A : best!!!
B : good!!
C : run!
D : slowly~
나머지 문자들 : what?


참고
조건/선택문을 복합적으로 구성해 출력할 수도 있지만,

switch(정수값)
{
  case 'A': //문자 'A'가 정수값 65('A'의 아스키 값)로 저장되기 때문에 가능하다.
    ...;
    break;
  case 'B':
    ...;
    break;
  case 'C':
    ...;
    break;
  default:
    ...;
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String a = scanner.nextLine();
		/*
		A : best!!!
		B : good!!
		C : run!
		D : slowly~
		나머지 문자들 : what?
*/
		switch(a) {
			case "A":
				System.out.println("best!!!");
				break;
			case "B":
				System.out.println("good!!");
				break;
			case "C":
				System.out.println("run!");
				break;
			case "D":
				System.out.println("slowly~");
				break;
			
			default:
			System.out.println("what?");
			

		
		
		}
	   
	}
}

위와 같은 switch( ) ... case... break; 제어문을 사용할 수 있다.

** break; 를 사용하지 않으면 이후의 명령들도 계속 실행된다.
default: 는 제시된 case 를 제외한 나머지 모든 경우에 실행된다.
switch( ) 에 주어지는 값은 “정수"값만 가능하며,
문자도 아스키코드 정수값이기 때문에 가능하다.

scpc - d13 

1060

입력된 정수 두 개를 비트단위로 and 연산한 후 그 결과를 정수로 출력해보자.
비트단위(bitwise)연산자 &를 사용하면 된다.(and, ampersand, 앰퍼센드라고 읽는다.)


** 비트단위(bitwise)연산자는,
~(bitwise not), &(bitwise and), |(bitwise or), ^(bitwise xor),
<<(bitwise left shift), >>(bitwise right shift)
가 있다.

예를 들어 3과 5가 입력되었을 때를 살펴보면
3       : 00000000 00000000 00000000 00000011
5       : 00000000 00000000 00000000 00000101
3 & 5 : 00000000 00000000 00000000 00000001
이 된다.

비트단위 and 연산은 두 비트열이 주어졌을 때,
둘 다 1인 부분의 자리만 1로 만들어주는 것과 같다.

이 연산을 이용하면 어떤 비트열의 특정 부분만 모두 0으로도 만들 수 있는데
192.168.0.31   : 11000000.10101000.00000000.00011111
255.255.255.0 : 11111111.11111111.11111111.00000000

두 개의 ip 주소를 & 연산하면
192.168.0.0 : 110000000.10101000.0000000.00000000 을 계산할 수 있다.

실제로 이 계산은 네트워크에 연결되어 있는 두 개의 컴퓨터가 데이터를 주고받기 위해
같은 네트워크에 있는지 아닌지를 판단하는데 사용된다.

이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서
마스크연산(특정 부분을 가리고 출력하는)을 수행하는 데에도 효과적으로 사용된다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt(); //		
		int b  =scanner.nex    tInt();
		//&:비트and연산  | : 비트or연산
        // ^ : 비트 xor연산   ~: 비트 not연산
		int c = a&b;
		System.out.println(c);
		}
}

1061

입력된 정수 두 개를 비트단위로 or 연산한 후 그 결과를 정수로 출력해보자.
비트단위(bitwise) 연산자 |(or, vertical bar, 버티컬바)를 사용하면 된다.


** | 은 파이프(pipe)연산자라고도 불리는 경우가 있다.

** 비트단위(bitwise) 연산자는,
~(bitwise not), &(bitwise and), |(bitwise or), ^(bitwise xor),
<<(bitwise left shift), >>(bitwise right shift)
가 있다.

예를 들어 3과 5가 입력되었을 때를 살펴보면
3     : 00000000 00000000 00000000 00000011
5     : 00000000 00000000 00000000 00000101
3 | 5 : 00000000 00000000 00000000 00000111
이 된다.

비트단위 or 연산은 둘 중 하나라도 1인 자리를 1로 만들어주는 것과 같다.

이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서도 효과적으로 사용된다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt(); //		
		int b = scanner.nextInt();
		
		System.out.println(a|b);

	}
}

1062

입력된 정수 두 개를 비트단위로 xor 연산한 후 그 결과를 정수로 출력해보자.
비트단위(bitwise) 연산자 ^(xor, circumflex/caret, 서컴플렉스/카릿)를 사용하면 된다.

** 주의 ^은 수학식에서 거듭제곱(power)을 나타내는 기호와 모양은 같지만,
C언어에서는 전혀 다른 배타적 논리합(xor, 서로 다를 때 1)의 의미를 가진다.

** 비트단위(bitwise) 연산자는,
~(bitwise not), &(bitwise and), |(bitwise or), ^(bitwise xor),
<<(bitwise left shift), >>(bitwise right shift)
가 있다.

예를 들어 3과 5가 입력되었을 때를 살펴보면
3       : 00000000 00000000 00000000 00000011
5       : 00000000 00000000 00000000 00000101
3 ^ 5 : 00000000 00000000 00000000 00000110
이 된다.
이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서도 효과적으로 사용된다.

구체적으로 설명하자면,
두 장의 이미지가 겹쳐졌을 때 색이 서로 다른 부분만 처리할 수 있다.
배경이 되는 그림과 배경 위에서 움직이는 그림이 있을 때,
두 그림에서 차이만 골라내 배경 위에서 움직이는 그림의 색으로 바꿔주면
전체 그림을 구성하는 모든 점들의 색을 다시 계산해 입히지 않고
보다 효과적으로 그림을 처리할 수 있게 되는 것이다.
비행기 슈팅게임 등을 상상해보면 된다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt(); //		
		int b = scanner.nextInt();
		//^ : xor연산 다르면1 같으면0
		System.out.println(a^b);   
	}
}

1063

입력된 두 정수 a, b 중 큰 값을 출력하는 프로그램을 작성해보자.
단, 조건문을 사용하지 않고 3항 연산자 ? 를 사용한다.

참고
3개의 요소로 이루어지는 3항(ternary) 연산자는
"조건식 ? (참일 때의 값) : (거짓일 때의 값)” 의 형태로 사용하는 연산자이다.
- 조건식의 계산 결과가 참인 경우에는 ':' 왼쪽의 값 또는 식으로 바뀌고,
- 거짓인 경우에는 ':' 오른쪽의 값 또는 식으로 바뀐다.

예를 들어
123 > 456 ? 0 : 1
과 같은 표현식은 123 > 456 의 비교연산 결과가 거짓이므로 1이 된다.

예시
printf("%d", a>b ? a:b); //두 값 중 큰 값이 출력된다.

예시 코드는 a>b 의 결과가 참(1)이면 (a>b ? a:b)의 결과는 a가 되고,
거짓(0)이면 (a>b ? a:b)의 결과는 b가 된다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt(); //		
		int b = scanner.nextInt();
		
		System.out.println(a>b ? a:b);
	}
}

1064

입력된 세 정수 a, b, c 중 가장 작은 값을 출력하는 프로그램을 작성해보자.
단, 조건문을 사용하지 않고 3항 연산자 ? 를 사용한다.


참고
C언어 소스코드 작성시 모든 요소들은
"순서에 따라 한 단계씩 실행"
"미리 정해진 순서에 따라 하나씩 연산 수행"
"그 때까지 연산된 결과를 이용해 다시 순서에 따라 하나씩 연산"
...
등의 원리가 적용된다.

따라서 3항 연산자 ? 를 중첩해(괄호로 묶는 등..) 이용하면
여러 값들을 순서대로 비교해 가장 큰/작은 값을 계산할 수 있다.

예를 들어
(a>b ? a:b)>c ? (a>b ? a:b):c 의 계산식은
a, b, c 의 값 중 가장 큰 값으로 계산된다.
잘 이해가 되지 않는다면 어떤 순서에 따라 계산될지 생각해보고
여러 가지 연산자가 동시에 사용된 식이 있을 때,
어떤 우선순위에 따라 순서대로 계산이 되는지 찾아보도록 한다.

“연산자 우선순위”를 검색하면 우선순위와 결합방향이 나온다.
예를 들어 변수에 어떤 값을 대입하는
대입(assign) 연산자 = 의 우선순위는 가장 낮고, 오른쪽에서 왼쪽의 결합방향을 가진다.

따라서,
a = b = c = d = e = f = g = h = i = j = 0;
의 식을 실행하면 오른쪽에서부터 왼쪽으로 가면서
처음에 j 변수에 0이 대입되고, 다음에 i 변수에 j변수에 저장되어 있는 값이 저장되고,
그 다음에 h 변수에 i변수에 저장되어 있는 값이 저장되고 ...
결국 모든 변수의 값을 0으로 만드는 결과가 된다.

** 3항 연산자는 자주 사용되지는 않지만,
복잡한 계산식이나 조건 처리, 비교 구조를 매우 간단히 표현할 수 있게 해준다.

잘 사용해보면 나름대로의 재미와 묘미가 있는 연산자이다.

특히, 보다 짧은 코드로 문제를 해결하려고 하는
숏 코딩(coding)에서는 빠질 수 없는 요소이다.
"똑같이 해결할 수 있는 프로그램이지만, 때로는 아주 적은 소스코드 양으로 풀어내는 것을
매우 즐기는 숏 코더들이 있다."

숏 코딩은 일종의 재미이기는 하지만,
프로그래밍언어의 밑바닥 기초, 세세한 처리 과정에 대한 이해,
컴파일러의 소스코드 해석과 변환 등에 대한 경험과 지식이 필요하다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt(); //		
        int b = scanner.nextInt();
        int c  = scanner.nextInt();
       
        
        System.out.println( c>(a>b? b:a) ? (a>b? b:a):c  );
        
	}
}