En Son Liderlik Tablosu @ 2014-08-02 12:00

| Pos # | Author               | Name                    | Language   | Score | Win   | Draw  | Loss  | Avg. Dec. Time |
+-------+----------------------+-------------------------+------------+-------+-------+-------+-------+----------------+
| 1st   | Emil                 | Pony                    | Python2    | 064   | 064   | 000   | 005   | 0026.87 ms     |
| 2nd   | Roy van Rijn         | Gazzr                   | Java       | 062   | 062   | 001   | 006   | 0067.30 ms     |
| 2nd   | Emil                 | Dienstag                | Python2    | 062   | 062   | 001   | 006   | 0022.19 ms     |
| 4th   | ovenror              | TobiasFuenke            | Python2    | 061   | 061   | 001   | 007   | 0026.89 ms     |
| 5th   | PhiNotPi             | BayesianBot             | Perl       | 060   | 060   | 000   | 009   | 0009.27 ms     |
| 6th   | Claudiu              | SuperMarkov             | Python2    | 058   | 058   | 001   | 010   | 0026.77 ms     |
| 7th   | histocrat            | Alternator              | Ruby       | 057   | 057   | 001   | 011   | 0038.53 ms     |
| 8th   | histocrat            | LeonardShelby           | Ruby       | 053   | 053   | 000   | 016   | 0038.55 ms     |
| 9th   | Stretch Maniac       | SmarterBot              | Java       | 051   | 051   | 002   | 016   | 0070.02 ms     |
| 9th   | Martin Büttner       | Markov                  | Ruby       | 051   | 051   | 003   | 015   | 0038.45 ms     |
| 11th  | histocrat            | BartBot                 | Ruby       | 049   | 049   | 001   | 019   | 0038.54 ms     |
| 11th  | kaine                | ExcitingishBot          | Java       | 049   | 049   | 001   | 019   | 0065.87 ms     |
| 13th  | Thaylon              | UniformBot              | Ruby       | 047   | 047   | 001   | 021   | 0038.61 ms     |
| 14th  | Carlos Martinez      | EasyGame                | Java       | 046   | 046   | 002   | 021   | 0066.44 ms     |
| 15th  | Stretch Maniac       | SmartBot                | Java       | 045   | 045   | 001   | 023   | 0068.65 ms     |
| 16th  | Docopoper            | RoboticOboeBotOboeTuner | Python2    | 044   | 044   | 000   | 025   | 0156.55 ms     |
| 17th  | Qwix                 | Analyst                 | Java       | 043   | 043   | 001   | 025   | 0069.06 ms     |
| 18th  | histocrat            | Analogizer              | Ruby       | 042   | 042   | 000   | 027   | 0038.58 ms     |
| 18th  | Thaylon              | Naan                    | Ruby       | 042   | 042   | 004   | 023   | 0038.48 ms     |
| 20th  | Thaylon              | NitPicker               | Ruby       | 041   | 041   | 000   | 028   | 0046.21 ms     |
| 20th  | bitpwner             | AlgorithmBot            | Python2    | 041   | 041   | 001   | 027   | 0025.34 ms     |
| 22nd  | histocrat            | WereVulcan              | Ruby       | 040   | 040   | 003   | 026   | 0038.41 ms     |
| 22nd  | Ourous               | QQ                      | Cobra      | 040   | 040   | 003   | 026   | 0089.33 ms     |
| 24th  | Stranjyr             | RelaxedBot              | Python2    | 039   | 039   | 001   | 029   | 0025.40 ms     |
| 25th  | JoshDM               | SelfLoathingBot         | Java       | 038   | 038   | 001   | 030   | 0068.75 ms     |
| 25th  | Ourous               | Q                       | Cobra      | 038   | 038   | 001   | 030   | 0094.04 ms     |
| 25th  | Ourous               | DejaQ                   | Cobra      | 038   | 038   | 001   | 030   | 0078.31 ms     |
| 28th  | Luis Mars            | Botzinga                | Java       | 037   | 037   | 002   | 030   | 0066.36 ms     |
| 29th  | kaine                | BoringBot               | Java       | 035   | 035   | 000   | 034   | 0066.16 ms     |
| 29th  | Docopoper            | OboeBeater              | Python2    | 035   | 035   | 002   | 032   | 0021.92 ms     |
| 29th  | Thaylon              | NaanViolence            | Ruby       | 035   | 035   | 003   | 031   | 0038.46 ms     |
| 32nd  | Martin Büttner       | SlowLizard              | Ruby       | 034   | 034   | 004   | 031   | 0038.32 ms     |
| 33rd  | Kyle Kanos           | ViolentBot              | Python3    | 033   | 033   | 001   | 035   | 0032.42 ms     |
| 34th  | HuddleWolf           | HuddleWolfTheConqueror  | .NET       | 032   | 032   | 001   | 036   | 0029.86 ms     |
| 34th  | Milo                 | DogeBotv2               | Java       | 032   | 032   | 000   | 037   | 0066.74 ms     |
| 34th  | Timmy                | DynamicBot              | Python3    | 032   | 032   | 001   | 036   | 0036.81 ms     |
| 34th  | mccannf              | YAARBot                 | JS         | 032   | 032   | 002   | 035   | 0100.12 ms     |
| 38th  | Stranjyr             | ToddlerProof            | Java       | 031   | 031   | 010   | 028   | 0066.10 ms     |
| 38th  | NonFunctional User2..| IHaveNoIdeaWhatImDoing  | Lisp       | 031   | 031   | 002   | 036   | 0036.26 ms     |
| 38th  | john smith           | RAMBOBot                | PHP        | 031   | 031   | 002   | 036   | 0014.53 ms     |
| 41st  | EoinC                | SimpleRandomBot         | .NET       | 030   | 030   | 005   | 034   | 0015.68 ms     |
| 41st  | Martin Büttner       | FairBot                 | Ruby       | 030   | 030   | 006   | 033   | 0038.23 ms     |
| 41st  | Docopoper            | OboeOboeBeater          | Python2    | 030   | 030   | 006   | 033   | 0021.93 ms     |
| 44th  | undergroundmonorail  | TheGamblersBrother      | Python2    | 029   | 029   | 000   | 040   | 0025.55 ms     |
| 45th  | DrJPepper            | MonadBot                | Haskel     | 028   | 028   | 002   | 039   | 0008.23 ms     |
| 46th  | Josef E.             | OneBehind               | Java       | 027   | 027   | 007   | 035   | 0065.87 ms     |
| 47th  | Ourous               | GitGudBot               | Cobra      | 025   | 025   | 001   | 043   | 0053.35 ms     |
| 48th  | ProgramFOX           | Echo                    | .NET       | 024   | 024   | 004   | 041   | 0014.81 ms     |
| 48th  | JoshDM               | SelfHatingBot           | Java       | 024   | 024   | 005   | 040   | 0068.88 ms     |
| 48th  | Trimsty              | Herpetologist           | Python3    | 024   | 024   | 002   | 043   | 0036.93 ms     |
| 51st  | Milo                 | DogeBot                 | Java       | 022   | 022   | 001   | 046   | 0067.86 ms     |
| 51st  | William Barbosa      | StarWarsFan             | Ruby       | 022   | 022   | 002   | 045   | 0038.48 ms     |
| 51st  | Martin Büttner       | ConservativeBot         | Ruby       | 022   | 022   | 001   | 046   | 0038.25 ms     |
| 51st  | killmous             | MAWBRBot                | Perl       | 022   | 022   | 000   | 047   | 0016.30 ms     |
| 55th  | Mikey Mouse          | LizardsRule             | .NET       | 020   | 020   | 007   | 042   | 0015.10 ms     |
| 55th  | ja72                 | BlindForesight          | .NET       | 020   | 020   | 001   | 048   | 0024.05 ms     |
| 57th  | robotik              | Evolver                 | Lua        | 019   | 019   | 001   | 049   | 0008.19 ms     |
| 58th  | Kyle Kanos           | LexicographicBot        | Python3    | 018   | 018   | 003   | 048   | 0036.93 ms     |
| 58th  | William Barbosa      | BarneyStinson           | Lua        | 018   | 018   | 005   | 046   | 0005.11 ms     |
| 60th  | Dr R Dizzle          | BartSimpson             | Ruby       | 017   | 017   | 001   | 051   | 0038.22 ms     |
| 60th  | jmite                | IocainePowder           | Ruby       | 017   | 017   | 003   | 049   | 0038.50 ms     |
| 60th  | ArcticanAudio        | SpockOrRock             | PHP        | 017   | 017   | 001   | 051   | 0014.19 ms     |
| 60th  | Dr R Dizzle          | BetterLisaSimpson       | Ruby       | 017   | 017   | 000   | 052   | 0038.23 ms     |
| 64th  | Dr R Dizzle          | LisaSimpson             | Ruby       | 016   | 016   | 002   | 051   | 0038.29 ms     |
| 65th  | Martin Büttner       | Vulcan                  | Ruby       | 015   | 015   | 001   | 053   | 0038.26 ms     |
| 65th  | Dr R Dizzle          | Khaleesi                | Ruby       | 015   | 015   | 005   | 049   | 0038.29 ms     |
| 67th  | Dr R Dizzle          | EdwardScissorHands      | Ruby       | 014   | 014   | 002   | 053   | 0038.21 ms     |
| 67th  | undergroundmonorail  | TheGambler              | Python2    | 014   | 014   | 002   | 053   | 0025.47 ms     |
| 69th  | cipher               | LemmingBot              | Python2    | 011   | 011   | 002   | 056   | 0025.29 ms     |
| 70th  | Docopoper            | ConcessionBot           | Python2    | 007   | 007   | 000   | 062   | 0141.31 ms     |
+-------+----------------------+-------------------------+------------+-------+-------+-------+-------+----------------+
Total Players: 70
Total Matches Completed: 2415
Total Tourney Time: 06:00:51.6877573

Turnuva Notları

• WOO HOO 70 BOTS
• Emil hala KOTH ile birlikte Ponyve yeni bot Dienstag3. sırada yer alıyor
• Roy, botuyla ikinci sırayı attığı için Gazzrtebrikler
• William Barbosa botuyla Quick Draw ödülünü kazandı.BarneyStinson

• Ve Yavaş Poke ödülü onun botlar için Docopoper gider R.O.B.O.Tve Concessionbotel başına hem> 140ms kim

• Kullanılabilir günlükler @ https://github.com/eoincampbell/big-bang-game/blob/master/tourneys/Tournament-2014-08-01-23-24-00.zip?raw=true

Dışlanan Botlar

• BashRocksBot -. Net ile cygwin bash scriptlerini çalıştırma
• CounterPreferenceBot - hata düzeltmeyi bekliyor
• RandomlyWeighted - Hata düzeltme bekliyor
• CasinoShakespeare - aktif bir internet bağlantısı gerektirdiğinden dışlandı

Orijinal Gönderilen Soru

Rock, Paper, Scissors, Lizard, Spock’ın en destansı şov savaşı için arkadaşlarınızın evinde dolandınız. Gerçek BigBang nerd-tastic tarzında, hiçbir oyuncu kendi kendine oynamıyor, ancak kendi adına oynamak için konsol botları yarattı. USB anahtarınızı çırpın ve gösteriye dahil edilmesi için faturasına Sheldor'a verin . Penny kakaları. Ya da belki Howard küfür eder. Burada Leonard'ın dairesinde yargılamıyoruz.

kurallar

Standart Taş, Kağıt, Makas, Kertenkele, Spock kuralları uygulanır.

• Kağıt kesme makası
• Kağıt Rock kapsar
• Rock Lizard'ı eziyor
• Kertenkele zehirleri Spock
• Spock Makas Parçalar
• Makas Kertenkele dekapit
• Kertenkele kağıt yiyor
• Kağıt Spock'u çürütüyor
• Spock Rock'ı buharlaştırıyor
• Kaya Makası

Her oyuncunun bot biri oynayacak Match turnuvasında birbirlerine bot karşı.

Her maç bir RPSLV oyununun 100 tekrarından oluşacak.

Her maçtan sonra kazanan, 100 üzerinden en fazla oyun / el kazanan oyuncu.

Bir maç kazanırsanız, lig tablosunda 1 puan alırsınız. Beraberlik eşleşmesi sonucunda hiçbir oyuncu bir puan kazanmaz.

Bot Gereksinimleri

Botunuz komut satırından çalıştırılabilir olmalıdır.

Sheldor's * nix kutusu öldü, bu yüzden onu pencerelerinden kullanıyoruz. 8 Gaming Laptop, sağlanan çözümün pencerelerde çalışabildiğinden emin olun. Sheldor, nezaketle çözümünüzü yürütmek için gerekli tüm çalışma zamanlarını (sebep dahilinde) yüklemeyi teklif etti. (.NET, Java, Php, Python, Ruby, Powershell…)

Girdiler

Her bir karşılaşmanın ilk oyunda, botunuza hiçbir argüman verilmez. Her maçtan sonraki her oyunda: - Arg1 bu maçtaki botların el / karar tarihini içerecektir. - Arg2 bu maçta rakip ellerin / kararların geçmişini içerecektir.

Tarih, oynayabileceğiniz olası elleri temsil eden tek bir büyük harf dizisi ile temsil edilecektir.

 | R | Rock     |
 | P | Paper    |
 | S | Scissors |
 | L | Lizard   |
 | V | Spock    |

Örneğin

• Oyun 1: MyBot.exe
• Oyun 2: MyBot.exe SV
• Oyun 3: MyBot.exe SS VL
• Oyun 4: MyBot.exe SSR VLS

Çıktı

Botunuz, her oyun için "elini" temsil eden tek bir karakter cevabı yazmalıdır. Sonuç STDOUT'a yazılmalıdır ve bot daha sonra çıkmalıdır. Geçerli tek büyük harfler aşağıdadır.

 | R | Rock     |
 | P | Paper    |
 | S | Scissors |
 | L | Lizard   |
 | V | Spock    |

Botunuzun geçerli bir el vermemesi durumunda (örneğin yukarıdaki 5 büyük harfin 1'i, o eli otomatik olarak kaybedersiniz ve maç devam eder).

Her iki botun da geçerli bir el getirmemesi durumunda, oyun berabere sayılır ve maç devam eder.

Maç biçimi

Gönderilen her bot turnuvada birbirlerine karşı bir maç oynayacaktır.

Her maç tam 100 maç sürecek.

Maçlar anonim olarak oynanacak, karşı oynadığınız bot hakkında ileri düzeyde bir bilgiye sahip olmayacaksınız, ancak mevcut maçın tarihçesi boyunca kararınızı alırken elde edebileceğiniz tüm bilgileri, maçınıza karşı stratejinizi değiştirmek için kullanabilirsiniz. karşı taraf. Aynı zamanda, önceki oyunlarınızın geçmişini, kalıplar / sezgisel taramalar vb.

Tek bir oyun sırasında orkestrasyon motoru botunuzu ve rakiplerinizi 100 milisaniyelik botunuzda çalıştırır ve ardından aynı dilde / çalışma zamanında herhangi bir PRNG çarpışmasını önlemek için sonuçları karşılaştırır. (Bu aslında test sırasında bana oldu).

Yargılama ve Kısıtlamalar

Fatih Sheldor kılığında Dr. Sheldon Cooper, turnuvanın yürütülmesini denetlemeyi teklif etti. Fatih Sheldor, adil ve adil bir kişidir (çoğunlukla). Sheldor tarafından verilen tüm kararlar kesindir.

Oyun adil ve doğru bir şekilde yapılacaktır:

• Bot scriptiniz / programınız orkestrasyon motorunda bir alt klasör altında saklanacak Players\[YourBotName]\
• Players\[YourBotName]\dataMevcut turnuvadaki tüm verileri veya oyun geçmişlerini kaydetmek için alt klasörü kullanabilirsiniz . Her turnuvanın başında veri dizinleri temizlenir.
• Turnuvadaki başka bir oyuncunun Player dizinine erişemezsiniz
• Botunuz başka bir belirli botun davranışını hedefleyen belirli bir koda sahip olamaz
• Her oyuncu, etkileşimde bulunmadıkları veya birbirlerine yardım etmedikleri sürece birden fazla bot oynayabilir.

Düzenleme - Ek Kısıtlamalar

• Kayıplarla ilgili olarak, desteklenmeyeceklerdir. Botunuz geçerli 5 elden birini oynamalıdır. Her botu turnuva dışında test edecekler ve davranışlarını kontrol etmek için rasgele veriler vereceğim. Hata atan tüm botlar (yani, sahte hatalar), hata düzeltilinceye kadar turnuva dışında bırakılır.
• Botlar davranışlarında tamamen farklı oldukları sürece türev olabilirler. Mevcut bir botla aynı davranışı yapan botlar (diğer diller dahil) diskalifiye edilir
• Aşağıdakiler için zaten spam botlar var, lütfen tekrar göndermeyin
• • Kaya - BartSimpson
• • Kağıt - LisaSimpson
• • Makas - EdwardScissorhands
• • Spock - Vulcan
• • Kertenkele - Khaleesi
• • Sözde Rastgele - SimpleRandomBot & FairBot
• • Psuedo Rastgele RPS - ConservativeBot
• • Psuedo Rastgele LV - Barney Stinson
• Botlar, 3. taraf servislerine veya web kaynaklarına (veya eşleşmelerin hızını / karar verme süresini önemli ölçüde yavaşlatan herhangi bir şey) seslenemez. CasinoShakespeareBu kısıtlama eklenmeden önce botun gönderildiği tek istisna.

Sheldor, bu soruyu, daha fazla bot gönderildiği gibi, Turnuva sonuçlarında olabildiğince sık güncelleyecektir.

Orkestrasyon / Kontrol Programı

Orkestrasyon programı, her bot için kaynak kodu ile birlikte github'da mevcuttur.

https://github.com/eoincampbell/big-bang-game

Gönderim Detayları

Gönderiniz içermelidir

• Botunun adı
• Senin kodun
• Bir komut
  • botunuzu kabuktan yürütmek
  • yakut myBot.rb
  • python3 myBot.py
  • VEYA
  • önce ikinizi de derleyin ve sonra uygulayın. Örneğin
  • csc.exe MyBot.cs
  • MyBot.exe

Örnek gönderme

BotName: SimpleRandomBot
Compile: "C:\Program Files (x86)\MSBuild\12.0\Bin\csc.exe" SimpleRandomBot.cs
Run:     SimpleRandomBot [Arg1] [Arg2]

Kod:

using System;
public class SimpleRandomBot
{
    public static void Main(string[] args)
    {
        var s = new[] { "R", "P", "S", "L", "V" };
        if (args.Length == 0)
        {
            Console.WriteLine("V"); //always start with spock
            return;
        }
        char[] myPreviousPlays = args[0].ToCharArray();
        char[] oppPreviousPlays = args[1].ToCharArray();
        Random r = new Random();
        int next = r.Next(0, 5);
        Console.WriteLine(s[next]);
    }
}

açıklama

Herhangi bir sorunuz, aşağıdaki yorumlarda sorun.

Midilli (Python 2)

Bu, bir süre önce Udacity çevrimiçi sınıfının sonunda bir programlama zorluğu için yazdığım bir rock-scissors makas botuna dayanıyor . Spock ve kertenkele içerecek şekilde değiştirdim ve bazı geliştirmeler yaptım.

Programın her biri 5 değişkenli 11 farklı basit stratejisi var. Son turlarda ne kadar iyi performans gösterdiklerine dayanarak bunlar arasından seçim yapar.

Daha güçlü rakiplere karşı rastgele oynanan bir geri dönüş stratejisini kaldırdım. Sanırım böyle daha eğlenceli.

import sys

# just play Spock for the first two rounds
if len(sys.argv)<2 or len(sys.argv[1])<2: print 'V'; sys.exit()

# initialize and translate moves to numbers for better handling:
my_moves, opp_moves = sys.argv[1], sys.argv[2]
moves = ('R', 'P', 'S', 'V', 'L')   
history = zip([moves.index(i) for i in my_moves],
              [moves.index(i) for i in opp_moves])

# predict possible next moves based on history
def prediction(hist):
    N = len(hist)    

    # find longest match of the preceding moves in the earlier history
    cand_m = cand_o = cand_b = range(N-1)
    for l in xrange(1,min(N, 20)):
        ref = hist[N-l]
        cand_m = ([c for c in cand_m if c>=l and hist[c-l+1][0]==ref[0]]
                  or cand_m[-1:])
        cand_o = ([c for c in cand_o if c>=l and hist[c-l+1][1]==ref[1]]
                  or cand_o[-1:])
        cand_b = ([c for c in cand_b if c>=l and hist[c-l+1]==ref]
                  or cand_b[-1:])

    # analyze which moves were used how often
    freq_m, freq_o = [0]*5, [0]*5
    for m in hist:
        freq_m[m[0]] += 1
        freq_o[m[1]] += 1

    # return predictions
    return ([hist[-i][p] for i in 1,2 for p in 0,1]+   # repeat last moves
            [hist[cand_m[-1]+1][0],     # history matching of my own moves
             hist[cand_o[-1]+1][1],     # history matching of opponent's moves
             hist[cand_b[-1]+1][0],     # history matching of both
             hist[cand_b[-1]+1][1],
             freq_m.index(max(freq_m)), # my most frequent move
             freq_o.index(max(freq_o)), # opponent's most frequent move
             0])                        # good old rock (and friends)


# what would have been predicted in the last rounds?
pred_hist = [prediction(history[:i]) for i in xrange(2,len(history)+1)]

# how would the different predictions have scored?
n_pred = len(pred_hist[0])
scores = [[0]*5 for i in xrange(n_pred)]
for pred, real in zip(pred_hist[:-1], history[2:]):
    for i in xrange(n_pred):
        scores[i][(real[1]-pred[i]+1)%5] += 1
        scores[i][(real[1]-pred[i]+3)%5] += 1
        scores[i][(real[1]-pred[i]+2)%5] -= 1
        scores[i][(real[1]-pred[i]+4)%5] -= 1

# return best counter move
best_scores = [list(max(enumerate(s), key=lambda x: x[1])) for s in scores]
best_scores[-1][1] *= 1.001   # bias towards the simplest strategy    
if best_scores[-1][1]<0.4*len(history): best_scores[-1][1] *= 1.4
strat, (shift, score) = max(enumerate(best_scores), key=lambda x: x[1][1])
print moves[(pred_hist[-1][strat]+shift)%5]

Olarak çalıştırmak:

python Pony.py

Düzenleme : Emin değilseniz en basit stratejiye (yani her zaman aynı hareketi oynar) doğru önyargı koyarak küçük bir değişiklik yaptım. Bu, örneğin ConservativeBot gibi botlarda bulunmayan aşırı karmaşık kalıpları bulmamaya yardımcı olur.

Not : Bu botun diğer bot Dienstag'ım için gönderimde kullandığı temel tarih eşleştirme stratejisini açıklamaya çalıştım .

Markov, Yakut

Rakibin son iki hamlesine bakar ve olası (ve en muhtemel) takipleri belirler. Eğer kombinasyon daha önce seçilmediyse, sadece rakibin tüm hareketlerini (şimdiye kadar) kullanır. Sonra bunlar için mümkün olan tüm cevapları toplar ve rastgele bir cevap alır.

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0 || (history = ARGV[1]).length < 3
    choices = ['R','P','S','L','V']
else
    markov = Hash.new []
    history.chars.each_cons(3) { |chars| markov[chars[0..1].join] += [chars[2]] }

    choices = []
    likely_moves = markov.key?(history[-2,2]) ? markov[history[-2,2]] : history.chars
    likely_moves.each { |move| choices += responses[move] }
end

puts choices.sample

Gibi koş

markov.rb

Muhafazakar Bot, Ruby

Yeni şeyler kötü şeylerdir.

puts ['R','P','S'].sample

Gibi koş

ruby conservative.rb

Star Wars Fan - Yakut

Boşver seni Spock

puts ['R','P','L','S'].sample

Gibi koş:

ruby starwarsfan.rb

Barney Stinson - Lua

Sadece bir kural var: Yeni her zaman daha iyidir. Yaşlı Jo Ken Po'yu ya da ona ne diyorsan onu boşver.

math.randomseed(os.time())
print(math.random() > 0.5 and "V" or "L")

Gibi koş:

lua legenwaitforitdary.lua

Sıkıcı Bot (Java)

Herkesin hep aynı şeyi oynadığını ve buna göre plan yaptığını varsayar. O genellikle bağları içinde kayaları toplar, çünkü herkes doğru mu?

public class BoringBot
{
    public static void main(String[] args)
    {
        int Rock=0;
        int Paper=0;
        int Scissors=0;
        int Lizard=0;
        int Spock=0;

        if (args.length == 0)
        {
            System.out.print("P");
            return;
        }

        char[] oppPreviousPlays = args[1].toCharArray();

        for (int j=0; j<oppPreviousPlays.length; j++) {
            switch(oppPreviousPlays[j]){
                case 'R': Rock++; break;
                case 'P': Paper++; break;
                case 'S': Scissors++; break;
                case 'L': Lizard++; break;
                case 'V': Spock++;
            }
        }

        int Best = Math.max(Math.max(Lizard+Scissors-Spock-Paper,
                                     Rock+Spock-Lizard-Scissors),
                            Math.max(Math.max(Paper+Lizard-Spock-Rock,
                                              Paper+Spock-Rock-Scissors),
                                     Rock+Scissors-Paper-Lizard));

        if (Best== Lizard+Scissors-Spock-Paper){
            System.out.print("R"); return;
        } else if (Best== Rock+Spock-Lizard-Scissors){
            System.out.print("P"); return;
        } else if (Best== Paper+Lizard-Spock-Rock){
            System.out.print("S"); return;
        } else if(Best== Paper+Spock-Rock-Scissors){
            System.out.print("L"); return;
        } else {
            System.out.print("V"); return;
        }
    }
}

IocainePowder, Ruby

Buradaki RPS stratejisine dayanarak (utanmadan çalındı) . Bot, Markov botuyla aynı olan bir tahmin seçti, ancak daha sonra rakibin ne seçeceğini tahmin ettiğini varsayar ve buna göre yenmek için bir hareket seçer.

Sadece bağlantılı stratejinin temel fikrini uyarladığımı, ayrıntılı olarak takip etmediğimi not edin.

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0 || (history = ARGV[1]).length < 3
    choices = ['R','P','S','L','V']
else
    markov = Hash.new []
    history.chars.each_cons(3) { |chars| markov[chars[0..1].join] += [chars[2]] }

    choices = []
    likely_moves = markov.key?(history[-2,2]) ? markov[history[-2,2]] : history.chars
    likely_moves.each { |move| choices += responses[move] }
end

myChoice = choices.sample 
theirChoice = responses[myChoice].sample
actualChoice = responses[theirChoice].sample
puts actualChoice

Gibi koş

iocaine.rb

HuddleWolfTheConqueror - C #

HuddleWolf geri döndü ve her zamankinden daha iyi. Fatih’i Sheldor’u kendi aptalca oyununda yenecek. HuddleWolf spam gönderenleri tanımlayacak ve karşılaştıracak kadar akıllıdır. Daha zeki rakipler için, HuddleWolf, temel 5. sınıf istatistik bilgilerini kullanır ve muhalefetin oyun geçmişine dayanan ağırlıklı bir zar atar.

using System;
using System.Collections.Generic;
using System.Linq;

public class HuddleWolfTheConqueror
{

    public static readonly char[] s = new[] { 'R', 'P', 'S', 'L', 'V' };

    public static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine(pickRandom());
            return;
        }

        char[] myPlays = args[0].ToCharArray();
        char[] oppPlays = args[1].ToCharArray();

        char tryPredict = canPredictCounter(oppPlays);
        if (tryPredict != '^')
        {
            Console.WriteLine(tryPredict);
        }
        else
        {
            Console.WriteLine(pickRandom());
        }
        return;
    }


    public static char canPredictCounter(char[] history)
    {
        // don't predict if insufficient data
        if (history.Length < 5)
        {
            return '^';
        }

        // calculate probability of win for each choice
        Dictionary<char, double> dic = getBestProabability(history);

        // get item with highest probability of win
        List<char> maxVals = new List<char>();
        char maxVal = '^';
        double mostFreq = 0;
        foreach (var kvp in dic)
        {
            if (kvp.Value > mostFreq)
            {
                mostFreq = kvp.Value;
            }
        }
        foreach (var kvp in dic)
        {
            if (kvp.Value == mostFreq)
            {
                maxVals.Add(kvp.Key);
            }
        }

        // return error
        if (maxVals.Count == 0)
        {
            return maxVal;
        }

        // if distribution is not uniform, play best play
        if (maxVals.Count <= 3)
        {
            Random r = new Random(Environment.TickCount);
            return maxVals[r.Next(0, maxVals.Count)];
        }

        // if probability is close to uniform, use weighted dice roll
        if (maxVals.Count == 4)
        {
            return weightedRandom(dic);
        }

        // if probability is uniform, use random dice roll
        if (maxVals.Count >= 5)
        {
            return pickRandom();
        }

        // return error
        return '^';
    }

    public static Dictionary<char, double> getBestProabability(char[] history)
    {
        Dictionary<char, double> dic = new Dictionary<char, double>();
        foreach (char c in s)
        {
            dic.Add(c, 0);
        }
        foreach (char c in history)
        {
            if (dic.ContainsKey(c))
            {
                switch(c)
                {
                    case 'R' : 
                        dic['P'] += (1.0/(double)history.Length);
                        dic['V'] += (1.0/(double)history.Length);
                        break;
                    case 'P' : 
                        dic['S'] += (1.0/(double)history.Length);
                        dic['L'] += (1.0/(double)history.Length);
                        break;
                    case 'S' : 
                        dic['V'] += (1.0/(double)history.Length);
                        dic['R'] += (1.0/(double)history.Length);
                        break;
                    case 'L' : 
                        dic['R'] += (1.0/(double)history.Length);
                        dic['S'] += (1.0/(double)history.Length);
                        break;
                    case 'V' : 
                        dic['L'] += (1.0/(double)history.Length);
                        dic['P'] += (1.0/(double)history.Length);
                        break;
                    default : 
                        break;

                }
            }
        }
        return dic;
    }

    public static char weightedRandom(Dictionary<char, double> dic)
    {
        Random r = new Random(Environment.TickCount);
        int next = r.Next(0, 100);
        int curVal = 0;
        foreach (var kvp in dic)
        {
            curVal += (int)(kvp.Value*100);
            if (curVal > next)
            {
                return kvp.Key;
            }
        }
        return '^';
    }

    public static char pickRandom()
    {
        Random r = new Random(Environment.TickCount);
        int next = r.Next(0, 5);
        return s[next];
    }
}

ToddlerProof

Bu oldukça aptal bot, hamlesini "kovalayan" bir yürümeye başlayan çocuk oynadığını ve her zaman en son atılanı yenmeye çalıştığını varsayar. Bot üst üste birkaç kez yenilirse, düzende yeni bir noktaya atlar. Her zaman benim yenerek benim stratejisine dayanmaktadır çok kardeşi. :)

EDIT :: Rasgele atışlara atlamak için gereken kayıp çizgisinin uzunluğunu değiştirdi. Ayrıca rastgele atlama ile büyük bir hata düzeltildi.

Farklı kaydet ToddlerProof.java, derle ve çalıştırjava ToddlerProof [me] [them]

import java.util.HashMap;
public class ToddlerProof
{
    char[] moves = new char[]{'R', 'P', 'S', 'L', 'V'};
    public static void main(String[] args)
    {
        if(args.length<1) //first Round
        {
            System.out.print('V');//Spock is best
            return;
        }
        else
        {
            String them = args[1];
            String me = args[0];
            int streak = 0;

            HashMap<Character, Character> nextMove = new HashMap<Character, Character>();
            //Next move beats things that beat my last move
            nextMove.put('L', 'V');
            nextMove.put('V', 'S');
            nextMove.put('S', 'P');
            nextMove.put('P', 'R');
            nextMove.put('R', 'L');
            //Check if last round was a tie or the opponent beat me
            int lastResult = winner(me.charAt(me.length()-1), them.charAt(them.length()-1));
            if(lastResult == 0)
            {
                //tie, so they will chase my last throw
                System.out.print(nextMove.get(me.charAt(me.length()-1)));

                return;
            }
            else if(lastResult == 1)
            {
                //I won, so they will chase my last throw
                System.out.print(nextMove.get(me.charAt(me.length()-1)));


                return;
            }

            else{
                //I lost
                //find streak
                for(int i = 0; i<me.length(); i++)
                {
                    int a = winner(me.charAt(i), them.charAt(i));
                    if(a >= 0) streak = 0;
                    else streak++;
                }
                //check lossStreak
                //If the streak is 2, then a rotation will make it even.
                //if it is >2, something bad has happened and I need to adjust.
                if(streak>2)
                {
                    //if they are on to me, do something random-ish
                    int r = (((them.length()+me.length()-1)*13)/7)%4;
                    System.out.print(move[r]);
                    return;
                }
                //otherwise, go on with the plan
                System.out.print(nextMove.get(me.charAt(me.length()-1)));
                return;
            }
        }
    }
    public static int winner(char me, char them)
    {
        //check for tie
        if(me == them) return 0;
        //check if they won
        if(me=='V' && (them == 'L' || them == 'P')) return -1;
        if(me=='S' && (them == 'V' || them == 'R')) return -1;
        if(me=='P' && (them == 'S' || them == 'L')) return -1;
        if(me=='R' && (them == 'P' || them == 'V')) return -1;
        if(me=='L' && (them == 'R' || them == 'S')) return -1;
        //otherwise, I won
        return 1;
    }
}

Bart Simpson

"Eski güzel rock! Hiçbir şey kayayı yenemez!"

puts 'R'

Olarak çalıştırmak

ruby DoTheBartman.rb

Lisa Simpson

"Zavallı, öngörülebilir Bart. Her zaman kaçı seçer."

puts 'P'

Olarak çalıştırmak

ruby LisaSimpson.rb

Daha iyi Lisa Simpson

Lisa'yı bu kadar aptal yapmak konusunda kendimi kötü hissettim, bu yüzden onu kayaya çarpacak ellerden birini rastgele seçmesine izin verdim. Hala aptal, ama sonuçta o bir Simpson. Belki beynine bir mum boya sıkışmıştır?

puts ['P','V'].sample

Olarak çalıştırmak

ruby BetterLisaSimpson.rb

Eko

C # ile yazılmış. İle derleyin csc Echo.cs. Gibi koş Echo.exe ARG1 ARG2.

İlk çalıştırmada Echo rastgele bir seçenek alır. Birinciden sonraki her etap, Echo sadece rakibin son hareketini tekrarlar.

using System;

namespace Echo
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Random r = new Random();
                string[] options = new string[] { "R", "P", "S", "L", "V" };
                Console.WriteLine(options[r.Next(0, options.Length)]);
            }
            else if (args.Length == 2)
            {
                string opponentHistory = args[1];
                Console.WriteLine(opponentHistory[opponentHistory.Length - 1]);
            }
        }
    }
}

Vulkan, Yakut

Parmaklarım birbirine yapışmış.

puts 'V'

Gibi koş

ruby vulcan.rb

(Bence bu arka plan ayarınız için tek karakter stratejisi.)

Tyrannosaurus, Godzilla, Barney ... Kertenkeleler Kuralı. Bazen başları belaya girerler ve Spock'u aramaları veya Rocks atmaları gerekir.

using System;
public class LizardsRule
{
    public static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("L");
            return;
        }
        char[] oppPreviousPlays = args[1].ToCharArray();
        var oppLen = oppPreviousPlays.Length;
        if (oppPreviousPlays.Length > 2
            && oppPreviousPlays[oppLen - 1] == 'R'
            && oppPreviousPlays[oppLen - 2] == 'R'
            && oppPreviousPlays[oppLen - 3] == 'R')
        {
            //It's an avalance, someone call Spock
            Console.WriteLine("V");
            return;
        }

        if (oppPreviousPlays.Length > 2
                && oppPreviousPlays[oppLen - 1] == 'S'
                && oppPreviousPlays[oppLen - 2] == 'S'
                && oppPreviousPlays[oppLen - 3] == 'S')
        {
            //Scissors, Drop your tail and pick up a rock
            Console.WriteLine("R");
            return;
        }

        //Unleash the Fury Godzilla
        Console.WriteLine("L");     
    }
}

BayesianBot, Perl (şimdi v2!)

Her şeyden önce, bu eşsiz bir program. İçinde, istatistiğin parlak bir füzyonunu ve korkunç programlama formunu göreceksiniz. Ayrıca, bu bot muhtemelen Bayesian istatistiklerinin birçok kurallarını ihlal ediyor, ancak isim daha iyi geliyor.

Bu botun özü, 250 farklı tahmin modelinin oluşturulmasıdır. Her model, "Son sıralarda rock oynadığım ve rakibimin iki tur önce makas oynadığı düşünüldüğünde, bu rakibimin bir sonraki hamlesinin olasılık dağılımıdır." Her olasılık dağılımı, çok boyutlu bir Dirichlet dağılımı şeklini alır.

Her turda, geçerli tüm modellerin tahminleri (tipik olarak 10), genel bir tahmin oluşturmak üzere bir araya getirilir ve daha sonra hangi hamlelerin beklenen en yüksek kazancı sağladığını belirlemek için kullanılır.

Düzenleme 1: Bu sürümde önceki dağıtımı değiştirdim ve kaybederken botu daha rastgele hale getirdim.

Modellerin sayısı (250 sadece 3 haneli bir sayıdır), önceki dağıtımın seçimi (şu anda Dir (3,3,3,3,3)) ve kaynaştırma tahminleri yöntemi. Ayrıca, olasılık dağılımlarının hiçbirini normalleştirmek için hiçbir zaman zahmet etmedim, çünkü şu an için sorun değil çünkü onları çarpıyorum.

Süper yüksek beklentilerim yok, ama umarım bu bot iyi yapabilir

my ($phist, $ohist) = @ARGV;

my %text2num = ('R',0,'V',1,'P',2,'L',3,'S',4);  #the RVPLS ordering is superior
my @num2text = ('R','V','P','L','S');

@phist = map($text2num{$_},split(//,$phist));
@ohist = map($text2num{$_},split(//,$ohist));

$lowerlimit = 0;
for($lowerlimit..~~@phist-3){$curloc=$_;
 $result = $ohist[$curloc+2];
 @moveset = ($ohist[$curloc],$ohist[$curloc+1],$phist[$curloc],$phist[$curloc+1]);
 for(0..3){$a=$_;
  for(0..$a){$b=$_;
   $predict[$a][$b][$moveset[$a]][$moveset[$b]][$result]++;
  }
 }
}

@recentmoves = ($ohist[-2],$ohist[-1],$phist[-2],$phist[-1]);

@curpred = (1,1,1,1,1);

for(0..3){$a=$_;
 for(0..$a){$b=$_;
  for(0..4){$move=$_;
   $curpred[$move] *= $predict[$a][$b][$recentmoves[$a]][$recentmoves[$b]][$move]/3+1;
  }
 }
}

@bestmove = (0,0,0,0,0);
for(0..4){
 $bestmove[$_] = $curpred[$_]/2+$curpred[$_-1]+$curpred[$_-2];
}

$max = 0;
for(0..4){
 if($bestmove[$_]>$max){
  $max = $bestmove[$_];
 }
}
@options=();
$offset=0;
if(($ohist[-1] - $phist[-1])%5 < 2 && ($ohist[-2] - $phist[-2])%5 < 2 && ($ohist[-3] - $phist[-3])%5 < 2){  #frequentist alert!
 $offset=int(rand(3));
}
for(0..4){
 if($bestmove[$_] == $max){
  push(@options,$num2text[($_+$offset)%5]);
 }
}
$outputb = $options[int(rand(~~@options))];

print "$outputb";

Bu programı şöyle çalıştırıyorum:

perl BayesianBot.plx

DynamicBot

Dinamik bot neredeyse her zaman değişiyor. Gerçekten kendini tekrar etmekten nefret ediyor

import sys, random
choices = ['L','V','S','P','R'] * 20
if len(sys.argv) > 1:
    my_history = sys.argv[1]
    [choices.remove(my_history[-1]) for i in range(15)]
print(choices[random.randrange(len(choices))])

Dil: Python 3.4.1

Komut: python dynamicbot.py <history>veya python3 dynamicbot.py <history>sisteminize bağlı olarak

SmartBot - Java

Bu sitedeki herhangi bir şeye ilk girişim!

Çok yaratıcı bir isim olmasa da ...

SmartBot, rakibin ve / veya kendisinin hamlelerinin en son yapılan hamlelere benzemesi ve buna göre plan yapması gereken hamle dizilerini bulur.

name = SmartBot

Koşmayı düşünüyorum, yanılıyorsam düzelt beni.

java -jar SmartBot.jar

import java.util.ArrayList;
public class SmartBot {
    public static void main(String[] args) {
        if(args.length ==0){
            System.out.print("L");
            return;
        }
        if(args[0].length()<3){
            String[] randLetter = new String[]{"R","P","S","L","V"};
            System.out.print(randLetter[(int) Math.floor(Math.random()*5)]);
            return;
        }
        String myHistory = args[0];
        String otherHistory = args[1];

        double rScore,pScore,sScore,lScore,vScore;//score - highest = highest probability of next opponent move
        rScore = pScore = sScore = lScore = vScore = 0;
        lScore = .001;
        ArrayList<ArrayList<Integer>> moveHits = new ArrayList<ArrayList<Integer>>();
        for(int g = 0;g<2;g++){
            for(int i=1;i<(myHistory.length() / 2) + 1;i++){
                if(g==0){
                    moveHits.add(findAll(myHistory.substring(myHistory.length() - i),myHistory));
                }
                else{
                    moveHits.add(findAll(otherHistory.substring(otherHistory.length() - i),otherHistory));
                }
            }
            for(int i = 0; i < moveHits.size();i++){
                int matchingMoves = i+1;
                ArrayList<Integer> moveIndexes = moveHits.get(i);
                for(Integer index:moveIndexes){
                    if(index+matchingMoves +1<= otherHistory.length()){
                        char nextMove = otherHistory.charAt(index + matchingMoves-1);
                        if(nextMove=='R'){rScore = rScore + matchingMoves;}
                        if(nextMove=='P'){pScore = pScore + matchingMoves;}
                        if(nextMove=='S'){sScore = sScore + matchingMoves;}
                        if(nextMove=='L'){lScore = lScore + matchingMoves;}
                        if(nextMove=='V'){vScore = vScore + matchingMoves;}
                    }
                }
            }
        }
        if(rScore >= pScore && rScore >= sScore && rScore >= lScore && rScore >= vScore){
            System.out.print("V");
            return;
        }
        if(pScore >= rScore && pScore >= sScore && pScore >= lScore && pScore >= vScore){
            System.out.print("L");
            return;
        }
        if(sScore >= pScore && sScore >= rScore && sScore >= lScore && sScore >= vScore){
            System.out.print("R");
            return;
        }
        if(vScore >= pScore && vScore >= sScore && vScore >= lScore && vScore >= rScore){
            System.out.print("L");
            return;
        }
        if(lScore >= pScore && lScore >= sScore && lScore >= rScore && lScore >= vScore){
            System.out.print("S");
        }
        return;
    }
    public static ArrayList<Integer> findAll(String substring,String realString){
        ArrayList<Integer> ocurrences = new ArrayList<Integer>();
        Integer index = realString.indexOf(substring);
        if(index==-1){return ocurrences;}
        ocurrences.add(index+1);
        while(index!=-1){
            index = realString.indexOf(substring,index + 1);
            if(index!=-1){
                ocurrences.add(index+1);
            }
        }
        return ocurrences;
    }
}

Benzer kalıpların meydana gelme sayısına göre sıradaki her hamle için bir puan atar.

Biraz kertenkele yanadır.

SpockOrRock - PHP

Gerçek dünyada oynandığında çoğu insan içgüdüsel olarak makas seçer. Bu bot, ortalama oyuncuyu yenmek için Spock veya Rock seçer. Önceki turlar için rahatsız değil.

koşmak php spockorrock.php

<?php

//Pick either Spock or Rock
if (rand(0,1) == 0)     echo("R\n");
else                    echo("V\n");


?>

SlowLizard, Yakut

Kertenkele ile başladıktan sonra, her zaman rakibin önceki hamlesini geçen rasgele bir hareket seçer.

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0
  puts 'L'
else
  puts responses[ARGV[1][-1]].sample
end

Gibi koş

ruby slowlizard.rb

LexicographicBot

Bu bot mektuplarını sipariş etmeyi sever, bu yüzden önceki turda rakibinden 1 kat daha yüksek bir cevap seçecektir - rakip Vulcan'ı seçmediyse, rastgele bir cevap alır.

import sys
import random

choices = ["L", "P", "R", "S", "V"]

total = len(sys.argv)
if total==1:
    print("L")
    sys.exit()

opponent = sys.argv[2]
opponent_last = opponent[-1]

if opponent_last == choices[-1]:
    print(random.choice(choices))
else:
    next = choices.index(opponent_last)+1
    print(choices[next])

Bu, rakip elin ikinci ele geçirilmesini bekler:

                           me
                            v
python LexicographicBot.py SR RV
                              ^
                            opponent

Werevulcan - Yakut

Olarak çalıştırmak ruby werevulcan.rb

@rules = {

  'L' => %w[V P],
  'P' => %w[V R],
  'R' => %w[L S],
  'S' => %w[P L],
  'V' => %w[R S]
}

@moves = @rules.keys

def defeats?(move1, move2)
  @rules[move1].include?(move2)
end

def score(move1, move2)
  if move1 == move2
    0
  elsif defeats?(move1, move2)
    1
  else
    -1
  end
end

def move
  player, opponent = ARGV

  # For the first 30 rounds, pick a random move that isn't Spock
  if player.to_s.size < 30
    %w[L P R S].sample
  elsif opponent.chars.to_a.uniq.size < 5
    exploit(opponent)
  else
    # Pick a random move that's biased toward Spock and against lizards
    %w[L P P R R S S V V V].sample
  end

end

def exploit(opponent)
  @moves.shuffle.max_by{ |m| opponent.chars.map{|o| score(m,o) }.reduce(:+) }
end

puts move

Werevulcan gün geçtikçe normal görünüyor, ancak ay yükseldiğinde kulakları sivri ve hareketleri daha mantıklı hale geliyor.

Analogizer - Yakut

İle koş ruby analogizer.rb. Kod için mantıksal bir düzeltme yaptım, ancak bu konuda neden hatalar olduğu hakkında hiçbir fikrim yok.

@rules = {

  'L' => %w[V P],
  'P' => %w[V R],
  'R' => %w[L S],
  'S' => %w[P L],
  'V' => %w[R S]
}

@moves = @rules.keys

def defeats?(move1, move2)
  @rules[move1].include?(move2)
end

def score(move1, move2)
  if move1 == move2
    0
  elsif defeats?(move1, move2)
    1
  else
    -1
  end
end

def move
  player, opponent = ARGV

  case player.to_s.size
  # Throw six lizards in the beginning to confuse opponent
  when 0..5
    'L'
  when 6
    'V'
  when 7
    'S'
  when 8
    'P'
  when 9
    'R'
  else
    analyze_history(player.chars.to_a, opponent.chars.to_a)
  end

end

def analyze_history(player, opponent)
  my_last_move = player.last
  predicted_moves = Hash.new {0}
  opponent_reactions = player.zip(opponent.drop(1))

  # Check whether opponent tended to make a move that would've beaten, lost, or tied my last move
  opponent_reactions.each do |my_move, reaction|
    score = score(reaction, my_move)
    analogous_moves = @moves.select { |move| score == score(move, my_last_move) }
    analogous_moves.each { |move| predicted_moves[move] += 1 }
  end

  # Assume if an opponent has never made a certain move, it never will
  @moves.each { |m| predicted_moves[m] = 0 unless opponent.include?(m) }

  # Pick the move with the best score against opponent's possible moves, weighted by their likelihood, picking randomly for ties
  @moves.shuffle.max_by{ |m| predicted_moves.map { |predicted, freq| score(m, predicted) * freq }.reduce(0,:+) }

end

puts move

Rakip botun her zaman önceki hareketime tepki gösterdiğini ve ya onu yenecek bir şeyi, kendisine kaybedecek bir şeyi ya da muhtemelen sınırlı bir olası hareketler kümesinden aynı hareketi seçtiğini varsayalım. Daha sonra bu varsayım verilen en iyi hareketi seçer.

İlk on hamlenin kodlanmış olması haricinde: ilk önce sadece kertenkele bildiğimi iddia ediyorum, sonra rakiplerimin her zaman doğru analiz için yeterli veriye sahip olana kadar attığım son şeyi yenmek için bir şeyler attığını farz ediyorum.

Java - SelfLoathingBot

BotName: SelfLoathingBot
Compile: Save as 'SelfLoathingBot.java'; compile.
Run:     java SelfLoathingBot [me] [them]

Bot rastgele başlar, ardından rastgele gitmek için ~% 33 ya da hemen önceki oyunlardan birine karşı% 50 kazanma taktiği ile kazanma taktisini oynamak için ~% 33.

import java.util.Random;

public class SelfLoathingBot {

    static final Random RANDOM = new Random();

    private static char randomPlay() {

        switch (RANDOM.nextInt(5)) {

            case 0 : return 'R';

            case 1 : return 'P';

            case 2 : return 'S';

            case 3 : return 'L';

            default : return 'V';
        }
    }

    private static char antiPlay(String priorPlayString) {

        char[] priorPlays = priorPlayString.toCharArray();

        int choice = RANDOM.nextInt(2);

        switch (priorPlays[priorPlays.length - 1]) {

            case 'R' : return choice == 0 ? 'P' : 'V'; 

            case 'P' : return choice == 0 ? 'S' : 'L';

            case 'S' : return choice == 0 ? 'V' : 'R';

            case 'L' : return choice == 0 ? 'R' : 'S';

            default : return choice == 0 ? 'L' : 'P'; // V        
        }
    }

    public static void main(String[] args) {

        int choice = args.length == 0 ? 0 : RANDOM.nextInt(3);

        char play;

        switch (choice) {

            case 1 :

                // 33.3% chance Play myself
                play = antiPlay(args[0]);
                break;

            case 2 :

                // 33.3% chance Play opponent just in case opponent is screwy like that
                play = antiPlay(args[1]);
                break;

            default :

                // 33.3% chance 100% Random
                play = randomPlay();
        }

        System.out.print(play);
        return;
    }
}

Analist

Analist bazı şeyleri analiz eder ve sizi yenmek için bazı şeyler yapar.

ile derlemek javac Analyst.javave çalıştırmakjava Analyst

import java.util.Random;

public class Analyst{
    public static void main(String[] args){
        char action = 'S';

        try{
            char[] enemyMoves = null, myMoves = null;

            //first move is random
            if(args.length == 0){
                System.out.print(randomMove());
                System.exit(0);
            //moves 2-3 will beat their last move
            }else if(args[0].length() < 8){
                System.out.print(counterFor(args[1].charAt(args[1].length()-1)));
                System.exit(0);
            //following moves will execute some analyzation stuff
            }else{
                //get previous moves
                myMoves = args[0].toCharArray();
                enemyMoves = args[1].toCharArray();
            }

            //test if they're trying to beat our last move
            if(beats(enemyMoves[enemyMoves.length-1], myMoves[myMoves.length-2])){
                action = counterFor(counterFor(myMoves[myMoves.length-1]));
            }
            //test if they're copying our last move
            else if(enemyMoves[enemyMoves.length-1] == myMoves[myMoves.length-2]){
                action = counterFor(myMoves[myMoves.length-1]);
            }
            //else beat whatever they've done the most of
            else{
                action = counterFor(countMost(enemyMoves));
            }

            //if they've beaten us for the first 40 moves, do the opposite of what ive been doing
            if(theyreSmarter(myMoves, enemyMoves)){
                action = counterFor(action);
            }

        //if you break my program do something random
        }catch (Exception e){
            action = randomMove();
        }

        System.out.print(action);
    }

    private static char randomMove(){
        Random rand = new Random(System.currentTimeMillis());
        int randomMove = rand.nextInt(5);

        switch (randomMove){
            case 0: return 'R';
            case 1: return 'P';
            case 2: return 'S';
            case 3: return 'L';
            default: return 'V';
        }
    }

    private static char counterFor(char move){
        Random rand = new Random(System.currentTimeMillis());
        int moveSet = rand.nextInt(2);

        if(moveSet == 0){
            switch (move){
                case 'R': return 'P'; 
                case 'P': return 'S'; 
                case 'S': return 'R'; 
                case 'L': return 'R'; 
                default: return 'P';
            }
        }else{
            switch (move){
                case 'R': return 'V'; 
                case 'P': return 'L'; 
                case 'S': return 'V'; 
                case 'L': return 'S'; 
                default: return 'L';
            }
        }
    }

    private static boolean beats(char move1, char move2){
        if(move1 == 'R'){
            if((move2 == 'S') || (move2 == 'L')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'P'){
            if((move2 == 'R') || (move2 == 'V')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'S'){
            if((move2 == 'L') || (move2 == 'P')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'L'){
            if((move2 == 'P') || (move2 == 'V')){
                return true;
            }else{
                return false;
            }
        }else{
            if((move2 == 'R') || (move2 == 'S')){
                return true;
            }else{
                return false;
            }
        }
    }

    private static char countMost(char[] moves){
        int[] enemyMoveList = {0,0,0,0,0};

        for(int i=0; i<moves.length; i++){
            if(moves[i] == 'R'){
                enemyMoveList[0]++;
            }else if(moves[i] == 'P'){
                enemyMoveList[1]++;
            }else if(moves[i] == 'S'){
                enemyMoveList[2]++;
            }else if(moves[i] == 'L'){
                enemyMoveList[3]++;
            }else if(moves[i] == 'V'){
                enemyMoveList[4]++;
            }
        }

        int max = 0, maxIndex = 0;
        for(int i=0; i<5; i++){
            if(enemyMoveList[i] > max){
                max = enemyMoveList[i];
                maxIndex = i;
            }
        }

        switch (maxIndex){
            case 0: return 'R';
            case 1: return 'P';
            case 2: return 'S';
            case 3: return 'L';
            default: return 'V';
        }
    }

    private static boolean theyreSmarter(char[] myMoves, char[] enemyMoves){
        int loseCounter = 0;

        if(enemyMoves.length >= 40){
            for(int i=0; i<40; i++){
                if(beats(enemyMoves[i],myMoves[i])){
                    loseCounter++;
                }
            }
        }else{
            return false;
        }

        if(loseCounter > 20){
            return true;
        }else{
            return false;
        }
    }
}

Kumarbaz - Python 2

import sys
import random

MODE = 1

moves = 'RSLPV'

def element_sums(a, b):
    return [a[i] + b[i] for i in xrange(len(a))]

def move_scores(p):
    def calc(to_beat):
        return ['LDW'.find('DLLWW'[moves.find(m)-moves.find(to_beat)]) for m in moves]

    return dict(zip(moves, element_sums(calc(p[0]), calc(p[1]))))

def move_chooser(my_history, opponent_history):
    predict = sorted(moves, key=opponent_history.count, reverse=MODE)[-2:]
    scores = move_scores(predict)
    return max(scores, key=lambda k:scores[k])

if __name__ == '__main__':
    if len(sys.argv) == 3:
        print move_chooser(*sys.argv[1:])
    elif len(sys.argv) == 1:
        print random.choice(moves)

İsmin aksine, bu programda kullanılan tek zaman rastgeleliği, hiçbir bilgi olmadığı zaman ilk raunddadır. Bunun yerine, kumarbazın yanıltması olarak adlandırılır, eğer rastgele bir olay geçmişte daha az gerçekleşirse, gelecekte gerçekleşmesi daha olasıdır. Örneğin, 20 kez adil bir jeton atarsanız ve ilk 15 kafa ise, kumarbazın yanıltısı, kalan fişlerin kuyruk olma ihtimalinin arttığını belirtir. Tabii ki, bu doğru değil; Bir önceki yazıya bakılmaksızın, adil bir madenin para kazanma olasılığı her zaman% 50'dir.

Bu program rakibin geçmişini analiz eder, şimdiye kadar en az kullandığı 2 hamleyi bulur ve bu sefer rakibin hamlesinin bu ikisinden biri olacağını varsayar. Bir galibiyete 2, berabere bir çekilişe ve 0 kaybeden bahseden, tahmin edilen bu iki hamleye karşı maksimum puanla hamleyi bulur ve bunu atar.

Kumarbazın Kardeşi - Python 2

import sys
import random

MODE = 0

moves = 'RSLPV'

def element_sums(a, b):
    return [a[i] + b[i] for i in xrange(len(a))]

def move_scores(p):
    def calc(to_beat):
        return ['LDW'.find('DLLWW'[moves.find(m)-moves.find(to_beat)]) for m in moves]

    return dict(zip(moves, element_sums(calc(p[0]), calc(p[1]))))

def move_chooser(my_history, opponent_history):
    predict = sorted(moves, key=opponent_history.count, reverse=MODE)[-2:]
    scores = move_scores(predict)
    return max(scores, key=lambda k:scores[k])

if __name__ == '__main__':
    if len(sys.argv) == 3:
        print move_chooser(*sys.argv[1:])
    elif len(sys.argv) == 1:
        print random.choice(moves)

Geçiş yaparak MODE0'a değişkeni, bu program ilgili safsata dayalı olarak çalışması, bazen kumarbaz safsata olarak anılacaktır. Geçmişte rastlantısal bir olayın daha sık yaşanması durumunda gelecekte yaşanmasının daha muhtemel olduğunu belirtir. Örneğin, bir madeni parayı 20 kez çevirirseniz ve ilk 15 kafa ise, bu yanlışlık, kalan uçların kafa olma ihtimalinin daha yüksek olduğunu, çünkü şu anda bir çizgi olduğunu belirtir. 0 modunda, bu program aynı şekilde çalışır, ancak rakibin şimdiye kadar en sık attığı iki hamleden birini atacağını varsayması dışında.

Yani evet, bu iki program birbirinden sadece bir karakter. :)

Dienstag (Python 2)

İlk girişim Pony , ikinci tahminleri (tripple tahminleri, ...) ve meta akıl yürütmeleri ile oldukça iyi anlaşıyor. Fakat bu gerekli mi?

İşte Pony'nin küçük arkadaşı Dienstag, 55 stratejiden sadece biriyle: Rakibin bir sonraki hamlesini tahmin et ve onu yen.

Uzun vadede Dienstag, mevcut liderlik tablosunun ilk onundaki her Bot ile kazanır ya da bağlanır. Midilli hariç.

import sys
if len(sys.argv)<2 or len(sys.argv[1])<2: print 'L'; sys.exit()
hist = [map('RPSVL'.index, p) for p in zip(sys.argv[1], sys.argv[2])]
N = len(hist)
cand = range(N-1)
for l in xrange(1,N):
    cand = ([c for c in cand if c>=l and hist[c-l+1]==hist[-l]] or cand[-1:])
print 'RPSVL'[(hist[cand[-1]+1][1]+(1,3)[N%2==0])%5]

Olarak çalıştırmak:

python Dienstag.py

Kodun biraz karışık olduğunu kabul ediyorum. Herhangi biri hakkında daha fazla şey bilmek isteyen olursa açıklama ekleyebilirim.

Düzenleme: İşte fikri açıklamak için kısa bir örnek:

• Program, kendi geçmişini ve rakibin hamlelerini alır:

  sys.arg[1] = 'LLVLLVL', sys.arg[2] = 'RPSPSSP'

• Tarih bir çiftler listesine eklenir ve hamleler sayılara çevrilir (R = 0, ...):

  hist = [[4, 0], [4, 1], [3, 2], [4, 1], [4, 2], [3, 2], [4, 1]]

• Şu ana kadar oynanan tur sayısı belirlendi:

  N = 7

• Şimdi temel fikir, önceki tarihteki son hamlelerin en uzun kopmamış zincirini aramak. Program, böyle bir zincirin listede cand("adaylar" için) nerede bittiğini takip eder . Başlangıçta, kontrol etmeden geçmişte sonuncusu hariç her pozisyon göz önünde bulundurulur:

  cand = [0, 1, 2, 3, 4, 5]

• Şimdi olası zincirlerin uzunluğu adım adım arttırıldı. Zincir uzunluğu l = 1için, son hareket çiftinin önceki oluşumlarını arar [4, 1]. Bu tarih pozisyonunda bulunabilir 1ve 3. Sadece bunlar candlistede tutulur :

  cand = [1, 3]

• Daha l = 2sonra, muhtemel adaylardan hangisinin önce ikinci ile son hamle çiftinden önce geldiğini kontrol eder [3, 2]. Bu sadece pozisyon için geçerlidir 3:

  cand = [3]

• İçin l = 3ve daha oradaki uzunluğun daha önce zincirleri ve candboş olurdu. Bu durumda son elemanı candtutulur:

  cand = [3]

• Bot şimdi tarihin tekrar edeceğini varsayıyor. Cain en son [3, 2], [4, 1]meydana geldiğinde onu takip etti [4, 2]. Böylece rakip (Spock) veya (rock) 2tarafından dövülebilecek (makas) oynadı . Bot , tuhaf olup olmadığına bağlı olarak birinci veya ikinci alternatifle , hatta sadece bazı sapmalar ortaya çıkarmak için cevap verir .(2+1)%5 = 3(2+3)%5 = 0N

• İşte 3daha sonra geri çevrilecek olan hamle seçildi:

  print 'V'

Not: Dienstag, N turdan sonra bir sonraki hareketi döndürmek için zaman karmaşıklığına sahiptir ( N ² ) . Midilli zaman karmaşıklığı O sahiptir ( K ³ ). Yani bu açıdan diğer girişlerden sonra muhtemelen çok daha kötü.

Bash Kayalar

Cygwin çalışma zamanı olarak sormak için fazla mı?

bashrocks.sh:

#!/bin/bash
HAND=(R P S L V)
RAND=`od -A n -t d -N 1 /dev/urandom | xargs`
echo ${HAND[ $RAND  % 5 ]}

ve bu şekilde çalıştırın:

sh bashrocks.sh

Algoritma

Sahip olmak uğruna bir algoritma.

Çünkü bir şeyler yapmak her zaman daha güvenlidir, ne kadar karmaşık olursa o kadar iyi.

Henüz ciddi bir matematik yapmadım, bu yüzden bu algoritma o kadar etkili olmayabilir.

import random, sys

if __name__ == '__main__':

    # Graph in adjacency matrix here
    graph = {"S":"PL", "P":"VR", "R":"LS", "L":"VP", "V":"SR"}
    try:
        myHistory = sys.argv[1]
        opHistory = sys.argv[2]
        choices = ""

        # Insert some graph stuff here. Newer versions may include advanced Math.
        for v in graph:
            if opHistory[-1] == v:
                for u in graph:
                    if u in graph[v]:
                        choices += graph[u]

        print random.choice(choices + opHistory[-1])

    except:
        print random.choice("RPSLV")

Python 2 programı: python algorithm.py

FairBot, Ruby

Basit başlayalım.

puts ['R','P','S','L','V'].sample

Gibi koş

ruby fairbot.rb

ViolentBot

Bu bot, rakiplerin önceki seçimlerine göre en şiddetli olanı seçiyor:

import sys

choice_dict = {"L" : "S", "P" : "S", "R" : "V", "S" : "V", "V" : "L"}

total = len(sys.argv)
if total==1:
    print("L")
    sys.exit()

opponent = sys.argv[2]
opponent_last = opponent[-1]

print(choice_dict[opponent_last])

Olarak çalıştırmak

python ViolentBot.py (me) (opp)

Haskell - MonadBot

Ghc'nin “aklın içinde” sayılıp sayılmadığını bilmiyorum, ama farz edelim de. Bu botun stratejisi, rakibinin en popüler hamlesine karşı koymak.

Compile: ghc monadbot.hs
Run:     ./monadbot [Arg1] [Arg2]

Kod:

import System.Environment
import Data.List
import Data.Ord

main :: IO ()
main = do
  args <- getArgs
  let moves = if not (null args) then args !! 1 else ""
      fave = if not (null moves) then head $ maximumBy (comparing length) (group $ sort moves) else 'V'
  putChar $ case fave of 'R' -> 'P'
                         'P' -> 'S'
                         'S' -> 'R'
                         'L' -> 'R'
                         'V' -> 'P'
                         _   -> 'V'