आउटपुट सभी तार

34

अक्षरों के एक सेट को देखते हुए, उन अक्षरों से बने सभी तारों को आउटपुट करें। (यह सेट का क्लेन स्टार है।) उदाहरण के लिए, {'a','b'}तार हैं:

'', 'a', 'b', 'aa', 'ab', 'ba', 'bb', 'aaa', 'aab', ...

इनपुट: अलग-अलग अक्षरों का एक गैर-खाली संग्रह a..z। ये चरित्र या एकल-वर्ण स्ट्रिंग्स हो सकते हैं।

आउटपुट: उन पत्रों में सभी तार, किसी भी क्रम में, बिना दोहराए। आप तार की सूचियों को तार के रूप में उपयोग कर सकते हैं।

यह एक अनंत सूची है, जिससे आप इसका उत्पादन कर सकते हैं:

  • हमेशा के लिए अधिक से अधिक तार लेखन चल रहा है। इन स्ट्रिंग्स को किसी भी फ्लैट से अलग प्रारूप में लिखा जा सकता है, जिसका अर्थ है कि आप बता सकते हैं कि प्रत्येक स्ट्रिंग कहाँ समाप्त होती है, लेकिन स्ट्रिंग्स को समूहों में उप-विभाजित नहीं किया जाता है।
  • किसी संख्या nको इनपुट के रूप में लेना और nकिसी भी फ्लैट से अलग प्रारूप में पहली स्ट्रिंग्स को आउटपुट करना
  • प्रत्येक स्ट्रिंग को जेनरेटर ऑब्जेक्ट से बदले में उपज देना
  • अनंत वस्तु का निर्माण करना

सुनिश्चित करें कि आपकी विधि अंततः आउटपुट में प्रत्येक स्ट्रिंग का उत्पादन करती है, क्योंकि सेट से असीम रूप से कई तारों का उत्पादन करना संभव है, जबकि कुछ तारों तक कभी नहीं।

आप इसे द्वारा आउटपुट नहीं कर सकते

  • nदिए गए वें स्ट्रिंग का निर्माणn
  • यदि एक दिया स्ट्रिंग सेट के अंतर्गत आता है, तो यह तय करने के लिए कि सदस्यता सदस्यता प्रदान करना

बिल्ट-इन की अनुमति है, लेकिन मैं मतदाताओं से उन उत्तरों पर ध्यान देने के लिए कहता हूं जो ऑपरेशन को स्वयं लागू करते हैं जो ज्यादातर एक अंतर्निहित में भरोसा करते हैं।

कोड स्निपेट दिखाएं

code-golf  string 
— XNOR
स्रोत
@Cyoce यकीन नहीं है कि आप क्या मतलब है। मैंने स्पष्ट किया कि तार को अलग किया जाना चाहिए, इसलिए आप खाली स्ट्रिंग को कुछ भी नहीं बता सकते हैं।
— xnor
कृपया बताएं कि "Nth स्ट्रिंग दी गई N" का उत्पादन करने की अनुमति क्यों नहीं है।
— कैलकुलेटर
4
@CatsAreFluffy यह एक निर्णय कॉल था। मुझे लगता है कि विकल्पों की तुलना में Nth स्ट्रिंग का उत्पादन बहुत आसान होगा और चुनौती को कम दिलचस्प बना देगा, खासकर क्योंकि कुछ भाषाओं में अंतर्निहित मनमाना-आधार रूपांतरण है। इसके अलावा, मुझे नहीं लगा कि इसने क्वेरी करने के बजाय एक अनंत सेट बनाने के विचार पर कब्जा कर लिया है।
— xnor
क्या आप समझा सकते हैं "एक अनंत वस्तु का निर्माण"? इसका मतलब है कि हम उदाहरण के लिए प्रत्येक स्ट्रिंग को स्टैक पर (स्टैक भाषाओं के लिए) धकेल सकते हैं और इसे "हमेशा के लिए" चलने दें, भले ही कोई आउटपुट कभी भी उत्पन्न नहीं होगा क्योंकि प्रोग्राम समाप्त नहीं होगा?
— लुइस मेंडो
@DonMuesli क्या ऐसी भाषाओं के लिए एक स्वीकृत आउटपुट विधि है? और, क्या स्टैक में किसी भी समय केवल ये तार होंगे?
— 21

जवाबों:

26

पायथन 2, 53 56

-3 का एहसास होने के बाद जिसे yield xएक अभिव्यक्ति के रूप में इस्तेमाल किया जा सकता है।

def f(s):yield'';[(yield w+c)for w in f(s)for c in s]
— feersum
स्रोत
एक बाइट कम, लेकिन कम से शुरू होता है 'aa'बजाय पर '': S=lambda s:(c+w for f in[str,S]for w in f(s)for c in s)। खाली इनपुट के लिए भी काम नहीं करता है।
— orlp
20

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

f s=[]:[b:a|a<-f s,b<-s]

एक अनंत सूची तैयार करता है।

*Main> f "abc"
["","a","b","c","aa","ba","ca","ab","bb","cb","ac","bc","cc","aaa","baa","caa","aba","bba","cba",…
— एंडर्स कसीगोर
स्रोत
बहुत बुरा (:)<$>s<*>f sगलत आदेश देगा। वहाँ है, f s="":(flip(:)<$>f s<*>s)लेकिन यह लंबा है।
— xnor
हाँ। मैं 23-बाइट पाया था f s=[]:(f s<**>map(:)s)सिवाय इसके कि अंदर <**>नहीं है Prelude।
— एंडर्स कासोर्ग
11

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

function*g(s){yield'';for(let r of g(s))for(c of s)yield c+r}

@ Feersum के पायथन जनरेटर का पोर्ट। letआवश्यक है। सरणी बोध का उपयोग करके 2 बाइट्स सहेजें (विफल ES7 प्रस्ताव, लेकिन फ़ायरफ़ॉक्स 30-57 में काम करता है):

function*g(s){yield'';[for(r of g(s))for(c of s)yield c+r]}

73 बाइट्स के लिए वैकल्पिक संस्करण nजो उपरोक्त जनरेटर द्वारा उत्पादित पहले तत्वों को लौटाता है :

(s,n)=>Array(n).fill('').map(g=(r,i)=>i--?g(r+s[i%l],i/l|0):r,l=s.length)
— नील
स्रोत
जेएस के जनरेटर हैं? : 0000000
— बिल्ली
10

गणितज्ञ, ३२ ३१ बाइट्स

Do[Echo/@#~Tuples~n,{n,0,∞}]&

संपादित करें:

CatsAreFluffy ने एक बाइट को बिखेर दिया।

— मर्फी
स्रोत
8

पर्ल, 39 37 35 बाइट्स

(पहले एक पुराने संस्करण का वर्णन करता है। नया छोटा कार्यक्रम अंत में है)

के लिए +3 शामिल है -alp

एसटीडीआईएन पर पात्रों के सेट के साथ, जैसे perl -alp kleene.pl <<< "a b c"

kleene.pl (यह संस्करण 34 + 3 बाइट्स है):

$#a=$"=","}for(@a){push@a,<{@F}$_>

+2 जोड़ें -F( -aयदि इनपुट वर्णों के बीच कोई स्थान नहीं है तो ड्रॉप छोड़ें , या -6 (केवल @a=""पहले }) अगर हम पहले ही STDIN पर वर्णों के बीच अल्पविराम लगा दें

स्पष्टीकरण:

-alpविकल्प कोड को प्रभावी ढंग से करते हैं:

BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
    chomp $_;
    our @F = split(' ', $_, 0);
    $#a = $" = ',';
}
foreach $_ (@a) {
    use File::Glob ();
    push @a, glob('{' . join($", @F) . '}' . $_);
}

जैसा कि आप देख सकते हैं <>पर्ल में न केवल रीडलाइन के लिए उपयोग किया जाता है, बल्कि शेल स्टाइल ग्लोबिंग भी कर सकते हैं (वास्तव में प्राचीन पर्ल्स में इसे शेल को कॉल करके लागू किया गया था)।

उदाहरण के लिए इसका <{a,b}{1,2}>विस्तार किया जाएगा"a1","a2","b1","b2"

इसलिए यदि हमारे पास तत्व हैं तो हमें @Fअल्पविराम को जोड़ने की आवश्यकता है। प्रक्षेप के लिए डिफ़ॉल्ट इनबेटवर्क वर्ण स्थान है, जिसे विशेष चर में संग्रहीत किया जाता है $"। की स्थापना तो $"करने के लिए ,बदल जाएगी "{@F}"में {a,b}अगर @F=qw(a b)(globs तारों के रूप में विस्तार)

वास्तव में मैं वास्तव में कुछ के साथ लूप को पसंद कर सकता glob"{@F}"x$n++हूं, लेकिन मैं इस समस्या में भाग रहा हूं कि पहली खाली लाइन उत्पन्न नहीं होती है और मुझे मिले सभी वर्कअराउंड ने कोड को बहुत लंबा कर दिया है।

इस कोड का एक अन्य अनिवार्य हिस्सा यह है कि यदि आप forकिसी सरणी पर लूप का उपयोग करते हैं तो आप लूप के दौरान अतिरिक्त तत्वों को वास्तव में धक्का दे सकते हैं और लूप इन नए तत्वों को भी उठाएगा। इसलिए यदि लूप में हम उदाहरण के लिए तत्व हैं "ab", तो <{@F}$_>विस्तार होगा <{a,b}ab>जो सूची के संदर्भ में हो जाता है ("aab", "bab")। इसलिए अगर मैं इन पर जोर @aदूं तो तार एक से बाईं ओर बढ़ जाते हैं जो उपलब्ध भी हो जाते हैं

सभी मुझे अभी भी एक खाली स्ट्रिंग के साथ लूप को प्रधान करने की आवश्यकता है। इसका उपयोग करके किया जाता है $#a = 0( ,संख्यात्मक संदर्भ में 0) जो पहले और एकमात्र तत्व के @aअपरिभाषित हो जाते हैं, जो ""इसका उपयोग करते समय ऐसा व्यवहार करेगा

सुधार की

वास्तव में इस स्पष्टीकरण के लिए परीक्षण करने से मुझे बढ़ते ग्लोब का उपयोग करने का एक छोटा तरीका मिला जो पहले खाली प्रविष्टि को ठीक से संभालता है। के रूप में चलाएं perl -ap kleene0.pl <<< "a b"(इसलिए 2 बाइट जोड़ें -ap)

kleene0.pl (यह संस्करण 33 + 2 बाइट्स है):

$"=",";print<$z,>;$z.="{@F}";redo

ये सभी समाधान मेमोरी में आउटपुट का अधिक से अधिक हिस्सा रखेंगे और इससे प्रोग्राम कुछ समय बाद विफल हो जाएगा। आप आलसी पीढ़ी के लिए पर्ल ग्लब्स का उपयोग स्केलर संदर्भ में भी कर सकते हैं, लेकिन इससे प्रोग्राम लंबे समय तक चलते हैं ...।

— टन हास्पेल
स्रोत
क्या आप कृपया समझा सकते हैं कि क्या चल रहा है <{@F}$_>:? धन्यवाद!
— andlrc
6

अजगर,,

<s^LzQQ

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

यह प्रत्येक नंबर के साथ इनपुट के कार्टेशियन उत्पाद की गणना करता है 0..n-1, उनसे जुड़ता है, और फिर केवल पहले रखता है n। यह संख्या या स्ट्रिंग्स के लिए ऑनलाइन समय निकाल देगा जो 3-4 से बहुत बड़ा है।

वैकल्पिक रूप से, जंक्यूब के उत्तर पर अनंत आउटपुट देखने के लिए ।

— FryAmTheEggman
स्रोत
5

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

⁷³p$Ȯ¿

यह एक अद्वैत लिंक है जो एक वर्णमाला को स्वीकार करता है और तार की एक अनंत सूची को प्रिंट करता है। इसे ऑनलाइन आज़माएं!

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

⁷³p$Ȯ¿    Monadic link. Argument: A (alphabet)

⁷         Set the return value to '\n'.
     ¿    While loop.
            Condition:
    Ȯ         Print the current return value and return it (always truthy).
            Body:
   $          Combine the two links to the left into a single, monadic link.
 ³              Yield A.
  p             Perform the Cartesian product of A and the current return value,
                updating the return value in the process.

वैकल्पिक संस्करण, 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

R’ḃL}ị

यह एक डाइएडिक लिंक है जो क्रमशः एक वर्णमाला और बाएं और दाएं तर्कों के रूप में तार की वांछित संख्या को स्वीकार करता है।

मैं इस संस्करण को गैर-प्रतिस्पर्धात्मक मानता हूं, क्योंकि यह द्वि-मूल आधार रूपांतरण का उपयोग करता है, जिसे इस चुनौती के सैंडबॉक्स किए जाने के बाद लागू किया गया है। इसे ऑनलाइन आज़माएं!

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

R’ḃL}ị    Dyadic link. Arguments: n (integer), A (alphabet)

R         Range; yield [1, ..., n].
 ’        Decrement; yield [0, ..., n-1].
   L}     Yield l, the length of A.
  ḃ       Convert every i in [0, ..., n-1] to bijective base l.
     ị    For each array of digits, retrieve the corresponding characters of A.
— डेनिस
स्रोत
4

सीजेएम, 16 10 बाइट्स

6 बाइट बचाने के लिए jimmy23013 का धन्यवाद।

N{eam*_o}h

इनपुट एक कमांड-लाइन तर्क प्रति चरित्र है। आउटपुट प्रत्येक पंक्ति पर एक स्ट्रिंग है।

इसे ऑनलाइन आज़माएं! (लेकिन इसे तुरंत मार डालो ...)

व्याख्या

N      e# Push [\n]. At each step this array will contain all strings of length N,
       e# each followed by a linefeed.
{      e# Infinite loop...
  ea   e#   Read command-line arguments.
  m*   e#   Cartesian product: pairs each letter with each string in the list.
  _o   e#   Output all the strings of the current length.
}h
— मार्टिन एंडर
स्रोत
3

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

.V0j^zb

@Fry के लिए वैकल्पिक। यह कार्यक्रम एक स्ट्रिंग पढ़ता है और अनंत तक तार को मुद्रित करता रहता है।

स्पष्टीकरण:

.V0      for b in (0 to infinity):
    ^zb     compute all strings of length b consisting of the input alphabet
   j        print each one on a separate line

वैकल्पिक रूप से निम्नलिखित भी काम करेगा। हालांकि थोड़ा अधिक हैकी।

u
M^zH7
— Jakube
स्रोत
3

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

k u=do s<-[0..];mapM(\_->u)[1..s]

परीक्षा के लिए, k "xyz"अनंत सूची है["","x","y","z","xx","xy","xz","yx","yy","yz","zx","zy","zz","xxx",...]

— लिन
स्रोत
3

MATL , 10 बाइट्स

0cD`G@Z^DT

इसे ऑनलाइन आज़माएं! लेकिन सर्वर पर बड़े कम्प्यूटेशनल लोड से बचने के लिए इसे लंबे समय तक चलाना न छोड़ें।

कार्यक्रम गतिशील रूप से तारों को प्रदर्शित करता है, प्रत्येक स्ट्रिंग एक अलग लाइन पर।

0cD             % force display of a newline to represent the empty string
   `      T     % infinite do-while loop
    G           % push input, or nothing if no input has been taken yet
     @          % push iteration. Gives 1, 2,... in each iteration
      Z^        % Cartesian power. In the first iteration takes input implicitly 
       D        % display
— लुइस मेंडो
स्रोत
2

पायथन 3, 95

from itertools import*
def f(x,l=0):
 while 1:print(*combinations_with_replacement(x*l,l));l+=1

इटर्स्टूल फ़ंक्शंस में इतने लंबे नाम क्यों होने चाहिए।

— मॉर्गन थ्रैप
स्रोत
3
combinations_with_replacementइसके लायक कभी नहीं है। मुझे पूरा यकीन है कि यह छोरों का उपयोग करने के लिए छोटा है। हमेशा।
— mbomb007
2

रूबी, 65 60 बाइट्स

->a{n=-1;loop{puts a.repeated_permutation(n+=1).map &:join}}

ऐसे बने लंबे नाम ...

— Doorknob
स्रोत
1
AFAIK से पहले आपको स्थान की आवश्यकता नहीं है और आप पुट के बजाय p का उपयोग कर सकते हैं।
— निधि मोनिका का मुकदमा
@QPaysTaxes अंतरिक्ष ड्रॉप नहीं किया जा सकता है, और pकॉल inspectअपने तर्कों पर जो की तरह उत्पादन का उत्पादन होगा[] ["a","b"] ["aa", "ab", ...
— दरवाज़े
मैंने आपके उत्तर को गलत समझा। मुझे लगा कि यह एक अनंत सरणी उत्पन्न कर रहा है और इसे मुद्रित कर रहा है। हालाँकि, मुझे पूरा यकीन है कि ऐरे पर, to_s को निरीक्षण करने के लिए अलियास किया जाता है, इसलिए पुट और पी का समान आउटपुट होता है। ruby-doc.org/core-2.2.0/Array.html#method-i-to_s स्थान को खाली करें: क्या हमने इसकी जांच की? निश्चित रूप से मैं निश्चित नहीं हूं, लेकिन मैं इसके बारे में निश्चित हूं।
— निधि मोनिका का मुकदमा
1

पाइके (कमिट ३१), १० ९ बाइट्स

=blR.fbtp

स्पष्टीकरण:

=b         -    set characters for base conversion to eval_or_not(input())
  l        -   len(^)
   R      -  [^, eval_or_not(input()]
    .f    - first_n(^)
      b   -    conv_base(^)
       t  -   ^[-1]
        p -  print(^)
— नीला
स्रोत
1

स्काला, ६ ९

def f[A](s:Set[A]):Stream[List[A]]=Nil#::f(s).flatMap(x=>s.map(_::x))

इस तरह की चीजों के लिए आलसी स्ट्रीम काफी अच्छी हैं।

— जो के
स्रोत
1

जाप, 50 40 34 28 बाइट्स

V²o ®s1+Ul)£UgXnH)¯X¦0}Ãâ ¯V

इनपुट है "string", number of items। आउटपुट को लंबाई से क्रमबद्ध किया जाता है, फिर वर्णमाला क्रम को उल्टा किया जाता है। इसे ऑनलाइन टेस्ट करें!

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

V²  o ®   s1+Ul)£  UgXnH)¯  X¦ 0}Ã â ¯  V
Vp2 o mZ{Zs1+Ul)mX{UgXnH)s0,X!=0}} â s0,V

Vp2 o      // Create the range [0..V²).
mZ{     }  // Map each item Z in this range to:
Zs1+Ul)    //  Take the base-(1+U.length) representation of Z.
mX{     }  //  Map each char X in this to:
XnH        //   Parse X as a base-32 number.
Ug   )     //   Take the char at index -^ in U.
s0,X!=0    //   If X is 0, slice it to an empty string.
â          // Uniquify the result.
s0,V       // Slice to the first V items.

यदि आप 100 से अधिक आइटम करना चाहते हैं तो इस संस्करण में थोड़ा समय लगता है। यदि आप एक तेज़ संस्करण चाहते हैं, तो इस 32-बाइट को आज़माएँ :

V*2 o ms1+Ul)f@!Xf'0î£UgXnH}ïV
— ETHproductions
स्रोत
1

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

0000000: 6801 301c e74b                           h.0..K

गैर-प्रतिस्पर्धा क्योंकि इस चुनौती के बाद दालचीनी गोंद बनाया गया था।

इसे ऑनलाइन आज़माएं (TIO लिमिट आउटपुट)।

व्याख्या

hमें दालचीनी गम डालता प्रारूप और मोड उत्पन्न । स्ट्रिंग के बाकी decompresses करने के लिए [%s]*। %sतो इनपुट के साथ बदल दिया जाता है, और एक जनरेटर है कि आउटपुट regex मिलान के लिए सभी संभव तार बनाई गई है।

— एक स्पैगेटो
स्रोत
0

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

s=input();l=['']
for x in l:print x;l+=[x+c for c in s]

यह feersum के 53-बाइट समाधान से अधिक लंबा है , लेकिन यह मुद्रित आउटपुट के साथ एक अलग विधि दिखाता है। यह सूची lउस समय अपडेट की जाती है, जब इसे पढ़े जाने वाले प्रत्येक स्ट्रिंग के हर एक-वर्ण प्रत्यय को जोड़कर इसे पुन: प्रसारित किया जाता है।

यह उपयोग करने के लिए समान रूप से लंबा है map:

s=input();l=['']
for x in l:print x;l+=map(x.__add__,s)

पायथन 3 में एक ही लंबाई की जा सकती है, इसके लिए एक चार को खोने print(), और इनपुट अनपैकिंग से एक को बचाया जा सकता है ।

s,*l=input(),''
for x in l:print(x);l+=[x+c for c in s]
— XNOR
स्रोत
0

Zsh , 31 बाइट्स

f(){<<<${(F)a};a=($^a$^@);f $@}

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

सरणी को प्रिंट करें, फिर आवर्ती करने से पहले तर्कों पर ज़िप करें। फ़ंक्शन नाम शामिल करने के बावजूद, यह पुनरावृत्त संस्करण की तुलना में छोटा है:

for ((;;))<<<${(F)a}&&a=($^a$^@)
— GammaFunction
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.