मिश्रित आधार रूपांतरण

Question

पृष्ठभूमि

यहाँ पर अधिकांश लोग कई आधार प्रणालियों से परिचित होने चाहिए: दशमलव, बाइनरी, हेक्साडेसिमल, ऑक्टल। हेक्साडेसिमल प्रणाली में, संख्या 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]। सही-सबसे आधार न्यूनतम महत्वपूर्ण अंक से मेल खाता है । फिर आप आधारों (बाईं ओर) से गुजरते हैं जैसे ही आप अंकों (बाईं ओर) से गुजरते हैं, चारों ओर लपेटते हैं यदि आधार से अधिक अंक हैं।

आगे पढ़ने के लिए, विकिपीडिया देखें ।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें, जो Dएक इनपुट बेस Iऔर आउटपुट बेस के अंकों की एक सूची दी गई है, जो आधार से आधार Oद्वारा दर्शाए गए पूर्णांक को धर्मान्तरित करता है । आप STDIN, ARGV या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं और परिणाम को वापस कर सकते हैं या इसे STDOUT में प्रिंट कर सकते हैं।DIO

आप मान सकते हैं:

• कि संख्या में Iऔर Oसब से अधिक हैं 1।
• Iऔर Oगैर खाली कर रहे हैं।
• इनपुट नंबर दिए गए आधार में मान्य है (यानी, आधार से बड़ा कोई अंक नहीं)।

Dखाली (प्रतिनिधित्व 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]     []

Comments

क्या मुझे आधार विवरण के रूप में एक अनंत सूची की आवश्यकता हो सकती है, या मुझे इसे स्वयं को सूचित करना होगा?

— जॉन ड्वोरक

@JanDvorak का मतलब है कि यदि आप आधार सूचियों की अपेक्षा कर सकते हैं कि पहले से ही सभी अंकों को कवर करने के लिए पर्याप्त संख्या में पुनरावृत्ति हो? नहीं, आपको अपने चारों ओर रैपिंग करनी होगी या फिर खुद को दोहराना होगा।

— मार्टिन एंडर

मैं मान रहा हूं कि आधार के रूप में एक खाली सूची प्राप्त करना यूबी है, लेकिन क्या हम मान सकते हैं कि अंकों की सूची गैर-रिक्त है? इसके अलावा, जीरो को पीछे छोड़ने की नीति क्या है?

— जॉन डेवोरक

अर्थात्, मुझे इनपुट पर एक खाली सूची से कोई आपत्ति नहीं है, लेकिन []अगर इनपुट है तो मैं इसका उत्पादन करना चाहूंगा[0]

— जॉन ड्वोरक

क्या मैं रिवर्स ऑर्डर (एलएसडी पहले) में अंकों की सूची का अनुरोध और उत्पादन कर सकता हूं?

— जॉन ड्वोरक

Answer 1

सीजेएम, 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. ";

सीजाम, ४ ९ ४ 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. ";

Comments

मैं सरणी रोटेशन का उपयोग बंद कर दिया है क्योंकि CJam यह है ... यह _{}?चाल वास्तव में साफ है।

— डेनिस

@ सोडो {}e|वही है।

— jimmy23013

क्या आप उपयोग करने वाले संस्करण के लिए स्पष्टीकरण जोड़ना चाहेंगे j? :)

— मार्टिन एंडर

@ मार्टिनबटनर ने किया।

— jimmy23013

Answer 2

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प्रिंट ""।

Comments

OMG ने कभी 62 बाइट्स CJam प्रोग्राम नहीं देखा: D

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र यह शायद मेरा सबसे लंबा सीजेएम सबमिशन है।

— एगलैंगिंग फ्रूट

@ चैलेंजर 5 कोडगॉल्फ.स्टैकएक्सचेंज.com

— डेनिस

@ डेनिस कोड-गोल्फ नहीं था, क्या यह था?

— एगलैंगिंग फ्रूट

@ Challenger5 यह नहीं था, लेकिन मुझे शक है कि एक गोल्फ संस्करण 200 बाइट्स से छोटा होगा।

— डेनिस

Answer 3

अजगर 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 [])

मैंने गलती से तर्कों के क्रम को गड़बड़ कर दिया, इसलिए मुझे उन्हें उल्टा करना पड़ा। मैं बाद में दूसरी दिशा में काम करने के लिए सूचियों को प्राप्त करने के लिए स्लाइस-फू पर काम करूंगा, मैंने पहले से ही अपना पूरा दोपहर का भोजन बर्बाद कर दिया: पी

फिक्स्ड

Comments

"बेकार" मत कहो;)

— मार्टिन एंडर

आपको इसे 286 बाइट्स तक नीचे ले जाने में सक्षम होना चाहिए: repl.it/JbIk

— Zacharý

@ Zacharý यह मेरा पहला गोल्फ था जो मुझे लगता है, मुझे यकीन है कि यह इससे बहुत कम हो सकता है! फेर्सम का जवाब दर्शाता है कि मुझे लगता है कि काफी अच्छा है। यदि आप चाहते हैं कि आप इस उत्तर को संपादित कर सकें, लेकिन मुझे डर है कि मैं इसे सुधारने के लिए विशेष रूप से प्रेरित नहीं हूं।

— FryAmTheEggman

Answer 4

एपीएल, 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

Comments

सामान्य शिक्षा के लिए - बिल्ट-इन के साथ: {{⍵↓⍨1⍳⍨×⍵}(99⍴⎕)⊤⍵⊥⍨⎕⍴⍨⍴⍵}डी को सही तर्क के रूप में लेता है, फिर I और O के लिए पूछता है

— Adám

Answer 5

अजगर 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

Ungolfed:

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

संपादित करें: 116-बाइट प्रोग्राम संस्करण 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

यह संस्करण अल्पविराम से अलग किए गए इनपुट को स्वीकार करता है [1,9,0,3,1,5], [2,10], [10]

Comments

@FryAmTheEggman मुझे यकीन नहीं है कि यह उद्धरण के साथ इनपुट को कैसे स्वीकार कर सकता है लेकिन कॉमा के कार्यों के साथ सरणियों को अलग कर सकता है।

— 20

Answer 6

k2 - 83 74 चार

एक तर्क लेने का कार्य। यह जम्मू की तुलना में कश्मीर के लिए बस एक बहुत बेहतर अनुकूल था, यही कारण है कि मैं जे का उपयोग नहीं कर रहा हूं। यह सिर्फ बॉक्सिंग / अनबॉक्सिंग कचरा का भार होगा, और कोई भी ऐसा नहीं चाहता है। यह k2 बोली में है (खुले स्रोत कार्यान्वयन कोनों में काम करने के लिए कुछ अनुकूलन की आवश्यकता हो सकती है), लेकिन मैं इसे k4 में बदल दूंगा अगर मैं इसे छोटा कर सकता हूं।

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

मैं ध्यान दूंगा कि मैं यहां अचार के लिए एक स्टैंड लेता हूं और कहता हूं कि एक आइटम सूची को इनपुट करना होगा। ,2एक आइटम की एक सूची है, वह आइटम स्केलर है 2। अक्सर स्केलर और 1-आइटम सूचियाँ विनिमेय होती हैं, लेकिन इस गोल्फ में तर्क है जो सूची तर्कों की धारणा पर निर्भर करता है।

गोल्फ को समझाने के लिए, मैं इसे दो भागों में तोड़ूँगा। Fगोल्फ है, Lमुख्य लूप है जो आउटपुट की गणना करता है। लूपिंग का सटीक तंत्र यह है कि Lइसके तर्कों को बार-बार लागू किया जाता है जब तक कि दूसरा तर्क शून्य न हो, फिर उस परिणाम को वापस कर दिया जाता है। (यह .[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
 ()
 ())

Answer 7

पर्ल 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*}

कोशिश करो