Analizar barajaduras superpuestas

13

Rod está moderando un juego de cartas entre dos jugadores: George y Tim. Actualmente, Tim está barajando las cartas. Rod sospecha que Tim está tratando de hacer trampa, por lo que necesita su ayuda para verificar que la combinación sea justa.

Tim está haciendo la barajadura desordenada: corta un montón de cartas desde la parte inferior del mazo, luego corta varias partes desde la parte superior del montón hasta la parte superior del mazo, y repite el proceso varias veces.

Rod tiene ojos de águila y puede ver exactamente cuántas cartas está cortando Tim cada vez, sin embargo, no puede calcular y hacer un seguimiento de las cartas tan rápido como Tim está barajando. Aquí es donde entras: a Rod le gustaría que escribieras un programa o función que obtenga la información detallada de la barajadura y determine si la barajadura es justa, débil o un truco.

  • Si después de barajar, quedan menos de 25 pares de cartas adyacentes (en el mismo orden), entonces la baraja es justa y el juego puede continuar.
  • Si al menos 25 (pero no todos) pares de cartas adyacentes permanecen adyacentes, entonces el barajado es débil y Rod golpeará a Tim sobre la cabeza y le pedirá que baraje un poco más.
  • Si todas las cartas permanecen en la misma posición al final, entonces Tim obviamente está haciendo trampa y Rod lo golpeará con una trucha grande.

Este es el código de golf, por lo que gana el código más corto.

Entrada:

Obtendrá una serie de números entre 0 y 52 (ambos exclusivos) separados por espacio, en varias líneas, donde cada línea representa una ronda de barajado que comienza y termina con todas las cartas juntas.

En cada línea, el primer número es el número de cartas que Tim corta desde la parte inferior del mazo, y cada número posterior es un número de cartas que deja caer de su mano en la parte superior del mazo. Si quedan cartas después del último número en una línea, debes asumir que Tim las coloca en la parte superior del mazo.

La entrada está garantizada para ser válida. Hay al menos una línea de números, y cada línea contiene al menos 2 números. El primer número en cada línea no es más pequeño que la suma de todos los otros números en la misma línea. Una nueva línea final es opcional, puede suponer que la entrada tiene una o que no la tiene.

Salida:

Su programa debe imprimir / devolver "justo" si la combinación es justa, "débil" si la combinación es débil y "engañar" si Tim mantiene todas las cartas en el mismo orden. Una nueva línea final es opcional.

Ejemplo:

Se supone que el mazo tiene 52 cartas, pero para fines de demostración, usaré un mazo más pequeño de 10 cartas.

Entrada:

5 3 1
4 2 2

Mazo inicial, visto desde arriba: 0 1 2 3 4 5 6 7 8 9
50 1 2 3 4( 5 6 7 8 9en mano)
35 6 7 0 1 2 3 4( 8 9en mano)
18 5 6 7 0 1 2 3 4( 9en mano)
final de línea ➜ 9 8 5 6 7 0 1 2 3 4
49 8 5 6 7 0( 1 2 3 4en mano)
21 2 9 8 5 6 7 0( 3 4en mano)
23 4 1 2 9 8 5 6 7 0
4 pares permanecen adyacentes:(3 4) (1 2) (5 6) (6 7)

Casos de prueba:

43 5 5 5 5 5 5 5 5
43 5 5 5 5 5 5 5 5
43 5 5 5 5 5 5 5 5

Salida: fair


43 5 5 5 5 5 5 5 5
43 5 5 5 5 5 5 5 5
43 5 5 5 5 5 5 5

Salida: weak


29 24
19 18
38 2 1 8 13 6 4
47 15 16 5 2 1 7
34 22 9 3
44 9 10 11 3 1 7
33 18 4 2 3 3

Salida: fair


24 6 12 4
25 3 19
36 4 25 2
19 11 1 3
15 9 3
37 5 27

Salida: weak


26 13
26 13
26 13
26 13

Salida: trick


50 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

Salida: weak


50 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
50 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

Salida: trick


50 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
49 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

Salida: fair

Requisitos:

  • Si escribe una función, puede leer desde la entrada estándar o recibir la entrada como un único parámetro de cadena. Además, la función puede imprimir la salida o devolverla.
  • El programa debe ser ejecutable en Linux utilizando software disponible gratuitamente.
  • El código fuente debe usar solo caracteres ASCII.
  • No hay lagunas estándar.
aditsu renunció porque SE es MALO
fuente
2
¿Por qué la restricción a ASCII? Muchos idiomas (APL, código de máquina, TI-BASIC) no usan ASCII en absoluto, por lo que está implícitamente rechazando esos.
lirtosiast
@ThomasKwa Porque no me gustan los problemas asociados con mostrar y contar caracteres que no son ASCII. Algunos de esos idiomas tienen representaciones o alternativas ASCII. Creo que no es una restricción muy dura, y nivela ligeramente el campo de juego.
Aditsu dejó porque SE es MAL
Creo que un sistema de puntuación como "Entradas que usan solo caracteres ASCII imprimibles tendrá su conteo de bytes multiplicado por log (95) / log (256)" sería una mejor opción si desea incentivar de manera justa las presentaciones ASCII imprimibles. El razonamiento es que el contenido de información de las entradas con el mismo puntaje sería igual. Personalmente, todavía preferiría una puntuación simple por bytes.
lirtosiast
@ThomasKwa Ok, ¿qué tal esto? Solo caracteres unicode imprimibles, contando bytes en la codificación UTF-8
aditsu se cierra porque SE es MAL

Respuestas:

3

Pyth, 62 bytes

@c"weak trick fair"d-!JlfhT-M.:us_cG.u+NYtKrH7-52hK.zU52 2>J26

Demostración.

isaacg
fuente
4

CJam, 76 75 bytes

52,qN/{[~](52\-@/(\e_@{/(@+\e_}/\+}/2ew::m2f/0-,_!\26>-"weak trick fair"S/=

Pruébelo en línea en el intérprete de CJam .

Dennis
fuente
55
LOL, "trucha" :)
Aditsu renunció porque SE es MAL
2

JavaScript, 292 289 bytes

Probablemente esto podría obtener algunos bytes más, pero es un primer paso rápido por ahora:

d=[];for(i=0;i<52;i+=1)d[i]=i
s=prompt().split('\n')
s.forEach(function(e,i){s[i]=e.split(' ')
h=d.splice(-s[i][0],99)
for(j=1;j<s[i].length;j+=1)d.unshift.apply(d,h.splice(0,s[i][j]))
d.unshift.apply(d,h)})
for(c=0;i>1;i-=1)if(d[i-2]==d[i-1]-1)c+=1
alert(c<25?"fair":c<51?"weak":"trick")

EDITAR: se guardaron 3 bytes al reutilizar el valor del ibucle de construcción de mazos al contar el número de cartas adyacentes.

Sean Latham
fuente