Una rotazione "si ottiene dividendo una stringa in due pezzi e invertendo il loro ordine" . Un oggetto è simmetrico sotto un'operazione se l'oggetto rimane invariato dopo aver applicato detta operazione. Quindi, una "simmetria rotazionale" è il fatto che una stringa rimane invariata dopo "rotazione".

Data una stringa non vuota scomposta da sole lettere da aa z, emette il più alto ordine di simmetria rotazionale della stringa.

Casi test:

input        output
a            1
abcd         1
abab         2
dfdfdfdfdfdf 6

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

Retina , 15 byte

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

Provalo online!

Corrisponde all'intera stringa ripetendo una sottostringa (le sottostringhe più brevi hanno la priorità a causa della non gradazione .+?) e sostituisce l'intera stringa con il numero di ripetizioni che abbiamo usato.

Gelatina , 3 byte

ṙJċ

Provalo online!

05AB1E , 8 byte

gGDÀ})QO

Provalo online!

Spiegazione

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 byte

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

Trova il primo indice diverso da zero di sin s+sper capire fino a che punto dobbiamo ruotarlo per tornare sindietro, quindi dividi la lunghezza di sper quel numero. Basato su idee che ho visto altrove .

Prolog (SWI) , 64 byte

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

Provalo online!

Definisce un predicato +/2che accetta una stringa (sotto forma di un elenco di codici carattere) come primo argomento ( A) e imposta il secondo argomento ( B) sull'ordine della rotazione simmetrica di ordine più elevato.

Spiegazione

Questo programma utilizza il fatto che l'insieme di rotazioni simmetriche su una stringa sono un gruppo ciclico e quindi l'ordine dell'insieme di rotazioni simmetriche è uguale all'ordine della rotazione simmetrica di ordine più elevato. Pertanto, il programma è in grado di calcolare il risultato desiderato trovando il numero totale di rotazioni simmetriche sulla stringa di input.

Spiegazione del codice

La maggior parte del sollevamento pesante viene effettuata tramite una chiamata al findall/3predicato. Il findall/3predicato trova tutti i diversi valori possibili per il primo argomento ( Xin questo caso) in modo tale che l'espressione fornita come secondo argomento sia vera ( (append(X,Y,A),append(Y,X,A)), più su questo più avanti). Infine memorizza ciascuno di questi possibili valori di Xcome elenco nell'argomento finale ( [_|Z]).

L'espressione passata findall/3come secondo arugment, (append(X,Y,A),append(Y,X,A))usa il append/3predicato per specificare che Xconcatenato con alcuni ancora indefiniti Ydeve essere uguale a A, la stringa di input e che anche lo stesso Yconcatenato Xdeve essere uguale a A. Ciò significa che Xdeve essere un prefisso Atale che se viene rimosso dalla parte anteriore Ae aggiunto alla parte posteriore, la stringa risultante è la stessa di A. L'insieme di Xs con questa proprietà ha quasi una corrispondenza uno a uno con le rotazioni simmetriche di A. Esiste sempre esattamente un caso di doppio conteggio che è causato dal fatto che sia la stringa vuota che i Aprefissi sonoAche corrisponde alla rotazione 0 di A. Poiché la 0rotazione di Aè sempre simmetrica, la lunghezza dell'elenco risultante di Xs da findall/3sarà uno maggiore del numero di rotazioni simmetriche su A.

Per risolvere il problema del doppio conteggio, utilizzo il pattern matching sul terzo argomento del findall/3predicato. In Prolog le liste sono rappresentate come coppie della loro testa (il primo elemento) e della coda (il resto). [_|Z]Rappresenta quindi un elenco la cui coda è uguale è uguale a Z. Ciò significa che la lunghezza di Zè uno in meno del numero di prefissi trovati dal findall/3predicato e quindi uguale al numero di rotazioni simmetriche di A. Infine, uso il length/2predicato per impostare Bla lunghezza di Z.

JavaScript (ES6), 42 41 byte

Salvato 1 byte grazie a @ l4m2

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

Casi test

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

Japt , 7 byte

¬x@¥UéY

Provalo online!

Spiegazione

 ¬ 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 byte

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

Provalo online!

PHP, 67 byte

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

Provalo online!

C (gcc) , 59 byte

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

n;

Provalo online!

Haskell , 49 byte

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

Provalo online!

Haskell , 49 byte

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

Provalo online!

Spiegazione

Questo utilizza la semplice soluzione @ 0 'sottolineata. Poiché le rotazioni della stringa formano un gruppo ciclico, l'elemento di ordine più alto è uguale alla dimensione del gruppo, quindi possiamo ottenere l'ordine dell'unità trovando il numero di rotazioni simmetriche.

Il semplice codice comprende una lista e conta il numero di rotazioni che preservano la stringa originale.