To pochodzi z tego pytania (za zgodą oczywiście). Zacytuję:

Utwórz funkcję, która pobiera ciąg znaków i powinna zwracać wartość true lub false w zależności od tego, czy dane wejściowe składają się tylko z powtarzanej sekwencji znaków. Długość podanego ciągu jest zawsze większa niż 1, a sekwencja znaków musi mieć co najmniej jedno powtórzenie.

Kilka przykładów:

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

W szczególności sprawdzenie łańcucha ściśle złożonego z powtarzających się podciągów ( Aktualizacja ) może wygenerować dowolną prawdziwą lub fałszywą reprezentację, ale proszę nie dać wyniku błędu. Ciągi ściśle alfanumeryczne. W przeciwnym razie standardowe zasady gry w golfa. To jest Code Golf, więc wygrywa najkrótsza odpowiedź w bajtach dla każdego języka.

Brachylog , 4 3 bajty

ġ=Ṁ

Wypróbuj online!

Wyjaśnienie

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

Program drukuje, true.czy ograniczenia mogą być spełnione, a false.jeśli nie.

JavaScript (ES6), 22 bajty

Zwraca wartość logiczną.

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

Wypróbuj online!

Bez wyrażenia regularnego  33  29 bajtów

Zwraca albo null(fałsz), albo obiekt (prawda).

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

Wypróbuj online!

NB: Technicznie, $s$ jest konwertowane na wyrażenie regularne dla match () , więc powyższy tytuł jest kłamstwem.

grep, 19

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

Test

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

Wydajność:

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

Japt , 6 bajtów

²é ¤øU

Oszczędność jednego bajtu dzięki @Shaggy

Wypróbuj 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 bajtów

-1 bajt dzięki Olivier Grégoire!
Nudna odpowiedź regularna

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

Wypróbuj online!

To tylko 1 bajt dłużej niż odpowiedź pytona aaaaa Jestem teraz związany :)

Excel, 26 bajtów

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

Dane wejściowe z A1, dane wyjściowe do dowolnej komórki, w której umieścisz tę formułę.

R , 28 bajtów

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

Wypróbuj online!

Prosta wersja Regex. R jest (czasami) bardzo podobny do Pythona, więc jest podobny do odpowiedzi wyrażeń regularnych w Pythonie 2 TFeld, choć krótszy!

Pytanie (jeśli ktoś zna odpowiedź)

Nadal jestem zdezorientowany, dlaczego to działa, ponieważ podłańcuch może mieć dowolną długość i zawsze będzie działać, i nadal działa, gdy dodam literę z przodu prawidłowego ciągu, na przykład „cABABABABAB”. Jeśli osobiście przeczytam regex, widzę (.+), że przechwytuje on dowolną grupę dowolnej długości. A następnie, \\1+$która powtarza przechwyconą grupę dowolną liczbę razy do końca.

Dlaczego więc nie przechwytuje tylko „AB” i nie stwierdza, że ​​jest powtarzane aż do końca łańcucha, tym bardziej, że nie określono ograniczeń co do tego, gdzie może zaczynać się podłańcuch?

Siatkówka 0.8.2 , 9 bajtów

^(.+)\1+$

Wypróbuj online! Link zawiera przypadki testowe.

Galaretka ,  5  4 bajtów

Widzę teraz, że optymalnym sposobem jest zastosowanie metody xnor !

Ḋ;Ṗw

Monadyczny link, który przyjmuje listę znaków i zwraca liczbę całkowitą - najkrótszą możliwą długość powtarzającego się wycinka lub zero, jeśli nie istnieje. Zauważ, że zero to falsey, podczas gdy niezerowe liczby są prawdziwe w Jelly.

Wypróbuj online!

W jaki sposób?

Ḋ;Ṗ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 bajtów

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

Wypróbuj online!

Python 2 , 24 bajty

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

Wypróbuj online!

Bezwstydnie skradziony z odpowiedzi Xnora na pierwotne pytanie.

Bardziej intuicyjna wersja:

Python 2 , 59 55 53 bajtów

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

Wypróbuj online!

Nudna wersja wyrażenia regularnego:

Python 2 , 44 bajty

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

Wypróbuj online!

Wolfram Language (Mathematica) , 24 23 bajty

StringMatchQ[x__..~~x_]

Wypróbuj 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 bajty

+tO{

Wypróbuj tutaj!

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

J , ^{26 25 15} 14 bajtów

Korzystanie z metody xnor

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

Wypróbuj online!

oryginalne (dwa różne podejścia)

J , 25 bajtów

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

Wypróbuj online!

J , 26 bajtów

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

Wypróbuj online!

PowerShell, 23 24 bajty

+1 bajt, aby w pełni dopasować reguły

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

Wypróbuj online!

Strasznie nudne. Na podstawie innych odpowiedzi Regex. Na szczęście PowerShell nie używa \jako znaku ucieczki!

C # (interaktywny kompilator Visual C #) , 70 bajtów

bezwstydna adaptacja xnora ( 46 bajtów )

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

Moje rozwiązanie bez Regex:

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

Wyjaśnienie:

Zastąp każdy możliwy podciąg rozpoczynający się od indeksu 0 pustym ciągiem. Jeśli wynikiem jest pusty ciąg, ciąg jest w całości wykonany z tego podłańcucha. Ponieważ obejmuje to ocenę całego łańcucha za pomocą samego siebie, liczba oczekiwanych wyników musi być większa niż 1.

Przykład: abcabc

Możliwe podciągi zaczynające się od indeksu 0:

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

Jeśli zastąpimy je pustymi ciągami

Substring          Result

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

Ponieważ istnieje podciąg inny niż „abcabc”, który zwraca pusty ciąg, ciąg jest w całości wykonany z innego podłańcucha („abc”)

Wypróbuj online!

Python 3 , 62 60 56 54 bajtów

-4 bajty dzięki dla ArBo

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

1. Iteruj po wszystkich możliwych prefiksach ciągu.
2. Spróbuj zbudować ciąg z prefiksu.
3. Zwróć, czy w ogóle uda się to z dowolnym prefiksem.

Wypróbuj online!

Japt , 10 bajtów

Zwraca liczbę dodatnią, jeśli jest prawdą, i 0, jeśli falsey. Jeśli chcesz otrzymać wynik bool, po prostu dodaj -¡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

Wypróbuj online!

Łuska , 6 bajtów

Ṡ€ȯhtD

Wypróbuj online!

Wydaje mi się, że jest to jeden bajt więcej niż optymalny, ale nie mogłem znaleźć aranżacji, która stworzyłaby wyraźną kompozycję ȯ zbędna.

Wyjaśnienie

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

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

gdzie w całości #reprezentuje ciąg wejściowy, oraz

StringCases[#,<pattern>]

znajduje podciągi ciągu wejściowego pasujące do wzorca

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

Ten wzorzec wymaga dopasowań, xmusi zaczynać się na początku łańcucha i musi spełniać warunek, że (1) dopasowanie nie jest całym łańcuchem wejściowym i (2), jeśli zastąpimy wystąpienia dopasowania w łańcuchu wejściowym pustym łańcuchem otrzymujemy pusty ciąg. Wreszcie, porównując listę dopasowań z pustą listą,

{}!=

jest, Truejeśli lista dopasowań nie jest pusta iFalse jeśli lista dopasowań jest pusta.

Przypadki testowe:

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

i

{}!=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 bajtów

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

Używa textwrap.wrap(dzięki tej odpowiedzi ) do podzielenia łańcucha na kawałki długości w ncelu przetestowania każdej możliwej długości powtarzającego się podłańcucha. Podzielone elementy są następnie porównywane ze sobą poprzez dodanie ich do zestawu. Jeśli wszystkie elementy są równe, a zestaw ma długość 1, łańcuch musi być ciągiem powtarzalnym. Użyłem <2zamiast, ==1ponieważ zapisuje bajt, a długość łańcucha wejściowego była gwarantowana większa niż zero.

Jeśli nie ma żadnego, ndla którego powtarzające się podciągi długości nskładają się na cały ciąg, to zwróć false dla całej funkcji.

05AB1E , 5 bajtów

Metoda xnor z poprzedniego pytania wydaje się również optymalna w 05AB1E.

«¦¨så

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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

Czysty , 73 bajty

Nie używa wyrażenia regularnego.

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

Wypróbuj online!

Definiuje $ :: [Char] -> Bool.
Sprawdza, czy podany ciąg jest prefiksem powtórzenia dowolnego podciągu pobranego od końca.

C ++ (gcc) , 36 bajtów

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

Wypróbuj online!

Kolejny port rozwiązania xnor. Używa makra, aby rozwinąć argument do wyrażenia. Przyjmuje się, że argument jest typu std::string.

Zmienna QlikView, 27 bajtów

Należy to zdefiniować jako zmienną, która następnie pozwala przekazać parametry, np $1 Jako wartość wejściową.

Zwraca 0lub -1(odpowiednik TRUE()funkcji QlikView ).

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

Szybki, 196 bajtów

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}

Wypróbuj online!

Ikona , 46 bajtów

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

Wypróbuj online!

Kolejny port rozwiązania xnor.

K (oK) , 29 bajtów

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

Wypróbuj online!

Czerwony , 72 bajty

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

Wypróbuj online!

Zwraca 1zaTrue

T-SQL, 47 bajtów

Używając metody @ Xnor :

DECLARE @ varchar(max)='ababab'

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

Zachowując starą odpowiedź, ponieważ zawiera trochę dobrej gry w golfa (67 bajtów):

DECLARE @y varchar(max)='abababa'

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

Objaśnienie: Ten skrypt wielokrotnie próbuje zastąpić wejście „@y” pierwszymi znakami „@” wejścia „@y” niczym, jednocześnie zwiększając „@”.

jeśli zastąpisz „ab” w „ababab” niczym, masz pusty ciąg

Ostatecznie wynik będzie pusty. Jeśli dzieje się tak, gdy zmienna pętli jest równa długości varchara, kryterium jest fałszywe / 0, ponieważ „@” = len (@y) (nie było powtarzającego się varchara).

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

można w to zagrać w golfa

@/len(@y)^1

ponieważ długość „@y” nie może wynosić 0, a „@” nigdy nie przekroczy długości @y.

Wypróbuj online