Questo è tratto da questa domanda (con il permesso del corso). Citerò:

Creare una funzione che accetta una stringa e dovrebbe restituire vero o falso in base al fatto che l'input sia costituito solo da una sequenza di caratteri ripetuta. La lunghezza di una determinata stringa è sempre maggiore di 1 e la sequenza di caratteri deve avere almeno una ripetizione.

Qualche esempio:

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

In particolare, il controllo per una stringa rigorosamente composta da sottostringhe ripetute ( Aggiornamento ) può generare qualsiasi rappresentazione vera o falsa, ma per favore nessun output di errore. Stringhe rigorosamente alfanumeriche. Altrimenti regole standard per il golf del codice. Questo è Code Golf, quindi vince la risposta più breve in byte per ogni lingua.

Brachylog , 4 3 byte

ġ=Ṁ

Provalo online!

Spiegazione

ġ=Ṁ    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.

Il programma stampa true.se i vincoli possono essere soddisfatti e in false.caso contrario.

JavaScript (ES6), 22 byte

Restituisce un valore booleano.

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

Provalo online!

Senza un'espressione regolare,  33  29 byte

Restituisce null(falsa) o un oggetto (verità).

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

Provalo online!

NB: Tecnicamente, $s$ viene convertito in un'espressione regolare per match () , quindi il titolo sopra è una bugia.

grep, 19

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

Test

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

Produzione:

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

Japt , 6 byte

²é ¤øU

Salvato un byte grazie a @Shaggy

Provalo online!

        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 byte

-1 byte grazie a Olivier Grégoire!
Risposta regex noiosa

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

Provalo online!

È solo 1 byte più lungo della risposta python aaaaa Sono legato ora :)

Excel, 26 byte

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

Ingressi da A1, output in qualunque cella metti questa formula.

R , 28 byte

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

Provalo online!

Versione Regex semplice. R è (a volte) molto simile a Python, quindi è simile alla risposta regex di TFeld Python 2, anche se più breve!

Domanda (se qualcuno conosce la risposta)

Sono ancora confuso perché questo funziona, poiché la sottostringa può essere di qualsiasi lunghezza e funzionerà sempre, e funziona ancora quando aggiungo una lettera all'inizio di una stringa valida, come "cABABABABAB". Se leggo personalmente la regex, vedo (.+), che cattura qualsiasi gruppo di qualsiasi lunghezza. E poi \\1+$che ripete il gruppo catturato un numero qualsiasi di volte fino alla fine.

Quindi perché non cattura solo "AB" e scopre che viene ripetuto fino alla fine della stringa, soprattutto perché non è stata specificata alcuna restrizione su dove può iniziare la sottostringa?

Retina 0.8.2 , 9 byte

^(.+)\1+$

Provalo online! Il link include casi di test.

Gelatina ,  5  4 byte

Vedo ora che il modo ottimale è seguire il metodo di xnor !

Ḋ;Ṗw

Un collegamento monadico che accetta un elenco di caratteri e genera un numero intero: la lunghezza più breve possibile di una sezione ripetuta o zero se non esiste. Nota che zero è falso mentre i numeri diversi da zero sono veri in Jelly.

Provalo online!

Come?

Ḋ;Ṗ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 byte

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

Provalo online!

Python 2 , 24 byte

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

Provalo online!

Spudoratamente rubato dalla risposta di Xnor alla domanda originale.

Versione più intuitiva:

Python 2 , 59 55 53 byte

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

Provalo online!

Versione regex noiosa:

Python 2 , 44 byte

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

Provalo online!

Wolfram Language (Mathematica) , 24 23 byte

StringMatchQ[x__..~~x_]

Provalo online!

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 byte

+tO{

Provalo qui!

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

J , ^{26 25 15} 14 byte

Usando il metodo xnor

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

Provalo online!

originale (due approcci diversi)

J , 25 byte

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

Provalo online!

J , 26 byte

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

Provalo online!

PowerShell, 23 24 byte

+1 byte per abbinare completamente le regole

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

Provalo online!

Piuttosto noioso. Basato sulle altre risposte Regex. Fortunatamente PowerShell non usa \come personaggio di escape!

C # (compilatore interattivo Visual C #) , 70 byte

adattamento spudorato di xnor ( 46 byte )

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

La mia soluzione non Regex:

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

Spiegazione:

Sostituisci ogni possibile sottostringa che inizia all'indice 0 con una stringa vuota. Se il risultato è una stringa vuota, la stringa è interamente composta da quella sottostringa. Poiché ciò include la valutazione dell'intera stringa con se stessa, la quantità di risultati previsti deve essere maggiore di 1.

Esempio: abcabc

Possibili sottostringhe a partire dall'indice 0:

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

Se li sostituiamo con stringhe vuote

Substring          Result

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

Poiché esiste una sottostringa diversa da "abcabc" che restituisce una stringa vuota, la stringa è interamente costituita da un'altra sottostringa ("abc")

Provalo online!

Python 3 , 62 60 56 54 byte

-4 byte grazie ad ArBo

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

1. Scorrere su tutti i possibili prefissi nella stringa.
2. Prova a costruire la stringa fuori dal prefisso.
3. Restituisci se questo ha successo con qualsiasi prefisso.

Provalo online!

Japt , 10 byte

Restituisce un numero positivo se verità e 0 se falsa. Se vuoi un output bool, aggiungi semplicemente -¡flag

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

Provalo online!

Buccia , 6 byte

Ṡ€ȯhtD

Provalo online!

Sento che questo è un byte in più rispetto all'ottimale, ma non sono riuscito a trovare un accordo che rendesse ȯsuperflua la composizione esplicita .

Spiegazione

Ṡ€      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 byte

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

dove, in tutto, #rappresenta la stringa di input e

StringCases[#,<pattern>]

trova sottostringhe della stringa di input corrispondenti al modello

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

Questo modello richiede corrispondenze, xdeve iniziare all'inizio della stringa e deve soddisfare la condizione che (1) la corrispondenza non sia l'intera stringa di input e (2) se sostituiamo le occorrenze della corrispondenza nella stringa di input con la stringa vuota otteniamo la stringa vuota. Infine, confrontando l'elenco delle corrispondenze con l'elenco vuoto,

{}!=

è Truese l'elenco delle corrispondenze è vuoto e Falsese l'elenco delle corrispondenze è vuoto.

Casi 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  *)

e

{}!=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 byte

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

Utilizza textwrap.wrap(grazie a questa risposta ) per dividere la stringa in pezzi di lunghezza nper testare ogni possibile lunghezza di sottostringa ripetuta. I pezzi divisi vengono quindi confrontati tra loro aggiungendoli a un set. Se tutti i pezzi sono uguali e il set è di lunghezza 1, la stringa deve essere una stringa ripetuta. Ho usato <2invece ==1perché salva un byte e la lunghezza della stringa di input è stata garantita maggiore di zero.

Se non esiste un numero nper cui le sottostringhe ripetute di lunghezza ncompongono l'intera stringa, restituisce false per l'intera funzione.

05AB1E , 5 byte

Il metodo di xnor della domanda precedente sembra essere ottimale anche in 05AB1E.

«¦¨så

Provalo online! o come una suite di test

Spiegazione

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

Pulito , 73 byte

Non usa regex.

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

Provalo online!

Definisce $ :: [Char] -> Bool.
Verifica se la stringa specificata è un prefisso della ripetizione di qualsiasi sottostringa presa dalla fine.

C ++ (gcc) , 36 byte

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

Provalo online!

Un'altra porta della soluzione di xnor. Utilizza una macro per espandere l'argomento nell'espressione. Si presume che l'argomento sia di tipo std::string.

Variabile QlikView, 27 byte

Questo dovrebbe essere definito come una variabile, che consente quindi di passare parametri, ad esempio $1come valore di input.

Restituisce 0o -1(equivalente alla TRUE()funzione di QlikView ).

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

Rapido, 196 byte

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}

Provalo online!

Icona , 46 byte

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

Provalo online!

Un'altra porta della soluzione di xnor.

K (oK) , 29 byte

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

Provalo online!

Rosso , 72 byte

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

Provalo online!

Restituisce 1perTrue

T-SQL, 47 byte

Usando il metodo di @ Xnor :

DECLARE @ varchar(max)='ababab'

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

Mantenere la vecchia risposta in quanto contiene un bel golf (67 byte):

DECLARE @y varchar(max)='abababa'

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

Spiegazione: Questo script tenta ripetutamente di sostituire l'input "@y" con i primi caratteri "@" dell'input "@y" con nulla, aumentando al contempo "@".

se sostituisci "ab" in "ababab" con nulla hai una stringa vuota

Alla fine il risultato sarà vuoto. Se ciò accade quando la variabile del ciclo è uguale alla lunghezza di varchar, i criteri sono falsi / 0 perché '@' = len (@y) (non c'era ripetizione varchar).

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

può essere giocato a golf in questo

@/len(@y)^1

perché la lunghezza di '@y' non può essere 0 e '@' non supererà mai la lunghezza @y.

Provalo online