পটভূমি

দশমিক, বাইনারি, হেক্সাডেসিমাল, অক্টাল: এখানকার বেশিরভাগ লোকদের বেশ কয়েকটি বেস সিস্টেমের সাথে পরিচিত হওয়া উচিত। উদাহরণস্বরূপ, হেক্সাডেসিমাল সিস্টেমে, 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, পূর্ণসংখ্যা দ্বারা প্রতিনিধিত্ব পরিবর্তন করে Dবেস থেকে Iবেস O। আপনি STDIN, ARGV বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিতে পারেন এবং হয় ফলাফলটি ফেরত দিতে পারেন বা এটি STDOUT এ মুদ্রণ করতে পারেন।

আপনি ধরে নিতে পারেন:

যে সংখ্যা 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]     []

— মার্টিন ইন্ডার
সূত্র

বেসের বিবরণ হিসাবে আমার কি অসীম তালিকার প্রয়োজন, বা আমাকে নিজেই এটি অসম্পূর্ণ করতে হবে?

— জন ডিভোরাক

@ জনডভোরাক আপনার অর্থ আপনি যদি বেস তালিকাগুলি ইতিমধ্যে সমস্ত সংখ্যার আবরণ করার জন্য পর্যাপ্ত সংখ্যক পুনরাবৃত্তি আশা করতে পারেন? না, আপনার চারপাশে মোড়ানো বা নিজেকে পুনরাবৃত্তি করতে হবে।

— মার্টিন ইন্ডার

আমি বেসটি ইউবি হিসাবে খালি তালিকা পাওয়ার কথা ধরে নিই, তবে আমরা কী ধরে নিতে পারি যে অঙ্কগুলির তালিকাটি খালি নয়? এছাড়াও, শূন্যগুলি অনুসরণ করার নীতি কী?

— জন ডিভোরাক

যেমন, আমি ইনপুটের একটি খালি তালিকা কিছু মনে না করেন, কিন্তু আমি উত্পাদন করতে চাই []যদি ইনপুট[0]

— জন ডিভোরাক

আমি কি বিপরীত ক্রমে (প্রথমে এলএসডি) অঙ্কের একটি তালিকা অনুরোধ করতে এবং উত্পাদন করতে পারি?

— জন ডিভোরাক

6

সিজেম, 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. ";

সিজেম, 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. ";

— jimmy23013
সূত্র

আমি অ্যারে রোটেশনটি ব্যবহার বন্ধ করে দিয়েছি কারণ কেবল সিজেমে রয়েছে ... সেই _{}?কৌশলটি খুব ঝরঝরে।

— ডেনিস

@ সুডো {}e|একই রকম।

— জিমি 23013

আপনি কি সংস্করণটি ব্যবহার করে একটি ব্যাখ্যা যুক্ত করতে আপত্তি করবেন j? :)

— মার্টিন এন্ডার

@ মার্টিনবাটনার সম্পন্ন

— জিমি 23013

3

সিজেম, 62 61 59 57 বাইট

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

[O I D]এসটিডিআইএন হিসাবে ইনপুট অ্যারে পড়ুন। এটি অনলাইনে চেষ্টা করুন।

কিভাবে এটা কাজ করে

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

নোট করুন যে খালি স্ট্রিং এবং খালি অ্যারেগুলি সিজোমের সাথে পৃথক নয়, তাই []pপ্রিন্ট করে ""।

— ডেনিস
সূত্র

4

ওএমজি কখনও 62 বাইটস সিজেএম প্রোগ্রামটি দেখে নি: ডি

— অপ্টিমাইজার

@ অপ্টিমাইজার এটি সম্ভবত আমার দীর্ঘতম সিজেএম জমা।

— ফলটি Esolanging

@ চ্যালেঞ্জার 5 কোডগল্ফ.স্ট্যাক্কেঞ্জাওন.আ.এ

— ডেনিস

@ ডেনিস যে কোড-গল্ফ ছিল না , তাই না?

— 9:55

@ চ্যালেঞ্জার 5 এটি ছিল না তবে আমি সন্দেহ করি যে গল্ফযুক্ত সংস্করণটি 200 বাইটের চেয়ে কম হবে।

— ডেনিস

2

পাইথন 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 [])

আমি দুর্ঘটনাক্রমে যুক্তিগুলির ক্রমটি গণ্ডগোল করে দিয়েছি, তাই আমাকে তাদের বিপরীত করতে হয়েছিল। তালিকাগুলি অন্য দিকে কাজ করার জন্য পরে স্লাইস ফুতে কাজ করব, ইতিমধ্যে আমার পুরো মধ্যাহ্নভোজনে বিরতি নষ্ট করেছি: পি

ফিক্সড

— FryAmTheEggman
সূত্র

"বর্জ্য" বলবেন না;)

— মার্টিন ইন্ডার

আপনি এটিকে 286 বাইটে নামিয়ে আনতে সক্ষম হবেন: repl.it/JbIk

— Zacharý

@ জ্যাচারý এটি আমার প্রথম গল্ফ ছিল বলে আমি মনে করি, আমি নিশ্চিত যে এটি এর চেয়ে আরও ছোট হতে পারে! ফেয়ারসামের উত্তরটি আমার মনে হয় যে এটি যথেষ্ট ভাল। আপনি যদি চান তবে আপনি এই উত্তরটি সম্পাদনা করতে পারেন, তবে আমি ভয় করি যে আমি এটির উন্নতি করতে বিশেষত অনুপ্রাণিত হই না।

— FryAmTheEggman

2

এপিএল, 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

— jimmy23013
সূত্র

কেবল সাধারণ শিক্ষার জন্য - বিল্ট-ইনগুলি সহ: {{⍵↓⍨1⍳⍨×⍵}(99⍴⎕)⊤⍵⊥⍨⎕⍴⍨⍴⍵}

— ডিটিকে

2

পাইথন 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]

— feersum
সূত্র

@ ফ্রাইআম দ্য এজিগম্যান আমি নিশ্চিত নই যে এটি কীভাবে উদ্ধৃতি সহ ইনপুট গ্রহণ করতে পারে তবে অ্যারেগুলি কমা কাজের সাথে পৃথক করে।

— feersum

1

কে 2 - 83 74 চর

একটি যুক্তি নিয়ে ফাংশন। এটি জেদের চেয়ে কে-এর পক্ষে অনেক বেশি উপযুক্ত ছিল, এই কারণেই আমি জে ব্যবহার করছি না It এটি কেবল বক্সিং / আনবক্সিং আবর্জনা বোঝা হবে, এবং কেউ এটি চায় না। এটি কে 2 উপভাষায় রয়েছে (ওপেন সোর্স বাস্তবায়ন কোনাতে কাজ করার জন্য কিছু অভিযোজন প্রয়োজন হতে পারে) তবে আমি যদি এখানে এটির চেয়ে কম গল্ফ করতে পারি তবে আমি এটিকে কে 4 এ পরিবর্তন করব।

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

আমি নোট করব যে আমি এখানে বাছাইয়ের পক্ষে অবস্থান নিয়েছি এবং বলব যে একটি আইটেমের তালিকাতে যেমন ইনপুট হতে হবে be ,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
 ()
 ())

— algorithmshark
সূত্র

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*}

চেষ্টা করে দেখুন

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

মিশ্র বেস রূপান্তর

পটভূমি

চ্যালেঞ্জ

উদাহরণ

সিজেম, 45

কিভাবে এটা কাজ করে

সিজেম, 49 48

কিভাবে এটা কাজ করে

সিজেম, 62 61 59 57 বাইট

কিভাবে এটা কাজ করে

পরীক্ষার মামলা

পাইথন 2 - 318

এপিএল, 78

পাইথন 2 - 122

সম্পাদনা করুন: 116-বাইট প্রোগ্রাম সংস্করণ FryAmTheEggman ধন্যবাদ

কে 2 - 83 74 চর

পার্ল 6 , 67 বাইট

সম্প্রসারিত: