Vérifiez si une chaîne est entièrement composée de la même sous-chaîne

24

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.

code-golf  decision-problem 
— ouflak
source
4
Hm, j'allais fermer ce défi en tant que dupe de celui-là , mais j'ai remarqué que l'autre marque sur le nombre de personnages. Alors peut-être devrions-nous fermer l'autre (il a également une réponse acceptée) en tant que dupe de celle-ci à la place.
— Erik the Outgolfer le
— Erik the Outgolfer le

Réponses:

11

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.

— Zgarb
source
J'avais juste du mal à essayer d'obtenir quelque chose comme ça ~j↙ou à =Ṁctravailler avant de remarquer que vous avez posté cela il y a une heure
— Chaîne sans rapport
4
Oh, oui, cela pourrait être un octet plus court:ġ=Ṁ
— Chaîne non
( Ṁest une variable contrainte d'être une liste de deux éléments ou plus)
— Chaîne non
1
@UnrelatedString Super, merci! Je n'ai pas pensé à vérifier la page wiki des variables.
— Zgarb
1
Beaucoup de bonnes réponses, et la réponse LUA a une place spéciale dans mon cœur. La réponse d'Arnauld est particulièrement douce, car la question d'origine sur laquelle j'ai basé cela (pas le dupe) est en fait étiquetée Javascript. Je sélectionne principalement celle-ci simplement parce qu'elle semble être la plus courte dans toutes les langues et, comme c'est ma première question, je reçois un badge.
— ouflak
19

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.

— Arnauld
source
9

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
— Thor
source
9

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
— Incarnation de l'ignorance
source
Nice one :) Vous pouvez remplacer le p<space>avec ²d'enregistrer un octet.
— Shaggy
9

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

— Benjamin Urquhart
source
3
Vous pouvez supprimer la finale $car la matchesméthode est une correspondance exacte, pas une correspondance de sous-chaîne par défaut.
— Olivier Grégoire
J'ai oublié d' matchesajouter sa propre $expression rationnelle. Merci!
— Benjamin Urquhart
7

Excel, 26 octets

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

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

— Sophia Lechner
source
Vous pouvez économiser 4 octets si vous définissez un nom de plage à une seule lettre (par exemple A) et le définissez comme entrée.
— i_saw_drones
@i_saw_drones - Je pense que cela n'est pas autorisé par les règles d'E / S standard: voici un lien vers la méta-réponse qui s'appliquerait à cette méthode; il est actuellement à -36 votes.
— Sophia Lechner
Toutes mes excuses, je n'avais pas vu ce billet, bien que j'y pense, n'est-ce pas A1aussi une "variable" car il contient la valeur d'entrée? :)
— i_saw_drones
1
Je me sentirais de cette façon si je faisais quelque chose de spécial avec le fait que c'est A1 spécifiquement, comme si je comptais en quelque sorte sur sa ROW (_) étant 1. Comme c'est, cependant, c'est juste la façon la plus naturelle de fournir une fonction Excel avec une entrée arbitraire.
— Sophia Lechner
7

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?

— Sumner18
source
1
Intéressant, cela semble être un bug dans le moteur d'expression régulière de R. L'ajout de l'option le perl=TRUEfait correspondre à cABABAB, comme vous vous en doutez. L'exécution grep -E '(.*)\1+$'en bash correspond également à cABABAB, même si elle grep -Eutilise ERE, la même saveur regex que R est censée prendre en charge.
— Grimmy
2
Je suppose que c'est une optimisation incorrectement appliquée. La modification .+au début d'un modèle ^.+est une optimisation importante, mais si l' .+intérieur est en train de capturer des parenthèses, il cesse d'être valide.
— Grimmy
6

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)
— Jonathan Allan
source
3

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!

— Gabriel Mills
source
il revient truepouraabcabc
— mazzy
1
@mazzy vient d'être corrigé!
— Gabriel Mills
3

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!

— Innat3
source
3

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!

— movatica
source
1
Bonne réponse! Le f=peut être supprimé; les fonctions anonymes sont généralement autorisées. De plus, en passant à Python 2 et en vérifiant l'appartenance à une liste au lieu de la anyconstruction, vous pouvez atteindre 55 octets
— ArBo
1
Belle prise avec l'adhésion à la liste, merci! Je ne passerai pas à Python 2, car cela revient à changer de langue, ce qui n'est évidemment pas le cas ici;) De plus, existe-t-il un moyen pratique de tester une fonction anonyme dans TIO, en conservant le nombre d'octets?
— movatica
1
@movatica Dans l'en-tête, mettez `f =` (\ est le caractère de continuation de ligne en python)
— Artemis prend en charge Monica le
De façon ennuyeuse, \ est également un personnage d'échappement. Voici, sans mise en forme de code, ce que vous devez mettre dans l'en-tête: f = \
— Artemis prend en charge Monica
2

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!

— Luis felipe De jesus Munoz
source
2

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.
— Sophia Lechner
source
2
€htD¹évite le ȯ.
— Zgarb
C'est fantastique! J'y avais pensé λ€htD¹mais je ne savais pas que les lambdas seraient ajoutés implicitement
— Sophia Lechner
2

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  *)
— Eric Towers
source
2

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.

— Delya Erricson
source
2

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
— Emigna
source
1
Bien sûr .. J'étais sur le point de répondre 05AB1E quand je vis qu'il n'y en avait pas. Un collègue m'a posé quelques questions et a parlé de ses vacances. Je repense à l'écran: une nouvelle réponse. Tada, bat encore XD
— Kevin Cruijssen
@KevinCruijssen: C'est typique. Cela m'est aussi arrivé plusieurs fois;)
— Emigna
2

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.

— Οurous
source
2

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.

— jxh
source
1

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
— i_saw_drones
source
1

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!

— onnoweb
source
Je n'utilise pas Swift, mais je suis sûr que des espaces supplémentaires peuvent être supprimés
— Benjamin Urquhart
193 octets utilisant la suggestion de @ benjamin.
— Artemis prend en charge Monica le
@ArtemisFowl ou même 123 octets
— Roman Podymov
1

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

— t-clausen.dk
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.