Lý lịch

Hầu hết mọi người ở đây nên làm quen với một số hệ thống cơ bản: thập phân, nhị phân, thập lục phân, bát phân. Ví dụ, trong hệ thập lục phân, số 12345 ₁₆ sẽ đại diện cho

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

Lưu ý rằng chúng ta thường không mong đợi cơ sở (ở đây, 16) thay đổi từ chữ số sang chữ số.

Tổng quát hóa các hệ thống vị trí thông thường này cho phép bạn sử dụng một cơ sở số khác nhau cho mỗi chữ số. Ví dụ: nếu chúng ta xen kẽ giữa hệ thập phân và hệ nhị phân (bắt đầu bằng cơ sở 10 bằng chữ số có nghĩa ít nhất), số 190315 _[2,10] sẽ đại diện

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

Chúng tôi biểu thị cơ sở này là [2,10]. Cơ sở bên phải nhất tương ứng với chữ số có nghĩa ít nhất . Sau đó, bạn đi qua các căn cứ (bên trái) khi bạn đi qua các chữ số (bên trái), quấn quanh nếu có nhiều chữ số hơn căn cứ.

Để đọc thêm, xem Wikipedia .

Các thách thức

Viết chương trình hoặc hàm, đưa ra danh sách các chữ số Dmột cơ sở đầu vào Ivà cơ sở đầu ra O, chuyển đổi số nguyên được biểu thị Dtừ cơ sở Isang cơ sở O. Bạn có thể nhận đầu vào thông qua STDIN, ARGV hoặc đối số hàm và trả về kết quả hoặc in ra STDOUT.

Bạn có thể giả sử:

• các số trong Ivà Ođều lớn hơn 1.
• các Ivà Ođều là phòng không trống.
• số đầu vào là hợp lệ trong cơ sở đã cho (nghĩa là không có chữ số nào lớn hơn cơ sở của nó).

Dcó thể trống (đại diện 0) hoặc có thể có các số 0 đứng đầu. Đầu ra của bạn không được chứa các số 0 hàng đầu. Cụ thể, một kết quả đại diện 0nên được trả về dưới dạng một danh sách trống.

Bạn không được sử dụng bất kỳ chức năng chuyển đổi cơ sở tích hợp hoặc bên thứ ba nào.

Đây là mã golf, câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

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;

Cuối cùng tôi tìm thấy một sử dụng tốt j.

Làm thế nào nó hoạt động

Long ArrayList Block jthực thi khối lấy một số nguyên làm tham số và Long jsẽ gọi khối này theo cách đệ quy trong khối. Nó cũng sẽ lưu trữ các giá trị được trả về bởi khối trong một mảng bên trong, được khởi tạo bởi tham số mảng. Nó sẽ không thực thi khối nếu đầu vào đã có trong mảng và thay vào đó giá trị trong mảng được trả về.

Vì vậy, nếu tôi khởi tạo nó bằng một mảng của một mảng trống, mảng trống sẽ được trả về cho đầu vào 0 và khối sẽ được thực thi cho bất kỳ đầu vào nào khác.

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%`

Đầu vào nên được O I D.

Ví 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]
""
""

Làm thế nào nó hoạt động

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 byte

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

Đọc các mảng đầu vào như [O I D]từ STDIN. Hãy thử trực tuyến.

Làm thế nào nó hoạt động

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.                                            ";

Các trường hợp thử nghiệm

$ 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]         ]'
""

Lưu ý rằng chuỗi rỗng và mảng trống không thể phân biệt được với CJam, do đó, []pin "".

Con trăn 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 [])

Tôi đã làm xáo trộn trật tự của các cuộc tranh luận một cách tình cờ, vì vậy tôi phải đảo ngược chúng. Tôi sẽ làm việc trên lát cắt để đưa các danh sách hoạt động theo hướng khác sau, tôi đã lãng phí toàn bộ thời gian nghỉ trưa của mình: p

đã sửa

APL, 78

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

Ví dụ:

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

Con trăn 2 - 122

Rất đơn giản, đã không quản lý để tìm thấy bất kỳ thủ thuật golf đặc biệt trên cái này.

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

Ung dung:

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

Chỉnh sửa: Phiên bản chương trình 116 byte nhờ FryAmTheEggman

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

Phiên bản này chấp nhận đầu vào được phân tách bằng dấu phẩy, ví dụ: [1,9,0,3,1,5], [2,10], [10]

k2 - 83 74 char

Hàm lấy một đối số. Điều này chỉ phù hợp với K hơn J rất nhiều, đó là lý do tại sao tôi không sử dụng J. Nó sẽ chỉ là một đống rác thải / hộp không có hộp, và không ai muốn điều đó. Đây là phương ngữ k2 (có thể yêu cầu một số điều chỉnh để hoạt động trong triển khai mã nguồn mở Kona), nhưng tôi sẽ thay đổi điều này thành k4 nếu tôi có thể chơi golf ngắn hơn ở đó.

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

Tôi sẽ lưu ý rằng tôi có lập trường cho sự kén chọn ở đây và nói rằng một danh sách các mục phải được nhập như vậy. ,2là một danh sách của một mục, mục đó là vô hướng 2. Thông thường vô hướng và danh sách 1 mục có thể hoán đổi cho nhau, nhưng có logic trong môn đánh gôn này dựa trên giả định về các đối số danh sách.

Để giải thích về môn đánh gôn, tôi sẽ chia nó thành hai phần. Flà golf, Llà vòng lặp chính tính toán đầu ra. Cơ chế chính xác của vòng lặp được Láp dụng cho các đối số của nó nhiều lần cho đến khi đối số thứ hai bằng 0, sau đó kết quả đó được trả về. (Đây là .[L]/một phần.)

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

Bằng vụ nổ:

{_(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

Trong hành động:

  {:[#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
 ()
 ())

Perl 6 , 67 byte

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

Thử nó

Mở rộng:

{  # 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
}

Trong trường hợp bạn không chắc tam giác nào giảm:

[\*] 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

Nếu tôi có thể đảo ngược các đầu vào và xuất ngược lại, nó sẽ là 47 byte.

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

Thử nó