Se le da un entero no negativo no base (base 9) que consta de los dígitos del 0 al 8 como de costumbre. Sin embargo, el número de dígitos en este número (sin ceros a la izquierda) es un cuadrado perfecto.

Debido a esto, el número se puede organizar en una cuadrícula cuadrada (con el orden de lectura aún conservado).

Ejemplo con 1480 (1125 base 10):

14
80

Ahora deje que cada dígito en una cuadrícula no tanary indique un movimiento a otro espacio de cuadrícula (con condiciones de contorno periódicas ):

432
501
678

Esto esta diciendo que

0 = stay still
1 = move right
2 = move right and up
3 = move up
...
8 = move right and down

Entonces, si en la cuadrícula de 1480 comienzas en el 4, luego te mueves hacia arriba (recuerda pbc) y hacia la izquierda hacia el 8, lo que significa que te mueves hacia la derecha y hacia abajo hacia el 4, comenzando un ciclo con el período 2.

En general, este proceso continúa hasta llegar a 0 o se nota un ciclo. (A 0 se considera un ciclo con período 1).

En el caso de 1480, el período finalmente alcanzado en cada uno de los 4 dígitos iniciales es 2 2 2 1respectivamente.

Para una cuadrícula más grande, estos números pueden ser mayores que 8, pero aún podemos usarlos como "dígitos" en un nuevo número nonario (simplemente los coeficientes de 9 ^ n como si fueran dígitos):

2*9^3 + 2*9^2 + 2*9 + 1 = 1639 (base 10) = 2221 (base 9)

Llamaremos a esto la fuerza del número nonario original. Entonces, la fuerza de 1480 es 1639 (base 10) o, equivalentemente, 2221 (base 9).

Desafío

Escriba el programa más corto que diga si la fuerza de un número nonario es mayor, menor o igual que el número nonary en sí. (No es necesario que calcules la fuerza).

La entrada será un número nonario no negativo que contiene un número cuadrado de dígitos (y no ceros a la izquierda además del caso especial de 0). Debe provenir de la línea de comando o stdin.

La salida debería ir a stdout como:

G if the strength is larger than the original number (example: 1480 -> strength = 2221)
E if the strength is equal to the original number (example: 1 -> strength = 1)
L if the strength is less than the original number (example: 5 -> strength = 1)

Desafío de bonificación divertida: ¿
Cuál es el mayor aporte que puedes encontrar que es igual a su fuerza? (¿Hay un límite?)

Pitón 2, 213 209 202

Editar: Se eliminó el cortocircuito, que a veces es incorrecto. Vea abajo.

(En gran medida) El mismo algoritmo que @KSab, pero muy golfizado.

n=`input()`
s=int(len(n)**.5)
c=0
for i in range(s*s):
 a=[]
 while(i in a)<1:a+=[i];x='432501678'.find(n[i]);i=(i+x%3-1)%s+((i/s+x/3-1)%s)*s
 c=c*9+len(a)-a.index(i)
d=long(n,9)
print'EGL'[(c>d)-(c<d)]

Golfs:

• 213: Solución defectuosa de cortocircuito.

• 209: primera solución de trabajo.

• 202: Combinó las dos búsquedas de cuerdas en una.

Editar: Acabo de darme cuenta de que este programa, y ​​por lo tanto también el de KSab, tenían fallas porque ignoran las longitudes de ciclo de varios dígitos. Ejemplo de falla:

3117
2755
3117
7455

Mientras que el 3 tiene una duración de ciclo de 2, y por lo tanto el algoritmo anterior hace un cortocircuito a 'L', esto debería de hecho devolver 'G', porque la longitud de ciclo de 14 en el segundo dígito supera con creces eso. Por lo tanto, he cambiado el programa. También se hizo más corto, curiosamente. Para probar su programa, use 3117275531177455. Debería volver G.

Python 296

En realidad no es demasiado ineficiente, solo verifica tantos dígitos como sea necesario.

n=raw_input();s=int(len(n)**.5);t=0
for i in range(s**2):
    l=[]
    while i not in l:l.append(i);c=n[i];i=(i%s+(-1 if c in'456'else 1 if c in'218'else 0))%s+((i/s+(-1 if c in'432'else 1 if c in'678'else 0))%s)*s
    t=t*9+len(l)-l.index(i)
print'EGL'[cmp(t,long(n,9))]

En cuanto a los números iguales a su fuerza, creo que las únicas soluciones son, para cada N x N cuadrado hasta N = 8 un cuadrado que contiene N en cada espacio. Mi opinión es que, dado que cada número en un bucle debe ser el mismo número (la longitud del bucle) cada bucle debería estar en una sola dirección. Por supuesto, esto significa que el tamaño del bucle debe ser N (y cada elemento debe ser N). Estoy bastante seguro de que esta lógica se puede aplicar a cuadrados y bucles de cualquier tamaño, lo que significa que no hay cuadrados iguales a su fuerza que no sean los primeros 8.

CJam - 81

q:X,:L,{[L2*{_[_Lmqi:Smd@X=432501678s#3md]2/z{~+(S+S%}%Sb}*]L>_&,\X=~-}%9bg"EGL"=

Pruébalo en http://cjam.aditsu.net/

Probablemente se pueda jugar más al golf.

Lua - Todavía no ha jugado golf

Solo poniéndome aquí para su custodia. Lo jugaré (e implementaré el "Para una cuadrícula más grande, estos números pueden ser mayores que 8, pero aún podemos usarlos como" dígitos "") más adelante. Funciona sin embargo.

d={{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1}}
d[0]={0,0}ssd=''
n=arg[1]
q=math.sqrt(#n)t={}

    for y=1,q do
    table.insert(t,y,{})
    for x =1,q do
        v=(y-1)*q+x
        table.insert(t[y],x,n:sub(v,v)+0)
        io.write(t[y][x])
    end
end
for y=1,q do
    for x=1,q do
        cx=x cy=y pxy=''sd=0
        while pxy:match(cx..':%d*:'..cy..' ')==nil do
            pxy=pxy..cx..':'..sd..':'..cy.." "
            ccx=cx+d[t[cx][cy]][2]
            ccy=cy+d[t[cx][cy]][1]
            cx=ccx cy=ccy
            if cx<1 then cx=q elseif cx>q then cx=1 end
            if cy<1 then cy=q elseif cy>q then cy=1 end
            sd=sd+1
        end
        dds=(pxy:sub(pxy:find(cx..':%d+:'..cy)):match(':%d*'))
        ssd=ssd..(sd-dds:sub(2))
    end
end
print(ssd)
nn=tonumber(n,9) tn=tonumber(ssd,9)
if tn>nn then print("G") elseif tn==nn then print("E") else print("L") end