आपके सभी विशेषण आधार हमारे हैं

Question

पृष्ठभूमि

एक विशेषण आधार b संख्या है , जहां b एक धनात्मक पूर्णांक है, एक विशेषण स्थिति धारणा है जो 1 से b के संबंधित मानों के साथ b प्रतीकों का उपयोग करती है ।

इसके गैर-जीवनी प्रतिरूप के विपरीत, किसी भी प्रतीक का मान 0 नहीं है । इस तरह, प्रत्येक गैर-नकारात्मक पूर्णांक n में विशेषण आधार b में एक अद्वितीय प्रतिनिधित्व है ।

लोकप्रिय विशेषण संख्याओं में unary, bijective base 2 ( bzip2 की रन-लेंथ एन्कोडिंग में प्रयुक्त ) और bijective base 26 (स्प्रेडशीट में संख्या स्तंभों में प्रयुक्त) शामिल हैं।

परिभाषा

इस चुनौती में, हम सेट M को प्रतीकों के रूप में परिभाषित करते हैं

123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz<=>

और एक फ़ंक्शन i से M तक प्राकृतिक संख्या जैसे कि मैं ('1') = 1, ..., i ('>') = 64 ।

एक आधार को देखते हुए ख के बीच 1 और 64 (दोनों सहित), हम एक गैर नकारात्मक पूर्णांक कि परिभाषित n स्ट्रिंग से मेल खाती है एक _{कश्मीर} ... एक ₀ , के प्रतीकों से मिलकर एम , ऐसी है कि एन = ख ^k मैं (एक _{कश्मीर} ) + … + बी ^० आई (एक _० ) ।

यह पत्राचार अच्छी तरह से परिभाषित और विशेषण है। चूंकि एक खाली राशि को 0 के रूप में परिभाषित किया गया है , पूर्णांक 0 को खाली स्ट्रिंग के रूप में एन्कोड किया जा सकता है।

कार्य

इनपुट के रूप में तीन तारों को स्वीकार करें:

• एक इनपुट बेस बी 1 और 64 के बीच , एक जीवनी आधार 64 स्ट्रिंग के रूप में एन्कोड किया गया ।

• एक गैर-नकारात्मक पूर्णांक n , एक विशेषण आधार b स्ट्रिंग के रूप में एन्कोड किया गया ।

• एक आउटपुट बेस बी 1 और 64 के बीच , एक विशेषण आधार 64 स्ट्रिंग के रूप में एन्कोड किया गया ।

इन तीन इनपुटों को देखते हुए, एक एन बेसिक्टिव बेस बी स्ट्रिंग के रूप में एनकोड करें ।

परीक्षण के मामलों

सभी परीक्षण मामलों में आदेश बी , एन , बी में इनपुट निर्दिष्ट किया गया है ।

Input:  "4" "" "8"
Output: ""

Input:  "A" "16" "2"
Output: "1112"

Input:  "2" "122" "A"
Output: "A"

Input:  "3" "31" "1"
Output: "1111111111"

Input:  ">" "Fe" "a"
Output: "RS"

नियम

• आप किसी भी सुविधाजनक क्रम में तीन स्ट्रिंग्स को पढ़ सकते हैं, जैसे, स्ट्रिंग्स की एक सरणी, उसके बाद एक स्ट्रिंग प्रतिनिधित्व, जिसे आपकी पसंद के एकल-वर्ण के सीमांकक द्वारा संक्षिप्त या अलग किया गया है।

• यदि आप आउटपुट को STDOUT में प्रिंट करना चुनते हैं, तो आप केवल प्रतीकों को प्रिंट कर सकते हैं और (वैकल्पिक रूप से) एक अनुगामी न्यूलाइन।

• सभी प्रकार के बेस रूपांतरण की अनुमति है।

• मानक कोड-गोल्फ नियम लागू होते हैं।

Answer 1

CJam, 43

qA,s"?[a{A<":,:^+:Mf#):B;(bLa{(Bmd)M=\j\+}j

3 बाइट्स डेनिस की मदद से मिट गए :) इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

इनपुट के रूप में लिया जाता है bnB, एक स्ट्रिंग में समाप्‍त किया जाता है ।

q           read the input
A,s         make an array of numbers from 0 to 9 and convert to string
"?[a{A<"    push this string, which contains the ends of 3 character ranges:
             uppercase letters: ['A'…'[')
             lowercase letters: ['a'…'{')
             "<=>": ['<'…'?')
             they're in a special order for the symmetric difference below
:,          for each character, make a range of all characters smaller than it
:^          fold/reduce these 6 ranges using symmetric difference
+           concatenate with the digits before
:M          save in M; this is like the M from the statement,
             except it starts with a zero (for matching indexes)
f#          find the indexes in M of all characters from the input string
)           take out the last value from the array
:B;         save it in B and pop it
(           take out the first value
b           use it as a base and convert the remaining array to a number
             this works even if some of the digits are not in the "normal" range
La{…}j      calculate with memoized recursion, using an empty string for value 0
  (         decrement the number
  Bmd       divide by B and get the quotient and remainder
  )         increment the remainder (this is the last digit in bijective base B)
  M=        get the corresponding character from M
  \j        swap with the quotient, and convert the quotient recursively
  \+        swap again and concatenate

Comments

ओह, आप वास्तव में पहले आधार रूपांतरण के लिए नियमित आधार रूपांतरण ऑपरेटर का उपयोग कर सकते हैं? अब मुझे अपने समाधान में सभी कोड का उपयोग करने के लिए मूर्खतापूर्ण लगता है। :) मुझे एहसास नहीं था कि यह उन मूल्यों के साथ काम करेगा जो आधार की सीमा के बाहर हैं। वैसे, दृष्टिहीनता में, कोई अच्छा कारण नहीं है कि यह क्यों नहीं होना चाहिए।

— रेटो कोराडी

@RetoKoradi हाँ, आप ऐसा कर सकते हैं; एक दिन यह प्रलेखित किया जाएगा :)

— aditsu

यदि आप आधार रूपांतरण का उपयोग करने के लिए अपना समाधान बदलते हैं तो क्या आप बुरा मानते हैं? मैं आम तौर पर अन्य समाधानों से विचारों को लेने से बचने की कोशिश करता हूं। लेकिन यह वास्तव में मुझे इस तरह के एक उप-इष्टतम दृष्टिकोण के साथ खड़ा करने की अनुमति देता है। यह अत्यधिक संभावना है कि आपका समाधान अभी भी कम होगा।

— रेटो कोराडी

@RetoKoradi कोई समस्या नहीं है, आगे बढ़ें

— aditsu

Answer 2

पिप, 84 80 78 बाइट्स

m:J[,tAZLCAZ"<=>"]p:$+(m@?^b)*(m@?a)**RV,#bs:m@?cWn:px:(mn-(p:n//s-!n%s)*s).xx

पिप के लिए GitHub रिपॉजिटरी

एल्गोरिदम विकिपीडिया लेख से अनुकूलित है। यहाँ एक छोटे से ungolfed पूर्व संस्करण के लिए स्पष्टीकरण दिया गया है:

                 Implicit: initialize a,b,c from cmdline args; t=10;
                 AZ=uppercase alphabet; x=""
m:               Build lookup table m:
 (J,t)             0123456789 (i.e. join(range(10)))...
 .AZ               plus A-Z...
 .LCAZ             plus lowercase a-z...
 ."<=>"            plus <=>
f:{              Define f(a,b) to convert a from bijective base b to decimal:
 $+                Sum of...
  (m@?^a)            list of index of each character of a in m
  *                  multiplied item-wise by 
  b**RV,#a           b to the power of each number in reverse(range(len(a)))
}
t:{              Define t(a,b) to convert a from decimal to bijective base b:
 x:""              Reset x to empty string (not needed if only calling the function once)
 Wa{               While a is not zero:
  p:a//b-!a%b        p = ceil(a/b) - 1 (= a//b if a%b!=0, a//b-1 otherwise)
  x:m@(a-p*b).x      Calculate digit a-p*b, look up the corresponding character in m, and
                     prepend to x
  a:p                p becomes the new a
 }
 x                 Return x
}
(t               Return result of calling t with these arguments:
 (f                Result of calling f with these arguments:
  b                  2nd cmdline arg
  m@?a)              1st cmdline arg's decimal value
 m@?c              3rd cmdline arg's decimal value
)
                 Print (implicit)

नमूना रन:

dlosc@dlosc:~/golf$ python pip.py bijectivebase.pip ">" "Fe" "a"
RS

Answer 3

ऑक्टेव, 166 बाइट्स

function z=b(o,x,n)
M=['1':'9','A':'Z','a':'z','<=>'];N(M)=1:64;n=N(n);x=polyval(N(x),N(o));z='';while x>0 r=mod(x,n);t=n;if r t=r;end;z=[M(t),z];x=fix(x/n)-(r<1);end

बहु-पंक्ति संस्करण:

function z=b(o,x,n)
   M=['1':'9','A':'Z','a':'z','<=>'];
   N(M)=1:64;
   n=N(n);
   x=polyval(N(x),N(o));
   z='';
   while x>0
      r=mod(x,n);
      t=n;if r t=r;end;
      z=[M(t),z];
      x=fix(x/n)-(r<1);
   end
%end // implicit - not included above

चरित्र को इंडेक्स मान में बदलने के लिए एक मानचित्र बनाने के बजाय, मैंने सिर्फ Nएससीआई मूल्यों के लिए उलटा लुकअप टेबल बनाया 1..'z'और उचित मूल्यों पर सूचकांकों के साथ इसे आबाद किया।

polyval समीकरण का मूल्यांकन करता है

c ₁ x ^k + c ₂ x ^k-1 + ... + c _k x ⁰

गुणांक के वेक्टर cऔर मूल आधार के रूप में दशमलव-परिवर्तित इनपुट मूल्य का उपयोग करना x। (दुर्भाग्य से, ऑक्टेव base2dec()सामान्य सीमा से बाहर प्रतीकों को अस्वीकार करता है।)

एक बार जब हमारे पास बेस 10 में इनपुट मूल्य है, तो नए आधार में मूल्य की गणना सीधी है।

परीक्षण चालक:

% script bijecttest.m
a=b('4','','8');
disp(a);
a=b('A','16','2');
disp(a);
a=b('2','122','A');
disp(a);
a=b('3','31','1');
disp(a);
a=b('>','Fe','a');
disp(a);

परिणाम:

>> bijecttest

1112
A
1111111111
RS
>>

Answer 4

पर्ल, 261 248 229 बाइट्स

sub t{$b=0;$b*=$_[1],$b+=ord($1=~y/0-9A-Za-z<=>/\0-A/r)while$_[0]=~/(.)/g;return$b}sub r{$n=$_[0];$n-=$m=($n-1)%$_[1]+1,$d=(chr$m)=~y/\0-A/0-9A-Za-z<=>/r.$d,$n/=$_[1]while$n;print$d}@a=split/,/,<>;r(t(@a[1],t@a[0],64),t@a[2],64)

बहु-पंक्ति, जबकि लूप अनफॉर्म्ड:

sub t{ # convert bijective base string to number
    $b=0;
    while($_[0]=~/(.)/g)
        {$b*=$_[1];$b+=ord($1=~y/0-9A-Za-z<=>/\0-A/r)}
    return$b}
sub r{ # convert number to bijective base string
    $n=$_[0];
    while($n)
        {$n-=$m=($n-1)%$_[1]+1;$d=(chr$m)=~y/\0-A/0-9A-Za-z<=>/r.$d;$n/=$_[1]}
    print$d}
@a=split/,/,<>; # parse input
r(t(@a[1],t@a[0],64),t@a[2],64)

tकिसी दिए गए आधार के एक विशेषण-आधार स्ट्रिंग से एक संख्या को पार्स करने के लिए एक फ़ंक्शन है। rएक संख्या से किसी दिए गए आधार का एक विशेषण-आधार स्ट्रिंग उत्पन्न करने के लिए एक फ़ंक्शन है। 3 अल्पविराम से अलग किए गए मापदंडों को स्टडिन से पार्स किया जाता है और कार्यों को आवश्यकतानुसार कहा जाता है।

एक सकारात्मक संख्या को एक विशेषण आधार स्ट्रिंग में बदलना सामान्य आधार के समान है। हालाँकि आप सामान्य आधार के लिए ऐसा कुछ कहाँ करेंगे:

string s = ""
while(n)
{
    c = (n % base)
    s = (c + '0') + s
    n -= c // not necessary because the division will take care of it
    n /= base 
}

आप 0 से आधार की जगह 1 से आधार की श्रेणी देने के लिए मॉड को समायोजित करते हैं - 1:

string s = ""
while(n)
{
    c = (((n-1) % base)+1)
    s = (c + '0') + s
    n -= c  // necessary in the case c = base
    n /= base 
}

Answer 5

पायथन 2, ... 317 307 298 311 बाइट्स

निश्चित रूप से गोल्फ। मैं वास्तव में नफरत करता हूं कि कैसे स्ट्रिंग में कोई आइटम असाइनमेंट नहीं है और सूची में कोई भी नहीं है find। मैं अपने तेज़ फ़िक्स से बेहतर तरीके से देखूँगा जो अब मेरे पास है।

मेरा तरीका इनपुट को दशमलव संख्या में परिवर्तित करना है, फिर आउटपुट बेस पर, फिर उस को बायजेक्टिव बेस में बदलना है।

संपादित करें : पाया गया कि जब Unary में परिवर्तित किया गया तो मेरा कार्यक्रम काम नहीं कर रहा था। इसके साथ ठीक करने के लिए 13 बाइट्स खर्च होते हैं e=F(o)<2, आदि।

इसे यहाँ आज़माएँ

R=range;M="".join(map(chr,R(48,58)+R(65,91)+R(97,123)))+"<=>"
b,s,o=input()
F=M.find
e=F(o)<2
B=lambda n:n and B(n/F(o)-e)+M[n%F(o)+e]or""
n=B(sum(F(s[~j])*F(b)**j for j in R(len(s))))
i=n.find('0')
n=list(n)
while-~i:n=n[:i-1]+[M[F(n[i-1])-1]]+[o]+n[i+1:];n=n["0"==n[0]:];i="".join(n).find('0')
print"".join(n)

Comments

मैं आपके अजगर पालतू जानवरों के साथ सहमत हूँ।

— DLosc

@DLosc गोल्फ की मदद के लिए धन्यवाद।

— mbomb007

क्या यह कोड-बॉलिंग है ? : पी

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

सूचियों की .index()विधि है .. खोजने के बजाय उसका उपयोग क्यों नहीं करते? इसके अलावा, बचत F(b)और F(o)चर के बजाय , आप केवल एक बार उनका उपयोग करते हैं, इसलिए जहां आवश्यक हो वहां उन्हें उप करें। अंत में, इससे 'n'[2::5]छोटा है ''.join(n)(बैकस्टिक्स के लिए एपॉस्ट्रॉफ़ को प्रतिस्थापित करें)।

— Kade

इसके अलावा, मुझे लगता है कि आप इसे अधिक जटिल कर रहे हैं .. एक स्ट्रिंग एम बायजेक्टिव बेस b से दशमलव में रूपांतरण 35-40 से अधिक बाइट नहीं लेना चाहिए। विशेषण आधार B के स्ट्रिंग के लिए दशमलव इससे अधिक नहीं होगा।

— Kade

Answer 6

पायथन 2, 167 बाइट्स

[2::5]कम बाइट काउंट पर चारसेट प्राप्त करने के लिए स्लाइसिंग को छोड़कर वास्तव में यहां कोई विशेष ट्रिक नहीं है ।

x=range;A=`map(chr,x(49,58)+x(65,91)+x(97,123))`[2::5]+'<=>'
r=A.find
b,n,B=input()
B=r(B)+1
d=0;s=''
for c in n:d=d*-~r(b)+r(c)+1
while d:d-=1;s=A[d%B]+s;d/=B
print s

टेस्ट:

"4","","8"     >>> (empty string)
">","Fe","a"   >>> RS
"3","31","1"   >>> 1111111111
"A","16","2"   >>> 1112
"2","122","A"  >>> A

Answer 7

CJam, 73 70 69 55 51 48 बाइट्स

नवीनतम संस्करण स्रोत बेस से रूपांतरण के लिए CJam आधार रूपांतरण ऑपरेटर का उपयोग करता है, जो मैंने तब तक नहीं सोचा था जब तक कि मैंने @ aditsu का समाधान नहीं देखा। यह "डिजिट" स्ट्रिंग ( /codegolf//a/54348/32852 ) के निर्माण के लिए @Dennis द्वारा हाल ही में एक टिप भी लागू करता है , साथ ही साथ चैट पर साझा किए गए कुछ अन्य विचार भी।

lA,s'[,_el^+"<=>"+:Lf#Ll#bLl#:K;{(Kmd)L=\}hs-]W%

इनपुट प्रारूप एक मूल्य है, इसके बाद स्रोत और गंतव्य आधार, उनमें से प्रत्येक एक अलग लाइन पर होता है। खाली स्ट्रिंग के लिए, पहली पंक्ति को खाली छोड़ दें। उदाहरण इनपुट:

122
2
A

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

l       Get and interpret value from input.
A,s     Build the list of 64 "digits". Start with [0..9]
'[,     Build character sequence from \0 to Z.
_el     Lower case copy of the same sequence.
^       Symmetric set difference gives only letters from both sequences.
+       Concatenate with sequence of decimal digits, creating [0..9A..Za..z].
"<=>"   Remaining 4 characters.
+       Concatenate, resulting in full 64 character "digit" string.
:L      ... and store it in variable L for repeated use.
f#      Look up input characters in digit list.
Ll#     Get source base from input, and look up value in digit list.
b       Base conversion. This produces the input value.
Ll#     Get destination base from input, and look up value in digit list.
:K;     Store it in variable K for use in loop, and pop it off stack.
{       Loop for generating output digits.
  (       Decrement to get ceiling minus 1 after division.
  Kmd     Calculate divmod of current value with destination base.
  )       Increment mod to get 1-based value for digit.
  L=      Look up digit character for digit value.
  \       Swap. Digit stays on stack for output, remaining value is processed
          in next loop iteration until it is 0.
}h      End of loop for generating output digits.
s       Final value is 0. Covert it to a string.
-       And subtract it from second but last value. This eliminates the 0,
        as well as the second but last value if it was a \0 character.
]       Wrap digits in array.
W%      Reverse array, to get result from MSB to LSB.

Answer 8

जेली , 22 बाइट्स

ØBḊ;“<=>”
i@€€¢ḅḃ2ƭ/ị¢

इसे ऑनलाइन आज़माएं!