Uma das razões pelas quais eu sempre amei Pokemon é porque, para um jogo tão simples, ele tem muitas camadas de complexidade. Vamos considerar o movimento Hidden Power. No jogo, o tipo e o poder (pelo menos antes da Geração VI) de Hidden Power é diferente para cada Pokémon que o usa! Isso é bem legal, né? Agora, você ficaria surpreso se eu lhe dissesse que o tipo e o poder do Hidden Power não são gerados aleatoriamente?

Em todos os jogos de Pokemon, todos os Pokémon (não apenas os do seu grupo, ALL POKEMON) têm seis números inteiros armazenados internamente (um para o status da HP, um para o status do ataque, um para o status do ataque, um para o status da defesa, um para o status especial do ataque, um para o status de defesa especial e outro para o status de velocidade) denominavam seus valores individuais, ou IVs. Esses valores variam entre 0 e 31, e são essencialmente um dos poucos fatores que influenciam as estatísticas gerais de um Pokémon. No entanto, eles também determinam o tipo e o poder do poder oculto!

Nas gerações III a V (as gerações cujo algoritmo iremos implementar), o tipo de potência oculta é determinado pela seguinte fórmula (observe os colchetes, isso significa que você precisa arredondar o resultado):

onde a, b, c, d, e ef são os bits menos significativos do HP, Ataque, Defesa, Velocidade, Sp. Ataque e Sp. IVs de defesa, respectivamente. (O bit menos significativo é IV mod 2.) O número produzido aqui pode ser convertido no tipo real usando este gráfico:

0 Fighting
1 Flying
2 Poison
3 Ground
4 Rock
5 Bug
6 Ghost
7 Steel
8 Fire
9 Water
10 Grass
11 Electric
12 Psychic
13 Ice
14 Dragon
15 Dark

Para poder, uma fórmula semelhante é usada:

Aqui, no entanto, u, v, w, x, ye z representam o segundo bit menos significativo do HP, Attack, Defense, Speed, Sp. Ataque e Sp. IVs de defesa (nessa ordem novamente). (O segundo bit menos significativo é mais complicado que o bit menos significativo. Se o IV mod 4 for 2 ou 3, o bit será 1, caso contrário, será 0. Se o seu idioma tiver algum tipo de recurso interno ou pelo menos uma maneira mais inteligente para fazer isso, você provavelmente deve usá-lo.)

Então, como você provavelmente já descobriu, o desafio aqui é escrever um programa que inclua seis números inteiros separados por espaços via STDIN que representem HP, Ataque, Defesa, Velocidade, Sp. Ataque e Sp. Defende IVs de um Pokémon (nessa ordem) e produz o tipo e o poder do Hidden Power desse Pokémon.

Entrada de amostra:

30 31 31 31 30 31

Saída de amostra:

Grass 70

Entrada de amostra:

16 18 25 13 30 22

Saída de amostra:

Poison 61

Isso é código-golfe, então o código mais curto vence. Boa sorte!

(E antes que as pessoas perguntem, eu usei o algoritmo da Geração V aqui porque a Geração VI se livra da randomização de potência e a torna sempre 60. Não apenas acho que isso é incrivelmente idiota, como também torna o desafio MUITO INTERESSANTE. para os propósitos do desafio, estamos executando um jogo da Geração V.)

Pitão, 110 bytes

J+dGA.b/*iN2CY63Cm_+0jd2_Q"("r@cs@LJjC"!�W��Zm�����A�zB0i��ȏ\"���?wC�ǀ�-#ך
?ЫܦO@�J/m���#"26)G3+30H

Isso contém caracteres não imprimíveis. Então aqui está um hexdump:

00000000: 4a 2b 64 47 41 2e 62 2f 2a 69 4e 32 43 59 36 33  J+dGA.b/*iN2CY63
00000010: 43 6d 5f 2b 30 6a 64 32 5f 51 22 0f 28 22 72 40  Cm_+0jd2_Q".("r@
00000020: 63 73 40 4c 4a 6a 43 22 10 21 de 57 ad c8 5a 1c  cs@LJjC".!.W..Z.
00000030: 10 6d e0 d6 12 f6 80 bc 41 85 7a 42 30 69 ae 80  .m......A.zB0i..
00000040: c8 8f 5c 22 a0 84 ab 3f 77 43 01 ca c7 80 d0 1d  ..\"...?wC......
00000050: 2d 23 d7 9a 0a 3f d0 ab dc a6 4f 40 b9 4a 2f 6d  -#[email protected]/m
00000060: d2 ca c6 23 22 32 36 29 47 33 2b 33 30 48        ...#"26)G3+30H

Você também pode baixar o arquivo pokemon.pyth e executá-lo compython3 pyth.py pokemon.pyth

A entrada 30, 31, 31, 31, 30, 31imprime

Grass
70

Explicação:

J+dGA.b/*iN2CY63Cm_+0jd2_Q".("
J+dG                            store the string " abc...xyz" in J
                 m      _Q      map each number d in reverse(input list) to:
                     jd2          convert d to base 2
                   +0             add a zero (list must have >= 2 items)
                  _               reverse the list
                C               zip
                          ".("  string with the ascii values 15 and 40
     .b                         map each N of ^^ and Y of ^ to:
         iN2                       convert N from base 2 to base 10
        *   CY                     multiply with the ascii value of Y
       /      63                   and divide by 63
    A                           G, H = ^

r@cs@LJjC"longstring"26)G3+30H
        C"longstring"           interpret the string as bytes and convert 
                                from base 256 to base 10
       j             26         convert to base 26
   s@LJ                         lookup their value in J and create a string
                                this gives "fighting flying ... dark"
  c                    )        split by spaces
 @                      G       take the Gth element
r                        3      make the first letter upper-case and print
                          +30H  print 30 + H

Ruby, 210

a=$*.map.with_index{|a,i|[a.to_i%2<<i,a.to_i[1]<<i]}.transpose.map{|a|a.inject &:+}
$><<"#{%w(Fighting
Flying
Poison
Ground
Rock
Bug
Ghost
Steel
Fire
Water
Grass
Electric
Psychic
Ice
Dragon
Dark)[a[0]*15/63]} #{a[1]*40/63+30}"

Golfe pela primeira vez, acho que essa é uma solução bastante óbvia.

CJam, 140 115 bytes

q~]W%_1f&2bF*63/"GMÿD>BÙl½}YÛöí6P¶;óKs¯¿/·dǯã®Å[YÑÌÞ%HJ9¹G4Àv"256b25b'af+'j/=(euooSo2f/1f&2b40*63/30+

Observe que o código contém caracteres não imprimíveis.

Experimente on-line no intérprete CJam: Chrome | Raposa de fogo

Javascript (ES6), 251 bytes

Meio longo, pelo menos por enquanto. A lista de tipos e a matemática complexa ocupam aproximadamente a mesma quantidade de espaço. Estou procurando maneiras de encurtar os dois.

x=>([a,b,c,d,e,f]=x.split` `,`Fighting
Flying
Poison
Ground
Rock
Bug
Ghost
Steel
Fire
Water
Grass
Electric
Psychic
Ice
Dragon
Dark`.split`
`[(a%2+b%2*2+c%2*4+d%2*8+e%2*16+f%2*32)*5/21|0]+' '+((a/2%2+(b&2)+(c&2)*2+(d&2)*4+(e&2)*8+(f&2)*16)*40/63+30|0))

Como sempre, sugestões são bem-vindas!

Javascript (ES6), 203 bytes

f=(...l)=>(q=(b,m)=>~~(l.reduce((p,c,x)=>p+(!!(c&b)<<x),0)*m/63),'Fighting0Flying0Poison0Ground0Rock0Bug0Ghost0Steel0Fire0Water0Grass0Electric0Psychic0Ice0Dragon0Dark'.split(0)[q(1,15)]+' '+(q(2,40)+30))

Exemplo é executado:

f(30,31,31,31,30,31)
> "Grass 70"

f(16,18,25,13,30,22)
> "Poison 61"