Garland Wörter

Ein Girlandenwort ist ein Wort, das wie eine Girlande aneinander gereiht werden kann, da es mit denselben Buchstaben endet, mit denen es beginnt. Diese Buchstabengruppen können sich sogar überschneiden!

Beispielsweise undergroundhandelt es sich um ein Girlandenwort in der Reihenfolge 3, da es mit denselben 3 Zeichen beginnt und endet und. Das heißt es könnte gerne aneinander gereiht werden undergroundergrounderground....

alfalfaist auch ein Girlandenwort! Es ist in Ordnung 4. Es beginnt und endet mit alfa. Es kann aneinandergereiht werden , etwa so: alfalfalfalfa.

Ein Prozess, den ich garlandifying nenne, besteht darin, dass Sie, sobald Sie die Reihenfolge neines Girlandenworts festgelegt haben, das ursprüngliche Wort nehmen und das Segment hinzufügen, das erforderlich ist, um es als Girlandenzeitschleife zu nverwenden. Da oniones sich also um ein 2Girlandenwort handelt, würden Sie oniondie ersten 2Buchstaben abhacken, um sie zu erhalten, ionund diese zu den Endzeiten hinzufügen, um sie 2zu erhalten onionionion.

Zielsetzung

Erstellen Sie ein Programm oder eine Funktion, die Eingaben von der Standardeingabe oder einem Funktionsargument entgegennimmt und das Wort als Girlande ausgibt oder zurückgibt.

Alle Wörter werden in Kleinbuchstaben geschrieben und die höchstmögliche Reihenfolge für ein Wort ist length(word) - 1.

Beispiel I / O

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

Dies ist Code-Golf , also gewinnt die geringste Anzahl von Bytes.

Pyth, 19 18 Bytes

+z*>Kf!xz>zT1zl>zK

Probieren Sie es online aus: Vorführ- oder Testgeschirr

Erklärungen:

+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

Python, 60 Bytes

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

Habe auf Besseres gehofft, aber na ja. s.findfunktioniert hier ordentlich anstelle von not s.startswith.

Netzhaut , 58 Bytes

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

Jede Zeile sollte in eine eigene Datei gehen, aber Sie können den Code als eine Datei mit dem -sFlag ausführen .

Die vier Substitutionspaare führen Folgendes aus:

• Doppelte Wörter, damit wir auch nach Überlappungen suchen können.
• Fügen Sie das Wort an, das nach der orderAnzahl der Zeichen aufgeteilt ist.
• Hänge den letzten Teil ordermal an.
• Behalten Sie das ursprüngliche Wort und den zuletzt angehängten Teil bei und lassen Sie alles andere fallen.

Die Zeichenfolge gibt für das Beispiel Folgendes an onion:

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

Haskell, 64 Bytes

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

Tests:

λ: 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

Java, 160 bis 157 Bytes

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;}}

Input-Output:

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

Zur besseren Lesbarkeit in Abständen und mit Tabs versehen:

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;
    }
}

Vorschläge sind willkommen.

Sed: 87 84 Zeichen

(83 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

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

Probelauf:

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

CJam, 24 23 Bytes

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.

Nur um es mit etwas zu beginnen ..

Probieren Sie es hier online aus

Matlab: 97 89 82 Bytes

Funktion, die einen regulären Ausdruck mit Lookbehind und einer Erfassungsgruppe verwendet:

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

Dies sumist erforderlich, um die Eingabe von Leerzeichenfolgen zu verarbeiten (konvertieren []in 0).

Beispiele:

> 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

REGXY, 53 49 Bytes

Verwendet REGXY , eine auf Regex-Substitution basierende Sprache

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

Überblick: Eine Reihe von regulären Ausdrücken wird angewendet. Ein Beispiellauf würde so aussehen:

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 #)

Detaillierte Erklärung Das Folgende ist eine zeilenweise Aufschlüsselung der regulären Ausdrücke:

//$'#/

Hierbei handelt es sich um eine reguläre Ersetzung, die mit der ersten leeren Zeichenfolge (dh dem Anfang der Zeichenfolge) übereinstimmt und diese durch alles rechts von match ( $') gefolgt von einem Hash ersetzt. Zum Beispiel wird es onionzu onion#onion.

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

Diese Zeile findet den Abschnitt, der sich überlappt, indem nach einer Gruppe von Zeichen unmittelbar vor dem # ( (.+)) gesucht wird, die auf der anderen Seite des # ( \1) identisch sind . Das \ K bedeutet nur "Vergiss, dass ich etwas gefunden habe", was bedeutet, dass es bei der Ersetzung nicht ersetzt wird. Das bedeutet effektiv, dass wir der Position einfach ein # hinzufügen, nachdem die Überlappung gefunden wurde und sich onion#onionin verwandelt hat onion#on#ion.

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

Das anfängliche 'a' ist nur eine Bezeichnung für den regulären Ausdruck. Danach finden wir das erste # gefolgt von einem einzelnen Zeichen ( .) und erfassen alles danach bis zum nächsten # ( .*#). Wir ersetzen dies durch alles rechts von der Übereinstimmung, dh das letzte Token ($ '), gefolgt von einem # ( $1), gefolgt vom zweiten Token abzüglich eines Zeichens (wir behandeln dies als einen Zähler und verringern ihn bei jeder Iteration). Im Fall von Zwiebeln # on # ion, die beide Token wir Rückreferenzierung ist in Klammern gezeigt, und der Abschnitt der gesamten regex Einstimmungen zwischen den Rohren: onion|(#)o(n#)|ion. Wir ersetzen dann die Bits, die wir angleichen (zwischen den Pipes), durch $'(alles rechts von der Übereinstimmung, dh 'ion'), dann $ 1 (das #), dann $ 2 (n #), was bedeutet, dass wir am Ende mit onion|(ion)(#)(n#)|ion(Klammern ) enden die drei Token in der Ersatzzeichenfolge).

Wenn der reguläre Ausdruck im ersten Wechsel (alles vor der Pipe) nicht übereinstimmt, müssen wir unseren Zähler auf Null verringert haben, was bedeutet, dass das zweite Token keine Zeichen enthält. Stattdessen schauen wir uns den zweiten Teil des Musters an #.*. Dies ersetzt einfach alles nach dem ersten # mit $'$1$2. Da durch diese Abwechslung keine Rückverweise erstellt werden und rechts von der Übereinstimmung ( .*Übereinstimmungen bis zum Ende der Zeichenfolge) nichts vorhanden ist , beenden wir die Übereinstimmung und geben das Ergebnis zurück.

//a

Dies ist nur ein Verweis auf die vorherige Zeile und stellt sicher, dass die reguläre Ausdrücke so lange ersetzt werden, bis sie nicht mehr übereinstimmen.

jq 1,5: 91 Zeichen

(87 Zeichen Code + 4 Zeichen Befehlszeilenoption.)

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

Probelauf:

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

RS , 51 48 Bytes

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

NEHMEN SIE DAS, RETINA UND SED !!!!! ;)

Schneiden Sie 3 Bytes dank @randomra ab.

Live-Demo und Testfälle.

Beachten Sie, dass der jackhammerTestfall nicht vorhanden ist. Es gibt einen Fehler im Umgang mit Leerzeichen in der Weboberfläche , der dazu führt, dass falsche Ausgaben gedruckt werden. Die Offline-Version von rsbehandelt es richtig.

51-Byte-Version:

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

Live-Demo und Testfälle für Original.

JavaScript (ES6), 95 Byte

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

Demo

Firefox erst einmal:

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>

JavaScript (ES6), 82 Byte

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

[Meine ursprüngliche Antwort wurde gelöscht, da ich jetzt ES6 gelernt habe und daran interessiert war, eine rekursive Lösung für diese Herausforderung zu finden.]

Beispiel

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'));

CoffeeScript + ES6, 77 Bytes

Gleicher Ansatz wie meine JavaScript-Antwort.

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

C

#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;
}

Golf gespielt: 195 Bytes - GCC

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);}

Groovy 75 57 55 Bytes

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

Erstaunlich, wie es helfen kann, am nächsten Tag auf etwas zurückzukommen

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()     
}

Falls jemand den Code in JS benötigt, um ihn zu testen. Hinweis: Ich habe die Zeichenfolge vom Ende durchlaufen, um die Effizienz zu erhöhen:

"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");