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

รับสตริงที่ไม่ว่างsซึ่งประกอบด้วยตัวอักษรจากaถึงzเท่านั้นส่งออกลำดับสูงสุดของการหมุนสมมาตรของสตริง

Testcases:

input        output
a            1
abcd         1
abab         2
dfdfdfdfdfdf 6

นี่คือ รหัสกอล์ฟ. คำตอบที่สั้นที่สุดในการชนะไบต์ ช่องโหว่มาตรฐานใช้

เรติน่า 15 ไบต์

(^.+?|\1)+$
$#1

ลองออนไลน์!

จับคู่สตริงทั้งหมดด้วยการทำซ้ำสตริงย่อย (สตริงย่อยที่สั้นกว่าจะถูกจัดลำดับความสำคัญเนื่องจากไม่มีการจัดเรียง.+?) และแทนที่สตริงทั้งหมดด้วยจำนวนการทำซ้ำที่เราใช้

เยลลี่ 3 ไบต์

ṙJċ

ลองออนไลน์!

05AB1E , 8 ไบต์

gGDÀ})QO

ลองออนไลน์!

คำอธิบาย

gG  }      # len(input)-1 times do:
  D        # duplicate
   À       # rotate left
     )     # wrap result in a list
      Q    # compare each to input for equality
       O   # sum

Python ขนาด 31 ไบต์

lambda s:len(s)/(s+s).find(s,1)

ค้นหาดัชนีที่ไม่ใช่ศูนย์แรกsในs+sเพื่อหาว่าเราต้องหมุนsกลับไปไกลแค่ไหนแล้วจึงหารความยาวของsจำนวนนั้น บนพื้นฐานความคิดที่ผมเห็นที่อื่น ๆ

Prolog (SWI) 64 ไบต์

A+B:-findall(X,(append(X,Y,A),append(Y,X,A)),[_|Z]),length(Z,B).

ลองออนไลน์!

กำหนดเพรดิเคต+/2ที่รับสตริง (ในรูปแบบของรายการของรหัสอักขระ) เป็นอาร์กิวเมนต์แรก ( A) และตั้งค่าอาร์กิวเมนต์ที่สอง ( B) เป็นลำดับของการหมุนสมมาตรลำดับสูงสุด

คำอธิบาย

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

รหัสคำอธิบาย

ส่วนใหญ่ของการยกของหนักจะกระทำโดยการเรียกไปที่ภาคfindall/3แสดง เพรดิเคตfindall/3ค้นหาค่าต่าง ๆ ที่เป็นไปได้ทั้งหมดสำหรับอาร์กิวเมนต์แรก ( Xในกรณีนี้) เพื่อให้นิพจน์ที่กำหนดเป็นอาร์กิวเมนต์ที่สองเป็นจริง ( (append(X,Y,A),append(Y,X,A))เพิ่มเติมในภายหลัง) ในที่สุดก็เก็บค่าแต่ละค่าที่เป็นไปได้เหล่านี้Xเป็นรายการในอาร์กิวเมนต์สุดท้าย ( [_|Z])

แสดงออกผ่านเข้ามาfindall/3เป็น arugment ที่สอง(append(X,Y,A),append(Y,X,A))ใช้append/3คำกริยาเพื่อระบุว่าXตัดแบ่งกับบางส่วนยังไม่ได้กำหนดYต้องเท่ากับA, สายป้อนและที่เดียวYconcatenated ด้วยยังจะต้องเท่ากับX Aซึ่งหมายความว่าXจะต้องมีคำนำหน้าของบางอย่างAเช่นว่าถ้ามันถูกลบออกจากหน้าและเพิ่มไปยังด้านหลังแล้วสตริงส่งผลให้เป็นเช่นเดียวกับA AชุดของXs พร้อมด้วยคุณสมบัตินี้เกือบจะAมีการติดต่อแบบหนึ่งต่อหนึ่งกับการหมุนสมมาตร มีเสมอหนึ่งกรณีของการนับสองครั้งซึ่งเกิดจากความจริงที่ว่าทั้งสตริงที่ว่างเปล่าและAเป็นคำนำหน้าของAที่สอดคล้องกับ 0 Aการหมุนของ ตั้งแต่0-rotation ของAอยู่เสมอสมมาตรความยาวของรายการผลลัพธ์ของXs จากจะเป็นหนึ่งมากกว่าจำนวนผลัดสมมาตรบนfindall/3A

เพื่อแก้ปัญหาการนับซ้ำฉันใช้การจับคู่รูปแบบกับอาร์กิวเมนต์ที่สามของเพfindall/3รดิเคต ในรายการ Prolog จะแสดงเป็นคู่ของหัวของพวกเขา (องค์ประกอบแรก) และหางของพวกเขา (ส่วนที่เหลือ) จึงหมายถึงรายการที่มีหางเท่ากับเท่ากับ[_|Z] Zซึ่งหมายความว่าความยาวของZเป็นหนึ่งในน้อยกว่าจำนวนของคำนำหน้าพบโดยกริยาจึงเท่ากับจำนวนของการหมุนสมมาตรของfindall/3 Aสุดท้ายผมใช้length/2คำกริยาชุดความยาวของBZ

JavaScript (ES6), 42 41 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @ l4m2

s=>s.length/s.match`(.+?)\\1*$`[1].length

กรณีทดสอบ

let f =

s=>s.length/s.match`(.+?)\\1*$`[1].length

console.log(f("a"))            // 1
console.log(f("abcd"))         // 1
console.log(f("abab"))         // 2
console.log(f("dfdfdfdfdfdf")) // 6

Japtap , 7 ไบต์

¬x@¥UéY

ทดสอบออนไลน์!

คำอธิบาย

 ¬ x@   ¥ UéY
 q xXY{ ==UéY}  // Expanded
Uq xXY{U==UéY}  // Variable introduction
                // Implicit: U = input string
Uq              // Split U into chars.
   xXY{      }  // Map each item X and index Y by this function, then sum the results:
       U==UéY   //   Return U equals (U rotated by Y characters).
                // Implicit: output result of last expression

PHP, 66 ไบต์

for(;strtr($a=$argn,[substr($a,0,++$i)=>""]););echo strlen($a)/$i;

ลองออนไลน์!

PHP, 67 ไบต์

preg_match('#^(.+?)\1*$#',$argn,$t);echo substr_count($argn,$t[1]);

ลองออนไลน์!

C (gcc) , 59 ไบต์

-Df(d,s)=for(d=n=strlen(s);n%d|memcmp(s,s+n/d,n-n/d);d--)

n;

ลองออนไลน์!

Haskell , 49 ไบต์

g x=sum[1|a<-[1..length x],drop a x++take a x==x]

ลองออนไลน์!

Haskell , 49 ไบต์

g x=sum[1|(a,_)<-zip[1..]x,drop a x++take a x==x]

ลองออนไลน์!

คำอธิบาย

นี่ใช้วิธีแก้ปัญหาง่าย ๆ @ 0 ' เนื่องจากการหมุนของสตริงเป็นกลุ่มวงจรองค์ประกอบเรียงลำดับสูงสุดจะเท่ากับขนาดของกลุ่มดังนั้นเราจึงสามารถหาลำดับหน่วยได้โดยหาจำนวนการหมุนแบบสมมาตร

รหัสที่เรียบง่ายจะทำความเข้าใจกับรายการและนับจำนวนการหมุนที่เก็บรักษาสตริงเดิม