Una rotación "se realiza dividiendo una cuerda en dos partes e invirtiendo su orden" . Un objeto es simétrico bajo una operación si el objeto no cambia después de aplicar dicha operación. Entonces, una "simetría rotacional" es el hecho de que una cadena permanece sin cambios después de la "rotación".

Dada una cadena no vacía que sconsta de solo letras de aa z, genera el orden más alto de la simetría rotacional de la cadena.

Casos de prueba:

input        output
a            1
abcd         1
abab         2
dfdfdfdfdfdf 6

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

Retina , 15 bytes

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

Pruébalo en línea!

Coincide con la cadena completa repitiendo una subcadena (las subcadenas más cortas se priorizan debido a la falta de gravedad .+?) y reemplaza la cadena completa con el número de repeticiones que usamos.

Jalea , 3 bytes

ṙJċ

Pruébalo en línea!

05AB1E , 8 bytes

gGDÀ})QO

Pruébalo en línea!

Explicación

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 bytes

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

Encuentra el primer índice no nulo de sen s+saveriguar hasta qué punto hay que girar para obtener sla espalda, y luego dividir la longitud de spor ese número. Basado en ideas que vi en otros lugares .

Prólogo (SWI) , 64 bytes

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

Pruébalo en línea!

Define un predicado +/2que toma una cadena (en forma de una lista de códigos de caracteres) como su primer argumento ( A) y establece su segundo argumento ( B) en el orden de la rotación simétrica de mayor orden.

Explicación

Este programa utiliza el hecho de que el conjunto de rotaciones simétricas en una cadena es un grupo cíclico y, por lo tanto, el orden del conjunto de rotaciones simétricas es igual al orden de la rotación simétrica de mayor orden. Por lo tanto, el programa puede calcular el resultado deseado al encontrar el número total de rotaciones simétricas en la cadena de entrada.

Explicación del código

La mayor parte del trabajo pesado se realiza mediante una llamada al findall/3predicado. El findall/3predicado encuentra todos los diferentes valores posibles para el primer argumento ( Xen este caso) de modo que la expresión dada como el segundo argumento sea verdadera ( (append(X,Y,A),append(Y,X,A))más sobre eso más adelante). Finalmente, almacena cada uno de estos posibles valores de Xcomo una lista en el argumento final ( [_|Z]).

La expresión que se pasa findall/3como el segundo argumento, (append(X,Y,A),append(Y,X,A))usa el append/3predicado para especificar que Xconcatenado con algo aún indefinido Ydebe ser igual a A, la cadena de entrada, y que el mismo Yconcatenado Xtambién debe ser igual a A. Esto significa que Xdebe ser un prefijo de Atal manera que si se elimina del frente Ay se agrega a la parte posterior, la cadena resultante es la misma que A. El conjunto de Xs con esta propiedad casi tiene una correspondencia uno a uno con las rotaciones simétricas de A. Siempre hay exactamente un caso de doble conteo que se debe al hecho de que tanto la cadena vacía como Alos prefijos deAque corresponden a la rotación 0 de A. Dado que la 0rotación de Asiempre es simétrica, la longitud de la lista resultante de Xs findall/3será mayor que la cantidad de rotaciones simétricas en A.

Para resolver el problema del conteo doble, utilizo la coincidencia de patrones en el tercer argumento del findall/3predicado. En Prolog, las listas se representan como pares de su cabeza (el primer elemento) y su cola (el resto). Por lo tanto, [_|Z]representa una lista cuya cola es igual a Z. Esto significa que la longitud de Zes menor que el número de prefijos encontrados por el findall/3predicado y, por lo tanto, igual al número de rotaciones simétricas de A. Finalmente, uso el length/2predicado para establecer Bla longitud de Z.

JavaScript (ES6), 42 41 bytes

Guardado 1 byte gracias a @ l4m2

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

Casos de prueba

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 bytes

¬x@¥UéY

¡Pruébelo en línea!

Explicación

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

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

Pruébalo en línea!

PHP, 67 bytes

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

Pruébalo en línea!

C (gcc) , 59 bytes

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

n;

Pruébalo en línea!

Haskell , 49 bytes

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

Pruébalo en línea!

Haskell , 49 bytes

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

Pruébalo en línea!

Explicación

Esto utiliza la solución simple @ 0 'señalada. Dado que las rotaciones de la cadena forman un grupo cíclico, el elemento de orden más alto es el mismo que el tamaño del grupo, por lo que podemos obtener el orden de la unidad al encontrar el número de rotaciones simétricas.

Los códigos simples hacen una comprensión de la lista y cuentan el número de rotaciones que preservan la cadena original.