KOTH: Pandemia na całym świecie

82

Ostateczne wyniki są tutaj!

Wprowadzenie

W 2042 r. Świat został przeludniony. Globalizacja, przeludnienie, nowy styl życia i globalny brak higieny spowodowały rozprzestrzenienie się nowej pandemii. W tych trudnych czasach przywódcy państw muszą poradzić sobie z sytuacją. Nie możesz pozwolić, by twoja populacja została zdziesiątkowana, ale być może mógłbyś skorzystać, pozwalając swoim sąsiadom umrzeć ...

Słownik

Zdrowy : Ludzie niezainfekowani
Zarażeni : Ludzie, którzy mogą umrzeć w wyniku pandemii
Martwy : Liczba ciał, brak konkretnego efektu (tylko punktacja)
Współczynnik infekcji : Liczba zdrowych, którzy zostaną zarażeni w każdej turze
Współczynnik zarażenia : Procent zainfekowanych , którzy zamienią Zdrowych na Zarażonych w każdej turze Wskaźnik
śmiertelności : odsetek zainfekowanych, którzy umrą w każdej turze Wskaźnik
migracji : odsetek zarówno zdrowych, jak i zainfekowanych, którzy będą emigrować / emigrować w każdej turze
Lokalnie: Wpływa tylko na twój stan
Globalny : Wpływa na każdy stan

Zasada

Każdy z graczy będzie zarządzał jednym miastem, zaczynając od 100 osób . Niestety, wśród nich jest jeden Zarażony .

Gra jest turowa. Tura składa się z siedmiu faz , przy czym ostatnia jest interaktywna (proszenie botów o polecenie). Kolejność graczy jest losowa w każdej turze. Kolejna faza rozpoczyna się, gdy poprzednia faza zostanie wykonana przez każde miasto (Tura 1: Gracz 1, Gracz 2, Gracz 3 ...; Tura 2: Gracz 3, Gracz 2, Gracz 1 ...):

1. Mutation                                 - AUTOMATED
2. Reproduction                             - AUTOMATED
3. Migration                                - AUTOMATED
4. Infection                                - AUTOMATED
5. Contagion                                - AUTOMATED
6. Extinction                               - AUTOMATED
7. Players Turn                             - INTERACTIVE

Kontroler udostępnia dane wejściowe za pomocą argumentów poleceń, a program musi wyświetlać dane wyjściowe za pomocą standardowego wyjścia.

Składnia

Wejście

Za każdym razem, gdy wywoływany jest twój program, będzie on otrzymywał argumenty w następującym formacie:

Round;YourPlayerId;PlayerId_Healthy_Infected_Dead_InfectionRate_ContagionRate_LethalityRate_MigrationRate;PlayerId_Healthy_Infected_Dead_InfectionRate_ContagionRate_LethalityRate_MigrationRate;...

Rundy są indeksowane 1.

Przykładowe dane wejściowe

6;2;1_106_23_9_2_4_13_5;0_20_53_62_16_20_35_5;2_20_53_62_16_20_35_5

Tutaj widzisz, że jest to szósta runda i jesteś graczem 2. Masz 20 zdrowych, 53 zainfekowanych, 62 martwych, 16% infekcji, 20% współczynnika zarażenia, 35% śmiertelności i 5% migracji.

Wynik

Musisz wydać trzy znaki (bez spacji, bez separatora), z których każdy odpowiada jednej akcji, którą wykonasz w tej turze. Kolejność znaków określa kolejność akcji. Możesz wygenerować te same działania wiele razy.

N: Do N żaden przepis
M: Badanie M icrobiology [Efekty: Zmniejszenie lokalnej infekcji Ocena 4%]
E: Badanie E pidemiology [Efekty: zmniejsza miejscowe Contagion Cena 8%]
I: Badanie I mmunology [Efekty: Zmniejszenie miejscowego śmiertelne działanie Ocena 4%]
V: badania V accination [Efekty: zmniejszenie lokalnej infekcji Cena jednym, zmniejsza miejscowe Contagion Ocena 4%, zmniejsza miejscowe letalność Ocena 2%]
C: Daj C URE [efektów: Konwersja 10 lokalnego Zainfekowane na zdrowe ]
Q: Q uarantine [Efekty: Usuń 30 lokalnych zainfekowanych ]
O: O pen Borders [Efekty: Zwiększ lokalną migrację o 10%]
B: Zamknij zamówienia B [Efekty: Zmniejsz lokalną migrację o 10%]
T: Błąd T Bio [Efekty: Konwersja 4 globalny zdrowe do zakażonych ]
W: w eaponization [efektów: wzrost światowego infekcji Ocena 1, wzrost globalnych letalność Ocena 2%]
D: D issemination [Efekty: wzrost światowego infekcji Oceńo 1, zwiększ globalną Współczynnik Zarażenia o 2%]
P: P acyfikacja [Efekty: Zmniejsz globalną Współczynnik Zarażenia o 1, zmniejsz globalną Współczynnik Zarażenia o 1%, zmniejsz globalną Współczynnik Śmiertelności o 1%]

Rozgrywka

Wszystkie fazy

Nieprawidłowe polecenie = Nic
Procent sumuje się jak liczby całkowite, tj. 10% - 4% = 6%. Po zastosowaniu procentu w formule wynik zostaje zmieniony.

Faza 1: Mutacja

Pandemia staje się coraz silniejsza. W każdej turze losowo zyskuje jeden z tych atrybutów (mutacja dotyczy wszystkich graczy jednocześnie):

  • Zwiększ globalny wskaźnik infekcji o 2
  • Zwiększ globalny współczynnik zarażenia o 5%
  • Zwiększ globalny wskaźnik śmiertelności o 5%

Faza 2: Powielanie

Co pięć rund (runda 5, 10, 15 ...) rodzą się nowi obywatele. Każda para Zdrowych sprawi, że jeden Zdrowy (23 Zdrowych wygeneruje 11 nowych Zdrowych ). Każda para Zainfekowanych spowoduje jedną Zainfekowaną .

Faza 3: Migracja

W każdej turze procent Zdrowych i Zainfekowanych opuszcza stany, w zależności od ich współczynnika migracji (10 Zdrowych opuszcza stan o 100 Zdrowych i 10% Współczynnika migracji ). Następnie migranci zostaną rozdzieleni między wszystkie państwa, ponownie w zależności od wskaźnika migracji . (Stawki dla każdego stanu są ważone, a następnie wszyscy migranci są odpowiednio dystrybuowani).

Faza 4: Zakażenie

Zdrowe każdego stanu są konwertowane na Zainfekowane , zgodnie ze współczynnikiem infekcji .

Faza 5: Zakażenie

Zdrowe każdego stanu są konwertowane na Zarażone , zgodnie z Współczynnikiem Zarażenia . Liczbę oblicza się, mnożąc Zarażonego przez Współczynnik Zarażenia .

Faza 6: Wyginięcie

Zainfekowani są konwertowani na Dead , zgodnie ze współczynnikiem śmiertelności . Liczbę oblicza się, mnożąc Zarażonego przez Wskaźnik Śmiertelności .

Faza 7: tura graczy

Każdy gracz otrzymuje dane wejściowe i musi wykonać trzy akcje, które są wykonywane w kolejności, w jakiej są wyprowadzane.

Zasady

  • Boty nie powinny być pisane w celu pokonania lub wspierania określonych innych botów.
  • Zapis do plików jest dozwolony. Napisz do „twojasubmissionname.txt”, folder zostanie opróżniony przed rozpoczęciem gry. Inne zasoby zewnętrzne są niedozwolone.
  • Twoje zgłoszenie ma jedną sekundę na odpowiedź (na miasto).
  • Podaj polecenia, aby skompilować i uruchomić swoje zgłoszenia.

Zwycięski

Zwycięzcą jest ten, który jest najbardziej zdrowy po 50 rundach. Jeśli gracz jest ostatnim żywym (więcej niż 0 Zdrowych lub Zainfekowanych ) gra zatrzymuje się i wygrywa. Jeśli wielu graczy ma taką samą liczbę Zdrowych , wygra ten, który ma najwięcej Zainfekowanych , a ten z mniejszą liczbą Zabitych .

Kontroler

Kontroler można znaleźć na GitHub . Zawiera także trzy sampleboty napisane w Javie.
Aby go uruchomić, sprawdź projekt i otwórz go w swoim Java IDE. Punkt wejścia w mainmetodzie klasy Game. Wymagana Java 8.

Aby dodać boty, najpierw potrzebujesz skompilowanej wersji dla Javy (pliki .class) lub źródeł tłumaczonych języków. Umieść je w folderze głównym projektu. Następnie utwórz nową klasę Java w playerspakiecie (możesz wziąć przykład z już istniejących botów). Ta klasa musi zostać zaimplementowana, Playeraby zastąpić metodę String getCmd(). Zwrócony ciąg to polecenie powłoki do uruchamiania botów. Można na przykład wykonać pracę bota Ruby z tym poleceniem: return "C:\Ruby\bin\ruby.exe MyBot.rb";. Na koniec dodaj bota do playerstablicy na górze Gameklasy.

Ostateczne wyniki (2016-03-04 08:22 GMT)

Globalna (100 reputacji):

Wyniki 100 gier: http://pasted.co/942200ff

1. EvilBot (24, 249, 436)
2. Triage (23, 538, 486)
3. WICKED (23, 537, 489)
4. Israel (23, 40, 240)
5. InfectedTown (22, 736, 482)
6. ZombieState (22, 229, 369)
7. Mooch (22, 87, 206)
8. InfectedHaven (21, 723, 483)
9. Crossroads (16, 9, 136)
10. TheKeeper (3, 4, 138)
11. Terrorist (0, 595, 496)
12. InfectionBot (0, 511, 430)
13. FamilyValues (0, 6, 291)
14. UndecidedBot (0, 0, 20)
15. XenoBot (0, 0, 26)
16. Researcher (0, 0, 33)
17. Strategist (0, 0, 42)
18. TheCure (0, 0, 55)
19. Socialist (0, 0, 67)
20. TrumpBot (0, 0, 77)
21. CullBot (0, 0, 81)
22. BackStabber (0, 0, 87)
23. BlunderBot (0, 0, 104)
24. RemoveInfected (0, 0, 111)
25. PFC (0, 0, 117)
26. BioterroristBot (0, 0, 118)
27. PassiveBot (0, 0, 118)
28. Smaug (0, 0, 118)
29. WeaponOfMassDissemination (0, 0, 119)
30. AllOrNothing (0, 0, 121)
31. Obamacare (0, 0, 122)
32. DisseminationBot (0, 0, 123)
33. CureThenQuarantine (0, 0, 125)
34. Madagascar (0, 0, 129)
35. OpenAndClose (0, 0, 129)
36. ThePacifist (0, 0, 130)
37. MedicBot (0, 0, 131)
38. Medic (0, 0, 133)
39. Salt (0, 0, 134)
40. Piecemeal (0, 0, 136)
41. Graymalkin (0, 0, 137)
42. PureBot (0, 0, 140)
43. MadScienceBot (0, 0, 144)
44. BipolarBot (0, 0, 149)
45. RedCross (0, 0, 151)

Doomsday-less (200 reputacji):

Wyniki 100 gier: http://pasted.co/220b575b

1. FamilyValues (5708, 14, 2)
2. BlunderBot (5614, 12, 3)
3. Graymalkin (5597, 17, 4)
4. PureBot (5550, 12, 5)
5. Crossroads (5543, 11, 4)
6. Salt (5488, 24, 7)
7. CureThenQuarantine (5453, 13, 7)
8. Piecemeal (5358, 121, 23)
9. TrumpBot (5355, 12, 5)
10. CullBot (5288, 12, 9)
11. AllOrNothing (5284, 13, 10)
12. Madagascar (5060, 180, 35)
13. TheKeeper (4934, 165, 44)
14. WICKED (4714, 25, 5)
15. Strategist (2266, 25, 5)
16. BackStabber (2180, 1327, 596)
17. RemoveInfected (2021, 33, 27)
18. OpenAndClose (1945, 667, 394)
19. Triage (1773, 401, 80)
20. TheCure (1465, 46, 26)
21. Obamacare (1263, 525, 247)
22. Mooch (1103, 546, 269)
23. Israel (1102, 580, 292)
24. RedCross (1086, 1700, 727)
25. ThePacifist (1069, 636, 580)
26. Researcher (1035, 113, 37)
27. UndecidedBot (825, 219, 93)
28. PassiveBot (510, 990, 567)
29. MedicBot (411, 1474, 667)
30. Medic (392, 1690, 619)
31. Socialist (139, 63, 90)
32. XenoBot (0, 82, 170)

Dziękujemy wszystkim za udział. Mam nadzieję, że świetnie się bawiłeś, projektując i kodując boty, tak jak podczas gry.

king-of-the-hill 
— Thrax
źródło
9
Czy możemy otrzymać polecenie E xecute, które zabija X zainfekowanych osób (zamieniając ich w martwych)? Prawdopodobnie nie jest to realna metoda na wygraną, ale działanie, które wydaje się uzasadnione. Chyba że robi to Kwarantanna (nie jest jasne).
— Draco18s,
3
Krótka uwaga gramatyczna: „Rozsądny” oznacza „stabilny psychicznie”; słowo (prawdopodobnie), którego tu szukasz, to „zdrowe”. (Czy miałbym rację, zgadując, że twoim pierwszym językiem jest hiszpański, gdzie „sano” oznacza „zdrowy” lub coś blisko spokrewnionego?)
— Mason Wheeler
5
@MasonWheeler terminologia nitpicking uwaga: Twoja uwaga była terminologia lub słownictwo nuta jak nie było gramatyka zaangażowany;)
— Jan
3
@Thrax Sposób, w jaki tury są obecnie obsługiwane (losowe na początku, ta sama kolejność od tej pory), daje graczom, którzy przyjdą później w kolejności tury, ogromną przewagę, co sprawia, że ​​wynik końcowy jest bardzo zmienny. Być może, jeśli: 1) losowo wybierzesz kolejność tury w każdej rundzie lub 2) sprawisz, że wszyscy zobaczą ten sam stan podczas swojej tury i zastosują zmiany do wszystkich jednocześnie pod koniec rundy, wtedy wyniki mogą być bardziej zrównoważone i być oparte więcej na temat jakości zgłoszenia. Przetestowałem pierwszą opcję, a wyniki są znacznie bardziej spójne.
— Mwr247
7
@Thrax Obecnie istnieje nadmiar botów, które istnieją po to, by „zniszczyć świat”. Chociaż może to być zabawne wyzwanie, w tym momencie boty faktycznie próbujące konkurować nie mogą już skutecznie tego przeciwdziałać, a my zostajemy z wszelkimi botami zaprogramowanymi na „Cure X 3” jako zwycięzcami. Chciałbym zasugerować zmianę reguły, w której aby być branym pod uwagę przy KOTH, boty muszą przynajmniej być w stanie zakończyć się pozytywnymi „sanami” w pojedynku 1 na 1 z PassiveBot? Wyzwanie jest przyjemniejsze, gdy strategie faktycznie przynoszą efekty.
— Mwr247

Odpowiedzi:

12

Wartości rodzinne, węzeł (ES6)

// Process input
var data = process.argv[2].split(';');
var round = data.shift()*1;
var id = data.shift()*1;
var playerCount = data.length;
var local = data.find(function(v) {
  return !v.indexOf(id+'_')}
).split('_');
local = {
  sane: local[1]*1,
  infected: local[2]*1,
  dead: local[3]*1,
  infectionRate: local[4]*1,
  contagionRate: local[5]*1,
  lethalityRate: local[6]*1,
  migrationRate: local[7]*1
};

// Determine response
var response = [];
for(var i=0;i<3;i++) {
  var model = {
    M: local.infectionRate,
    E: local.contagionRate * (local.sane > 0 ? 1 : 0.5),
    I: local.lethalityRate * (round > 45 ? 0 : local.sane > 0 ? 1 : 2),
    V: (local.infectionRate/4 + local.contagionRate/2 + local.lethalityRate/2) * (round > 45 ? 0 : 1),
    C: local.infected / Math.max(local.infectionRate, 1) * (round > 48 ? round : local.infectionRate + local.contagionRate/100 * local.infected < (3 - i) * 10 ? 1 : 0),
    B: local.migrationRate * 10
  };
  var max = 'M';
  for(k in model) {
    if (model[k] > model[max] ) {
      max = k;
    } else if(model[k] == model[max]) {
      max = [max, k][Math.random()*2|0];
    }
  }
  response.push(max);

  // Refactor priorities
  if(max == 'M') {
    local.infectionRate -= 4;
  } else if(max == 'E') {
    local.contagionRate -= 8;
  } else if(max == 'I') {
    local.lethalityRate -= 4;
  } else if(max == 'V') {
    local.infectionRate -= 1;
    local.contagionRate -= 4;
    local.lethalityRate -= 2;
  } else if(max == 'C') {
    local.infected -= 10;
  } else if(max == 'B') {
    local.migrationRate -= 10;
  }
}

// Respond with actions
process.stdout.write(response.join(''));

Wartości rodzinne koncentrują się na samozachowawczości i obronie i wykonują jedynie działania w tym celu. Korzysta z systemu wartości punktowej, aby określić najlepszy sposób działania, a następnie dostosowuje własne wartości statusu, aby lepiej określić jego następny priorytet. W przypadku remisu losowo wybiera jedną z najlepszych opcji.

EDYCJA: Wydaje się, że do tej pory wszystko było w porządku:

    ********** FINISH **********
    1. FamilyValues (1143, 0, 188)
    2. Triage (582, 0, 158)
    3. Researcher (281, 0, 142)
    4. Madagascar (149, 0, 162)
    5. Mooch (148, 0, 331)
    6. MedicBot (142, 0, 161)
    7. Medic (66, 65, 211)
    8. XenoBot (0, 0, 22)
    9. WMDbot (0, 0, 218)
    10. PassiveBot (0, 0, 221)
    11. BioterroristBot (0, 0, 221)
    12. MadScienceBot (0, 0, 221)
    13. DisseminationBot (0, 0, 221)
    14. TheCure (0, 0, 222)

The Pacifist, Node

// Process input
var data = process.argv[2].split(';');
var round = data.shift()*1;

// Respond with actions
process.stdout.write(round == 1 ? 'OOO' : 'PPP');

Przy tak dużym skupieniu się na zabijaniu i śmierci, pacyfista uważa, że ​​silne zdrowie na świecie oznacza silne zdrowie lokalne. Jako takie, skupiają się głównie na zmniejszeniu globalnej choroby, pozostawiając częściowo otwarte granice, aby umożliwić rozprzestrzenianie się dobroci.

— Mwr247
źródło
Wow, nie spodziewałem się, że TheCure będzie ostatnim
— tylko
@ justhalf Przy tak dużej liczbie graczy wszyscy poruszają się dużo na planszach: właśnie uruchomiłem jednego, w którym TheCure skończył na 3 miejscu. Zarówno FamilyValues, jak i Triage są prawie zawsze w pierwszej dwójce, a FV zdobywa pierwsze miejsce przez większość czasu.
— Mwr247,
Hmm, samo zadanie jest deterministyczne, prawda? Czy to dlatego, że niektórzy gracze wprowadzają losowość do swojego algorytmu?
— justhalf
@justhalf Zdecydowanie największym czynnikiem wydaje się kolejność tur, która jest losowa (ale taka sama dla każdej rundy w grze). Wybranie pierwszego oznacza, że ​​nie masz szansy zareagować na działania wszystkich podczas bieżącej tury, natomiast przejście do ostatniego pozwala najlepiej dostosować się do tego, co zrobili ci inni gracze.
— Mwr247,
1
@ justhalf Właśnie przetestowałem zmodyfikowany kontroler, który losowo porządkuje kolejkę dla każdej rundy, a wyniki są teraz znacznie bardziej spójne.
— Mwr247
27

TrumpBot

private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    //states.add(new State(args[thisTownID+2]));

    otherStates = new ArrayList<>();


    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.ownerId == thisTownID) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    StringBuilder cmd = new StringBuilder();

    for (int j =0;j<3;j++){
        if (thisState.infected > 7) {
          if (thisState.infected > 25){
            cmd.append("Q");
            thisState.infected -= 30;
          }
          else {
            cmd.append("C");
            thisState.infected -= 10;
          }
        }
        else if (thisState.migrationRate > 2) {
          cmd.append("B");
          thisState.migrationRate -= 10;
        }
        else if (thisState.infectionRate > 4) {
          cmd.append("M");
          thisState.infectionRate  -= 4;
        }
        else if (thisState.contagionRate > 10 || thisState.lethalityRate > 6 || thisState.infectionRate > 0) {
          cmd.append("V");
          thisState.contagionRate  -= 4;
          thisState.lethalityRate  -= 2;
          thisState.infectionRate  -= 1;
        }

        else if (thisState.infected % 10 <= 6){
          cmd.append("T");
          thisState.infected +=4;
        }
        else cmd.append("V");
    }
    System.out.print(cmd.reverse());
}

Sprawia, że ​​Ameryka jest świetna, lecząc wszystkich zarażonych, chyba że są tylko 2 lub mniej; mniejszości zostaną zignorowane.

Mniej infekcji sprawia, że ​​lek jest tańszy.

Nie potrzebuje imigrantów - przynoszą tylko infekcje.

Jeśli nie ma już nic do roboty, zbombarduj innych graczy.

Odwrócony rozkaz dowodzenia na sposób amerykański, bomby najpierw leczą ludzi później.

Edycja: naprawiono błąd, który spamował leczy, ponieważ liczba zainfekowanych nie została zmniejszona po wyleczeniu.

Trumpscript

Dziękujemy J Atkinowi za zapewnienie:

Make turn 4000000
As long as, turn larger than 1000000;:
If, refugee count > 2000000;: say "C"!
Else if, infectionRate > 200000;: say "M"!
Else if, immigration rate > 9000000;: say "B"!
Else: say "T"!
Make turn old turn - 1000000!
America is Great.
— Eumel
źródło
14

AllOrNothing, R

args <- strsplit(commandArgs(TRUE),";")[[1]]
round <- as.integer(args[1])
me <- as.integer(args[2])
stats <- do.call(rbind,strsplit(args[-(1:2)],"_"))
stats <- as.data.frame(apply(stats,2,as.integer))
colnames(stats) <- c("id","Sane","Infected","Dead","InfRate","ContRate","LethRate","MigRate")
out <- ""
statme <- stats[stats$id==me,]
while(nchar(out)<3){
    if(round==1 & !nchar(out)){
        out <- paste0(out, "B")
    }else if(round%%5==4 & statme$Infected > 20){
        statme$Infected <- statme$Infected - 30
        out <- paste0(out, "Q")
    }else if(statme$Sane*statme$InfRate/100 >= 1){
        o <- ifelse(statme$Sane*statme$InfRate/100 < statme$Infected*statme$ContRate/100, "C", "M")
        if(o=="C") statme$Infected <- statme$Infected - 10
        if(o=="M") statme$InfRate <- statme$InfRate - 4
        out <- paste0(out, o)
    }else if(statme$Infected > 0){
        statme$Infected <- statme$Infected - 10
        out <- paste0(out, "C")
    }else if(median(stats$LethRate)<20){ 
        out <- paste0(out, "W")
    }else{
        out <- paste0(out, "E")     
    }
}
cat(substr(out,1,3))

Wywoływany przez Rscript AllOrNothing.R.

Chodzi tutaj z jednej strony o ograniczenie do maksimum ryzyka infekcji (poprzez obniżenie wskaźnika infekcji, wyleczenie zainfekowanych i zapobieganie imigracji), a z drugiej strony zwiększenie śmiertelności choroby, aby ludzie, którzy ją dostali zarażeni, umierają przed skażeniem innych.

Edycja: trochę poprawiono strategię.

— plannapus
źródło
Fajnie, wydaje się, że robi to wyjątkowo dobrze przeciwko 21 innym państwom!
— Thrax,
@Thrax Rzeczywiście, chociaż czasami, podczas niektórych uruchomień, nadal zawodzi dość imponująco :) Ale najczęściej udaje się tak, jak w przypadku uruchomienia testowego.
— plannapus
to całkiem niesamowity bot, dobra robota
— Eumel
Wygląda to bardzo podobnie do stanu, który zamierzałem napisać, kiedy znalazłem czas, jeśli nie identyczny. Mój istnieje jednak tylko w mojej głowie („jeśli 20 zarażonych, poddaj je kwarantannie, jeśli 10 zaraż, wylecz je itp.”), Więc dobra robota.
— Draco18s,
13

Lekarski

Medyk był zawsze ... zmartwiony , że tak powiem, przez ludzi bez lekarstw. Uwielbia praktykować medycynę, więc to wszystko, co robi. Lubi także pytony, więc napisał swój kod w Pythonie. Wszystko ma sens, jeśli się nad tym zastanowić. Nie, tak naprawdę nie jest. Właściwie to trochę ...

from random import *
commands = ""
while len(commands) < 3:
    chance = random()
    if chance < .5: commands += "V"
    elif chance < .66: commands += "I"
    elif chance < .84: commands += "E"
    else: commands += "M"

print(commands)

Jestem tu by pomóc.

Jestem tu by pomóc.

— Conor O'Brien
źródło
4
Pytony jak w pręcie Asklepiosa? Lub jak w sztabie Hermesa? To może mieć jakiś sens ...
— Nie, że Charles
3
Zarówno! Obie! Dlaczego nie? To wszystko ma sens!
— Conor O'Brien
7
++ 1; dla TF2: D
— kot
11

The Cure

Wydaje się to nieco zbyt uproszczone, ale wydaje się również, że jest to całkiem dobra metoda ograniczania liczby infekcji / śmierci. Na każdym kroku wyjścia MCQ:

  • Zmniejszyć wskaźnik infekcji
  • Wylecz niektóre zainfekowane
  • Poddaj kwarantannie niektóre z pozostałych zainfekowanych

Otóż ​​to! 

public class TheCure{
    public static void main(String[]a){
        System.out.println("MCQ");
    }
}

Prawdopodobnie mógłbym to poprawić, wysyłając więcej M(lub B), jeśli nie mam aktualnie zainfekowanego zamiast leczyć i poddać kwarantannie, ale chciałbym zobaczyć, jak dobrze to robi. Niestety, jednym z efektów ubocznych pierwszego opublikowania jest to, że trudno jest ocenić skuteczność:

— Geobity
źródło
9

WICKED, Kotlin

Pamiętaj, że WICKED jest dobry.

package wicked

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = it.infectionRate //Allow negative healthy.
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = (it.infected * it.contagionRate).toInt()
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1[myId].healthy
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    val currentGame = Game(players)

    if (round == 50) {
        println("CCC")  //Extra 30 at end of game.
        return
    }

    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    if (game[myId].lethalityRate > .02) {        //Save the executives!!!
        return 'I'
    } else if (game[myId].lethalityRate > 0) {
        return 'V'
    }

    val bestAction = "NMEIVQCOBP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

Kompiluj z: kotlinc WICKED.kt
Uruchom z:kotlin wicked.WICKEDKt

PFC, Kotlin

Próby uwolnienia choroby u wszystkich.

package pfc

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = Math.min(it.healthy, it.infectionRate)
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = Math.min(it.healthy, (it.infected * it.contagionRate).toInt())
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1.players.sumBy { it.infected }
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    @Suppress("UNUSED_VARIABLE")
    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    val currentGame = Game(players)

    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    val bestAction = "NMEIVCQOBTWDP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

Kompiluj z: kotlinc PFC.kt
Uruchom z:kotlin pfc.PFCKt

Terrorysta, Kotlin

Stara się zabić wszystkich ludzi.

package terrorist

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = Math.min(it.healthy, it.infectionRate)
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = Math.min(it.healthy, (it.infected * it.contagionRate).toInt())
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1.players.sumBy { it.dead }
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    @Suppress("UNUSED_VARIABLE")
    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    if (round == 50) {
        println("TTT")  //Let's mess up the scoreboard :D
        return
    }

    val currentGame = Game(players)
    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    if (game[myId].lethalityRate > .02) {          //We don't want to hurt ourselves.
        return 'I'
    } else if (game[myId].lethalityRate > 0) {
        return 'V'
    }

    val bestAction = "NMEIVCQOBTWDP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

Kompiluj z: kotlinc Terrorist.kt
Uruchom z:kotlin terrorist.TerroristKt

— Numer jeden
źródło
Kompilacja daje mi „niegodziwy” folder z klasami Game, Player i WICKEDkt. Uruchomienie zgodne z opisem zwraca: „błąd: nie można znaleźć lub załadować głównej klasy niegodziwej. WICKEDKt”
— Mwr247,
To dziwne, działa dobrze na moim komputerze. Czy na pewno plik klasy WICKEDkt nie ma nazwy WICKEDKt? Upewnij się również, że katalog roboczy nie znajduje się w folderze niegodziwym.
— TheNumberOne
To jest WICKEDKt. Wpisałem w komentarzu.
— Mwr247
@ Mwr247 Czy pozostawiłeś wygenerowany niegodziwy folder w folderze zgłoszeń? Czy przeniesiłeś wygenerowane pliki z niegodziwego folderu?
— TheNumberOne
WICKED jest dobry ... niech cię diabli i twoje odniesienia do rzeczy, które właśnie przeczytałem.
— ArtOfCode
9

Madagaskar, Java

Tak, jadąc drogą Madagaskaru. W pierwszej rundzie BBBzamykamy nasze granice. W przeciwnym razie daje lekarstwo i skupia się na lokalnych szczepionkach. 

public class Madagascar{
    public static void main(String[]args){
        Boolean bool = false;
        bool = args[0].startsWith("1;");

        if(bool) {
            System.out.println("BBB");
        }
        else {
            System.out.println("CVV");
        }
    }
}

Edit1 - I more-Madagascar'd
Edit2 - Dzięki @Geobits za startsWithprzypomnienie

— AdmBorkBork
źródło
jeśli Geobity mają rację co do szybkości migracji od 5 i nie dają się zredukować do zera, B nie robią absolutnie nic.
— kwintopia
Obecnie nie wygląda to na kompilację. if (b == true)(co powinno być if (b)kwestią stylu) spowoduje błąd, ponieważ zmienna jest faktycznie wywoływana bool.
— Peter Taylor
nie byłoby, gdyby sprawdzanie względem rundy == 1 działało o wiele lepiej niż tworzenie pliku?
— Eumel
1
@TimmyD Na szczęście runda jest pierwsza, więc nie trzeba dużo analizować. Wystarczy sprawdzić, czy dane wejściowe zaczynają się od1;
— Geobits
@Geobits Dzięki za startsWith()przypomnienie. O wiele łatwiejsze niż dzielenie się ;i próba odzyskania i ... Powiedziałem, że byłem zardzewiały z Javą.
— AdmBorkBork
7

Sól, Kotlin

Ten bot przetrwa, dopóki wszyscy paskudni gracze nie zginą. Następnie leczy ludność i zaludnia miasto zdrowymi ludźmi.

Ten bot ma 5 kroków:

  1. Zamknij granice.
  2. Pozwól zainfekowanym umrzeć, ale nie za szybko (trudność polega na ustaleniu, jak szybko jest za szybko).
  3. Zapobiegaj zarażeniu zdrowych osób.
  4. Wylecz zainfekowanych (solą: P).
  5. Rozmnażać się.

Oto on:

package salt

import java.io.File
import java.util.*

data class Player(
        val id            : Int,
        var healthy       : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Int,
        var lethalityRate : Int,
        var migrationRate : Int)

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toInt(), data[6].toInt(), data[7].toInt()))
    }

    if (round == 50) {
        println("CCC")  //Extra 30 at end of game.
        return
    }

    var actionsLeft = 3

    val me = players.first { it.id == myId }
    val dataFile = File("Salt.txt")
    val lastRoundInfected : Int
    var roundsInHole : Int
    if (round == 1) {
        lastRoundInfected = 1
        roundsInHole = 0
    } else {
        val lines = dataFile.readLines()
        lastRoundInfected = lines[0].toInt()
        roundsInHole = lines[1].toInt()
    }

    val wantedInfected = lastRoundInfected * Math.pow(1/1.5, 1.0/5) * (if (round % 5 == 0 && round != 0) 1.5 else 1.0)

    while (me.migrationRate > 0) {
        print('B')          //Close borders
        me.migrationRate = Math.max(0, me.migrationRate - 10)
        actionsLeft--
    }

    if (me.infected <= wantedInfected) {   //Our infected are dieing too quickly
        roundsInHole++
    } else {
        roundsInHole = Math.max(0, roundsInHole - 1)
    }

    if (me.lethalityRate > 0) {
        var lethalityRateDelta = roundsInHole * 2
        while (lethalityRateDelta > 0 && me.lethalityRate > 0 && actionsLeft > 0) {
            if (lethalityRateDelta == 2 || me.lethalityRate <= 2) {
                lethalityRateDelta -= 2
                print('V')  //Research vaccines
                me.infectionRate = Math.max(0, me.infectionRate - 1)
                me.contagionRate = Math.max(0, me.contagionRate - 4)
                me.lethalityRate = Math.max(0, me.lethalityRate - 2)
                actionsLeft--
            } else {
                lethalityRateDelta -= 4
                print('I')
                me.lethalityRate = Math.max(0, me.lethalityRate - 4)
                actionsLeft--
            }
        }
    }

    dataFile.writeText("${me.infected}\n$roundsInHole")

    while (actionsLeft > 0) {
        if (me.infectionRate + me.contagionRate * me.infected / 100 <= 0) {
            break
        }
        val mWeight = Math.min(me.infectionRate, 4)
        val eWeight = Math.min(me.contagionRate, 8) * me.infected / 100
        val vWeight = Math.min(me.contagionRate, 4) * me.infected / 100 + Math.min(me.infectionRate, 1)
        if (mWeight > eWeight && mWeight > vWeight) {
            print('M')      //Research microbiology
            me.infectionRate = Math.max(0, me.infectionRate - 4)
        } else if (eWeight > vWeight){
            print('E')      //Research epidemiology
            me.contagionRate = Math.max(0, me.contagionRate - 8)
        } else {
            print('V')      //Research vaccines
            me.infectionRate = Math.max(0, me.infectionRate - 1)
            me.contagionRate = Math.max(0, me.contagionRate - 4)
            me.lethalityRate = Math.max(0, me.lethalityRate - 2)
        }
        actionsLeft--
    }

    while (actionsLeft > 0) {
        if (me.infected <= 0) {
            break
        }
        print('C')          //Cure
        val cured = Math.min(me.infected, 10)
        me.infected -= cured
        me.healthy += cured
        actionsLeft--
    }

    while (actionsLeft > 0) {
        print('N')          //Do nothing
        actionsLeft--
    }

    return
}

Kompiluj z: kotlinc Salt.kt
Uruchom z:kotlin salt.SaltKt

EDYCJA: Wyższe prawdopodobieństwo przeżycia do momentu śmierci większości botów „końca świata”.

Przykładowe wyniki:

1. Salt (247, 12, 280)
2. InfectedTown (30, 2016, 843)
3. ZombieState (30, 1030, 609)
4. WICKED (30, 413, 222)
5. Triage (18, 965, 706)
6. Mooch (18, 657, 597)
7. MadScienceBot (18, 305, 647)
8. TheKeeper (13, 0, 158)
9. FamilyValues (10, 110, 373)
10. Madagascar (2, 0, 271)
11. Terrorist (0, 1358, 651)
12. InfectionBot (0, 1217, 830)
13. Medic (0, 27, 340)
14. MedicBot (0, 1, 200)
15. UndecidedBot (0, 0, 33)
16. Researcher (0, 0, 63)
17. TheCure (0, 0, 71)
18. TrumpBot (0, 0, 88)
19. WeaponOfMassDissemination (0, 0, 137)
20. Strategist (0, 0, 142)
21. PassiveBot (0, 0, 149)
22. DisseminationBot (0, 0, 152)
23. PassiveBot (0, 0, 155)
24. Crossroads (0, 0, 164)
25. InfectedHaven (0, 0, 170)
26. Socialist (0, 0, 172)
27. BioterroristBot (0, 0, 175)
28. XenoBot (0, 0, 184)
29. ThePacifist (0, 0, 199)
30. CullBot (0, 0, 294)
31. AllOrNothing (0, 0, 327)
— Numer jeden
źródło
Bardzo fajna strategia. Podoba mi się, że używasz śmiertelności w „dobry” sposób!
— Thrax
Dobra robota, która położy kres botom „końca świata”! Jednak sól mogłaby się przewrócić, gdyby było jeszcze kilka takich botów, nie jestem jednak pewien. Zdolność do przeżycia jest już imponująca, miły człowieku!
— busukxuan
@busukxuan W chwili obecnej kilka botów musiałoby zmaksymalizować współczynnik śmiertelności, zanim mogliby to zabić, zabijając się w trakcie tego procesu.
— TheNumberOne
7

PureBot (Haskell)

PureBot nienawidzi jednej rzeczy: Skutki uboczne!
Spróbuje poradzić sobie ze wszystkimi efektami ubocznymi, a jeśli wszystko pójdzie dobrze, zmniejszy ilość efektów ubocznych wytwarzanych przez świat zewnętrzny.
W swoich obliczeniach ignoruje również wszystkie skutki uboczne.
To sprawia, że ​​gra znacznie lepiej przeciwko pasywnym wrogom (które nie zmieniają globalnych stawek).

Jeśli infected, infection, contagion, lethalityi migrationsą zerowe, to pomoże inne boty z P(na Purekomendę).

module Main where
import Control.Monad (void)
import Data.List (find)
import System.Environment (getArgs)
import System.Exit (exitFailure)
import Text.Parsec

-- | The world
data World = World
    { worldRound  :: Int    -- ^ The current round
    , worldTownID :: Int    -- ^ The current town ID
    , worldTowns  :: [Town] -- ^ List of all towns in the world
    }
    deriving (Show)

-- | A town in the world
data Town = Town
    { townID            :: Int -- ^ The town ID
    , townDeath         :: Int -- ^ The number of death people in the town
    , townHealthy       :: Int -- ^ The number of healthy people in the town
    , townInfected      :: Int -- ^ The number of infected people in the town
    , townInfectionRate :: Int -- ^ The infaction rate of the town
    , townContagionRate :: Int -- ^ The contagion rate of the town
    , townLethalityRate :: Int -- ^ The lethality rate of the town
    , townMigrationRate :: Int -- ^ The migration rate of the town
    }
    deriving (Show)

-- | Parse a Int
parseInt :: Parsec String () Int
parseInt = do
    sign <- option '+' $ oneOf "+-"
    numb <- read <$> many1 digit
    return $ if sign == '+'
        then numb
        else negate numb

-- | Parse a town
parseTown :: Parsec String () Town
parseTown = do
    nID <- parseInt
    void $ char '_'
    nHealthy <- parseInt
    void $ char '_'
    nInfected <- parseInt
    void $ char '_'
    nDeath <- parseInt
    void $ char '_'
    nInfectionRate <- parseInt
    void $ char '_'
    nContagionRate <- parseInt
    void $ char '_'
    nLethalityRate <- parseInt
    void $ char '_'
    nMigrationRate <- parseInt
    return Town
        { townID            = nID
        , townDeath         = nDeath
        , townHealthy       = nHealthy
        , townInfected      = nInfected
        , townInfectionRate = nInfectionRate
        , townContagionRate = nContagionRate
        , townLethalityRate = nLethalityRate
        , townMigrationRate = nMigrationRate }

-- | Parse a world
parseWorld :: Parsec String () World
parseWorld = do
    nRound <- parseInt
    void $ char ';'
    nTownID <- parseInt
    void $ char ';'
    towns <- parseTown `sepBy` char ';'
    let nTowns = length towns
    if nTowns < nTownID
        then let nExpected   = (nTownID - nTowns) in
            fail $ "expected at least " ++ show nExpected ++ " more town(s)"
        else return World
            { worldRound  = nRound
            , worldTownID = nTownID
            , worldTowns  = towns }

-- | Update a town
updateTown :: World -> Town -> String
updateTown world town = take 3 $ lastRound
                   ++ prepareForReproduction
                   ++ decreaseInfected
                   ++ decreaseMigration
                   ++ decreaseInfection
                   ++ decreaseContagion
                   ++ decreaseLethality
                   ++ decreaseWorldWide
  where
    -- | The current round number
    nRound         = worldRound world
    -- | The current number of infected
    nInfected      = townInfected town
    -- | The current lethality rate
    nLethalityRate = townLethalityRate town
    -- | The current migration rate
    nMigrationRate = townMigrationRate town
    -- | The current infection rate
    nInfectionRate = townInfectionRate town
    -- | The current contagion rate
    nContagionRate = townContagionRate town
    -- | What to do on the last round
    lastRound
        | nRound == 50 = "CCC"
        | otherwise    = ""
    -- | What to do in order to prepare for reproduction
    prepareForReproduction
        | (nRound+1) `mod` 5 == 0 = decreaseInfected
        | otherwise               = ""
    -- | What to do in order to decrease infected
    decreaseInfected
        | nInfected > 25 = "CCC"
        | nInfected > 15 = "CC"
        | nInfected > 5  = "C"
        | otherwise      = ""
    -- | What to do in order to decrease lethality
    decreaseLethality
        | nLethalityRate > 4 = "I"
        | otherwise          = ""
    -- | What to do in order to decrease migration
    decreaseMigration
        | nMigrationRate > 0 = "B"
        | otherwise          = ""
    -- | What to do in order to decrease infection
    decreaseInfection
        | nInfectionRate > 0 = "M"
        | otherwise          = ""
    -- | What to do in order to decrease contagion
    decreaseContagion
        | nContagionRate > 4 = "E"
        | otherwise          = ""
    -- | What to do if everything else has been taken care of
    decreaseWorldWide = "PPP"

-- | Update a world
updateWorld :: World -> Maybe String
updateWorld world = updateTown world <$> town
  where
    town          = find ((==worldTownID world) . townID) (worldTowns world)

-- | Main program entry point
main :: IO ()
main = do
    cmds <- concat <$> getArgs
    case parse parseWorld "stdin" cmds of
        Left err    -> print err >> exitFailure
        Right world -> case updateWorld world of
            Just cmd -> putStrLn cmd
            Nothing  -> putStrLn "Failed to update world!" >> exitFailure

Biegnij z: runhaskell PureBot.hs

— Rrrrrr
źródło
Wow, jaka czystość techniczna! Podoba mi się sposób interpretacji polecenia P.
— busukxuan
Właśnie zainstalowałem Haskell 7.10.3, a kiedy próbuję uruchomić twojego bota, czeka on bez końca. Próbowałem z tym: runhaskell.exe PureBot.hs 1;0;0_97_3_0_2_5_15_5;1_97_3_0_2_5_15_5. Czy muszę coś zrobić przed uruchomieniem?
— Thrax
@Thrax Och, przepraszam. Myślałem, że przekazałeś komendy przez standardowe wejście ... Jeśli nie, zmienię program.
— YoYoYonnY
Polecenia są przekazywane jako argumenty. Zrobię następny bieg po zaktualizowaniu bota.
— Thrax
@Thrax W takim przypadku powinno działać teraz.
— YoYoYonnY
7

Infected Town, Java

Zainfekowane miasto nie obchodzi, czy ludzie są zarażeni, dopóki nie umrą. To dlatego obniży w jak największym stopniu lokalną śmiertelność.

Kiedy wskaźnik śmiertelności jest już bardzo niski, wykorzystuje pozostałe działania, aby zwiększyć globalny wskaźnik śmiertelności, zanim zmniejszy swój własny.

Ponieważ stara się być największym miastem w okolicy, saldo imigracji może być tylko ujemne, więc jego pierwszym działaniem jest zamknięcie granic.

Podczas ostatniej tury wskaźnik śmiertelności nie ma wpływu, a ranking odbywa się na podstawie liczby zdrowych ludzi w mieście, więc leczy 30 osób i ma nadzieję, że to wystarczy.

import java.util.ArrayList;
import java.util.List;

public class InfectedTown {

    int playerID;
    State thisState;

    public static void main(String[] args){
        new InfectedTown().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {
        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        // Special actions on turn 1 and 50.
        String action="";
        if(round == 1){
            action = "B";
        } else if(round == 50){
            action="CCC";
        } 

        while(action.length()<3){
            if(thisState.lethalityRate<=2 && action.length()<2){
                // We still have at least one action: lets increase the 
                // lethality rate for everyone, we will decrease it with our 
                // remaining actions.
                action+="W";
                thisState.lethalityRate+=2;
            } else if (thisState.lethalityRate>=4 
                    ||(thisState.lethalityRate>0 && action.length()==2)) {
                // Don't let people die!
                action+="I";
                thisState.lethalityRate-=4;
            } else {
                // Nothing better to do, lets distract other towns by  
                // increasing some useless values
                action+="D";
            }
        }

       System.out.println(action);
    }

    private class State {
        public int ownerId;
        public int lethalityRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
    }
}
— Garrluk
źródło
5

CullBot, Python 3

Prawie standardowy bot samoobrony, który zamyka granice i próbuje obniżyć wskaźnik infekcji w mieście. Odbywa się to poprzez wycinanie wektorów zwierzęcych (ponieważ zarażeni ludzie nie mają wpływu na wskaźnik infekcji, musi to mieć coś wspólnego z wektorami innymi niż ludzkie; w zasadzie jest to „mikrobiologia badawcza”). Czasami „uśmierca” także zarażonych ludzi ... Wiesz, AI też popełnia błędy ...

# Parsing code
from sys import argv

args = argv[1].split(";")

n = int(args[0])
pid = int(args[1])
dic = ["pid","healthy","infected","dead","infection","contagion","lethality","migration"]
players = []
for p in args[2:]:
    players += [{dic[i]:int(p.split("_")[i]) for i in range(len(p.split("_")))}]
    if int(p.split("_")[0]) == pid:
        me = players[-1]

# Bot code

actions = ""
nextInfected = me["infected"]*me["contagion"]/100 + me["infection"] + me["infected"] - me["infected"]*me["lethality"]/100
if n%5 == 4:
    nextInfected *= 1.5

if n == 1:
    actions += "BM"
    if nextInfected*1.3 > 10:
        actions += "C"
    elif me["infection"] > 6:
        actions += "M"
    elif me["infection"] > 4:
        actions += "V"
    else:
        actions += "E"
    print(actions)
    exit()
elif n == 50:
    print("CCC")
    exit()


if nextInfected*1.2 > 30:
    if me["infected"] >= 23:
        actions += "Q"
        me["infected"] -= 30
    else:
        actions += "C"
        me["infected"] -= 10
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if me["infection"] >= 3:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] >= 7 :
    actions += "C"
    me["infected"] -= 10
elif me["infection"] > 0 and me["contagion"] >= 3:
    actions += "V"
    me["infection"] -= 1
    me["contagion"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if me["infection"] >= 3:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] >= 7 :
    actions += "C"
    me["infected"] -= 10
elif me["infection"] > 0 and me["contagion"] >= 3:
    actions += "V"
    me["infection"] -= 1
    me["contagion"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if actions[-2:] == "VV":
    actions = actions[0] + "ME"
print(actions)
— busukxuan
źródło
1
Nie jestem facetem w Pythonie, więc mógłbym to zrobić źle, ale uruchomienie tego w Pythonie 3.4 daje mi „NameError: nazwa„ słownik ”nie jest zdefiniowana” w linii 9.
— Mwr247,
@ Mwr247 Dzięki, okazuje się, że całkowicie oszalałem, kiedy napisałem parsujący kod ... Było o wiele więcej problemów.
— busukxuan
Teraz podaje „TypeError: obiekt„ list ”nie może być interpretowany jako liczba całkowita” w linii 11
— Mwr247
Teraz to działa =)
— Mwr247
@ Mwr247 Lol! Myślałem, że to naprawiłem, ale nie skopiowałem i nie wkleiłem nowego kodu, więc chyba tego nie zauważyłem. Testowałem, teraz powinno działać dobrze. Chyba, że ​​jakoś źle zrozumiałem zasady We / Wy.
— busukxuan
5

EvilBot, Java

EvilBot nie dba o ludzi. Tak długo, jak pozostaną przy życiu (trochę). Stara się rozchorować resztę świata.

W moich lokalnych testach BlunderBot działał znacznie lepiej, dopóki nie wprowadziłem EvilBot. Wydaje się, że trochę wstrząsnęło.

import java.util.ArrayList;
import java.util.List;

public class EvilBot {

int round;
int phase;
int playerID;
int thisTownID;

List<State> states;
List<State> otherStates;

State thisState;
String action = "";
int cc=0; // command count

public static void main(String[] args){
    new EvilBot().sleep(args[0].split(";"));
}

private void action(String newAction) {
    action += newAction;
    cc+= newAction.length();
    if (cc>=3) {
        System.out.println(action.substring(0, 3));
        System.exit(0);;
    }
}
private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    otherStates = new ArrayList<>();

    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.isMine()) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    // Round specific commands
    if (round == 1 )                                { action("B");   }
    if (round == 50)                                { action("CCC"); }

    for (int i=0;i<3;i++){
        if (thisState.getLethalityRate() >= 4)  { action("I"); thisState.lethalityRate -= 4;}
    }

    // Nothing else to do, cause trouble.
    action("DWT");
}


private class State {

    private final int ownerId;
    private int healthy;
    private int infected;
    private int dead;
    private int infectionRate;
    private int contagionRate;
    private int lethalityRate;
    private int migrationRate;

    public State(String string) {
        String[] args = string.split("_");
        ownerId = Integer.parseInt(args[0]);
        healthy = Integer.parseInt(args[1]);
        infected = Integer.parseInt(args[2]);
        dead = Integer.parseInt(args[3]);
        infectionRate = Integer.parseInt(args[4]);
        contagionRate = Integer.parseInt(args[5]);
        lethalityRate = Integer.parseInt(args[6]);
        migrationRate = Integer.parseInt(args[7]);
    }

    public int getOwnerId() {
        return ownerId;
    }

    public int getHealthy() {
        return healthy;
    }

    public int getInfected() {
        return infected;
    }

    public int getDead() {
        return dead;
    }

    public int getInfectionRate() {
        return infectionRate;
    }

    public int getContagionRate() {
        return contagionRate;
    }

    public int getLethalityRate() {
        return lethalityRate;
    }

    public int getMigrationRate() {
        return migrationRate;
    }

    public boolean isMine(){
        return getOwnerId() == thisTownID;
    }

}

}
— Denham Coote
źródło
5

Broń masowego rozpowszechniania

public class WMDbot{
    public static void main(String[]a){
        System.out.println("WMD");
    }
}

Bot WMD jest palantem: utrzymuje niski poziom infekcji i podnosi wszystkich.

Bot skonstruowany wyłącznie dla akronimu, prawdopodobnie nie jest silnym konkurentem, ale sprawi, że konkurencja będzie trochę bardziej ... interesująca. Kod pożyczył od TheCure i właśnie zmienił ciąg akcji.

— Draco18s
źródło
Technicznie zmieniłeś też nazwę klasy; P
— Captain Man
@DenhamCoote: Proszę nie omijać masowo dodawanych tagów językowych. Jeśli zamierzasz edytować post, upewnij się, że jest on bardziej znaczący (gramatyka, formatowanie itp.). Dzięki.
— Zach Gates,
O? Kiedyś miałem to jedyną edycję jednego z moich postów - po prostu śledziłem czyjeś prowadzenie ...
— Denham Coote,
@DenhamCoote To jedna z tych „łatwych, tanich edycji”, która niczego nie dodaje, ale w rzeczywistości nie jest zabroniona. Wykonanie kilku z nich staje się spamem.
— Draco18s,
Nie jestem pewien, co rozumiesz przez „tani” - dla mnie zwiększa czytelność… To wyzwanie ma o wiele więcej kodu do odczytania niż normalne wyzwanie w golfa, dlatego pomyślałem, że podświetlanie składni byłoby mile widziane. To nie tak, że robię to dla punktów, po prostu przypadło mi do gustu to wyzwanie.
— Denham Coote,
5

Graymalkin, Java

Głównym celem Graymalkin jest zmniejszenie wskaźnika infekcji do 0 i zwiększenie zdrowej populacji. Nie wierzy w kwarantanny ... oczywiście poza światem zewnętrznym.

Mój pierwszy post - krytyka mile widziany. :) 

import java.util.ArrayList;
import java.util.List;

public class Graymalkin {

    int round;
    int phase;
    int playerID;
    int thisTownID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args) {
        new Graymalkin().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++) {
            states.add(new State(args[i]));
        }

        for (State state : states) {
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
            System.out.println("CCC");
            return;
        }

        String out = "";

        if (round == 1) {
            out += "B";
        }

        if (thisState.infectionRate < 10 && thisState.infected >= 10) {
            out += "C";
            thisState.infected -= 10;
        }

        while (thisState.infectionRate >= 4) {
            out += "M";
            thisState.infectionRate -= 4;
        }

        while (thisState.infectionRate > 0) {
            out += "V";
            thisState.infectionRate -= 1;
        }

        while (out.length() < 3) {
            if (thisState.infected > 0) {
                out += "C";
                thisState.infected -= 10;
            } else if (thisState.contagionRate > 0) {
                out += "E";
                thisState.contagionRate -= 8;
            } else if (thisState.lethalityRate > 0) {
                out += "I";
                thisState.lethalityRate -= 4;
            } else {
                out += "N";
            }
        }

        System.out.println(out.substring(0, 3));
    }

    private class State {

        private final int ownerId;
        private int sane;
        private int infected;
        private int dead;
        private int infectionRate;
        private int contagionRate;
        private int lethalityRate;
        private int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public int getSane() {
            return sane;
        }

        public int getInfected() {
            return infected;
        }

        public int getDead() {
            return dead;
        }

        public int getInfectionRate() {
            return infectionRate;
        }

        public int getContagionRate() {
            return contagionRate;
        }

        public int getLethalityRate() {
            return lethalityRate;
        }

        public int getMigrationRate() {
            return migrationRate;
        }

        public boolean isMine() {
            return getOwnerId() == playerID;
        }
    }
}
— teatrousers
źródło
@ Thrax wygląda na to, że mój bot nie został uwzględniony w twoim ostatnim uruchomieniu. Jestem ciekawy, jak to działa!
— teatrousers
5

Triage, Java

import java.util.ArrayList;
import java.util.List;

public class Triage {

    int round;
    int phase;
    int playerID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args){
        new Triage().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++){
            states.add(new State(args[i]));
        }

        for (State state : states){
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
          System.out.println("CCC");
          return;
        }

        String output = "";

        while( thisState.lethalityRate >= 4) {
          output += "I";
          thisState.lethalityRate -= 4;
        }

        while( thisState.lethalityRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.contagionRate >= 8) {
          output += "E";
          thisState.contagionRate -= 8;
        }

        while( thisState.contagionRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.infectionRate > 0) {
          output += "M";
          thisState.infectionRate -= 4;
        }

        while( output.length() < 3) {
          output += "C";
        }

        System.out.println(output.substring(0,3));

    }

    private class State {

        private final int ownerId;
        public int sane;
        public int infected;
        public int dead;
        public int infectionRate;
        public int contagionRate;
        public int lethalityRate;
        public int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public boolean isMine(){
            return getOwnerId() == playerID;
        }

    }

}

Najpierw utrzymuje swoich obywateli przy życiu, a następnie chroni ich przed zarażeniem innych, a następnie leczy.

Mooch, Java

import java.util.ArrayList;
import java.util.List;

public class Mooch {

    int round;
    int phase;
    int playerID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args){
        new Mooch().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++){
            states.add(new State(args[i]));
        }

        for (State state : states){
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
          System.out.println("CCC");
          return;
        }

        String output = "";

        while( thisState.migrationRate < 100) {
          output += "O";
          thisState.migrationRate += 10;
        }

        while( thisState.lethalityRate >= 4) {
          output += "I";
          thisState.lethalityRate -= 4;
        }

        while( thisState.lethalityRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.contagionRate >= 8) {
          output += "E";
          thisState.contagionRate -= 8;
        }

        while( thisState.contagionRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.infectionRate > 0) {
          output += "M";
          thisState.infectionRate -= 4;
        }

        while( output.length() < 3) {
          output += "C";
        }

        System.out.println(output.substring(0,3));

    }

    private class State {

        private final int ownerId;
        public int sane;
        public int infected;
        public int dead;
        public int infectionRate;
        public int contagionRate;
        public int lethalityRate;
        public int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public boolean isMine(){
            return getOwnerId() == playerID;
        }

    }

}

To samo co Triage, tyle że zaczyna się od całkowitego otwarcia granic. Zapewnia to olbrzymią wieczną populację zainfekowanych, niewygodną dla innych botów i potencjalnie służącą jako przełom.

— histocrat
źródło
Triage wciąż daje Family Values ​​szansę na swoje pieniądze. Z drugiej strony Mooch buduje przerażającą armię chorych ludzi. Dobra robota!
— Mwr247,
czy moochbot nie chce, aby wszyscy byli zarażeni? Czy thisState.x nie modyfikuje wartości State, a następnie gra zmienia ją ponownie z ciągu, co daje podwójny efekt? Świetny pomysł na thr CCC w ostatniej rundzie
— Eumel
Zrozumiałem teraz kod i moje drugie pytanie było dość głupie
— Eumel
Moochbot ostatecznie próbuje stworzyć zdrową populację, ale otwarte granice + zerowa śmiertelność gwarantują, że zarażona populacja będzie rosła znacznie szybciej.
— histokrata
4

InfectedHaven, Python 3

Bezpieczna przystań dla zainfekowanych z zamkniętymi granicami. Próbuje zminimalizować śmiertelność. Jeśli zostanie zminimalizowane, próbuje zwiększyć śmiertelność w innych stanach, aby „skorzystać” z zainfekowanych lokalnych.

# parsing code
from sys import argv
args = argv[1].split(";")

n = int(args[0])
pid = int(args[1])
dic = ["pid","healthy","infected","dead","infection","contagion","lethality","migration"]
players = []
for p in args[2:]:
    players += [{dic[i]:int(p.split("_")[i]) for i in range(len(p.split("_")))}]
    if int(p.split("_")[0]) == pid:
        me = players[-1]

# bot code

actions =""

if n == 50:
    print("CCC")
    exit()
elif n == 1:
    actions += "B"
    if me["lethality"] <= 6:
        actions += "WI"
    else:
        actions += "II"
    print(actions)
    exit()

if me["lethality"] >= 9:
    actions += "III"
elif me["lethality"] >= 3:
    actions += "WII"
else:
    actions += "WWI"
print(actions)
— busukxuan
źródło
Wprowadzona modyfikacja zostanie uwzględniona przy następnym uruchomieniu. Nadal nie będzie konkurować w drugim etapie, ponieważ twoja strategia polega na stworzeniu Bezpiecznej przystani dla zainfekowanych. Niemniej bardzo interesujące!
— Thrax
2
@Thrax Lol dzięki, to nie jest tak naprawdę strategia. Pomyślałem, że osoby zarażone będą prawdopodobnie narażone na szkodę lub dyskryminowane przez zdrowych, więc w chaotycznym świecie prawdopodobnie katalizowałoby to tworzenie się stanu „zarażonego przez innych”. Szczerze mówiąc, był to bot dla zabawy, ale potem zobaczyłem w nim trochę potencjału, więc poddałem się.
— busukxuan
@ Thrax przepraszam, jeśli jest to niewygodne, ale właśnie dowiedziałem się, że przeliczyłem warunki na dole, więc zaktualizowałem ponownie.
— busukxuan
4

Rozdroże, Python2

Crossroads to demokratyczny naród skupiający się na futurystycznych wartościach naukowych. Podobnie jak większość demokracji, większość decyzji podejmowane są przez niewykształcone naukowo, samolubne i dysfunkcyjne komitety, które często podejmują bardzo dziwne i złe - pozornie losowe, nawet - decyzje. Jednak rząd ostatecznie działa na rzecz wspólnego dobra swoich ludzi i rasy ludzkiej.

import sys
import random
import itertools
def sample_wr(population, k):
    "Chooses k random elements (with replacement) from a population"
    n = len(population)
    _random, _int = random.random, int  # speed hack
    return [population[_int(_random() * n)] for i in itertools.repeat(None, k)]
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
worldpopulation = 0
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
    worldpopulation += (int(b[1])+int(b[2]))*int(b[7])/100
output = ""
if round == 1:
    output="BM"
    if players[myid][Infected]>6: output+="C"
    else: output+="E"
if round == 50: 
    if players[myid][Infected] > 20: output = "CCC"
    elif players[myid][Infected]> 6: output = "CTC"
    else: output = "TTC"
if round == 48 and players[myid][Infected] > 45 and players[myid][InfectionRate]>12:
    output = "MMM"
if round == 49 and players[myid][Infected] > 30:
    output = "CCC"
if (round+1)%5==0:
    if players[myid][Sane]==0 or players[myid][Infected]/players[myid][Sane] > 2: output+="I"*(players[myid][LethalityRate]/4)
    output+="M"*(players[myid][InfectionRate]/4)
    output+="C"*max((players[myid][Infected]/10),1)
if players[myid][InfectionRate] < 8 and players[myid][ContagionRate] < 20 and players[myid][Sane]+min(players[myid][Infected]/5,60)>players[myid][Infected] and (round+2)%5==0:
    output+="C"*max((players[myid][Infected]/10),1)
    players[myid][Infected] -= min(max((players[myid][Infected]/10),1)*10,players[myid][Infected])
if players[myid][Sane] > players[myid][Infected] > 30: 
    output +="Q"
    players[myid][Infected] -= min(players[myid][Infected],30)
if players[myid][Sane] > players[myid][Infected] > 20:
    output+="CC"
    players[myid][Infected] -= min(players[myid][Infected],20)
if (players[myid][Sane] > 2*players[myid][Infected] > 20):
    output+="C"
    players[myid][Infected] -= min(players[myid][Infected],10)
if round <= 5 and players[myid][Infected] > 10:
    output+="C"
    players[myid][Infected] -= min(players[myid][Infected],10)
if 25 <= players[myid][Infected] < 40 and players[myid][InfectionRate]<10:# and players[myid][ContagionRate]*(players[myid][Infected]-20)/100 < 10:
    output+="CCC"

if players[myid][InfectionRate]-players[myid][ContagionRate]>10: output+="M"
if players[myid][ContagionRate]-players[myid][InfectionRate]>20: output+="E"
population = []
population +=["I" for i in range(int(1.15**players[myid][LethalityRate]))]
if players[myid][Sane]<10 or players[myid][Infected]-players[myid][Sane]>10: population+=["I" if players[myid][LethalityRate]>8 else "V" for i in range(players[myid][InfectionRate])]
if players[myid][Sane]+players[myid][Infected]>10 and (players[myid][Sane]>15 or players[myid][LethalityRate]<10): population += ["M" if players[myid][InfectionRate] > 6 else "V" for i in range(2*max(players[myid][InfectionRate]*players[myid][Sane]/100,int((1.15+0.002*(50-round))**min(50,players[myid][InfectionRate]))))]
if players[myid][Sane]+players[myid][Infected]>10 and (players[myid][Sane]>15 or players[myid][LethalityRate]<10): population += ["E" if players[myid][ContagionRate] > 10 else "V" for i in range(max(min(players[myid][Sane],players[myid][ContagionRate]*players[myid][Infected]/100),int(1.15**min(50,players[myid][ContagionRate]))))]
if players[myid][InfectionRate]+players[myid][ContagionRate]<15: population += ["C" for i in range(players[myid][Infected])]
if players[myid][Infected] < 10: population += ["WV" for i in range(int(1.05**round))]
output += ''.join(sample_wr(population,3))
print output[:3]

4 przebiegi z udziałem wszystkich:

1. Crossroads (36, 12, 185)
2. InfectedTown (14, 1040, 510)
3. InfectedHaven (14, 977, 481)
4. Triage (14, 668, 531)
5. ZombieState (14, 523, 393)

1. AllOrNothing (541, 0, 312)
2. InfectedTown (30, 1125, 574)
3. InfectedHaven (30, 1020, 612)
4. WICKED (30, 732, 622)
5. Triage (30, 553, 554)
6. Mooch (30, 80, 240)
7. Crossroads (25, 0, 162)

1. AllOrNothing (846, 12, 241)
2. Crossroads (440, 15, 146)
3. FamilyValues (388, 34, 201)
4. Salt (170, 0, 176)
5. InfectedHaven (18, 1290, 664)

1. Crossroads (80, 14, 365)
2. InfectedHaven (30, 1596, 603)
3. InfectedTown (30, 1286, 576)
4. Triage (30, 1084, 412)
5. WICKED (18, 1286, 578)

4 przebiegi bez „botów doomsday”:

1. Salt (6790, 0, 58)
2. FamilyValues (6697, 7, 9)
3. Crossroads (6616, 4, 16)
4. PureBot (6454, 0, 50)
5. Piecemeal (6260, 0, 111)

1. Crossroads (6970, 0, 39)
2. PureBot (6642, 0, 77)
3. CureThenQuarantine (6350, 2, 51)
4. FamilyValues (6153, 13, 21)
5. Piecemeal (5964, 4, 132)

1. PureBot (6142, 0, 34)
2. CureThenQuarantine (6010, 4, 75)
3. Piecemeal (5971, 4, 72)
4. CullBot (5409, 8, 115)
5. Crossroads (5129, 0, 27)

1. FamilyValues (7277, 12, 26)
2. Crossroads (6544, 4, 32)
3. Salt (5830, 26, 103)
4. Piecemeal (5757, 8, 164)
5. PureBot (5657, 8, 127)

EDYCJA: Widząc skuteczną strategię CullBota „ignorowania śmiertelności i skupiania się na utrzymaniu zdrowia ludzi”, zwiększyłem priorytet zmniejszenia infekcji i zarażenia oraz leczenia nad zmniejszeniem śmiertelności, nie rezygnując z istotnego losowego stylu decyzji podejmowanych przez komitet.

EDYCJA 2: Okazuje się, że ignorowanie śmiertelności wśród wielu terrorystów jest złe. Priorytet redukcji śmiertelności ponownie wzrósł, teraz skalowany wraz ze współczynnikiem śmiertelności. Naprawiono również inne słabe decyzje, takie jak otwieranie i zamykanie granic w tym samym zakręcie, i zwiększono próg kwarantanny, woląc zamiast tego leczyć, jeśli to możliwe.

EDYCJA 3: Kilka drobnych korekt priorytetów w celu obsługi sytuacji, które nie były obsługiwane. Teraz wyniki znajdują się u szczytu, niezależnie od tego, czy dni śmierci są uwzględnione, czy nie, pomyślał Salt w obu przypadkach. Mój głos jest obecnie w Salt za zwycięzcę tego wydarzenia.

EDIT4: Poprawiony czas i skuteczność utwardzania.

EDYCJA 5: Usunąłem rzeczy, które nie zgadzają się z migracją, ponieważ nigdy nie osiągają zerowej populacji i kilka innych specjalnych przypadków leczenia.

EDYCJA 6: Zwiększ priorytet obniżenia wskaźnika infekcji we wczesnej fazie gry. Usuń skomentowane linie. Nie zaktualizowałem wyników uruchomień testowych, ale teraz wyniki są znacznie wyższe w biegach innych niż doomsday (pokonując FamilyValues, ale nie TrumpBot)

EDYCJA 7: Wykładnik szybkości infekcji / zarażenia przy 50, aby zapobiec dużemu zużyciu pamięci.

— kwintopia
źródło
Zaraz ... Czy Izrael jest wzorowany na Jerozolimie z WWZ o bardzo wysokich ścianach?
— busukxuan
@busukxuan, która była inspiracją tak, z tym wyjątkiem, że ten Izrael bardziej przypomina Jeruzalem w filmie (szybko opanowanym przez zainfekowanych), ponieważ w zasadzie otwiera się na szerokie granice a la Mooch. Pierwotny plan przewidywał głównie „P”, ale nie była to skuteczna strategia.
— kwintopia
Hm ... Wydaje się, że drogi CullBot nie mógł już nadążyć, gdy jest więcej botów próbujących zwiększyć infekcję.
— busukxuan
robi się świetnie, gdy dodałem bota, aby ograniczyć infekcję (losowość kolejności)
— quintopia
Zasadniczo więc CullBot jest dość niestabilny i zależy od sytuacji. Rzeczywiście, kiedy napisałem kod, założyłem, że można ograniczyć infekcję. Jedyną awarią była do 1 kwarantanny na turę.
— busukxuan
3

Opiekun, Lua

KotH wykonane przez francuską żabę! Musiałem być w tym konkursie!

Ten bot zrobi wszystko, co możliwe, aby utrzymać możliwie najniższy wskaźnik infekcji / zarażenia i śmiertelności. Jego największym priorytetem jest śmiertelność w pobliżu 0. Następnie spróbuje zgadnąć, kiedy warto spróbować „zaimportować” więcej osób.

Edycja: założyłem, że to, co otrzymujemy, argzostało posortowane według playerId. To błędne założenie, dlatego dodałem sortowanie bąbelkowe datas.

input=arg[1]

datas={}
format={"playerID","sane","infected","dead","infection","contagion","lethality","migration"}
i=1
for s in input:gmatch("[^;]+") 
do
  j=1
  if round==nil then round=tonumber(s) 
  elseif me==nil then me=tonumber(s)+1
  else
    table.insert(datas,{})
    for r in s:gmatch("%d+")
    do
      datas[i][format[j]]=tonumber(r)
      j=j+1
    end
    i=i+1
  end
end
for i=#datas-1,1,-1
do
  for j=1,i
  do
    if datas[j].playerID>datas[j+1].playerID
    then
      datas[j],datas[j+1]=datas[j+1],datas[j]
    end
  end
end

-- First, we put ourself in a safe state
if round==1 then print("VVV")os.exit(0)end
if round==50 then print("CCC")os.exit(0)end

actions=""

-- Safety actions first
if datas[me].lethality>2 
then 
  actions=actions.."I"
  datas[me].lethality=datas[me].lethality-4>0 and datas[me].lethality-4 or 0
end

if datas[me].infected>=10
then
  if(datas[me].infection+datas[me].contagion+datas[me].lethality>4)
  then
    actions=actions.."V"
    datas[me].infection=datas[me].infection-1>0 and datas[me].infection-1 or 0
    datas[me].contagion=datas[me].contagion-4>0 and datas[me].contagion-4 or 0
    datas[me].lethality=datas[me].lethality-2>0 and datas[me].lethality-2 or 0
  end
  actions=actions.."C"
  datas[me].sane=datas[me].sane+10
  datas[me].infected=datas[me].infected-10
end

-- We can now try taking some initiatives
while #actions<3
do
  rates={}
  for i=1,#datas
  do
    if i~=me 
    then
      table.insert(rates,(datas[i].infected/datas[i].sane>0 and datas[i].sane or 0)*(datas[i].migration/100))
    end
  end
  rates["total"]=0
  for i=1,#rates
  do
    rates.total=rates.total+rates[i]
  end
  rates.total=(rates.total/#rates)*100


  if datas[me].migration<=15 and datas[me].migration+10>rates.total
  then
    actions=actions.."O"
    datas[me].migration=datas[me].migration+10>0 and datas[me].migration+10 or 0
  elseif (datas[me].sane/datas[me].infected)*100<rates.total
  then
    actions=actions.."B"
    datas[me].migration=datas[me].migration-10>0 and datas[me].migration-10 or 0
  elseif datas[me].infected>=10
  then
    actions=actions.."C"
    datas[me].infected=datas[me].infected-10
  else
    actions=actions.."V"
    datas[me].infection=datas[me].infection-1>0 and datas[me].infection-1 or 0
    datas[me].contagion=datas[me].contagion-4>0 and datas[me].contagion-4 or 0
    datas[me].lethality=datas[me].lethality-2>0 and datas[me].lethality-2 or 0
  end
end
print(actions)
os.exit(0)
— Katenkyo
źródło
@Thrax Oh .. Poprawiono kod źródłowy, teraz użyj input=arg[1]zamiast input=io.read().
— Katenkyo
3

MadScienceBot, Python2

Wiesz czego potrzebuje ten świat?

WIĘCEJ NAUKI!

Jak uzyskać WIĘCEJ NAUKI?

Z BRAINZZ

Leczy ludzi tylko w ostatniej sekundzie, nie obchodzi ich to mniej niż w rundzie 50. Próbuje być farmą zombie co drugą rundę

import sys, copy
import itertools

mults = {'mig_rate': -15, 'let_rate': -15, 'dead': -20, 'inf_rate': -20, 'sane': 0, 'infected': 60, 'con_rate': -30, 'id': 0}
def get_score(player_data):
    score = 0
    for k in player_data:
        score += player_data[k] * mults[k] / 100.
    return score


def add_rates(player_data):
    #Infection
    no_sane_converted = player_data["sane"]*player_data["inf_rate"]/100.
    player_data["infected"] += no_sane_converted
    player_data["sane"] -= no_sane_converted
    #Contagion
    no_sane_converted = player_data["con_rate"]
    player_data["infected"] += no_sane_converted
    player_data["sane"] -= no_sane_converted
    #Extinction
    no_killed = player_data["infected"]*player_data["let_rate"]/100.
    player_data["dead"] += no_killed
    player_data["infected"] -= no_killed

def correct(data):
    if round % 5 == 4:
        data["sane"] += int(data["sane"])/2
        data["infected"] += int(data["infected"])/2
    data["inf_rate"] += 2
    data["con_rate"] += 5
    data["let_rate"] += 5

args = sys.argv[1].split(";")
round = int(args[0])
self_id = int(args[1])
player_data = [map(int, player.split("_"))for player in args[2:]]
player_data = [dict(zip(("id", "sane", "infected", "dead", "inf_rate", "con_rate", "let_rate", "mig_rate"), player)) for player in player_data]
self_data = [player for player in player_data if player["id"] == self_id][0]

f = open("MadScienceBot.txt", "a")
f.write("\n")
f.write(`round`+"\n")
f.write("INPUT: "+`self_data`+"\n")

def m(p): p["inf_rate"] -= 4
def e(p): p["con_rate"] *= 92/100.
def i(p): p["let_rate"] -= 4
def v(p): p["inf_rate"] -= 1; p["con_rate"]-=4;p["let_rate"]-=2
def c(p): x=min(p['infected'], 10); p['infected']-=x; p['sane']+=x
def q(p): x=min(p['infected'], 30); p['infected']-=x; p['dead']+=x
def o(p): p["mig_rate"] += 10
def b(p): p["mig_rate"] -= 10

out = ""
instructions = {"M": m,
                "E": e,
                "I": i,
                "V": v,
                "C": c,
                "Q": q,
                "O": o,
                "B": b}

def run_inst(new_data, inst_id, i):
    inst = instructions[inst_id]
    if i != 2:
        inst(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        #f.write("%s %s %s\n"%(inst_id, get_score(new_data), new_data))
    else:
        inst(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        correct(new_data)
        add_rates(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        #f.write("%s %s %s\n"%(inst_id, get_score(new_data), new_data))
    return new_data

def run_3_insts(self_data, insts):
    new_data = copy.copy(self_data)
    for i, inst in enumerate(insts):
        run_inst(new_data, inst, i)
    return get_score(new_data)

scores = {}
for combo in itertools.permutations(instructions.keys(), 3):
    joined = "".join(combo)
    score = run_3_insts(self_data, joined)
    scores[score] = joined
#print scores
out = scores[max(scores)]

if round == 50:
    out = "CCC"

f.write(out+"\n")
print out
— niebieski
źródło
3

ZombieState, Java

Hej, to mój pierwszy post na tej stronie. Zasadniczo właśnie wziąłem jednego z przykładowych botów i zmieniłem wiersze dotyczące wyjścia. 

import java.util.ArrayList;
import java.util.List;

public class ZombieState {

int round;
int phase;
int playerID;
int thisTownID;

List<State> states;
List<State> otherStates;

State thisState;

public static void main(String[] args){
    new ZombieState().sleep(args[0].split(";"));
}

private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    otherStates = new ArrayList<>();

    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.isMine()) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    StringBuilder sb = new StringBuilder();
    if(round == 1)
        System.out.println("TTT");
    else if(round == 50)
        System.out.println("CCC");
    else
    {
        while(thisState.lethalityRate >= 4)
        {
            sb.append("I");
            thisState.lethalityRate -= 4;
        }
        sb.append("DDD");
        System.out.println(sb.toString().substring(0, 3));
    }
}

private class State {

    private final int ownerId;
    public int sane;
    public int infected;
    public int dead;
    public int infectionRate;
    public int contagionRate;
    public int lethalityRate;
    public int migrationRate;

    public State(String string) {
        String[] args = string.split("_");
        ownerId = Integer.parseInt(args[0]);
        sane = Integer.parseInt(args[1]);
        infected = Integer.parseInt(args[2]);
        dead = Integer.parseInt(args[3]);
        infectionRate = Integer.parseInt(args[4]);
        contagionRate = Integer.parseInt(args[5]);
        lethalityRate = Integer.parseInt(args[6]);
        migrationRate = Integer.parseInt(args[7]);
    }

    public int getOwnerId() {
        return ownerId;
    }

    public boolean isMine(){
        return getOwnerId() == playerID;
    }

}

}

Mam nadzieję, że to jest w porządku i bot całkiem dobrze sobie radził we własnych biegach. Bo kto potrzebuje życia, jeśli możesz mieć 30 zdrowych i maksymalną liczbę zarażonych na końcu. Rozpoczyna grę od 3x BioTerroryzmu, aby wszystko zacząć, i stara się utrzymać lokalną śmiertelność na niskim poziomie. Jeśli jest mniejszy niż 4, próbuje zwiększyć globalny wskaźnik infekcji i zarażeń dzięki Rozpowszechnianiu.

— Taronyu
źródło
Witamy w PPCG :-) Mam nadzieję, że dobrze się tutaj
— bawisz
Jak dotąd wydaje się, że to dobrze. Witamy w PPCG i dobra robota!
— Rɪᴋᴇʀ
2

Rozpowszechnianie Bot, Ruby

Ten bot będzie leczył, dopóki 10 lub więcej pozostanie do wyleczenia. Następnie, jeśli wskaźnik infekcji wynosi co najmniej 4, bot go zmniejszy. Wszystkie inne działania są wydawane na zwiększenie współczynnika zarażenia, co mnie nie skrzywdzi, ponieważ nie mam już zainfekowanego.

#You can copy this code if you want. Not specific to my strategy.
PlayerId = 0
Sane = 1
Infected = 2
Dead = 3
InfectionRate = 4
ContagionRate = 5
LethalityRate = 6
MigrationRate = 7

a = ARGV[0].split ';'
round = a.shift.to_i
my_id = a.shift.to_i
players = a.map{|s|s.split('_').map{|str| str.to_i}}

my_index = players.index{|p|
    p[PlayerId] == my_id
}
me = players[my_index]

#strategy specific code starts here.

commands = ""
commands += 'C' if me[Infected] >= 10
commands += 'C' if me[Infected] >= 20
commands += 'C' if me[Infected] >= 30
commands += 'M' if me[InfectionRate] >= 4 and commands.length < 3
commands += 'D' while commands.length < 3

print commands
$stdout.flush
— MegaTom
źródło
2

XenoBot (Node.js)

XenoBot boi się ludzi, jego rozwiązaniem epidemii jest izolowanie jego populacji, wyleczenie ludzi, których może, i izolowanie ich, kiedy nie może. Nie przejmuje się tymi wszystkimi nonsensami wojennymi, po prostu stara się utrzymać swój lud przy życiu.

Aktywuj XenoBot tak:

node xenobot.js [data]

Kod:

const argv = String(process.argv),
    data = argv.split(";"),
    round = data[0],
    id = Number(data[1]),
    info = data[id + 1].split("_"),
    sane = info[1],
    infected = info[2],
    dead = info[3],
    infectionRate = info[4],
    contagionRate = info[5],
    lethalityRate = info[6],
    migrationRate = info[7]

var moves = 3
function exec(a) {
  process.stdout.write(a)
}
if(migrationRate >= 10) {
  exec("B")
}
if (infectionRate >= 8) {
  exec("MQ")
  moves-=2;
} else if(contagionRate >= 16) {
  exec("EC")
  moves-=2;
} else if(lethalityRate >= 8) {
  exec("IV")
  moves--;
} else {
  exec("B");
  moves--;
}

if (sane / 3 > infected + dead) {
  exec("Q")
  moves--;
}
if(moves > 0) {
  exec("B")
}
— MayorMonty
źródło
2

Strateg, Python

Ten bot naprawdę poważnie myśli o przetrwaniu. Przeanalizował możliwe strategie i opracował własną metodę wygrywania. Które teraz udokumentuje w komentarzach źródłowych, ponieważ jest miłym facetem i chce, aby inni też przeżyli.

Wywołana python strategist.py.

import sys
import random
import math


def main():
    id = int(get_player_id(sys.argv[1]))
    stats = get_player_stats(sys.argv[1], id)
    round = int(get_round(sys.argv[1]))

    if id == -1 or stats == None or round == -1:
        # Something is wrong here. RED ALERT! Close all possible entry routes and set 
        # quarantine levels to maximum!
        print("BQQ")
        sys.exit(1)

    if round == 1:
        # remove migration, cure some infected, and remove some danger
        print("BCM")
    elif round % 5 == 4:
        # Rounds 4, 9, 14 etc. One before repopulation. We want as many Healthy and as 
        # few Infected as possible to reproduce. Prioritise curing infected, because that
        # maximises Healthy for reproduction. If that's not possible, quarantine them.
        quarantine = math.ceil(int(stats['infected']) / 30)
        cure = math.ceil(int(stats['infected']) / 10)
        if cure <= 3:
            # we can deal with all our infections within 3 cures
            output = "C" * cure
            for i in range(3 - cure):
                # got moves left? Great, remove some danger.
                output += get_random_science()
            print(output)
        elif quarantine <= 3:
            # we can deal with all our infections within 3 quarantines
            output = "Q" * quarantine
            for i in range(3 - quarantine):
                # got moves left? Great, remove some danger.
                output += get_random_science()
            print(output)
        else:
            # We can't deal with all the infected in one round, so deal with some. Yes, we
            # don't get rid of as many as we could here, but we're about to reproduce so
            # we want Healthies in the next round.
            print("QQC")
    else:
        output = ""
        if int(stats['infected']) <= 10:
            # we can deal with all our infections by curing them
            output += "C"
        elif int(stats['infected']) <= 30:
            # we can deal with all our infections by quarantining them
            output += "Q"
        elif int(stats['infected']) >= int(stats['healthy']) * 0.5:
            # we're getting overrun with infected people, get rid of some
            output = "QCC"

        for i in range(3 - len(output)):
            # if we haven't used all our moves, we can remove some danger factors
            output += get_random_science()

        print(output)


def get_random_science():
    return random.choice(["M", "E", "I", "V"])


def get_player_id(args):
    splat = args.split(";")
    return splat[1] if len(splat) >= 2 else -1


def get_player_stats(args, id):
    splat = args.split(";")
    players_data = [x for x in splat if "_" in x]
    my_data = [y for y in players_data if y.split("_")[0] == str(id)]
    data_splat = my_data[0].split("_")

    if len(data_splat) == 8:
        # Id, Healthy, Infected, Dead, InfRate, ConfRate, LethRate, MigRate
        return {
            'healthy': data_splat[1],
            'infected': data_splat[2],
            'dead': data_splat[3],
            'inf_rate': data_splat[4],
            'conf_rate': data_splat[5],
            'leth_rate': data_splat[6],
            'mig_rate': data_splat[7]
        }
    else:
        return None


def get_round(args):
    splat = args.split(";")
    return splat[0] if len(splat) >= 1 else -1


if __name__ == "__main__":
    main()
— ArtOfCode
źródło
2

Otwarte i zamknięte

Rozpocznij grę, otwierając granice, a następnie pozwól przyjść wszystkim chorym. Po dużej populacji chorych (runda 30) zamknij granice i pracuj nad leczeniem chorych.

#You can copy this code if you want. Not specific to my strategy.
PlayerId = 0
Healthy = 1
Infected = 2
Dead = 3
InfectionRate = 4
ContagionRate = 5
LethalityRate = 6
MigrationRate = 7

a = ARGV[0].split ';'
round = a.shift.to_i
my_id = a.shift.to_i
players = a.map{|s|s.split('_').map{|str| str.to_i}}

my_index = players.index{|p|
    p[PlayerId] == my_id
}
me = players[my_index]

#strategy specific code starts here.

commands = ""
if round < 30
  commands += me[MigrationRate] == 100 ? (me[InfectionRate] <= 1 ? "V" : "M") : "O"
  commands += me[LethalityRate] <= 2 ? "V" : "I"
  commands += me[ContagionRate] <= 4 ? "V" : "E"
elsif round < 50
  commands += me[MigrationRate] == 0 ? "V" : "B"
  commands += me[LethalityRate] < 20 ? "C" : "I"
  commands += me[ContagionRate] <  5 ? "C" : "E"
else
  commands = "CCC"
end

print commands
$stdout.flush
— MegaTom
źródło
2

Dwa kolejne boty Python

Izrael

Jest podobny do Moocha, ale może nie tak dobry jak Mooch, z wyjątkiem rzadkich przypadków, gdy jest znacznie lepiej:

import sys
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
output=''
if round<=4:output = ["OOO","OOO","OOO","OII"][round-1]
if round==50: output = "CCC"
mycontrate = players[myid][ContagionRate]
myfatrate = players[myid][LethalityRate]
myinfrate = players[myid][InfectionRate]
if myinfrate+mycontrate<5:
    output+="V"
    myfatrate-=2
    if round < 47: 
        output+="I"*(myfatrate/4)
        if myfatrate%4: output+="V"
else:
    if round < 47: 
        output+="I"*(myfatrate/4)
        if myfatrate%4: output+="V"
    output+="M"*(myinfrate/4)
    if round < 47: 
        output+="E"*(mycontrate/4)
output+="CCC"

print output[:3]

czerwony Krzyz

Coś w rodzaju pacyfisty, z wyjątkiem prób powstrzymania własnego ludu przed śmiercią. Zawodzi żałośnie, ale miło jest mieć innego towarzysza na boisku.

import sys
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
output="PPPPP"
if round<=4:output = ["OOO","OOO","OOO","OII"][round-1]
elif round==50: output = "CCC"
else: output = output[:2-3*round%5]+"I"+output[2-3*round%5:]
print output[:3]
— kwintopia
źródło
2

Smaug (Python)

Jestem ogniem; Jestem śmiercią.

Smaug powoduje jak najwięcej śmierci, niezależnie od tego, gdzie to nastąpi. 

# "I am fire, I am death"
# Smaug has two goals: hoard gold and bring death...
#    and this world seems to be all out of gold

from sys import argv
args = argv[1].split(";")

round = int(args.pop(0))
me = int(args.pop(0))

if round==50: # can't cause more death on the last round, might as well infect
    print('TTT')

def predict_infected(infected, infection_rate, contagion_rate):
    i = infected + infection_rate
    return i + int(i*contagion_rate)

def predict_dead(infected, lethality_rate):
    return int(infected*lethality_rate)

strategies = {'WWW':0, 'WWD':0, 'WDD':0, 'DDD':0}
for player in args:
    player=player.split('_')
    healthy=int(player[1])
    infected=int(player[2])
    infection_rate=int(player[4])
    contagion_rate=int(player[5])/100.
    lethality_rate=int(player[6])/100.

    if round%5==0:
        healthy+=healthy/2
        infected+=infected/2

    pi_old = predict_infected(infected, infection_rate, contagion_rate)
    pd_old = predict_dead(pi_old, lethality_rate)

    for strat in strategies:
        ir_new = infection_rate + 3
        lr_new = lethality_rate + (strat.count('W')*.02) 
        cr_new = contagion_rate + (strat.count('D')*.02) 

        pi_new = predict_infected(infected, ir_new, cr_new)
        pd_new = predict_dead(pi_new, lr_new)

        increase = pd_new - pd_old

        strategies[strat]+=increase

print max(strategies, key=strategies.get)
— SnoringFrog
źródło
Jeśli próbujesz zagrać w golfa w poliglota, pusty plik byłby krótszy i zrobiłby dokładnie to, co robi obserwator (a także, co się dzieje, dokładnie to, co robi PassiveBot - oba zachowują się identycznie), ponieważ interpreter zastępuje NNN nazwą Odpowiedź długości 0.
— kwintopia
@ Quintopia, której nie próbowałem, po prostu zdałem sobie sprawę, kiedy napisałem, że wygodnie działa jako poliglota, ale nie zdawałem sobie sprawy, co zrobił PassiveBot, więc po prostu usunę Watchera (nie ma sensu mieć dwóch identycznych)
— SnoringFrog
2

Usuń zainfekowane (Python)

Pomimo całej losowej logiki, jestem dość rzadki, aby zwracało to wszystko oprócz Q i C (środki zapobiegawcze nigdy nie wydają się tak pomocne). No cóż. Może pożyczyć trochę dla innego bota, ale zostawić na wypadek, gdyby pomógł.

# Remove as many of it's own infected as possible, preferably by curing, but quarantining if it's getting out of hand
# If not very many can be cured, takes preventative measures (B,E,M, or V)

from sys import argv

CMDS=3
C_RATE=10
E_RATE=.08
M_RATE=4
Q_RATE=30
V_RATE=(1,.04)

def find_me(args):
    for player in args:
        player=player.split('_')
        if int(player[0])==me:
            return player

def actions_available():
    global actions
    if len(actions) < CMDS:
        return True
    else:
        return False

def add_actions(new_actions):
    global actions
    actions = (actions + new_actions)[0:CMDS]

def get_remaining_infected(local_infected):
    global actions
    return local_infected - (Q_RATE*actions.count('Q')) - (C_RATE*actions.count('C'))

def too_many_infected(local_infected):
    max_infected = C_RATE*(CMDS+1) # If we can get down to 10 or less without quarantining, that's good
    if local_infected > max_infected:
        return True
    else: return False

def projection(infection_rate, remaining_infected, action):
    additional_M=0
    additional_E=0
    additional_V=0

    if action == "M":
        additional_M=1
    elif action == "E":
        additional_E=1
    else:
        additional_V=1

    M_level = M_RATE*(actions.count('M')+additional_M)
    E_level = E_RATE*(actions.count('E')+additional_E)
    V_level = (V_RATE[0]*(actions.count('V')+additional_V), V_RATE[1]*(actions.count('V')+additional_V))

    projection = infection_rate - M_level - V_level[0] + (remaining_infected * (contagion_rate - E_level - V_level[1])) 
    return int(projection)

def get_best_action(local_infected):
    global actions
    remaining_infected = get_remaining_infected(local_infected)

    # If we can leave no infected, do so
    if remaining_infected <= C_RATE and remaining_infected >= 0:
        return 'C'

    strategies = {'M':0, 'E':0, 'V':0,'C':min(remaining_infected,C_RATE)}

    pni = int(infection_rate + (remaining_infected*contagion_rate)) # predicted new infected
    strategies['M'] = pni - projection(infection_rate, remaining_infected, 'M')
    strategies['E'] = pni - projection(infection_rate, remaining_infected, 'E')
    strategies['V'] = pni - projection(infection_rate, remaining_infected, 'V')
    # any benefit to including P as an option? 

    #print(strategies)
    max_saved = 'C'
    for strat,saved in strategies.iteritems():
        if saved > strategies[max_saved]:
            max_saved=strat
        elif saved == strategies[max_saved]:
            #prioritize V because of it's extra benefit of reducind lethality_rate
            max_saved=max(strat,max_saved) 

    if strategies[max_saved] <= C_RATE/2:
        # can't save that many, just close borders instead
        selected_action = 'B'
    else: selected_action = max_saved
    return selected_action


args = argv[1].split(";")
round = int(args.pop(0))
me = int(args.pop(0))
actions = ""

my_town = find_me(args)

local_infected = int(my_town[2])
infection_rate = int(my_town[4])
contagion_rate = int(my_town[5])/100.

if round!=50 and too_many_infected(local_infected):
    # Things are getting out of hand, quarantine and consider preventative measures
    actions = ('Q'*(local_infected/Q_RATE))[0:CMDS]

    while actions_available():
        add_actions(get_best_action(local_infected))
else: actions='CCC'

print ''.join(sorted(actions)) # always cure first
— SnoringFrog
źródło
@Thrax Ten bot został zaktualizowany
— SnoringFrog
2

CureThenQuarantine, Java

Państwo zainicjowało politykę leczenia tych nieszczęśliwych, a następnie poddania kwarantannie pozostałej części zainfekowanych osób. Gdy zarażona populacja zostanie zmniejszona, skup się na zmniejszeniu lokalnych wskaźników, a następnie pomóż w zmniejszeniu globalnych wskaźników.

Granice są zamknięte, aby zapewnić brak zainfekowanej migracji do stanu.

Testowałem bota tylko przeciwko botom Java i Python ... Wygląda na to, że działa przeciwko nim. Wygląda również na to, że mój bot zachowuje się podobnie do CullBota. 

public class CureThenQuarantine {
    static int playerID;

    public static void main(String[] args)
    {
        State thisState=null;

        args = args[0].split(";");

        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        String action="";
        if(round == 1) action = "B"; // ensure no migration.
        else if (round == 50 ) action ="CCC"; // not much else we can do so just cure some people.

        // Highest Priority to Curing and then Quarantining infected, but do not perform either action if it would be wasteful.
        if (thisState.infected>9)
        {
            if (thisState.infected<19) action+="C";
            else if (thisState.infected<29) action+="CC";
            else if (thisState.infected<39) action+="CCC";
            else if (thisState.infected<49) action+="CQ";
            else if (thisState.infected<59) action+="CCQ";
            else if (thisState.infected<79) action+="CQQ";
            else action+="QQQ";
        }

        // Next priority is to reduce infection rate
        if (thisState.infectionRate>8) action+="MMM";
        else if (thisState.infectionRate>4) action+="MM";
        else if (thisState.infectionRate>1) action+="M";
        else if (thisState.infectionRate>0) action+="V";

        // then reduce contagion rate
        if (thisState.contagionRate>16) action+="EEE";
        else if (thisState.contagionRate>8) action+="EE";
        else if (thisState.contagionRate>1) action+="E";
        else if (thisState.contagionRate>0) action+="V";

        // and least priority is lethality rate... since we are only going to quarantine infected persons anyway.
        if (thisState.lethalityRate>8) action+="III";
        else if (thisState.lethalityRate>4) action+="II";
        else if (thisState.lethalityRate>1) action+="I";
        else if (thisState.lethalityRate>0) action+="V";

        // and if we have managed to clean up our state then we help others states.
        action+="PPP";

        System.out.println(action.substring(0,3));
    }

    static private class State {
        public int ownerId;
        public int lethalityRate;
        public int healthy;
        public int infected;
        public int infectionRate;
        public int contagionRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            healthy = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
        public String toString()
        {
            return "H: "+healthy+" I: "+infected+" IR: "+infectionRate+" LR: "+lethalityRate+" CR: "+contagionRate;
        }
    }
}
— Moogie
źródło
2

Badacz, Java

Ten bot koncentruje się na badaniach. Jeśli liczba zarażonych jest mniejsza niż 15, próbuje je wyleczyć. Jeśli jest wyższa, wybiera bardziej skuteczne rozwiązanie . 

public class Researcher {
    public static void main(String[] args){
        String[] args1 = args[0].split(";");
        int id = Integer.parseInt(args1[1]);
        for (int i = 2; i < args1.length; ++ i) {
            String[] args2 = args1[i].split("_");
            if (Integer.parseInt(args2[0]) == id) {
                int infected = Integer.parseInt(args2[2]);
                if (infected == 0) {
                    System.out.println("MEI");
                } else if(infected < 15) {
                    System.out.println("MEC");
                } else {
                    System.out.println("MEQ");
                }
            }
        }
    }
}
— Sleafar
źródło
1
Język Java, jak sądzę?
— kot
2

Piecemeal, Java

Na podstawie mojego poprzedniego bota (CureThenQuarantine) odkryłem, że przy agresywnych botach w grze nie ma potrzeby kwarantanny, ponieważ zainfekowani umrą bardzo szybko, więc ten bot oportunistycznie wyleczy 10 zakażonych w każdej turze (przybywających z migracji lub od infekcji zdrowej populacji). Następnie wykorzysta pozostałe działania, aby zapewnić, że zdrowa populacja pozostanie zdrowa, opierając się na porodach, aby zwiększyć zdrową populację.

Granice są zamknięte, aby zapewnić brak zainfekowanej migracji do stanu. 

public class Piecemeal{
    static int playerID;

    public static void main(String[] args)
    {
        State thisState=null;

        args = args[0].split(";");

        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        String action="";
        if(round == 1) action = "B"; // ensure no migration.
        else if (round == 50 ) action ="CCC"; // not much else we can do so just cure some people.

        // Highest Priority to Curing up to ten infected if there are any.
        if (thisState.infected>0)
        {
            action+="C";
        }

        // Next priority is to reduce infection rate
        if (thisState.infectionRate>8) action+="MMM";
        else if (thisState.infectionRate>4) action+="MM";
        else if (thisState.infectionRate>1) action+="M";
        else if (thisState.infectionRate>0) action+="V";

        // then reduce contagion rate
        if (thisState.contagionRate>16) action+="EEE";
        else if (thisState.contagionRate>8) action+="EE";
        else if (thisState.contagionRate>1) action+="E";
        else if (thisState.contagionRate>0) action+="V";

        // and least priority is lethality rate... since we are only going to quarantine infected persons anyway.
        if (thisState.lethalityRate>8) action+="III";
        else if (thisState.lethalityRate>4) action+="II";
        else if (thisState.lethalityRate>1) action+="I";
        else if (thisState.lethalityRate>0) action+="V";

        // and if we have managed to clean up our state then we help others states.
        action+="PPP";

        System.out.println(action.substring(0,3));
    }

    static private class State {
        public int ownerId;
        public int lethalityRate;
        public int healthy;
        public int infected;
        public int infectionRate;
        public int contagionRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            healthy = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
        public String toString()
        {
            return "H: "+healthy+" I: "+infected+" IR: "+infectionRate+" LR: "+lethalityRate+" CR: "+contagionRate;
        }
    }
}
— Moogie
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.