공지: 기존 사이트는 old.codingdojang.com에서 확인할 수 있으며, 2026년 8월 3일 종료됩니다.
10진수를 n진수로 변환하기
다음은 233 이란 10진수를 2진수로 변환하는 과정을 나타낸 그림이다.
위 그림을 참조하여 라이브러리를 사용하지 말고 10진수를 n진수로 변환하는 프로그램을 작성하시오.. (단, n의 범위는 2 <= n <= 16)
예)
- 2진수로 변환 : 23310 --> 111010012
- 8진수로 변환 : 23310 --> 3518
- 16진수로 변환 : 23310 --> E916
221개의 풀이가 있습니다.
재귀로 풀어 보았습니다.
def convert(n, base):
T = "0123456789ABCDEF"
q, r = divmod(n, base)
if q == 0:
return T[r]
else:
return convert(q, base) + T[r]
print convert(233, 2)
print convert(233, 8)
print convert(233, 16)
깔끔하네요. 재귀를 이렇게 활용이 되는 군요.
-
Shin gil sang,
2015/11/17 16:11
저도 재귀로 풀었지만, 훨씬 더 깔끔하네요. 함수에 문자를 더하고 리턴하는법 배우고 갑니다^^
-
디디,
2016/03/21 23:38
divmod 펑션과 리턴하는법 배우고갑니다 ^^
-
Kim Soojong,
2016/12/05 09:15
divmod 라는 좋은 built-in function 과 재구함수호출 그리고 재귀함수 return 할때 문자를 더해서 리턴 할 수도 있다는 것, 10 이상의 수를 list indexing 으로 하면 깔끔하다는 것을 배우고 갑니다. 고맙습니다.
-
예강효빠,
2017/04/18 04:38
divmod()라는 걸 처음알았네요 감사합니다
-
임지호,
2017/12/27 15:58
divmod라는 내장함수를 다시 알게 되었네요!
-
농창,
2019/02/25 00:55
def toN(n, num=2):
res=[]
res2=''
while n>0:
n, tmp = divmod(n, num)
res.append((str(tmp) if tmp <10 else 'ABCDEF'[tmp-10]))
for i in range(len(res)):
res2 += res.pop()
return res2
print(toN(233, 2))
print(toN(233, 8))
print(toN(233, 16))
C#으로 작성했습니다. 재귀함수로 더 이상 나누어 떨어질 수 없을 때까지의 나머지 값을 string으로 묶었습니다.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CodingDojang
{
class CodingDojang
{
static void Main(string[] args)
{
DecimalConverter.Answer();
Console.Read();
}
}
public static class DecimalConverter
{
public static void Answer()
{
Console.WriteLine("Please type a decimal number: ");
int number = int.Parse(Console.ReadLine());
Console.WriteLine("Please type a form to convert: ");
int convert = int.Parse(Console.ReadLine());
string solution = string.Empty;
solution = Division(number, convert, solution);
Console.WriteLine(solution);
}
public static string Division(int number, int convert, string solution)
{
int remainder = number % convert;
solution = ConvertToSymbol(remainder) + solution;
number = number / convert;
if (number > convert)
solution = Division(number, convert, solution);
else
solution = ConvertToSymbol(number) + solution;
return solution;
}
public static string ConvertToSymbol(int remainder)
{
if (remainder < 10)
return remainder.ToString();
else
{
switch (remainder)
{
case 10: return "A"; break;
case 11: return "B"; break;
case 12: return "C"; break;
case 13: return "D"; break;
case 14: return "E"; break;
case 15: return "F"; break;
}
}
return string.Empty;
}
public string ConvertToBaseNumber(int value, int n)
{
if (n == 2) return IntToString(value, new [] {'0', '1'});
if (n == 16)
return IntToString(value,
new[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'});
if (n == 26)
return IntToString(value, Enumerable.Range('A', 26).Select(x => (char) x).ToArray());
if (n == 60)
return IntToString(value,
new[]
{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c',
'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z'
});
return string.Empty;
}
public string IntToString(int value, char[] bases)
{
var result = string.Empty;
var targeted = bases.Length;
do
{
result = bases[value%targeted] + result;
value /= targeted;
} while (value > 0);
return result;
}
}
}
파이썬으로 풀어봤습니다.
# num -> 바꿀 숫자, t -> 진수 타입(2, 8, 16 등)
def transNum(num, t):
tNum = ''
# 정수형태의 최소값이 나올 때까지 진행
while 1 <= num:
modNum = num % t
if 9 < modNum: # 나머지가 9자리를 초과할 경우 캐릭터형태로 변환
tNum = str(unichr(ord('a') + modNum - 10)) + tNum
else:
tNum = str(modNum) + tNum
num = num / t
return tNum
def baseN(num,b,numerals="0123456789abcdefghijklmnopqrstuvwxyz"):
return ((num == 0) and numerals[0]) or (baseN(num // b, b, numerals).lstrip(numerals[0]) + numerals[num % b])
package which_system;
import java.util.Scanner;
public class Secret {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("Input number in decimal system :"); //수를 10진법으로 입력하세요
int input=in.nextInt();
System.out.println("Into which number system? :"); //몇진법으로 나타낼 건가요?
int system=in.nextInt();
int cipher=1, a,i;
for(a=system; input>=a; a*=system, cipher++); //자릿수 계산. cipher=자릿수
int[] result=new int[cipher]; //결과값 배열로 만들기
//System.out.println("cipher: "+cipher); //자릿수 출력시
for(i=0; input>=0 && cipher>i; i++){ //진법에 맞는 결과값 계산
result[i]=(input%system);
input/=system;
}
System.out.println("Result in "+system+" system :"); //진법에 맞는 결과값은
for(i=cipher-1; i>=0; i--){
if(result[i]<10){
System.out.print(result[i]); //결과값 나타내기
}
else System.out.print((char)(result[i]+55)); //10이상일 경우 알파벳으로 변환
}
}
}
#coding: CP949
k=int(input('변환하려는 수를 입력하여라:'))
n=int(input('몇진수로 표현하려는가(1이상 16이하)?:'))
table={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,
10:'A', 11:'B',12:'C',13:'D',14:'E',15:'F'} # n이 11~16일 경우 table 사용.
data=[]
if n <=10:
while k !=0:
p=divmod(k,n)[1]
data.append(p)
k=divmod(k,n)[0]
data.reverse()
result=""
for i in data:
result+=str(i)
print(result)
elif n>10 and n<=16:
while k != 0:
p=divmod(k,n)[1]
data.append(table[p])
k=divmod(k,n)[0]
data.reverse()
result=""
for i in data:
result+=str(i)
print(result)
else:
print('잘못된 입력입니다.')
파이썬 3.4
저처럼 for i in range(0, len(data))를 를 하는 대신 for i in data를 쓰면 간결하군요. divmod함수도 배워갑니다.
-
최승호,
2016/07/14 18:44
num_sys <- function(x,n){
res <- c()
while(x != 0){
res <- c(res, x %% n)
x <- x %/% n
}
return(rev(res))
}
num_sys(233,2)
num_sys(233,8)
num_sys(233,16)
자바로 간단히 풀어보았습니다
package java_test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 자바에서 제공되는 메서드가 아닌 사용자 정의 진법 변환 메서드를 만드는 예제입니다.10진수를 입력 받아 2진수, 8진수 16진수로 반환하는 프로그램 입니다.
*/
public class test_2 {
public static void main(String[] args) throws IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.println("구할 숫자를 입력하세요");
String value = in.readLine();
for(int i=2; i<=16; i++){
String strNum = toDeposition(Integer.parseInt(value), i);
System.out.println(value + "의 "+i+" 진법: "+ strNum + "<br>");
}
}
public static String toDeposition(int value, int i){
String returnString = "";
String temp = "";
while(value != 0){
// 나머지가 0~9 사이이면 캐릭터 값을 배열에 저장
if( (value % i) < 10 ) {
//문자열 우->좌로 배열
returnString = (value % i) + returnString;
//몫을 구함
value /= i;
}
// 나머지가 10 이상이면 해당하는 값의 알파벳을 저장
else {
int temp1 = (char)((value % i) + 55);
returnString = Integer.toString(temp1) + returnString;
}
}
return returnString;
}
}
결과]]] 구할 숫자를 입력하세요 233 233의 2 진법: 11101001
233의 3 진법: 22122
233의 4 진법: 3221
233의 5 진법: 1413
233의 6 진법: 1025
233의 7 진법: 452
233의 8 진법: 351
233의 9 진법: 278
233의 10 진법: 233
233의 11 진법: 1A2
233의 12 진법: 175
233의 13 진법: 14C
233의 14 진법: 129
233의 15 진법: 108
233의 16 진법: E9
public class SimpleDecimalConversion {
private String result = "";
private String[] tmp = {"A","B","C","D","E","F"};
public static void main(String[] args) {
SimpleDecimalConversion sdc = new SimpleDecimalConversion();
sdc.getRemainder(233, 2);
sdc.getRemainder(233, 8);
sdc.getRemainder(233, 16);
}
public void getRemainder(int t, int v) {
if (t == 0 || v == 0) {
return;
}
int mod = (t % v);
if (mod >= 10) {
result = tmp[mod%10] + result;
} else {
result = mod + result;
}
int tv = t/v;
if (tv >= v) {
getRemainder(tv,v);
} else {
if (tv >= 10) {
System.out.println(tmp[tv%10]+result);
} else {
System.out.println(tv+result);
}
result = "";
}
}
}
간단하게 c++로 플어봤습니다.
풀이
int main(){
int input,i=0,div,res;
int a[1000];
printf("\n원하는 10진수를 입력하세요 : ");
scanf("%d",&input);
div=input/2;
res=input%2;
a[i]=res;//처음은 input받아서 2로 나눈 나머지값을 a[0]에 넣는다.
printf("\n입력하신 %d의 8진수 값: %#o",input,input);//8진수값 출력 oXXX형태로..
printf("\n입력하신 %d의 16진수 값: %#x",input,input);//16진수값 출력 oxXXX형태로..
while(1){
if(div==0) break;
else {
i++;
res=div%2;
div=div/2;
a[i]=res; }
}//a[1]부터 계속 나머지값 입력, 단2로 나눈 몫이 0될때까지..
printf("\n입력하신 %d의 2진수 값: ",input);
for(i;i>=0;i--){
printf("%d",a[i]);
}//a[i]부터 a[0]까지 역순으로 프린터..
printf("\n");
return 0;
}
Objective c로 풀었습니다. 좀 지저분해 보이긴 하네요..
- (NSString *)ScaleChange:(int)n Value:(int)v
{
if(n > 1 && n < 17)
{
//초기화 작업
int scalesize = n;
int value = v;
int remain = 0;
result = [[NSMutableString alloc] init];
while(value > scalesize)
{
remain = value % scalesize;
value = value / scalesize;
//나머지가 10 이상일 경우
if(remain >= 10)
{
tempstr = [NSString stringWithFormat:@"%c", remain+55];
NSLog(@"%@", tempstr);
}else{
tempstr = [NSString stringWithFormat:@"%d", remain];
}
[result insertString:tempstr atIndex:0];
};
//마지막 나머지 값을 넣어줌
if(value >= 10)
{
tempstr = [NSString stringWithFormat:@"%c", value+55];
NSLog(@"%@", tempstr);
}else{
tempstr = [NSString stringWithFormat:@"%d", value];
}
[result insertString:tempstr atIndex:1];
return result;
}else{
return @"2~16사이의 숫자를 입력해주세요";
}
};
자바입니다~ LinkedList를 스택으로 사용했습니다.
package my_test;
import java.util.LinkedList;
public class T {
public static void main(String[] args) {
System.out.println(change(233,2));
System.out.println(change(233,8));
System.out.println(change(233,16));
}
/**
* 진수 변환
* @param num 해당 10진수
* @param su 진수
* @return 변환값
*/
public static String change(int num,int su){
LinkedList stack= new LinkedList();//스택으로 사용
String result="";
char c;
int n=num;
while(n>0){
if(n%su>9){//나머지가 10 이상일때(즉 11진수 이상일때) 문자열 배당
stack.add((char)(n%su+55));
}else{// 그외는 나머지 숫자값 넣기
stack.add(n%su);
}
n=n/su;
}
//스택에서 값 추출
while(!stack.isEmpty()){
result+=stack.pollLast();
}
if(result.equals("")) result="0";//입력수가 0일때는 결과값 0 배당
result=+num+"--->"+result;
return result;
}
}
파이썬 3.4 입니다.
def num_conv(num, sys):
result = ''
rem_str_list = ['A','B','C','D','E','F','G']
while num > 0:
num, rem = divmod(num, sys)
if rem < 10:
rem_str = str(rem)
else:
rem_adj = rem - 10
rem_str = rem_str_list[rem_adj]
result = rem_str + result
print(result)
C로 풀어보았습니다.
#include <stdio.h>
int find_digit (int *digit_pnt, int value, int n) {
if(value==0) {
return 0;
}
else {
(*digit_pnt)++;
return find_digit(digit_pnt, value/n, n);
}
}
int convert_value (int *top_pnt, int *result_stack, int value, int n) {
if(value==0) {
return 0;
}
else {
result_stack[(*top_pnt)] = value%n;
(*top_pnt)++;
return convert_value(top_pnt, result_stack, value/n, n);
}
}
int main() {
int option;
int value, n, i;
int top;
int digit;
int *result_stack;
while(1) {
do{
printf("1:프로그램 (재)실행, 2:프로그램 종료 :");
scanf("%d", &option);
}while(option!=1 && option!=2);
switch(option){
case 1:
top=0;
digit=1;
do{
printf("변환할 양의 정수를 입력 : ");
scanf("%d", &value);
}while(value<=0);
do{
printf("(n)진법 입력(2<=n<=16) : ");
scanf("%d", &n);
}while(n<2 || n>16);
find_digit(&digit, value, n);
result_stack = (int*)malloc(sizeof(int)*digit);
convert_value(&top, result_stack, value, n);
for(i=(top-1);i>=0;i--){
printf("%x", result_stack[i]);
}
printf("\n");
break;
case 2:
return 0;
}
}
}
c++입니다.
#include <iostream>
long transform(int, int);
using namespace std;
int main(int argc, const char * argv[]) {
// insert code here...
cout<<transform(123, 2)<<endl;
cout<<transform(123, 8)<<endl;
cout<<transform(123, 16)<<endl;
return 0;
}
long transform(int number, int n) {
if(n < 2 || n > 16) return 0;
int result = 0;
number*=n;
for(int count = 1; number/=n; count*=10) result += (number%n)*count;
return result;
}
결과
1111011
173
81
Program ended with exit code: 0
stack = []
hoho = "ABCDEF"
ans = ""
def transformer(m,n):
global stack
global hoho
global ans
if m%n == 0:
stack.append(0)
else:
if m%n < 10:
stack.append(m%n)
else:
stack.append(hoho[(m%n)-10])
if m/n >= n:
transformer(m/n,n)
else:
if m/n <= 10:
stack.append(m/n)
else:
stack.append(hoho[(m/n)-10])
for i in range(len(stack)-1,-1,-1):
ans += str(stack[i])
clojure
(ns base.core)
(def NUM_DIC
(->> "0123456789ABCDEF"
(map-indexed vector)
(into {})))
(defn- _base10->n
([num base]
(_base10->n num base '()))
([num base acc]
(let [q (quot num base)
r (rem num base)]
(if (zero? q)
(conj acc r)
(recur q base (conj acc r))))))
(defn base10->n
[num base]
(->> (_base10->n num base)
(map #(NUM_DIC %))
(apply str)))
(base10->n 233 2)
;=> "11101001"
(base10->n 233 8)
;=> "351"
(base10->n 233 16)
;=> "E9"
C로 풀어보았습니다.
#include <stdio.h>
void convert( int, int );
int main(int argc, char ** argv[])
{
// 인자를 제대로 입력하지 않은 경우 사용법을 출력하고 종료한다.
if( argc < 3 )
{
printf("usage : convert decimal n(진법)\n");
return 0;
}
if( atoi(argv[2]) > 16 || atoi(argv[2]) < 2 )
{
printf("2 ~ 16진법을 입력해주세요\n");
return 0;
}
int decimal = atoi(argv[1]);
printf("10진수 : %d\n", decimal);
printf("%d진수 : ", atoi(argv[2]) );
convert( decimal, atoi(argv[2]) );
return 0;
}
// decimal을 n진수로 변환하여 출력한다.
void convert(int decimal, int n)
{
int remain; /* 각 자리별 나머지 */
int idx = 0; /* 변환된 문자가 저장될 배열의 인덱스 */
char result[512]; /* 변환된 문자열이 저장될 배열 */
int i;
do
{
// n 으로 나눈 나머지를 구한다.
remain = decimal % n;
// Step 1. 나머지가 9보다 크면 'A'부터 시작한다.
if( remain > 9 )
{
remain -= 10;
remain += 'A';
}
// Step 2. 나머지가 10보다 작으면 '0'부터 시작한다.
else
remain += '0';
// 각 자리의 나머지를 배열에 저장한다.
result[idx++] = remain;
// 몫을 취한다.
decimal /= n;
} while( decimal > 0 ); /*decimal(몫)이 0이 될 때 까지 반복 */
// 배열을 역순으로 출력한다.
for(i = idx; i >= 0; i--)
printf("%c", result[i]);
}
public class DecimalConverterMain {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(convertDecimal(233, 2));
System.out.println(convertDecimal(233, 8));
System.out.println(convertDecimal(233, 16));
}
private static String convertDecimal(long from, long solution) {
// TODO Auto-generated method stub
String result = "";
// System.out.println(from + "," + solution);
if (from >= solution) {
long remain = from % solution;
// System.out.println(from + "%" + solution + ":" + remain);
result = String.valueOf(remain);
// System.out.println("result : " + result);
return convertDecimal(from / solution, solution) + result;
}
else {
if (solution <= 10) {
result = result + String.valueOf(from);
}
else {
switch ((int)from) {
case 10: result = result + "A"; break;
case 11: result = result + "B"; break;
case 12: result = result + "C"; break;
case 13: result = result + "D"; break;
case 14: result = result + "E"; break;
case 15: result = result + "F"; break;
}
}
}
return result;
}
}
메서드 이름이 별로긴 한데 x진수에 해당하는 영어를 잘몰라서 ㅜㅜ
class Fixnum
CHARS_FOR_TRANS = "0123456789ABCDEF"
def trans_by(n)
string, number = "", self
loop do
string.prepend CHARS_FOR_TRANS[number % n]
number /= n
break if number.zero?
end
string
end
end
p 233.trans_by(16)
파이썬으로 풀어보았습니다.
def convert(num, base=2):
assert base > 1 and base < 17
digits = "0123456789ABCDEF"
s = []
while num > 0:
s.append(digits[num % base])
num = num // base
return "".join(s[::-1]) + "(%d)"%base
print convert(254, 16)
Scala
def convert(input: Int, n: Int): String = {
assert(n >= 2 && n <= 16)
val N = "0123456789ABCDEF"
def fn(input: Int, result: List[Char]): List[Char] = {
if(input == 0) {
result
} else {
fn(input / n, N(input % n) :: result)
}
}
fn(input, Nil).mkString
}
(2 to 16).foreach { n =>
println(s"$n 진수 : " + convert(233, n))
}
Perl
use integer;
sub conv{
my ($n,$b)=@_;
my @a=split(//,"0123456789ABCDEF");
my $r="";
while($n>0){
$r.=$a[$n-(($n/$b)*$b)];
$n/=$b;
}
$r= reverse $r;
return $r
}
python 3.4
def convert(n, a = 2):
#16 진수 까지만 변환하기 위한 체크
if(a > 16):
return '16진수 이상은 계산할 수 없습니다.'
else:
#몫 과 나머지를 가지고 오기 위한 함수
x,y = divmod(n,a)
#재귀호출 조건 체크
result = (convert(x, a)) if (n >= a) else ''
# 9가 넘어가는 숫자는 55를 더하여 아스키문자로 반환
return result + (str(y) if y < 10 else chr(y+55))
print(convert(233,2))
print(convert(233,8))
print(convert(233,16))
print(convert(233,32))
Scala로 풀었습니다.
def convert(n:Int, base:Int):String = {
assert (base >= 2 && base <= 16)
def stack(n:Int):Array[Int] = {
if(n < base) Array(n)
else stack(n / base) :+ (n % base)
}
stack(n).map(i => if (i > 10) ('A' + i - 10).toChar.toString else i).mkString
}
convert(233,2) //11101001
convert(233,8) //351
convert(233,16) //E9
coding by python beginner
import math
def convert( decimal, n ):
rs = []
while decimal > 0:
t0 = decimal % n
if t0 > 9: t0 =['A','B','C','D','E','F'][t0 - 10]
rs.append( str( t0 ) )
decimal = math.floor( decimal / n );
rs.reverse()
print( ''.join(rs) );
convert(233, 2)
convert(233, 8)
convert(233, 16)
Python 2.7입니다.
n = 16
num_in_decimal = 233
dic = dict(zip(range(0,16),range(0,10)+['a','b','c','d','e']))
result = []
while num_in_decimal > n:
result.append(dic[num_in_decimal%n])
num_in_decimal = num_in_decimal/n
result.append(dic[num_in_decimal])
result.reverse()
print reduce(lambda x,y: str(x)+str(y),result)
sn = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F')
re=''
n=600
num=16
mok=int(n/num)
nmg=int(n%num)
re = sn[nmg]
while(mok != 0):
n=mok
mok=int(n/num)
nmg=int(n%num)
re = sn[nmg] + ' ' + re
print(re)
Using python layout을 위해 코드의 간결성을 버렸군요...
#!/usr/bin/pytohn
# -*- coding: utf-8 -*-
def convN(s,m):
d = []
S = s
pat = "012345789ABCDEF"
while True:
s,a = divmod(s,m)
d.append(pat[a])
if s == 0:
break
d = d[::-1]
print str(S)+" =",
print "".join(d)+"("+str(m)+")"
convN(110,16)
python입니다
mox=100
a=2
ans=[]
while mox!=0:
mox,remind=mox/a,mox%a
ans.append(remind)
print ans[::-1]
NASM으로 작성해봤습니다. 입력 및 출력 모듈을 사용하기 위해 io.inc를 포함합니다.
%include "io.inc"
section .bss
_str_buffer resb 256
section .text
global _main
_main:
mov ebp, esp
enter 0, 0
pusha
GET_DEC 4, eax ; 입력 매크로: 4bytes 크기만큼 입력받아 eax에 삽입
GET_DEC 4, ebx ; 입력 매크로: 4bytes 크기만큼 입력받아 ebx에 삽입
mov ecx, _str_buffer
call _trans_num
mov ebx, eax
mov eax, _str_buffer
call _rotate_buffer
PRINT_STRING _str_buffer ; 출력 매크로: _str_buffer의 각 원소를 순회하며 '\0'문자 발견 이전까지 출력
popa
xor eax, eax
leave
ret
; summary ----------------------
; 10진수 숫자를 n진수 문자열로 변환.
; 출력 순서가 반대로 되어있기 때문에
; 각 원소 n, length - n에 대해서
; swap이 필요하다.
; ------------------------------
; input ------------------------
; eax: 10진수 변환 대상(원본 숫자)
; ebx: 변환 시킬 진수
; ecx: 변환된 값을 기록할 버퍼
; ------------------------------
; output -----------------------
; eax: 변환된 버퍼의 길이
; ------------------------------
_trans_num:
push ecx
__tn_loop_begin:
xor edx, edx
; eax / ebx의 결과
; eax: 몫
; edx: 나머지
; 가 기록된다.
div ebx
; 10이상의 숫자에 대해선 문자로 표현해야 하므로 7만큼 추가로 더해준다.
cmp edx, 10
jae __tn_conv_char
__tn_continue_loop:
; 48만큼 더해 ASCII코드의 숫자로 변환한다.
add dl, 30h
mov [ecx], dl
inc ecx
cmp eax, 0
jne __tn_loop_begin
;jmp __tn_loop_end
__tn_loop_end:
; 문자열이므로 맨 마지막에 '\0'를 기록한다.
xor eax, eax
mov [ecx], al
mov eax, ecx
pop ebx
sub eax, ebx
ret
__tn_conv_char:
add dl, 7h
jmp __tn_continue_loop
; summary ----------------------
; 버퍼의 각 n, length - n원소를
; swap시킨다.
; ------------------------------
; input ------------------------
; eax: 대상 버퍼
; ebx: 버퍼의 길이
; ------------------------------
_rotate_buffer:
cmp ebx, 1
jbe __rb_loop_end
mov ecx, ebx
mov ebx, eax
add ebx, ecx
dec ebx
__rb_loop_begin:
movzx ecx, byte[eax]
movzx edx, byte[ebx]
cmp ecx, edx
je __rb_loop_iterate
mov [eax], dl
mov [ebx], cl
__rb_loop_iterate:
inc eax
dec ebx
cmp eax, ebx
jnae __rb_loop_begin
;jmp __rb_loop_end
__rb_loop_end:
ret
Sub main()
Dim n As Integer = Val(Console.ReadLine)
Dim d As String = "0123456789ABCDEF"
Dim num As Integer = 233
Dim r As String = ""
While num > n - 1
Dim a As Integer = num Mod n
r &= d(a)
num \= n
End While
r &= d(num)
Console.WriteLine("Result: " & StrReverse(r))
Console.ReadLine()
End Sub
$num = $_GET['n'];
for($i=0;$num>0;$i++){
$result[$i] = $num%2;
$num = $num/2;
}
for($j=$i-1;$j>=0; $j--)
{
echo $result[$j];
}
꼼수.ㅎ{.cs}
static void Main(string[] args)
{
Console.WriteLine("몇진수로 변환할것인지 적으시요.");
int n = int.Parse(Console.ReadLine());
Console.WriteLine("변환할 값을 적으시요.");
int a = int.Parse(Console.ReadLine());
string value = Convert.ToString(a, n);
Console.WriteLine("{0} 를 {1} 진법으로 변환하여 {2}", a, n, value);
}
static void exce68()
{
Scanner scan = new Scanner(System.in);
int dec = scan.nextInt(), n = scan.nextInt();
int test = dec, cnt = 0;
String sample = "0123456789ABCDEF";
char[] output;
while (test > 0)
{
cnt++;
test /= n;
}
output = new char[cnt];
while (dec > 0)
{
output[(cnt--) - 1] = sample.charAt(dec % n);
dec /= n;
}
for(int i=0;i<output.length;i++)
System.out.printf("%c",output[i]);
}
간단히 만들었습니다.
char str[17] = "0123456789ABCDEF";
void myconv(int in, int n)
{
int q = in / n;
int r = in % n;
if(q == 0)
{
printf("%c",str[r]);
return;
}
myconv(q,n);
printf("%c",str[r]);
};
def convert(num,n):
ret=""
while num>0:
m = num%n
if m>9:m=chr(65+m-10)
ret+=str(m)
num=num/n
return ret[-1::-1]
def convert2(num,n):
if num<=0: return ''
m = num%n
ret=str(m)if m<10 else chr(65+m-10)
return convert2(num/n,n)+ret
print convert2(233,16)
Javascript로풀었습니다.
var num = 233;
var n = 16;
var mystack = new Array(50);
var mytop = -1;
var Digit = "0123456789ABCDEF";
while( parseInt(num / n) > 0)
{
mystack[++mytop] = parseInt(num % n);
num = parseInt(num / n);
}
if(num != 0)
mystack[++mytop] = num;
var answer = "";
for(var i=mytop; i>=0; i--)
answer += Digit[mystack[i]];
console.log(answer);
- python으로 작성하였습니다.
def convertNum(s,k):
outS=[]
while(True):
outS.append(s%k)
s=s//k
if s==0:
break
return outS
def displayNum(l):
hexC="ABCDEF"
for tn in l[-1::-1]:
if tn>=10:
print hexC[tn-10],
else:
print tn,
print
displayNum(convertNum(233,2))
displayNum(convertNum(233,8))
displayNum(convertNum(233,16))
자바로 진법사 숫자를 입력받아서 나오게 만들어 보았습니다
import java.util.Scanner;
public class test21 {
static String[] arr = new String[10];
static String[] arr1 = {"A","B","C","D","E","F"};
static int mok=0, nmg=0;
static int i=0;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
jin(a,b); //2,233
for(int j=i-1; j>=0; j--){ //i=8
System.out.print(""+arr[j]);
}
}
public static void jin(int jinsu, int num){
while(num>0){
nmg = num%jinsu; //2
num = num/jinsu;
if(nmg>=10){
arr[i] = arr1[nmg%10];
}
else arr[i] = Integer.toString(nmg);
i++;
}
}
}
파이썬3.4입니다. 재귀함수로 풀었지만 길가의풀님이 재귀함수를 알기도 쉽고, 이해하기도 쉽게 풀었네요
CODE = '0123456789ABCDEF'
def f(src, n, li):
q, r = divmod(src, n)
if q == 0:
li += [CODE[r]]
li = li[::-1]
print(''.join(li))
return
f(q, n, li + [CODE[r]])
f(233, 2, [])
f(233, 8, [])
f(233, 16, [])
Ruby
rest = "0123456789ABCDEF"
to_n = ->num,f { num<f ? rest[num] : to_n[num/f,f]+rest[num%f] }
Test
expect(to_n[233,2]).to eq "11101001"
expect(to_n[233,8]).to eq "351"
expect(to_n[233,16]).to eq "E9"
#파이썬3.4.2
def do(n,b):
r = ''
let = '0123456789ABCDEF'
while n//b != 0:
r += str(let[n%b])
n //= b
return (r + str(let[n%b]))[::-1]
n,b = map(int,input().split())
print(do(n,b))
Python 3.4.4
def essence_recurrent(number, esse):
def recurrent(n, esse, rest = []):
esse_map = "0123456789ABCDEF"
if n == 0:
return "".join(rest)
q, r = divmod(n, esse)
rest.insert(0, esse_map[r] if esse > 10 else str(r))
return recurrent(q, esse, rest)
return number, recurrent(number, esse)
print(essence_recurrent(233, 2))
print(essence_recurrent(233, 8))
print(essence_recurrent(233, 16))
while __name__ == '__main__':
i, n = list(map(int, input('>>>').split())); res = []
while 1:
res += list(x if x<10 else chr(ord('A')+x-10) for x in [i%n])
i //= n
if i == 0: break
print(''.join(str(x) for x in res[::-1]))
파이썬 3.5.1
def getBinaryValue(val, n):
result = ""
text = "0123456789ABCDEF"
while True:
result = str(text[val % n]) + result
val /= n
if val == 0 : break
return result
if __name__ == '__main__':
print(getBinaryValue(233, 16))
python 2.7
자바로 풀어보았습니다 ...
import java.util.Scanner;
public class _10진수를n진수로변환하기 {
public static char[] table = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'};
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int value = scan.nextInt();
int n = scan.nextInt();
if(!(n >=2 && n <= 16)){
System.err.println("올바른 n값을 입력하세요.");
System.exit(0);
}
StringBuffer sb = new StringBuffer();
while(value > 0) {
sb.insert(0, table[value%n]);
value /= n;
}
System.out.println(sb);
}
}
for문, 딕셔너리,클래스를 이용해서 풀었습니다.
dic={10:'A', 11:'B', 12:'C', 13:'D', 14:'E', 15:'F'}
class Modulo:
def __init__(self, jinsu):
self.m=jinsu
def convert(self, n):
converted=[]
while n!=0:
converted.append(n%self.m)
n=n//self.m
converted.reverse()
result=''
for k in converted:
a=str(k)
if k>=10:
a=dic[k]
result+=a
print('%s(%s)' %(result, self.m))
#예제
bina=Modulo(2)
octa=Modulo(8)
hexa=Modulo(16)
bina.convert(233)
octa.convert(233)
hexa.convert(233)
자바 로 코딩
public static void main(String[] args){
try{
int jinsu = 0;
int number = 0;
String resultNumber = "";
Scanner sc = new Scanner(System.in);
System.out.print("진수 선택 :: ==> ");
jinsu = sc.nextInt();
System.out.print("숫자 입력 :: ==> ");
number = sc.nextInt();
do{
if( jinsu == 16 ){
switch ( number%jinsu ) {
case 10 :
resultNumber += "A";
break;
case 11 :
resultNumber += "B";
break;
case 12 :
resultNumber += "C";
break;
case 13 :
resultNumber += "D";
break;
case 14 :
resultNumber += "E";
break;
case 15 :
resultNumber += "F";
break;
default:
resultNumber += String.valueOf( (number%jinsu) );
break;
}
number = (number/jinsu);
}else{
resultNumber += String.valueOf( (number%jinsu) );
number = (number/jinsu);
}
}while( number > 0 );
System.out.println("resultNumber :: ==> " + resultNumber );
System.out.println("resultNumber reverse:: ==> " + new StringBuffer(resultNumber).reverse() );
}catch(Exception e){
e.printStackTrace();
}
}
자바로 코딩
- 나누는 수는 나머지 보다 항상 큼
- char 배열을 16 까지 선언
- table[number%jinsu] 여기가 핵심.
public static void main(String[] args){
char[] table = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
try{
int jinsu = 0;
int number = 0;
String resultNumber = "";
Scanner sc = new Scanner(System.in);
System.out.print("진수 선택 :: ==> ");
jinsu = sc.nextInt();
System.out.print("숫자 입력 :: ==> ");
number = sc.nextInt();
while( number > 0 ){
System.out.println("table :: ==> " + number%jinsu );
System.out.println( table[number%jinsu] );
number /= jinsu;
}
}catch (Exception e) {
e.printStackTrace();
}
}
Python 으로 풀어봤습니다...
def Dec_to_N(number):
dict_A = {10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
ret_val = []
data = 233
while data != 0:
if (data % number < 10):
ret_val.append(str(data % number))
else:
ret_val.append(dict_A[data % number])
data = data / number
ret_val.reverse()
answer = "".join(ret_val)
return answer
print (Dec_to_N(2))
print (Dec_to_N(8))
print (Dec_to_N(16))
private static void convert(int n, int var) {
String str ="";
String asc = "ABCDEF";
int ceil=0;
if(n<10){
while (var > 0) {
str += var % n + "";
var /= n;
}
for (int i = str.length() - 1; i >= 0; i--) {
System.out.print(str.charAt(i));
}
}
else{//10진수이상이면
while (var > 0) {
if(var>n)//값이 진수보다 크면{
str+=asc.charAt(var/n-10);
ceil = var%n;
var/=n;
}
if(var<n){//나눈값이 진수보다 작을경우
if(ceil<10){//나머지가 10미만이면
str+=ceil;
var/=n;
}
else{//몫이 10이상이면
str+=asc.charAt(ceil-10);
var/=n;
}
}
}//while
for (int i = 0; i <str.length(); i++) {
System.out.print(str.charAt(i));
}
}
public static void main(String[] args) {
int n=0,var=0;
Scanner sc = new Scanner(System.in);
System.out.print("변환할 진수 입력");
n=sc.nextInt();
System.out.print("값 입력");
var=sc.nextInt();
convert(n,var);
}
class binaly{
int num = 255;
int a = num;
String bi="";
binaly(){
for(int i = 2; i<17; i++){
while(a>0){
if(a%i<10) bi = ((a%i)+"") + bi;
else bi = (char)((a%i)+55) + bi;
a=a/i;
}
a=num;
System.out.println(bi);
bi="";
}
}
}
public class lv1_05_01 {
public static void main(String[] args){
binaly b = new binaly();
}
}
자바입니다.
python
a=[]
n=233
b=int(input("몇 진수로 변환?"))
while(n>0):
k=n%b
if(k>9):
a.append(chr(k+55))
else: a.append(k)
n=int(n/b)
for i in range(len(a)):
print(a[len(a)-1-i],end="")
def digitChanger(number, digit):
result = []
digitString="0123456789ABCDEF"
while True:
dev, rem = divmod(number,digit)
result.append(digitString[rem])
number = dev
if dev == 0:
break;
result.reverse() # Stack에 들어간 순서를 거꾸로 돌림
return result
print(digitChanger(233,2))
print(digitChanger(233,8))
print(digitChanger(233,16))
['1', '1', '1', '0', '1', '0', '0', '1'] ['3', '5', '1'] ['E', '9']
16진수 문자를 String을 이용해서 변환하는 방법은 다른 분이 작성한 코드를 참고했습니다.(기발하네요!)
def ten_to_n(num, n):
temp = ''
change_num_to_char = {10: "A", 11: "B", 12: "C", 13: "D", 14: "E", 15: "F"}
while 1 <= num:
if 9 < num % n:
temp += change_num_to_char[num%n]
num = num // n
else:
temp += str(num % n)
num = num // n
return temp[::-1]
ten_to_n(233, 16)
#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <stdio.h>
#define max 256
int main(void) {
int ascii[16] = { 48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70 };
//0~9,,A~F
int rst[max] = { 0, };
int m, n, i=0;
printf("10진수 수 입력 = ");
scanf("%d", &m);
printf("바꿀 n진수 입력 = ");
scanf("%d", &n);
printf("10진수 : %d ------> %d진수 : ", m, n);
while (m) {
rst[i++] = ascii[m%n];
m = m / n;
}
for (i; i > 0; i--) {
printf("%c", rst[i-1]);
}
printf("\n");
system("pause");
}
#include<iostream>
#include<stdio.h>
using namespace std;
int main()
{
int div, num;
int arr[100];
int temp;
int i;
cout << "10진수가 아닌 다른 진수로 나타내고 싶은 숫자를 입력하세요 : ";
cin >> num;
temp = num;
cout << "2~16사이에 위의 수를 10진수가 아닌 다른 진수로 나타내고 싶은 것을 쓰시오 : ";
cin >> div;
for (i = 0;i < 100;i++)
arr[i] = 20;
if (div < 10)
{
while (temp >= div)
{
arr[0] = temp % div;
for (i = 1;temp>=1;i++)
{
temp = temp / div;
arr[i] = temp % div;
}
}
cout << num << "을 " << div << "진수로 나타낸 결과는 ";
for ( i = 99 ; i>=0 ; i-- )
{
if (arr[i] == 20)
;
else
{
cout << arr[i];
}
}
}
else if (div == 10)
{
cout << num;
}
else if (div > 10 && div <= 16)
{
int arr2[200];
for (int i = 0;i < 200;i++)
arr2[i] = 20;
while (temp >= div)
{
for (i = 0;i<=temp;i++)
{
arr2[i] = temp%div;
temp = temp / div;
}
// arr[i] = temp%div;
}
cout << num << "을 " << div << "진수로 나타낸 결과는 ";
for (i = 199;i >= 0;i--)
{
if (arr2[i] != 20)
{//cout << arr2[i];
if (arr2[i] >= 10)
{
if (arr2[i] == 10)
cout << 'a';
else if (arr2[i] == 11)
cout << 'b';
else if (arr2[i] == 12)
cout << 'c';
else if (arr2[i] == 13)
cout << 'd';
else if (arr2[i] == 14)
cout << 'e';
else if (arr2[i] == 15)
cout << 'f';
}
else
cout << arr2[i];
}
}
cout << endl;
}
cout << endl;
}
파이썬
def trans(dec, n):
tr = "0123456789ABCDEF"
nlist = []
nstr =""
while dec > 0:
dec, rem = divmod(dec, n)
nlist.append(tr[rem])
nlist.reverse()
for i in nlist:
nstr += str(i)
return nstr
print(trans(233, 2))
print(trans(233, 8))
print(trans(233, 16))
Python코드입니다.
while문을 이용해서 ans에 문자열을 하나씩 추가한다음, 역순으로 읽어내는 방식을 이용했습니다.
'''나눗셈을 이용한 진수 변환'''
n = input("변환할 숫자: ")
m = int(input("진법: "))
tmp = int(n)
ans = ""
table = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
while tmp > 0:
tmp, a = divmod(tmp,m)
ans += table[a]
print("10진수 {}는 {}진수로 변환하면 {:s}입니다.".format(n,m,ans[::-1]))
파이썬초보입니다. 많은 피드백 부탁드립니다!!
안녕하세요. C++로 구현했습니다.
스택구조를 보고 재귀함수 사용했습니다.
#include<iostream>
#include<string>
using namespace std;
void cvtNum(int num, int n)
{
int rem = num%n;
num /= n;
if(num != 0)
cvtNum(num,n);
if(rem >9)
cout<<(char)(rem+55);
else
cout<<rem;
}
void main()
{
cout<<"Hello Stranger??"<<endl;
int num =0;
int n =0;
cout<<"숫자를 입력하시오."<<endl;
cin>>num;
cout<<"n을 입력하시오."<<endl;
cin>>n;
cvtNum(num,n);
}
def redix_conversion(num, radix):
if not 2 <= radix <= 16:
raise Exception("radix : 2 <= radix <= 16")
if not 0 <= num:
raise Exception("num : 0 <= num")
p = '0123456789ABCDEF'
r = []
n = num
while n != 0:
n, m = divmod(n, radix)
r.append(p[m])
r.reverse()
print("".join(r) or '0')
Python 3.5.2에서 작성하였습니다.
자바로 작성
public String changNumeralSystem(int digit, int ns){
String result = "";
while( digit > 0 ){
int rem = digit % ns;
digit = digit /ns;
switch(rem){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
result = Integer.toString(rem) + result;
break;
case 11:
result = "A" + result;
break;
case 12:
result = "B" + result;
break;
case 13:
result = "C" + result;
break;
case 14:
result = "D" + result;
break;
case 15:
result = "E" + result;
break;
}
}
return result;
}
파이썬3.5.2.로 작성했어요
num = int(input("임의의 숫자를 입력하세요="))
way = int(input("원하는 진법을 입력하세요="))
def A(n):
if n==1 : return num
return (A(n-1)-(A(n-1)%way))/way
i = 1
blank=[]
while 1:
if A(i) < 1:
blank.reverse()
result = ''.join(blank)
print(result+"("+str(way)+")")
break
else:
blank.append(str(int(A(i)%way)))
i += 1
def insertQue(que, num):
up10 = ['a','b','c','d','e','f']
if num > 9:
num -= 10
que.insert(0,up10[num])
else:
que.insert(0,num)
def ch10toN(num, n):
que = []
new_num = 0
while num > n:
num, new_num = divmod(num,n)
insertQue(que,new_num)
insertQue(que,num)
return que
print(ch10toN(233,2))
입력이 0인 경우만 따로 처리해줘야 하네요.
function format(base, n) {
if (base > 16) throw new Error();
var digits = "0123456789abcdefgh";
var result = [];
if (n == 0) return "0";
while (n > 0) {
result.unshift(digits[n % base]);
n = Math.floor(n / base);
}
return result.join("");
}
console.log(format(16, 256));
include
void print_num(int n, int num) { if (num == 0) return; else { print_num(n, (num/n)); if ((num%n) < 10) printf("%d", (num%n)); else printf("%c", 'A'+((num%n)-10)); } }
int main() { int n, num;
printf("Scale : ");
scanf("%d", &n);
if ((n < 2) || (n > 16)) {
printf("Error\n");
return 0;
}
printf("Number : ");
scanf("%d", &num);
print_num(n, num);
printf("\n");
return 0;
}
def change_number(num,step=2):
dict_ = {10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
tmp_list = list()
while num >= 1:
if num % step < 10:
tmp_list.append(num % step)
else:
tmp_list.append(dict_[(num % step)])
num = num//step
tmp_list.reverse()
for x in tmp_list:
print(x,end='')
print(' ',step,'진수')
change_number(233)
change_number(233,8)
change_number(233,16)
#### 2016.12.10 D-439 ####
class Division {
private int quotient;
private int remainder;
public Division(int quotient) {
this.quotient = quotient;
}
public int getQuotient() {
return quotient;
}
public int getRemainder() {
return remainder;
}
public void runDiv(int num, int divisor) {
this.quotient = num / divisor;
this.remainder = num % divisor;
}
}
public class NodalNumber {
public void printTransferNodalNumber(int num, int nodal) {
System.out.println(
nodal < 10 ? this.LessThanDecimal(num, nodal) : this.MoreThenDecimal(num, nodal)
);
}
public String LessThanDecimal(int num, int nodal) {
System.out.println("LessThanDecimal");
Division div = new Division(num);
StringBuffer resultNumber = new StringBuffer();
while(div.getQuotient() > nodal) {
div.runDiv(num, nodal);
resultNumber.append(div.getRemainder());
num = div.getQuotient();
}
resultNumber.append(div.getQuotient());
resultNumber.reverse().append("(").append(nodal).append(")");
return resultNumber.toString();
}
public String MoreThenDecimal(int num, int nodal) {
System.out.println("MoreThenDecimal");
Division div = new Division(num);
StringBuffer resultNumber = new StringBuffer();
String[] arr = {"A","B","C","D","E","F","G"};
while(div.getQuotient() > nodal) {
div.runDiv(num, nodal);
int remainder = div.getRemainder();
resultNumber.append(remainder < 10 ? remainder : arr[remainder % 10]);
num = div.getQuotient();
}
int quotient = div.getQuotient();
resultNumber.append(quotient < 10 ? quotient : arr[quotient % 10]);
resultNumber.reverse().append("(").append(nodal).append(")");
return resultNumber.toString();
}
public static void main(String[] args) {
new NodalNumber().printTransferNodalNumber(233, 16);
}
}
자바입니다.
num = 233
결과 : E9(16) 351(8) 11101001(2)
C(11) gcc -std=c11
#include <stdio.h>
#include <assert.h>
// n을 k진수로 변환, k범위[2, 16]
void convt(int n, int k);
int main(void)
{
int n, k;
while (scanf("%d %d", &n, &k) == 2)
{
assert(2 <= k && k <= 16);
convt(n, k);
putchar('\n');
}
return 0;
}
void convt(int n, int k)
{
static const char *code = "0123456789ABCDEF";
if (n / k == 0) ;
else convt(n / k, k);
putchar(code[n % k]);
}
public class test {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("변경하고 싶은 값과 변경하고 싶은 진수를 차례로 입력");
int number = scan.nextInt();
int jinsu = scan.nextInt();
System.out.println(changeJinsu(number,jinsu));
} // main end
public static String changeJinsu(int number, int jinsu) {
String strNumber = "";
while( (number+jinsu) > jinsu) { // 값보다 진수가 더 작을때 + 1번더
if(number % jinsu > 9) { // 나머지가 10 이상일 경우
char test = (char)(number % jinsu + 55); // char(문자)로 대체 (65부터 대문자 A)
strNumber = test + strNumber;
} else {
strNumber = (number % jinsu) + strNumber; // 10 미만일 경우 그대로 진행
}
number /= jinsu;
}
return strNumber;
} // changeJinsu end
} // test end
#include<stdio.h>
#include<windows.h>
#define MAX 10
int main()
{
int a,i,b=233,count=0,c[MAX];
printf("몇진수로 구하겠습니까?\n");
scanf("%d",&a);
while(1)
{
c[count]=b%a;
b=(int)b/a;
if(b==0) break;
count++;
}
for(i=0;i<=count;i++)
printf("%d",c[count-i]);
system("pause");
return 0;
}
#include<stdio.h>
#include<windows.h>
#define MAX 10
int main()
{
int a,i,b=233,count=0,c[MAX];
printf("몇진수로 구하겠습니까?\n");
scanf("%d",&a);
while(1)
{
c[count]=b%a;
b=(int)b/a;
if(b==0) break;
count++;
}
for(i=0;i<=count;i++)
printf("%d",c[count-i]);
system("pause");
return 0;
}
number=int(input('0<=숫자:')); system=int(input('2<=진법<=16:'))
result=[]; char="0123456789ABCDEF"
while 1==1:
result.insert(0,char[number%system])
if number<system: break
number//=system
print("".join(result))
// C++ 16 진수 이상을 지원합니다.. 단 대문자 알파벳 이후는 소문자 알파벳 등 아스키 코드로 변환.. 이런 저런 에러 처리는 생략..
int main()
{
int nValue = 0;
int nBit = 0;
cin >> nValue >> nBit;
int anBuff[ 10000 ] = { 0, };
int nData = nValue;
int nCount = 0;
while( nData > 0 )
{
anBuff[ nCount ] = ( nData % nBit );
nData /= nBit;
++nCount;
}
while( nCount > 0 )
{
--nCount;
if( 10 <= anBuff[ nCount ] )
{
cout << ( char )( 'A' + ( anBuff[ nCount ] - 10 ) );
}
else
{
cout << anBuff[ nCount ];
}
}
return 0;
}
Input Value : 233
Input Radix : 16
Output :
E9
계속하려면 아무 키나 누르십시오 . . .
스트링에 하나 씩 추가함으로써 역순 출력
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
int radix = 0;
int input = 0;
printf("Input Value : ");
scanf("%d", &input);
printf("Input Radix : ");
scanf("%d", &radix);
int sum = 0;
char out[10];
int i = 0;
while(input > 0) {
if(radix > 9) {
switch(input) {
case 10: out[i]='A'; break;
case 11: out[i]='B'; break;
case 12: out[i]='C'; break;
case 13: out[i]='D'; break;
case 14: out[i]='E'; break;
case 15: out[i]='F'; break;
default: out[i] = input%radix+48;
}
i++;
input = input / radix;
}
else {
out[i] = input%radix+48;
input = input / radix;
i++;
}
}
printf("Output : \n");
for(int j=i-1; j>=0;j--)
printf("%c", out[j]);
printf("\n");
}
def number(n,p):
alpha=['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']
result=""
while n>0:
result=alpha[n%p]+result
n=n//p
print(result)
자바 재귀함수 이용
public class Test458 {
static StringBuffer nNumber = new StringBuffer();
public static void main(String[] args) {
convert(233, 16);
System.out.println(nNumber.reverse());
}
private static void convert(int num, int n) {
if (num / n == 0 && num % n == 0) {
return;
}
if (num % n >= 10) {
switch (num % n) {
case 10: nNumber.append("A"); break;
case 11: nNumber.append("B"); break;
case 12: nNumber.append("C"); break;
case 13: nNumber.append("D"); break;
case 14: nNumber.append("E"); break;
case 15: nNumber.append("F"); break;
}
} else {
nNumber.append(num % n);
}
n10ton2(num / n, n);
}
}
/*
dev : peanutBro
date : 170218
content :
위 그림을 참조하여 라이브러리를 사용하지 말고 10진수를 n진수로 변환하는 프로그램을 작성하시오.. (단, n의 범위는 2 <= n <= 16)
예)
2진수로 변환 : 233(10) --> 11101001(2)
8진수로 변환 : 233(10) --> 351(8)
16진수로 변환 : 233(10) --> E9(16)
*/
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <iostream>
#include <string>
#include <stack>
using namespace std;
void viewTransNumber(int inputNumber, int formNumber);
int main(void)
{
int inputNumber = -1;
int inputFormNumber = -1;
cout << "숫자를 입력하세요 : ";
cin >> inputNumber;
cout << "진법을 입력하세요 : ";
cin >> inputFormNumber;
viewTransNumber(inputNumber, inputFormNumber);
return 0;
}
void viewTransNumber(int inputNumber, int formNumber)
{
stack<int> stack;
while (inputNumber != 0)
{
if (inputNumber % formNumber)
{
stack.push(1);
}
else
{
stack.push(0);
}
inputNumber /= formNumber;
}
while (!(stack.empty()))
{
cout << stack.top();
stack.pop();
}
cout << endl;
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Ndecimal {
static int t = 233;
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
String k[] = new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};
List<String> queue = new ArrayList();
while (true) {
int m = t / n;
int l = t % n;
t = m;
queue.add(k[l]);
if (m <= n) {
queue.add(k[m]);
break;
}
}
Collections.reverse(queue);
queue.stream().forEach(System.out::print);
}
}
-
python 3.5.2
-
재귀함수방식으로 풀었습니다.
def convert(n, base) :
T = '0123456789ABCDEF'
q, r = divmod(n, base)
if q == 0 :
return T[r]
else :
return convert(q, base) + T[r]
print(convert(233,2))
print(convert(233,8))
print(convert(233,16))
math 라이브러리의 floor 모듈 사용했는데, 문제가 될 지도 모르겠네요?! 다른 분들 코드 보고 많이 배워갑니다~^__^
from math import *
n = int(input('10진수로 숫자를 입력'))
conv_n = int(input('원하는 system은? (2 <= m <= 16)'))
changed = []
while n/conv_n > 0:
if n%conv_n < 10:
changed.insert(0, n%conv_n)
elif n%conv_n == 10:
changed.insert(0, 'A')
elif n%conv_n == 11:
changed.insert(0, 'B')
elif n%conv_n == 12:
changed.insert(0, 'C')
elif n%conv_n == 13:
changed.insert(0, 'D')
elif n%conv_n == 14:
changed.insert(0, 'E')
elif n%conv_n == 15:
changed.insert(0, 'F')
n = floor(n/conv_n)
for n in changed:
print(n,end='')
파이썬 3.5.3 연습용 코드입니다.
Rsum = ''
a = int(input("몇진수로 교환? : "))
def change2other(n):
global a
Qcompare = divmod(n,a)[0]
R = str(divmod(n,a)[1])
global Rsum
if R == '10':
R = 'A'
elif R == '11':
R = 'B'
elif R == '12':
R = 'C'
elif R == '13':
R = 'D'
elif R == '14':
R = 'E'
elif R == '15':
R = 'F'
Rsum = R + Rsum
if Qcompare == 0:
print(Rsum)
Rsum = ''
else:
change2other(Qcompare)
class Program
{
private static List<string> rList = new List<string>();
static void Main(string[] args)
{
int targetNum = 233;
int quintessence = 16;
string result = string.Empty;
Generator(targetNum, quintessence);
for (int i = rList.Count-1; i >= 0; i--)
{
result += rList[i].ToString();
}
Console.WriteLine(result);
Console.ReadLine();
}
private static void Generator(int targetNum, int quintessence)
{
int q = targetNum / quintessence;
int r = targetNum % quintessence;
string t = "0123456789ABCDEF";
rList.Add(t[r].ToString());
if(q != 0)
{
Generator(q, quintessence);
}
}
}
//8진수 까지만
include
include
using namespace std;
int main() { int n = 0; int count = 0; cout << "n을 입력하세요 "; cin >> n; int n2 = n;
//2진수
int arr[100];
for(;;)
{
arr[count] = n % 2;
n = n / 2;
count++;
if (n == 1)
{
arr[count] = n;
break;
}
}
int j = 0;
cout << "2진수 : ";
for (count ; count >= j;count--)
{
cout << arr[count] ;
}
cout << endl;
//8진수
if (n >= 8)
{
count = 0;
int arr2[100];
for (;;)
{
arr2[count] = n2 % 8;
n2 = n2 / 8;
count++;
if (1 <= n2 && n2<8)
{
arr2[count] = n2;
break;
}
}
j = 0;
cout << "8진수 : ";
for (count; count >= j; count--)
{
cout << arr2[count];
}
}
return 0;
}
스택을 이용해서 풀어봤습니다
#include <cstdio>
#include <stack>
using namespace std;
int main(){
int T;
scanf("%d",&T);
while(T--){
int N,M;
stack<int> s;
scanf("%d%d",&N,&M);
while(N!=0){
s.push(N%M);
N/=M;
}
while(!s.empty()){
if(M > 10 && s.top() >= 10) printf("%c",s.top()+55);
else printf("%d",s.top());
s.pop();
}
printf("\n");
}
}
package training;
import java.util.Scanner;
/*
* 위 그림을 참조하여 라이브러리를 사용하지 말고 10진수를 n진수로 변환하는 프로그램을 작성하시오.. (단, n의 범위는 2 <= n <= 16)
* 예)
*
* 233의 2 진법: 11101001
* 233의 3 진법: 22122
* 233의 4 진법: 3221
* 233의 5 진법: 1413
* 233의 6 진법: 1025
* 233의 7 진법: 452
* 233의 8 진법: 351
* 233의 9 진법: 278
* 233의 10 진법: 233
* 233의 11 진법: 1A2
* 233의 12 진법: 175
* 233의 13 진법: 14C
* 233의 14 진법: 129
* 233의 15 진법: 108
* 233의 16 진법: E9
*/
public class ConvNum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Please insert JINSU? ");
int iNum = 233;
int iJinsu = sc.nextInt();
int iTmp = iNum;
String sb = "";
while(1==1){
if(iJinsu < 10){
sb = String.valueOf(iTmp % iJinsu) + sb;
} else if(iJinsu >= 10){
sb =(char)((iTmp % iJinsu) + 55) + sb;
}
iTmp = iTmp / iJinsu;
if(iTmp == 0){
break;
}
}
System.out.println(sb);
}
}
#8.py
#10진수를 n진수로 변환하기
def trans(number,base):
result = ''
num_lst = '0123456789ABCDEF'
while True:
result = str(num_lst[number%base])+result
if int(number/base) == 0: return result
else: number = int(number/base)
print(trans(233,2))
print(trans(233,8))
print(trans(233,16))
파이썬 3.5
# decimal => n
Number = int(input("Input a natural number: "))
n = int(input("10 => n (note that 2 <= n <= 16): "))
temp = Number
result = ""
while temp != 0:
rem = temp%n # 나머지를 구한다.
if rem == 10: # 11진수~16진수를 위해서.
rem = 'A'
elif rem == 11:
rem = 'B'
elif rem == 12:
rem = 'C'
elif rem == 13:
rem = 'D'
elif rem == 14:
rem = 'E'
elif rem == 15:
rem = 'F'
result = str(rem) + result
temp = temp//n # 몫을 구한다.
print("%d(10) => %s(%d)" %(Number, result, n))
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
string result;
int num, to, remainder;
cin >> num;
cin >> to;
while (num > 0) {
remainder = num % to;
num /= to;
result.append(to_string(remainder));
}
reverse(result.begin(), result.end());
cout << result << endl;
return 0;
}
Pythone 3.4.2 함수 작성
def conv_digit(dividend, digit):
result = []
quotient = dividend // digit
remainder = dividend % digit
remainder_str = str(remainder)
if remainder > 9:
if remainder == 10: remainder_str = "A"
if remainder == 11: remainder_str = "B"
if remainder == 12: remainder_str = "C"
if remainder == 13: remainder_str = "D"
if remainder == 14: remainder_str = "E"
if remainder == 15: remainder_str = "F"
result.append(remainder_str)
while quotient != 0:
remainder = quotient % digit
remainder_str = str(remainder)
if remainder > 9:
if remainder == 10: remainder_str = "A"
if remainder == 11: remainder_str = "B"
if remainder == 12: remainder_str = "C"
if remainder == 13: remainder_str = "D"
if remainder == 14: remainder_str = "E"
if remainder == 15: remainder_str = "F"
result.append(remainder_str)
quotient = quotient // digit
result.reverse()
result_digit_number = "".join(result)
return result_digit_number
'길가의 풀'님의 풀이임. divmod(), 재귀함수호출, 재귀함수호출과 문자리턴을 동시에, 10 이상은 list indexing 으로..정말 깔끔
def convert(n, base):
T = "0123456789ABCDEF"
q, r = divmod(n, base)
if q == 0:
return T[r]
else:
return convert(q, base) + T[r]
-
예강효빠,
2017/04/18 04:41
def n(number,div):
result=[number]
result1=[]
six={10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
if div==2:
while number>1:
number=number//div
result.append(number)
for i in result:
num=i%2
result1.append(num)
if div==8:
while number>1:
number=number//div
result.append(number)
for i in result:
num=i%8
result1.append(num)
if div==16:
while number>1:
number=number//div
result.append(number)
for i in result:
num=i%16
if num in six:
num=six[num]
result1.append(num)
result1.reverse()
for k in result1:
kk=print(k, end='')
return kk
print(n(233,2))
print(n(233,8))
print(n(233,16))
# python 3.5.2 with PyCharm Community Edition 2017.1.1
import math
def njinsoo(num, base):
result = []
num_expression = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
for i in range(0, int(math.log(num, base)) + 1):
if i == 0:
result = num_expression[num % base]
else:
result = num_expression[num % base] + result
num = num // base
return result
print(njinsoo(233,2))
print(njinsoo(233,8))
print(njinsoo(233,16))
n = input("10진수 >> ")
length = len(n)
result = 0
a = 1
while a <= length:
place_value = 1
index = length - a
while index > 0:
place_value = place_value * 2
index = index - 1
result = result + n[a] * place value
a = a + 1
#get input
N = int(input("Input number. > "))
base = int(input("Input base. (From 2 to 16) > "))
string = "0123456789ABCDEF"
#define function
def b_cnvrt(N, base):
convert = []
while N != 0:
convert.append(string[N % base])
N = N // base
convert = reversed(convert)
result = ""
for x in convert:
result = result + x
return result
#print result
print("Converted number is " + b_cnvrt(N,base) + "(" + str(base) + ").")
public class practice {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int type = sc.nextInt();
ArrayList list = new ArrayList<Integer>();
while(num>0){
list.add(num%type);
num = num/type;
}
for(int i=1; i<=list.size(); i++){
int j = (int)list.get(list.size()-i);
if(j>=10){
char ch = (char)((int)'A'+(j-10));
System.out.print(ch);
}else{
System.out.print(j);
}
}
}
}
k = int(input("숫자를 입력하세요 :"))
n = int(input("몇진수로바꿀까요? :"))
box = []
i=0
def change(arg):
if arg==10 :
return('A')
elif arg==11 :
return('B')
elif arg==12 :
return('C')
elif arg==13 :
return('D')
elif arg==14 :
return('E')
else :
return('F')
def number(arg,jin,ma):
for p in range(0,jin):
global k
p=p+1
if arg<p*pow(jin,ma):
if p<11:
box.append(str(p-1))
else :
box.append(change(p-1))
k=k-(p-1)*pow(jin,ma)
break
while True:
i=1+i
if k<(pow(n,i)):
for j in range(i-1,-1,-1):
number(k,n,j)
break
change(box)
print("".join(box))
a = int(input("숫자를 입력하세요 : "))
n = int(input("2~16사이의 숫자를 입력하세요 : "))
R = ""
while 1:
b = a % n
if a % n == 10 : c = "A"
elif a % n == 11 : c = "B"
elif a % n == 12 : c = "C"
elif a % n == 13 : c = "D"
elif a % n == 14 : c = "E"
elif a % n == 15 : c = "F"
else: c = str(b)
a = int((a - b) / n)
R = c + R
if a == 0 : break
else : pass
print(R)
// C언어 작성
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int data;
struct node* link;
} Stack;
Stack* getNode() {
Stack* newNode = (Stack *)malloc(sizeof(Stack));
newNode->link = 0;
return newNode;
}
void Push(Stack** top, int data) {
Stack* newNode = getNode();
newNode->data = data;
newNode->link = *top;
*top = newNode;
}
int Pop(Stack** top) {
int tmp = (*top)->data;
Stack* tmp2 = *top;
*top = (*top)->link;
free(tmp2);
return tmp;
}
void func(int num, int n, Stack** top) {
int i;
for (i = 0; num > 0; i++) {
Push(top, num%n);
num /= n;
}
for (i = 0; (*top) != 0; i++) {
int a = Pop(top), b;
if (a < 10)
b = a + 48;
else
b = a + 55;
printf("%c", b);
}
}
void main() {
Stack* Top = 0;
int num, i;
printf("10진수 입력 : "); scanf("%d", &num);
for (i = 2; i <= 16; i++) {
printf("%d진수 : ", i);
func(num, i, &Top);
printf("\n");
}
}
a = int(input("십진수:"))
n = a
b = int(input("진수변환 (2~16):"))
c = []
d = []
e = ""
x = "0123456789ABCDEF"
while a >= 1 :
c.append(a%b)
a = int(a/b)
c.reverse()
for i in c:
d.append(x[i])
for i in d:
e = e + i
print ("십진수 %d를 %d진수로 변경하면 %s 이다." %(n, b, e))
c로 풀이.
#include <stdio.h>
int main(void)
{
int i,j,num,n;
char s[16]="0123456789abcdef";
int num2[10];
printf("숫자 진수 : ");
scanf("%d%d",&num,&n);
for(i=0;i<10;i++)
{
num2[i]=num%n;
num/=n;
if (num==0) break;
}
for(j=i;j>=0;j--) printf("%c",s[num2[j]]);
printf("(%d)",n);
return 0;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("10진수를 입력하세요 : ");
int num = sc.nextInt();
System.out.print("몇 진수로 반환하시겠습니까? : ");
int zinSu = sc.nextInt();
ArrayList<Integer> list = new ArrayList<>();
if(num>zinSu){
do{
list.add(num%zinSu);
num/=zinSu;
if(num<zinSu)
break;
}while(true);
}
System.out.print(num);
for(int i=list.size()-1;i>=0;i--){
System.out.print(list.get(i));
}
sc.close();
}
// 진수 체계 바꾸기 - C
#include <stdio.h>
void converter(int i, int n)
{
if (i >= n)
converter(i / n, n);
switch (i % n)
{
case 15:
printf("F");
break;
case 14:
printf("E");
break;
case 13:
printf("D");
break;
case 12:
printf("C");
break;
case 11:
printf("B");
break;
case 10:
printf("A");
break;
default:
printf("%d", i % n);
break;
}
}
int main(void)
{
int i, n;
printf("변환할 수와 진수를 입력하세요.\n");
scanf("%d %d", &i, &n);
converter(i, n);
}
javascript(ES6)
Number.DIGIT = "0123456789ABCDEF";
// 재귀로
Number.prototype.systemTo = function(base) {
return this > base ? parseInt(this / base).systemTo(base) + "" + Number.DIGIT[this % base] :
Number.DIGIT[this];
};
console.log((233).systemTo(2));
console.log((233).systemTo(8));
console.log((233).systemTo(16));
// 반복문으로
Number.prototype.systemTo = function(base) {
var q = this,
n = "";
do {
[q, r] = [parseInt(q / base), q % base];
n = Number.DIGIT[r] + n;
} while(q > 0);
return n;
};
console.log((233).systemTo(2));
console.log((233).systemTo(8));
console.log((233).systemTo(16));
JAVA풀이 (stack을 이용했습니다)
import java.util.*;
import java.util.Stack;
public class a_20170622 { //재귀함수로 n진수 만들기
int qt ;
int rm ;
int i ;
String direction;
String rmS ;
String val ;
Stack<String> myStack = new Stack<String>();
public void quotient(int x, int y){
qt = x/y ;
rm = x%y ;
rmS =Integer.toString(rm);
direction = Integer.toString(y);
if (x>=y){
myStack.push(rmS);
quotient(qt,y);
}else{
this.val = rmS;
while(!myStack.isEmpty()) {
this.val = this.val + (String)myStack.pop() ;
}
return;
}
}
public static void main(String[] args) {
a_20170622 ans = new a_20170622();
ans.quotient(233,2);
System.out.println(ans.val + "("+ ans.direction + ")");
}
}
!/usr/bin/pytohn
-- coding: utf-8 --
def convN(s,m): d = [] S = s pat = "012345789ABCDEF"
while True:
s,a = divmod(s,m)
d.append(pat[a])
if s == 0:
break
d = d[::-1]
print str(S)+" =",
print "".join(d)+"("+strc(m)+")"
convvN(110,16)
맞을려나? 잘모르겠네
def dec_to_n_radix(n, dec):
if (n > 16 or n < 2):
return 0
numbers = "0123456789ABCDEF"
n_radix = ""
while True:
n_radix = numbers[dec % n] + n_radix
dec = int(dec / n) # int로 감싸주지 않았을 경우 0보다 항상 큰값이 되어 while문을 반복한다.
if (dec <= 0):
break
return n_radix
term = "0123456789ABCDEF"
def dton(dec, n):
rem = ''
while dec:
rem = term[dec % n] + rem
dec = dec // n
return rem
# 재귀 버전
def dton_rec(dec, n):
if not dec:
return ''
return dton_rec(dec//n, n) + term[dec % n]
import java.util.Scanner;
public class dissolve { public static void main(String[] args) { //편의를 위해 입력 제한 256개 int[] inputs = new int[256]; Scanner input = new Scanner(System.in); int length = 0; //총 입력 수 기억하기 위한 변수 int number = 10; //while문이 반드시 실행하기 위해 10으로 초기화 int result = 0; //최종적으로 값을 저장하는 변수
System.out.print("숫자를 입력, 입력을 끝내려면 0~9까지의 숫자를 입력(최대 256개) : ");
while(number > 9) // 10 이상의 수가 입력되었을 경우
{
number = input.nextInt();//입력한 정수를 받음
if(number < 10)//10보다 작을 경우
{
System.out.println("입력을 종료.");
break;
}
inputs[length] = number;//배열에 입력을 저장함
length++;//배열 위치 한칸 옮김
}
System.out.println("입력했던 숫자들을 나열.");
//제대로 입력되었는지 확인하기 위한 출력
for(int i = 0; i < length; i++)
{
int n = inputs[i];
System.out.println(n);
}
System.out.println();
for(int i = 0; i < length; i++)
{
int temp;//배열 내부 값 저장 변수
int tempTwo = 1;//각 자리값을 저장하는 변수
int n = 1;//10의 몇 제곱인지 나타내기 위한 변수이며, 나머지를 봐야하므로 1부터 시작
temp = inputs[i];
while(temp > 0)//temp값은 매 반복마다 줄어들게 됨.
{
int powed = (int)Math.pow(10,n);
tempTwo = tempTwo * (temp % powed);//매 나머지 값을 곱함
temp = temp / powed;//temp 값 수정
n++;//제곱값 증가
}
result += tempTwo; //최종 결과를 합산
}
System.out.println(result); //출력
} }
#d_num = decimal number
#t_num = target number
def DecimalTo(d_num,t_num):
dic = {10:'A', 11:'B', 12:'C', 13:'D', 14:'E', 15:'F'}
s = ''
if t_num > d_num:
return d_num
while(d_num):
remainder = (d_num % t_num)
if remainder >=10:
s = dic[remainder] + s
else:
s = str(d_num%t_num) + s
d_num = d_num/t_num
if t_num > d_num:
if d_num >=10:
return dic[d_num] + s
else:
return str(d_num) + s
return 0
print DecimalTo(10,3)
// 초보입니다.. 스택은 직접 구현했습니다.
private static int number = 233;
public static void main(String[] args) {
// convertAnotherBase(2);
// convertAnotherBase(8);
convertAnotherBase(16);
}
public static void convertAnotherBase(int baseType){
int quotient = 0;
int remainder = 0;
do{
quotient = number / baseType;
remainder = number % baseType;
Stack.push( remainder >= 10 ? mappingBase16(remainder): Integer.toString(remainder));
number = quotient;
}while( quotient >= baseType );
Stack.push( quotient >= 10 ? mappingBase16(quotient): Integer.toString(quotient));
Stack.showStatck();
Stack.clear();
}
public static String mappingBase16(int number){
String str = "";
if ( number == 10 ){
str = "A";
}else if ( number == 11){
str = "B";
}else if ( number == 12){
str = "C";
}else if ( number == 13){
str = "D";
}else if ( number == 14){
str = "E";
}else {
str = "F";
}
return str;
}
public class Stack {
private static final int SIZE = 255;
private static String[] array;
private static int idx;
static{
array = new String[255];
idx = 0;
}
public static String pop(){
if (idx == 0){
System.out.println("stack is empty");
return "";
}
return array[idx--];
}
public static boolean push(String item){
if (idx >= SIZE){
System.out.println("stack is full");
return false;
}
array[idx++] = item;
return true;
}
public static void showStatck(){
if ( idx == 0 ){
System.out.println("stack is empty");
}else{
for ( int i = idx - 1 ; i >= 0; i-- ){
System.out.print( array[i] );
}
}
}
public static void clear(){
for ( int i = 0 ; i < idx; i++){
array[0] = "";
}
}
}
def systemconverter(target_system, decimal_number):
if 2<= target_system <= 16:
result =[]
zero_count = 0
while decimal_number//target_system >= 0:
if decimal_number//target_system == 0:
zero_count += 1
if zero_count == 2:
break
result.append(decimal_number % target_system)
print(result)
decimal_number = decimal_number//target_system
print("결과창")
result.reverse()
print(result)
index = 0
for num in result:
if num == 10:
result[index] = "A"
elif num == 11:
result[index] = "B"
elif num == 12:
result[index] = "C"
elif num == 13:
result[index] = "D"
elif num == 14:
result[index] = "E"
elif num == 15:
result[index] = "F"
elif num == 16:
result[index] = "G"
index += 1
print("".join(list(map(lambda x: str(x), result)))+ "\t" + str(target_system)+"진법")
else:
print("##'2 ~ 16'진법까지만 변환이 가능합니다##")
systemconverter(2,233)
systemconverter(8,233)
systemconverter(16,233)
또 하나의 lengthy한 trash solution을 창조해냈네요..하하.. 몫과 나머지를 이용하였고, List에 순서대로 append()써서 추가한 뒤 순서 reverse()해주었습니다.
아래는 10이상 숫자를 A,B,C,D,E,F,G로 바꾸는... 노가다..(눈물)입니다
package java_tutorial;
import java.util.Scanner;
public class Ten_toOthers {
public static void main(String[] args) {
int remain = 0;
int quot = 1;
String answer = "";
Scanner sc = new Scanner(System.in);
StringBuffer sb = new StringBuffer();
System.out.print("From : ");
int from_Num = sc.nextInt();
System.out.print("To(2~16) : ");
int to_Num = sc.nextInt();
System.out.println("");
System.out.print(to_Num + "진수로 변환 : " + from_Num + "(10) -------> ");
while(quot>0)
{
quot = from_Num / to_Num;
remain = from_Num % to_Num;
answer += remain;
from_Num = quot;
}
sb.append(answer);
System.out.println(sb.reverse()+ "("+ to_Num + ")");
}
}
좋은 풀이가 엄청 많네요...
dict = {'10' : 'A', '11' : 'B', '12' : 'C', '13' : 'D', '14' : 'E', '15' : 'F'}
def ts(a, n, list = []):
while a != 0:
list.append(str(a%n))
a = a//n
list = ",".join(list[::-1])
for a, b in dict.items():
list = list.replace(a,b)
return "".join(list.split(','))
import java.util.*;
public class DecimalConversion {
public static String converter(int n, int base) {
if(n != 0) {
if(n%base > 9) return converter(n/base,base) + (char) (n%base+55);
else return converter(n/base,base) + (char) n%base;
}
else return "";
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int base = sc.nextInt();
System.out.println(converter(n,base));
}
}
print('==============================================')
print('binary_system:2 / octal_num_system:8 / hexadecimal number:16')
user_input=input('Input hex data: ')
system_input=input('input system: ')
print('==============================================')
a=int(user_input)
si=int(system_input)
def change_num_system(a,si):
list=[]
if a<si:
list.append(str(a))
else:
while a>=si:
if a%si==0:
list.append(str(0))
else:
if a%si==10:
list.append('A')
elif a%si==11:
list.append('B')
elif a%si==12:
list.append('C')
elif a%si==13:
list.append('D')
elif a%si==14:
list.append('E')
elif a%si==15:
list.append('F')
else:
list.append(str(int(a)%si))
a=a/si
if a<si:
list.append(str(a))
print(list)
break
list.reverse()
# print(list)
print(''.join(list))
change_num_system(a,si)
진법의 변환된 수에서 0이 쭈욱 딸려오는 것을 무시해야 하네요.
function convertBase(base, e) {
if ( e < 0 || e > 16) return -1;
const digit = [0,1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F'];
let ans = [], tailingZero = true;
const solve = (base, e) => {
const num = Math.floor(base / e);
if (!tailingZero || base % e !== 0) {
ans.unshift(digit[base % e]);
tailingZero = false;
}
return (num === 0) ? -1 : solve(num, e);
}
solve(base, e);
return ans.join('');
}
console.log(convertBase(51712, 2));
console.log(convertBase(233, 8));
console.log(convertBase(233, 16));
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));
System.out.print("10진수 값 : ");
int decimalNum = Integer.parseInt(br.readLine()); // 10진수 값
System.out.print("바꿀 진수 입력 : ");
int jinsu = Integer.parseInt(br.readLine()); // 바꿀 진수 ex) 2진수
decimalToBinary(decimalNum, jinsu);
br.close();
}
public static void decimalToBinary(int decimalNum, int jinsu) {
int mok = 1, namuji = 0;
StringBuilder sb = new StringBuilder();
while (mok > 0) {
mok = decimalNum / jinsu;
namuji = decimalNum % jinsu;
if (namuji > 9) {
switch (namuji) {
case 10: sb.append("A"); break;
case 11: sb.append("B"); break;
case 12: sb.append("C"); break;
case 13: sb.append("D"); break;
case 14: sb.append("E"); break;
case 15: sb.append("F"); break;
}
} else {
sb.append(namuji);
}
decimalNum = mok;
}
System.out.println("-----------------");
System.out.println(">>> " + jinsu + "진수 변환 : " + sb.reverse() + "(" + jinsu + ")");
}
}
def changeNum(num, target):
print('10진수:', num)
arr = ''
arr1 = '0123456789ABCDEF'
while True:
num, tmp = divmod(num, target)
arr = arr1[tmp] + arr
if num <=0:
break
print(arr)
changeNum(233, 2)
changeNum(233, 8)
changeNum(233, 16)
def convert(dec,bit):
num = ""
while dec:
b = dec % bit
if b > 10:b = 'ABCDEF'[b - 10]
dec = int(dec / bit)
num += str(b)
return num[::-1]
print(convert(233,2))
print(convert(233,8))
print(convert(233,16))
# python 3.6
def base_n(n, base):
pool = "0123456789ABCDEF"
rst = list()
while n:
rst.insert(0, pool[n % base])
n = n // base
return "".join(rst)
print(base_n(233, 2), base_n(233, 8), base_n(233, 16))
# ans: 11101001 351 E9
def numeral_system(x):
n = int(input("which number do you want to use?"))
answer = ''
pool = "0123456789abcdef"
while x > 0 :
answer += pool[x % n]
x = (x // n)
answer = answer[::-1]
print(answer)
numeral_system(233)
# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3)
import sys
import io
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')
# 10진수를 n진수로 변환하는 프로그램을 작성하시오.. (단, n의 범위는 2 <= n <= 16)
import random
# number_10 = 233
# decimal_n = 2
number_10 = random.randint(1,1000)
decimal_n = random.randint(2,16)
number_n = []
temp = number_10
showing_number = "0123456789ABCDEF"
while temp :
number_n = [showing_number[temp % decimal_n]] + number_n
temp //= decimal_n
print(number_10,"=",''.join(x for x in number_n)+"("+str(decimal_n)+")")
python
d = int(input('digit : '))
n = int(input('n : '))
l = []
while d/n > 0:
if d//n != d/n:
rem = d%n
if rem > 9:
t = rem - 10
if t == 0: rem = 'A'
elif t == 1: rem = 'B'
elif t == 2: rem = 'C'
elif t == 3: rem = 'D'
elif t == 4: rem = 'E'
elif t == 5: rem = 'F'
elif t == 6: rem = 'G'
l.append(rem)
else:
rem = 0
l.append(rem)
d = d//n
else: l.reverse()
for i in l:
print(i, end ='')
N = 233
binaryN = []
while True:
binaryN.append(N%2)
N = N//2
if N==0:
break
binaryN.reverse()
[print(binaryN[x], end="") for x in range(len(binaryN))]
print("\n")
N = 233
binary8 = []
while True:
binary8.append(N%8)
N = N//8
if N==0:
break
binary8.reverse()
[print(binary8[x], end="") for x in range(len(binary8))]
print("\n")
N = 233
binary16 = []
while True:
binary16.append(N%16)
N = N//16
if N==0:
break
for i in range(len(binary16)):
if binary16[i] == 10:
binary16[i] = "A"
elif binary16[i] == 11:
binary16[i] = "B"
elif binary16[i] == 12:
binary16[i] = "C"
elif binary16[i] == 13:
binary16[i] = "D"
elif binary16[i] == 14:
binary16[i] = "E"
elif binary16[i] == 15:
binary16[i] = "F"
binary16.reverse()
[print(binary16[x], end="") for x in range(len(binary16))]
public class Conversion {
private String result = "";
private String[] tmp = {"A","B","C","D","E","F"};
public static void main(String[] args) {
SimpleDecimalConversion sdc = new SimpleDecimalConversion();
sdc.getRemainder(233, 2);
sdc.getRemainder(233, 8);
sdc.getRemainder(233, 16);
}
public void getRemainder(int t, int v) {
if (t == 0 || v == 0) {
return;
}
int mod = (t % v);
if (mod >= 10) {
result = tmp[mod%10] + result;
} else {
result = mod + result;
}
int tv = t/v;
if (tv >= v) {
getRemainder(tv,v);
} else {
if (tv >= 10) {
System.out.println(tmp[tv%10]+result);
} else {
System.out.println(tv+result);
}
result = "";
}
}
}
Mod=int(input('modulo(2 이상, 16이하의 정수): '))
start=int(input('initial number(자연수): '))
def trans(num):
if num<10:
return(str(num))
else:
return(chr(num+55))
def nth(num, mod, result=''):
if num<mod:
result=trans(num)+result
return(result)
else:
a,b=divmod(num,mod)
result=trans(b)+result
return(nth(a, mod, result))
print(nth(start, Mod))
캐릭터에 저장시키고 거꾸로 읽어오는 방식입니다
def chgr(num,n):
char =""
while num>n:
char += str(num%n)
num = num //n
char+=str(num)
print(char[::-1])
print(chgr(233,8))
java
package cddj;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class cddj7 {
public static void main(String[] args) {
int num = 233;
Scanner input = new Scanner(System.in);
int N;
System.out.print("N = ");
N = input.nextInt();
ArrayList<Integer> ans = new ArrayList<Integer>();
while (num != 0) {
int rem = num % N;
num = num / N;
ans.add(rem);
}
Collections.reverse(ans);
String answer = "";
for (int i : ans) {
answer += i;
}
System.out.println(answer);
}
}
- 10진수를 n 진수로 변환하는 프로그램 ( 2 <= n <= 16 )
# 10진수 및 변환하고자 하는 진수 입력
print("\n")
print(" ■■■ 10진수 -> n진수 변환기 ■■■ ", "\n")
d = int(input(" ▶ 변환하고자 하는 10진수를 입력하세요: "))
print("\n")
n = int(input(" ▶ 변환하고자 하는 진수 n을 입력하세요 ( 2 or 8 or 16) : "))
print("\n")
# 결과 값을 저장할 객체 정의
result = []
# 16진수 표현을 위한 함수 정의
def inttostr(x):
if x == 10:
x = 'A'
if x == 11:
x = 'B'
if x == 12:
x = 'C'
if x == 13:
x = 'D'
if x == 14:
x = 'E'
if x == 15:
x = 'F'
result.append(str(x))
# 진수 변환을 위한 함수 정의
def convertdec(d):
dsource = []
dsource.append(d)
rem = 0
if n == 2 or n == 8: # 2진법 또는 8진법으로 변환
while d >= rem:
rem = d % n
d = d // n
result.append(str(rem))
if not d == 0:
result.append(str(d))
result.reverse()
print(" ☞ 10진수 %d의 %d진수는" % (dsource[0], n), "".join(result),"입니다.","\n")
if n == 16:
while d >= rem:
rem = d % n
d = d // n
if rem > 9:
inttostr(rem)
else:
result.append(str(rem))
if d > 9:
inttostr(d)
break
if d != 0 and d < 10:
result.append(str(d))
result.reverse()
print(" ☞ 10진수 %d의 %d진수는" % (dsource[0], n), "".join(result),"입니다.","\n")
convertdec(d)
- 결과값
■■■ 10진수 -> n진수 변환기 ■■■
▶ 변환하고자 하는 10진수를 입력하세요: 777
▶ 변환하고자 하는 진수 n을 입력하세요 ( 2 or 8 or 16) : 2
☞ 10진수 777의 2진수는 1100001001 입니다.
■■■ 10진수 -> n진수 변환기 ■■■
▶ 변환하고자 하는 10진수를 입력하세요: 777
▶ 변환하고자 하는 진수 n을 입력하세요 ( 2 or 8 or 16) : 8
☞ 10진수 777의 8진수는 1411 입니다.
■■■ 10진수 -> n진수 변환기 ■■■
▶ 변환하고자 하는 10진수를 입력하세요: 777
▶ 변환하고자 하는 진수 n을 입력하세요 ( 2 or 8 or 16) : 16
☞ 10진수 777의 16진수는 489 입니다.
private void getNTypeValue(int aaa, int i) {
// TODO Auto-generated method stub
ArrayList resultVal = new ArrayList();
int result = aaa;
System.out.println("초기값-"+aaa);
do
{
resultVal.add(result%i);
result/=i;
System.out.println("result="+result);
}
while(result!=0);
Collections.reverse(resultVal);
System.out.print("결과값 = ");
for(int t=0; t<resultVal.size(); t++)
{
System.out.print(resultVal.get(t));
}
}
decimal=int(input())
result=''
while(decimal>0):
remainder=decimal%2
print(remainder)
decimal=decimal//2
result=str(remainder)+result
print(result)
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("변환할 10진수를 입력해 주세요");
int num = sc.nextInt();
System.out.println("진수를 입력해 주세요");
int jinsu = sc.nextInt();
System.out.println(jinsu + "진수로 변환 : " + convert(num, jinsu));
sc.close();
}
private static String convert(int num, int jinsu) {
String convert = "";
int div = num / jinsu;
int rem = num % jinsu;
ArrayList<String> result = new ArrayList<String>();
result.add(String.valueOf(rem));
while (true) {
rem = div % jinsu;
if (div == 0)
break;
else {
if (rem >= 10) {
char c = (char) (rem + 55);
result.add(String.valueOf(c));
} else {
result.add(String.valueOf(rem));
}
div = div / jinsu;
}
}
for (int i = result.size() - 1; i >= 0; i--)
convert += result.get(i);
return convert;
}
}
decimal=int(input("Enter the decimal : "))
n = int(input("Enter the N : "))
jinsu=[]
if n >= 2 and n <= 16:
tdecimal = decimal
while tdecimal > 0:
jinsu.append(tdecimal % n)
tdecimal = tdecimal // n
jinsu.reverse()
print(n," 진수 : ", end='')
for i in jinsu:
print(i, end='')
remainderList = []
def digitChanger(m, n):
remainder = m % n # 나머지
remainderList.insert(0, remainder) # 맨 처음에 값 추가
new_quotient = int(m / n) # 몫
if(n <= new_quotient):
digitChanger(new_quotient, n)
return
else:
remainderList.insert(0, new_quotient)
result = ""
for temp in remainderList: # 16진수일 경우 10이상의 수는 문자로 변환
if(n == 16):
if(temp == 10):
temp = "A"
elif(temp == 11):
temp = "B"
elif(temp == 12):
temp = "C"
elif(temp == 13):
temp = "D"
elif(temp == 14):
temp = "E"
elif(temp == 15):
temp = "F"
result += str(temp)
print(result)
JAVA
import java.util.*;
public class DecimalConvert { //JAVA
public static void main(String[] args) {
DoConvert doConvert = new DoConvert();
doConvert.setNum();
doConvert.doconvert();
}
}
class DoConvert {
// 필드 선언
private Deque<Integer> deque;
static int Num;
//생성자
DoConvert() {
deque = new ArrayDeque<>();
}
// 정수 설정
public void setNum() {
Scanner scan = new Scanner(System.in);
System.out.print("n진수로 변환할 정수를 입력하시오: ");
DoConvert.Num = scan.nextInt();
scan.close();
}
// 진수변환 실행문
public void doconvert() {
for(int n=2; n<=16; n++)
{
int num = DoConvert.Num;
// deque 에 정보 쌓기
while(true)
{
deque.add(num % n);
num /= n;
if(num == 0) break;
}
// deque 에서 정보 추출
while(!deque.isEmpty())
{
if(deque.peekLast()<10)
System.out.print(deque.removeLast());
else {
System.out.print((char)(deque.removeLast()+55));
}
}
System.out.print("("+ n +")"); // 몇 진법인지 알려준다.
System.out.println("");
}
}
}
Console
n진수로 변환할 정수를 입력하시오: 233
11101001(2)
22122(3)
3221(4)
1413(5)
1025(6)
452(7)
351(8)
278(9)
233(10)
1A2(11)
175(12)
14C(13)
129(14)
108(15)
E9(16)
python 3.6
number = int(input('Enter the decimal number: '))
n = int(input('Enter the converter number(n): '))
n_list = []
while number > 0:
if number%n < 10:
n_list.append(number%n)
number = number//n
else:
d = {10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F'}
n_list.append(d.get(number%n))
number = number//n
n_list.reverse()
print(''.join(map(str,n_list)))
print("이 프로그램은 x의 값을 n진수로 변환해서 보이는 프로그램입니다.")
x = int(input("x의 값을 입력하세요"))
n = int(input("n의 값을 입력하세요. 단, n의 값은 2이상 16이하여야 합니다"))
while x//n > 0:
print(x%n)
x = x//n
continue
print(x%n)
num, n = raw_input("number and number system (2,8,16):\n").split()
num=int(num)
n=int(n)
j=0
new=[]
new2=[]
while num > n:
i=num%n
num=num//n
if i == 10: i='A'
elif i == 11: i='B'
elif i == 12: i='C'
elif i == 13: i='D'
elif i == 14: i='E'
elif i == 15: i='F'
new.append(str(i))
j=j+1
if num == 10: num='A'
elif num == 11: num='B'
elif num == 12: num='C'
elif num == 13: num='D'
elif num == 14: num='E'
elif num == 15: num='F'
new.append(str(num))
for k in range(0,j+1):
new2.append(new[j-k])
print ''.join(new2)
def question(target, n): lst = [] lst.append(target % n)
while(target >= n):
answer = target // n
lst.append(answer % n)
target = answer
lst1 = []
for i in range(len(lst)):
lst1.append(lst[-1])
lst.pop()
print(lst1)
question(233, 8)
import org.junit.Test;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
public class JinsuTest {
@Test
public void convertNJinsuTest() throws Exception {
int testNum = 233;
assertThat("11101001", is(equalTo(convertNJinsu(testNum, 2))));
assertThat("351", is(equalTo(convertNJinsu(testNum, 8))));
assertThat("E9", is(equalTo(convertNJinsu(testNum, 16))));
}
public String convertNJinsu(int num, int base) {
String numArray = "0123456789ABCDEF";
StringBuilder njinsu = new StringBuilder();
while (num > 0) {
njinsu.insert(0, numArray.charAt(num % base));
num = num / base;
}
return njinsu.toString();
}
}
def jinsu(a, b):
result = []
while a//b > 0:
result.append(a%b)
a = a//b
result.append(a)
result.reverse()
for i in range(len(result)):
if result[i] ==10:
result[i] = 'A'
elif result[i] ==11:
result[i] = 'B'
elif result[i] ==12:
result[i] = 'C'
elif result[i] ==13:
result[i] = 'D'
elif result[i] ==14:
result[i] = 'E'
elif result[i] ==15:
result[i] = 'F'
return (result, b)
import java.util.*;
public class Main { public static void main(String[] args) { Scanner scanf=new Scanner(System.in); int a=233; String s=""; String s2=""; String s3=""; s=Integer.toBinaryString(a); s2=Integer.toHexString(a); s3=Integer.toOctalString(a); System.out.println(s); System.out.println(s2.toUpperCase()); System.out.println(s3);
}
}```{.java}
```
def binary():
number=input('input number:')
dimension=input('input dimension:')
n=[]
c=number
while number!=0:
b=number%dimension
number=number/dimension
n.append(b)
n.reverse()
n=[str(x) for x in n]
m=""
for x in n:
m=m+x
print m
N=int(input("몇진수로 변환할지 입력하세요:"))
num=int(input("변환하려는 숫자를 입력하세요:"))
num_list=[]
while num!=0:
num_list.append(num%N)
num=num//N
num_list.reverse()
ans=''
for num in num_list:
if num==10:
ans+='A'
elif num==11:
ans+='B'
elif num==12:
ans+='C'
elif num==13:
ans+='D'
elif num==14:
ans+='E'
elif num==15:
ans+='F'
else:
ans+=str(num)
print(ans)
def convert(decimal, num) :
remainder_list = '0123456789ABCDEF'
result = divmod(decimal, num)
if result[0] < num :
return remainder_list[result[0]] + remainder_list[result[1]]
else :
return convert(result[0], num) + remainder_list[result[1]]
def njinsu(num,jin):
n=[0,1,2,3,4,5,6,7,8,9,'A','B','C','D','E','F']
if jin <=16:
while num>=jin:
num,rmd=divmod(num,jin)
print(n[rmd],end='')
print(n[num])
else :
print('jin must be lower than 16')
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> p;
int n = 233;
int remain = 0;
int select;
cout << "2진수,8진수,16진수를 선택하시오>>";
while (true)
{
cin >> select;
if (select == 2 || select == 8 || select == 16) break;
else
continue;
}
while (n != 0)
{
remain = n % select;
n /= select;
p.push_back(remain);
}
for (int j = p.size() - 1; j >= 0; j--)
{
if (p[j] == 10)
cout << "A";
else if (p[j] == 11)
cout << "B";
else if (p[j] == 12)
cout << "C";
else if (p[j] == 13)
cout << "D";
else if (p[j] == 14)
cout << "E";
else if (p[j] == 15)
cout << "F";
else
cout << p[j];
}
cout << endl;
}
a = int(input("Enter the number: ",))
b = int(input("Enter the number you want to convert: ",))
remainder={10:'A',11:'B',12:'C',13:'D',14:'E',15:'f'}
def convert_n(x, y):
n=''
while x//y > 0 or x%y > 0:
r = x%y
if r>=10:
r = remainder[r]
n+=str(r)
x=x//y
return print(n[::-1])
convert_n(a, b)
Swift입니다.
import Foundation
var numbers = Array(1...20)
func convert(_ base: Int, _ number: Int) -> String {
var n = number
var result = ""
while true {
if n >= base {
let reminder = n % base
n = n / base
result.append(String(reminder, radix: base, uppercase: true))
} else {
result.append(String(n, radix: base, uppercase: true))
break
}
}
return String(result.reversed())
}
print( convert(2, 233) )
print( convert(8, 233) )
print( convert(16, 233) )
print( convert(32, 233) )
def changenum(number,n): # n 진수
lst = []
result_lst = []
for k in range(1,number):
if n ** k < number:
lst.append(n ** k)
lst.append(1)
lst.sort(reverse = True)
for x in lst:
res = number % x
a = number // x
result_lst.append(a)
number = res
result = ''
for number in result_lst:
result = result + str(number)
return result
//10진수를 n진수로 변환하는 프로그램을 작성하시오..
class BinGenerator
{
constructor(num, n)
{
this._decNum = num;
this._answerArray = [];
this._n = n;
this._curNum = num;
this.Digit = "0123456789ABCDE";
}
getBinByLibrary()
{
return (this._n >= 2 && this._n <= 16 ) ? this._decNum.toString(this._n) : '';
}
getNBin()
{
if(!(this._n >= 2 && this._n <= 16))
{
return 'Error';
}
while(this._curNum>this._n)
{
let val = parseInt(this._curNum % this._n);
this._answerArray.push(this.Digit[val]);
this._curNum /= this._n;
}
this._answerArray.push(this.Digit[parseInt(this._curNum)]);
return this._answerArray.reverse().join('');
}
}
let binGenerator = new BinGenerator(233,2);
let octGenerator = new BinGenerator(233,8);
let hexGenerator = new BinGenerator(233,16);
console.log(binGenerator.getNBin());
console.log(octGenerator.getNBin());
console.log(hexGenerator.getNBin());
Python
c = ["A","B","C","D","E","F"]
n = 233
k = 16
ans = ""
while True:
if n//k == 0:
if n%k > 9:
ans += c[n%k - 10]
else:
ans += str(n%k)
break
if n%k > 9:
ans += c[n%k - 10]
else:
ans += str(n % k)
n = n//k
print(ans[::-1])
def dec2(n, b):
char = "0123456789ABCDEF"
a = []
while(n!=0):
a.append(char[n % b])
n //= b
return ''.join(a[::-1])
print(dec2(233, 2))
print(dec2(233, 8))
print(dec2(233, 10))
print(dec2(233, 16))
파이썬3
def convert(number, n):
m = "0123456789ABCDEF"
rems = []
quo = number
while True:
rem = m[quo % n]
rems.insert(0, rem)
quo = quo // n
if quo == 0:
break
return "".join(list(map(str,rems)))
print(convert(233,2))
print(convert(233,8))
print(convert(233,16))
결과
11101001
351
E9
def conv_numsys(n, m):
cv,r = 'ABCDEF', ''
while n > 0:
r = (str(n%m) if n%m < 10 else cv[n%m-10]) + r
n = n//m
return r
print(conv_numsys(235235,16))
Ruby
char = "0123456789ABCDEF"
rs = []
a = gets.chomp.to_i # 10진 숫자
b = gets.chomp.to_i # 진수
loop do
rs << a % b
a /= b
break if a == 0
end
rs = rs.reverse
rs.each do |i|
print char[i]
end
def JINSU_2(a):
result =[]
while a>0:
b,c=divmod(a,2)
a=b
result.append(str(c))#2진수값저장
result.reverse()
print(''.join(result))
def JINSU_8(a):
result =[]
while a>0:
b,c=divmod(a,8)
a=b
result.append(str(c))
result.reverse()
print(''.join(result))
def JINSU_16(a):
result =[]
while a>0:
b,c=divmod(a,16)
a=b
result.append(format(c,'x'))
result.reverse()
print(''.join(result))
a=233
JINSU_2(a), JINSU_8(a), JINSU_16(a)
bi = []
def hex_list(na):
if na == 10:
return 'A'
elif na == 11:
return 'B'
elif na == 12:
return 'C'
elif na == 13:
return 'D'
elif na == 14:
return 'E'
elif na == 15:
return 'F'
else:
return na
def bi_list(num,n):
na=''
if num <= (n-1):
if n == 16:
na=hex_list(num)
else:
na = num
bi.insert(0,str(na))
return
na = num%n
if n == 16:
na=hex_list(na)
bi.insert(0,str(na))
bi_list(num//n,n)
x,y = map(int,input("10진수 값 과 변환진수를 입력하세요: ").split())
bi_list(x,y)
v=''
for k in bi:
v = v+k
print(str(y)+'진수로 변환 : '+str(x)+'--->'+str(v))
def division(num, n) :
result_num = []
while num//n != 0 :
result_num.append(str(num%n))
num=num//n
result_num.append(str(num))
result_num.reverse()
return result_num
def replace(num,dic) :
for i in range (0, len(num)) :
if num[i] in dic :
num[i] = dic.get(num[i])
return num
def convert_notation() :
result = []
#10이상의 알파벳 dictionary 생성
dic_num = {}
ascii_cd = 65
for i in range (10, 16) :
dic_num[str(i)] = chr(ascii_cd)
ascii_cd+=1
while 1 :
n= input("변환하고 싶은 진수를 입력하세요.")
#숫자 입력
input_num = int(input(n+"진수로 바꿀 숫자를 입력하세요."))
#n의 진수로 변환
result = division(input_num, int(n))
#10진수 이상일 때, dictionary 값 알파벳 치환
if int(n)>10 :
result = replace(result, dic_num)
str_result = str(input_num)+ " --> " + "".join(result) +"\n"
print(str_result)
import java.util.Scanner;
import java.util.ArrayList;
public class KimSanghyeop {
public static void main(String args[])
{
char[] arr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
Scanner sc = new Scanner(System.in);
System.out.print("10 진수 수를 입력하세요 : ");
int num = sc.nextInt();
System.out.println("몇진수로 바꿀까요?");
int convert = sc.nextInt();
int res;
ArrayList<Integer> al = new ArrayList<Integer>();
while(num!=0)
{
res = num % convert;
num = num / convert;
al.add(res);
}
for(int f1=al.size()-1;f1>=0;f1--)
{
System.out.print(arr[al.get(f1)]);
}
}
}
#자연수를 N진법으로 나타내기
ls=['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']
k=int(input('자연수 입력: '))
n=int(input('몇 진수로 변환할 것인가?'))
r=[]
while True:
kr=ls[k%n]
r.append(kr)
k=k//n
if k<n:
r.append(ls[k])
r.reverse()
result="".join(r)#문자열 합치기
print(n,'진법 변환 후: ',result)
break
def Changenary(number,n):
Exnum = {10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
res=[]
while number != 0:
if number%n < 10: res.append(number%n)
else: res.append(Exnum[number%n])
number = number//n
return "%s진수로 변환 : %s --> %s"%(n,number,''.join(map(str,res[::-1])))
print(Changenary(233,16))
재귀함수 이용안하고 풀어봤습니다 ㅎㅎ
def ten_to_num(num, n):
T = '0123456789ABCDE'
if num == 0:
return ''
else:
return T[num % n] + ten_to_num(num // n, n)
num, n = map(int, input().split())
print(ten_to_num(num, n)[::-1])
function solution(a, n) {
var tmp = a;
var arr = [];
var digit = "0123456789ABCDEF";
while (tmp > n) {
arr.unshift(digit[tmp % n]);
tmp = parseInt(tmp / n);
}
arr.unshift(digit[tmp]);
return arr;
}
console.log(solution(233, 2).join(''));
console.log(solution(233, 8).join(''));
console.log(solution(233, 16).join(''));
over_10 = {10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F'}
def n_number(n, num):
result_list = []
while num > n:
rem = num % n
if rem >= 10:
rem = over_10[rem]
result_list.insert(0, rem)
num = num // n
if num >= 10:
num = over_10[num]
result_list.insert(0, num)
result_str = ''
for x in result_list:
result_str += str(x)
return result_str
n, number = input("n진수 변환 할 숫자").split()
print(n_number(int(n), int(number)))
while True:
digit='0123456789ABCDEF'
n=int(input("Input the number in decimal form: "))
base=int(input("Input base (from 2 to {0}): ".format(len(digit))))
def cnvrtbase(n,base):
string=''
while n>0:
string=digit[n%base]+string
n=n//base
return string
print(cnvrtbase(n,base))
def antilogarithm(num,n):
s = []
ans =''
while num //n != 0:
cc = num % n
if cc < 10:
s.insert(0,num % n)
num = num //n
else:
print('통과')
for i,v in zip([10,11,12,13,14,15],['A','B','C','D','E','F']):
if cc == i:
print(v)
s.insert(0,v)
num = num //n
break
if num % n > 9 :
for i,v in zip([10,11,12,13,14,15],['A','B','C','D','E','F']):
if (num % n) == i:
s.insert(0,v)
break
else:
s.insert(0,num%n)
for i in s:
ans += str(i)
return ans
def change_base(n, base):
base_number = "0123456789ABCDEF"
p, q = divmod(n, base)
if p == 0:
return base_number[q]
else:
return change_base(p, base) + base_number[q]
c로 풀었습니다
#include <stdio.h>
int main()
{
int n, n1, i = 0;
int a[20] = { 0, };
char b[20] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G' };
int c[20] = { 0, };
int d[20] = { 0, };
printf("숫자와 진수를 입력하삼 ex) 100 2 >>>");
scanf("%d %d", &n, &n1);
switch (n1) {
case 2:
if (n == 0) {
printf("0");
return 0;
}
while (n >= 1) {
a[i] = n % 2;
i++;
n /= 2;
}
i -= 1;
while (i >= 0) {
printf("%d", a[i]);
i--;
}
break;
case 8:
if (n == 0) {
printf("0");
return 0;
}
while (n >= 1) {
a[i] = n % 2;
i++;
n /= 2;
}
i -= 1;
for (int j = 0; j <= i; j += 3) {
c[j] = (a[j] * 1) + (a[j + 1] * 2) + (a[j + 2] * 4);
}
for (int j = i; j >= 0; j--) {
if (j % 3 == 0) {
printf("%d", c[j]);
}
}
break;
case 16:
if (n == 0) {
printf("0");
return 0;
}
while (n >= 1) {
a[i] = n % 2;
i++;
n /= 2;
}
i -= 1;
for (int j = 0; j <= i; j += 4) {
d[j] = (a[j] * 1) + (a[j + 1] * 2) + (a[j + 2] * 4) + (a[j + 3] * 8);
}
for (int j = i; j >= 0; j--) {
if (j % 4 == 0) {
printf("%c", b[d[j]]);
}
}
break;
}
}
넘나 쉬운것
#include <iostream>
using namespace std;
int main()
{
long long int N;
int d;
char intToChar[16] = {'0','1','2','3','4','5','6','7',
'8','9','A','B','C','D','E','F'};
string str;
scanf("%lld", &N);
scanf("%d", &d);
while(N / d > 0)
{
str = intToChar[N%d] + str;
N /= d;
}
str = intToChar[N%d] + str;
cout << str;
return 0;
}
def henkan(NUM,N):
asd='0123456789ABCDEF'
q,w=divmod(NUM,N)
if q==0:
return asd[w]
else:
return henkan(q,N)+asd[w]
num,n =map(int,input().split())
print(henkan(num,n))
print("dec(변환하고싶은10진수,변환하고싶은진수입력(16이하)")
def dec(a,b):
result = []
while a > 0:
if a%b > 9:
dic = {10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
result.append(dic[a%b])
a = a // b
result = [str(x) for x in result]
else:
result.append(a % b)
a = a // b
result = [str(x) for x in result]
print(''.join(reversed(result)),"{}진법".format(b))
d = '0123456789ABCDEF'
def f(m, base):
s = ''
while m != 0:
s = d[m % base] + s
m = m // base
print(s)
public class TentoN {
public static void main(String[] args) {
int n = 8;
int input = 233;
getReminder(input, n);
}
private static void getReminder(int input, int n) {
if( input/n >0 ) {
getReminder(input/n, n);
}
if( input/n>0) {
System.out.print(input%n + " ");
}else {
System.out.print(input + " ");
}
}
}
Python 3입니다.
a=int(input('몇 진수로 나타낼 지 입력하세요'))
su=233
result=[]
while su!=0 :
(su,number)=divmod(su,a)
result.append(str(number))
print("".join(result))
def dim(m, n) :
'''m을 n진수로 변환하는 함수'''
result = []
while m // n != 0 :
rem = m % n
m = m // n
result.append(rem)
rem = m % n; result.append(rem)
for i in range(len(result)-1, -1, -1) :
if result[i] == 10 : result[i] = 'A'
elif result[i] == 11 : result[i] = 'B'
elif result[i] == 12 : result[i] = 'C'
elif result[i] == 13 : result[i] = 'D'
elif result[i] == 14 : result[i] = 'E'
elif result[i] == 15 : result[i] = 'F'
print(result[i], end = '')
파이썬입니다. 하나는 일일이 나눠서 나머지를 출력하는 일반 함수, 하나는 재귀함수로 풀어봤습니다.
def TentoN(x, n):
num = []
q = x // n
atof = ['A', 'B', 'C', 'D', 'E', 'F']
while q != 0:
q, r = divmod(x, n)
if r >= 10:
r = atof[r-10]
num.insert(0, str(r))
x = q
return ''.join(num)
# 재귀함수
def TentoN(x, n):
L = '0123456789ABCDEF'
q, r = divmod(x, n)
if x == 0:
return 0
TentoN(q, n)
print L[r],
def num_p(n,p):
np = []
while n >= p:
remain = n % p
np = [remain] + np
n = int((n - remain) / p)
return [n]+np
#include <iostream>
using namespace std;
void in_arr(int* arr, int num, int np,int rem);
void print_arr(int* arr,int np);
int main(void)
{
int num,num1;
int rem, np = 0;
int* arr;
cout << "입력할 숫자: ";
cin >> num;
cout << "변환할 진수: ";
cin >> rem;
for (int i = num; i > 0; i= i / rem)
np++;
arr = new int[np];
in_arr(arr, num, np,rem);
print_arr(arr,np);
}
void in_arr(int* arr, int num, int np, int rem)
{
for (int i = 0; i < np; i++)
{
arr[i] = num % rem;
num = num / rem;
}
}
void print_arr(int *arr,int np)
{
for (int i = 0; i < np; i++)
{
switch (arr[i])
{
case 10:
{
cout << 'A';
break;
}
case 11:
{
cout << 'B';
break;
}
case 12:
{
cout << 'C';
break;
}
case 13:
{
cout << 'D';
break;
}
case 14:
{
cout << 'E';
}
case 15:
{
cout << 'F';
break;
}
default:
cout << arr[i];
}
}
}
def change(m,n):
list1 = []
while m > n:
a = m % n
list1.append(a)
m = m // n
list1.append(m)
list1.reverse()
return list1
print(change(233,2))
PHP
$fn = function(int $num, int $n) : string {
$dgt = str_split("0123456789ABCDEF");
$arr = [];
if (2 <= $n && $n <= 16) {
while ($num > $n) {
$arr[] = $dgt[$num % $n];
$num = floor($num / $n);
}
$arr[] = $dgt[$num];
}
return implode(array_reverse($arr));
};
print_r($fn(233, 2)); // 11101001
print_r($fn(233, 8)); // 351
print_r($fn(233, 16)); // E9
def decimal(a, b):
result = []
while a // b != 0:
result.insert(0, str(a%b))
a = a // b
result.insert(0, str(a%b))
return ''.join(result)
print(decimal(200, 8))
Python 3.7
def con(n, base):
a = '0123456789ABCDEF'
re = ''
while n > 0:
n, r = divmod(n, base)
re = a[r] + re
return re
import java.util.*;
import javax.xml.transform.stream.StreamSource;
public class 십진수를n진수로변환하기 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
int n = scan.nextInt();
ArrayList<String> list = new ArrayList<String>();
char digit;
for(int i=0;; i++) {
if(n>=10) {
if(num%n<10) {
digit = (char)(num%n+48);
list.add(Character.toString(digit));
}
else if(num%n>=10) {
digit = (char)(num%n+55);
list.add(Character.toString(digit));
}
num = num/n;
if(num<n) {
if(num>=10) {
digit = (char)(num+55);
list.add(Character.toString(digit));
break;
}
else {
digit = (char)(num+48);
list.add(Character.toString(digit));
break;
}
}
}
else if(n<10) {
list.add(Integer.toString(num%n));
num = num/n;
if(num<=n) {
list.add(Integer.toString(num));
break;
}
}
}
Collections.reverse(list);
String changed = String.join("", list);
System.out.println(changed);
}
}
11,12,13,14진수 다 가능합니다.
파이썬 3.6 입니다
def remainder_helper(remainder):
if remainder < 10:
return str(remainder)
elif 10 <= remainder < 16:
return chr(65 + (remainder - 10))
else:
raise ValueError("Only supported for base up to 16 - i.e. Hexadecimal")
def change_base(n, base, result=None):
if result == None:
result = []
if n // base == 0:
result.append(remainder_helper(n % base))
result.reverse()
return "".join(result)
else:
result.append(remainder_helper(n % base))
return change_base((n // base), base, result)
print(change_base(233, 2))
print(change_base(233, 16))
print(change_base(233, 8))
num=int(input("10진수를 입력하십시오: "))
k=int(input("n(2<=n<=16)을 입력하십시오: "))
d="0123456789ABCDEF"
def change(num,k):
if k<2 or k>16:
return "ERROR!!! Out of range"
q,r=divmod(num,k)
if q==0:
return d[r]
else:
return change(q,k)+d[r]
print(change(num,k))
python 3.8
a=int(input()) # 10진수 입력
b=int(input()) # 2~16진수 입력
t='0123456789ABCDEF'
c=' '
while a!= 0:
c=t[a%b]+c # 나머지 구하여 문자열로 처리
a=int(a/b) # << 진수 자리 이동
print(c)
print('input decimal number?',end='')
num=int(input())
print('which numeral system do you want (2~16)?',end='')
ns=int(input())
convert=[]
print (str(num)+'[10]=',end='')
while(num>1):
convert.append(num%ns)
num=num//ns
if (num!=0):
convert.append(num)
i=len(convert)-1
while(i>-1):
if (convert[i]>9):
print (chr(int(convert[i])+55),end='')
else:
print(convert[i],end='')
i=i-1
print('['+str(ns)+']')
#include <iostream>
#include <stack>
using namespace std;
/*
라이브러리를 사용하지 말고 10진수를 n진수로 변환하는 프로그램을 작성하시오.. (단, n의 범위는 2 <= n <= 16)
예)
2진수로 변환 : 23310 --> 11101001(2)
8진수로 변환 : 23310 --> 351(8)
16진수로 변환 : 23310 --> E9(16)
*/
void Func(int k,int n) {
if (k <= 0) { cout << "0보다 큰수만 변환 할수있음" << endl; return; }
if (n < 2 || n>16) { cout << "2진수부터 16진수까지만 변환이 가능" << endl; return; }
cout << "숫자" << k << "를" << n << "진수로 변환" << endl;
cout << k<<"->";
int mok=INT_MAX;
int namerge;
stack<int> s;
int ch;
while (1) {
if (mok == 0)break;
if (mok == INT_MAX) {
mok = k / n;
namerge = k%n;
}
else {
namerge = mok %n;
mok = mok / n;
}
s.push(namerge);
}
for (int i = 0; s.size(); i++) {
ch = s.top();
s.pop();
if (ch == 10) { cout << 'A'; }
else if (ch == 11) { cout << 'B'; }
else if (ch == 12) { cout << 'C'; }
else if (ch == 13) { cout << 'D'; }
else if (ch == 14) { cout << 'E'; }
else if (ch == 15){ cout << 'F'; }
else { cout << ch; }
}
cout << endl;
}
int main() {
Func(233, 2);
Func(233, 8);
Func(233, 16);
}
class ConversionD:
def __init__(self):
self.stack = []
def bdigit(self, dec, digi):
self.dec = dec
while (dec//digi) != 0:
self.stack.append(str(dec % digi))
dec //= digi
self.stack.append('ABCDEF'[dec-10] if dec > 8 else str(dec))
self.stack.reverse()
return self.stack
if __name__ == '__main__':
dec = 233
digi = [2, 8, 16]
for d in digi:
digit = ConversionD()
print('{}의 {}진수 변환값: {}'.format(dec, d, ''.join(digit.bdigit(dec, d))))
def convert(Num=0, Base=2):
num = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']
result = ''
division = Num // Base
remain = Num % Base
if division < Base:
return num[division] + num[remain]
else:
result = convert(division, Base)
return result + num[remain]
print(convert(233, 2))
print(convert(233, 8))
print(convert(233, 16))
print(convert(4, 2))
파이썬 재귀함수로 작성하면서 숫자 뒷부분에 진수를 나타내는 표현을 넣어보려했는데 잘 넣지 못해서 변환된 숫자가 나오게 밖에는 못했네요 반복문이 아닌 재귀함수에서 진수변환 숫자뒤에 진수표시를 넣을 수 있을까요??
Nums = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def change(n,i):
str1 = ""
while n != 0:
if n % i == 0:
str1 += "0"
else:
str1 += str(Nums[n%i])
n = n // i
return(str1)[::-1]
print(change(233,2))
print(change(233,8))
print(change(233,16))
def convert(num,N):
list_a=[]
while num>0:
if N>=10 and num%N>=10:
list_a.append(chr(num%N+55))
else:
list_a.append(str(num%N))
num=num//N
return "".join(list(reversed(list_a)))
num=int(input("정수 입력 : "))
while True:
N=int(input("몇 진수로 변환 ?(0 종료)"))
if N==0:
break
print(convert(num,N))
table={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,
10:'A', 11:'B',12:'C',13:'D',14:'E',15:'F'}
def find_jinsu(n,k):
jinsu = []
while n >0:
for b in range(1,k):
if n%k == b:
jinsu.append(b)
n = (n-b)/k
elif n%k == 0:
jinsu.append(0)
n = n/k
else:
continue
for i in range(0,len(jinsu)):
if int(jinsu[i]) > 10:
jinsu[i] = table[int(jinsu[i])]
return jinsu[::-1]
package test;
import java.util.*;
public class Test{
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int digit = sc.nextInt();
while(num != 0) {
stack.push(num % digit);
num /= digit;
}
while(!stack.empty()) {
if(stack.peek() >= 10) {
switch(stack.peek()) {
case 10 : System.out.print("A");stack.pop(); break;
case 11 : System.out.print("B");stack.pop(); break;
case 12 : System.out.print("C");stack.pop(); break;
case 13 : System.out.print("D");stack.pop(); break;
case 14 : System.out.print("E");stack.pop(); break;
case 15 : System.out.print("F");stack.pop(); break;
}
}
System.out.print(stack.pop());
}
sc.close();
}
}
import java.util.*;
public class test10 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("수를 입력하시오 : ");
int n = scanner.nextInt();
System.out.print("진수를 입력하시오 : ");
int m = scanner.nextInt();
Stack<Integer> stack = new Stack<>();
while(true) {
stack.push(n % m);
n = n / m;
if (n == 0) {
break;
}
}
System.out.print("결과 : ");
while(!stack.isEmpty()) {
int temp = stack.pop();
if(temp >= 10) {
switch(temp - 10) {
case 0: {
System.out.print("A");
break;
}
case 1: {
System.out.print("B");
break;
}
case 2: {
System.out.print("C");
break;
}
case 3: {
System.out.print("D");
break;
}
case 4: {
System.out.print("E");
break;
}
case 5: {
System.out.print("F");
break;
}
}
} else {
System.out.print(temp);
}
}
scanner.close();
}
}
마지막 16진수 A-F까지를 어떻게 해야할지 몰라서 좀 멍청하게 해결했네요..ㅠㅠ
def dec2N(n, N):
result = ""
ABC = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
while n != 0:
result += ABC[n % N]
n = n // N
print(result[::-1]+"({})".format(N))
dec2N(233,2)
dec2N(233,8)
dec2N(233,16)
def change_number(numbers,ints):
for_answer=[]
while numbers>0:
for_answer.append(numbers%ints)
numbers=numbers//ints
answer=for_answer[::-1]
return answer
print(change_number(233,8))
def change(num,n):
remainder_list=[]
while True:
char_list='ABCDEFG'
if num<n:
if num>=10:
remainder_list.insert(0,char_list[num-10])
else:
remainder_list.insert(0,str(num))
break
else:
if num%n>=10:
remainder_list.insert(0,char_list[num%n-10])
else:
remainder_list.insert(0,str(num%n))
num=num//n
print(''.join(remainder_list),'({})'.format(n))
change(233,2)
change(233,8)
change(233,16)
def change(num, div):
result = []
q, r = num, div
while q > 0:
q, r = divmod(q, div)
if r > 10:
_remain = 'ABCDEF'
r = _remain[r-10]
result.append(str(r))
print(''.join(result[::-1]))
change(233,2)
change(233,8)
change(233,16)
a=[]
def Multiple(q,n):
if q==2:
a=[]
print("{}을 2진수로 변환한 값: ".format(n), end='')
while n>=1:
if n%2==0:
a.append('0')
else:
a.append('1')
n//=2
a.reverse()
for i in a:
print(i, end='')
print('\n')
if q==8:
a=[]
print("{}을 8진수로 변환한 값: ".format(n), end='')
while n>=1:
if n%8==0:
a.append('0')
else:
a.append(n%8)
n//=8
a.reverse()
for i in a:
print(i,end='')
print('\n')
if q==16:
a=[]
print("{}을 16진수로 변환한 값: ".format(n), end='')
while n>=1:
if n%16==0:
a.append('0')
else:
if n%16==10:
a.append('A')
elif n%16==11:
a.append('B')
elif n%16==12:
a.append('C')
elif n%16==13:
a.append('D')
elif n%16==14:
a.append('E')
elif n%16==15:
a.append('F')
else:
a.append(n%16)
n//=16
a.reverse()
for i in a:
print(i,end='')
print('\n')
Multiple(2,233)
Multiple(8,233)
Multiple(16,233)
너무 허접하게 풀었네요.. 2,8,16 진법밖에 모르는 저로선 이렇게 풀었어요... 초보탈출하고싶네요..
def conv(x, y):
s = ''
t = '0123456789ABCDEF'
while x > 0:
s += t[int(x % y)]
x = int(x//y)
s = s[::-1]
return s
print(conv(233,2))
print(conv(233,8))
print(conv(233,16))
def to_radix(n, b):
"""10진수를 n진수로 변환하기"""
if n < b:
return str(n)
s = to_radix(n//b, b)
return s + str(n%b)
n = int(input('십진수를 입력하세요: '))
b = int(input('구하고자 하는 n진수를 입력하세요.: '))
print(to_radix(n,b))
def change(a,b):
k = []
while a >= b:
d = a%b
k.append(str(d))
a = a//b
k.append(str(d))
return print(''.join(list(reversed(k))))
change(233,2)
change(233,8)
change(233,16)
2진법은 수가 맞게 나오는데 8,16진법은 답이 다르게 나오네요 흠
python 3.9.5입니다. 문자열의 slicing 기능을 활용하였습니다. 소스 코드입니다.
origin = int(input('변환할 10진수를 입력하세요. '))
base = int(input('n진수 변환에서 n을 입력하세요(단, 2 <= n <= 16). '))
q = origin
r = 0
result = ''
while q != 0:
r = q % base
result += str(r)
q //= base
result = result[::-1]
while result[0] == 0:
result = result[1:]
print(f'변환된 값은 {int(result)}입니다.')
실행 결과입니다.
변환할 10진수를 입력하세요. 233
n진수 변환에서 n을 입력하세요(단, 2 <= n <= 16). 2
변환된 값은 11101001입니다.
#codingdojing_10toN
n_dic = {
0: '0', 1:'1', 2:'2', 3:'3', 4:'4', 5:'5', 6:'6', 7:'7', 8:'8', 9:'9', 10:'A', 11:'B', 12:'C', 13:'D', 14:'E', 15:'A'
}
def _10toN(num, n):
result = ''
q, r = divmod(num, n)
while q > 0:
result = n_dic[r] + result
q, r = divmod(q,n)
result = n_dic[r] + result
print(f"{num}의 {n}진수는 {result}")
_10toN(233, 2)
_10toN(233, 8)
_10toN(233, 16)
_10toN(0, 5)
자바스크립트로 작성하였습니다.
toString 메소드의 기능을 사용하였습니다.
const change = function(input, to) {
return input.toString(to)
}
change(233, 2)
change(233, 8)
change(233, 16)
def Trans (a,n):
arr =[]
while a//n !=0 :
arr.append(a%n)
a //=n
arr.append(a%n)
for i in range(len(arr)) :
if arr[i]==10:
arr[i]="A"
elif arr[i]==11:
arr[i]="B"
elif arr[i]==12:
arr[i]="C"
elif arr[i]==13:
arr[i]="D"
elif arr[i]==14:
arr[i]="E"
elif arr[i]==15:
arr[i]="F"
return print("".join(list(map(str,reversed(arr)))),"(",n,"진수)")
Trans(233,2)
Trans(233,8)
Trans(233,16)
def n_trans(decimal,n):
answer = ""
while decimal/n >= 1:
i = str(decimal%n) if decimal%n < 10 else chr((decimal%n)+55)
answer += i
decimal = int(decimal/n)
i = str(decimal) if decimal < 10 else chr(decimal+55)
answer += i
return answer[::-1]
print(n_trans(233,2))
print(n_trans(233,8))
print(n_trans(233,16))
에라 모르겠다 하며 짰습니다. 너무 지저분한 점 죄송합니다.
n=int(input('몇진수? (n<=16) '))
x=int(input('어떤 값을 바꾸시겠습니까? '))
k=-1
while n**k<=x:
k+=1
k-=1
#n진수의 각 자릿수 설정
change=[]
for i in range(k,-1,-1):
num=0
if x>=n**i:
while x>=n**i:
x-=n**i
num+=1
change.append(str(num))
else:
change.append('0')
#숫자를 알파벳으로 바꿈
ch={'10':'A','11':'B','12':'C','13':'D','14':'E','15':'F'}
key=list(ch.keys())
val=list(ch.values())
for y in change:
for z in ch:
if y==z:
change[change.index(y)]=val[key.index(z)]
finish=''.join(change)
print(finish)
자바로 풀어보았습니다.
import java.util.Scanner;
import java.util.ArrayList;
public class calculator {
public static int checkRemain(int number, int N, ArrayList remain) {
String[] hexChar = {"A", "B", "C", "D", "E", "F"};
for(int i=10; i<16; i++) {
if(number%N==i)
remain.add(hexChar[i-10]);
}
if(number%N<10)
remain.add(String.valueOf(number%N));
number /= N;
return number;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
ArrayList<String> remain = new ArrayList<>();
String result = "";
// 입력
System.out.print("10진수를 입력:");
int number = scan.nextInt();
System.out.print("변환하고자 하는 N진수 입력:");
int N = scan.nextInt();
// 변환 (나머지)
while(number>=N) {
number = checkRemain(number, N, remain);
}
// 몫
number = checkRemain(number, N, remain);
// 결과 출력
for(int i=remain.size()-1; i>=0; i--)
result += remain.get(i);
System.out.printf("결과: %s\n", result);
}
}
def Xn(X,n):
if X == 0: return f'0({n})'
result = [f'({n})']
numbers = '0123456789ABCDEF'
while X > 0:
result.insert(0,numbers[X % n])
X = X // n
return ''.join(result)
print(Xn(233, 2))
print(Xn(233, 8))
print(Xn(233, 16))
def Deci_to_num(num, transnum):
if transnum > 16 or num <= 0:
print('Error')
return
nums, result, k = num, [], 0 # 변환되는 값들, 나누어지는값 표시
print(str(transnum) + '진수로 변환 : ' + str(num) + ' -> ', end ='')
while nums > 0:
result, k = result+[int(nums % transnum)], k+1
nums = num // (transnum**k)
for i in range(1, len(result) + 1):
print(result[-i] if result[-i] < 10 else chr(ord('A')+result[-i]-10), end ='')
num = input('10진수를 n진수로 변환하는 프로그램입니다. \n변환시킬 양의 정수를 입력해주세요 : ')
transnum = input('n에 해당하는 값을 입력해주세요.(단, 2 <= n <= 16) : ')
Deci_to_num(int(num), int(transnum))
아스키 코드를 이용해 변환할 수 있게 작성하였습니다.