Alguns cromos têm valor real e podem ser vendidos por dinheiro. Dobrar as cartas é desaprovado, porque tira seu valor e as faz parecer menos novas. Digamos que você tenha um baralho de cartas (Pokémon, Magia etc.) e queira embaralhá-las. Em vez de fazer a ponte que dobra todas as cartas, outra maneira simples de embaralhar as cartas é colocá-las em pilhas. Aqui está o que eu quero dizer.

fundo

Com um baralho de 60 cartas que precisa ser baralhado, você pode separar as 60 cartas em três pilhas de 20 cartas. Existem várias maneiras de fazer isso, sendo a mais simples colocar uma carta na pilha A, depois uma na pilha B, depois uma na pilha C. Outra maneira é colocar uma carta na pilha C, depois B e depois A. também existem maneiras de espalhar os cartões pelas pilhas de maneira desigual. Aqui está um: coloque um cartão na pilha A, coloque outro cartão em A, depois coloque um cartão na pilha B e depois coloque um cartão na pilha C.

Desafio

Crie um programa completo que produzirá evense uma certa maneira de se agrupar em pilhas espalhar as cartas nas pilhas uniformemente, e as saídas unevene o número de cartas em cada pilha de outra forma.

Entrada

A entrada será feita através do STDIN ou da alternativa mais próxima (sem funções).

[sequence] [deck size]

• sequenceé uma sequência de caracteres. Diz o padrão em que as cartas são colocadas nas pilhas. Cada caractere diferente corresponde a uma única pilha. Essa string sempre estará abaixo do tamanho do deck e conterá apenas letras maiúsculas AZ.
• deck sizeé um número inteiro que especifica quantas cartas estão no baralho. Se o tamanho do baralho for 60, o número de cartas no baralho é 60.

Resultado

even

Se o número de cartões em cada pilha no final do shuffle for o mesmo, seu programa deverá produzir isso.

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

Se o número de cartões em cada pilha no final dos shuffles não for o mesmo, seu programa deverá gerar uneveno número de cartões em cada pilha assim: uneven 20 30se a pilha A contiver 20 canrds e a pilha B contiver 30. A ordem das números de pilha não importa.

Outra informação

• Esse é um desafio de código de golfe, portanto o código mais curto em bytes de 25 de setembro vence. Se houver um empate na contagem de bytes, o código enviado primeiro vence.
• Seu programa deve ser um programa, não uma função.
• Se possível, inclua um link para um intérprete on-line ou um link para um local onde eu possa baixar um intérprete para o seu idioma na sua resposta.
• Qualquer coisa que eu não especifique nesse desafio é um jogo justo, ou seja, se eu não digo, é com você. Se algo for vago, diga-me e editarei a resposta de acordo. (Espero que isso corra mais bem do que meu último desafio.)

Exemplos

     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

Pitão, 33 31 bytes

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

Exemplo de entrada:

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)

Isso duplica a sequência de entrada (mais vezes do que o necessário, o que é bom o suficiente) e pega apenas os primeiros ncaracteres. Eles são contados e um unevenou evené escolhido e, se o primeiro, as contagens também são impressas print(*z), o que é descompactado automaticamente zpara mim.

Economizou 32 bytes graças ao xnor e Sp3000!

Além disso, o Python 3.5 possui um novo recurso que permite esta solução 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})>1descompacta a lista z, faz um conjunto e verifica se há mais de um elemento. É {*z}especificamente isso que é novo.

CJam, 35 bytes

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

Experimente on-line no intérprete CJam .

Como 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.