MISE À JOUR : La soumission isaacg de Pyth est la gagnante!

Beaucoup d’entre vous ont sûrement entendu dire qu’il existe une version plus fraîche de JavaScript en ville (lisez ES6), qui dispose d’une méthode String.prototype.repeatpermettant de le faire.

"Hello, World!".repeat(3)

et obtenir

"Hello, World!Hello, World!Hello, World!"

comme sortie.

Votre travail consiste à écrire une fonction ou un programme dans la langue de votre choix afin de détecter si une chaîne a été transformée.

C'est-à-dire que la chaîne en entrée peut être représentée comme une nrépétition exacte de l' heure d'une chaîne plus petite. La sortie (en tant qu'instruction return ou STDOUT de la fonction) doit être true si la chaîne peut être ou falsy si la chaîne ne peut pas être représentée sous la forme d'une répétition de chaîne plus petite.

Quelques exemples d'entrées:

"asdfasdfasdf"  // true
"asdfasdfa"     // false
"ĴĴĴĴĴĴĴĴĴ"     // true
"ĴĴĴ123ĴĴĴ123"  // true
"abcdefgh"      // false

Notez que la dernière entrée est fausse, elle devrait donc nêtre supérieure à1

Règles complètes

• Écrivez une fonction / un programme dans n’importe quelle langue pour saisir (via l’argument de la fonction / les arguments de la ligne de commande / STDIN) une chaîne
• Renvoie / Imprime une valeur de vérité si la chaîne donnée est formée via la répétition exacte d'une chaîne plus petite, en répétant au moins deux fois.
• La taille maximale de la chaîne d'entrée est idéalement Infinity
• La chaîne peut avoir tous les caractères ASCII possibles
• C'est un code-golf si le code le plus petit des personnages gagne.

Pyth , 9

/:+zz1_1z

Ou

}z:+zz1_1

Ce sont deux traductions proches de la réponse python de @ xnor, à la différence près qu'elles prennent l'entrée de STDIN et l'impriment. Le premier est équivalent à:

z = input()
print((z+z)[1:-1].count(z))

0 pour faux, 1 pour vrai.

La deuxième ligne est équivalente à:

z = input()
print(z in (z+z)[1:-1])

False pour False, True pour True.

Le compilateur officiel de Pyth avait un bogue lié au second, que je viens de corriger, le premier est donc ma soumission officielle.

Python (24)

lambda s:s in(s+s)[1:-1]

Vérifie si la chaîne est une sous-chaîne d'elle-même concaténée deux fois, en éliminant les premier et dernier caractères pour éviter les correspondances triviales. Si c'est le cas, il doit s'agir d'une permutation cyclique non triviale d'elle-même, et donc de la somme de segments répétés.

Regex (saveur ECMAScript), 11 octets

Cela ressemble à un travail pour regex!

^([^]+)\1+$

Testez-le ici.

J'ai choisi ECMAScript, car c'est la seule saveur (je sais) dans laquelle [^]correspond n'importe quel caractère. Dans tous les autres cas, il me faudrait un drapeau pour changer le comportement de .ou utiliser [\s\S]trois caractères de plus.

Selon la façon dont nous comptons le drapeau, cela pourrait bien sûr être un octet plus court. Par exemple, si nous comptons modèle + drapeaux (par exemple en ignorant les délimiteurs), l’équivalent PCRE / Perl serait

/^(.+)\1+$/s

Ce qui correspond à 10 octets, en ignorant les délimiteurs.

Testez-le ici.

Cela correspond uniquement aux chaînes qui consistent en au moins deux répétitions de certaines sous-chaînes.

Voici une fonction ES6 complète de 26 octets, mais je maintiens que les soumissions d’expression régulière sont généralement valides:

f=s->/^([^]+)\1+$/.test(s)

CJam, 9

q__+)@+#)

Semblable à l'idée de xnor.

q      " Read input. ";
__+    " Duplicate twice and concatenate them together. ";
)      " Remove the last character of the longer string. ";
@+     " Insert that character at the beginning of the shorter string. ";
#)     " Find the shorter string in the longer string, and increase by one. ";

APL, 11

2<+/x⍷,⍨x←⍞

Explication
⍞ prend une chaîne de caractères à partir des
x←assignations d’ écran à une variable x
,⍨concatène la chaîne avec elle-même
x⍷recherche xdans la chaîne résultante. Retourne un tableau composé de 1 à la position de départ d'une correspondance et de 0 ailleurs.
+/somme la
2<vérification du tableau si la somme est supérieure à 2 (car il y aura 2 correspondances triviales)

CJam, 10 octets

J'ai attrapé le virus CJam. Ma première réponse, donc peut probablement être joué au golf un peu plus:

q__+(;);\#

Sorties -1 pour FALSE et un nombre> = 0 pour TRUE

GolfScript, 10 octets

..+(;);\?)

Encore une autre implémentation de l’idée intelligente de xnor.

Python - 59 57

lambda s:any([s*n==s[:n]*len(s)for n in range(2,len(s))])

Pure bash, 30 octets

Port simple de la réponse intelligente @ xnor :

[[ ${1:1}${1:0: -1} =~ "$1" ]]

Le code de sortie est 0 pour VRAI et 1 pour FAUX:

$ for s in 'Hello, World!Hello, World!Hello, World!' 'asdfasdfasdf' 'asdfasdfa' 'ĴĴĴĴĴĴĴĴĴ' 'ĴĴĴ123ĴĴĴ123' 'abcdefgh'; do echo "./isrepeated.sh "\"$s\"" returns $(./isrepeated.sh "$s"; echo $?)"; done
./isrepeated.sh "Hello, World!Hello, World!Hello, World!" returns 0
./isrepeated.sh "asdfasdfasdf" returns 0
./isrepeated.sh "asdfasdfa" returns 1
./isrepeated.sh "ĴĴĴĴĴĴĴĴĴ" returns 0
./isrepeated.sh "ĴĴĴ123ĴĴĴ123" returns 0
./isrepeated.sh "abcdefgh" returns 1
$ 

La note en =~dedans [[ ... ]]est l'opérateur de regex dans bash . Cependant "Toute partie du motif peut être citée pour le forcer à correspondre sous forme de chaîne" . Comme c’est souvent le cas avec bash, il est très important d’obtenir des guillemets exacts. Ici, nous voulons simplement vérifier la présence d’une chaîne et non d’une correspondance regex.

TI-BASIC - 32

Je pensais que j'essaierais un langage symbolique. Exécuter avec la chaîne dans Ans, renvoie 0 si faux et la longueur de la chaîne répétée si vrai.

inString(sub(Ans+Ans,1,2length(Ans)-1),sub(Ans,length(Ans),1)+Ans

Incroyable comme c'est un one-liner.

ECMAScript 6 (189)

(function(){var S=String.prototype,r=S.repeat;S.isRepeated=function(){return!1};S.repeat=function(c){var s=new String(r.call(this,c));if(c>1)s.isRepeated=function(){return!0};return s}}());

< console.log("abc".isRepeated(),"abc".repeat(10).isRepeated());
> false true

C’est sûrement la seule solution valable? Par exemple, le mot (chaîne) nanan'est pas nécessairement créé à partir de"na".repeat(2)

ECMAScript 6 (34 36 )

Une autre réponse de ES6, mais sans utiliser repeatet utiliser le truc de xnor :

f=i=>(i+i).slice(1,-1).contains(i)

Doit être exécuté dans la console d'un navigateur compatible ES6 tel que Firefox.

C 85

l,d;f(s){return l=strlen(s),strstr(d,strcpy(strcpy(d=alloca(l*2+1),s)+l,s)-1)-d-l+1;}

Cela s'est avéré être assez long, mais les fonctions externes sont toujours comme ça. Il m'est venu à l'esprit que je pouvais réécrire chaque fonction de chaîne en les remplaçant par une boucle ou une récursive. Mais, selon mon expérience, les résultats seraient plus longs et, franchement, je ne veux pas essayer.

Après quelques recherches, j'ai trouvé des solutions hautes performances mais pas aussi intelligentes (et courtes) que celle de xnor. juste pour être original ... j'ai réécrit la même idée en c.

explication:

int length, 
    duplicate;
int is_repetition(char *input)
{
    // length = "abc" -> 3
    length = strlen(input);
    // alloca because the function name is as long as "malloc" 
    // but you don't have to call free() because it uses the stack
    // to allocate memory
    // duplicate = x x x x x x + x
    duplicate = alloca(length*2 + 1);
    // duplicate = a b c 0 x x + x
    strcpy(duplicate, input);
    // duplicate = a b c a b c + 0
    strcpy(duplicate + length, input);
    if (strstr(duplicate,duplicate + length - 1) != duplicate + length - 1)
        // repetition
        // e.g. abab -> abababab -> aba[babab]
        // -> first occurence of [babab] is not aba[babab]
        // but a[babab]ab -> this is a repetition
        return 1;
    else
        // not repetition
        // e.g. abc -> abcabc -> ab[cabc]
        // -> first occurence of [cabc] is ab[cabc]
        // it matches the last "cabc"
        return 0;
}

ECMAScript 6 (59 62 67 73 )

Pas un gagnant, mais il semble qu'il devrait y avoir au moins une réponse dans ES6 pour cette question qui utilise réellement la repeatfonction:

f=i=>[...i].some((_,j)=>i.slice(0,j).repeat(i.length/j)==i)

Doit être exécuté dans la console d'un navigateur compatible ES6 tel que Firefox.

Il fait beaucoup d'itérations inutiles, mais pourquoi le prolonger pour éviter cela, non?

• Edit # 1: Sauvegardé quelques octets en le convertissant en une fonction. Merci à Optimizer!
• Edit # 2: Merci à hsl pour le truc de l’opérateur de propagation pour économiser plus d’octets!
• Edit # 3: Et merci à Rob W. pour encore 3 octets!

Gelée , 3 octets

ṙJċ

Essayez-le en ligne!

Identique à cette réponse (le dernier défi est peut-être une généralisation de celle-ci?).

Java 8, 28 octets

s->s.matches("(?s)(.+)\\1+")

Essayez-le en ligne.

Explication:

Vérifie si la chaîne d'entrée correspond à l'expression régulière, où elle est String#matchesimplicitement ajoutée ^...$pour correspondre à la chaîne entière.
Explication de la regex elle-même:

^(s?)(.+)\1+$
^                Begin of the string
 (s?)            Enable DOTALL-mode, where `.` also matches new-lines
     (           Open capture group 1
      .+          One or more characters
        )        Close capture group 1
         \1+     Plus the match of the capture group 1, one or more times
            $    End of the string

Donc, il vérifie fondamentalement si une sous-chaîne est répétée deux fois ou plus (en prenant en charge les nouvelles lignes).