Una stringa di caratteri si ripete se contiene due sottostringhe consecutive equivalenti.

Ad esempio, si 2034384538452ripete poiché contiene 3845due volte, consecutivamente.

Pertanto, la tua sfida è decidere se una stringa contiene una sottostringa ripetuta. È possibile prendere l'input come una stringa o una matrice di caratteri.

Non riceverai mai un input vuoto e la lunghezza della sottostringa (se presente) può essere 1 o più.

Io uso 1e 0qui come i miei valori di verità e falsità, ma puoi usare valori diversi, purché siano verità e falsità nella tua lingua.

Esempi:

abcab -> 0
bdefdefg -> 1
Hello, World! -> 1
pp.pp/pp -> 1
q -> 0
21020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021012102012101202102012021012102012021020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020120210201210120210201202101210201210120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120 -> 0

(L'ultimo esempio è stato generato dalla quantità di uno tra ogni zero nella sequenza Mar-Morse)

Retina , 6 byte

(.+)\1

Provalo online!

Valore positivo per la verità; zero per falso.

Come funziona

Restituisce il numero di corrispondenze della regex /(.+)\1/g.

Brachylog , 3 byte

s~j

Provalo online!

s~j
s    exists a sublist of input
 ~j  which is the result of a juxtaposition of something

Gelatina , 6 5 byte

Ẇµ;"f

Questo è un programma completo. TIO non può gestire l'ultimo caso di test senza troncarlo.

Provalo online! (ultimo caso di test troncato a 250 cifre)

Come funziona

Ẇµ;"f  Main link. Argument: s (string)

Ẇ      Words; generate all substrings of s.
 µ     New chain. Argument: A (substring array)
  ;"   Vectorized concatenation; concatenate each substring with itself.
    f  Filter; keep "doubled" substrings that are also substrings.
       This keeps non-empty string iff the output should be truthy, producing
       non-empty output (truthy) in this case and empty output (falsy) otherwise.

Mathematica, 32 byte

StringMatchQ[___~~x__~~x__~~___]

Java, 27 byte

a->a.matches(".*(.+)\\1.*")

Praticamente un duplicato della risposta Retina , ma non c'è modo che Java si accorcia.

05AB1E , 5 byte

Œ2×åZ

Provalo online!

Emette 1 come valore di verità e 0 come valore di falsa

Spiegazione

Œ2×åZ
Π    # Substrings of input
 2×   # duplicate them (vectorized)
   å  # Is the element in the input? (vectorized)
    Z # Maximum value from list of elements

Python , 38 byte

import re
re.compile(r'(.+)\1').search

Provalo online!

Sbadiglio, una regex. Verifica se la stringa contiene una stringa di uno o più caratteri .+seguita da quella stessa stringa appena catturata. L'oggetto di ricerca dell'output è Verità se c'è almeno una corrispondenza, come può essere verificato da bool.

L'utilizzo compilequi consente di risparmiare sulla scrittura di una lambda:

lambda s:re.search(r'(.+)\1',s)

Python , 54 byte

f=lambda s:s>''and(s in(s*2)[1:-1])|f(s[1:])|f(s[:-1])

Provalo online!

Cerca una sottostringa composta da due o più stringhe uguali concatenate, verificata da s in(s*2)[1:-1]come in questa risposta . I sottostringhi vengono generati in modo ricorsivo scegliendo di tagliare il primo o l'ultimo carattere. Questo è esponenziale, quindi scade nel caso di test di grandi dimensioni.

Near miss:

f=lambda s,p='':s and(s==p)*s+f(s[1:],p+s[0])+f(s[:-1])
f=lambda s,i=1:s[i:]and(2*s[:i]in s)*s+f(s[1:])+f(s,i+1)

Il primo non usa Python inper il controllo delle sottostringhe e quindi potrebbe essere adattato ad altre lingue.

Pyth - 10 9 8 byte

f}+TTQ.:

Restituisce un elenco di tutte le sottostringhe ripetute (che se non ce ne sono, è un elenco vuoto, che è falso)

Provalo

Spiegazione:

f}+TTQ.:
      .:    # All substrings of the input (implicit):
f           # filter the list of substrings T by whether...
  +TT       # ...the concatenation of the substring with itself...
 }   Q      # ...is a substring of the input

Cheddar , 60 byte

n->(|>n.len).any(i->(|>i).any(j->n.index(n.slice(j,i)*2)+1))

Provalo online!

PHP , 32 byte

<?=preg_match('#(.+)\1#',$argn);

Provalo online!

PHP , 38 byte

<?=preg_match('#(.+)(?(1)\1)#',$argn);

Provalo online!

Python 3 , 73 66 byte

-7 byte grazie a @LeakyNun

lambda s:any(2*s[j:i]in s for i in range(len(s))for j in range(i))

Provalo online!

Perl 6 , 11 byte

{?/(.+)$0/}

Provalo

Allargato:

{        # bare block lambda with implicit parameter ｢$_｣

  ?      # Boolify the following
         # (need something here so it runs the regex instead of returning it)

  /      # a regex that implicitly matches against ｢$_｣
    (.+) # one or more characters stored in $0
     $0  # that string of characters again
  /
}

PHP, 32 byte

<?=preg_match('#(.+)\1#',$argn);

Esegui come pipe con -F. Scusa Jörg, non avevo notato che avevi pubblicato lo stesso .

versione non regex, 84 82 byte

    for($s=$argn;++$e;)for($i=0;~$s[$i];)substr($s,$i,$e)==substr($s,$e+$i++,$e)&&die

esce con un codice di ritorno 0per una ripetizione, timeout (ed esce con errore) per nessuno. Esegui come pipe con -nr.
presuppone input ASCII stampabili; sostituire ~con a&per qualsiasi ASCII.

JavaScript (ES6), 19 byte

s=>/(.+)\1/.test(s)

Pyth, 15 byte

.E.nm.bqNYtdd./

Provalo!

V , 6 byte

ø¨.«©±

Provalo online!

Test Suite!

Il programma emette 0valori falsi e un numero intero positivo per valori positivi.

(Nota che c'era un piccolo bug, quindi ho dovuto guadagnare 1 byte. Ora dopo la correzione, sarò in grado di sostituire .«con \x82)

Spiegazione

ø                     " This is a recent addition to V. This command takes in a regex
                      " and replaces the line with the number of matches of the regex
 ¨.«©±                " The compressed regex. This decompresses to \(.\+\)\1

Japt, 8 + 1 = 9 8 byte

f"(.+)%1

Provalo online . Output nullper falsy e un array contenente tutte le stringhe ripetute per verità.

Spiegazione

 f"(.+)%1
Uf"(.+)%1" # Implicit input and string termination
Uf         # Find in the input
  "(.+)%1" #   a sequence followed by itself
 f         # and return the matched substring
           # output the return value

Cheddar, 16 byte

@.test(/(.+)\1/)

Questa è una funzione Provalo online!