¡Es súper efectivo!

42

¡Es súper efectivo!

En Pokémon hay 18 tipos:

Normal    Fighting  Flying  Poison  Ground  Rock
Bug       Ghost     Steel   Fire    Water   Grass
Electric  Psychic   Ice     Dragon  Dark    Fairy

Un Pokémon puede tener mecanografía simple o doble. Por ejemplo, Pikachu es Electricy Tyranitar es Rock/Dark. El orden de los tipos no importa. Un Pokémon no puede tener el mismo tipo dos veces. Un movimiento de ataque tiene exactamente uno de los 18 tipos anteriores.

  • Algunos tipos de Pokémon son débiles para un cierto tipo de ataque. Por ejemplo, un FirePokémon es débil contra los Waterataques. Esto da un multiplicador de daño de 2.

  • Algunos tipos de Pokémon son resistentes a cierto tipo de ataque. Por ejemplo, un RockPokémon es resistente a un Normalataque. Esto da un multiplicador de daño de 0.5.

  • Algunos tipos de Pokémon son inmunes a cierto tipo de ataque. Por ejemplo, un FlyingPokémon es inmune a un Groundataque. Esto da un multiplicador de daño de 0.

Un pokemon puede ser doblemente débil, doblemente resistente o cualquier otra combinación contra un tipo de ataque. Multiplica los multiplicadores para obtener una efectividad total.

Escribe un programa o función que tenga un tipo de movimiento y un tipo de Pokémon genera el multiplicador de daño total del ataque. La tipificación de Pokémon siempre se escribe como Ao A/B, where Ay Bson tipos distintos de la lista anterior. Debes aceptar el Pokémon escribiendo en este formato. Aparte de esta restricción, puede tomar aportes de cualquier manera razonable. Un formato de entrada de ejemplo que es aceptable es:

"Ice", "Dragon/Flying"

Pero esto es inaceptable:

["Ice", ["Dragon", "Flying"]]

Su salida debe ser exactamente una de las siguientes cadenas, seguida de una nueva línea final opcional:

0x    0.25x    0.5x    1x    2x    4x

Ejemplos

Ground, Fire -> 2x
Normal, Rock/Dragon -> 0.5x
Fighting, Ghost/Steel -> 0x
Steel, Water/Steel -> 0.25x
Ice, Dragon/Flying -> 4x
Water, Ground/Water -> 1x
Ghost, Ghost -> 2x

Tipo de efectividad

Para obtener una tabla de tipo amigable para los humanos, me gustaría referirlo a Gamepedia . Para que el proceso de golf sea un poco más rápido, le daré una matriz de efectividad comprimida y amigable con la computadora. Divide cada número entre dos para obtener el verdadero multiplicador (1 -> 0.5, 4 -> 2):

              Defending type
               (same order)

   Normal   222221201222222222
   Fighting 421124104222214241
A  Flying   242221421224122222
t  Poison   222111210224222224
t  Ground   220424124421422222
a  Rock     214212421422224222
c  Bug      211122211124242241
k  Ghost    022222242222242212
i  Steel    222224221112124224
n  Fire     222221424114224122
g  Water    222244222411222122
   Grass    221144121141222122
T  Electric 224202222241122122
y  Psychic  242422221222212202
p  Ice      224242221114221422
e  Dragon   222222221222222420
   Dark     212222242222242211
   Fairy    242122221122222442

El código más corto en bytes gana.

orlp
fuente
44
¡Me encantan los desafíos basados ​​en videojuegos!
kirbyfan64sos
77
Prefiero fingir que el tipo de hada no existe. Pokémon solo empeora cuanto más agregan.
mbomb007
34
PPCG usó CJam! ¡Es súper efectivo! ¡PPCG usó Java! No es muy efectivo ...
Fatalize
10
No hagas caso al viejo mbomb007, pequeño Togekiss. Todo el mundo sabe que eres mejor con Fairy typing.
Geobits
44
¡Alguien debería escribir una respuesta en Pikalang ! (Buena suerte.)
mbomb007

Respuestas:

16

Pyth - 246 245 188 bytes

Codifica la matriz con compresión base, probablemente usará indexación / hashing modular para los índices de la matriz, pero en este momento no he hecho nada elegante con ellos.

Lxc"NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai"3<b3.F"{:g}x"*Fm@@c19cR2KXjC"
©ªªå´ê۩涪©Y+ªº;oªnz®©Z»­*«ªºj«¥fëª×­ª¯«Z¥ö]©ªâªÖ»ªj*î¥zzªªj«ªº«¥¹ªZ«ë¥ª¾"4]3]4yzydcw\/

Test Suite .

Maltysen
fuente
10
¿Estás seguro de que es un programa y no un ruido de línea?
Marcar el
17

Java, 663639582 bytes

String f(String...a){float d=1;for(String B:a[1].split("/"))d*=("222221201222222222421124104222214241242221421224122222222111210224222224220424124421422222214212421422224222211122211124242241022222242222242212222224221112124224222221424114224122222244222411222122221144121141222122224202222241122122242422221222212202224242221114221422222222221222222420212222242222242211242122221122222442".charAt(g(a[0])*18+g(B))-48)*.5;return(d+"x").replace(".0","");}int g(String a){int i=0;for(;i<18;i++)if(a.contains("N,gh,ly,oi,ou,ck,B,ho,S,re,W,G,E,P,I,g,k,y".split(",")[i]))break;return i;}

Hay una tabla de búsqueda simple que ocupa gran parte de la habitación. Simplemente encuentra los tipos correctos y los multiplica. Llámalo así:

f("Water","Ground/Fire")

Con algunos saltos de línea se ve así:

String f(String...a){
    float d=1;
    for(String B:a[1].split("/"))
        d*=("222221201222222222421124104222214241242221421224122222222111210224222224220424124421422222214212421422224222211122211124242241022222242222242212222224221112124224222221424114224122222244222411222122221144121141222122224202222241122122242422221222212202224242221114221422222222221222222420212222242222242211242122221122222442"
                .charAt(g(a[0])*18+g(B))-48)*.5;
    return(d+"x").replace(".0","");
}

int g(String a){
    int i=0;
    for(;i<18;i++)
        if(a.contains("N,gh,ly,oi,ou,ck,B,ho,S,re,W,G,E,P,I,g,k,y".split(",")[i]))
            break;
    return i;
}
Geobits
fuente
1
Puede c="222...442".split(",");
reducir
Correcto. No estoy seguro de por qué lo hice para uno y no para el otro: /
Geobits
quieres explicarnos esto? Estoy muy interesado pero no entiendo lo que está pasando lol :)
duxfox--
2
¿Podría reducir los bytes for(String B:b)haciendo que su ciclo for pase de 24 a 15, ahorrando 9 y convirtiéndose [b[i++]]en B7 para ahorrar más? ¡Total de 16 ahorros!
corsiKa
1
@ Luminoso No estoy seguro de eso. Desde que regreso i, necesitaría restar uno más tarde o iniciarlo en -1, lo que anularía ese byte guardado.
Geobits
9

JavaScript (ES6), 287

No he visto una buena compresión de los tipos, así que aquí hay uno.

(a,b)=>b.split('/').reduce((j,p)=>j*[0,.5,1,2][parseInt("kjwhcgnj2xd6elihtlneemw82duxijsazl3sh4iz5akjmlmsqds06xf1sbb8d0rl1nu7a2kjwi3mykjwlbpmk1up4mzl1iuenedor0bdmkjwmpk6rhcg4h3en3pew5".substr((g=x=>[..."BWSEIRNulkcDPotyeG"].findIndex(c=>x.match(c)))(a)*7,7),36).toString(4)[g(p)]],1)+'x'

Sin golf:

(a,b)=>{
  // keys is a list of letters found in the types of attacks/defenses
  keys = [..."BWSEIRNulkcDPotyeG"]; 

  // getIndex is a single case statement.
  // it checks each of keys, one-by-one, falling through until we've found the proper index
  getIndex=x=>keys.findIndex(c=>x.match(c));

  // encodedValues is a list, indexed by `keys`, where each value is 7-characters.
  encodedValues = "kjwhcgnj2xd6elihtlneemw82duxijsazl3sh4iz5akjmlmsqds06xf1sbb8d0rl1nu7a2kjwi3mykjwlbpmk1up4mzl1iuenedor0bdmkjwmpk6rhcg4h3en3pew5";

  // the 7-character value (e.g., B=0="kjwhcgn", W=1="j2xd6el") were created by 
  // turning base4 values into base36, so let's turn this back into a string the same way
  valuesForAttack = parseInt(encodedValues.substr(getIndex(a)*7,7),36).toString(4);

  // valuesForAttack is indexed by defenseType.  The value will be 0..3, depending on the multiplier

  // let's get an array of the multipliers and reduce...
  multiplier = b.split('/').reduce((oldMultiplier,defenseType)=>oldMultiplier * [0,.5,1,2][valuesForAttack[getIndex(defenseType)]],1);

  return multiplier+'x';
}

Ah, y aquí está mi tabla (teniendo en cuenta que está ordenada para que una letra no coincida con ninguna de las palabras que figuran debajo):

"Bug" => "B",
"Water" => "W",
"Steel" => "S",
"Electric" => "E",
"Ice" => "I",
"Rock" => "R",
"Normal" => "N",
"Ground" => "u",
"Flying" => "l",
"Dark" => "k",
"Psychic" => "c",
"Dragon" => "D",
"Poison" => "P",
"Ghost" => "o",
"Fighting" => "t",
"Fairy" => "y",
"Fire" => "e",
"Grass" => "G"
No es que Charles
fuente
¡Buen trabajo! Tuve una idea similar, ¡pero tú lo hiciste primero!
MayorMonty
1
Si codifica su cadena de valores ya codificada con atob, puede guardar 26 bytes al usar btoaeso. Cuando lo codifique, solo asegúrese de agregar un carácter adicional, ya que "...pew5"se "...peww=="debe a la alineación de bytes.
SLuck49
@ SLuck49 Gracias. Lo probé y parece que tiene menos caracteres pero más bytes. ¿Estoy haciendo algo mal?
No es que Charles
Dispara, tienes razón, estaba mirando el recuento de caracteres en lugar del recuento de bytes ... estúpidos caracteres UTF-8 de varios bytes.
SLuck49
@ SLuck49 Es probable que haya una mejor manera de codificar los multiplicadores. Hay mucho espacio desperdiciado con todos los 2.
No es que Charles
9

Pikalang, 868068 bytes

Esta era una idea demasiado buena para omitirla. ( Gracias, mbomb007. )

Básicamente es una tabla de búsqueda subóptima. Primero codifico cada tipo como

((first_char + second_char * 2 + third_char * 3) mod 256) - 0x3c

Esto da como resultado representaciones únicas para cada tipo. El tipo vacío (cuando el pokemon defensor tiene un solo tipo) se codifica como0x00 .

Después de eso solo uso un lío de if-else equivalentes para verificar todas las combinaciones ~ 5800.

Código

Stack Exchange no me permitió publicar el código como un todo, así que aquí está gzipped + base64'd.

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

Ejemplo

Aparentemente, el intérprete oficial de Pikalang aún no está listo, pero como es una sustitución trivial de Brainfuck, lo probé con un intérprete de Brainfuck.

$ base64 -d supereff.pokeball.gz.b64 > supereff.pokeball.gz
$ gunzip supereff.pokeball.gz
$ pikalang supereff.pokeball
Normal
Rock/Dragon
0.5x

La entrada está separada por una nueva línea y requiere una nueva línea adicional.

El programa usa la ubicación de memoria -1, por lo que si su intérprete no permite salir del lado izquierdo de la cinta, anteponga el código con una pipio una> (para Pikalang y Brainfuck, respectivamente).

Brainfuck, 193708

Aquí está el mismo programa en Brainfuck (también gzipped + base64'd).

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

El programa contiene cuatro partes:

  1. La entrada Lectura de los tipos y cálculo de sus identificadores.
  2. La generación de texto. Generando cadenas para cada una de las salidas posibles.
  3. La tabla de búsqueda. Esta parte fue generada por computadora (ver más abajo). Mueve el puntero al resultado correcto.
  4. La salida. Solo imprimo el resultado.

Estructura principal del programa

,>,[-<++>],[-<+++>] read first type id
++++++[-<---------->] subtract 3c
+[,----------] skip until newline
>,>,[-<++>],[-<+++>] read second type id
++++++[-<---------->] subtract 3c
>- set @LOOPFLAG@ to get into loop
[
 >-< set @CHARFLAG@
 <,---------- get character; newline is 00 slash is 25
 [ was not newline
  ------------------------------------- slash is now 00
  [ was not slash
   >>+<< reset @CHARFLAG@
   [-] clear character
  ]
 ]
 >>[ was newline or slash (@CHARFLAG@ set)
  <+>+ reset @LOOPFLAG@ and @CHARFLAG@
 ]<
]
,>,[-<++>],[-<+++>] read third type id
<[->+>+<<]>[-<+>] copy third to @CHARFLAG@
>[ if @CHARFLAG@ is set
 [-] clear @CHARFLAG@
 <++++++[-<---------->]> subtract 3c from third
]<
++++++++[- do 8 times
 >++++++ put a 0 here
 >+++++++++++++++ put an x here
 >>++++++ put a 0 here
 >++++++ put a 0 here
 >++++++ put a 0 here
 >+++++++ put a 8 here
 >+++++++++++++++ put an x here
 >>++++++ put a 0 here
 >++++++ put a 0 here
 >+++++++ put a 8 here
 >+++++++++++++++ put an x here
 >>++++++ put a 0 here
 >+++++++++++++++ put an x here
 >>++++++ put a 0 here
 >+++++++++++++++ put an x here
 >>++++++ put a 0 here
 >+++++++++++++++ put an x here
 <<<<<<<<<<<<<<<<<<<<<< go back
]
>>>>>-- change 0 to dot
>++ change 0 to 2
>--- change 8 to 5
>>>>-- change 0 to dot
>--- change 8 to 5
>>>+ change 0 to 1
>>>++ change 0 to 2
>>>++++ change 0 to 4
<<<<<<<<<<<<<<<<<<<<<< go back
(lookup table here)
>[.>] print result

Aquí está el script que genera la tabla de búsqueda:

typemap = [[int(value, 16), name] for value, name in [
    ["00", "(Nothing)"],
    ["02", "Ice"],
    ["07", "Fairy"],
    ["0f", "Dragon"],
    ["10", "Electric"],
    ["11", "Fighting"],
    ["12", "Grass"],
    ["1d", "Rock"],
    ["20", "Dark"],
    ["25", "Bug"],
    ["28", "Ghost"],
    ["2d", "Poison"],
    ["2e", "Steel"],
    ["32", "Fire"],
    ["39", "Water"],
    ["3c", "Ground"],
    ["46", "Normal"],
    ["4d", "Flying"],
    ["65", "Psychic"]
]]
multipliers = {
    0: 5,
    0.25: 8,
    0.5: 14,
    1: 19,
    2: 22,
    4: 25
}
types = [
    "Normal", "Fighting", "Flying", "Poison", "Ground", "Rock", "Bug", "Ghost", "Steel",
    "Fire", "Water", "Grass", "Electric", "Psychic", "Ice", "Dragon", "Dark", "Fairy"
]
results = [
    [2, 2, 2, 2, 2, 1, 2, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2],
    [4, 2, 1, 1, 2, 4, 1, 0, 4, 2, 2, 2, 2, 1, 4, 2, 4, 1],
    [2, 4, 2, 2, 2, 1, 4, 2, 1, 2, 2, 4, 1, 2, 2, 2, 2, 2],
    [2, 2, 2, 1, 1, 1, 2, 1, 0, 2, 2, 4, 2, 2, 2, 2, 2, 4],
    [2, 2, 0, 4, 2, 4, 1, 2, 4, 4, 2, 1, 4, 2, 2, 2, 2, 2],
    [2, 1, 4, 2, 1, 2, 4, 2, 1, 4, 2, 2, 2, 2, 4, 2, 2, 2],
    [2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 4, 2, 4, 2, 2, 4, 1],
    [0, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 4, 2, 2, 1, 2],
    [2, 2, 2, 2, 2, 4, 2, 2, 1, 1, 1, 2, 1, 2, 4, 2, 2, 4],
    [2, 2, 2, 2, 2, 1, 4, 2, 4, 1, 1, 4, 2, 2, 4, 1, 2, 2],
    [2, 2, 2, 2, 4, 4, 2, 2, 2, 4, 1, 1, 2, 2, 2, 1, 2, 2],
    [2, 2, 1, 1, 4, 4, 1, 2, 1, 1, 4, 1, 2, 2, 2, 1, 2, 2],
    [2, 2, 4, 2, 0, 2, 2, 2, 2, 2, 4, 1, 1, 2, 2, 1, 2, 2],
    [2, 4, 2, 4, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 0, 2],
    [2, 2, 4, 2, 4, 2, 2, 2, 1, 1, 1, 4, 2, 2, 1, 4, 2, 2],
    [2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 4, 2, 0],
    [2, 1, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 4, 2, 2, 1, 1],
    [2, 4, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 4, 4, 2]
]
def getMultiplier(first, second, third):
    id1 = types.index(first)
    id2 = types.index(second)
    if third in types:
        id3 = types.index(third)
        return results[id1][id2] * results[id1][id3] / 4;
    else:
        return results[id1][id2] / 2

def genFirstType(second, third, remain, removed):
    mul = getMultiplier(remain[0][1], second, third)
    if len(remain) == 1:
        result = "[ first is not " + removed[1] + "\n"
        result += "thus first must be " + remain[0][1] + "\n"
        result += ">" * (multipliers[mul] - 1) + "[-]-> " + str(mul).replace(".", "").rstrip("0") + "x multiplier\n"
        result += "]\n"
        return result
    elif not removed:
        result = "<<" + "-" * remain[0][0] + " " + remain[0][1] + " is now 00\n"
        result += genFirstType(second, third, remain[1:], remain[0])
        result += "<+[ first is " + remain[0][1] + "\n"
        result += ">" * multipliers[mul] + "[-] " + str(mul).replace(".", "").rstrip("0") + "x multiplier\n"
        result += "]->\n"
        return result
    else:
        result = "[ first is not " + removed[1] + "\n"
        result += "-" * (remain[0][0] - removed[0]) + " " + remain[0][1] + " is now 00\n"
        result += genFirstType(second, third, remain[1:], remain[0])
        result += "<+[ first is " + remain[0][1] + "\n"
        result += ">" * multipliers[mul] + "[-] " + str(mul).replace(".", "").rstrip("0") + "x multiplier\n"
        result += "]->\n"
        result += "]\n"
        return result
def genSecondType(third, remain, removed):
    if len(remain) == 1:
        result = "[ second is not " + removed[1] + "\n"
        result += "thus second must be " + remain[0][1] + "\n"
        result += genFirstType(remain[0][1], third, typemap[1:], False)
        result += "]\n"
        return result
    elif not removed:
        result = "<<" + "-" * remain[0][0] + " " + remain[0][1] + " is now 00\n"
        result += genSecondType(third, remain[1:], remain[0])
        result += "<+[-> second is " + remain[0][1] + "\n"
        result += genFirstType(remain[0][1], third, typemap[1:], False)
        result += "<+]->\n"
        return result
    else:
        result = "[ second is not " + removed[1] + "\n"
        result += "-" * (remain[0][0] - removed[0]) + " " + remain[0][1] + " is now 00\n"
        result += genSecondType(third, remain[1:], remain[0])
        result += "<+[-> second is " + remain[0][1] + "\n"
        result += genFirstType(remain[0][1], third, typemap[1:], False)
        result += "<+]->\n"
        result += "]\n"
        return result
def genThirdType(remain, removed):
    if len(remain) == 1:
        result = "[ third is not " + removed[1] + "\n"
        result += "thus third must be " + remain[0][1] + "\n"
        result += genSecondType(remain[0][1], [item for item in typemap[1:] if item[1] != remain[0][1]], False)
        result += "]\n"
        return result
    elif not removed:
        result = "-" * remain[0][0] + " " + remain[0][1] + " is now 00\n"
        result += genThirdType(remain[1:], remain[0])
        result += "<+[-> third is " + remain[0][1] + "\n"
        result += genSecondType(remain[0][1], [item for item in typemap[1:] if item[1] != remain[0][1]], False)
        result += "<+]->\n"
        return result
    else:
        result = "[ third is not " + removed[1] + "\n"
        result += "-" * (remain[0][0] - removed[0]) + " " + remain[0][1] + " is now 00\n"
        result += genThirdType(remain[1:], remain[0])
        result += "<+[-> third is " + remain[0][1] + "\n"
        result += genSecondType(remain[0][1], [item for item in typemap[1:] if item[1] != remain[0][1]], False)
        result += "<+]->\n"
        result += "]\n"
        return result
def genLookup():
    return genThirdType(typemap, False)

def compact(code):
    import re
    return re.sub(r"[^+\-<>\[\],.]", "", code)
def golfStep(code):
    return code.replace("><", "").replace("<>", "").replace("+-", "").replace("-+", "")
def golf(code):
    previous = golfStep(code)
    while previous != code:
        previous, code = code, golfStep(code)
    return code

if __name__ == "__main__":
    import sys
    result = genLookup()
    if "-g" in sys.argv:
        print(golf(compact(result)))
    elif "-c" in sys.argv:
        print(compact(result))
    else:
        print(result)

Por cierto, esta respuesta toma 29817 bytes. :)

PurkkaKoodari
fuente
¿Realmente, el intérprete no está listo? ¿Qué hay de aquí ?
mbomb007
@ mbomb007 Bueno, al menos el que vinculaste antes no lo era. No estoy seguro de eso (BFC), no enumera Pikalang en la página principal y tampoco estoy seguro de si funciona (depende de que analice los espacios correctamente, PIPIpodría interpretarse como >o ++). También BFC aparentemente requeriría mayúsculas en el código.
PurkkaKoodari
Gracias @ Pietu1998 por hacer la versión pikalang. ¡divertidísimo! ahora si pudiera encontrar el tiempo para terminar este idioma como quiero en lugar de la manera rápida y sucia. Gracias de nuevo
groteworld
5

C ++ 14, 420 416

#include<iostream>
#include<string>
std::string m,t,n="NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai";int i;int main(){std::cin>>m>>t;auto k=[](auto y){return(i=6*n.find(m.substr(0,3))+n.find(y.substr(0,3))/3,i="J:2JJJ;YQJV>N:;ZIJJ5&ZJZ*[Y;KJVF;KZJ6I6YN>HJNJNFJZ:EYZJ:[UZIJ^J7JI:]9=JIZBJ>IINK:JFBZN:U:KJJ:JJ+FJNJN6NI:IJO"[i/3]-32>>i%3*2&3,i+i/3)/2.;};std::cout<<k(t)*((i=t.find(47)+1)?k(t.substr(i)):1)<<"x";}

La entrada debe ser stdin y estar en la forma Normal, Rock/Dragon

Versión en vivo .

Con algo de espacio en blanco:

#include<iostream>
#include<string>
std::string m, t, n = "NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai";
int i;
int main(){
    std::cin >> m >> t;
    auto k = [](auto y){
        return(i = 6 * n.find(m.substr(0, 3)) + n.find(y.substr(0, 3)) / 3
            , i = "J:2JJJ;YQJV>N:;ZIJJ5&ZJZ*[Y;KJVF;KZJ6I6YN>HJNJNFJZ:EYZJ:[UZI"
            "J^J7JI:]9=JIZBJ>IINK:JFBZN:U:KJJ:JJ+FJNJN6NI:IJO"[i / 3] - 32 >> i % 3 * 2 & 3
            , i + i / 3) / 2.;
    }; 
    std::cout << k(t)*((i = t.find(47) + 1) ? k(t.substr(i)) : 1) << "x";
}
Mattnewport
fuente
3

Tcl, 382

proc p a\ d [zlib i ...361 bytes...]

El script contiene datos comprimidos que incluyen bytes que no son UTF-8. Aquí está el script exacto codificado en la base 64:

cHJvYyBwIGFcIGQgW3psaWIgaSDFU7FugzAQ/ZU3pEuGlljqwlilibpUUVw7dEBc
Zo7jghUHI9uREiH+vUDA2NCqY2SJXDt87969XDvb5dkaXCTfSp+oxUN2QWKZjOPm
L1dlHC9RLetEnmiJPRJTSmGxOOApRSVFceAXVNVcbsOKHp/bb28nq0ZFeswtTm4+
SJBPhkiDX7nYEBmYSVijw6489l5Jx3/Dj0pIj47GWp0lXh2fN6w9R5FcdHasP1dE
HH7oMVxupkRmfpfn+lx298NOHXOADmbqKXcT9NDE1Se/dDFiRybiT7rb+Sunm1xb
0J1fwceOM/JcIoEfBaz+HVx0XHt0XjCROa/T587wvxPx7+dU4TS/wdQ1Emk41SxH
9d4+NomNyHIrilxmG3ltzU5cdKNcbmy1OhcHfCh2xMs5wzZXxuLTct6maI4varlu
YNQYvErOrBZcZlw7c2V5Y98Yx1rTrCFaU1x9xIZcblx9rbGg6Z0F7NM6TdMfXQ== 

Utiliza el zlibcomando para la compresión.

Johannes Kuhn
fuente
Eso no es realmente un script tcl válido ahora, ¿verdad?
slebetman
1
@slebetman Es el script tcl codificado en base64.
orlp
2
¿Quieres explicar lo que hace?
No es que Charles
3

LUA, 758 661 633 bytes

m={"222221201222222222","421124104222214241","242221421224122222","222111210224222224","220424124421422222","214212421422224222","211122211124242241","022222242222242212","222224221112124224","222221424114224122","222244222411222122","221144121141222122","224202222241122122","242422221222212202","224242221114221422","222222221222222420","212222242222242211","242122221122222442"}s="NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai"function f(a,d)z=string.sub n=tonumber _,r=s:find(z(a,1,3))r=r/3g,_,c=0,s:find(z(d,1,3))c=c/3p=d:find("/")or 0 e=m[r]_,g=s:find(z(d,p+1,p+3))g=g/3r=n(z(e,c,c))/2r=r*n(z(e,g,g))/2print(r.."x")end

Sin golf:

m={"222221201222222222","421124104222214241","242221421224122222","222111210224222224","220424124421422222","214212421422224222","211122211124242241","022222242222242212","222224221112124224","222221424114224122","222244222411222122","221144121141222122","224202222241122122","242422221222212202","224242221114221422","222222221222222420","212222242222242211","242122221122222442"}
s="NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai"
function f(a,d)
    z=string.sub
    n=tonumber
    _,r=s:find(z(a,1,3))
    r=r/3
    g,_,c=0,s:find(z(d,1,3))
    c=c/3
    p=d:find("/") or 0
    e=m[r]
    _,g=s:find(z(d,p+1,p+3))
    g=g/3
    r=n(z(e,c,c))/2
    r=r*n(z(e,g,g))/2
    print(r.."x")
end

Llámalo con f("Grass","Water/Flying")

Nikolai97
fuente
Creo que podría mejorar usando el valor de mdirectamente, ya que solo se hace referencia una vez.
Ivo Beckers
A menos que te malinterprete, guardar el acceso ma ees más barato porque ese usa un par de veces.
Nikolai97
No . Me refiero a no usar m en absoluto. Elimine la línea 'm =' y reemplace 'e = m [r]' pegando toda la tabla en lugar de m
Ivo Beckers
Ah bien, creo que entiendo. ¿Te refieres a algo como esto e={...}[r]:? Porque intenté eso y no es legal: /
Nikolai97
Sí, quise decir eso. Supongo que me equivoco entonces. Pensé que sería legal
Ivo Beckers
2

Python 3 - 362

k,*l=['rm gh yi is ou ck g os ee re te as ec yc e ag rk ir'.split().index(x[2:4])for x in input().replace('/',' ').split()]
s=[[0,0.5,1,2][[(ord(m)-40)//4**q%4 for m in'RB:RRRCaYR^FVBCbQRR=.bRb2caCSR^NCSbR>Q>aVFPRVRVNRbBMabRBc]bQRfR?RQBeAERQbJRFQQVSBRNJbVB]BSRRBRR3NRVRV>VQBQRW'for q in(0,1,2)][k*18+z]]for z in l]
v=s[0]*(s[1:]or[1])[0]
print(str(v//1+v%1)+'x')

El formato de entrada es el tipo de movimiento y el tipo de Pokémon, separados por espacios. Por ejemplo Fire Grass, o Water Steel/Electric.

La tabla almacenada es una cadena donde el índice de cada personaje está en el rango de 40 a 103 y representa 3 combinaciones de tipos. La lista de tipos se almacena como los caracteres tercero y cuarto (si existe) de cada tipo, que se comparan con los caracteres tercero y cuarto de cada tipo ingresado.

faubi
fuente
Creo que puedes afeitarte algunos caracteres usando en 'rmghyiis...'.find(x[2:4])//2lugar de"rm gh yi is ...".split().index(x[2:4])
Blckknght
Oh, eso no funciona para los desnudos ey los gpersonajes ... tal vez se podrían usar prefijos de tres letras y aún tendrías algunos ahorros en .find(...)//3comparación con.split().index(...)
Blckknght
3
Genial, pero no creo que siga las reglas de entrada? Las reglas parecen bastante específicas acerca de requerir /entre los dos tipos de Pokémon de doble tipo, por ejemplo Steel/Electric.
mattnewport
Oh, me perdí eso. Ahora acepta el formato de entrada adecuado.
faubi
1

PHP, 426

eval('f('.fgets(STDIN).');');
function f($a,$d){
    $x=1;$r=array_fill_keys(explode('/',$d),$a);
    while(list($d,$a)=each($r)) {
        $x*=substr(gmp_strval(gmp_init('26gXl6oUL8Ekoey31DRp2k1Jq85b0G3f1PsFPfEnL1P6Bxh4vSloX8zWWa4XPBAGavHMKLgaGhPp2JPA3qQI3L9kkQ4kSHvu2vm76aLpJmu6TV8qcPTO0hchrLRh6G9',62),5),n($a)*18+n($d),1)/2;
    }
    echo$x.'x';
}
function n($p){return strpos('NorFigFlyPoiGroRocBugGhoSteFirWatGraElePsyIceDraDarFai',substr($p,0,3))/3;}

Entrada de muestra:

"Ground", "Fire"
"Normal", "Rock/Dragon"
"Fighting", "Ghost/Steel"
"Steel", "Water/Steel"
"Ice", "Dragon/Flying"
"Water", "Ground/Water"
"Ghost", "Ghost"

Salida de muestra:

2x
0.5x
0x
0.25x
4x
1x
2x
Fausak oxidado
fuente