У покемонов есть 18 видов:

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

Покемон может иметь одинарный или двойной тип ввода. Например, Пикачу есть Electric, а Тиранитар есть Rock/Dark. Порядок типов не имеет значения. У покемона не может быть одного и того же типа дважды. Атакующий ход имеет ровно один из перечисленных выше 18 типов.

• Некоторые типы покемонов слабы для определенного типа атаки. Например, FireПокемон слаб против Waterатак. Это дает множитель урона 2.

• Некоторые типы покемонов устойчивы к определенному типу атак. Например, RockПокемон устойчив к Normalатаке. Это дает множитель урона 0,5.

• Некоторые типы покемонов невосприимчивы к определенному типу атак. Например, FlyingПокемон невосприимчив к Groundатаке. Это дает множитель урона 0.

Покемон может быть вдвойне слабым, вдвойне стойким или любой другой комбинацией против атакующего типа. Умножьте множители, чтобы получить полную эффективность.

Напишите программу или функцию с заданным типом хода и типом покемона, который выводит множитель общего урона атаки. Типирование покемонов всегда пишется либо как, Aлибо A/B, где Aи Bявляются отличными типами из списка выше. Вы должны принять ввод покемонов в этом формате. Помимо этого ограничения, вы можете принять участие любым разумным способом. Пример допустимого формата ввода:

"Ice", "Dragon/Flying"

Но это недопустимо

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

Ваш вывод должен быть точно одной из следующих строк, сопровождаемых дополнительным завершающим переводом строки:

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

Примеры

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

Тип эффективности

Для удобной для человека типовой диаграммы я бы хотел отослать вас в Gamepedia . Чтобы ускорить процесс игры в гольф, я дам вам сжатую компьютерную матрицу эффективности. Разделите каждое число на два, чтобы получить истинный множитель (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

Самый короткий код в байтах побеждает.

Pyth - 246 245 188 байт

Кодирует матрицу с базовым сжатием, вероятно, будет использовать модульное индексирование / хеширование для индексов матрицы, но сейчас я ничего такого не сделал.

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

Тестовый пакет .

Java, 663 639 582 байта

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;}

Есть простой справочный стол, который занимает большую часть комнаты. Он просто находит правильные типы и умножает их. Назовите это так:

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

С некоторыми переносами строк это выглядит так:

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;
}

JavaScript (ES6), 287

Я не видел хорошего сжатия типов, так что вот один.

(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'

Ungolfed:

(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';
}

О, и вот мой график (помните, что он упорядочен так, чтобы буква не соответствовала ни одному из перечисленных ниже слов):

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

Пикаланг, 868068 байт

Это была слишком хорошая идея, чтобы пропустить. ( Спасибо, mbomb007. )

Это в основном неоптимальная таблица поиска. Я сначала кодирую каждый тип как

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

Это приводит к уникальным представлениям для каждого типа. Пустой тип (когда защищающийся покемон имеет только один тип) кодируется как 0x00.

После этого я просто использую кучу if-elseэквивалентов, чтобы проверить все ~ 5800 комбинаций.

Код

Stack Exchange не позволил мне опубликовать код в целом, так что вот он gzipped + base64'd.

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

пример

Видимо, официальный переводчик Пикаланга еще не готов, но, поскольку это тривиальная замена Brainfuck, я протестировал его с помощью интерпретатора Brainfuck.

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

Ввод разделен новой строкой и требует дополнительного завершающего перевода новой строки.

Программа использует ячейку памяти -1, поэтому, если ваш интерпретатор не разрешает уходить с левой стороны ленты, добавьте код с помощью a pipiили a >(для Pikalang и Brainfuck соответственно).

Brainfuck, 193708

Вот та же самая программа в Brainfuck (также gzipped + base64'd).

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

Программа состоит из четырех частей:

1. Вход. Чтение типов и вычисление их идентификаторов.
2. Генерация текста. Генерация строк для каждого из возможных выходов.
3. Таблица поиска. Эта часть была сгенерирована компьютером (см. Ниже). Перемещает указатель на правильный результат.
4. Выход. Просто распечатать результат.

Основная структура программы

,>,[-<++>],[-<+++>] 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

Вот скрипт, который генерирует таблицу поиска:

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)

Кстати, этот ответ занимает 29817 байт. :)

С ++ 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";}

Ввод должен быть в стандартный ввод и должен быть в форме Normal, Rock/Dragon

Живая версия .

С некоторыми пробелами:

#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";
}

Tcl, 382

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

Скрипт содержит сжатые данные, включая байты не-UTF-8. Вот точный скрипт, закодированный в базе 64:

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

Использует zlibкоманду для сжатия.

Lua, 758 661 633 байта

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

Ungolfed:

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

Позвони с f("Grass","Water/Flying")

Питон 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')

Формат ввода - это тип перемещения и тип Pokemon, разделенные пробелами. Например Fire Grass, или Water Steel/Electric.

В таблице хранится строка, где индекс каждого символа находится в диапазоне от 40 до 103 и представляет 3 комбинации типов. Список типов хранится в виде 3-го и 4-го (если он существует) символов каждого типа, которые сравниваются с 3-м и 4-м символами каждого введенного типа.

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;}

Пример ввода:

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

Пример вывода:

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