배경

여기에있는 대부분의 사람들은 십진, 이진, 16 진, 8 진 등 몇 가지 기본 시스템에 익숙해야합니다. 예를 들어 16 진수 시스템에서 숫자 12345 ₁₆ 은

1*16^4 + 2*16^3 + 3*16^2 + 4*16^1 + 5*16^0

일반적으로 기본 (여기서는 16)이 숫자에서 숫자로 변경 될 것으로 예상하지 않습니다 .

이러한 일반적인 위치 시스템의 일반화를 통해 각 숫자에 대해 다른 숫자 기반을 사용할 수 있습니다. 예를 들어 십진법과 이진법을 번갈아 가면서 (최소 수 자릿수의 10 진수로 시작) 숫자 190315 _[2,10] 은

1*10*2*10*2*10 + 9*2*10*2*10 + 0*10*2*10 + 3*2*10 + 1*10 + 5 = 7675

이 기준을로 표시합니다 [2,10]. 가장 오른쪽은 가장 작은 자릿수에 해당합니다 . 그런 다음 자릿수보다 왼쪽에있는 자릿수를 기준으로 자릿수보다 많은 자릿수가 있으면 왼쪽을 기준으로 자릅니다.

자세한 내용은 Wikipedia를 참조하십시오 .

도전

자릿수 목록에 D입력 기수 I와 출력 기수가 주어지면 base 에서 base 로 O표시되는 정수를 변환 하는 프로그램 또는 함수를 작성하십시오 . STDIN, ARGV 또는 함수 인수를 통해 입력을 받아 결과를 리턴하거나 STDOUT에 인쇄 할 수 있습니다.DIO

당신은 가정 할 수 있습니다 :

• 의 숫자 것을 I하고 O보다 모두 큰 1.
• I및 O비 비어 있습니다.
• 주어진 숫자에서 입력 번호가 유효 함 (즉, 숫자보다 큰 자릿수 없음).

D비어 있거나 (을 나타내는 0) 선행 0을 가질 수 있습니다. 출력에는 선행 0이 포함되지 않아야합니다. 특히, 나타내는 결과는 0빈 목록으로 반환되어야합니다.

내장 또는 타사 기본 변환 기능을 사용해서는 안됩니다.

이것은 코드 골프이며, 가장 짧은 대답 (바이트)이 이깁니다.

예

D               I                  O        Result
[1,0,0]         [10]               [2]      [1,1,0,0,1,0,0]
[1,0,0]         [2]                [10]     [4]
[1,9,0,3,1,5]   [2,10]             [10]     [7,6,7,5]
[1,9,0,3,1,5]   [2,10]             [4,3,2]  [2,0,1,1,0,1,3,0,1]
[52,0,0,0,0]    [100,7,24,60,60]   [10]     [3,1,4,4,9,6,0,0]
[0,2,10]        [2,4,8,16]         [42]     [1,0]
[]              [123,456]          [13]     []
[0,0]           [123,456]          [13]     []

CJam, 45

q~_,@m>0@{@(:T+@T*@+}/\;La{\)_@+@@md@@j@+}jp;

마침내 나는 좋은 사용법을 발견했다 j.

작동 원리

Long ArrayList Block j정수를 매개 변수로 사용하는 블록을 실행하고 블록 Long j에서이 블록을 재귀 적으로 호출합니다. 또한 블록에 의해 반환 된 값을 내부 배열에 저장하며 이는 배열 매개 변수에 의해 초기화됩니다. 입력이 이미 배열에있는 경우 블록을 실행하지 않고 배열의 값이 대신 반환됩니다.

따라서 빈 배열의 배열로 초기화하면 빈 배열이 입력 0에 대해 반환되고 블록은 다른 입력에 대해 실행됩니다.

q~_,@m>0@{@(:T+@T*@+}/\;     " See below. Stack: O decoded-D ";
La                           " Initialized the value with input 0 as empty list. ";
{
  \)_@+@@md@@                " See below. Stack: remainder O quotient ";
  j                          " Call this block recursively except when the same quotient has
                               appeared before, which is impossible except the 0.
                               Stack: remainder O returned_list ";
  @+                         " Append the remainder to the list. ";
}j
p;                           " Format and output, and discard O. ";

CJam, 49 48

q~_,@m>0@{@(:T+@T*@+}/\;{\)_@+@@md@@}h;;_{}?]W%`

입력은이어야합니다 O I D.

예 :

$ while read; do <<<$REPLY ./cjam-0.6.2.jar <(echo 'q~_,@m>0@{@(:T+@T*@+}/\;{\)_@+@@md@@}h;;_{}?]W%`');echo; done
[2] [10] [1 0 0]
[10] [2] [1 0 0]
[10] [2 10] [1 9 0 3 1 5]
[4 3 2] [2 10] [1 9 0 3 1 5]
[10] [100 7 24 60 60] [52 0 0 0 0]
[42] [2 4 8 16] [0 2 10]
[13] [123 456] []
[13] [123 456] [0 0]
[1 1 0 0 1 0 0]
[4]
[7 6 7 5]
[2 0 1 1 0 1 3 0 1]
[3 1 4 4 9 6 0 0]
[1 0]
""
""

작동 원리

q~           “ Read the input and evaluate. ";
_,@m>        " Rotate I to the right by the length of D. ";
0@{          " For each item in D, with the result initialized to 0: ";
  @(:T+      " Rotate I to the left, and set the original first item to T. ";
  @T*@+      " Calculate result * T + current. ";
}/
\;           " Discard I. ";
{            " Do: ";
  \)_@+      " Rotate O to the right, and get a copy of the original last item. ";
  @@md       " Calculate divmod. ";
  @@         " Move O and the quotient to the top of the stack. ";
}h           " ...while the quotient is not 0. ";
;;           " Discard O and the last 0. ";
_{}?         " If the last item is still 0, discard it. ";
]W%          " Collect into an array and reverse. ";
`            " Turn the array into its string representation. ";

CJam, 62 61 59 57 바이트

q~Wf%~UX@{1$*@+\@(+_W=@*@\}/;\;{\(+_W=@\md@@}h;;]W%_0=!>p

[O I D]STDIN에서 와 같이 입력 배열을 읽습니다 . 온라인으로 사용해보십시오.

작동 원리

q~         " Read from STDIN and evaluate the input. Result: [O I D]                      ";
Wf%~       " Reverse each of the three arrays and dump them on the stack.                 ";
UX@        " Push U (0) and X (1); rotate D on top of both.                               ";
{          " For each N in D:                                                             ";
  1$*      "   N *= X                                                                     ";
  @+       "   U += N                                                                     ";
  \@(+     "   I := I[1:] + I[:1]                                                         ";
  _W=@*    "   X *= I[-1]                                                                 ";
  @\       "   ( U I X ) ↦ ( I U X )                                                      ";
}/         "                                                                              ";
;\;        " Discard I and X.                                                             ";
{          " R := []; Do:                                                                 ";
  \(+      "   O := O[1:] + O[:1]                                                         ";
  _W=@\md  "   R += [U / O[-1]], U %= O[-1]                                               ";
  @@       "   ( O U R[-1] ) ↦ ( R[-1] O U )                                              ";
}/         " While U                                                                      ";
;;]        " Discard U and O.                                                             ";
W%         " Reverse R.                                                                   ";
_0=!>      " Execute R := R[!R[0]:] to remove a potential leading zero.                   ";
p          " Print a string presentation of R.                                            ";

테스트 사례

$ cjam mixed-base.cjam <<< '[ [2]     [10]             [1 0 0]       ]'
[1 1 0 0 1 0 0]
$ cjam mixed-base.cjam <<< '[ [10]    [2]              [1 0 0]       ]'
[4]
$ cjam mixed-base.cjam <<< '[ [10]    [2 10]           [1 9 0 3 1 5] ]'
[7 6 7 5]
$ cjam mixed-base.cjam <<< '[ [4 3 2] [2 10]           [1 9 0 3 1 5] ]'
[2 0 1 1 0 1 3 0 1]
$ cjam mixed-base.cjam <<< '[ [10]    [100 7 24 60 60] [52 0 0 0 0]  ]'
[3 1 4 4 9 6 0 0]
$ cjam mixed-base.cjam <<< '[ [42]    [2 4 8 16]       [0 2 10]      ]'
[1 0]
$ cjam mixed-base.cjam <<< '[ [13]    [123 456]        []            ]'
""
$ cjam mixed-base.cjam <<< '[ [13]    [123 456]        [0 0]         ]'
""

빈 문자열과 빈 배열은 CJam과 구분할 수 없으므로 []p인쇄합니다 "".

파이썬 2-318

from operator import *
d,i,o=input()
c=len
def p(l):return reduce(mul,l,1)
n=sum(x[1]*p((i[-x[0]%c(i)-1:]+x[0]/c(i)*i)[1:]) for x in enumerate(d[::-1]))
r=[]
j=1
t=[]
k=c(o)
while p(t)*max(o)<=n:t=(o[-j%k-1:]+j/k*o)[1:];j+=1
while j:j-=1;t=(o[-j%k-1:]+j/k*o)[1:];r+=[n/p(t)];n%=p(t)
print (r if r[0] else [])

나는 우연히 논증의 순서를 엉망으로 만들었습니다. 나는 목록을 다른 방향으로 작동시키기 위해 slice-fu에서 작업 할 것입니다. 나는 이미 전체 점심 시간을 낭비했습니다 : p

결정된

APL, 78

{1↓(⊃1⌷⍺)({t←⍺[(⍴⍺)|⍴⍵]
(⌊0⌷⍵÷t)(t|0⌷⍵),1↓⍵}⍣{0=0⌷⍵}),+/(0,⍵)×⌽×\1,(⍴⍵)⍴⌽⊃0⌷⍺}

예 :

f←{1↓(⊃1⌷⍺)({t←⍺[(⍴⍺)|⍴⍵]
  (⌊0⌷⍵÷t)(t|0⌷⍵),1↓⍵}⍣{0=0⌷⍵}),+/(0,⍵)×⌽×\1,(⍴⍵)⍴⌽⊃0⌷⍺}
(,10)(,2) f 1 0 0
1 1 0 0 1 0 0
(,2)(,10) f 1 0 0
4
(2 10)(,10) f 1 9 0 3 1 5
7 6 7 5
(2 10)(4 3 2) f 1 9 0 3 1 5
2 0 1 1 0 1 3 0 1
(100 7 24 60 60)(,10) f 52 0 0 0 0
3 1 4 4 9 6 0 0
(2 4 8 16)(,42) f 0 2 10
1 0
(123 456)(,13) f ⍬

⍴(123 456)(,13) f ⍬
0
(123 456)(,13) f 0 0

⍴(123 456)(,13) f 0 0
0

파이썬 2-122

매우 간단하고, 이것에 대한 특별한 골프 트릭을 찾지 못했습니다.

def f(D,I,O):
 n,i,l=0,-len(D),[]
 for d in D:n=n*I[i%len(I)]+d;i+=1
 while n:i-=1;b=O[i%len(O)];l=[n%b]+l;n/=b
 return l

언 골프 드 :

def f(D,I,O):
    n = 0
    for i in range(len(D)):
        dn = len(D) - i
        n = n * I[-dn % len(I)] + D[i]
    l = []
    i = 0
    while n:
        i -= 1
        b = O[i%len(O)]
        l = [n%b] + l
        n /= b
    return l

편집 : FryAmTheEggman 덕분에 116 바이트 프로그램 버전

D,I,O=input()
n,i,l=0,-len(D),[]
for d in D:n=n*I[i%len(I)]+d;i+=1
while n:i-=1;b=O[i%len(O)];l=[n%b]+l;n/=b
print l

이 버전은 쉼표로 구분 된 입력을 허용합니다. 예 : [1,9,0,3,1,5], [2,10], [10]

K2 - 83 74 CHAR

하나의 인수를 취하는 함수. 이것은 J보다 K에 훨씬 더 적합했기 때문에 J를 사용하지 않는 것입니다. 그것은 단지 많은 권투 / 언 박싱 쓰레기 일 것이므로 아무도 그것을 원하지 않습니다. 이것은 k2 방언에 있지만 (오픈 소스 구현 Kona에서 작동하려면 약간의 조정이 필요할 수 있음), 더 짧게 골프를 치기 위해 이것을 k4로 변경합니다.

{:[#x@:|&~&\~x;|*{x 1}.[{_(x,y!*z;y%*z;1!z)}]/(();+/x*1*\(1-#x)#y;|z);()]}

나는 여기서 pickiness를지지하고 하나의 항목 목록을 입력해야한다고 언급 할 것입니다. ,2한 항목의 목록이며 해당 항목은 스칼라 2입니다. 스칼라와 1 개 항목 목록은 종종 변경 가능하지만이 골프에는 목록 인수의 가정에 의존하는 논리가 있습니다.

골프를 설명하기 위해 두 부분으로 나눕니다. F골프, L출력을 계산하는 주요 루프입니다. 루핑의 정확한 메커니즘은 L두 번째 인수가 0이 될 때까지 인수에 반복적으로 적용되어 결과가 반환된다는 것입니다. (이 .[L]/부분입니다.)

L: {_(x,y!*z;y%*z;1!z)}
F: {:[#x@:|&~&\~x;|*{x 1}.[L]/(();+/x*1*\(1-#x)#y;|z);()]}

폭발로 :

{_(x,y!*z;y%*z;1!z)}  /function, args x y z
  (      ;    ;   )   / update each arg as follows:
               1!z    /  new z: rotate z left
            *z        /  head of z (current base digit)
          y%          /  y divided by that
 _                    /  new y: floor of that
     y!*z             /  y modulo head of z
   x,                 /  new x: append that to old x

{:[#x@:|&~&\~x;|*{x 1}.[L]/(();+/x*1*\(1-#x)#y;|z);()]}  /function, args x y z
            ~x                                           /find the 0s in x
          &\                                             /find leading zeros
        &~                                               /indices of digits that aren't
    x@ |                                                 /those items from x, reverse order
    x :                                                  /assign to x
 :[#          ;                                      ]   /if length is 0:
                                                   ()    / return empty list
                                                  ;      /else:
                      .[L]/                              / loop L repeatedly
                 {x 1}                                   / until y = 0
                           (  ;               ;  )       / starting with args:
                            ()                           /  Lx: empty list
                                       1-#x              /  number of input digits, minus 1
                                      (    )#y           /  cyclically extend base leftward
                                   1*\                   /  running product, start at 1
                                 x*                      /  multiply digits by these
                               +/                        /  Ly: sum of the above
                                               |z        /  Lz: out base, reverse order
               |*                                        / first elem of result, reversed

행동 :

  {:[#x@:|&~&\~x;|*{x 1}.[{_(x,y!*z;y%*z;1!z)}]/(();+/x*1*\(1-#x)#y;|z);()]}[1 0 0; ,10; ,2]
1 1 0 0 1 0 0
  f:{:[#x@:|&~&\~x;|*{x 1}.[{_(x,y!*z;y%*z;1!z)}]/(();+/x*1*\(1-#x)#y;|z);()]}
  f[1 0 0; ,2; ,10]
,4
  f .' ((1 9 0 3 1 5; 2 10;           ,10)  /f apply each
>       (1 9 0 3 1 5; 2 10;           4 3 2)
>       (52 0 0 0 0;  100 7 24 60 60; ,10)
>       (0 2 10;      2 4 8 16;       ,42)
>       (();          123 456;        ,13)
>       (0 0;         123 456;        ,13))
(7 6 7 5
 2 0 1 1 0 1 3 0 1
 3 1 4 4 9 6 0 0
 1 0
 ()
 ())

펄 6 , 67 바이트

{[R,] [+]([R,](@^a)Z*1,|[\*] |[R,](@^b)xx*).polymod: |[R,](@^c)xx*}

시도 해봐

넓히는:

{  # bare block lambda with placeholder parameters @a,@b,@c

  [R,]    # reduce the following using reverse meta op ｢R｣ combined with ｢,｣ op
          # (shorter than ｢reverse｣)

    [+](  # sum

        [R,](@^a) # reverse of first argument

      Z[*]        # zipped using &infix:<*> with the following

        1,
        |                    # slip the following in (flattens)
          [\*]               # triangle reduce

            |[R,](@^b) xx*   # reverse of second argument repeated infinitely
    )

    .polymod: |[R,](@^c) xx* # moduli the reverse of third argument repeated
}

삼각형 감소가 무엇인지 확실하지 않은 경우 :

[\*] 1,2,3,4,5
# 1, 1*2, 1*2*3, 1*2*3*4, 1*2*3*4*5
# 1,   2,     6,      24,       120

입력을 역으로 가져 와서 역으로 출력하면 47 바이트가됩니다.

{[+](@^a Z*1,|[\*] |@^b xx*).polymod: |@^c xx*}

시도 해봐