อัพเดท : การส่ง Pyth ของ isaacgเป็นผู้ชนะ!

หลายคนคงเคยได้ยินว่ามี JavaScript รุ่นเย็นในเมือง (อ่าน ES6) ซึ่งมีวิธีการString.prototype.repeatเพื่อให้คุณสามารถทำ

"Hello, World!".repeat(3)

และรับ

"Hello, World!Hello, World!Hello, World!"

เป็นเอาท์พุท

งานของคุณคือการเขียนฟังก์ชั่นหรือโปรแกรมในภาษาที่คุณเลือกซึ่งตรวจพบว่าสตริงได้รับภายใต้การเปลี่ยนแปลงดังกล่าว

เช่นสตริงอินพุตสามารถแสดงเป็นการnซ้ำซ้อนเวลาที่แน่นอนของสตริงที่เล็กกว่า เอาท์พุท (เป็นคำสั่งส่งกลับของฟังก์ชั่นหรือ STDOUT) ควรเป็นจริงถ้าสตริงสามารถหรือเท็จถ้าสตริงไม่สามารถแสดงเป็นซ้ำของสตริงที่มีขนาดเล็กลง

ตัวอย่างอินพุตบางส่วน:

"asdfasdfasdf"  // true
"asdfasdfa"     // false
"ĴĴĴĴĴĴĴĴĴ"     // true
"ĴĴĴ123ĴĴĴ123"  // true
"abcdefgh"      // false

โปรดทราบว่าการป้อนข้อมูลครั้งสุดท้ายเป็นเท็จจึงnควรมากกว่า1

ทำตามกฎ

• เขียนฟังก์ชั่น / โปรแกรมในภาษาใด ๆ เพื่อป้อนข้อมูล (ผ่านฟังก์ชั่นอาร์กิวเมนต์ / บรรทัดคำสั่ง args / STDIN) สตริง
• ส่งคืน / พิมพ์ค่าความจริงหากสตริงที่กำหนดเกิดขึ้นผ่านการซ้ำซ้อนที่แน่นอนของสตริงที่เล็กกว่าทำซ้ำอย่างน้อยสองครั้ง
• ขนาดสูงสุดของสายป้อนข้อมูลเป็นแบบอินฟินิตี้
• สตริงสามารถมีอักขระ ASCII ที่เป็นไปได้ทั้งหมด
• นี่คือรหัสกอล์ฟซึ่งเป็นรหัสที่เล็กที่สุดในตัวละครที่ชนะ

Pyth , 9

/:+zz1_1z

หรือ

}z:+zz1_1

เหล่านี้เป็นทั้งการแปลอย่างใกล้ชิดของคำตอบหลามของ @ xnor ยกเว้นว่าพวกเขารับอินพุตจาก STDIN และพิมพ์ ครั้งแรกเทียบเท่ากับ:

z = input()
print((z+z)[1:-1].count(z))

0 สำหรับเท็จ 1 สำหรับจริง

บรรทัดที่สองเทียบเท่ากับ:

z = input()
print(z in (z+z)[1:-1])

เท็จสำหรับเท็จจริงสำหรับจริง

คอมไพเลอร์อย่างเป็นทางการของ Pyth มีข้อผิดพลาดเกี่ยวกับอันที่สองซึ่งฉันเพิ่งแก้ไขดังนั้นอันแรกคือการส่งอย่างเป็นทางการของฉัน

Python (24)

lambda s:s in(s+s)[1:-1]

ตรวจสอบว่าสตริงนั้นเป็นสตริงย่อยของตัวเองต่อกันสองครั้งหรือไม่และกำจัดอักขระตัวแรกและตัวสุดท้ายเพื่อหลีกเลี่ยงการจับคู่เล็กน้อย หากเป็นเช่นนั้นจะต้องเป็นการเปลี่ยนรูปแบบวัฏจักรของตัวเองใหม่และรวมเป็นกลุ่มซ้ำ

Regex (ECMAScript รส), 11 ไบต์

ดูเหมือนงาน regex!

^([^]+)\1+$

ทดสอบที่นี่

ฉันเลือก ECMAScript เพราะเป็นเพียงรสชาติ (ฉันรู้) ที่[^]ตรงกับตัวละครใด ๆ ในคนอื่น ๆ ฉันต้องการธงเพื่อเปลี่ยนพฤติกรรม.หรือใช้[\s\S]ซึ่งมีความยาวสามอักขระ

ขึ้นอยู่กับว่าเรานับธงอย่างไรนั้นอาจเป็นไบต์ที่สั้นกว่า เช่นถ้าเรานับรูปแบบ + ธง (เช่นไม่สนใจตัวคั่น) ค่าเทียบเท่า PCRE / Perl จะเป็น

/^(.+)\1+$/s

ซึ่งคือ 10 ไบต์โดยไม่สนใจตัวคั่น

ทดสอบที่นี่

สิ่งนี้ตรงกับสตริงเท่านั้นซึ่งประกอบด้วยการซ้ำอย่างน้อยสองครั้งของสตริงย่อยบางส่วน

นี่คือฟังก์ชั่นเต็มรูปแบบ 26 ไบต์ ES6 แต่ฉันยืนยันว่าการส่งนิพจน์ทั่วไปนั้นใช้ได้จริง:

f=s->/^([^]+)\1+$/.test(s)

CJam, 9

q__+)@+#)

คล้ายกับแนวคิดของ xnor

q      " Read input. ";
__+    " Duplicate twice and concatenate them together. ";
)      " Remove the last character of the longer string. ";
@+     " Insert that character at the beginning of the shorter string. ";
#)     " Find the shorter string in the longer string, and increase by one. ";

APL, 11

2<+/x⍷,⍨x←⍞

คำอธิบาย
⍞รับอินพุตสตริงจากหน้าจอที่
x←กำหนดให้กับตัวแปรx
,⍨เชื่อมสตริงด้วยตัวเอง
x⍷ค้นหาxในสตริงผลลัพธ์ ส่งกลับอาร์เรย์ที่ประกอบด้วย 1 ในตำแหน่งเริ่มต้นของการแข่งขันและ 0 ของที่อื่น
+/สรุปผลการ
2<ตรวจสอบอาร์เรย์ว่าผลรวมมากกว่า 2 (เนื่องจากจะมีการแข่งขัน 2 เรื่องเล็กน้อย)

CJam, 10 ไบต์

ฉันจับข้อผิดพลาด CJam คำตอบแรกของฉันดังนั้นอาจจะสามารถเล่นกอล์ฟได้อีก:

q__+(;);\#

เอาต์พุต -1 สำหรับ FALSE และตัวเลข> = 0 สำหรับ TRUE

GolfScript ขนาด 10 ไบต์

..+(;);\?)

อีกหนึ่งการดำเนินการตามแนวคิดที่ชาญฉลาดของ xnor

Python - 59 57

lambda s:any([s*n==s[:n]*len(s)for n in range(2,len(s))])

ทุบตีบริสุทธิ์ 30 ไบต์

พอร์ตที่เรียบง่ายของคำตอบที่ฉลาดของ@ xnor :

[[ ${1:1}${1:0: -1} =~ "$1" ]]

รหัสทางออกคือ 0 สำหรับ TRUE และ 1 สำหรับ FALSE:

$ for s in 'Hello, World!Hello, World!Hello, World!' 'asdfasdfasdf' 'asdfasdfa' 'ĴĴĴĴĴĴĴĴĴ' 'ĴĴĴ123ĴĴĴ123' 'abcdefgh'; do echo "./isrepeated.sh "\"$s\"" returns $(./isrepeated.sh "$s"; echo $?)"; done
./isrepeated.sh "Hello, World!Hello, World!Hello, World!" returns 0
./isrepeated.sh "asdfasdfasdf" returns 0
./isrepeated.sh "asdfasdfa" returns 1
./isrepeated.sh "ĴĴĴĴĴĴĴĴĴ" returns 0
./isrepeated.sh "ĴĴĴ123ĴĴĴ123" returns 0
./isrepeated.sh "abcdefgh" returns 1
$ 

หมายเหตุ=~ภายใน[[ ... ]]เป็นผู้ประกอบการใน regex ทุบตี อย่างไรก็ตาม"ส่วนหนึ่งของรูปแบบใด ๆ อาจจะยกมาเพื่อบังคับให้มีการจับคู่เป็นสตริง" ดังนั้นบ่อยครั้งที่ ai ใช้ bash การได้รับข้อความที่ถูกต้องนั้นสำคัญมาก - ที่นี่เราแค่ต้องการตรวจสอบการส่งสตริงและไม่ใช่ regex

TI-BASIC - 32

ฉันคิดว่าฉันลองใช้ภาษาที่ได้รับโทเค็น รันด้วยสตริงใน Ans ส่งคืนค่า 0 หากเป็นเท็จและความยาวของสตริงซ้ำถ้าเป็นจริง

inString(sub(Ans+Ans,1,2length(Ans)-1),sub(Ans,length(Ans),1)+Ans

มันช่างน่าทึ่งแค่ไหน

ECMAScript 6 (189)

(function(){var S=String.prototype,r=S.repeat;S.isRepeated=function(){return!1};S.repeat=function(c){var s=new String(r.call(this,c));if(c>1)s.isRepeated=function(){return!0};return s}}());

< console.log("abc".isRepeated(),"abc".repeat(10).isRepeated());
> false true

แน่นอนนี่เป็นทางออกที่ถูกต้องเท่านั้น? ตัวอย่างเช่นnanaไม่จำเป็นต้องสร้างคำ (สตริง)"na".repeat(2)

ECMAScript 6 (34 36 )

อีกคำตอบ ES6 แต่ไม่ใช้repeatและใช้เคล็ดลับของ xnor :

f=i=>(i+i).slice(1,-1).contains(i)

ต้องทำงานในคอนโซลของเบราว์เซอร์ที่สามารถใช้ ES6 เช่น Firefox

C 85

l,d;f(s){return l=strlen(s),strstr(d,strcpy(strcpy(d=alloca(l*2+1),s)+l,s)-1)-d-l+1;}

มันค่อนข้างยาว แต่ฟังก์ชั่นภายนอกก็เป็นแบบนั้นเสมอ มันอยู่ในใจของฉันที่ฉันสามารถเขียนใหม่ทุกฟังก์ชั่นสตริงแทนที่พวกเขาด้วยการวนซ้ำหรือซ้ำ แต่จากประสบการณ์ของฉันมันจะเปิดออกอีกต่อไปและตรงไปตรงมาฉันไม่ต้องการลอง

หลังจากการวิจัยบางอย่างฉันเห็นวิธีการแก้ปัญหาที่มีประสิทธิภาพสูง แต่ไม่ฉลาด (และสั้น) เท่า xnor เพียงเพื่อเป็นต้นฉบับ ... ฉันเขียนความคิดเดียวกันในค

คำอธิบาย:

int length, 
    duplicate;
int is_repetition(char *input)
{
    // length = "abc" -> 3
    length = strlen(input);
    // alloca because the function name is as long as "malloc" 
    // but you don't have to call free() because it uses the stack
    // to allocate memory
    // duplicate = x x x x x x + x
    duplicate = alloca(length*2 + 1);
    // duplicate = a b c 0 x x + x
    strcpy(duplicate, input);
    // duplicate = a b c a b c + 0
    strcpy(duplicate + length, input);
    if (strstr(duplicate,duplicate + length - 1) != duplicate + length - 1)
        // repetition
        // e.g. abab -> abababab -> aba[babab]
        // -> first occurence of [babab] is not aba[babab]
        // but a[babab]ab -> this is a repetition
        return 1;
    else
        // not repetition
        // e.g. abc -> abcabc -> ab[cabc]
        // -> first occurence of [cabc] is ab[cabc]
        // it matches the last "cabc"
        return 0;
}

ECMAScript 6 (59 62 67 73 )

ไม่ใช่ผู้ชนะ แต่ดูเหมือนว่าควรมีคำตอบอย่างน้อยหนึ่งคำตอบใน ES6 สำหรับคำถามนี้ที่ใช้repeatฟังก์ชันจริง:

f=i=>[...i].some((_,j)=>i.slice(0,j).repeat(i.length/j)==i)

ต้องทำงานในคอนโซลของเบราว์เซอร์ที่สามารถใช้ ES6 เช่น Firefox

มันทำซ้ำที่ไม่จำเป็นจำนวนมาก แต่ทำไมต้องทำให้นานขึ้นเพื่อหลีกเลี่ยงสิ่งนั้นใช่ไหม

• แก้ไข # 1:บันทึกสองสามไบต์โดยแปลงเป็นฟังก์ชัน ขอบคุณเครื่องมือเพิ่มประสิทธิภาพ!
• แก้ไข # 2:ขอบคุณ hsl สำหรับเคล็ดลับการแพร่กระจายตัวดำเนินการเพื่อบันทึกไบต์เพิ่มเติม!
• แก้ไข # 3:และต้องขอบคุณ Rob W. อีก 3 ไบต์!

เยลลี่ 3 ไบต์

ṙJċ

ลองออนไลน์!

เช่นเดียวกับคำตอบนี้ (บางทีความท้าทายในภายหลังอาจเป็นลักษณะทั่วไปของสิ่งนี้)

Java 8, 28 ไบต์

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

ลองออนไลน์

คำอธิบาย:

ตรวจสอบว่า Input-String ตรงกับ regex หรือไม่String#matchesโดยที่เพิ่ม^...$เข้ากับ String ทั้งหมดโดยปริยาย
คำอธิบายของ regex นั้น:

^(s?)(.+)\1+$
^                Begin of the string
 (s?)            Enable DOTALL-mode, where `.` also matches new-lines
     (           Open capture group 1
      .+          One or more characters
        )        Close capture group 1
         \1+     Plus the match of the capture group 1, one or more times
            $    End of the string

ดังนั้นโดยทั่วไปจะตรวจสอบว่าซับสตริงซ้ำสองครั้งหรือมากกว่า (รองรับบรรทัดใหม่)