10

하나의 숫자 기본 시스템에서 블록 배열을 취하는 루틴을 작성하고 다른 숫자 기본 시스템에서 블록 배열로 변환하십시오. 시작 및 종료 시스템은 모두 임의적이며 매개 변수로 승인되어야합니다. 입력 배열은 임의의 길이 일 수 있습니다 (C와 같이 배열에 배열 길이가 저장되지 않은 언어를 사용하는 경우 길이 매개 변수가 함수에 전달되어야 함).

작동 방식은 다음과 같습니다.

fromArray = [1, 1]
fromBase = 256
toBase = 16
result = convertBase(fromArray, fromBase, toBase);

반환해야 할 [0, 1, 0, 1]수도 있고 가능할 수도 있습니다 [1, 0, 1]( 0대답은 값을 변경하지 않으므로 선택 사항 임).

다음은 몇 가지 테스트 벡터입니다.

신원 테스트 벡터

fromArray = [1, 2, 3, 4]
fromBase = 16
toBase = 16
result = [1, 2, 3, 4]

사소한 테스트 벡터

fromArray = [1, 0]
fromBase = 10
toBase = 100
result = [10]

큰 테스트 벡터

fromArray = [41, 15, 156, 123, 254, 156, 141, 2, 24]
fromBase = 256
toBase = 16
result = [2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]

정말 큰 테스트 벡터

fromArray = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
fromBase = 2
toBase = 10
result = [1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]

고르지 않은 기본 벡터

fromArray = [41, 42, 43]
fromBase = 256
toBase = 36
result = [1, 21, 29, 22, 3]

다른 기준 / 규칙 :

모든 정수 변수는 모든 제네릭 입력 범위에 대해 표준 32 비트 부호있는 정수에 맞아야합니다.
중개자가 32 비트 부호있는 정수의 배열에 지나지 않는 한 중개 표현으로 변환 할 수 있습니다.
2에서 256 사이의베이스를 처리 할 것으로 예상됩니다. 그보다 더 높은베이스를 지원할 필요는 없습니다 (그러나 원한다면 꼭).
최소 1000 개의 요소까지 입력 및 출력 크기를 처리 할 것으로 예상됩니다 . 2 ^ 32-1 요소로 확장되는 솔루션이 더 좋지만 1000은 괜찮습니다.
이것은 반드시 이러한 규칙을 충족하는 가장 짧은 코드를 갖는 것은 아닙니다. 가장 깨끗하고 가장 우아한 코드를 만드는 것입니다.

이제는 이것이 쉬운 일이 아니므로 거의 효과가 있는 대답이 받아 들여질 수 있습니다!

code-challenge number

— ircmaxell
소스

# 1은 bigint 유형을 사용할 수 없음을 의미합니까?

— Keith Randall

@Keith : 맞습니다. 32 비트 정수만

— ircmaxell

"부호있는 정수"라고 말하지만 예제는 양의 정수만을위한 것이므로 음수를 처리해야합니까?

— Eelvex

@ Elvex : 부정적인 것을 처리 할 필요가 없습니다. 네거티브가 처리되면 컨버터 외부에 있습니다.

— ircmaxell

그들은 항상 정수 염기입니까?

— 피터 올슨

8

파이썬

# divides longnum src (in base src_base) by divisor
# returns a pair of (longnum dividend, remainder)
def divmod_long(src, src_base, divisor):
  dividend=[]
  remainder=0
  for d in src:
    (e, remainder) = divmod(d + remainder * src_base, divisor)
    if dividend or e: dividend += [e]
  return (dividend, remainder)

def convert(src, src_base, dst_base):
  result = []
  while src:
    (src, remainder) = divmod_long(src, src_base, dst_base)
    result = [remainder] + result
  return result

— 키이스 랜달
소스

감사합니다. 나는 이런 루틴을 찾고있었습니다. 그래도 Javascript로 변환하는 데 시간이 걸렸습니다. 아마 약간 골프를 치고 재미를 위해 여기에 게시 할 것입니다.

— Stephen Perelson

5

하스켈 솔루션은 다음과 같습니다.

import Data.List
import Control.Monad

type Numeral = (Int, [Int])

swap              ::  (a,b) -> (b,a)
swap (x,y)        =   (y,x)

unfoldl           ::  (b -> Maybe (b,a)) -> b -> [a]
unfoldl f         =   reverse . unfoldr (fmap swap . f)

normalize         ::  Numeral -> Numeral
normalize (r,ds)  =   (r, dropWhile (==0) ds)

divModLongInt            ::  Numeral -> Int -> (Numeral,Int)
divModLongInt (r,dd) dv  =   let  divDigit c d = swap ((c*r+d) `divMod` dv)
                                  (remainder, quotient) = mapAccumR divDigit 0 (reverse dd)
                             in   (normalize (r,reverse quotient), remainder)

changeRadixLongInt       ::  Numeral -> Int -> Numeral
changeRadixLongInt n r'  =   (r', unfoldl produceDigit n)
  where  produceDigit  (_,[])   =  Nothing
         produceDigit  x        =  Just (divModLongInt x r')

changeRadix :: [Int] -> Int -> Int -> [Int]
changeRadix digits origBase newBase = snd $ changeRadixLongInt (origBase,digits) newBase

doLine line = let [(digits,rest0)] = reads line
                  [(origBase,rest1)] = reads rest0
                  [(newBase,rest2)] = reads rest1
              in show $ changeRadix digits origBase newBase

main = interact (unlines . map doLine . lines)

그리고 질문에서 테스트를 실행하십시오.

$ ./a.out 
[1,2,3,4] 16 16
[1,2,3,4]
[1,0] 10 100
[10]
[41, 15, 156, 123, 254, 156, 141, 2, 24] 256 16
[2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 2 10
[1,2,3,7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3]
[41, 42, 43] 256 36
[1,21,29,22,3]

— 제프 리드
소스

오 와우. 대단해! 이제, 내가 이해할 수만 있다면

— :-)

5

아르 자형

핸들 요소의 많은 수천 ^* 분 안에.

addb <- function(v1,v2,b) {
    ml <- max(length(v1),length(v2))
    v1 <- c(rep(0, ml-length(v1)),v1)
    v2 <- c(rep(0, ml-length(v2)),v2)
    v1 = v1 + v2
    resm = v1%%b
    resd = c(floor(v1/b),0)
    while (any(resd != 0)) {
        v1 = c(0,resm) + resd
        resm = v1%%b
        resd = c(floor(v1/b),0)
    }
    while (v1[1] == 0) v1 = v1[-1]
    return(v1)
}

redb <- function(v,b) {
    return (addb(v,0,b))
}

mm = rbind(1)

mulmat <- function(fromb, tob, n) {
    if (dim(mm)[2] >= n) return(mm)
    if (n == 1) return(1)
    newr = addb(mulmat(fromb,tob,n-1) %*% rep(fromb-1,n-1), 1, tob)
    newm = mulmat(fromb,tob,n-1)
    while (is.null(dim(newm)) || dim(newm)[1] < length(newr)) newm = rbind(0,newm)
    mm <<-  cbind(newr, newm)
    return(mm)
}

dothelocomotion <- function(fromBase, toBase, v) {
    mm  <<- rbind(1)
    return(redb(mulmat(fromBase, toBase, length(v)) %*% v, toBase))
}

^{* 500 개 이상의 원소의 경우 기본 재귀 수준을 높이 거나mm 매트릭스를 재설정하지 않아야합니다 .dothelocomotion()}

예 :

v1 = c(41, 15, 156, 123, 254, 156, 141, 2, 24)
dothelocomotion(256,16,v1)
2  9  0 15  9 12  7 11 15 14  9 12  8 13  0  2  1  8

dothelocomotion(256,36,c(41,42,43))
1 21 29 22  3

dothelocomotion(2,10, rep(1,90))
1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3

— 엘 벡스
소스

3

난독 화되고 빠른 JavaScript 버전 :

function convert (number, src_base, dst_base)
{
    var res = [];
    var quotient;
    var remainder;

    while (number.length)
    {
        // divide successive powers of dst_base
        quotient = [];
        remainder = 0;
        var len = number.length;
        for (var i = 0 ; i != len ; i++)
        {
            var accumulator = number[i] + remainder * src_base;
            var digit = accumulator / dst_base | 0; // rounding faster than Math.floor
            remainder = accumulator % dst_base;
            if (quotient.length || digit) quotient.push(digit);
        }

        // the remainder of current division is the next rightmost digit
        res.unshift(remainder);

        // rinse and repeat with next power of dst_base
        number = quotient;
    }

    return res;
}

계산 시간이 o (자리수 ² )로 증가합니다.
많은 수의 경우 매우 효율적이지 않습니다.
특수화 된 버전의 라인 base64 인코딩은 기본 비율을 활용하여 계산 속도를 높입니다.

신의 일을하는 아들

— bryc

2

자바 스크립트

Python 답변에 Keith Randall에게 감사드립니다. 나는 내 솔루션의 미세한 부분으로 고심하고 논리를 복사하게되었습니다. 이 솔루션이 작동하기 때문에이 솔루션에 투표하는 사람이 있다면 Keith의 솔루션에도 투표하십시오.

function convert(src,fb,tb){
  var res=[]
  while(src.length > 0){
    var a=(function(src){
      var d=[];var rem=0
      for each (var i in src){
        var c=i+rem*fb
        var e=Math.floor(c/tb)
        rem=c%tb
        d.length||e?d.push(e):0
      }
      return[d,rem]
    }).call(this,src)
    src=a[0]
    var rem=a[1]
    res.unshift(rem)
  }
  return res
}

테스트

console.log(convert([1, 2, 3, 4], 16, 16))
console.log(convert([1, 0], 10, 100))
console.log(convert([41, 15, 156, 123, 254, 156, 141, 2, 24], 256, 16))
console.log(convert([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 2, 10))
console.log(convert([41, 42, 43], 256, 36))

/*
Produces:
[1, 2, 3, 4]
[10]
[2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8]
[1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3]
[1, 21, 29, 22, 3]
*/

이것은 아마도 많이 줄어들 수 있지만 실제로는 작은 측면 프로젝트에 사용하고 싶습니다. 그래서 나는 그것을 읽을 수있게 (약간) 유지하고 변수를 확인하려고했습니다.

— 스티븐 페럴 슨
소스

자바 스크립트는 어떻습니까? 각각?

— Hernán Eche

3 자 이상의 변수 이름, 더 이상 사용되지 않는 for each문장 및 눈물을 흘리는 구문이 없습니다 d.length||e?d.push(e):0... 이것은 난독 화 된 코드 도전입니까? 이해하기 쉬운 구문과 더 나은 성능으로 같은 것을 작성할 수 있습니다.

@kuroineko 이것은 코드 골프입니다. 무엇을 기대 했습니까? 최신 표준을 사용하여 깨끗하고 읽기 쉬운 코드? 나는 내 대답이 완벽하다고 주장하지 않았으며 프로덕션 프로젝트에서와 같이 사용하지 않을 것입니다.

— Stephen Perelson

글쎄, 실제로 어떤 이유로 JavaScript 에서이 알고리즘이 필요했고 파이썬 솔루션을 기본으로 사용하여 처음부터 다시 작성해야했습니다. 귀하의 기여에 감사 드리지만 실질적인 목적으로 모든 IMHO에서 거의 사용이 불가능했습니다.

2

매스 매 티카

변수가 정의되지 않았으며 메모리에 맞는 한 모든 입력이 허용됩니다.

f[i_, sb_, db_] := IntegerDigits[FromDigits[i, sb], db];

테스트 드라이브:

f[{1,2,3,4},16,16]
f[{1,0},10,100]
f[{41,15,156,123,254,156,141,2,24},256,16]
f[{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},2,10]
f[{41,42,43},256,36]

밖

{1,2,3,4}
{10}
{2,9,0,15,9,12,7,11,15,14,9,12,8,13,0,2,1,8}
{1,2,3 7,9,4,0,0,3,9,2,8,5,3,8,0,2,7,4,8,9,9,1,2,4,2,2,3}
{1,21,29,22,3}

— 닥터 벨리 사리우스
소스

1

스칼라 :

def toDecimal (li: List[Int], base: Int) : BigInt = li match {                       
  case Nil => BigInt (0)                                                             
  case x :: xs => BigInt (x % base) + (BigInt (base) * toDecimal (xs, base)) }  

def fromDecimal (dec: BigInt, base: Int) : List[Int] =
  if (dec==0L) Nil else (dec % base).toInt :: fromDecimal (dec/base, base)

def x2y (value: List[Int], from: Int, to: Int) =
  fromDecimal (toDecimal (value.reverse, from), to).reverse

테스트가 포함 된 테스트 코드 :

def test (li: List[Int], from: Int, to: Int, s: String) = {
 val erg= "" + x2y (li, from, to)
 if (! erg.equals (s))
   println ("2dec: " + toDecimal (li, from) + "\n\terg: " + erg + "\n\texp: " + s)
}   

 test (List (1, 2, 3, 4), 16, 16, "List(1, 2, 3, 4)")
 test (List (1, 0), 10, 100, "List(10)")
 test (List (41, 15, 156, 123, 254, 156, 141, 2, 24), 256, 16, "List(2, 9, 0, 15, 9, 12, 7, 11, 15, 14, 9, 12, 8, 13, 0, 2, 1, 8)") 
 test (List (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), 
   2, 10, "List(1, 2, 3, 7, 9, 4, 0, 0, 3, 9, 2, 8, 5, 3, 8, 0, 2, 7, 4, 8, 9, 9, 1, 2, 4, 2, 2, 3)") 
 test (List (41, 42, 43), 256, 36, "List(1, 21, 29, 22, 3)")

모든 테스트를 통과했습니다.

— 알 수없는 사용자
소스

1

J, ¹⁰⁹ 105

땀없이 수천 자리를 처리합니다. 정수가 손상되지 않았습니다!

e=:<.@%,.|~
t=:]`}.@.(0={.)@((e{:)~h=:+//.@)^:_
s=:[t[:+/;.0]*|.@>@(4 :'x((];~[t((*/e/)~>@{.)h)^:(<:#y))1')

예

256 16 s 41 15 156 123 254 156 141 2 24
2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8

256 36 s 41 42 43
1 21 29 22 3

16 16 s 1 2 3 4
1 2 3 4

256 46 s ?.1000$45
14 0 4 23 42 7 11 30 37 10 28 44 ...

time'256 46 s ?.3000$45'  NB. Timing conversion of 3000-vector.
1.96s

짧아집니다.

— 엘 벡스
소스

0

스몰 토크, 128

o:=[:n :b|n>b ifTrue:[(o value:n//b value:b),{n\\b}]ifFalse:[{n}]].
f:=[:a :f :t|o value:(a inject:0into:[:s :d|s*f+d])value:t].

테스트 :

f value:#[41 15 156 123 254 156 141 2 24]
  value:256
  value:16. 
    -> #(2 9 0 15 9 12 7 11 15 14 9 12 8 13 0 2 1 8)

f value:#[1 2 3 4]
  value:16
  value:16.
    -> #(1 2 3 4)

f value:#[1 0]
  value:10
  value:100.
    -> #(10)

f value:#[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
  value:2
  value:10.
    -> #(1 2 3 7 9 4 0 0 3 9 2 8 5 3 8 0 2 7 4 8 9 9 1 2 4 2 2 3)

f value:#[41 42 43]
  value:256
  value:36.
    -> #(1 21 29 22 3)

그리고 당신의 특별한 즐거움을 위해 ( 도전 : 입력 값에 대해 특별한 점을 알아 내십시오 ) :

f value:#[3 193 88 29 73 27 40 245 35 194 58 189 243 91 104 156 144 128 0 0 0 0]
  value:256
  value:1000.
    -> #(1 405 6 117 752 879 898 543 142 606 244 511 569 936 384 0 0 0)

— blabla999
소스