आधारभूत 62 में गिनती

Question

कार्य 'क' से '999' तक सभी स्ट्रिंग उत्पन्न करना है, जिसमें ऊपरी केस वर्ण भी शामिल हैं:

'a', 'b', 'c' ... 'y', 'z', 'A', 'B', 'C' ... 'Y', 'Z', '0', '1', 2' ... 
'8', '9', 'aa', 'ab', 'ac' ... 'az', 'aA', 'aB' ... 'aZ', 'a0' ... 'a9', 'ba'

और इसी तरह (अंतराल में भरना), वैकल्पिक रूप से खाली स्ट्रिंग से शुरू होता है।

इनपुट:

• लगातार पात्रों की मात्रा कार्यक्रम को प्रिंट करना है।

आउटपुट:

• प्रत्येक स्ट्रिंग या प्रति पंक्ति एक स्ट्रिंग युक्त एक सरणी

स्पष्टीकरण:

• आदेश कोई फर्क नहीं पड़ता, यदि आप चाहते हैं तो आप सबसे पहले अपरकेस या लोअरकेस अक्षर प्रिंट कर सकते हैं।

• आउटपुट किसी भी प्रकार की गणना कर सकता है, विशेष रूप से एक सरणी होने की जरूरत नहीं है, हालांकि मुझे संदेह है कि सभी संयोजनों को प्रिंट करना आसान नहीं होगा।

• का इनपुट इनपुट (या ) से लेकर on तक के इनपुट 3को प्रिंट करेगा ।'a''''999'5'99999'

Comments

किसी सरणी को आउटपुट करने से आपका क्या मतलब है?

— फ्रेडरिक

तो केवल अक्षर और संख्या? आप किस आदेश का उपयोग करते हैं? ASCII संख्या में पहले आते हैं, फिर अपरकेस अक्षर, लोअरकेस

— लुइस मेंडो

सभी मूल्यों अर्थात ['ए', 'बी', 'सी' ..] युक्त एक गणनीय। आपको या तो STDOUT के माध्यम से प्रत्येक लाइन पर आउटपुट देखना चाहिए या इसके माध्यम से असाइन करने में सक्षम होना चाहिए a = (function return)।

— साइमन लैंड्री

@ edc65 जैसा कि मैं इसे समझता हूं, इनपुट को संयोजित करने के लिए वर्णों की अधिकतम संख्या है। तो इनपुट 4 के लिए, आप से जाना aकरने के लिए 9999, 5 के लिए यह aकरने के लिए 99999इतने पर है, और।

— एलेक्स ए

ठीक है, कि ऊपर समाशोधन के लिए धन्यवाद। जिससे काफी बाइट बच गई। :) मैं मौजूदा शीर्षक थोड़ा भ्रामक के बाद से आप की आवश्यकता प्रतीत लगता द्विभाजित आधार 62.

— डेनिस

Answer 1

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

ØWṖṗR;/

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

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

यह काम किस प्रकार करता है

ØWṖṗR;/  Main link. Argument: n

ØW       Yield 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'.
  Ṗ      Remove the last element (underscore).
    R    Range; yield [1, ..., n].
   ṗ     Cartesian product. For each k in the range, this yields the arrays of all
         strings of alphanumeric characters.
     ;/  Concatenate the arrays of strings of each length.

Comments

कोडगुल्फ़ के लिए अपनी भाषा लिखते समय, क्या आप इसे कांटा नहीं लगा सकते, इसे संशोधित कर सकते हैं और 1 बाइट समाधान का उपयोग कर सकते हैं?

— फ्लोरियन वेंडेलबोर्न

नहीं, हमारे पास स्वीकार्य प्रोग्रामिंग भाषाओं के लिए सख्त नियम हैं, और एक यह है कि चुनौती पोस्ट किए जाने से पहले एक काम करने वाले दुभाषिया का अस्तित्व होना चाहिए। मैं अब इस कार्य के लिए बिल्ट-इन जोड़ सकता हूं, लेकिन मैं इसे भविष्य की चुनौतियों में ही इस्तेमाल कर सकता हूं।

— डेनिस

यह कैसे हास्यास्पद है? यदि इसे अनुमति दी गई, तो प्रत्येक चुनौती 1 बाइट के साथ हल हो जाएगी

— ज़िबेलस

@UncleZeiv जेली कोड पेज पोस्ट शीर्षक से जुड़ा हुआ है

— edc65

@UncleZeiv वास्तव में केवल एक ही चरित्र सेट है जो इसे करता है, जो कि जेली कोड पृष्ठ है।

— इसहाक

Answer 2

हास्केल, 65 बाइट्स

a#b=[a..b]
k n=mapM id.('a'#'z'++'A'#'Z'++'0'#'9'<$)=<<(1#)<$>1#n

प्रयोग उदाहरण: k 3-> ["a","b","c",....,"997","998","999"]।

यह काम किस प्रकार करता है

a#b = [a..b]        -- helper function that builds a list from a to b


        (1#n)<$>    -- map the function (1#), i.e. "build the list from 1 up to" 
                1#n -- on the list from 1 to n

                    -- now we have [[1],[1,2],[1,2,3]]

              =<<   -- map over this list (and combine results in a single list)
  (        <$)      -- a function that makes length of input copies of
 'a'#'z'++ ... '9'  -- all characters we need

                    -- now we have [["a..9"],["a..9","a..9"],["a..9","a..9","a..9"]]

mapM id.            -- and make the cartesian product of each sublist 

Answer 3

पायथन, 86 बाइट्स

f=lambda n:n*[1]and[x+chr(y)for x in['']+f(n-1)for y in range(128)if chr(y).isalnum()]

गैर-रिक्त स्ट्रिंग्स की सूची को आउटपुट करता है। प्रत्येक n-1स्ट्रिंग के लिए और खाली स्ट्रिंग के लिए प्रत्येक वर्णमाला वर्ण को पुन: पूर्वापेक्षित करता है।

Answer 4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 108 बाइट्स

f=n=>n?[for(s of['',...f(n-1)])for(c of(t='abcdefghijklmnopqrstuvwxyz')+t.toUpperCase()+'0123456789')s+c]:[]

TopperCase का उपयोग करके 3 बाइट्स सहेजे गए। 62 वर्णों की गणना मुझे 10 अतिरिक्त बाइट्स में ले जाती है।

Comments

मुझे काम करने के लिए आपका कोड नहीं मिल सकता है, कहते हैं कि फ़ंक्शन एफ अपरिभाषित है।

— साइमन लांड्री

@SimonLandry वूप्स, मैं f=शुरुआत में भूल गया । (मैं हमेशा पुनरावर्ती उत्तरों के लिए ऐसा करना भूल जाता हूं।)

— नील

उपरोक्त कारणों से काम नहीं करता है।

— कैलक्यूलेटरफिनलाइन

@CatsAreFluffy मैं अंदर डाल दिया f=, किसी भी आगे की समस्याओं के कारण जिस तरह से आप इसे कॉल करने की कोशिश कर रहे हैं।

— नील

Answer 5

दालचीनी गोंद, 15 बाइट्स

0000000: 689b b718 05be a345 9c4b c283 d077 de    h......E.K...w.

बहुत कम नहीं, इसके बावजूद दालचीनी गोंद को सटीक प्रकार की चुनौती के लिए बनाया गया था :(

Bijective आधार 96 से आधार 256 में परिवर्तित करके संपीडित । इसे ऑनलाइन आज़माएं। 2 से अधिक के इनपुट से TIO पर समस्या होगी।

व्याख्या

यह रेगेक्स को डिकम्प्रेस करता है [a-zA-Z0-9]{1,%s}। hमोड तब करने के लिए इनपुट विकल्प %sऔर regex मिलान सभी स्ट्रिंग्स आउटपुट।

Answer 6

रूबी, 82 बाइट्स

चरित्र के कार्टेशियन उत्पादों को दी गई लंबाई तक सेट करता है। वर्ण सेट के बीच सभी वर्णों को हथियाने 0और zगैर-शब्द वर्णों को फ़िल्टर करने और भी उत्पन्न होता है _।

->n{a=(?0..?z).grep(/\w/)-[?_];r=[]
n.times{|i|r+=a.product(*[a]*i).map &:join};r}

Answer 7

05AB1E , 9 8 बाइट्स

कोड:

ƒžj¨Nã€,

स्पष्टीकरण:

ƒ          # For N in range(0, input + 1), do:
 žj        #   Push predefined literal [a-zA-Z0-9_]
   ¨       #   Remove the last character (the underscore)
    N      #   Push N
     ã     #   Take the Cartesian product, with N repetitions.
      €,   #   For each element in the array, print with a newline

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Answer 8

पायथन 2.7, 136 134 बाइट्स

2 बाइट बचाने के लिए माल्टीसेन और नॉनलीनियर भर्ती के लिए धन्यवाद

from itertools import*;from string import*;f=lambda n:[''.join(a) for i in range(1,n+1) for a in product(ascii_letters+digits,repeat=i)]

स्ट्रिंग मॉड्यूल से लेता है ascii_lettersऔर सभी संयोजनों की गणना करने के लिए itertools से digitsकार्टेशियन उत्पाद का उपयोग करता है product।

उत्पादन

out = f(3)

print out[:10]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

print out[100:110]
['aM', 'aN', 'aO', 'aP', 'aQ', 'aR', 'aS', 'aT', 'aU', 'aV']

print out[-10:]
['990', '991', '992', '993', '994', '995', '996', '997', '998', '999']

Comments

आप कोष्ठक और अक्षरों के बीच के रिक्त स्थान को हटा सकते हैं।

— माल्टेन

के i in range(n)साथ प्रयास करेंrepeat=i+1

— NonlinearFruit

नकारात्मक इनपुट के लिए +1। क्या यह rangeफ़ंक्शन में बनाया गया है?

— केविन क्रूज़सेन

Answer 9

पायथ - 13 12 बाइट्स

1 बाइट्स @Jakube की बदौलत बच गई।

sm^s+rBG1UTh

इसे यहाँ ऑनलाइन आज़माएँ ।

s                    Add up the lists of different lengths  
 m          (Q)      Map implicitly over input
  ^     h(d)         Cartesian product of string to implicit lambda var + 1
   s                 Add up list
    ++               Concat up three things
     G               Alphabet
     rG1             Uppercase alphabet
     UT              All digits

Comments

अच्छा है! एक स्पष्टीकरण प्रदान करने के लिए देखभाल?

— साइमन लैंड्री

मैंने सोचा था कि लेक्सिकोग्राफिक क्रम में तार के माध्यम से पुनरावृति करने के लिए एक कमांड है?

— लीक नून

@ केनीलाऊ एनवीएम, संख्याएँ नहीं करता है।

— माल्टेन

rBG1एक बाइट +GrG1

— बचाएं

@ जकुब ओह, Bइफरात तर्कों के साथ काम करता है? धन्यवाद।

— माल्टेन

Answer 10

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

from string import*
f=lambda n,r=['']:n and r+f(n-1,[x+y for x in r for y in letters+digits])or r

Ideone पर इसे आज़माएं ।

Comments

लगभग एक ही विचार था, लेकिन अब कुछ बाइट्स ...

— बाइट कमांडर

वाह 2 उत्तर आप से @ डेनिस, आप इसे मार रहे हैं! :)

— साइमन लैंड्री

Answer 11

MATL , 12 बाइट्स

:"3Y24Y2h@Z^

यह एक संख्या को इनपुट के रूप में लेता है।

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

व्याख्या

:       % Implicitly take input, say N. Generate range [1 2... N]
"       % For each number in that range
  3Y2   %   Predefined literal: string with all letters, uppercase and lowercase
  4Y2   %   Predefined literal: string with all digits
  h     %   Concatenate horizontally
  @     %   Push number of characters corresponding to current iteration
  Z^    %   Cartesian power. Each result is a row 
        % End for each. Implicitly display

Answer 12

S , 21 चार्ट / 27 बाइट्स

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė)

Try it here (Firefox only).

नहीं। नहीं। नहीं।

व्याख्या

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė) // implicit: 
Ⓐïⓜ                    // [...Array(input)].map(($,_)=>...)
    ᵖ                   // push to stack:
     ɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)   // list of n-digit numbers in [a-zA-Z0-9]-ary
                     ė) // formatted into a matrix (no spaces)
                        // implicit stack output, newline-separated

Comments

पहली बार मैं इस भाषा को देखता हूं और इसे Google का उपयोग करते हुए नहीं ढूंढ सकता, इसके प्रलेखन और (या) स्रोत कोड में एक लिंक जोड़ने के लिए परवाह है? :)

— साइमन लैंड्री

github.com/molarmanful/ESMin

— मामा फन रोल

क्या भाषा का नाम गंभीरता से 4 रिक्त स्थान है?

— बैलिंट

नहीं, लेकिन हो सकता है कि आपका ब्राउज़र डबलस्ट्रेक वर्णों को सही तरीके से प्रस्तुत न करे। ASCII में, इसे ESMin कहा जाता है।

— मामा फन रोल

Answer 13

पर्ल, 113 बाइट्स + व्हाट्सएप

@r="";
for (1..shift) {
  @r = sub {
    map { $c=$_; map $c.$_, @{$_[1]} } @{$_[0]}
  }->(\@r, [0..9, "a".."z", "A".."Z"])
}
map say($_), @r

उपरोक्त संख्या पर एक तर्क के साथ "पर्ल-ई" का प्रयोग करें। मैं शायद शालीनता से गिनती में अंतिम "नक्शा कहना" नहीं गिना सकता।

Answer 14

जे, 50 बाइट्स

62&(('0123456789',~(,toupper)u:97+i.26){~#~#:i.@^)

आधे बाइट्स, 25 सटीक होने के लिए आवश्यक पत्रों और अंकों को उत्पन्न करने में खर्च किए जाते हैं।

Answer 15

एपीएल, 38 37 बाइट्स

{⊃{⍵,,⍺∘.,⍵}/⍵⍴⊂,¨⎕a,⎕d,⍨⎕ucs 96+⍳26}

Comments

मुझे पूछना होगा कि अगर वे कमिट नहीं कर सकते हैं तो कोई कैसे मिलेगा। (⎕ucs 96+⍳26),⎕d=>⎕d,⍨⎕ucs 96+⍳26

— ज़ाचरी

मैं आपको आश्वस्त कर सकता हूं कि मैं कम्यूट कर सकता हूं ("काम और घर के बीच एक ही यात्रा नियमित रूप से करने के बारे में बात नहीं कर रहा", क्योंकि यह उबाऊ है)। आपको लगता है कि यह अन्य लोगों के समाधान पर आसान सुधार हो सकता है। खासकर अगर आपके पास पूर्णकालिक नौकरी नहीं है। फिर वास्तविक जीवन है जो सब कुछ और भी कठिन बना देता है ...

— lstefano

Answer 16

बैश + जीएनयू उपयोगिताओं, 90

printf -vs %$1s
eval printf '%s\\n' ${s// /{=,{a..z\},{A..Z\},{0..9\}\}}|sed s/^=*//\;/=/d

कमांड-लाइन पैरामीटर के रूप में इनपुट। आउटपुट एक व्हाट्सएप-अलग-अलग सूची है।

इनपुट्स के लिए काम करता है और जिसमें शामिल हैं 3. मेमोरी के साथ 4 से बाहर चलाएं - बैश विस्तार eval printfके 63 ^एन तत्वों का एक पूरा सेट लेता है ।

Answer 17

बाश + GNU बर्तन, 66

अलग और मुझे लगता है कि थोड़ा उपन्यास) मेरे अन्य उत्तर के लिए दृष्टिकोण :

dc -e"64 $1^[d2 48^r-P1-d0<m]dsmx"|base64 -w8|sed s_^/*__\;/[+/]/d

• dc2 ⁴⁸ -1 से 2 ⁴⁸ -64 ^एन तक गिना जाता है और Pप्रत्येक परिणामी संख्या को बाइटस्ट्रीम (यानी बेस 256) के रूप में चिह्नित करता है। यदि इनपुट 1 और 4 के बीच है, तो यह प्रति नंबर 6 बाइट्स होने की गारंटी है।
• base64 इसे बेस 64 आउटपुट में कनवर्ट करता है और इस प्रकार 8 बाइट्स प्रति बेस 64 अंक, एक प्रति लाइन।
• sedस्ट्रिप्स ऑफ लीडिंग /(बेस 64 अंक 63), और उसके बाद +या /(बेस 64 अंक 62 और 63) युक्त किसी भी लाइन को हटा देता है । यह आवश्यक अनुक्रम छोड़ देता है।

Answer 18

आर , 73 बाइट्स

y='';x=c(letters,LETTERS,0:9);for(i in 1:scan())cat(y<-outer(y,x,paste0))

yxआधार मामले के रूप में खाली स्ट्रिंग के रूप में शुरू होता है 'a','b','c',...,'8','9'। outerइसके प्रत्येक इनपुट तर्कों को लेता है, और paste0तत्वों के प्रत्येक संयोजन में फ़ंक्शन को लागू करता है ( yऔर xजो स्ट्रिंग्स को मिलाता है। yपरिणाम बचाता है, catइसे प्रिंट करता है, और यह ऐसा करने के समय के STDIN संख्या के माध्यम से पुनरावृत्ति करता है।

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

Answer 19

Jq 1.5 , 97 बाइट्स

range(.)as$n|[[range(97;123),range(65;91),range(48;58)]|implode/""|combinations($n+1)]|map(add)[]

विस्तारित

  range(.) as $n           # for each n-digit sequence
| [
      [                    # build array of ordinals for
        range(97;123),     #   a-z
        range(65;91),      #   A-Z
        range(48;58)       #   0-9
      ]
    | implode/""           # make into array of strings
    | combinations($n+1)   # generate array of n-element combinations
  ]
| map(add)[]               # convert to sequence of strings

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