Garlandification

Question

माला शब्द

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

उदाहरण के लिए, undergroundआदेश की माला शब्द है 3, क्योंकि यह शुरू होता है और एक ही 3 अक्षरों के साथ अंत und। इसका मतलब यह है कि यह एक साथ जैसे मारा जा सकता है undergroundergrounderground...।

alfalfaएक माला शब्द भी है! यह आदेश 4 है। यह शुरू होता है और इसके साथ समाप्त होता है alfa। यह एक साथ इतनी तरह बांधा जा सके: alfalfalfalfa।

एक प्रक्रिया जिसे मैं माला कहता हूं वह है जहां एक बार जब आप nएक माला शब्द के क्रम को निर्धारित करते हैं , तो आप मूल शब्द लेते हैं और इसे लूप के रूप में एक माला nसमय के लिए आवश्यक खंड जोड़ते हैं । इसलिए, चूंकि onionएक ऑर्डर 2माला शब्द है, तो आप पाने के onionलिए पहले 2अक्षरों को काट लेंगे ionऔर अंत 2समय के लिए जोड़ देंगे onionionion।

लक्ष्य

एक प्रोग्राम या फ़ंक्शन करें जो मानक इनपुट या एक फ़ंक्शन तर्क से इनपुट लेता है और शब्द को प्रिंट या प्रिंट करता है, गला हुआ है।

सभी शब्द लोअरकेस होंगे, और किसी शब्द के लिए उच्चतम संभव क्रम है length(word) - 1।

उदाहरण I / O

"onion"       --> "onionionion"
"jackhammer"  --> "jackhammer"
"abracadabra" --> "abracadabracadabracadabracadabracadabra"
""            --> ""
"zvioz"       --> "zviozvioz"
"alfalfa"     --> "alfalfalfalfalfalfa"
"aaaa"        --> "aaaaaaa"

---

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतती हैं।

Comments

कोई भी N- अक्षर शब्द उसी N अक्षर से शुरू होता है, जिसके साथ वह समाप्त होता है। अधिकतम आदेश क्या है जिस पर विचार किया जाना चाहिए?

— feersum

@ Faersum अधिकतम क्रम शब्द की लंबाई है - 1. जो मुख्य पोस्ट में जोड़ा गया है।

— केड

क्या मुझे सिर्फ माला का प्रिंट आउट लेना है? या मैं शायद इसे और एक अपवाद मुद्रित कर सकता हूं?

— डेडशेक्स

@DeadChex कोई अपवाद नहीं होना चाहिए।

— केड

@LuisMendo इसे मनमाने ढंग से लंबे शब्दों के लिए काम करना चाहिए।

— केड

Answer 1

पायथ, 19 18 बाइट्स

+z*>Kf!xz>zT1zl>zK

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

स्पष्टीकरण:

+z*>Kf!xz>zT1zl>zK   implicit: z = input string
     f      1        find the first number T >= 1, which satisfies:
         >zT            all but the first T chars of z
       xz               index of ^ in z
      !                 == 0
    K                store in K
                     the order is length(z) - K
   >K        z       the last K chars
  *                  repeated
              l>zK   len(all but the last K chars) times
+z                   insert z at the beginning

Answer 2

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

f=lambda s,i=1:s.find(s[i:])and f(s,i+1)or(len(s)-i)*s[:i]+s

बेहतर के लिए उम्मीद कर रहा था, लेकिन ओह ठीक है। s.findके स्थान पर बड़े करीने से यहां काम करता है not s.startswith।

Answer 3

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

.+
$0#$0
(.*)(.+)#.*\1$
$0#$1#$2-
+`\w#(\w*)-
#$1-$1
#.*-
<empty line>

प्रत्येक पंक्ति को अपनी फ़ाइल पर जाना चाहिए लेकिन आप -sध्वज के साथ एक फ़ाइल के रूप में कोड चला सकते हैं ।

चार प्रतिस्थापन जोड़े निम्नलिखित कार्य करते हैं:

• डुप्लिकेट शब्द तो हम ओवरलैप के लिए भी खोज सकते हैं।
• orderवर्णों की संख्या पर विभाजित शब्द को जोड़ें ।
• पिछले भाग orderसमय लागू करें।
• मूल शब्द और अंतिम रूप से जोड़ा गया भाग रखें और बाकी सब कुछ छोड़ दें।

स्ट्रिंग उदाहरण के लिए बताता है onion:

onion
onion#onion
onion#onion#on#ion-
onion#onion##ion-ionion
onionionion

Answer 4

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

g s=[b>>a|(a,b)<-map(`splitAt`s)[1..],and$zipWith(==)s b]!!0++s

टेस्ट:

λ: g "onion"       == "onionionion"
True
λ: g "jackhammer"  == "jackhammer"
True
λ: g "abracadabra" == "abracadabracadabracadabracadabracadabra"
True
λ: g ""            == ""
True
λ: g "zvioz"       == "zviozvioz"
True
λ: g "alfalfa"     == "alfalfalfalfalfalfa"
True
λ: g "aaaa"        == "aaaaaaa"
True

Answer 5

जावा, 160 157 बाइट्स

static void g(String s){int i=s.length(),o;for(String p=s;i-->0;)if(s.endsWith(s.substring(0,i))){for(o=i;o-->0;)p+=s.substring(i);System.out.print(p);i=0;}}

इनपुट आउटपुट:

 g("abracadabra"); --> "abracadabracadabracadabracadabracadabra"

पठनीयता के लिए स्थान और वर्जित:

static void g(String s){
int i=s.length(),o;
for(String p=s;i-->0;)
    if(s.endsWith(s.substring(0,i))){
        for(o=i;o-->0;)
            p+=s.substring(i);
        System.out.print(p);
        i=0;
    }
}

सुझाव का स्वागत करते हैं।

Comments

मेरे स्वयं के लिए एक नोट के रूप में, स्ट्रिंग ऑप्स को एक बाइट या अर्धविराम पर दो को बचाने के लिए लूप में ले जाया जा सकता है

— डेडचेक्स

क्यों नहीं करते i=0;?

— ओवरएक्टर

@overactor कहाँ है? मेरे द्वारा लंबाई का उपयोग करने का कारण यह है क्योंकि मैं पूर्ण स्ट्रिंग चाहता हूं और फिर मैं इसमें से किसी की ओर बढ़ना चाहता हूं, विकल्प के साथ मुझे नहीं लगता कि मैं इस पद्धति का उपयोग करने से बच सकता हूं और इसके लिए बाइट का जुर्माना

— लगाऊंगा

मेरा मतलब था कि पाश के लिए बाहरी रूप से टूटना।

— ओवरएक्टर

Answer 6

पाल: 87 84 वर्ण

(83 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

h
s/(.*)./& \1/
T
s/(.+) \1.*/ \1 \1/
t
g
q
:
s/^([^ ]+)(.*)[^ ]$/\1 \1\2/
t
s/ //g

नमूना रन:

bash-4.3$ sed -r 'h;s/(.*)./& \1/;T;s/(.+) \1.*/ \1 \1/;t;g;q;:;s/^([^ ]+)(.*)[^ ]$/\1 \1\2/;t;s/ //g' <<< 'underground'
undergroundergroundergrounderground

Comments

आडम्बर उत्तर का स्वत: उत्थान; ;-)। अपनी लेबल परिभाषा और शाखा से 2 चार्ट छोड़ने के लिए इस टिप का अनुसरण करें

— डिजिटल ट्रॉमा

कोशिश की, लेकिन मुझे डर है कि सलाह केवल उन मामलों के लिए है जब आपके पास कोड के अंत तक लेबल-कम कूदता नहीं है। [थोड़ी देर बाद ...] ठीक है, फिर से सोच कर, मैंने एक ही बार में कई इनपुट लाइनें संसाधित करने की कोशिश क्यों की?

— मैनटवर्क

Answer 7

सीजेएम, 24 23 बाइट्स

q_:Q,{~)Q>Q\#!},W>~_Q>*

q_:Q                       e# Read the input, take a copy and store it in Q too
    ,{        },           e# Take the length of the input and filter [0 .. len - 1] array
      ~)                   e# Same as number * -1
        Q>                 e# Take last number characters. Call this string S
          Q\#!             e# See if Q starts with S. After the filter, we will only have
                           e# those numbers from [0 .. len - 1] array which are valid orders
                W>~        e# Take the last order number, if exists.
                   _Q>*    e# Garlandify the input order times.

बस इसे कुछ के साथ शुरू करने के लिए ..

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

Answer 8

मतलाब: 97 89 82 बाइट्स

फ़ंक्शनबाइंड और कैप्चर समूह के साथ एक नियमित अभिव्यक्ति का उपयोग करने वाले फ़ंक्शन:

function t=f(s)
n=sum(regexp(s,'(.*$)(?<=^\1.+)'))-1;t=[s(repmat(1:n,1,end-n)) s];

यही कारण है कि sumखाली स्ट्रिंग इनपुट (परिवर्तित संभाल करने की जरूरत है []में 0)।

उदाहरण:

> f('onion'), f('jackhammer'), f('abracadabra'), f(''), f('zvioz'), f('alfalfa'), f('aaaa')
ans =
onionionion
ans =
jackhammer
ans =
abracadabracadabracadabracadabracadabra
ans =
   Empty string: 1-by-0
ans =
zviozvioz
ans =
alfalfalfalfalfalfa
ans =
aaaaaaa

Answer 9

REGXY, 53 49 बाइट्स

REGXY , एक रेगेक्स प्रतिस्थापन आधारित भाषा का उपयोग करता है

//$'#/
/.(.+)#\1\K/#/
a/(#).(.*#)|#.*/$'$1$2/
//a

अवलोकन: कई नियमित अभिव्यक्तियों को लागू किया जाता है। एक उदाहरण रन जैसा दिखेगा:

onion (input)
onion#onion (line 1 regex)
onion#on#ion (line 2 regex - find the repeated section and separate with #)
onionion#n#ion (line 3 regex - the length of the middle token is the garland order, remove a character and append the third token onto the original string on the left)
onionionion##ion (line 4 regex is a pointer to line 3 - repeat the previous again)
onionionion##ion (line 4 regex is a pointer to line 3 - strip everything after and including the #)

विस्तृत विवरण निम्नलिखित रेखाओं के टूटने से एक पंक्ति है:

//$'#/

यह एक रेगेक्स प्रतिस्थापन है जो पहली खाली स्ट्रिंग (यानी स्ट्रिंग की शुरुआत) से मेल खाता है और इसे मैच के दाईं ओर सब कुछ के साथ बदल देता है ( $') एक हैश द्वारा पीछा किया जाता है। उदाहरण के लिए, यह बदल onionजाएगा onion#onion।

/.(.+)#\1\K/#/

यह रेखा उस खंड को खोजती है, जो कि पूर्व (# (.+)) के पूर्व के समान वर्णों के समूह की तलाश में होता है, जो # ( ) के दूसरी तरफ समान होते हैं \1। \ K का अर्थ है 'भूल जाओ कि मैं कुछ भी मिलान करता हूं', इसका अर्थ यह है कि वास्तव में प्रतिस्थापन में इसे प्रतिस्थापित नहीं किया जाएगा। यह प्रभावी रूप से, इस का मतलब है कि हम सिर्फ एक # स्थिति के लिए के बाद ओवरलैप, पाया गया है मोड़ जोड़ने onion#onionमें onion#on#ion।

a/(#).(.*#)|#.*/$'$1$2/

प्रारंभिक 'ए' रेगेक्स के लिए एक लेबल है। इसके बाद, हम पहले # के बाद एक एकल वर्ण ( .) पाते हैं और इसके बाद अगले # ( .*#) तक सब कुछ कैप्चर करते हैं । हम इसे मैच के दाईं ओर यानी पिछले टोकन ($ ') के साथ बदल देते हैं, उसके बाद एक # ( $1), उसके बाद दूसरा टोकन कम वर्ण (हम इसे एक काउंटर के रूप में मानते हैं, प्रत्येक पुनरावृत्ति को कम करते हुए)। # आयन पर # प्याज के मामले में, हम जिन दो टोकन पर पीछे हटते हैं, उन्हें कोष्ठक में दिखाया गया है, और अनुभाग पूरे रेगेक्स मेल पाइप के बीच है onion|(#)o(n#)|ion:। इसके बाद हम उन बिट्स की जगह लेते हैं जिन्हें हम (पाइप के बीच) मैच करते हैं (मैच $'के दाईं ओर यानी 'आयन'), फिर $ 1 (# #), फिर $ 2 (n #), जिसका अर्थ है कि हम onion|(ion)(#)(n#)|ion(कोष्ठक दिखाते हैं) प्रतिस्थापन स्ट्रिंग में तीन टोकन)।

यदि रेगेक्स पहले विकल्प (पाइप से पहले सब कुछ) में मेल करने में विफल रहता है, तो हमें अपने काउंटर को शून्य तक कम करना चाहिए, जिसका अर्थ है कि दूसरे टोकन के अंदर कोई वर्ण नहीं है। इसके बजाय, हम, पैटर्न के दूसरे भाग को देखो #.*। यह बस पहले # के बाद सब कुछ बदल देता है $'$1$2। चूंकि इस प्रत्यावर्तन द्वारा कोई बैकरेफ़रेंस नहीं बनाए गए हैं, और मैच के अधिकार के लिए कुछ भी नहीं है ( .*स्ट्रिंग के अंत तक मैच), हम मैच को समाप्त करते हैं और परिणाम वापस करते हैं।

//a

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

Answer 10

jq 1.5: 91 अक्षर

(87 वर्ण कोड + 4 वर्ण कमांड लाइन विकल्प।)

.+. as$t|[range(1;length)|select($t[:.]==$t[-.:])]|(max//0)as$i|[range($i)|$t[$i:]]|add

नमूना रन:

bash-4.3$ jq -R -r -f judy.jq <<< 'underground'
undergroundergroundergrounderground

Answer 11

आरएस , 51 48 बाइट्स

(.+)/\1 \1
(.+)(.+) .+\1$/\1(\2)^^((^^\1_))
 .*/

कि, RETINA और SED ले लो !!!!! ;)

@Randomra की बदौलत 3 बाइट्स काट दिए।

लाइव डेमो और परीक्षण के मामले।

ध्यान दें कि jackhammerपरीक्षण मामला नहीं है। वेब इंटरफ़ेस में रिक्त स्थान को संभालने के लिए एक बग है जो इसे गलत आउटपुट प्रिंट करने का कारण बनता है। ऑफ़लाइन संस्करण rsइसे सही ढंग से संभालता है।

51-बाइट संस्करण:

(.+)/\1 \1
^(.+)(.+) (.+)\1$/\1(\2)^^((^^\1_))
 .*/

लाइव डेमो और मूल के लिए परीक्षण के मामले।

Comments

@randomra अपडेट किया गया। धन्यवाद!

— kirbyfan64sos

Answer 12

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

f=s=>{for(e=i=s.length;i&&e;)s+=s.slice(--i).repeat(!(e=!s.endsWith(s.slice(0,i)))*i);return s}

डेमो

केवल अब के लिए फ़ायरफ़ॉक्स:

f = s => {
  for (e = i = s.length; i && e;) s += s.slice(--i).repeat(!(e = !s.endsWith(s.slice(0, i))) * i);
  return s
}

console.log = x => X.innerHTML += x + '\n';

console.log(f('onion'));
console.log(f('jackhammer'));
console.log(f('abracadabra'));
console.log(f(''));
console.log(f('zvioz'));
console.log(f('alfalfa'));
console.log(f('aaaa'));

<pre id=X></pre>

Answer 13

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

g=(s,i=t=s.length)=>s.endsWith(c=s.slice(0,--i))?c+s.slice(i-t).repeat(i+1):g(s,i)

[मेरे मूल उत्तर को नष्ट कर दिया, क्योंकि मैंने अब ES6 सीख लिया है और इस चुनौती का पुनरावर्ती समाधान खोजने में रुचि रखता था]

उदाहरण

g=(s,i=t=s.length)=>s.endsWith(c=s.slice(0,--i))?c+s.slice(i-t).repeat(i+1):g(s,i)

console.log(g('onion'));
console.log(g('jackhammer'));
console.log(g('abracadabra'));
console.log(g(''));
console.log(g('zvioz'));
console.log(g('alfalfa'));
console.log(g('aaaa'));

Answer 14

कॉफीस्क्रिप्ट + ईएस 6, 77 बाइट्स

मेरे जावास्क्रिप्ट जवाब के रूप में एक ही दृष्टिकोण।

f=(s,e=i=s.length)->s+=s[i..].repeat !(e=!s.endsWith s[...i])*i while--i&&e;s

Answer 15

सी

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

int main(int argc, char **argv) {
    char *str   = NULL;
    char *p     = NULL;
    int len     = 0 ;
    int i       = 0;
    int j       = 0;
    int k       = 0;
    int loop    = 0;

    if (argc == 1 )
        return 0;

    str = argv[1];
    len = strlen(str);

    if (len %2) {
        loop = len/2 + 1;
    }
    else {
        loop = len/2;
    }


    p = &str[len/2];
    for (i = 0; i < loop ; i++) {
        if (str[k] == *(p++)) {
            k++;
        }
        else
            k = 0;
    }

    printf("k = %d\n", k);
    printf("%s", str);
    p = &str[k];
    for (j =0; j < k ; j++) {
        printf("%s", p);
    }
    return 0;
}

गोल्फ: 195 बाइट्स - जीसीसी

main(int c,char**a){
char *s=a[1],*p;int i=0,j=0,k=0,z,l=strlen(a[1]);
z=l%2?-~(l/2):l/2;p=&s[l/2];
for(;i<z;i++)k=s[k]==*(p++)?-~k:0;
printf("k=%d\n",k);puts(s);p= &s[k];
for(;j<k;j++)puts(p);}

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह प्रश्न कोड गोल्फ है, इसलिए मेरा सुझाव है कि आप अनावश्यक व्हाट्सएप आदि को हटाकर अपने कोड को "गोल्फ" करें, और फिर भाषा के साथ अपने पोस्ट के शीर्षक में अपने कोड की बाइट गणना को शामिल करें।

— lirtosiast

समझ गया। दिशा का शुक्रिया। मैं अगली बार इसे ध्यान में रखूंगा।

— आलम

यह "गोल्फ" करने के लिए बहुत देर नहीं हुई है। यदि आप अपने उत्तर के नीचे "संपादित करें" बटन पर क्लिक करते हैं, तो आप अभी भी अनावश्यक व्हाट्सएप को हटा सकते हैं और एक बाइट गिनती जोड़ सकते हैं।

— DJMcMayhem

int(C के पर्याप्त रूप से पुराने संस्करणों) में अंतर्निहित नहीं है?

— मोनिका

Answer 16

ग्रूवी 75 57 55 बाइट्स

f={w->x=w;w.find{x-=it;!w.indexOf(x)};w+(w-x)*x.size()}

कमाल है कि कैसे किसी दिन के बाद वापस आ सकते हैं

Ungolfed:

f = {w ->

//Set x equal to w
    x=w

//Loop through the characters of w until we return true
    w.find {

//set x equal to x minus the first instance of the current character, i.e.     the word minus the first character
        x-=it

//Returns the index of the first occurance of the string of chars x, when this is 0 (false) we want to return true, so negate it
        !w.indexOf(x)
    }

//When we've escaped the loop, if we've found a match return the word plus the word minus the match multiplied by the lengh of the match.
    w+(w-x)*x.size()     
}

Answer 17

यदि किसी को इसे जांचने के लिए JS में कोड की आवश्यकता है। नोट: मैंने दक्षता बढ़ाने के लिए स्ट्रिंग को अंत से पीछे किया है:

"use strict";

var garlandify = function(inputString){
    var stringLength = inputString.length;  
    var savedString = inputString;

    for( var i=1; i<stringLength; i++ ){
         var endIndex = Math.abs(i) * -1;       
         if( inputString.startsWith( inputString.substr(endIndex) ) ){
              for( var j=1; j<=i; j++){
                  savedString += inputString.substr(i, stringLength );
              }
              console.log(savedString);         
         }  
    }
};

garlandify("onion");

Comments

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

— टोबे स्पाइट