BOJ 2745, 11005, 1373, 1212, 2089 진법변환하기
BOJ 2473, 11005, 1373, 1212, 2089 진법 변환하기
BOJ 2745. 진법 변환 ( N진법의 수를 10진법으로 변경하기)
풀이
B 진법의 수 N과, B가 주어진다.
10진법을 넘어가는 수는
A:10
B:11
C:12
D:13
..
..
..
Y:34
Z:35
위와 같이 A-Z로 표현한다.
ZZZZZ 36을 입력하였다면 36진법으로 표시된 문자열ZZZZZ이므로
입력받은 문자열을 반복문을 통해 char를 처음부터 확인한다.
char문자를 그대로 int로 캐스팅하면
char값은 아스키코드값으로 변경되기 때문에 Z는 35가 아닌 90으로 변경되게 된다.
아스키코드표를 참고하여
- 0~9이라면
- char - ‘0’
- char - 48
- A-Z이라면
- char - ‘A’ +10
- char - 55
또는
Character wrapper class의 메서드인 Character.getNumericValue(c);을 사용하여 10진수 숫자로 변경한다.
10진수 숫자를 얻었다면 B^(자리수 - 1)을 곱한다.
즉, ZZZZZ은 (35\* 35^4) + (35\*35^3) + (35\*35^2) + (35\*35^1) + \+ (35\*35^0)이다.
import java.io.*;
import java.util.Scanner;
class Main {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
String n = sc.next();
int b = sc.nextInt();
int answer = 0;
for (int i = 0; i < n.length(); i++) {
char c = n.charAt(i);
int r = 0;
if (c >= 'A' && c <= 'Z') {
r += (c - 'A' + 10);
} else {
r += (c - '0');
}
answer += r * Math.pow(b, n.length() - 1 - i);
}
System.out.println(answer);
sc.close();
}
}
import kotlin.math.pow
fun main() {
val (n, b) = readLine()!!.split(" ")
n.foldIndexed(0) { i, aar, c ->
val r = if (c in 'A'..'Z') (c - 'A' + 10) else (c - '0')
aar + (r * b.toDouble().pow(n.length - 1 - i)).toInt()
}.let(::println)
}
BOJ 11005. 진법 변환 2( 10진법의 수를 N진법으로 변경하기)
풀이 10진법의 수 N을 B진법으로 변환한다.
입력받은 10진법의 수를 B로 나누고,
나머지가 10 보다 큰지 (A-Z)
나머지가 10 보다 작은지 (0-9)인지를 구분하여 나머지를 기록한다.
N을 B로 더 이상 나눌 수 없을 때까지 나머지를 기록한다.
그 후 기록한 나머지를 거꾸로 출력한다.
import java.io.*;
import java.util.Scanner;
class Main {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int b = sc.nextInt();
StringBuilder answer = new StringBuilder();
while (n > 0) {
long rest = n % b;
if (rest >= 10) {
answer.append((char) ((rest - 10) + 'A'));
} else {
answer.append((char) (rest + '0'));
}
n /= b;
}
System.out.println(answer.reverse().toString());
sc.close();
}
}
fun main() {
var (n, b) = readLine()!!.split(" ").map { it.toInt() }
var answer = ""
while (n > 0) {
val rest = n % b
answer += when (rest) {
in 0..9 -> rest
else -> ('A' + (rest - 10))
}.toString()
n /= b
}
println(answer.reversed())
}
BOJ 1373. 2진수 8진수 ( 2진수를 8진수로 변환)
풀이
입력받은 8 진수의 수가 3자리씩 끊어지는지 확인하여
끊어지지 않는다면 맨 앞에 0을 추가한다.
맨 뒤부터 각 자리의 값들을 계산하여 더한 후 기록한다.
기록한 값을 거꾸로 출력한다.
import java.io.*;
import java.util.Stack;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String input = br.readLine();
Stack<Integer> stack = new Stack<>();
if (input.length() % 3 != 0) {
for (int i = 0; i < input.length() % 3; i++) {
input = "0" + input;
}
}
for (int i = input.length() - 1; i > 0; i -= 3) {
int oneSeat = Character.getNumericValue(input.charAt(i));
int twoSeat = Character.getNumericValue(input.charAt(i - 1));
int fourSeat = Character.getNumericValue(input.charAt(i - 2));
stack.push(oneSeat + twoSeat * 2 + fourSeat * 4);
}
while (!stack.isEmpty()) {
bw.write(stack.pop().toString());
}
bw.flush();
bw.close();
}
}
단순하게 BigInteger를 이용하는 방법도 있다.
import java.math.BigInteger
fun main() {
val b = BigInteger(readLine()!!, 2)
println(b.toString(8))
}
BOJ 1212. 8진수 2진수(8진수를 2진수로 변환)
풀이
8진법(8가지)에서 2진법으로 변환한 배열을 만든다.
현재 진법의 자리 수마다 2진법으로 바꾸어 이어 붙인다. 제일 앞쪽의 0을 제거한다.
import java.io.*;
import java.util.Scanner;
class Main {
static String[] octToBin = {"000", "001", "010", "011", "100", "101", "110", "111"};
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
char[] oct = sc.next().toCharArray();
if (oct.length == 1 && oct[0] == '0') {
System.out.println(0);
return;
}
for (char c : oct) {
sb.append(octToBin[c - '0']);
}
while (sb.charAt(0) == '0') {
sb.deleteCharAt(0);
}
System.out.println(sb.toString());
sc.close();
}
}
val octToBin: List<String> = listOf("000", "001", "010", "011", "100", "101", "110", "111")
fun main() {
readLine()!!.toCharArray().let { arr ->
if (arr.size == 1 && arr[0] == '0') "0"
else arr.joinToString("") { c -> octToBin[c - '0'] }
.let { it.substring(it.indexOf('1')) }
}.let(::println)
}
BOJ 2089. -2진수
풀이
보통의 10진법에서 2진법으로 변환하는 방법을 따르지만 나눈 몫을 올림 하여 처리한다.
10진법의 수 N을 -13을 입력으로 받았을 때, N이 0이 될 때까지 -2로 나눈나머지를 계속 저장하고, 나눈 몫을 올림 하여 계속 이어간다.
(-13) % (-2) = 1- 나머지 1 맨 앞에 저장
(-13) / (-2 ) = 6.5-> 반올림 7
(7) % (-2) = -1-> 절댓값 1- 나머지 1 맨 앞에 저장
(7) / (-2) = - 3.5-> 반올림 -3
(-3) % (-2) = -1-> 절댓값 1- 나머지 1 맨 앞에 저장
(-3) / (-2) = 1.5-> 반올림 2
(2) % (-2) = 0- 0 맨 앞에 저장
(2) / (-2) = -1
(-1) % (-2) = -1->절댓값 1- 나머지 1 맨 앞에 저장
(-1) / (-2) = 0.5-> 반올림 1
(1) % (-2) = 1- 나머지 1 맨 앞에 저장
(1) / (-2) = -0.5-> 반올림 -0.0
위 과정을 거친 후에 110111이라는 -2 진법의 수를 출력한다.
import java.io.*;
import java.util.Scanner;
class Main {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
long n = sc.nextLong();
if (n == 0) {
System.out.println(0);
return;
}
while (n != 0) {
sb.insert(0, Math.abs(n % -2));
n = (long) Math.ceil((double) n / -2);
}
System.out.println(sb.toString());
sc.close();
}
}
import java.lang.StringBuilder
import kotlin.math.abs
import kotlin.math.ceil
fun main() {
var n = readLine()!!.toInt()
if (n == 0) {
println(n)
return
}
val sb = StringBuilder()
while (n != 0) {
sb.insert(0, abs(n % -2))
n = ceil(n.toDouble() / -2).toInt()
}
println(sb)
}