728x90

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  );
        
	}
}

 

 

 

728x90
728x90

scpc d-13 // 비트연산은 매우 이해하기 쉬우나 코딩으로 처음사용해봐서 조금 실수함

// 1059 번의 반전비트연산~ 를 이용하면 쉽지만 이걸 직접 비트연산 함수를 구현해버렸다.

 

1055.

두 개의 참(1) 또는 거짓(0)이 입력될 때,
하나라도 참이면 참을 출력하는 프로그램을 작성해보자.


참고
논리연산자 || 는 주어진 2개의 논리값 중에 하나라도 참(1) 이면 1(참)로 계산하고,
그 외의 경우에는 0(거짓) 으로 계산한다.

** | 기호는 쉬프트를 누른 상태에서 백슬래시(\)를 누르면 나오는 기호로,
버티컬 바(vertical bar) 기호이다.

이러한 논리연산을 OR 연산이라고도 부르고,
+ 로 표시하며, 집합 기호로는 ∪(합집합, union)을 사용한다. 모두 같은 의미이다.

참, 거짓의 논리값(boolean value)인 불 값을 다루어주는 논리연산자는
!(not), &&(and), ||(or) 이 있다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로
참/거짓만 가지는 논리값과 그 연산을 다룬다.

예시
printf("%d", 0||0); //둘 다 거짓을 의미하므로 0이 계산되어 출력된다.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        
        int b =sc.nextInt();
        
        if(a+b >=1){
            System.out.println(1);
        }else{
            System.out.println(0);
            }
    }
        
        
        
    }

 

1056

두 가지의 참(1) 또는 거짓(0)이 입력될 때,
참/거짓이 서로 다를 때에만 참을 출력하는 프로그램을 작성해보자.


참고
이러한 논리연산을 XOR(exclusive or, 배타적 논리합)연산이라고도 부른다.
집합의 의미로는 합집합에서 교집합을 뺀 것을 의미한다. 모두 같은 의미이다.

논리연산자는 사칙연산자와 마찬가지로 여러 번 중복해서 사용할 수 있는데,
연산의 순서를 만들어주기 위해 괄호 ( )를 사용해 묶어 주면 된다.

수학에서는 괄호, 중괄호, 대괄호를 사용하지만 C언어에서는 소괄호 ( )만을 사용한다.

예시
printf(“%d”, (a&&!b)||(!a&&b)); //참/거짓이 서로 다를 때에만 1로 계산

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b =sc.nextInt();
        
        if(a+b==1) {
        	System.out.println(1);
        }else {
        	System.out.println(0);
        }
        
        
        
    }
    
}

 

1057

두 개의 참(1) 또는 거짓(0)이 입력될 때,
참/거짓이 서로 같을 때에만 참이 계산되는 프로그램을 작성해보자

import java.io.IOException;
import java.util.Scanner;

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

1058

 

두 개의 참(1) 또는 거짓(0)이 입력될 때,
모두 거짓일 때에만 참이 계산되는 프로그램을 작성해보자.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    //0 0 = 1
    // 01 = 0  10= 0 , 11 =0        
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b =sc.nextInt();
        
        if((a==0)&(b==0)) {
        	System.out.println(1);
        }else {
        	System.out.println(0);
        }
        
        
        
    }
    
}

1059

입력 된 정수를 비트단위로 참/거짓을 바꾼 후 정수로 출력해보자.
비트단위(bitwise)연산자 ~ 를 붙이면 된다.(~ : tilde, 틸드라고 읽는다.)


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

예를 들어 1이 입력되었을 때 저장되는 1을 32비트 2진수로 표현하면
        00000000 00000000 00000000 00000001 이고,
~1은 11111111 11111111 11111111 11111110 가 되는데 이는 -2를 의미한다.


예시
int a=1;
printf("%d", ~a); //-2가 출력된다.

참고
컴퓨터에 저장되는 모든 데이터들은 2진수 형태로 바뀌어 저장된다.
0과 1로만 구성되는 비트단위들로 변환되어 저장되는데,
양의 정수는 2진수 형태로 바뀌어 저장되고,
음의 정수는 "2의 보수 표현"방법으로 저장된다.

예를 들어 int형(4바이트(byte), 32비트)으로 선언된 변수에 양의 정수 5를 저장하면
5의 2진수 형태인 101이 32비트로 만들어져
00000000 00000000 00000000 00000101
로 저장된다.(공백은 보기 편하도록 임의로 분리)

int 형의 정수 0은
00000000 00000000 00000000 00000000

그리고 -1은 0에서 1을 더 빼고 32비트만 표시하는 형태로
11111111 11111111 11111111 11111111 로 저장된다.

-2는 -1에서 1을 더 빼면 된다.
11111111 11111111 11111111 11111110 로 저장된다.

그래서 int 형으로 선언된 변수에는 최소 -2147483648 을 의미하는
10000000 00000000 00000000 00000000 부터

최대 +2147483647 을 의미하는
01111111 11111111 11111111 11111111 로 저장될 수 있는 것이다.

그렇다면 -2147483648
10000000 00000000 00000000 00000000 에서 1을 더 뺀다면?

01111111 11111111 11111111 11111111 이 된다.
즉 -2147483649 가 아닌 +2147483647 이 되는 것이다.

이러한 것을 오버플로우(overflow, 넘침)라고 한다.

이러한 내용을 간단히 표시하면, 정수 n이라고 할 때,

~n = -n - 1
-n = ~n + 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 = ~a;   //비트 반전 연산자~
		System.out.println(b);  
	}
}
728x90
728x90

SCPC1차 D -14 

 

1050.



참고
어떤 값을 비교하기 위해 비교/관계연산자(comparison/relational)를 사용할 수 있다.

비교/관계연산자 == 는
두 개의 값이 같은 경우 참(true)을 나타내는 정수값 1로 계산하고,
다른 경우 거짓(false)를 나타내는 정수값 0으로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 1(참), 또는 0(거짓)으로 계산해 주는 연산자이다.

비교/관계연산자는 >, <, >=, <=, ==(같다), !=(다르다) 6개가 있다.

** 수학에서 왼쪽과 오른쪽의 계산 결과가 같음(동치)을 나타내는 기호 = 는
C언어에서 전혀 다른 의미로 사용된다.

a=1 와 같은 표현은 a와 1의 값이 같다는 의미가 아니라
오른쪽의 계산 결과인 1을 왼쪽의 변수 a에 저장하라는 의미이다.

 

import java.io.IOException;
import java.util.Scanner;

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

 

 

1051.

 

두 정수(a, b)를 입력받아
b가 a보다 크거나 같으면 1을, 그렇지 않으면 0을 출력하는 프로그램을 작성해보자.


참고
어떤 값을 비교하기 위해 비교/관계연산자(comparison/relational)를 사용할 수 있다.

비교/관계연산자는 주어진 2개의 값을 비교하여
그 결과가 참인 경우 참(true)을 나타내는 정수값 1로 계산하고,
거짓인 경우 거짓(false)를 나타내는 정수값 0으로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 1(참), 또는 0(거짓)으로 계산해 주는 연산자이다.

비교/관계연산자는 >, <, >=, <=, ==(같다), !=(다르다) 6개가 있다.

>=, <= 연산자는 같음(==)을 포함한다.
따라서 “작다/크다” 또는 "같다”는 의미를 가진다.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b =sc.nextInt();
        
        if(b>=a){
            System.out.println(1);
        }else{
            System.out.println(0);
        }
    }
    
}

 

1052.

두 정수(a, b)를 입력받아
a와 b가 서로 다르면 1을, 그렇지 않으면 0을 출력하는 프로그램을 작성해보자.


참고
어떤 값을 비교하기 위해 비교/관계연산자(comparison/relational)를 사용할 수 있다.

비교/관계연산자는 주어진 2개의 값을 비교하여
그 결과가 참인 경우 참(true)을 나타내는 정수값 1로 계산하고,
거짓인 경우 거짓(false)를 나타내는 정수값 0으로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 1(참), 또는 0(거짓)으로 계산해 주는 연산자이다.

비교/관계연산자는 >, <, >=, <=, ==(같다), !=(다르다) 6개가 있다.

예시
printf("%d", 123!=123); //비교 연산자 !=의 계산 결과인 0(거짓)이 출력된다.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a =sc.nextInt();
        int b =sc.nextInt();
        
        if(a != b ){
            System.out.println(1);
        }else{
            System.out.println(0);
        }
        
        
        
    }
    
}

1053.

1(true, 참) 또는 0(false, 거짓) 이 입력되었을 때
반대로 출력하는 프로그램을 작성해보자.


참고
C언어에서 비교/관계 연산(==, !=, >, <, >=, <=)이 수행될 때,
0은 거짓(false)으로 인식되고, 0이 아닌 모든 수는 참(true)으로 인식된다.

참 또는 거짓의 논리값을 역(반대)으로 바꾸기 위해서는
논리(logical)연산자 !를 사용할 수 있다.

이러한 논리연산을 NOT 연산이라고도 부르고,
프라임(기호 오른쪽에 따옴표) 이나 바(기호 위에 가로 막대)로 표시하고,
집합 기호로는 c (여집합, complement)를 의미한다. 모두 같은 의미이다.

참, 거짓의 논리값(boolean value)인 불 값을 다루어주는 논리연산자는
!(not), &&(and), ||(or) 이 있다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로
참/거짓만 가지는 논리값과 그 연산을 다룬다.

예시
printf("%d", !0); //거짓의 반대, 즉 참인 1로 계산됨
printf("%d", !1); //참의 반대, 즉 거짓인 0으로 계산됨
printf("%d", !999); //참의 반대, 즉 거짓인 0으로 계산됨

어떤 변수 a에, !a 와 같은 논리 연산이 가능하다.

 

import java.io.IOException;
import java.util.Scanner;

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

 

1054

두 개의 참(1) 또는 거짓(0)이 입력될 때,
모두 참일 때에만 참을 출력하는 프로그램을 작성해보자.


참고
논리연산자 && 는 주어진 2개의 논리값이 모두 참(1) 일 때에만 1(참)로 계산하고,
그 외의 경우에는 0(거짓) 으로 계산한다.

이러한 논리연산을 AND 연산이라고도 부르고, · 으로 표시하거나 생략하며,
집합 기호로는 ∩(교집합, intersection)을 의미한다. 모두 같은 의미이다.

참, 거짓의 논리값(boolean value)인 불 값을 다루어주는 논리연산자는
!(not), &&(and), ||(or) 이 있다.

** 불 대수(boolean algebra)는 수학자 불이 만들어낸 것으로
참/거짓만 가지는 논리값과 그 연산을 다룬다.

예시
printf("%d", 1&&1); //둘 다 참을 의미하므로 1로 계산되어 출력된다.

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        
        int b =sc.nextInt();
        
        if(a+b ==2){
            System.out.println(1);
        }else{
            System.out.println(0);
            }
    }
        
        
        
    }
728x90
728x90

SCPC 1차예선 D-14 ) 비트연산을처음 써보는데 신기하다

학교에서 어느과목인진 기억안나지만 shift연산을 자주햇었는데

알고리즘에서 shift 연산을해보니 좀 신기하네 1048은 제곱함수를 이용해서 쉽게구할수있겠지만 shift쓰는게 출제자의 의도이므로...

shift연산을 연습해야될거같다.

 

1045.

정수 2개(a, b)를 입력받아 합, 차, 곱, 몫, 나머지, 나눈 값을 자동으로 계산해보자.
단 0 <= a, b <= 2147483647, b는 0이 아니다.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        System.out.printf("%d\n%d\n%d\n%d\n%d\n%.2f",a+b,a-b,a*b,a/b,a%b,(double)a/b);
        
        
    }
    
}

 

1046.

정수 3개를 입력받아 합과 평균을 출력해보자.
단, -2147483648 ~ +2147483647

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        
        System.out.printf("%d\n%.1f",a+b+c, (double)(a+b+c)/3);
        
        
        
    }
    
}

 

1047.

정수 1개를 입력받아 2배 곱해 출력해보자.

참고
*2 의 값을 출력해도 되지만,
정수를 2배로 곱하거나 나누어 계산해 주는 비트단위시프트연산자 <<, >>를 이용한다.

2진수 형태로 저장되어 있는 값들을 왼쪽(<<)이나 오른쪽(>>)으로
지정한 비트 수만큼 밀어주면 2배씩 늘어나거나 반으로 줄어드는데,

왼쪽 비트시프트(<<)가 될 때에는 오른쪽에 0이 주어진 개수만큼 추가되고,

오른쪽 비트시프트(>>)가 될 때에는
왼쪽에 0(0 또는 양의 정수인 경우)이나 1(음의 정수인 경우)이 개수만큼 추가된다.

범위(32비트)를 넘어서 이동되는 비트는 삭제된다.

예시
int a=10;
printf("%d", a<<1); //10을 2배 한 값인 20 이 출력된다.
printf("%d", a>>1); //10을 반으로 나눈 값인 5 가 출력된다.
printf("%d", a<<2); //10을 4배 한 값인 40 이 출력된다.
printf("%d", a>>2); //10을 반으로 나눈 후 다시 반으로 나눈 값인 2 가 출력된다.

import java.io.IOException;
import java.util.Scanner;

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

 

1048.

정수 2개(a, b)를 입력받아 a를 2b배 곱한 값으로 출력해보자.
0 <= a <= 10, 0 <= b <= 10


참고
예를 들어 1 3 이 입력되면 1을 23(8)배 하여 출력한다.

예시
int a=1, b=10;
printf("%d", a << b); //210 = 1024 가 출력된다.

 

a 를 2b배 만큼 곱한 값을 출력한다.

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        
        if(b==0){
            System.out.println(a);
        }
        else{
        System.out.println(a * (2<<b-1) );
    }
    }
}

 

1049.

두 정수(a, b)를 입력받아

a가 b보다 크면 1을, a가 b보다 작거나 같으면 0을 출력하는 프로그램을 작성해보자.


참고
어떤 값을 비교하기 위해 비교/관계연산자(comparison/relational)를 사용할 수 있다.

비교/관계연산자 > 는
왼쪽의 값이 오른쪽 값 보다 큰 경우 참(true)을 나타내는 정수값 1로 계산하고,
그 외의 경우에는 거짓(false)를 나타내는 정수값 0으로 계산한다.

비교/관계연산자도 일반적인 사칙연산자처럼 주어진 두 수를 이용해 계산을 수행하고,
그 결과를 1(참), 또는 0(거짓)으로 계산해 주는 연산자이다.

비교/관계연산자는 >, <, >=, <=, ==(같다), !=(다르다) 6개가 있다.

예시
printf("%d", 123<456); //비교 연산자 < 의 계산 결과인 1(참)이 출력된다.

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b =sc.nextInt();
        
        if(a>b){
            System.out.println(1);
        }else{
            System.out.println(0);
        }
        
        
        
    }
    
}import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b =sc.nextInt();
        
        if(a>b){
            System.out.println(1);
        }else{
            System.out.println(0);
        }
        
        
        
    }
    
}
728x90
728x90

scpc 1차예선 d-14

 

1040 .

입력된 정수의 부호를 바꿔 출력해보자.
단, -2147483647 ~ +2147483647 범위의 정수가 입력된다.

참고
단항 연산자인 -(negative)를 변수 앞에 붙이면 부호가 반대로 바뀌어 계산된다.

예시
int a;
scanf("%d", &a);
printf("%d", -a);

 

import java.util.Scanner;

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

 

1041.

영문자 1개를 입력받아 그 다음 문자를 출력해보자.

영문자 'A'의 다음 문자는 'B'이고, 영문자 '0'의 다음 문자는 '1'이다.

참고
숫자는 수를 표현하는 문자로서 '0' 은 문자 그 자체를 의미하고, 0은 값을 의미한다.

힌트
아스키문자표에서 'A'는 10진수 65로 저장되고 'B'는 10진수 66으로 저장된다.
따라서 문자도 값으로 덧셈을 할 수 있다.

//String 를 char로 변환x

//String으로 1줄을 입력받으면서 charAt를 통해 char 문자 한개만 저장후 int를 통해 아스키코드 연산

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        char s = sc.nextLine().charAt(0);
        int sp = (int)s +1;
        
        System.out.println((char)sp);
        
        
        
    }
    
}

 

 

1042

 

정수 2개(a, b) 를 입력받아 a를 b로 나눈 몫을 출력해보자.
단, -2147483648 <= a <= b <= +2147483647, b는 0이 아니다.

참고
C언어에서 정수/정수 연산의 결과는 정수(몫)로 계산된다.
실수/정수, 정수/실수, (float)정수/정수, 정수/(float)정수 등의 연산 결과는 실수 값으로 계산된다.

(float)(정수/정수)는 정수/정수의 결과인 정수 값을 실수형(float)로 바꾸는 것으로,
계산 결과인 정수 값이 실수 형태로 변환되는 것이니 주의해야 한다.

정수/실수 계산결과가 자동으로 실수형으로 바뀌는 것을 묵시적 (데이터)형변환이라고 하고,
어떤 값이나 결과의 데이터형을 강제로 바꾸는 것을 명시적 (데이터)형변환이라고 한다.

int a;
scanf("%d", &a);
printf("%f", (float)a);

와 같이 실행하면, 정수로 저장되어 있는 값을 실수형(float)으로 명시적으로 변환하여 출력한다.

import java.io.IOException;
import java.util.Scanner;

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

 

1043.

정수 2개(a, b) 를 입력받아 a를 b로 나눈 나머지를 출력해보자.
단, 0 <= a, b <= +2147483647, b는 0이 아니다.

참고
C언어에서 정수%정수 연산의 결과는 나눈 나머지로 계산된다.

% 연산자(modulus, mod 연산) 수학자 가우스가 생각해낸 연산으로,
어떤 정수를 다른 정수로 나누고 난 후 남는 나머지를 계산하는 연산이다.

단, 음(-)이 아닌 정수에 대해서만 연산된다.

 

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        System.out.println(a%b);
        
        
        
        
    }
    
}

 

1044.

정수를 1개 입력받아 1만큼 더해 출력해보자.
단, -2147483648 ~ +2147483647 의 범위로 입력된다.

주의
계산되고 난 후의 값의 범위(데이터형)에 주의한다.

참고
어떤 변수(a)에 값을 저장한 후 a+1 의 값을 출력할 수도 있고,
++a 연산을 한 후에 출력할 수도 있다.

++a, --a, a++, a-- 와 같이 어떤 변수의 앞이나 뒤에 붙여
변수에 저장되어있는 값을 1만큼 더하거나 빼주는 연산자를 증감연산자라고 한다.

증감연산자를 변수 앞에 붙이면 그 변수를 사용하기 전에 증감을 먼저 수행하고,
증감연산자를 변수 뒤에 붙이면 일단 변수에 저장되어있는 값을 먼저 사용하고 난 후
나중에 증감을 수행한다.

import java.io.IOException;
import java.util.Scanner;

public class Main{
    
    public static void main(String [] args) throws IOException{
        
        Scanner sc = new Scanner(System.in);
        
        long a = sc.nextLong();
        
        System.out.println(a+1);
        
        
        
        
    }
    
}
728x90
728x90

d-14 ) 1036번에서 한번막히긴했지만 저 코드가 왜안되는지 아직 잘이해가 가지않는다.

C에서는 분명 돌아가는거같은데 자바에서는...

1035

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;
 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        //
        String hexNum = sc.nextLine();
        
        //문자열 hexNum을 16진수로 바꾼다
        int num = Integer.parseInt(hexNum, 16);
        
        //int num을 8진수로 바꾼다
        String octNum = Integer.toOctalString(num);
        
        System.out.print(octNum);
        
    }
}
 
cs

 

1036

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.Scanner;
 
public class Main{
    
    public static void main(String [] args){
        
        Scanner sc = new Scanner(System.in);
        
        char word = sc.next().charAt(0);
        
        System.out.println((int)word);
        
       
        
        
    }
    
}
 
//////////////아래코드는 오답
 
 
import java.util.Scanner;
 
public class Main{
    
    public static void main(String [] args){
        
        Scanner sc = new Scanner(System.in);
        
        char s = sc.next().charAt(0);
        
        System.out.printf("%d",s);
        
       
        
        
    }
    
}}
cs

 

 

 

 

1037

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;
 
public class Main{
    
    public static void main(String [] args){
        
        Scanner sc = new Scanner(System.in);
        
        int d = sc.nextInt();
        //정수를 아스키코드로....
        
        System.out.printf("%c",d);
        //System.out.println("(char)d");
        
        
        
    }
    
}
cs

 

 

1038

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Scanner;
 
public class Main{
    
    public static void main(String [] args){
        
        Scanner sc = new Scanner(System.in);
        
        long n = sc.nextLong();
        long p = sc.nextLong();
        
        System.out.println(n+p);
        
        
        
    }
    
}
cs

 

1039

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Scanner;
 
public class Main{
    
    public static void main(String [] args){
        
        Scanner sc = new Scanner(System.in);
        
        long n = sc.nextLong();
        long p = sc.nextLong();
        
        System.out.println(n+p);
        
        
        
    }
    
}
cs
728x90

+ Recent posts