Điều này được lấy từ câu hỏi này (với sự cho phép của khóa học). Tôi sẽ trích dẫn:

Tạo một chức năng mà phải mất một chuỗi, và nó sẽ trở lại đúng hay sai dựa trên việc đầu vào bao gồm chỉ một chuỗi ký tự lặp lại. Độ dài của chuỗi đã cho luôn lớn hơn 1 và chuỗi ký tự phải có ít nhất một lần lặp lại.

Vài ví dụ:

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

Cụ thể, việc kiểm tra một chuỗi bao gồm các chuỗi con lặp lại ( Cập nhật ) có thể xuất ra bất kỳ biểu diễn đúng hoặc sai, nhưng không có đầu ra lỗi nào. Chuỗi chữ cái nghiêm ngặt. Nếu không, quy tắc golf tiêu chuẩn. Đây là Code Golf, vì vậy câu trả lời ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.

Brachylog , 4 3 byte

ġ=Ṁ

Hãy thử trực tuyến!

Giải trình

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

Chương trình in true.nếu các ràng buộc có thể được thỏa mãn, và false.nếu không.

JavaScript (ES6), 22 byte

Trả về giá trị Boolean.

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

Hãy thử trực tuyến!

Không có biểu thức chính quy,  33  29 byte

Trả về một trong hai null(giả) hoặc một đối tượng (trung thực).

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

Hãy thử trực tuyến!

NB: Về mặt kỹ thuật, $s$ được chuyển đổi thành biểu thức chính quy cho match () , vì vậy tiêu đề trên là một lời nói dối.

grep, 19

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

Kiểm tra

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

Đầu ra:

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

Japt , 6 byte

²é ¤øU

Đã lưu một byte nhờ @Shaggy

Hãy thử trực tuyến!

        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 nhờ Olivier Grégoire!
Chán câu trả lời regex

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

Hãy thử trực tuyến!

Nó chỉ dài hơn 1 byte so với câu trả lời của con trăn aaaaa Tôi đang bị trói bây giờ :)

Excel, 26 byte

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

Đầu vào từ A1, xuất ra bất kỳ ô nào bạn đặt công thức này.

R , 28 byte

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

Hãy thử trực tuyến!

Phiên bản Regex đơn giản. R (đôi khi) rất giống với Python, vì vậy nó tương tự như câu trả lời regex Python 2 của TFeld, mặc dù ngắn hơn!

Câu hỏi (nếu ai biết câu trả lời)

Tôi vẫn bối rối tại sao điều này hoạt động, vì chuỗi con có thể dài bất kỳ và sẽ luôn hoạt động, và vẫn hoạt động khi tôi thêm một chữ cái vào trước một chuỗi hợp lệ, như "cABABABABAB". Nếu cá nhân tôi đọc regex, tôi thấy (.+), trong đó nắm bắt bất kỳ nhóm nào có độ dài bất kỳ. Và sau \\1+$đó lặp lại nhóm bị bắt bất kỳ số lần cho đến khi kết thúc.

Vậy tại sao nó không chỉ chụp "AB" và thấy rằng nó được lặp lại cho đến hết chuỗi, đặc biệt là vì không có giới hạn nào được chỉ định là nơi chuỗi con có thể bắt đầu?

Võng mạc 0.8.2 , 9 byte

^(.+)\1+$

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm.

Thạch ,  5  4 byte

Bây giờ tôi thấy cách tối ưu là theo phương pháp của xnor !

Ḋ;Ṗw

Liên kết đơn âm chấp nhận danh sách các ký tự và xuất ra một số nguyên - độ dài ngắn nhất có thể của một lát lặp lại hoặc bằng 0 nếu không tồn tại. Lưu ý rằng số 0 là falsey trong khi số khác không là số thật trong Jelly.

Hãy thử trực tuyến!

Làm sao?

Ḋ;Ṗ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+$/

Hãy thử trực tuyến!

Python 2 , 24 byte

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

Hãy thử trực tuyến!

Bị đánh cắp một cách đáng xấu hổ từ câu trả lời của xnor cho câu hỏi ban đầu.

Phiên bản trực quan hơn:

Python 2 , 59 55 53 byte

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

Hãy thử trực tuyến!

Phiên bản regex nhàm chán:

Python 2 , 44 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 24 23 byte

StringMatchQ[x__..~~x_]

Hãy thử trực tuyến!

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{

Hãy thử nó ở đây!

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

J , ^{26 25 15} 14 byte

Sử dụng phương pháp xnor

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

Hãy thử trực tuyến!

nguyên bản (hai cách tiếp cận khác nhau)

J , 25 byte

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

Hãy thử trực tuyến!

J , 26 byte

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

Hãy thử trực tuyến!

PowerShell, 23 24 byte

+1 byte để khớp hoàn toàn với các quy tắc

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

Hãy thử trực tuyến!

Khá nhàm chán. Dựa trên các câu trả lời khác của Regex. May mắn thay PowerShell không sử dụng \như một nhân vật thoát!

C # (Trình biên dịch tương tác Visual C #) , 70 byte

thích ứng không biết xấu hổ của xnor ( 46 byte )

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

Giải pháp phi Regex của tôi:

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

Giải trình:

Thay thế mọi chuỗi con có thể bắt đầu ở chỉ số 0 bằng một chuỗi trống. Nếu kết quả là một chuỗi rỗng, chuỗi hoàn toàn được tạo từ chuỗi con đó. Vì điều này bao gồm việc đánh giá toàn bộ chuỗi với chính nó, lượng kết quả dự kiến ​​phải lớn hơn 1.

Ví dụ: abcabc

Các chuỗi con có thể bắt đầu từ chỉ số 0:

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

Nếu chúng ta thay thế chúng bằng các chuỗi trống

Substring          Result

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

Vì có một chuỗi con khác ngoài 'abcabc' trả về một chuỗi trống, nên chuỗi hoàn toàn được tạo từ một chuỗi con khác ('abc')

Hãy thử trực tuyến!

Python 3 , 62 60 56 54 byte

-4 byte sox đến ArBo

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

1. Lặp lại tất cả các tiền tố có thể có trong chuỗi.
2. Cố gắng xây dựng chuỗi ra khỏi tiền tố.
3. Trả về việc này có thành công với bất kỳ tiền tố nào không.

Hãy thử trực tuyến!

Japt , 10 byte

Trả về một số dương nếu trung thực và 0 nếu falsey. Nếu bạn muốn một đầu ra bool chỉ cần thêm -¡cờ

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

Hãy thử trực tuyến!

Husk , 6 byte

Ṡ€ȯhtD

Hãy thử trực tuyến!

Tôi cảm thấy như đây là một byte nhiều hơn tối ưu, nhưng tôi không thể tìm thấy một sự sắp xếp làm cho bố cục rõ ràng ȯkhông cần thiết.

Giải trình

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

Toán học 11.x, 74 byte

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

trong đó, xuyên suốt, #đại diện cho chuỗi đầu vào và

StringCases[#,<pattern>]

tìm chuỗi con của chuỗi đầu vào khớp với mẫu

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

Mẫu này yêu cầu khớp, xphải bắt đầu khi bắt đầu chuỗi và phải thỏa mãn điều kiện (1) khớp không phải là toàn bộ chuỗi đầu vào và (2) nếu chúng ta thay thế các lần xuất hiện của khớp trong chuỗi đầu vào bằng chuỗi trống chúng ta thu được chuỗi rỗng. Cuối cùng, so sánh danh sách các trận đấu với danh sách trống,

{}!=

là Truenếu danh sách các trận đấu là không trống và Falsenếu danh sách các trận đấu trống.

Các trường hợp thử nghiệm:

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

và

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

Sử dụng textwrap.wrap(nhờ câu trả lời này ) để chia chuỗi thành các phần có độ dài nđể kiểm tra từng độ dài có thể lặp lại của chuỗi con. Các mảnh tách sau đó được so sánh với nhau bằng cách thêm chúng vào một bộ. Nếu tất cả các phần bằng nhau và tập hợp có độ dài 1, thì chuỗi phải là một chuỗi lặp lại. Tôi đã sử dụng<2 thay ==1vì bởi vì nó tiết kiệm một byte và độ dài của chuỗi đầu vào được đảm bảo lớn hơn 0.

Nếu không có nchuỗi con lặp lại nào ntạo thành toàn bộ chuỗi, thì trả về false cho toàn bộ hàm.

05AB1E , 5 byte

Phương pháp của xnor từ câu hỏi trước dường như cũng tối ưu trong 05AB1E.

«¦¨så

Hãy thử trực tuyến! hoặc như một thử nghiệm

Giải trình

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

Sạch sẽ , 73 byte

Không sử dụng regex.

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

Hãy thử trực tuyến!

Định nghĩa $ :: [Char] -> Bool.
Kiểm tra xem chuỗi đã cho có phải là tiền tố của sự lặp lại của bất kỳ chuỗi con nào được lấy từ cuối không.

C ++ (gcc) , 36 byte

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

Hãy thử trực tuyến!

Một cổng khác của giải pháp xnor. Sử dụng một macro để mở rộng đối số vào biểu thức. Đối số được coi là loại std::string.

Biến QlikView, 27 byte

Điều này nên được định nghĩa là một biến, sau đó cho phép bạn truyền tham số, ví dụ $1như giá trị đầu vào của bạn.

Nó trả về 0hoặc -1(tương đương với TRUE()chức năng của QlikView ).

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

Swift, 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}

Hãy thử trực tuyến!

Biểu tượng , 46 byte

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

Hãy thử trực tuyến!

Một cổng khác của giải pháp xnor.

K (oK) , 29 byte

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

Hãy thử trực tuyến!

Màu đỏ , 72 byte

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

Hãy thử trực tuyến!

Trả lại 1choTrue

T-SQL, 47 byte

Sử dụng phương pháp của @ Xnor :

DECLARE @ varchar(max)='ababab'

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

Giữ câu trả lời cũ vì nó chứa một số golf tốt (67 byte):

DECLARE @y varchar(max)='abababa'

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

Giải thích: Tập lệnh này đang lặp lại cố gắng thay thế đầu vào '@y' bằng các ký tự '@' đầu tiên của đầu vào '@y' bằng không, trong khi tăng '@'.

nếu bạn thay thế 'ab' trong 'ababab' bằng không có gì thì bạn có một chuỗi trống

Cuối cùng kết quả sẽ trống rỗng. Nếu điều này xảy ra khi biến vòng lặp bằng độ dài của varchar, thì tiêu chí là false / 0 vì '@' = len (@y) (không có varchar lặp lại).

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

có thể đánh gôn vào đây

@/len(@y)^1

bởi vì độ dài của '@y' không thể là 0 và '@' sẽ không bao giờ vượt quá độ dài @y.

Dùng thử trực tuyến