Ceci est tiré de cette question (avec la permission du cours). Je citerai:

Créez une fonction qui prend une chaîne, et elle doit retourner true ou false selon que l'entrée se compose uniquement d' une séquence de caractères répétée. La longueur de la chaîne donnée est toujours supérieure à 1 et la séquence de caractères doit avoir au moins une répétition.

Quelques exemples:

'aa' //true
'aaa' //true
'abcabcabc' //true
'aba' //false
'ababa' //false
'weqweqweqweqweqw' // false

Plus précisément, la vérification d'une chaîne strictement composée de sous-chaînes répétitives ( mise à jour ) peut générer n'importe quelle représentation vraie ou fausse, mais aucune sortie d'erreur s'il vous plaît. Chaînes strictement alphhanumériques. Sinon, les règles de golf de code standard. C'est Code Golf, donc la réponse la plus courte en octets pour chaque langue l'emporte.

Brachylog , 4 3 octets

ġ=Ṁ

Essayez-le en ligne!

Explication

ġ=Ṁ    Implicit input, say "abcabc"
ġ      Split into chunks of equal lengths (except maybe the last one): ["abc","abc"]
 =     Apply the constraint that all of the chunks are equal,
  Ṁ    and that there are multiple of them.

Le programme imprime true.si les contraintes peuvent être satisfaites et false.sinon.

JavaScript (ES6), 22 octets

Renvoie une valeur booléenne.

s=>/^(.*)\1+$/.test(s)

Essayez-le en ligne!

Sans expression régulière,  33  29 octets

Renvoie soit null(fausse), soit un objet (vrai).

s=>(s+s).slice(1,-1).match(s)

Essayez-le en ligne!

NB: Techniquement, $s$ est converti en une expression régulière pour match () , donc le titre ci-dessus est un mensonge.

grep, 19

grep -qxE '(.+)\1+'

Tester

while read; do 
  <<<"$REPLY" grep -qxE '(.+)\1+' && t="true" || t="false"
  echo "$REPLY: $t"
done < infile 

Sortie:

aa: true
aaa: true
abcabcabc: true
aba: false
ababa: false
weqweqweqweqweqw: false

Japt , 6 octets

²é ¤øU

Un octet enregistré grâce à @Shaggy

Essayez-le en ligne!

        Implicit input, stored in variable 'U'
²       U+U, "abcabc" -> "abcabcabcabc"
 é      Rotate 1 char to the right "abcabcabcabc" -> "cabcabcabcab"
   ¤    Remove first two chars, "cabcabcabcab" -> "bcabcabcab"
    øU  Check if U is in the above

Java, 25 24 octets

-1 octet merci à Olivier Grégoire!
Réponse de regex ennuyeux

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

Essayez-le en ligne!

C'est juste 1 octet de plus que la réponse python aaaaa je suis lié maintenant :)

Excel, 26 octets

=FIND(A1,A1&A1,2)<=LEN(A1)

Entrées de A1, sorties vers la cellule dans laquelle vous mettez cette formule.

R , 28 octets

grepl("(.+)\\1+$",scan(,''))

Essayez-le en ligne!

Version simple Regex. R est (parfois) très similaire à Python, donc c'est similaire à la réponse regex Python 2 de TFeld, bien que plus courte!

Question (si quelqu'un connaît la réponse)

Je ne comprends toujours pas pourquoi cela fonctionne, car la sous-chaîne peut être de n'importe quelle longueur et fonctionnera toujours, et fonctionne toujours lorsque j'ajoute une lettre au début d'une chaîne valide, comme "cABABABABAB". Si je lis personnellement l'expression régulière, je vois (.+), qui capture n'importe quel groupe de n'importe quelle longueur. Et puis \\1+$qui répète le groupe capturé un certain nombre de fois jusqu'à la fin.

Alors pourquoi ne capture-t-il pas simplement "AB" et ne trouve-t-il pas qu'il est répété jusqu'à la fin de la chaîne, d'autant plus qu'aucune restriction n'est spécifiée quant à l'endroit où la sous-chaîne peut commencer?

Retina 0.8.2 , 9 octets

^(.+)\1+$

Essayez-le en ligne! Le lien inclut des cas de test.

Gelée ,  5  4 octets

Je vois maintenant que la meilleure façon est de suivre la méthode de xnor !

Ḋ;Ṗw

Un lien monadique qui accepte une liste de caractères et génère un entier - la longueur la plus courte possible d'une tranche répétée ou zéro s'il n'en existe pas. Notez que zéro est falsey tandis que les nombres non nuls sont vrais dans Jelly.

Essayez-le en ligne!

Comment?

Ḋ;Ṗw - Link: list of characters, S   e.g. "abcabcabc"   or "abababa"
Ḋ    - dequeue S                           "bcabcabc"       "bababa"
  Ṗ  - pop from S                         "abcabcab"       "ababab"
 ;   - concatenate                "bcabcabcabcabcab"       "bababaababab"
   w - first index of sublist     3  ^---here!             0  (not found)

Perl 5 -p , 14 octets

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

Essayez-le en ligne!

Python 2 , 24 octets

lambda s:s in(s*2)[1:-1]

Essayez-le en ligne!

Sans vergogne volé de la réponse de xnor à la question d'origine.

Version plus intuitive:

Python 2 , 59 55 53 octets

lambda s:s in[len(s)/i*s[:i]for i in range(1,len(s))]

Essayez-le en ligne!

Version regex ennuyeuse:

Python 2 , 44 octets

lambda s:re.match(r'(.+)\1+$',s)>0
import re

Essayez-le en ligne!

Wolfram Language (Mathematica) , 24 23 octets

StringMatchQ[x__..~~x_]

Essayez-le en ligne!

StringMatchQ[           (*a function that checks if its input (string) matches:*)
             x__..      (*a sequence of one or more characters, repeated one or more times*)
                  ~~x_] (*and one more time*)

Pyke , 4 octets

+tO{

Essayez-le ici!

+    -    input+input
 t   -   ^[1:]
  O  -  ^[:-1]
   { - input in ^

J , ^{26 25 15} 14 octets

Utilisation de la méthode xnor

+./@E.}:@}.@,~

Essayez-le en ligne!

original (deux approches différentes)

J , 25 octets

1<1#.(#%#\)=<\+/@E.&:>"{]

Essayez-le en ligne!

J , 26 octets

1<1#.-@#\([:(-:##{.)<\)"{]

Essayez-le en ligne!

PowerShell, 23 24 octets

+1 octet pour correspondre pleinement aux règles

"$args"-match"^(.+)\1+$"

Essayez-le en ligne!

Plutôt ennuyeux. Basé sur les autres réponses Regex. Heureusement, PowerShell n'utilise pas \de personnage d'échappement!

C # (Visual C # Interactive Compiler) , 70 octets

Adaptation sans vergogne de xnor ( 46 octets )

s=>(s+s).Substring(1,s.Length*2-2).Contains(s)

Ma solution non Regex:

s=>s.Select((x,y)=>y).Count(z=>s.Replace(s.Substring(0,z+1),"")=="")>1

Explication:

Remplacez chaque sous-chaîne possible commençant à l'index 0 par une chaîne vide. Si le résultat est une chaîne vide, la chaîne est entièrement constituée de cette sous-chaîne. Étant donné que cela inclut l'évaluation de la chaîne entière avec elle-même, la quantité de résultats attendus doit être supérieure à 1.

Exemple: abcabc

Sous-chaînes possibles commençant à l'index 0:

'a', 'ab', 'abc', 'abca', 'abcab', 'abcabc'

Si nous les remplaçons par des chaînes vides

Substring          Result

'a'         =>     'bcbc'
'ab'        =>     'cc'
'abc'       =>     ''
'abca'      =>     'bc'
'abcab'     =>     'c'
'abcabc'    =>     ''

Puisqu'il existe une sous-chaîne autre que «abcabc» qui renvoie une chaîne vide, la chaîne est entièrement constituée d'une autre sous-chaîne («abc»)

Essayez-le en ligne!

Python 3 , 62 60 56 54 octets

-4 octets merci à ArBo

lambda s:s in(len(s)//l*s[:l]for l in range(1,len(s)))

1. Itérer sur tous les préfixes possibles de la chaîne.
2. Essayez de construire la chaîne à partir du préfixe.
3. Indiquez si cela réussit avec n'importe quel préfixe.

Essayez-le en ligne!

Japt , 10 octets

Renvoie un nombre positif si véridique et 0 si falsey. Si vous voulez une sortie booléenne, ajoutez simplement un -¡drapeau

å+ k@rXÃÊÉ

å+ k@rXÃÊÉ      Full program. Implicit input U.
                    e.g: U = "abcabcabc"
å+              Take all prefixes 
                         U = ["a","ab","abc","abca","abcab","abcabc","abcabca","abcabcab","abcabcabc"]
   k@           Filter U by:
     rXÃ        Values that return false (empty string)
                when replacing each prefix in U
                e.g: ["bcbcbc","ccc","","bcabc","cabc","abc","bc","c",""]
                                take ↑                             and ↑
                     U = ["abc","abcabcabc"]
         ÊÉ     Get U length and subtract 1. Then return the result

Essayez-le en ligne!

Husk , 6 octets

Ṡ€ȯhtD

Essayez-le en ligne!

J'ai l'impression que c'est un octet de plus qu'optimal, mais je n'ai pas trouvé d'arrangement qui rendait la composition explicite ȯinutile.

Explication

Ṡ€      Find the argument in the result of applying the following function to the argument
  ȯhtD  Duplicate the argument, then remove the first and last elements.

Mathematica 11.x, 74 octets

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&

où, tout au long, #représente la chaîne d'entrée, et

StringCases[#,<pattern>]

trouve les sous-chaînes de la chaîne d'entrée correspondant au modèle

StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="") 

Ce modèle nécessite des correspondances, xdoit commencer au début de la chaîne et doit satisfaire à la condition que (1) la correspondance ne soit pas la chaîne d'entrée entière et (2) si nous remplaçons les occurrences de la correspondance dans la chaîne d'entrée par la chaîne vide on obtient la chaîne vide. Enfin, en comparant la liste des correspondances à la liste vide,

{}!=

est Truesi la liste des correspondances n'est pas vide et Falsesi la liste des correspondances est vide.

Cas de test:

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aaa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["abcabc"]
(*  True  *)

et

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aba"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["ababa"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["weqweqweqweqweqw"]
(*  False  *)

Python 3, 84 octets

import textwrap
lambda s:any(len(set(textwrap.wrap(s,l)))<2 for l in range(1,len(s)))

Utilise textwrap.wrap(grâce à cette réponse ) pour diviser la chaîne en morceaux de longueur npour tester chaque longueur possible de sous-chaîne répétée. Les morceaux séparés sont ensuite comparés les uns aux autres en les ajoutant à un ensemble. Si toutes les pièces sont égales et que l'ensemble est de longueur 1, alors la chaîne doit être une chaîne répétitive. J'ai utilisé à la <2place de ==1car il enregistre un octet et la longueur de la chaîne d'entrée était garantie supérieure à zéro.

S'il n'y a pas nde sous-chaînes répétitives de longueur qui ncomposent la chaîne entière, retournez false pour la fonction entière.

05AB1E , 5 octets

La méthode de xnor de la question précédente semble également être optimale dans 05AB1E.

«¦¨så

Essayez-le en ligne! ou comme suite de tests

Explication

«       # append input to input
 ¦¨     # remove the first and last character of the resulting string
   så   # check if the input is in this string

Nettoyer , 73 octets

N'utilise pas l'expression régulière.

import StdEnv,Data.List
$s=or[isPrefixOf s(cycle t)\\t<-tl(tails s)|t>[]]

Essayez-le en ligne!

Définit $ :: [Char] -> Bool.
Vérifie si la chaîne donnée est un préfixe de la répétition d'une sous-chaîne prise à la fin.

C ++ (gcc) , 36 octets

#define f(x)(x+x).find(x,1)<x.size()

Essayez-le en ligne!

Un autre port de la solution de xnor. Utilise une macro pour développer l'argument dans l'expression. L'argument est supposé être de type std::string.

Variable QlikView, 27 octets

Elle doit être définie comme une variable, qui vous permet ensuite de transmettre des paramètres, par exemple $1comme valeur d'entrée.

Il renvoie 0ou -1(équivalent à la TRUE()fonction de QlikView ).

=substringcount($1&$1,$1)>2

Swift, 196 octets

func r(s:String)->Bool{guard let k=s.dropFirst().firstIndex(where:{$0==s.first}) else{return false};let v=s[...k].dropLast();var w=v;while s.hasPrefix(w) && s.count>=(w+v).count{w+=v};return s==w}

Essayez-le en ligne!

Icône , 46 octets

procedure f(s);return find(s,(s||s)[2:-1]);end

Essayez-le en ligne!

Un autre port de la solution de xnor.

K (oK) , 29 octets

{0<+/(1=#?:)'(0N,'1_!#x)#\:x}

Essayez-le en ligne!

Rouge , 72 octets

func[s][repeat i length? s[parse s[copy t i skip some t end(return 1)]]]

Essayez-le en ligne!

Retours 1pourTrue

T-SQL, 47 octets

En utilisant la méthode @ Xnor :

DECLARE @ varchar(max)='ababab'

PRINT sign(charindex(@,left(@+@,len(@)*2-1),2))

Garder l'ancienne réponse car elle contient du bon golf (67 octets):

DECLARE @y varchar(max)='abababa'

,@ INT=0WHILE
replace(@y,left(@y,@),'')>''SET
@+=1PRINT @/len(@y)^1

Explication: Ce script tente à plusieurs reprises de remplacer l'entrée '@y' par les premiers caractères '@' de l'entrée '@y' par rien, tout en augmentant '@'.

si vous remplacez «ab» dans «ababab» par rien, vous avez une chaîne vide

Finalement, le résultat sera vide. Si cela se produit lorsque la variable de boucle est égale à la longueur du varchar, le critère est faux / 0 car '@' = len (@y) (il n'y avait pas de varchar répétitif).

iif(@=len(@y),0,1)

peut être joué dans ce

@/len(@y)^1

car la longueur de '@y' ne peut pas être 0 et '@' ne dépassera jamais la longueur @y.

Essayez-le en ligne