Algunas tarjetas comerciales tienen un valor real y se pueden vender por dinero. Doblar las cartas está mal visto porque les quita su valor y las hace parecer menos nuevas. Digamos que tienes una baraja de cartas coleccionables (Pokémon, Magia, etc.) y quieres barajarlas. En lugar de hacer el puente que dobla todas las cartas, otra forma simple de barajar cartas es ponerlas en pilas. Esto es lo que quiero decir.

Antecedentes

Con un mazo de 60 cartas que necesita barajar, puede separar las 60 cartas en tres montones de 20 cartas. Hay varias formas de hacer esto, la más simple es colocar una carta en la pila A, luego una en la pila B, luego una en la pila C. Otra forma es poner una carta en la pila C, luego B, luego A. También hay formas de distribuir las cartas en las pilas de manera desigual. Aquí hay una: pon una carta en la pila A, pon otra carta en A, luego pon una carta en la pila B, luego pon una carta en la pila C.

Desafío

Cree un programa completo que se generará evensi una determinada forma de barajar en pilas distribuye las cartas en las pilas de manera uniforme y, de lo unevencontrario , genera y el número de cartas en cada pila.

Entrada

La entrada se tomará a través de STDIN o la alternativa más cercana (sin funciones).

[sequence] [deck size]

• sequenceEs una cadena de caracteres. Le dice al patrón que las cartas se colocan en las pilas. Cada personaje diferente corresponde a una sola pila. Esta cadena siempre estará por debajo del tamaño del mazo y contendrá solo letras mayúsculas AZ.
• deck sizees un número entero que especifica cuántas cartas hay en el mazo. Si el tamaño del mazo es 60, el número de cartas en el mazo es 60.

Salida

even

Si el número de cartas en cada pila al final de la baraja es el mismo, su programa debería mostrar esto.

uneven [pile1] [pile2] [...]

Si el número de cartas en cada pila al final de las barajas no es el mismo, su programa debería generar uneveny la cantidad de cartas en cada pila de esta manera: uneven 20 30si la pila A contiene 20 canrds y la pila B contiene 30. El orden del los números de pila no importan.

Otra información

• Este es un desafío de código de golf, por lo que gana el código más corto en bytes el 25 de septiembre. Si hay un empate en el recuento de bytes, el código que se envió primero gana.
• Su programa debe ser un programa, no una función.
• Si es posible, incluya un enlace a un intérprete en línea o un enlace a un lugar donde pueda descargar un intérprete para su idioma en su respuesta.
• Cualquier cosa que no especifique en este desafío es un juego justo, lo que significa que si no lo digo, depende de ti. Si algo es vago, dígame y editaré la respuesta en consecuencia. (Espero que esto sea más fácil que mi último desafío).

Ejemplos

     Input | Output | Alternate outputs (if uneven)
           |
    ABC 30 | even
    ABC 31 | uneven 11 10 10 | uneven 10 11 10 | uneven 10 10 11
    BCA 60 | even
    BBA 24 | uneven 8 16 | uneven 16 8
ABACBC 120 | even
  BBABA 50 | uneven 20 30 | uneven 30 20
  AABBB 12 | even

Pyth, 33 31 bytes

jd+>"uneven"yK!tl{J/L@LzQ{z*J!K

Entrada de ejemplo:

ABACBC
120

Python 3.x, 106 128 138 bytes

s,n=input().split()
n=int(n)
t=(s*n)[:n]
*z,=map(t.count,set(t))
b=z[:-1]!=z[1:];print("un"*b+"even",*z*b)

Esto duplica la secuencia de entrada (más veces de lo necesario, lo cual es lo suficientemente bueno) y luego toma solo los primeros ncaracteres. Estos se cuentan y se elige uneveno even, y si es el primero, también se imprimen los recuentos print(*z), que se desempacan automáticamente zpara mí.

¡Ahorró 32 bytes gracias a xnor y Sp3000!

Además, Python 3.5 tiene una nueva característica que permite esta solución de 102 bytes:

s,n=input().split()
n=int(n)
t=(s*n)[:n]
*z,=map(t.count,{*t})
b=len({*z})>1;print("un"*b+"even",*z*b)

len({*z})>1desempaqueta la lista z, crea un conjunto a partir de ella, luego verifica si tiene más de un elemento. Es {*z}específicamente que es nuevo.

CJam, 35 bytes

rri_@*<$e`0f=_)-"uneven":Ua@+S*U2>?

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

Cómo funciona

rri      e# Read a string (s) and an integer (n) from STDIN.
_@       e# Push a copy of n and rotate s on top of it.
*        e# Repeat s n times.
<        e# Keep only the first n characters.
$e`      e# Sort and perform run-length encoding.
0f=      e# Keep only the multiplicities.
_)-      e# Push a copy, pop the last element and remove its remaining occurrences.
         e# The result with be an empty array (falsy) iff all elements are equal.
"uneven" e# Push that string.
:Ua      e# Save it in U and wrap it in an array.
@+       e# Concatenate ["uneven"] with the array of multiplicities.
S*       e# Join, separating by spaces.
U2>      e# Push "even".
?        e# Select the result depending on whether _)- pushed an empty array.