स्ट्रिंग्स के साथ बेस रूपांतरण

Question

परिचय

हमारे पास अतीत में कुछ आधार रूपांतरण की चुनौतियाँ हैं, लेकिन बहुतों को मनमानी लंबाई की संख्या से निपटने के लिए डिज़ाइन नहीं किया गया है (यह कहना है, संख्याएँ जो लंबे समय से पर्याप्त हैं कि वे पूर्णांक डेटा ओवरफ्लो करते हैं), और उनमें से, सबसे थोड़ा महसूस किया उलझा हुआ। मैं उत्सुक हूं कि इस तरह से आधार कोड में बदलाव कैसे किया जा सकता है।

चुनौती

अपनी पसंद की भाषा में एक प्रोग्राम या फ़ंक्शन लिखें जो एक आधार के स्ट्रिंग को दूसरे आधार की स्ट्रिंग में बदल सकता है। इनपुट को परिवर्तित (स्ट्रिंग), बेस-बेस (बेस -10 नंबर), टू-बेस (बेस -10 नंबर), और कैरेक्टर सेट (स्ट्रिंग) होना चाहिए। आउटपुट परिवर्तित संख्या (स्ट्रिंग) होनी चाहिए।

कुछ और विवरण और नियम इस प्रकार हैं:

• परिवर्तित की जाने वाली संख्या एक गैर-नकारात्मक पूर्णांक होगी (क्योंकि -और .वर्ण सेट में हो सकती है)। तो भी आउटपुट होगा।
• अग्रणी शून्य (चरित्र सेट में पहला चरित्र) को छंटनी चाहिए। यदि परिणाम शून्य है, तो एकल शून्य अंक रहना चाहिए।
• न्यूनतम समर्थित आधार श्रेणी 2 से 95 तक होती है, जिसमें प्रिंट करने योग्य एससीआई अक्षर शामिल होते हैं।
• संख्या को परिवर्तित करने के लिए इनपुट, वर्ण सेट, और आउटपुट सभी स्ट्रिंग डेटाटाइप का होना चाहिए। आधार बेस -10 पूर्णांक डेटाटाइप (या पूर्णांक फ़्लोट्स) का होना चाहिए।
• इनपुट नंबर स्ट्रिंग की लंबाई बहुत बड़ी हो सकती है। एक समझदार न्यूनतम की मात्रा को निर्धारित करना कठिन है, लेकिन यह अपेक्षा करें कि यह कम से कम 1000 वर्णों को संभालने में सक्षम हो, और एक सभ्य मशीन पर कम से कम 10 सेकंड में 100 वर्णों का इनपुट पूरा कर सके (इस तरह की समस्या के लिए बहुत उदार है, लेकिन मुझे नहीं चाहिए फोकस होने की गति)।
• आप बिल्ट-इन-बेस फ़ंक्शन का उपयोग नहीं कर सकते।
• वर्ण सेट इनपुट किसी भी व्यवस्था में हो सकता है, न केवल ठेठ 0-9a-z ... आदि।
• मान लें कि केवल मान्य इनपुट का उपयोग किया जाएगा। त्रुटि से निपटने के बारे में चिंता न करें।

विजेता को सबसे कम कोड द्वारा निर्धारित किया जाएगा जो मानदंडों को पूरा करता है। उनका चयन कम से कम 7 बेस -10 दिनों में किया जाएगा, या यदि / जब पर्याप्त सबमिशन हो गए हों। एक टाई होने की स्थिति में, जो कोड तेजी से चलता है वह विजेता होगा। यदि गति / प्रदर्शन में पर्याप्त करीब है, तो पहले आया जवाब जीत जाता है।

उदाहरण

यहां इनपुट और आउटपुट के कुछ उदाहरण दिए गए हैं जिन्हें आपके कोड को संभालने में सक्षम होना चाहिए:

F("1010101", 2, 10, "0123456789")
> 85

F("0001010101", 2, 10, "0123456789")
> 85

F("85", 10, 2, "0123456789")
> 1010101

F("1010101", 10, 2, "0123456789")
> 11110110100110110101

F("bababab", 2, 10, "abcdefghij")
> if

F("10", 3, 2, "0123456789")
> 11

F("<('.'<)(v'.'v)(>'.'>)(^'.'^)", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? ")
> !!~~~~~~~!!!~!~~!!!!!!!!!~~!!~!!!!!!~~!~!~!!!~!~!~!!~~!!!~!~~!!~!!~~!~!!~~!!~!~!!!~~~~!!!!!!!!!!!!~!!~!~!~~~~!~~~~!~~~~~!~~!!~~~!~!~!!!~!~~

F("~~~~~~~~~~", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? ")
> ~

F("9876543210123456789", 10, 36, "0123456789abcdefghijklmnopqrstuvwxyz")
> 231ceddo6msr9

F("ALLYOURBASEAREBELONGTOUS", 62, 10, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
> 6173180047113843154028210391227718305282902

F("howmuchwoodcouldawoodchuckchuckifawoodchuckcouldchuckwood", 36, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? ")
> o3K9e(r_lgal0$;?w0[`<$n~</SUk(r#9W@."0&}_2?[n

F("1100111100011010101010101011001111011010101101001111101000000001010010100101111110000010001001111100000001011000000001001101110101", 2, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? ")
> this is much shorter

Comments

हमारे पास एक मनमाना लंबाई संख्या से निपटने के लिए डिज़ाइन किया गया है।

— पीटर टेलर

@PeterTaylor अच्छा ख़तरा, किसी तरह मेरी तलाश में वह चूक गया। फिर भी, मैं तर्क दूंगा कि वे काफी अलग हैं। अन्य में एक डिफ़ॉल्ट चरित्र सेट, मल्टी-बाइट अनुक्रम, त्रुटि से निपटने और अनुक्रम से अनुक्रम रूपांतरण शामिल है। ये सभी उत्तर में बहुत बड़े ब्लोट को जोड़ते हैं, और विभिन्न अनुकूलन पर ध्यान केंद्रित करते हैं। यह चुनौती बहुत अधिक छंटनी की है, और दूसरी चुनौती (कोर एल्गोरिथम की कमी) से पूरी तरह से अलग कोड में परिणाम होगा।

— 1924 में Mwr247

@PeterTaylor प्लस, अन्य प्रश्न 4 साल पहले पूछा गया था और केवल दो वैध उत्तर प्राप्त हुए (और पहले से ही स्वीकार किए जाते हैं, टक्कर के लिए थोड़ा कारण)। मैं शर्त लगाने के लिए तैयार हूं कि समुदाय इस चुनौती का आनंद ले, पिछले एक से थोड़ा प्रभाव, या "दोहराव" की भावनाओं के साथ।

— Mwr247

हालांकि यह चुनौती पिछले एक के समान है, मैं वास्तव में पिछले एक को इस एक के रूप में बंद करने के पक्ष में हूं। यह चुनौती पुराने की तुलना में बहुत स्पष्ट और उच्च गुणवत्ता वाली है।

— मेगो

क्या आप थोड़ा विस्तार कर सकते हैं You cannot use built in change-of-base functions to convert the entire input string/number at once? विशेष रूप से, क्या मैं इनपुट को इंटरमीडिएट बेस में बदलने के लिए बिल्ट-इन का उपयोग कर सकता हूं? क्या फिर मैं एक अंतर्निहित लक्ष्य का उपयोग करके लक्ष्य के आधार पर परिवर्तित कर सकता हूं? कुछ करना चाहेंगे convert input with canonical form for given base; convert to base 10; convert to target base; convert back to specified character set with string replacement?

— मेघो

Answer 1

CJam, 34 बाइट्स

0ll:Af#lif{@*+}~li:X;{XmdA=\}h;]W%

इनपुट प्रारूप input_N alphabet input_B output_Bप्रत्येक एक अलग लाइन पर है।

सभी परीक्षण मामलों को चलाएं।

व्याख्या

0     e# Push a zero which we'll use as a running total to build up the input number.
l     e# Read the input number.
l:A   e# Read the alphabet and store it in A.
f#    e# For each character in the input number turn it into its position in the alphabet,
      e# replacing characters with the corresponding numerical digit value.
li    e# Read input and convert to integer.
f{    e# For each digit (leaving the base on the stack)...
  @*  e#   Pull up the running total and multiply it by the base.
  +   e#   Add the current digit.
}
~     e# The result will be wrapped in an array. Unwrap it.
li:X; e# Read the output base, store it in X and discard it.
{     e# While the running total is not zero yet...
  Xmd e#   Take the running total divmod X. The modulo gives the next digit, and
      e#   the division result represents the remaining digits.
  A=  e#   Pick the corresponding character from the alphabet.
  \   e#   Swap the digit with the remaining value.
}h
;     e# We'll end up with a final zero on the stack which we don't want. Discard it.
]W%   e# Wrap everything in an array and reverse it, because we've generated the 
      e# digits from least to most significant.

यह एक ही बाइट काउंट के लिए काम करता है:

L0ll:Af#lif{@*+}~li:X;{XmdA=@+\}h;

अंतर केवल इतना है कि हम स्टैक पर सब कुछ इकट्ठा करने और इसे उलटने के बजाय एक स्ट्रिंग बना रहे हैं।

Answer 2

पायथन 2 , 115 114 106 105 94 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

संपादित करें: -9 बाइट्स mbomb007 के लिए धन्यवाद। -2 बाइट्स फ्लिपकैक को धन्यवाद।

def a(n,f,t,d,z=0,s=''):
 for i in n:z=z*f+d.find(i)
 while z:s=d[z%t]+s;z/=t
 print s or d[0]

Ungolfed:

def arbitrary_base_conversion(num, b_from, b_to, digs, z=0, s=''):
    for i in num:
        z = z * b_from + digs.index(i)
    while z:
        s = digs[z % b_to] + s
        z = z / t
    if s:
        return s
    else:
        return d[0]

Comments

while z:s=d[z%t]+s;z/=t9 बाइट्स बचाता है।

— mbomb007

आप डाल सकता है z=0और s=''समारोह घोषणा में बाइट्स को बचाने के लिए।

— 21

के printबजाय का उपयोग कर डिफ़ॉल्ट रूपreturn से अनुमति दी है ।

— 21

Answer 3

गंभीरता से, 50 बाइट्स

0╗,╝,2┐,3┐,4┐╛`4└í╜2└*+╗`MX╜ε╗W;3└@%4└E╜@+╗3└@\WX╜

हेक्स डंप:

30bb2cbc2c32bf2c33bf2c34bfbe6034c0a1bd32c02a2bbb60
4d58bdeebb573b33c0402534c045bd402bbb33c0405c5758bd

मुझे इसकी लंबाई के बावजूद इस पर गर्व है। क्यों? क्योंकि यह दूसरी कोशिश पर पूरी तरह से काम करता है। मैंने इसे लिखा और शाब्दिक रूप से 10 मिनट में इसे डिबग किया। आमतौर पर सीरियसली प्रोग्राम डेब्यू करना एक घंटे का श्रम होता है।

स्पष्टीकरण:

0╗                                                  Put a zero in reg0 (build number here)
  ,╝,2┐,3┐,4┐                                       Put evaluated inputs in next four regs
             ╛                                      Load string from reg1
              `         `M                          Map over its chars
               4└                                   Load string of digits
                 í                                  Get index of char in it.
                  ╜                                 Load number-so-far from reg0
                   2└*                              Multiply by from-base
                      +                             Add current digit.
                       ╗                            Save back in reg0
                          X                         Discard emptied string/list.
                           ╜                        Load completed num from reg0
                            ε╗                      Put empty string in reg0
                              W                W    While number is positive
                               ;                    Duplicate
                                3└@%                Mod by to-base.
                                    4└E             Look up corresponding char in digits
                                       ╜@+          Prepend to string-so-far.
                                                      (Forgetting this @ was my one bug.)
                                          ╗         Put it back in reg0
                                           3└@\     integer divide by to-base.
                                                X   Discard leftover 0
                                                 ╜  Load completed string from reg0
                                                    Implicit output.

Answer 4

C (फ़ंक्शन) GMP लाइब्रेरी के साथ , 260

यह उम्मीद की तुलना में अधिक लंबा निकला, लेकिन यहाँ यह वैसे भी है। mpz_*सामान वास्तव में बाइट्स का एक बहुत ऊपर खाता है। मैंने कोशिश की #define M(x) mpz_##x, लेकिन उसने 10 बाइट्स का शुद्ध लाभ दिया।

#include <gmp.h>
O(mpz_t N,int t,char*d){mpz_t Q,R;mpz_inits(Q,R,0);mpz_tdiv_qr_ui(Q,R,N,t);mpz_sgn(Q)&&O(Q,t,d);putchar(d[mpz_get_ui(R)]);}F(char*n,int f,int t,char*d){mpz_t N;mpz_init(N);while(*n)mpz_mul_ui(N,N,f),mpz_add_ui(N,N,strchr(d,*n++)-d);O(N,t,d);}

फ़ंक्शन F()प्रविष्टि-बिंदु है। यह इनपुट स्ट्रिंग को -base mpz_tद्वारा क्रमिक गुणन द्वारा fromऔर अंक सूची में दिए गए अंक के सूचकांक के साथ परिवर्तित करता है ।

फ़ंक्शन O()एक पुनरावर्ती आउटपुट फ़ंक्शन है। प्रत्येक पुनरावृत्ति -base mpz_tद्वारा divmods to। क्योंकि यह आउटपुट अंकों को उल्टे क्रम में प्राप्त करता है, पुनरावृत्ति प्रभावी रूप से अंकों को सही क्रम में स्टैक और आउटपुट पर संग्रहीत करने की अनुमति देता है।

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

पठनीयता के लिए नए अंक और इंडेंटिंग जोड़े गए।

#include <stdio.h>
#include <string.h>

#include <gmp.h>
O(mpz_t N,int t,char*d){
  mpz_t Q,R;
  mpz_inits(Q,R,0);
  mpz_tdiv_qr_ui(Q,R,N,t);
  mpz_sgn(Q)&&O(Q,t,d);
  putchar(d[mpz_get_ui(R)]);
}
F(char*n,int f,int t,char*d){
  mpz_t N;
  mpz_init(N);
  while(*n)
    mpz_mul_ui(N,N,f),mpz_add_ui(N,N,strchr(d,*n++)-d);
  O(N,t,d);
}

int main (int argc, char **argv) {
  int i;

  struct test_t {
    char *n;
    int from_base;
    int to_base;
    char *digit_list;
  } test[] = {
    {"1010101", 2, 10, "0123456789"},
    {"0001010101", 2, 10, "0123456789"},
    {"85", 10, 2, "0123456789"},
    {"1010101", 10, 2, "0123456789"},
    {"bababab", 2, 10, "abcdefghij"},
    {"10", 3, 2, "0123456789"},
    {"<('.'<)(v'.'v)(>'.'>)(^'.'^)", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? "},
    {"~~~~~~~~~~", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? "},
    {"9876543210123456789", 10, 36, "0123456789abcdefghijklmnopqrstuvwxyz"},
    {"ALLYOURBASEAREBELONGTOUS", 62, 10, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"},
    {"howmuchwoodcouldawoodchuckchuckifawoodchuckcouldchuckwood", 36, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? "},
    {"1100111100011010101010101011001111011010101101001111101000000001010010100101111110000010001001111100000001011000000001001101110101", 2, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? "},
    {0}
  };

  for (i = 0; test[i].n; i++) {
    F(test[i].n, test[i].from_base, test[i].to_base, test[i].digit_list);
    puts("");
  }

  return 0;
}

Answer 5

जावास्क्रिप्ट (ईएस 6), 140 बाइट्स

(s,f,t,m)=>[...s].map(c=>{c=m.indexOf(c);for(i=0;c||i<r.length;i++)r[i]=(n=(r[i]|0)*f+c)%t,c=n/t|0},r=[0])&&r.reverse().map(c=>m[c]).join``

@ Mwr247 के कोड के विपरीत (जो हर बार टी द्वारा विभाजित करने के लिए बेस-एफ अंकगणित का उपयोग करता है, प्रत्येक शेष को इकट्ठा करता है जैसे वह जाता है) मैं बेस-टी अंकगणित का उपयोग करता हूं, प्रत्येक बार एफ द्वारा उत्तर को गुणा करने के लिए, जैसा कि मैं जाता हूं, प्रत्येक अंक जोड़ते हैं।

Ungolfed:

function base(source, from, to, mapping) {
    result = [0];
    for (j = 0; j < s.length; s++) {
        carry = mapping.indexOf(s[j]);
        for (i = 0; carry || i < result.length; i++) {
            next = (result[i] || 0) * from + carry;
            result[i] = next % to;
            carry = Math.floor(next / to);
         }
    }
    string = "";
    for (j = result.length; j --> 0; )
        string += mapping[result[j]];
    return string;
}

Answer 6

रूबी, 113 112 105 98 97 95 87 बाइट्स

मैं अपने पायथन जवाब (किसी तरह) को डबल पोस्ट करता हूं, इसलिए यहां रूबी का जवाब है। सात और बाइट्स मैनटवर्क के लिए धन्यवाद, मार्टिन ब्यूटनर को एक और बाइट धन्यवाद , और सियाणा के लिए 8 और बाइट्स धन्यवाद ।

->n,f,t,d{z=0;s='';n.chars{|i|z=z*f+d.index(i)};(s=d[z%t]+s;z/=t)while z>0;s[0]?s:d[0]}

Ungolfed:

def a(n,f,t,d)
  z=0
  s=''
  n.chars do |i|
    z = z*f + d.index(i)
  end
  while z>0 
    s = d[z%t] + s
    z /= t
  end
  if s[0]   # if n not zero
    return s
  else
    return d[0]
  end
end

Comments

कैसे के s=d[z%t]+s;z/=tबजाय के बारे में उपयोग z,m=z.divmod t;s=d[m]+s?

— cia_rana

Answer 7

एपीएल, 10 बाइट्स

{⍺⍺[⍵⍵⍳⍵]}

यह एक एपीएल ऑपरेटर है। एपीएल में, ⍵और ⍺, मूल्यों पारित करने के लिए उपयोग किया जाता है, जबकि ⍵⍵और ⍺⍺आम तौर पर काम करता है पारित करने के लिए उपयोग किया जाता है। मैं यहाँ यह गाली दे रहा हूँ कि 3 तर्क हैं।⍺⍺बाएं तर्क है, ⍵⍵"आंतरिक" सही तर्क है, और ⍵"बाहरी" सही तर्क है।

मूल रूप से: ⍺(⍺⍺{...}⍵⍵)⍵

तो फिर बस इतना ही चाहिए ⍳ कि "से" तालिका में इनपुट स्ट्रिंग की स्थिति का पता लगाना है, और फिर []इन पदों के साथ "से" तालिका में अनुक्रमित करना है।

उदाहरण:

    ('012345'{⍺⍺[⍵⍵⍳⍵]}'abcdef')'abcabc'
012012

Answer 8

जावास्क्रिप्ट (ईएस 6), 175 बाइट्स

(s,f,t,h)=>eval('s=[...s].map(a=>h.indexOf(a));n=[];while(s.length){d=m=[],s.map(v=>((e=(c=v+m*f)/t|0,m=c%t),e||d.length?d.push(e):0)),s=d,n.unshift(m)}n.map(a=>h[a]).join``')

यह समझ में आया कि यह अब काफी लंबा हो गया है कि मैं उदाहरणों को बनाने के लिए एक को प्रस्तुत कर सकता हूं। मैं कोशिश कर सकता हूं और बाद में इसे थोड़ा बेहतर कर सकता हूं।

Answer 9

जाप, 9 बाइट्स

nVîX
sWîX

कोशिश करो