Di Pokemon ada 18 jenis:

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

Pokemon dapat memiliki pengetikan tunggal atau ganda. Misalnya, Pikachu adalah Electric, dan Tyranitar adalah Rock/Dark. Urutan jenisnya tidak masalah. Pokemon tidak dapat memiliki tipe yang sama dua kali. Langkah menyerang memiliki tepat salah satu dari 18 jenis di atas.

• Beberapa tipe Pokémon lemah terhadap jenis serangan tertentu. Misalnya, FirePokemon lemah terhadap Waterserangan. Ini memberikan pengganda kerusakan 2.

• Beberapa tipe Pokemon tahan terhadap jenis serangan tertentu. Misalnya, RockPokemon tahan terhadap Normalserangan. Ini memberikan pengali kerusakan 0,5.

• Beberapa tipe Pokémon kebal terhadap jenis serangan tertentu. Misalnya, FlyingPokemon kebal terhadap Groundserangan. Ini memberikan pengganda kerusakan 0.

Pokemon bisa dua kali lipat lemah, dua kali lipat kebal atau kombinasi lainnya terhadap tipe serangan. Lipat gandakan pengganda untuk mendapatkan efektivitas total.

Tulis program atau fungsi yang memberikan tipe gerakan dan hasil pengetikan Pokemon menghasilkan pengganda kerusakan total dari serangan. Pengetikan Pokémon selalu ditulis sebagai Aatau A/B, di mana Adan Bmerupakan tipe yang berbeda dari daftar di atas. Anda harus menerima pengetikan Pokemon dalam format ini. Selain dari pembatasan ini, Anda dapat mengambil input dengan cara yang wajar. Contoh format input yang dapat diterima adalah:

"Ice", "Dragon/Flying"

Tapi ini tidak bisa diterima:

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

Output Anda harus persis salah satu dari string berikut, diikuti oleh baris tambahan opsional:

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

Contohnya

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

Ketik efektivitas

Untuk bagan tipe ramah-manusia, saya ingin merujuk Anda ke Gamepedia . Untuk membuat proses golf sedikit lebih cepat, saya akan memberikan Anda matriks efektifitas terkompresi yang ramah komputer. Bagilah setiap angka dengan dua untuk mendapatkan pengganda yang benar (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

Kode terpendek dalam byte menang.

Pyth - 246 245 188 byte

Mengkodekan matriks dengan kompresi dasar, mungkin akan menggunakan pengindeksan / hashing modular untuk indeks matriks tapi sekarang saya belum melakukan sesuatu yang mewah dengan itu.

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 .

Java, 663 639 582 byte

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

Ada meja pencarian sederhana yang memakan banyak ruangan. Itu hanya menemukan jenis yang benar dan mengalikannya. Sebut saja seperti ini:

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

Dengan beberapa jeda baris terlihat seperti ini:

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

Saya belum melihat kompresi jenis yang baik, jadi ini salah satunya.

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

Tidak Disatukan:

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

Oh, dan inilah bagan saya (ingat itu dipesan sehingga surat tidak akan cocok dengan kata-kata yang tercantum di bawahnya):

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

Pikalang, 868068 byte

Ini terlalu bagus untuk dilewati. ( Terima kasih, mbomb007. )

Ini pada dasarnya tabel pencarian yang kurang optimal. Saya pertama kali mengkodekan setiap jenis sebagai

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

Ini menghasilkan representasi unik untuk setiap jenis. Jenis kosong (ketika pokemon yang membela hanya memiliki satu jenis) dikodekan sebagai 0x00.

Setelah itu saya hanya menggunakan kekacauan yang if-elsesetara untuk memeriksa semua ~ 5800 kombinasi.

Kode

Stack Exchange tidak mengizinkan saya memposting kode secara keseluruhan, jadi ini dia gzipped + base64'd.

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

Contoh

Rupanya penerjemah resmi Pikalang belum siap, tetapi karena ini adalah pengganti Brainfuck yang sepele, saya mengujinya menggunakan penerjemah Brainfuck.

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

Input dipisahkan oleh baris baru dan memerlukan baris tambahan tambahan baru.

Program ini menggunakan lokasi memori -1, jadi jika penerjemah Anda tidak diizinkan keluar dari sisi kiri kaset, tambahkan kode dengan a pipiatau a >(masing-masing untuk Pikalang dan Brainfuck).

Brainfuck, 193708

Berikut adalah program yang sama di Brainfuck (juga + gzped base64'd).

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

Program ini berisi empat bagian:

1. Input. Membaca jenis dan menghitung pengidentifikasi mereka.
2. Pembuatan teks. Menghasilkan string untuk masing-masing output yang mungkin.
3. Tabel pencarian. Bagian ini dibuat oleh komputer (lihat di bawah). Memindahkan pointer ke hasil yang benar.
4. Hasil. Hanya mencetak hasilnya.

Struktur program utama

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

Berikut skrip yang menghasilkan tabel pencarian:

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)

BTW, jawaban ini membutuhkan 29.817 byte. :)

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

Masukan harus berupa stdin dan dalam bentuk Normal, Rock/Dragon

Versi langsung .

Dengan spasi putih:

#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...]

Skrip berisi data terkompresi termasuk byte non-UTF-8. Berikut ini skrip persis yang dikodekan dalam basis 64:

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

Menggunakan zlibperintah untuk kompresi.

Lua, 758 661 633 byte

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

Tidak Disatukan:

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

Sebut saja dengan f("Grass","Water/Flying")

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

Format input adalah tipe bergerak dan tipe Pokemon, dipisahkan oleh spasi. Misalnya Fire Grass, atau Water Steel/Electric.

Tabel disimpan adalah string di mana indeks masing-masing karakter berada dalam kisaran 40 hingga 103 dan mewakili 3 jenis kombinasi. Daftar jenis disimpan sebagai karakter ke-3 dan ke-4 (jika ada) dari masing-masing jenis, yang dibandingkan dengan karakter ke-3 dan ke-4 dari setiap jenis yang dimasukkan.

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

Input sampel:

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

Output sampel:

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