Mots guirlande

Un mot guirlande est un mot qui peut être relié comme une guirlande, car il se termine par les mêmes lettres qu'il commence par. Ces groupes de lettres peuvent même se chevaucher!

Par exemple, undergroundest un mot d'ordre en guirlande 3, car il commence et finit avec les mêmes 3 caractères und,. Cela signifie qu'il pourrait être lié comme undergroundergrounderground....

alfalfaest un mot de guirlande, aussi! C'est de l'ordre 4. Cela commence et se termine par alfa. Il peut être enfilées comme ceci: alfalfalfalfa.

Un processus que j'appelle garlandifying est le suivant: une fois que vous déterminez l'ordre nd'un mot, vous prenez le mot d'origine et ajoutez le segment requis pour le faire boucler comme une guirlande n. Donc, puisque onionc'est un 2mot d' ordre en guirlande, vous onionprendriez, couperiez les premières 2lettres pour en obtenir ionet ajoutez cela à la fin des 2temps à obtenir onionionion.

Objectif

Créez un programme ou une fonction qui prend en entrée une entrée standard ou un argument de fonction et affiche ou renvoie le mot, garlandified.

Tous les mots seront en minuscule et l’ordre le plus élevé possible pour un mot est length(word) - 1.

Exemple I / O

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

C'est le code-golf , donc le moins d'octets gagne.

Pyth, 19 à 18 octets

+z*>Kf!xz>zT1zl>zK

Essayez-le en ligne: démonstration ou test de harnais

Explications:

+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 octets

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

J'espérais mieux, mais bon. s.findfonctionne parfaitement ici à la place de not s.startswith.

Retina , 58 octets

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

Chaque ligne doit aller dans son propre fichier mais vous pouvez exécuter le code en tant que fichier unique -s indicateur.

Les quatre paires de substitution font les choses suivantes:

• Mot en double pour que nous puissions également rechercher des chevauchements.
• Ajouter le mot divisé en order nombre de caractères.
• Ajouter la dernière partie order temps .
• Conservez le mot d'origine et la dernière partie ajoutée et supprimez tout le reste.

La chaîne indique pour l'exemple onion:

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

Haskell, 64 octets

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 157 octets

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

Entrée sortie:

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

Espacés et tabulés pour plus de lisibilité:

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

Suggestions bienvenues.

Sed: 87 84 caractères

(Code de 83 caractères + option de ligne de commande à 1 caractère.)

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

Échantillon échantillon:

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 octets

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.

Juste pour commencer avec quelque chose ..

Essayez-le en ligne ici

Matlab: 97 89 82 octets

Fonction utilisant une expression régulière avec lookbehind et un groupe de capture:

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

Cette sum est nécessaire pour gérer l'entrée chaîne vide (convertir []en 0).

Exemples:

> 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 octets

Utilise REGXY , un langage basé sur la substitution de regex

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

Présentation: Un certain nombre d'expressions régulières sont appliquées. Un exemple d'exécution ressemblerait à ceci:

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

Explication détaillée Vous trouverez ci-dessous une ventilation ligne par ligne des expressions rationnelles:

//$'#/

Il s'agit d'une substitution de regex qui correspond à la première chaîne vide (c'est-à-dire le début de la chaîne) et la remplace par tout ce qui se trouve à droite de la correspondance ( $') suivi d'un hachage. Par exemple, il se transformera onionen onion#onion.

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

Cette ligne recherche la section qui se chevauche en recherchant un groupe de caractères immédiatement avant le # ( (.+)) qui sont identiques de l’autre côté du # ( \1). Le \ K signifie simplement "oublie que je ne correspondais à rien", ce qui signifie qu'il ne sera pas remplacé dans la substitution. Ceci signifie que nous ajoutons simplement un # à la position après que le chevauchement a été trouvé, se transformant onion#onionen onion#on#ion.

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

Le 'a' initial est juste une étiquette pour la regex. Après cela, nous trouvons le premier # suivi d'un seul caractère ( .) et capturons tout ce qui suit jusqu'au prochain # ( .*#). Nous remplaçons ceci par tout ce qui se trouve à droite du match, c'est-à-dire le dernier jeton ($ '), suivi d'un # ( $1), suivi du deuxième jeton moins un caractère (nous le traitons comme un compteur, en le diminuant à chaque itération). Dans le cas de l' oignon # sur # ion, les deux jetons que nous backreference sur sont indiqués entre parenthèses, et la section des matches entiers regex est entre les tuyaux: onion|(#)o(n#)|ion. Nous remplaçons ensuite les bits que nous associons (entre les tuyaux) par $'(tout à droite du match, c.-à-d. 'Ion'), puis $ 1 (le #), puis $ 2 (n #), ce qui signifie que nous nous retrouvons avec onion|(ion)(#)(n#)|ion(parenthèses). les trois jetons dans la chaîne de remplacement).

Si la regex ne correspond pas à la première alternance (tout ce qui précède le tube), nous devons avoir diminué notre compteur à zéro, ce qui signifie qu'il n'y a aucun caractère dans le deuxième jeton. , Nous regardons plutôt la deuxième partie du motif, #.*. Ceci remplace simplement tout après le premier # avec $'$1$2. Comme il n'y a pas de références arrières créées par cette alternance et qu'il n'y a rien à droite du match ( .*correspond jusqu'à la fin de la chaîne), nous terminons la correspondance et retournons le résultat.

//a

Ceci est juste un pointeur sur la ligne précédente, assurant que nous continuons à exécuter la substitution de regex jusqu'à ce qu'elle ne corresponde plus.

jq 1.5: 91 caractères

(Option de ligne de commande code 87 caractères + 4 caractères.)

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

Échantillon échantillon:

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

rs , 51 48 octets

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

PRENEZ CELA, RETINA ET SED !!!!! ;)

Coupez 3 octets grâce à @randomra.

Démo en direct et cas de test.

Notez que le jackhammercas de test n'est pas là. Il y a un bogue dans la gestion des espaces dans l'interface Web qui entraîne l'impression d'une sortie incorrecte. La version hors ligne ders gère correctement.

Version de 51 octets:

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

Démo en direct et cas de test pour l'original.

JavaScript (ES6), 95 octets

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

Démo

Firefox uniquement pour l'instant:

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 octets

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

[Suppression de ma réponse initiale, car j'ai maintenant appris l'ES6 et je souhaitais trouver une solution récursive à ce défi.]

Exemple

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 octets

Même approche que ma réponse JavaScript.

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é: 195 octets - 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 octets

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

C'est incroyable de voir comment revenir à quelque chose le lendemain peut aider

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

Si quelqu'un a besoin du code dans JS pour le tester. Remarque: j'ai parcouru la chaîne de bout en bout pour augmenter l'efficacité:

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