उत्पन्न पुनरावृत्ति के साथ संयोजन का आदेश दिया

Question

विभिन्न वर्णों की एक स्ट्रिंग को देखते हुए, और एक नंबर n, उन वर्णों का उपयोग करते हुए, पुनरावृत्ति के साथ सभी क्रमबद्ध संयोजनों को लंबाई 1 से n तक उत्पन्न करते हैं।

इसे परिभाषित करने का एक और तरीका यह है कि दिए गए वर्णों को वर्णों की संख्या के आधार (मूलांक) में "कस्टम" अंकों के रूप में देखा जाए, फिर कार्यक्रम को उस आधार में 1 से n अंकों के साथ सभी "संख्याओं" को उत्पन्न करना चाहिए, हालांकि, अग्रणी "शून्य" भी शामिल हैं।

संयोजनों को उनकी लंबाई (1 वर्ण पहले, फिर 2, आदि) द्वारा आदेश दिया जाना चाहिए, लेकिन इसके अलावा वे किसी भी क्रम में हो सकते हैं। आप इनपुट और आउटपुट को संभालने के सबसे सुविधाजनक तरीके चुन सकते हैं। सबसे छोटा कोड जीतता है।

उदाहरण:

ab, 3-> a,b,aa,ab,ba,bb,aaa,aab,aba,baa,abb,bab,bba,bbb
0123456789, 2->0,1,2,3,4,5,6,7,8,9,00,01,...,09,10,11,...,99

Comments

गंभीरता से? "गणना"?

— पीटर टेलर

@PeterTaylor आपका क्या मतलब है?

— एडिट्स ने छोड़ दिया क्योंकि SE का EVIL

आप उस समस्या को पहचानते हैं जिसे आप बस लोगों से गिनने के लिए कह रहे हैं। क्या आपको नहीं लगता कि यह कुछ अटपटा है?

— पीटर टेलर

@PeterTaylor आधार 10 अंकों का उपयोग करते हुए भी, यह सीधी गिनती नहीं है। मैं यह देखना चाहता हूं कि इसे सबसे छोटे कोड में कैसे किया जाए। यह मुश्किल होने का इरादा नहीं है। मैंने अधिक तुच्छ प्रश्न भी देखे हैं और यह नहीं सोचता कि समस्या होनी चाहिए।

— एडित्सू ने छोड़ दिया क्योंकि SE का EVIL

इसके अलावा, कम से कम कुछ समस्याएं हैं जहां मैं इसे लागू कर सकता हूं :)

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल

Answer 1

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स ^SBCS

⊃,/,¨∘.,\⎕⍴⊂⍞

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

एक स्कैन का उपयोग करने का अवसर कभी न चूकें :)

"अंक" की एक स्ट्रिंग के लिए संकेत देता है और फिर के लिए n

धन्यवाद @ मुझे बताओ कि कैसे ]boxTIO पर सक्षम करने के लिए

Answer 2

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

nअधिकतम लंबाई है और sवर्णों की सूची होने की उम्मीद है। यह मेरे लिए स्पष्ट नहीं है कि n = 0 या एक खाली वर्ण सूची मान्य इनपुट है, लेकिन यह फ़ंक्शन भी उन्हें सही तरीके से संभालता है।

f=lambda s,n:n*s and s+[x+c for x in f(s,n-1)for c in s]

Answer 3

जे, ४१ चार

   f=.}:@;@({@(,&(<',')@(]#<@[))"1 0>:@i.@])

   'ab' f 3
a,b,aa,ab,ba,bb,aaa,aab,aba,abb,baa,bab,bba,bbb

Answer 4

एपीएल (31)

{,/⍺∘{↓⍉⍺[1+(⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺]}¨⍳⍵}

उपयोग: बाएं तर्क स्ट्रिंग है और सही तर्क संख्या है, जैसे:

    'ab'{,/⍺∘{↓⍉⍺[1+(⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺]}¨⍳⍵}3
b  a  ab  ba  bb  aa  aab  aba  abb  baa  bab  bba  bbb  aaa  

आउटपुट लंबाई द्वारा आदेशित किया जाता है, लेकिन लंबाई समूहों के भीतर उन्हें एक बाईं ओर स्थानांतरित किया जाता है, यह सबसे आसान था।

स्पष्टीकरण:

• ,/⍺∘{... }¨⍳⍵: 1 .. : के लिए, फ़ंक्शन को join पर लागू करें और परिणामों को एक साथ जोड़ दें।
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: प्रत्येक संख्या के लिए 1 से ((= (वर्तमान लंबाई)) ^ (amount = (वर्णों की राशि)),, अंकों का उपयोग करके आधार 1 में परिवर्तित करें।
• 1+: एक जोड़ें क्योंकि सरणियाँ 1-अनुक्रमित हैं।
• ⍺[... ]: इन्हें स्ट्रिंग में अनुक्रमित के रूप में उपयोग करें
• ↓⍉: मैट्रिक्स को घुमाएं, इसलिए 'नंबर' कॉलम के बजाय पंक्तियों पर हैं, और फिर मैट्रिक्स को पंक्तियों से विभाजित करें।

Comments

क्या एपीएल के पास अपने प्रतीकों के लिए एकल-बाइट एन्कोडिंग है?

— एडिट्स ने छोड़ दिया क्योंकि SE

@aditsu: Dyalog APL यूनिकोड का उपयोग करता है, मुझे लगता है कि अन्य सभी आधुनिक APL वही करते हैं। हालाँकि, इससे पहले कि यूनिकोड था आप एक कोडपेज का उपयोग करेंगे ताकि यह संभव हो सके।

— मारिनस

मैं मुख्य रूप से पूछ रहा हूँ क्योंकि मैं नहीं के बारे में चिंतित हूँ। बाइट्स बनाम नहीं। पात्रों का। मुझे नहीं पता कि एपीएल कितने अलग-अलग प्रतीकों का उपयोग करता है।

— एडित्सू ने छोड़ दिया क्योंकि SE का EVIL

जब तक मैं कुछ भूल या दुराचार नहीं किया है, Dyalog APL में 74 फ़ंक्शन और ऑपरेटर वर्ण हैं, जो कि 7-बिट ASCII के साथ ठीक-ठीक एक बाइट में फिट होंगे। और उन और सामान्य पात्रों के बीच कुछ ओवरलैप भी है जैसे ?!/\-+*~&=,.|और शायद कुछ और। वहाँ एकल-बाइट APL एन्कोडिंग मौजूद हैं, लेकिन यूनिकोड का उपयोग करना आसान है।

— मारिनस

Answer 5

हास्केल, 34 अक्षर

x%n=do k<-[1..n];mapM(\_->x)[1..k]

सूची का सीधा उपयोग मोनाड। केवल वास्तविक गोल्फिंग mapMअधिक मुहावरेदार (और कम) के बजाय का उपयोग replicateMहोता है जिसे आयात करने की आवश्यकता होती है Control.Monad।

प्रयोग

> "ab" % 3
["a","b","aa","ab","ba","bb","aaa","aab","aba","abb","baa","bab","bba","bbb"]

Answer 6

पायथन, 97 94

from itertools import*
s,n=input()
L=t=[]
exec"t=t+[s];L+=map(''.join,product(*t));"*n
print L

t=t+[s]t+=[s]इसलिए छोटा नहीं किया जा सकता क्योंकि L और t एक ही सूची की ओर इशारा करेंगे।

इनपुट: 'ab', 3

आउटपुट:

['a', 'b', 'aa', 'ab', 'ba', 'bb', 'aaa', 'aab', 'aba', 'abb', 'baa', 'bab', 'bb
a', 'bbb']

Answer 7

मेथेमेटिका 29 19 28

Join@@(i~Tuples~#&/@Range@n)

प्रयोग

i={a, 4, 3.2};n=3;

Join@@(i~Tuples~#&/@Range@n)

{{a}, {४}, {३२०}, {a, {a, ४, ४}, {क, ३.२}, {४,}, {४, ४}, {४, ३२}, { 3.2, a}, {3.2, 4}, {3.2, 3.2}, {a, a,}, a, a, 4}, {a, 3.2}, {a, 4, a}, { a, 4, 4}, {a, 4, 3.2}, {a, 3.2, a}, {a, 3.2, 4}, {a, 3.2, 3.2}, {4, a, a, {4, a, 4}, {4, 3.2}, {4, 4}, {4, 4, 4}, {4, 4, 3.2}, {4, 3.2,}, {4, 3.2}, 4}, {4, 3.2, 3.2}, {3.2, एक}, {3.2, ए, 4}, {3.2, ए 3.2, 3.2}, {3.2, 4, एक}, {3.2, 4, 4} , {3.2, 4, 3.2}, {3.2, 3.2}, {3.2, 3.2, 4}, {3.2, 3.2}, 3.2}}

Comments

क्या गणितज्ञ को खरीदे बिना इसे चलाना संभव है? इसके अलावा, क्या आप उत्पादन को "समतल" कर सकते हैं ताकि यह लंबाई से समूहीकृत न हो?

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल

आपको गणितज्ञ खरीदने की आवश्यकता है। (सिद्धांत रूप में, कोड को वुल्फरामअल्फा डॉट कॉम पर परीक्षण किया जा सकता है, लेकिन किसी कारण से लिंकिंग ठीक से काम नहीं करता है।)

— डेविड मार्क 22'13

खरीद गणित क्षमा करें, ऐसा नहीं होने वाला: p कोड wolframalpha पर अनमॉडिफाइड काम नहीं करता है, लेकिन मैं आपके पहले लिंक में से कुछ से कुछ आउटपुट देख सकता था, इसलिए वैसे भी मैं इसे अस्थायी रूप से सबसे छोटा उत्तर मान रहा हूं।

— एडिट्स ने छोड़ दिया क्योंकि SE को EVIL

Answer 8

MATL, 9 8 बाइट्स

x:"1G@Z^

MATL ऑनलाइन पर यह कोशिश करो!

(MATL इस चुनौती के पोस्ट होने के बाद बनाया गया था, लेकिन मेरा मानना ​​है कि इन दिनों मेटा सर्वसम्मति से ठीक है।)

(-1 बाइट्स @Luis मेन्डो के लिए धन्यवाद।)

x - स्टैक से स्ट्रिंग इनपुट हटाएं (स्वचालित रूप से इसे क्लिपबोर्ड जी पर कॉपी करता है)

:" - नंबर n का निहित इनपुट, 1 से n तक लूप

1G - स्टैक पर क्लिपबोर्ड G से इनपुट स्ट्रिंग वापस पेस्ट करें

@ - वर्तमान लूप पुनरावृत्ति सूचकांक को धक्का दें

Z^ - कार्टेशियन पावर: स्वयं के साथ इनपुट का कार्टेशियन उत्पाद @ संख्या के

कार्टेशियन पावर परिणाम ( @दिए गए आधार में "संख्या") स्टैक पर संचित होते हैं और अंत में प्रदर्शित होते हैं।

Comments

आप 1 बाइट बचा सकते हैंx:"1G@Z^

— लुइस मेंडो

@LuisMendo अपडेटेड (अंत में!)। धन्यवाद।

— सूंदर -

Answer 9

अजगर - 106

सीधा, बिना सोचे-समझे समाधान। यदि आप महत्वपूर्ण सुधार पाते हैं, तो कृपया एक अलग उत्तर के रूप में पोस्ट करें।

s,n=input()
l=len(s)
for i in range(1,n+1):
 for j in range(l**i):t='';x=j;exec't+=s[x%l];x/=l;'*i;print t

इनपुट: "ab",3
आउटपुट:

a
b
aa
ba
ab
bb
aaa
baa
aba
bba
aab
bab
abb
bbb

Answer 10

अजगर, १००

@ Aditsu के समाधान से व्युत्पन्न ।

s,n=input()
L=len(s)
i=0
while i<n:i+=1;j=0;exec"x=j=j+1;t='';exec't+=s[x%L];x/=L;'*i;print t;"*L**i

इनपुट: 'ab', 3

आउटपुट:

b
a
ba
ab
bb
aa
baa
aba
bba
aab
bab
abb
bbb
aaa

Answer 11

पर्ल 5 + -nlF -M5.010 -MList::Util+(uniq), 41 बाइट्स

$,=$"=",";say grep/./,uniq glob"{,@F}"x<>

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

-1 बाईट @ @ धन्यवाद के लिए धन्यवाद !

Comments

आप आउटपुट आइटम के बीच अल्पविराम का उपयोग करके एक बाइट बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— Xcali

@Xcali आह अच्छा स्पॉट, धन्यवाद!

— डोम हेस्टिंग्स

Answer 12

अजगर, 6 बाइट्स

s^LQSE

वर्णों के सेट को 1 इनपुट, 2 के रूप में अंकों की संख्या की उम्मीद है। एक बाइट को बचाया जा सकता है अगर बार-बार 2 इनपुट तक पहुंचने के लिए एक एकल-बाइट विधि थी, लेकिन अफसोस ...

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

s^LQSE   Implicit: Q=input 1, E=evaluate next input
    SE   Range [1,2,...,E]
 ^LQ     Perform repeated cartesian product of Q for each element of the above
s        Flatten

Answer 13

पर्ल 6 , 33 बाइट्स

{flat [\X~] '',|[$^a.comb xx$^b]}

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

अनाम कोड ब्लॉक जो एक स्ट्रिंग और एक संख्या लेता है और स्ट्रिंग की एक सूची देता है।

Answer 14

PHP 180

मुझे कोई पता नहीं है ... मैं आलसी महसूस कर रहा हूं।

<?php $f=fgetcsv(STDIN);$l=strlen($f[1]);$s=str_split($f[1]);for($i=1;$i<=$f[0];$i++)for($j=0;$j<pow($l,$i);$j++){$o="";$x=$j;for($q=0;$q<$i;$q++){$o.=$s[$x%$l];$x/=$l;}echo"$o ";}

Answer 15

एर्लांग 110

वाई कॉम्बिनेटर संस्करण (शेल के लिए):

fun(X, N)->F=fun(_,_,0)->[[]];(G, X, Y)->[[A|B]||A<-X,B<-G(G,X,Y-1)]end,[V||Y<-lists:seq(1,N),V<-F(F,X,Y)]end.

Answer 16

एरलांग 89 (118)

मॉड्यूल संस्करण:

-module(g).
-export([g/2]).
h(_,0)->[[]];h(X,N)->[[A|B]||A<-X,B<-h(X,N-1)].
g(X,N)->[V||Y<-lists:seq(1,N),V<-h(X,Y)].

अनिवार्य बहीखाता (मॉड्यूल और निर्यात) के बिना गिने गए चार्ट।

Answer 17

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

->s,n{(1..n).flat_map{|i|[*s.chars.repeated_permutation(i)]}.map(&:join)}

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

Answer 18

जाप , 9 बाइट्स

अनुसरण करने के लिए स्पष्टीकरण।

õ!àUçV)mâ

कोशिश करो

õ_çV àZ â

कोशिश करो

Answer 19

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

WẋŒpƤẎ

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

फंक्शन सबमिशन, पहले तर्क के रूप में अंकों की सूची और दूसरे के रूप में अंकों की संख्या। अंक स्वयं जेली के किसी भी प्रकार के डेटा हो सकते हैं, लेकिन मैंने ऊपर TIO लिंक में पूर्णांक का उपयोग किया है क्योंकि यह जेली के स्वचालित "फ़ंक्शन → पूर्ण कार्यक्रम" आवरण में सबसे अच्छी दिखने वाली आउटपुट का उत्पादन करता है।

व्याख्या

WẋŒpƤẎ                      (called with arguments, e.g. [1,2,5], 3)
Wẋ       Make {argument 2} copies of {argument 1}  (e.g. [[1,2,5],[1,2,5],[1,2,5])
    Ƥ    For each prefix:                          (e.g. 1-3 copies of [1,2,5])
  Œp       take Cartesian product of its elements
     Ẏ   Flatten one level

कार्टेशियन उत्पाद प्रभावी रूप से दिए गए अंकों की संख्या के अनुसार हमें सभी नंबर देता है (जिसके अनुसार हम उपसर्ग के साथ काम कर रहे हैं)। तो हम संयोजनों की सूची की एक सूची के साथ समाप्त होते हैं (लंबाई द्वारा समूहीकृत), और एक सूची प्राप्त करने के लिए उस स्तर को समतल कर सकते हैं जो समूहीकृत नहीं है (लेकिन जो अभी भी लंबाई के अनुसार हल किया गया है, जैसा कि प्रश्न की आवश्यकता है, Ẏdoesn के रूप में 'तत्वों के सापेक्ष क्रम को नहीं बदलता है और Ƥपहले छोटे उपसर्गों की कोशिश करता है)।

Answer 20

05AB1E , 6 बाइट्स

「˜Ùé

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ã         # Cartesian product of the second input repeated the first input amount of times
          #  i.e. 3 and 'ab' → ['aaa','aab','aba','abb','baa','bab','bba','bbb']
 €Œ       # Take all the substrings for each of those results
          #  i.e. 'aba' → ['a','ab','aba','b','ba','a']
   ˜      # Flatten the list of lists
    Ù     # Remove all duplicated values
     é    # Sort the list by length

---

6-बाइट्स विकल्प:

नोट: लचीले आउटपुट: एक ही प्रिंट लाइन पर, हर लंबाई के लिए एक नई सूची आउटपुट करता है।
इसे एकल सूची में बदलना 2 बाइट्स से अधिक लंबा होगा: Lv²yã`})( इसे ऑनलाइन आज़माएं )।

Lv²yã?

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Lv        # Loop `y` in the range [1, integer_input]
  ²yã     #  Take the second input and create an `y` times repeated cartesian product of it
          #   i.e. y=2 and 'ab' → ['aa','ab','ba','bb']
     ?    #  Print this list (without new-line)

Answer 21

के (ngn / k) , 17 बाइट्स

{,/(,/,'/:)\x#,y}

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