इस अफवाह पर कि कोडगॉल्फ में एक रॉक-पेपर-कैंची टूर्नामेंट होगा जिसे आप वर्ग-मुक्त शब्दों के विषय में देखते हैं । पत्र से बना एक शब्द R, P, Sहै वर्ग से मुक्त करता है, तो यह दो बार है कि दोहराता एक दृश्य शामिल नहीं है। यह कहना है, शब्द के रूप में नहीं लिखा जा सकता है

a x x b

जहां aऔर bकोई भी लंबाई के शब्द हैं और xकम से कम लंबाई का एक शब्द भी एक, पत्र के सभी बनाया है R, P, S।

कार्य

एक प्रोग्राम है जो उत्पन्न करता लिखें वर्ग मुक्त पत्र के शब्द R, P, Sलंबाई की nजहां संख्या 1 <= n <= 10इनपुट के रूप में लिया जाता है।

उदाहरण

उदाहरण के लिए लंबाई 3 के वर्ग-मुक्त शब्द हैं

RPR, RSR, RPS, RSP, SPS, SRS, SRP, SPR, PRP, PSP, PSR,PRS

और लंबाई 4 वाले हैं

RPRS, RPSR, RPSP, RSRP, RSPR, RSPS, PRPS, PRSR, PRSP, PSRP, PSRS, PSPR, SRPR, SRPS, SRSP, SPRP, SPRS,SPSR

और ध्यान दें कि उदाहरण के लिए SPSPया PRPRवर्ग-मुक्त नहीं हैं

नियम

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

संदर्भ

वर्ग-मुक्त शब्दों पर विकिपीडिया प्रविष्टि

दी गई लंबाई के वर्गाकार मुक्त टर्नरी शब्दों की संख्या https://oeis.org/A006156 में है

संबंधित: मनमाने ढंग से लंबाई टर्नरी स्क्वायरफ्री शब्द

code-golf sequence

— mschauer
स्रोत

4

के लिए एक परीक्षण मामला n>3एक अच्छा विचार होगा, क्योंकि बार-बार वर्ण बनाम दोहराया अनुक्रम के बारे में कुछ भ्रम हो गया है।

— लाकोनी

कृपया योजना बनाई अनुवर्ती रेत बॉक्स में पर टिप्पणी: codegolf.meta.stackexchange.com/a/14133/45211

— mschauer

6

मुझे नहीं लगता कि "प्राकृतिक भाषा" का टैग यहां लागू होना चाहिए

— लियो

1

आह, "शब्द" का "प्राकृतिक-भाषा" में विस्तार हुआ, मैंने इसे हटा दिया।

— mschauer

1

नहीं, इसमें

— mschauer

20

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

->n{(?P*n..?S*n).grep_v /[^RPS]|(.+)\1/}

यह प्रफुल्लित करने वाला अकुशल कार्य लंबाई N के सभी तारों को उत्पन्न करता है जो N Ps और N Ss के बीच वर्णानुक्रम में झूठ बोलते हैं, फिर गैर-RPS वर्णों वाले विशाल बहुमत को फ़िल्टर करते हैं। वास्तविक squarefree जांच सिर्फ एक Regexp backreference उपयोग करता है: (.+)\1।

अधिक मुहावरेदार 65 बाइट्स जो एन = 10 के लिए उचित समय में समाप्त होते हैं:

->n{%w[R P S].repeated_permutation(n).map(&:join).grep_v /(.+)\1/}

संपादित करें: G B के लिए एक बाइट धन्यवाद सहेजा गया

— histocrat
स्रोत

आपको grep_v पर कोष्ठक की आवश्यकता नहीं है, इसके और स्लैश के बीच में एक स्थान (1 बाइट बचाएं)

— GB

6

" प्रफुल्लित करने वाला अयोग्य " शायद इस साइट पर काफी कुछ उत्तर बताता है।

— निधि मोनिका मुकदमा

10

जेली , 15 14 बाइट्स

“RPS”ṗẆ;"f$$Ðḟ

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

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

“RPS”ṗẆ;"f$$Ðḟ  Main link. Argument: n

“RPS”ṗ          Cartesian power; yield all strings of length n over this alphabet.
            Ðḟ  Filterfalse; keep only strings for which the quicklink to the left 
                returns a falsy result.
           $      Monadic chain. Argument: s (string)
      Ẇ             Window; yield the array A of all substrings of s.
          $         Monadic chain. Argument: A
       ;"             Concatenate all strings in A with themselves.
         f            Filter; yield all results that belong to A as well.

— डेनिस
स्रोत

7

रेटिना , 28 बाइट्स

+%1`1
R$'¶$`P$'¶$`S
A`(.+)\1

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

इनपुट लेता एकल में ।

व्याख्या

+%1`1
R$'¶$`P$'¶$`S

यह लंबाई से बने सभी तारों को उत्पन्न करता है । जिस तरह से हम ऐसा करते हैं कि हम बार-बार प्रत्येक पंक्ति में पहले की जगह लेते हैं । चलिए लाइन के बारे में सोचते हैं , जहां मैच के सामने सब कुछ है और मैच के बाद सब कुछ है (वे और क्रमशः रेक्सएक्स प्रतिस्थापन सिंटैक्स में, लेकिन वे कम सहज दिखते हैं)। हम साथ की जगह लेते हैं , जहां लाइनफीड होते हैं। तो इस प्रतिस्थापन का पूरा परिणाम वास्तव में है , जो लाइन के तीन प्रतियां है, साथ के साथ बदलें , , , क्रमशः, तीन प्रतियों में से प्रत्येक में। यह प्रक्रिया एक बार बंद हो जाती है जब सभी एस प्रतिस्थापित हो जाते हैं।RPSn1<1><>$`$'1R>¶<P>¶<S¶<R>¶<P>¶<S>1RPS1

A`(.+)\1

अंत में, हम केवल उन सभी लाइनों को छोड़ देते हैं जिनमें दोहराव होता है।

— मार्टिन एंडर
स्रोत

मैं बार-बार बदल 1(.*)जाता $1R¶$1P¶$1Sलेकिन बाइट-काउंट एक ही है।

— नील

6

भूसी , 15 14 बाइट्स

-1 बाइट ज़गरब को धन्यवाद!

fȯεfoE½QΠR"RPS

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

सही लंबाई के सभी संभव अनुक्रम बनाता है और केवल उन सभी को रखता है जिनके सभी सबस्ट्रिंग (खाली को छोड़कर) दो अलग-अलग हिस्सों द्वारा बनाए गए हैं।

अरे, मैं वास्तव में यहाँ जेली को हराना चाहता था।

— सिंह
स्रोत

3

जेली के साथ टाई करने के लिए 14 बाइट्स ।

— जर्बद

5

गणितज्ञ, 61 बाइट्स

""<>#&/@{"R","P","S"}~Tuples~#~DeleteCases~{___,x__,x__,___}&

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

— J42161217
स्रोत

5

जावा 8, 285 277 बाइट्स

import java.util.*;Set r=new HashSet();n->p("",((1<<3*n)+"").replaceAll(".","PRS"),n)void p(String p,String s,int n){int l=s.length(),i=0;if(l<1&&(s=p.substring(0,n)).equals(s.replaceAll("(.*)\\1","")))r.add(s);for(;i<l;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,l),n));}

हालाँकि जावा लगभग हमेशा क्रियात्मक है, इस मामले में यह निश्चित रूप से इस तरह की चुनौती के लिए सही भाषा नहीं है। प्रदर्शन और अकुशल के लिए सबस्ट्रिंग के साथ निर्माण उत्पन्न करना खराब है।

निश्चित रूप से कुछ और गोल्फ हो सकता है, हालांकि।

-8 बाइट्स @ जेकॉब को धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (प्रदर्शन 3 से ऊपर परीक्षण के मामलों के लिए बहुत बुरा है, लेकिन यह स्थानीय स्तर पर काम करता है ..)

import java.util.*;   // Required import for Set and HashSet

Set r=new HashSet();  // Result-Set on class-level

n->                   // Method with integer parameter and no return-type
  p("",((1<<3*n)+"").replaceAll(".","PRS"),n)
                      //  Get all permutations and save them in the Set
                      // End of method (implicit / single-line return-statement)

void p(String p,String s,int n){
                      // Separated method with 2 String & int parameters and no return-type
  int l=s.length(),   //  The length of the second input-String
      i=0;            //  Index-integer, starting at 0
  if(l<1              //  If the length is 0,
     &&(s=p.substring(0,n)).equals(s.replaceAll("(.*)\\1","")))
                      //  and it doesn't contain a repeated part:
    r.add(s);         //   Add it to the result-Set
  for(;i<l;           //  Loop (2) from 0 to `l`
    p(                //   Recursive-call with:
      p+s.charAt(i),  //    Prefix-input + the character of the second input at index `i`
      s.substring(0,i)+s.substring(++i,l),
                      //    and the second input except for this character
      n)              //    and `n`
  );                  //  End of loop (2)
}                     // End of separated method

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

1

कैसे इस भेड़ के बच्चे के बारे में n->p("",((1<<3*n)+"").replaceAll(".","PRS"),n):। इसके अलावा, क्यों नहीं refactor for(;i<1;p(...));करने के लिए while(i<l)p(...);?

— जैकब

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

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

1

हाँ, मैं हमेशा कोशिश करता हूं कि किसी दिए गए बाइट काउंट पर जितना संभव हो सके अपने गोल्फ कोड को पढ़ा जा सके। शायद एक निरर्थक खोज!

— जेकब

रुको, क्या मेरा लंबोदर वास्तव में यहां काम करता है? मैं थोड़ा लापरवाह था ... यह n PRS अनुक्रमों की एक स्ट्रिंग उत्पन्न करता है , जबकि आपका मूल लूप 2 ^ ( एन -2) दृश्यों के साथ उत्पन्न होता है।

— जैकब

@ जाकोब nसमय "पीआरएस" सही है। मेरा अधिक उत्पादन हो रहा था क्योंकि यह बाइट्स को बचाता था (और प्रदर्शन में कमी आई थी, लेकिन कोडगोल्फ के साथ कौन परवाह करता है)। ;)

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

4

पायथन 3 , 97 96 बाइट्स

f=lambda n:{c+s for c in'RPS'*n for s in f(n-1)or{''}if all(k-s.find(c+s[:k])for k in range(n))}

स्ट्रिंग्स का एक सेट लौटाता है।

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

— डेनिस
स्रोत

4

जूलिया 0.6 , 65 बाइट्स

!n=n>0?["$c"s for s=!~-n,c="RPS"if~ismatch(r"(.+)\1","$c"s)]:[""]

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

— डेनिस
स्रोत

4

पर्ल 5 , 37 बाइट्स

sub r{grep!/(.+)\1/,glob"{R,S,P}"x<>}

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

फ़ंक्शन स्क्वायर फ्री स्ट्रिंग्स की एक सरणी देता है।

व्याख्या की:

globलंबाई के साथ की आर, एस, एंड पी सभी संयोजनों इनपुट के बराबर उत्पन्न करता है। यह grepकथन उन लोगों को फ़िल्टर करता है जो वर्ग मुक्त नहीं हैं।

— Xcali
स्रोत

ब्रेस विस्तार का शानदार उपयोग!

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

3

आर , 97 बाइट्स

cat((x=unique(combn(rep(c('p','r','s'),n),n<-scan(),paste,collapse='')))[!grepl("(.+)\\1",x,,T)])

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

combn(rep(c('p','r','s'),n),n,paste,collapse='')सभी गणना करता है nसाथ -वर्ण तार p, r, s, लेकिन यह दुर्भाग्य से डुप्लिकेट कई (*), इसलिए हम इसे uniquify, और उन है कि रेगुलर एक्सप्रेशन से मेल ले (.+)\1, पर्ल शैली मिलान का उपयोग कर, तो हम बाहर परिणामी सूची मुद्रित करें।

(*) तकनीकी रूप से, यह एक बार में लिए गए 3 बार 3nमें अक्षरों के सभी संयोजनों को उत्पन्न करता है, फिर सीधे तारों की गणना करने के बजाय प्रत्येक संयोजन पर लागू होता है , लेकिन यह एक (सच्चे कार्टेशियन उत्पाद) की तुलना में गोल्फर है ।p,r,snpaste(..., collapse='')3^nexpand.grid

— ग्यूसेप
स्रोत

3

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

f=n=>n?[for(x of f(n-1))for(y of'RPS')if(!/(.+)\1/.test(y+=x))y]:['']

चूँकि वर्गाकार-मुक्त शब्दों के सभी संक्षिप्तीकरण भी वर्गाकार-मुक्त होते हैं इसलिए जाँच पुनरावर्ती रूप से की जा सकती है।

— नील
स्रोत

2

हास्केल , 101 98 बाइट्स

f n=[x:r|x:r<-mapM(\_->"RPS")[1..n],[x]#r]
h#t@(x:r)=h/=take(length h)t&&(h++[x])#r&&[x]#r
h#t=1<3

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

— Laikoni
स्रोत

2

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

n=>[...Array(3**n)].map(g=(d=n,i)=>d?'RPS'[i%3]+g(d-1,i/3|0):'').filter(s=>!/(.+)\1/.test(s))

सभी पूर्णांकों RPSको अंक के रूप में उपयोग करके 0 से 3ts से (उलट पैडेड) आधार 3 में कनवर्ट करता है और उन्हें वर्ग-मुक्त शब्दों के लिए फ़िल्टर करता है।

— नील
स्रोत

2

जूलिया, 88

f(n)=[filter(A->!ismatch.(r"(.+)\1",join(A)),Iterators.product(repeated("RPS",n)...))...]

कुछ भी आकर्षक नहीं।

— mschauer
स्रोत

1

C # / LINQ, 169

Enumerable.Range(0,(int)Math.Pow(3,n)).Select(i=>string.Concat(Enumerable.Range(1,n).Select(p=>"PRS"[(i/(int)Math.Pow(3,n-p))%3]))).Where(s=>!Regex.IsMatch(s,@"(.+)\1"))

ऐसा करने का एक बेहतर तरीका होना चाहिए :)

— जेसन हैंडबी
स्रोत

1

एफ #, 143

let f n=[1..n]|>List.fold(fun l _->List.collect(fun s->["R";"P";"S";]|>List.map((+)s))l)[""]|>Seq.filter(fun x->not(Regex.IsMatch(x,"(.+)\1")))

— जेसन हैंडबी
स्रोत

अच्छा F # उत्तर!

— aloisdg

1

यह भाषाओं की सबसे अधिक कॉम्पैक्ट नहीं है, लेकिन हे, इसे इस्तेमाल करने का कोई भी बहाना :)

— जेसन हंडबी

1

मैं आपको महसूस करता हूं । यह भाषा इतनी अच्छी है।

— aloisdg

1

के, 56 बाइट्स

f:{$[x;(,/"RPS",/:\:f x-1){x@&~~/'(2,y)#/:x}/1_!x;,""]}

देशी रेगेक्स की कमी एक बार के लिए वक्र को अच्छी तरह से पीछे रखती है। मैं एक पुनरावर्ती समाधान के साथ गया था, क्योंकि इसे लागू करने के लिए पात्रों को एक सरल स्क्वायरफ्री चेक द्वारा बचाया गया था।

$[ test ; if-true ; if-false ]

k का ternary ऑपरेटर है, यहां हम गैर-शून्य लंबाई के लिए दिलचस्प सामान करते हैं, और शून्य लंबाई वाले शब्दों के लिए एकल खाली स्ट्रिंग लौटाते हैं।

(,/"RPS",/:\:f x-1)

"आरपीएस" और सभी एन -1 लंबाई वर्गफ्री शब्दों के कार्टेशियन उत्पाद लेता है। , /: \: दाएं से बाएं के प्रत्येक तत्व को जोड़ता है, जिससे लंबाई n सरणियों की लंबाई 3 सरणी होती है। , / यह एक लंबाई 3n सरणी में समतल करता है।

{x@&~~/'(2,y)#/:x}

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

/1_!x

लैम्बडा को इसके बाईं ओर स्थित प्रारंभिक परिणाम पर लागू करता है, जो प्रत्येक प्रतिस्थापन लंबाई पर 1 से लेकर (शब्द लंबाई) -1 तक पुनरावृत्त होता है। ! x 0 से x-1 तक एक सूची बनाता है, फिर 1_ पहला तत्व निकालता है (चूंकि 0-लंबाई सबस्ट्रिंग हमेशा चालू रहेगी)

कुछ वर्णों का त्याग कर हम उपयोग कर सकते हैं। फ़ंक्शन के नाम पर भरोसा करने के बजाय आत्म-संदर्भ का उपयोग कर सकते हैं, और प्रदर्शन के लिए लंबाई n-1 केवल चेक फ़्लोर (n / 2) तक सबस्ट्रिंग चेक करने के बजाय। यह सभी लंबाई 49 शब्दों (जिनमें से 5207706 हैं) को 7700k पर लगभग 120 सेकंड में पता चलता है, इसके बाद मैं मुफ्त 32-बिट k की 4GB सीमा में चला जाता हूं।

{$[x;(,/"RPS",/:\:.z.s x-1){x@&~~/'(2,y)#/:x}/1+!_x%2;,""]}

— ostewart
स्रोत

0

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

import re
f=lambda n:n and[c+s for c in'RPS'for s in f(n-1)if not re.search(r'(.+)(\1)',c+s)]or['']

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

— चास ब्राउन
स्रोत

रॉक-पेपर-कैंची में अपने आप को दोहराएं नहीं

कार्य

उदाहरण

नियम

संदर्भ

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

जेली , 15 14 बाइट्स

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

रेटिना , 28 बाइट्स

व्याख्या

भूसी , 15 14 बाइट्स

गणितज्ञ, 61 बाइट्स

जावा 8, 285 277 बाइट्स

पायथन 3 , 97 96 बाइट्स

जूलिया 0.6 , 65 बाइट्स

पर्ल 5 , 37 बाइट्स

आर , 97 बाइट्स

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

हास्केल , 101 98 बाइट्स

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

जूलिया, 88

C # / LINQ, 169

एफ #, 143

के, 56 बाइट्स

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