Bu, bu sorudan alınmıştır (elbette). Alıntı yapacağım:

Bir dize alan bir işlev oluşturun ve girişin yalnızca tekrarlanan bir karakter dizisinden oluşup oluşmamasına bağlı olarak doğru veya yanlış döndürmelidir . Verilen dizginin uzunluğu her zaman 1'den büyüktür ve karakter dizisinin en az bir tekrarı olması gerekir.

Bazı örnekler:

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

Özellikle, kesinlikle yinelenen alt dizilerden ( Güncelleme ) oluşan bir dize denetimi, herhangi bir doğru veya yanlış gösterimi çıktırabilir, ancak lütfen hata çıktısı veremez. Kesinlikle alfanümerik dizeler. Aksi halde standart kod golf kuralları. Bu Code Golf, her dil için bayt cinsinden en kısa cevap kazanır.

Brachylog , 4 3 bayt

ġ=Ṁ

Çevrimiçi deneyin!

açıklama

ġ=Ṁ    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 true., kısıtlamaların yerine getirilip getirilmediğini ve uygun false.değilse yazdırır .

JavaScript (ES6), 22 bayt

Bir Boolean değeri döndürür.

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

Çevrimiçi deneyin!

Normal ifade olmadan,  33  29 bayt

Ya null(sahte) ya da bir nesneyi (gerçeği) döndürür .

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

Çevrimiçi deneyin!

Not: Teknik olarak, , match () için normal bir ifadeye dönüştürülür , bu yüzden yukarıdaki başlık bir yalandır.$s$

grep, 19

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

Ölçek

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

Çıktı:

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

Japt , 6 bayt

²é ¤øU

@Shaggy sayesinde bir bayt kaydedildi

Çevrimiçi deneyin!

        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 bayt

Olivier Grégoire sayesinde -1 bayt!
Sıkıcı regex cevap

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

Çevrimiçi deneyin! Şimdi bağladım

python cevap aaaaa sadece 1 byte daha uzun :)

Excel, 26 bayt

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

A1'den gelen girişler, bu formülü koyduğunuz hücreye verilir.

R , 28 bayt

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

Çevrimiçi deneyin!

Basit Regex sürümü. R (bazen) Python'a çok benzer, bu nedenle TFeld'in Python 2 regex yanıtına benzer, daha kısa da olsa!

Soru (cevabı bilen varsa)

Alt dizenin herhangi bir uzunlukta olabileceği ve her zaman çalışabileceği için neden hala çalıştığını ve “cABABABABAB” gibi geçerli bir dizgenin önüne bir harf eklediğimde hala çalıştığım konusunda kafam karıştı. Regex'i şahsen okursam (.+), hangisinin herhangi bir uzunlukta herhangi bir grubu yakaladığını görüyorum . Ve sonra \\1+$ele geçirilen grubu sonuna kadar herhangi bir sayıda tekrarlar.

Öyleyse neden sadece "AB" yi yakalamıyor ve dizenin sonuna kadar tekrarlandığını görmüyor, özellikle alt tabakanın başlayabileceği bir kısıtlama olmadığı için?

Retina 0.8.2 , 9 bayt

^(.+)\1+$

Çevrimiçi deneyin! Link, test durumlarını içerir.

Jöle ,  5  4 bayt

Şimdi anlıyorum ki en uygun yol xnor yöntemini takip etmek !

Ḋ;Ṗw

Bir karakter listesi kabul eden ve bir tamsayı çıkaran, yinelenen bir dilimin mümkün olan en kısa uzunluğu ya da hiçbiri yoksa sıfır olan monadik bir Bağlantı. Jelly’de sıfır olmayan sayılar hakikaten sıfırın falsey olduğunu unutmayın.

Çevrimiçi deneyin!

Nasıl?

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

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

Çevrimiçi deneyin!

Python 2 , 24 bayt

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

Çevrimiçi deneyin!

Utanmadan xnor'ın asıl sorunun cevabından çalınmış .

Daha sezgisel versiyon:

Python 2 , 59 55 53 bayt

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

Çevrimiçi deneyin!

Sıkıcı regex sürümü:

Python 2,44 bayt

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 24 23 bayt

StringMatchQ[x__..~~x_]

Çevrimiçi deneyin!

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 bayt

+tO{

Burada dene!

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

J , ^{26 25 15} 14 bayt

Xnor yöntemini kullanma

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

Çevrimiçi deneyin!

orijinal (iki farklı yaklaşım)

J , 25 bayt

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

Çevrimiçi deneyin!

J , 26 bayt

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

Çevrimiçi deneyin!

PowerShell, 23 24 bayt

Kurallara tam olarak uyması için +1 bayt

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

Çevrimiçi deneyin!

Oldukça sıkıcı. Diğer Regex cevaplarına göre. Neyse ki PowerShell \kaçış karakteri olarak kullanmaz !

C # (Visual C # Etkileşimli Derleyici) , 70 bayt

xnor'ın utanmaz uyarlaması ( 46 bayt )

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

Regex olmayan çözümüm:

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

Açıklama:

Dizin 0'da başlayan her olası alt dizgiyi boş bir dize ile değiştirin. Sonuç boş bir dize ise, dize tamamen bu alt dizgiden yapılır. Bu, dizenin tamamının kendisiyle değerlendirilmesini içerdiğinden, beklenen sonuçların miktarı 1'den büyük olmalıdır.

Örnek: abcabc

0 dizininden başlayan olası alt diziler:

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

Onları boş dizelerle değiştirirsek

Substring          Result

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

Boş bir dize döndüren 'abcabc' dışında bir alt dize olduğundan, dize tamamen başka bir alt dize ('abc') 'den yapılmıştır.

Çevrimiçi deneyin!

Python 3 , 62 60 56 54 bayt

ArBo için -4 bayt thanx

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

1. Dizedeki tüm olası önekleri tekrarlayın.
2. Dizeyi önekten oluşturmayı deneyin.
3. Bunun herhangi bir önekle başarılı olup olmadığını döndürün.

Çevrimiçi deneyin!

Japt , 10 bayt

Doğruysa pozitif, falsey ise 0 döndürür. Bir bool çıkışı istiyorsanız, sadece -¡bayrak ekleyin

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

Çevrimiçi deneyin!

Kabuğu , 6 bayt

Ṡ€ȯhtD

Çevrimiçi deneyin!

Bunun bir bayt'ın optimalden daha fazla olduğunu hissediyorum, ancak açık kompozisyonu ȯgereksiz kılan bir düzenleme bulamadım .

açıklama

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

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

burada, #giriş dizesini temsil eder ve

StringCases[#,<pattern>]

Desene uyan giriş dizesinin alt dizelerini bulur

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

Bu desen eşleşmeleri gerektirir x, dizenin başlangıcında başlamalı ve (1) eşleşmenin tüm girdi dizisi olmadığı koşulunu sağlamalıdır (2), girdi dizisindeki eşleşmenin oluşumlarını boş dizeyle değiştirirsek (2) boş dizgeyi elde ederiz. Son olarak, eşleşme listesini boş listeyle karşılaştırarak,

{}!=

olduğu Truemaçların listesi boş olmayan ise ve Falseeşleşmelerin listesi boşsa.

Test durumları:

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

ve

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

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

Tekrarlayan alt tabakanın her olası uzunluğunu test etmek için ipi uzunluk parçalarına bölmek için kullanır textwrap.wrap( bu cevap sayesinde ) n. Bölünmüş parçalar daha sonra kümeye eklenerek birbirleriyle karşılaştırılır. Parçaların tümü eşitse ve küme uzunluğu 1 ise, dize yinelenen bir dize olmalıdır. Bunun <2yerine ==1bir bayt tasarrufu yaptığı için kullandım ve giriş dizesinin uzunluğunun sıfırdan büyük olması garanti edildi.

nYinelenen uzunluktaki alt ndizgilerin dizgenin tamamını oluşturduğuna dair bir şey yoksa , tüm işlev için false döndürür.

05AB1E , 5 bayt

xnor'ın önceki sorudan aldığı metot 05AB1E'de de en uygun gibi görünüyor.

«¦¨så

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

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

Temiz , 73 bayt

Regex kullanmaz.

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

Çevrimiçi deneyin!

Tanımlar $ :: [Char] -> Bool.
Verilen dizenin, alttan alınan herhangi bir alt dizenin tekrarının öneki olup olmadığını kontrol eder.

C ++ (gcc) , 36 bayt

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

Çevrimiçi deneyin!

Xnor'ın çözümünün başka bir limanı. Argümanı ifadeye genişletmek için bir makro kullanır. Argümanın tür olduğu varsayılır std::string.

QlikView Değişkeni, 27 bayt

Bu, bir değişken olarak tanımlanmalıdır, bu da parametreleri, örneğin $1giriş değeriniz olarak geçmenizi sağlar .

Bu döndüren 0veya -1(QlikView'ın eşdeğer TRUE()fonksiyonu).

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

Swift, 196 bayt

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}

Çevrimiçi deneyin!

Simge , 46 bayt

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

Çevrimiçi deneyin!

Xnor'ın çözümünün başka bir limanı.

K (oK) , 29 bayt

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

Çevrimiçi deneyin!

Kırmızı , 72 bayt

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

Çevrimiçi deneyin!

İade 1içinTrue

T-SQL, 47 bayt

@ Xnor'ın yöntemini kullanarak :

DECLARE @ varchar(max)='ababab'

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

Bazı eski golfleri (67 byte) içerdiği için eski cevabı saklamak:

DECLARE @y varchar(max)='abababa'

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

Açıklama: Bu betik, '@' girişini '@' girişinin ilk '@' karakterleriyle değiştirerek, '@' değerini arttırmaya çalışıyor.

eğer 'ab' yerine 'ababab' değiştirirseniz, boş bir dizginiz olmaz

Sonunda sonuç boş olacak. Bu, döngü değişkeni varchar uzunluğuna eşit olduğunda gerçekleşirse, ölçütler yanlış / 0'dır çünkü '@' = len (@y) (yinelenen varchar olmadı).

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

bunun içine golf edilebilir

@/len(@y)^1

çünkü '@' uzunluğu 0 olamaz ve '@' uzunluğu asla #y değerini aşmayacaktır.

Çevrimiçi deneyin