隐功率计算器

Question

我一直喜欢“口袋妖怪”的原因之一是，对于这样一个看似简单的游戏，它有很多复杂的层次。让我们考虑一下隐藏力量的移动。在游戏中，隐藏力量的类型和能力(至少在第六代之前)对于每一个使用它的精灵都是不同的！挺酷的对吧？现在，如果我告诉你隐藏力量的类型和力量不是随机产生的，你会感到惊讶吗？

在所有的口袋妖怪游戏中，所有的口袋妖怪(不仅仅是你所在的团队中的所有口袋妖怪)都有六个内部存储的整数(一个用于HP属性，一个用于攻击属性，一个用于防御属性，一个用于特殊攻击属性，一个用于特殊防御属性，一个用于速度属性)。这些值介于0到31之间，它们基本上是影响口袋妖怪总体统计的几个因素之一。然而，他们也决定了隐藏力量的类型和力量！

在第三代至第五代(我们将实现其算法的世代)中，隐藏功率的类型由以下公式决定(注意方括号，这意味着需要对结果进行舍入)：

其中a，b，c，d，e和f是HP，攻击，防御，速度，Sp中最不重要的部分。进攻，还有Sp。防御IVs。(最不重要的位是IV mod 2。)在此生成的数字可以使用此图表转换为实际类型：

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

对于权力，使用了类似的公式：

然而，在这里，u，v，w，x，y和z代表了HP，攻击，防御，速度，Sp中第二个最不重要的部分。攻击和攻击。防御IV(再次按这个顺序)。(第二，最不重要位比最不重要位更复杂。如果IV mod 4为2或3，则位为1，否则为0。如果您的语言有某种内置的或者至少是一种更聪明的方法来实现这一点，那么您可能应该使用它。)

所以，正如您可能已经知道的，这里的挑战是编写一个程序，通过STDIN (表示HP、攻击、防御、速度、Sp )用空格分隔六个整数。攻击和攻击。防御口袋妖怪的IVs (按这个顺序)，并输出该精灵的隐藏力量的类型和力量。

样本输入：

30 31 31 31 30 31

样本输出：

Grass 70

样本输入：

16 18 25 13 30 22

样本输出：

Poison 61

这是密码-高尔夫，所以最短的代码获胜。祝好运!

(在人们问我之前，我在这里使用了第五代算法，因为第六代摆脱了幂随机化，使它始终是60。我不仅认为这是令人难以置信的蹩脚之处，而且我认为这会使挑战变得不那么有趣。因此，为了挑战的目的，我们正在运行第五代游戏。)

Answer 1

Pyth，110个字节

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

这包含不可打印的字符。所以这里有个妖怪：

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  -#...?....O@.J/m
00000060: d2 ca c6 23 22 32 36 29 47 33 2b 33 30 48        ...#"26)G3+30H

您还可以下载文件pokemon.pyth并使用python3 pyth.py pokemon.pyth运行它。

输入30, 31, 31, 31, 30, 31打印

Grass
70

解释：

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

Answer 2

Javascript (ES6)，251字节

有点长，至少现在是这样。类型列表和复杂的数学所占的空间大致相同。我正在寻找缩短两者之一的方法。

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))

如往常一样，欢迎您提出建议！

Answer 3

Javascript (ES6)，203个字节

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))

示例运行：

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

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