공지 : 이 언덕의 도전은 완료되었습니다. 이것은 C5H8NNaO4에 참가한 것에 대한 녹색 확인 표시가 관찰자에게 새로운 답변으로 이동되지 않음을 의미합니다.

여전히 새로운 출품작을 제출할 수 있지만 더 이상 새로운 출품작을 적극적으로 확인하지 않아 새로운 토너먼트가 지연 될 수 있습니다.

소개

이 도전에서, 당신은 궁극의 사무라이 쇼다운 궁극 판 특별 버전 2.0 X 알파 오메가 터보 (또는 간단히 궁극의 사무라이 쇼다운 ) 라는 아케이드 게임을하고 있습니다. 당신의 상대? Programming Puzzles & Code Golf의 다른 멤버들 외에는 아무도 없습니다!

PPCG 아케이드 게임에서 기대할 수 있듯이 Ultimate Samurai Showdown을 직접 플레이하지 말고 게임을 대신 할 프로그램을 작성하십시오. 이 프로그램은 하나의 결투로 다른 사용자가 제출 한 프로그램과 싸울 것입니다. 가장 숙련 된 프로그램은 PPCG의 Ultimate Samurai에 선정되며 전설의 녹색 진드기가 부여됩니다.

게임 설명

이 섹션에서는 게임 배후의 메커니즘을 설명합니다.

승리 조건

경기는 두 가지로 구성 사무라이 서로 떨어져 직면하고있다. 각 사무라이는 20 개의 체력 과 1 개의 명예로 각 경기를 시작합니다 . 상대방이 죽었고 여전히 살아 있다면 사무라이가 이깁니다. 사무라이가 죽을 수있는 방법에는 두 가지가 있습니다.

1. 사무라이의 체력이 0으로 떨어지면 죽습니다.
2. 사무라이가 0 이하로 자신의 명예를 얻는다면 , 그는 결투에서 부정직하게 행동 한 신들에 의해 쓰러 질 것입니다.

신들에게 타격을받는 것은 체력이 0으로 줄어드는 것보다 우선 순위가 높기 때문에 한 사무라이가 0의 체력 점수에 있고 다른 사무국이 -1의 명예에있는 경우에는 체력이 0 인 사무라이가 승리합니다. 두 사무라이가 -1 명예에 처한 상황에서 둘 다 신들에게 타격을 받고 게임은 무승부입니다.

경기는 최대 500 턴으로 구성됩니다 . 500 번의 턴이 모두 끝나고 경기가 결정되지 않으면 (사무라이가 죽지 않았다면) 신들은 지루 해져서 두 사무라이를 모두 쓰러 뜨려 무승부로 이어집니다.

행위

매 차례마다 사무라이는 다음 중 하나를 정확하게 수행해야합니다.

W

사무라이는 기다렸다가 행동을 취하지 않아야한다. 이것은 그를 멋지게 보이게하지만 상대를 물리 치는 데 도움이되지는 않습니다. 이것은 또한 기본 동작입니다.

B

사무라이는 상대방에게 명예롭게 인사해야한다. 이것은 신들을 기쁘게하며 사무라이는 1 명예를 얻습니다. 모든 이동 떨어져에서 - 명예 명예는이 게임에 대해 "자원"본질적으로 때문에 사무라이의 성공에 매우 중요 B하고 W명예를 줄일 수 있습니다. 또한 사무라이가 7 명 이상의 명예를 획득 하면 신들 의 검을 사용할 수 있습니다 . 이것의 의미는 아래에 설명되어 있습니다.
그러나 상대방이 그의 검으로 당신을 때리기로 결정하면 상대방에게 절을하면 열린 채로있게됩니다. 그러므로 절을 선택할 때주의하십시오.

G

사무라이는 방어 적 입장을 취하고 검을 치지 않도록 보호해야합니다. 이 움직임은 모든 검 타격을, 신의 검으로 만든 공격을 성공적으로 차단합니다 .
그러나 신들은 지나치게 방어적인 사무라이를 찌르기 때문에 직전 차례에 사무라이의 행동이 지켜지고 있다면 이 행동은 명예 1을 소비 할 것 입니다. 그렇지 않으면 명예를 소비하지 않습니다.

I

사무라이는 칼집에서 칼을 빨리 뽑아 상대편을 때리려 고한다. 사무라이가 7 명 이상의 명예를 가지고 있다면, 그는 일반 검 대신 신들 의 검을 사용할 것입니다. 이 행동은 명예 1을 소모합니다.
빠른 추첨은 빠른 오버 헤드 공격으로 느린 오버 헤드 공격을 이길 수는 있지만 패리에 대해서는 패배합니다. 스트라이크가 성공적으로 연결 되면 신의 검으로 1의 피해를 입히거나 2의 피해를 입 힙니다 .

P

사무라이는 들어오는 공격을 막으려 고 시도한 다음 자신의 공격을 시작합니다. 사무라이가 7 명 이상의 명예를 가지고 있다면, 그는 일반 검 대신 신들 의 검을 사용할 것입니다. 이 행동은 명예 1을 소모합니다.
패리는 빠른 타격에 대한 좋은 작전이지만 느린 오버 헤드 공격에 의해 압도됩니다. 스트라이크가 성공적으로 연결 되면 신의 검으로 1의 피해를 입히거나 2의 피해를 입 힙니다 .

O

사무라이는 느린 오버 헤드 공격으로 상대방을 때리려 고 시도해야한다. 사무라이가 7 명예 이상을 가진 경우, 그는 일반 검 대신 신들 의 검을 사용할 것입니다. 이 이동은 1 명예를 소비합니다.
오버 헤드 스트라이크는 패리를 압도 할 수 있지만 빠른 스트라이크에서는 패배합니다. 스트라이크가 성공적으로 연결 되면 신의 검으로 1의 피해를 입히거나 2의 피해를 입 힙니다 .

신들의 검

7 명 이상의 명예를 가진 사무라이 는 신들 의 검을 사용할 수있는 능력을 얻습니다 . 그의 명예가 7 이하로 줄어들 면 신들 의 검을 사용할 수있는 능력 이 취소됩니다. 신들 의 검은 1이 아닌 2의 피해를 입 힙니다.

신들 의 검 (Sword of the Gods) 은 파업 이 평범 하지 않은 검 공격을 물 리치도록 허용하지 않습니다. 예를 들어, 신의 검의 검은 여전히 일반 오버 헤드 스트라이크를 잃게되고 신의 검의 빠른 끌기는 일반적인 빠른 끌기를 압도하지 않습니다. 실제로, 소위 신들의 검은 실제로 그렇게 강력하지는 않습니다. 아마도 신들이 행하는 우주적 농담 일 것입니다 ...

상호 작용 테이블

아래의 스택 스 니펫에는 두 사무라이가 취할 수있는 다양한 행동 조합의 가능한 모든 결과가 명시 적으로 나열되어있는 표가 포함되어 있습니다. 이를 보려면 "Show Code Snippet"을 클릭 한 다음 "Run Code Snippet"을 클릭하십시오.

td,
th {
  border: 1px solid #ccc;
  text-align: center;
  font-family: sans-serif;
}

<table>
  <tr>
    <th></th>
    <th>W (Wait)</th>
    <th>B (Bow)</th>
    <th>G (Guard)</th>
    <th>I (Quick Draw)</th>
    <th>P (Parry)</th>
    <th>O (Overhead Strike)</th>
  </tr>
  <tr>
    <td>W (Wait)</td>
    <td>Nothing occurs.</td>
    <td>The player that bowed gains +1 Honour.</td>
    <td>If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
  </tr>
  <tr>
    <td>B (Bow)</td>
    <td>The player that bowed gains +1 Honour.</td>
    <td>Both players gain +1 Honour.</td>
    <td>The player that bowed gains +1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
  </tr>
  <tr>
    <td>G (Guard)</td>
    <td>If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>If a guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour. </td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
  </tr>
  <tr>
    <td>I (Quick Draw)</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>Both players lose 1 Honour. </td>
    <td>Both players lose 1 Honour. The player that quick drawed takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
    <td>Both players lose 1 Honour. The player that used an overhead strike takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
  </tr>
  <tr>
    <td>P (Parry)</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>Both players lose 1 Honour. The player that quick drawed takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
    <td>Both players lose 1 Honour. </td>
    <td>Both players lose 1 Honour. The player that parried takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
  </tr>
  <tr>
    <td>O (Overhead Strike)</td>
    <td>The player that waited takes 1 damage (or 2 if the Sword of the Gods was used.) The player that struck loses 1 Honour.</td>
    <td>The player that bowed gains +1 Honour and takes 1 damage (or 2 if the Sword of the Gods was used). The player that struck loses 1 Honour.</td>
    <td>The player that struck loses 1 Honour. If the guarding player guarded the previous turn, that player loses 1 Honour.</td>
    <td>Both players lose 1 Honour. The player that used an overhead strike takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
    <td>Both players lose 1 Honour. The player that parried takes 1 damage (or 2 if the Sword of the Gods was used.).</td>
    <td>Both players lose 1 Honour. </td>
  </tr>
</table>

프로그램 커뮤니케이션

토너먼트의 진행을 촉진하기 위해 컨트롤러 프로그램은 "신들"의 역할을하도록 작성되었습니다. 그것은 명예와 건강의 기록을 유지하고 사무라이를 적절하게 지키는 것입니다. 이 섹션에서는 프로그램이 컨트롤러 프로그램과 통신하는 방법에 대해 설명합니다.

입력 설명

컨트롤러 프로그램은 다음과 같이 명령 행에서 프로그램을 호출합니다.

<command> <history> <enemy_history> <your_health> <enemy_health> <your_honour> <enemy_honour>

어디:

• <command>프로그램을 실행하는 데 필요한 명령입니다. 예를 들어, 프로그램이 파일에 있으면 super_sentai.pl명령은 아마도입니다 perl super_sentai.pl.

• <history>당신이 한 움직임의 역사입니다. 예를 들어, WWBP두 번 기다렸다가 한 번 절을하고 한 번은 ri다는 것을 의미합니다.

• <enemy_history>적의 움직임의 역사입니다. 예를 들어, BBBI적이 세 번 절을하고 한 번의 빠른 추첨을 수행했음을 의미합니다.

• <your_health> 당신의 현재 건강입니다.

• <enemy_health> 적의 현재 체력입니다.
• <your_honour> 당신의 현재 명예입니다.
• <enemy_honour> 적의 현재 명예입니다.

첫 번째 턴에는 historyand enemy_history가 비어 있으므로 프로그램은 다음과 같이 마지막 네 개의 인수로 호출됩니다.

<command> <your_health> <enemy_health> <your_honour> <enemy_honour>

이것을 준비하십시오!

당당한 독자라면 사무라이의 명예와 건강을 제공하는 네 가지 주장이 어느 정도 불필요하다는 것을 알 수 있습니다. 이것은 완벽한 정보 게임이므로 사무라이의 명예와 건강은 역사 만 사용하여 결정할 수 있습니다.

이 값은 편의를 위해 제공되므로 기록 인수를 구문 분석 할 필요가 없습니다. 명예가 0 일 때 공격하지 않는 등 간단한 전략을 구현하는 데 유용합니다.

출력 설명

작업을 선택하기 위해, 프로그램의 출력해야 하나 W, B, G, I, P, 또는 O당신이 만드는 할 작업에 따라, 표준 출력. 프로그램이 1000ms 이내에 아무것도 출력하지 않으면 프로그램이 종료되고 프로그램은 출력 된 것처럼 처리됩니다 W.

프로그램이 하나 이상의 문자를 출력하는 경우 첫 번째 문자 만 고려되므로 출력 Parry은 출력과 동일합니다 P.

프로그램의 첫 글자 출력이 위에 나열된 옵션이 아닌 경우 기본값은 W입니다.

제출 형식

이 게시물에 대한 답변으로 프로그램을 제출하십시오. 여러 프로그램을 제출할 수 있습니다. 여러 개의 간단한 프로그램을 제출하는 경우 단일 답변으로 제출하는 것이 좋습니다. 여러 개의 복잡한 프로그램을 제출하는 경우 별도의 답변으로 제출하는 것이 좋습니다. 귀하의 프로그램을 토너먼트에 성공적으로 추가하면, 귀하의 항목 (아래 링크)으로 git 저장소에 커밋합니다.

귀하의 프로그램이 토너먼트에 추가되지 못하는 문제가 발생하면 귀하의 참가작에 문제를 나타내는 의견을 남길 것입니다.

제출물에 다음을 포함하십시오.

1. 스코어 보드에 사용하기위한 사람이 읽을 수있는 프로그램의 이름. 여기에는 공백이 허용됩니다. 쉼표와 유니 코드 문자는 아닙니다.
2. 프로그램이 작성된 언어입니다. TinyMUSH와 같이 액세스하기 어려운 이상하고 어려운 언어로 작성하지 마십시오.
3. 프로그램의 간략한 개요. 프로그램의 작동 방식에 대한 설명이거나 프로그램에 대한 설명 (모든 비밀을 원한다면) 또는 둘 다일 수 있습니다.
4. 프로그램을 실행하는 데 필요한 명령. 예를 들어,이라는 Java로 제출물을 작성 example.java하는 경우 컴파일 지침 javac example.java을 제공 한 다음 지침 을 실행합니다 java example.
5. 프로그램의 소스 코드

제출을 돕기 위해 여기 에서 찾을 수있는 제출 템플릿을 제공합니다 . 템플릿을 사용하면 제출물이 더 멋지게 보입니다. 나는 그것을 사용하는 것이 좋습니다.

또한 두 가지 예제 항목을 제공합니다. 예제 출품작이 라운드 로빈에 참여하지만 주요 목적은 Ultimate Samurai의 타이틀에 대한 경쟁자가 아니라 토너먼트의 제출 및 입력 / 출력 형식을 명확하게하는 것입니다.

토너먼트 구조

이 섹션에서는 참가자 간의 토너먼트가 어떻게 진행되는지 설명합니다.

제어 프로그램

제어 프로그램은 Python 2로 작성되었으며 Ultimate Samurai Showdown Github 저장소 에서 찾을 수 있습니다 . 직접 실행하려면 실행 방법에 대한 지침이 링크의 README.md 파일에 포함되어 있습니다. 그러나 내 컴퓨터에서 운영되는 토너먼트 만 토너먼트 결과에 영향을 미치는 하드웨어 차이를 피하기 위해 공식적으로 진행됩니다.

제어 프로그램은 Arch Linux를 실행하는 랩톱 컴퓨터에서 실행됩니다. 인텔 코어 i7 프로세서와 8GB RAM이 있습니다. 컴퓨터에서 모든 항목을 실행하려고 노력하지만 무료로 액세스 할 수없는 언어를 피하십시오 (금전적 비용 없음).

채점 시스템

점수 시스템은 라운드 로빈입니다. 각 프로그램은 다른 모든 프로그램과 8 개의 경기를합니다. 승리는 프로그램에 1 점, 무손실 점, 0.5 점을줍니다. 가장 높은 점수를받은 프로그램이 게임에서 승리합니다. 추첨이있을 경우, 상위 2 개의 프로그램을 서로 대결하여 승자를 결정합니다.

참가자 수가 매우 많은 경우 각 프로그램이 서로 프로그램을 재생하는 횟수는 8 개에서 줄어들 수 있습니다. 이런 일이 발생하면 여기에 메모를 추가하겠습니다.

새 제출이 게시 될 때 라운드 로빈을 여러 번 실행하지만 가장 최근 라운드 로빈 일뿐입니다.

실격

귀하의 프로그램이 토너먼트에서 실격 될 수 있습니다. 다음과 같은 경우 실격이 발생할 수 있습니다.

• 프로그램이 컴파일되거나 실행되지 않습니다.
• 귀하의 프로그램은 다른 프로그램과 전략적으로 중복 됩니다 (즉, 다른 프로그램과 동일한 전략을 구현 함).
• 프로그램은 컨트롤러 코드, 다른 프로그램 코드 등을 수정하여 다른 프로그램을 방해하려고 시도합니다.
• 프로그램이 컨트롤러 코드의 버그를 악용하려고 시도합니다. 버그를 악용하는 대신 git 저장소에서 문제를 열거 나 여기에 의견을 말하거나 채팅에 핑을 보내야합니다.

과거 결과

모든 토너먼트의 자세한 결과는 위키 페이지 에서 확인할 수 있습니다 .

가장 최근 토너먼트는 2015-07-17 07:20에 완료되었습니다. 결과는 다음과 같습니다.

The Observer: 209.0
Coward: 203.0
Monk: 173.0
Elephant Warrior: 157.0
Iniqy: 157.0
Agent 38: 144.0
Ninja: 138.0
Meiyo Senshi: 138.0
Kakashi: 136.0
Yoshimitsu: 131.0
Hermurai: 121.0
Warrior Princess: 120.0
Gargoyle: 119.5
The Honourable: 119.0
Hebi: 118.5
Predictor: 116.0
Whack-a-mole: 107.0
The Fool: 106.0
The Prophet: 105.0
Copy-san: 97.0
YAGMCSE: 80.0
The Waiter: 66.0
Swordsman: 43.0
Spork Holder: 32.5
Blessed Samurai: 27.5
Attacker: 27.0
The Terminator: 17.0
Master Yi: 16.0

수도사 ^_(자바)

수도 사는 신의 축복을 존중하고 찬양합니다. 그는 인내심을 가지고 훈련되어 하나님의 은혜를받을 때까지 침착하게 하늘로기도를 보냅니다.

그는 인생을 즐기면서 그것을 보호하려고 노력합니다. 일정 속도 이상으로 건강을 잃으면 최대한 자신을 변호합니다.

그는 신들의지지를 기대하면서 임의로 사정 을 하늘에 보냅니다 ^[1] . 그렇지 않으면 그는 최선을 다해 싸운다.

그의 상대가 전투에서 닳 았다면 그는 남은 명예를 사용하여 그를 빠르고 고통없이 죽게합니다.

컴파일 / 실행

javac Monk.java
java Monk

public class Monk {
    public static void main(String[] args){
        char  r = 'B';
        double  s = Math.random ();
        int n = Math.max (args [0].length ()- 8, 1);
        int p = args.length > 4 ? Integer.parseInt (args [4]):0;
        int l = Integer.parseInt (args [3]);
        int m = Integer.parseInt (args [2]);
        double d = 1 + (20 - m) / n;
        double e = 1 + (20 - l) / n;

        if (((p>8&&s<.7)||l<11||m<2)&&p>0) {
                r=(s<(.14)||d>=2||e/d<.618)?'G':"OPI".charAt((int)(Math.random()*3));
        }

        System.out.print (r);
    }
}

닌자 ^(자바)

닌자는 빠르며 훨씬 더 빠르게 공격합니다. 그는 친근한 공식 인사를 마친 후 즉시 공격하며, 매 공격 전후에 절을하여 적을 혼란스럽게합니다.

축복을 받았을 때 닌자는이 행동을 계속하고 상대방이 첫 번째 움직임을 할 때까지 기다립니다. 이 기회를 이용하여 그는 전투에서 너무 닳아 없어 질 때까지 닌자 여신의 축복을 받아 일련의 폭발을 일으킨다. 그는 남은 명예를 사용하여 아래의 나뭇잎 아래 숨어 다음 공격으로부터 자신을 보호합니다. 그는 뛰어 내리고 뒤에서 적을 공격하여 다시 숨겨져 있습니다.

그가 치명적인 상처를 입으면, 상대방의 생명을 가져다 줄 것입니다. 물론 미미한 명예를 유지합니다.

javac Ninja.java
java Ninja

public class Ninja {
    public static void main(String[] args){
        char  r = 'B';
        int n = args [0].length ();
        int p = args.length > 4 ? Integer.parseInt (args [4]):0;
        int m = Integer.parseInt (args [2]);
        int a = n % 3;
        if (p>7) {
           if (m>17) {
                r = "BBI".charAt (a);
           } else if (m>13) {
                r = "BII".charAt (a); 
           } else {
               r  = "GIG".charAt (a);
           }

        } else if (p>0) {
           if (m > 10) {
                    r = "BBI".charAt (a);
           } else {
                r="IGI".charAt (n%2);
           }
        }
        System.out.print (r);
    }
}

카카시, 카피 캣 닌자 ^(자바)

카카시는 상대가 한 마지막 두 이동을 무작위로 선택하여 상대 이동을 복사합니다. 상대방이 기다리면 절을한다. 그는 명예를 유지한다.

javac Kakashi.java
java Kakashi

public class Kakashi {
    public static void main(String[] args){
        char  r;
        String h = args [1];
        if (h=="W" || Integer.parseInt ( args.length > 4?args [4]:"0") < 1){
                 r = 'B';
        } else if (Math.random ()<.1) {
            r = 'I';
        } else {
            r  = h.charAt ((int) (h.length()==1?0: h.length()-Math.random ()*2));
        }

        System.out.print (r);
    }
}

_{나는 카카시가 공유에 대해 축복받을 수 있기를 바란다. 나는 cast.txt를 읽는 것에 대해 생각했다. 그의 역사의 모든 라운드를 그곳의 모든 상대와 비교하십시오. 시뮬레이션 된 적의 역사와 실제 적의 역사를 비교하여 그가 상대하는 상대를 찾으십시오. 그런 다음 해당 정보를 사용하여 상대방이 다음에 할 움직임을 예측하고 미리 정의 된 목록에서 가장 좋은 반격을 선택하십시오. 하지만 지금은 인터넷 속도가 느리고 Java 기술이 없어서 조금 시간이 걸릴 수 있다고 생각합니다.}

관찰자 ^(node.js)

관찰자는 과거 5 번의 움직임에서 상대방의 다음 움직임을 예측하기 전에 절을하고 예측 된 움직임에 가장 적합한 상대를 선택합니다.

편집 : node.js boilerplate!을 공유 한 @apsillers에게 감사드립니다.

node observer.js

var argv = process.argv;
var history = argv.length>6?argv[2]:"";
var enemyHistory = argv.length>6?argv[3]:"";
var offset = 8 - argv.length;
var my = { health:+argv[4-offset], honor:+argv[6-offset], history:history };
var enemy = { health:+argv[5-offset], honor:+argv[7-offset], history:enemyHistory };
my.godSword = my.honor >= 7;
enemy.godSword = enemy.honor >= 7;
function decide() {
    process.stdout.write(arguments[Math.floor(arguments.length*Math.random())]);
    process.exit();
}

var m = {
    m:{},
    l:function (a,b) {
        if (!this.m[a]) {
           this.m [a] = [];
        }
        this.m[a].push (b);
    },
    p:function (a) {
       for (var k=0;k<a.length;k++)
       for (var j=1;j<a.length;j++)
       for (var i=-1+k; i<a.length-j; i++)this.l (a.slice (i,i+j),a[i+j]);
    },
    a:function (a) {
      if (!this.m[a])return;
      return this.m[a][0|Math.random () * this.m[a].length-1]
    }
}
var g={
   B:"IPO",
   G:"B",
   I:"PG",
   O:"IG",
   P:"OG",
   W:"I"
}
var c,i=0;
m.p(enemy.history);
while (!c && i++<enemy.history.length) {
   c=m.a (enemy.history.slice (i));
}
decide.apply  (0,my.honor < 7?["B"]:g[c].split (''))

편집 : 나는 관찰자에게 큰 결함이 있었고, 어제 밤에 내가 생각한 것을 실제로 모른다. 그는 과거 두 번의 적의 움직임 만 보았던 것 같습니다. 그는 놀랍게도 이렇게 좋아했습니다.

그의 기억은 이제 그가 본 적의 역사에서 가장 긴 (끝) 부분을 쿼리받습니다. 여기에는 이동 기록을 따르는 모든 이동이 포함 된 배열이 포함됩니다. 하나는 무작위로 선택됩니다. 따라서 한 번의 움직임이 더 자주 발생하면 선택 될 가능성이 높습니다. 마르코프 체인과 같은 종류.

관찰자는 이제 보호합니다.

_{[1] : TIL : 사정은 종교적인 의미가 있습니다}

메이요 센시 ^_(자바)

Haijima 지역에서 출발하는 Meiyo에 대해서는별로 알려지지 않았습니다. 그들은 일반적으로 스포츠 게임에 참여하지는 않지만 라이벌을 평가하기 위해 이것에 전사를 보냈습니다.

그들은 명예로운 무리이므로, 신에게 그의 존재를 짧은 순서로 알리게 될 것입니다. 그가보고 할 적을 충분히 본 후에는받은 축복을 사용하여 상대를 물리치게됩니다.

실행을 컴파일하려면 표준 Java 방법입니다.

> javac MeiyoSenshi.java
> java MeiyoSenshi

public class MeiyoSenshi {
    public static void main(String[] args){
        System.out.print(
                Integer.valueOf(args[args.length<5?0:2])>12 ||
                Integer.valueOf(args[args.length<5?2:4])<1  ?
                "B":
                "IPO".charAt((int)(Math.random()*3))
        );
    }
}

스포크 홀더 ^_(루비)

스포크 홀더는 첫 턴에 절을 한 후 무작위로 행동합니다. 두 가지 예제 항목 중 하나입니다.

명령: ruby spork-holder.rb

if ARGV.length == 4
    print "B"
else
    print ["W", "B", "G", "I", "P", "O"].sample
end

웨이터 ^_(bash)

웨이터는 매 턴마다 대기합니다. 두 가지 예제 항목 중 하나입니다.

명령: echo W

소스 코드가 필요하지 않습니다.

겁쟁이 _^(Node.js)

나는 겁쟁이 / 숨쉬는 기적이야
압도적 인 / 가장 온화한 여름 바람

• 을 검사합니다 BXBXBX/ BBB당신이 굴복 할 때 패턴 나비 (또는 충돌)합니다.
• GXGXGX보호 할 때 절을 할 패턴을 확인합니다 .
• 그의 무작위 용감한 롤이 해당 라운드에 대한 두려움 임계치를 극복하면, 그는 명중을 시도합니다.
  • 신들의 검을 가지고 용감 해집니다.
  • 신들의 검을 가진 상대는 그를 더 두려워하게 만듭니다.
  • 체력이 5 이상 이상인 적도 그를 조금 무섭게 만듭니다.
• 그렇지 않으면 교대로 경비와 절을한다.

Node.js 제출을 작성 하려면 상용구 코드를 사용하십시오. decide기능을 포함하여 최대의 모든 것이 완전하고 일반적입니다.

node coward.js

var argv = process.argv;
var history = argv.length>6?argv[2]:"";
var enemyHistory = argv.length>6?argv[3]:"";
var offset = 8 - argv.length;
var my = { health:+argv[4-offset], honor:+argv[6-offset], history:history };
var enemy = { health:+argv[5-offset], honor:+argv[7-offset], history:enemyHistory };
my.godSword = my.honor >= 7;
enemy.godSword = enemy.honor >= 7;
function decide() {
    process.stdout.write(arguments[Math.floor(arguments.length*Math.random())]);
    process.exit();
}

var enemyGuards = !!enemy.history.match(/G.G.G.$/);
var enemyBows = !!enemy.history.match(/(B.B.B.$)|(BBB$)/);

// open with a bow
if(!my.history) { decide("B"); }

// enemy will likely bow? Hit them with your super sword! (or bow)
if((!enemy.honor || enemyBows)) {
    if(my.godSword) { decide("P","I","O"); }
    else { decide("B"); }
}

// no point in hitting them if they're going to guard
if(enemyGuards) { decide("B"); }

// calculate bravery level
var braveryLevel = 0.3;
braveryLevel += (my.godSword * 0.2) - (enemy.godSword * 0.2);
braveryLevel -= (enemy.health - my.health > 5) * 0.1;

// if we're feeling brave, hit them
if(Math.random() < braveryLevel && my.honor) { decide("P","I","O"); }

// if we didn't just guard, and we're not feeling brave, cower in fear
if(!my.history.match(/G$/)) {
    decide("G");
}

// if we did just guard, and we're feeling cowardly,
//   if we don't have sword of the gods, bow
//   otherwise, do anything except guard
if(!my.godSword) {
    decide("B");
} else {
    decide("B","P","I","O");
}

두더지 ^_(R)

적이 절을 할 가능성이 높으면 공격합니다.

args <- commandArgs(TRUE)
L <- length(args)
my_health <- as.integer(args[L-3])
enemy_health <- as.integer(args[L-2])
my_honour <- as.integer(args[L-1])
enemy_honour <- as.integer(args[L])
if(L>4){enemy_history <- args[L-4]}else{enemy_history <- ""}
if(my_honour<1){
    out <- "B"
}else if (enemy_honour<=1 | grepl("BB$",enemy_history)){
    out <- sample(c("I","O"),1)
}else{
    out <- "G"
}
cat(out)

를 사용하여 실행하십시오 Rscript Whack-a-mole.R.

코끼리 전사 ^_(자바)

코끼리 전사는 나이가 많고 자연스러 웠습니다. 그는 많은 것을 보았고 모든 것을 기억합니다. 그는 상대를 조사하는 동안 신들에게 호의를 베풀고, 일단 그들을 마음에 데려 가면 그들을 분리시킵니다.

컴파일 : javac ElephantWarrior.java
명령 :java ElephantWarrior

import java.util.LinkedList;

//Elephants never forget
class ElephantWarrior
{


  static LinkedList<Choice> analysis = new LinkedList<Choice>();

  public static void main(String[] args){
      if(args.length < 6){ respond("B");}   
      String myhis = args[0];
      String enHis = args[1];
      int health = Integer.parseInt(args[2]);
      int enHealth = Integer.parseInt(args[3]);
      int honour = Integer.parseInt(args[4]);
      int enHonour = Integer.parseInt(args[5]);

        //Bow a few times until I know how he operates
        if(enHis.length() <= 5){
            respond("B");
        }

        //Special cases
        //If I'm at 0 honor, better bow
        else if(honour <= 0){
            respond("B");

        }
        else{
          analyze(enHis);

          //Narrow it down to applicable choices
          char hisLast = enHis.toCharArray()[enHis.toCharArray().length - 1];
          LinkedList<Choice> hisOptions = new LinkedList<Choice>();
          for(Choice c: analysis){
              if(c.pattern.toCharArray()[0] == hisLast){
                  hisOptions.add(c);
              }
          }

           //Default to assuming they bow
          char hisNext = 'B';
          int mostLikely = 0;

          //What will they do next?
          for(Choice c : hisOptions){
              if(c != null && c.probability > mostLikely){
                  //System.out.println("Option = " + c.pattern);
                  //System.out.println("Prob = " + c.probability);
                  mostLikely = c.probability;
                  hisNext = c.pattern.toCharArray()[1]; }
          }

          //Now go through potential case
          switch(hisNext){
              case 'W':
                  respond("I");
                  break;
              case 'B': 
                  respond("O");
                  break;
              case 'G':
                  respond("B");
                  break;
              case 'I':
                  if(enHonour  > 0){
                      respond("P");
                  }
                  else{
                      respond("B");
                  }
                  break;
              case 'P':
                  respond("O");
                  break;
              case 'O':
                  respond("I");
                  break;
              default:
                  respond("G");
          }
        }
    }





      static void analyze(String his){

        //Keep track of his previous moves
        char[] shortString = his.substring(1,his.length() - 1).toCharArray();
        char[] longString = his.toCharArray();
        for( int i = 0; i < shortString.length; i++) {
          String pattern = "" + longString[i] + shortString[i];
          boolean exists = false;
          for(Choice c : analysis){
              if(c.pattern.equals(pattern)){
                  exists = true;
                  c.probability++;
              }
          }
          if(!exists){
              analysis.add(new Choice(pattern, 1));
          }
        }
      }

      private static void respond(String s){
            System.out.println(s);
            System.exit(0);
        }

    }

class Choice{
        String pattern;
        int probability;

       Choice(String p, int i){
            pattern = p;
            probability = i;
       }
}

전사 공주 ^_(줄리아)

이것은 내가 경쟁 한 첫 번째 King of the Hill 도전입니다. 이것이 어떻게 진행되는지 봅시다.

전사 공주는 공격과 명예의 우선 순위를 정하고 필요할 때 자기 보존에 의지합니다. 그녀는 오히려 열심이고 기다리지 않습니다. 민첩하게 유지하기 위해 오버 헤드 공격도 사용하지 않습니다.

다음과 같이 저장 warrior-princess.jl하고 명령 행에서 실행 하십시오 .

julia warrior-princess.jl <arguments>

Julia가없는 경우 여기에서 다운로드 할 수 있습니다 . 문제를 피하려면 최신 안정 버전 (예 : 개발 버전)이 권장됩니다.

type Samurai
    history::String
    health::Int
    honor::Int
end

A = length(ARGS) < 5 ? ["", "", ARGS] : ARGS

me = Samurai(A[1], int(A[3]), int(A[5]))
opponent = Samurai(A[2], int(A[4]), int(A[6]))


if length(me.history) == 0

    # Always begin the match with an honorable bow
    action = "B"

elseif (!ismatch(r"[OIP]", opponent.history) && me.history[end] != 'G') ||
       (me.health < 2 && me.honor > 0)

    # Guard if the enemy has not yet attacked and I did not previously
    # guard, or if my health is low and my honor is sufficient
    action = "G"

elseif me.honor < 2

    # Bow if I'm low on honor
    action = "B"

elseif opponent.honor >= 7 && opponent.history[end] ∈ ['B', 'W']

    # Assume the enemy will attack with the Sword of the Gods if they
    # most recently bowed or waited
    action = "I"

else
    action = "P"
end

println(action)

석상 ^_(자바)

명예를 잃지 않고 방어 이동을 시도합니다.

그것은 자바 항목이기 때문에 :

> javac Gargoyle.java
> java Gargoyle

public class Gargoyle { 
    public static void main(String args[]) {
        if (args.length < 5 || Integer.valueOf(args[4]) > 0) {
            System.out.println("IPO".charAt((int)(Math.random()*3)));
        } else if (args[0].charAt(args[0].length()-1) != 'G') {
            System.out.println('G');
        } else {
            System.out.println('B');
        }
    }
}

검객 ^{_{(C / Java)}}

검객은 첫 턴에서 그리고 그가 명예를 떨칠 때마다 절을한다. 그런 다음 상대방이 이전 차례에 절하거나 방어하지 않았거나 기다렸는지 확인합니다. 상대방이 그렇지 않은 경우, 현재 턴에서이 중 하나를 수행하고 검객이 무작위로 상대에게 타격을 입힐 가능성이 큽니다. 이것이 사실이 아닌 경우, 그는 이전 차례를 방어하지 않은 경우 방어합니다. 그가 있다면, 그는 명예를 얻기 위해 절을한다.

C 버전 :

#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void print_and_exit(char* str)
{
    puts(str);
    exit(0);
}

int main(int argc, char** argv){

    srand(time(NULL));
    char* attack_moves[]={"I", "P", "O"};
    int random_num = rand() % 3;

    if(argc == 5 || atoi(argv[5]) == 0)
        print_and_exit("B");
    else if(argv[2][strlen(argv[2])-1] != 'B' && argv[2][strlen(argv[2])-1] != 'G' && argv[2][strlen(argv[2])-1] != 'W')
        print_and_exit(attack_moves[random_num]);
    else if(argv[1][strlen(argv[1])-1] != 'G')
        print_and_exit("G");

     print_and_exit("B");
}

GCC (컴파일러)를 설치 하고 컴파일을 위해 " Swordsman.c "명령 파일에 코드를 저장하십시오 .

gcc Swordsman.c -o Swordsman

" Swordsman " 이라는 이름의 실행 파일 이 생성됩니다. 를 사용하여 실행

Swordsman

자바 버전 :

public class Swordsman {

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }
    public static void main(String[] argv) {

        String attack_moves[]={"I", "P", "O"};
        int random_num = (int)(Math.random()*3);

        if(argv.length == 4 || Integer.valueOf(argv[5]) == 0)
            print_and_exit("B");
        else if(argv[2].charAt(argv[2].length()-1) != 'B' && argv[2].charAt(argv[2].length()-1) != 'G' && argv[2].charAt(argv[2].length()-1) != 'W')
            print_and_exit(attack_moves[random_num]);
        else if(argv[1].charAt(argv[1].length()-1) != 'G')
            print_and_exit("G");

         print_and_exit("B");
    }

}

javac (컴파일러)를 설치 하고 컴파일을 위해 " Swordsman.java " 라는 파일에 코드를 저장하십시오 .

javac Swordsman.java

" Swordsman.class " 라는 클래스 파일 이 생성됩니다. 를 사용하여 실행

java Swordsman

공격자 ^_(자바)

공격자는 상대방이 죽기를 원한다는 것을 제외하고는 아무것도 신경 쓰지 않습니다. 그는 무작위로 공격 중 하나를 공격하고 명예가 낮 으면 활을칩니다.

public class Attacker {

    static int position = -1;

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }
    public static void main(String[] argv) {

        String attack_moves[]={"I", "P", "O"};
        position = (position + 1) % 3;

        if(argv.length != 5 && Integer.valueOf(argv[5]) == 0)
            print_and_exit("B");
        else 
            print_and_exit(attack_moves[position]);
    }

}

javac (컴파일러)를 설치 하고 컴파일을 위해 " Attacker.java " 라는 파일에 코드를 저장하십시오 .

javac Attacker.java

" Attacker.class " 라는 클래스 파일 이 생성됩니다. 를 사용하여 실행

java Attacker

예측 자 ^{_{(C / Java)}}

예측자는 적의 움직임을 예측합니다. 첫 번째 턴에서는 무작위 이동을 사용합니다. 적의 명예가 낮 으면 활을 쏘고 적의 명예가 낮거나 이전 차례에 절을 쳤다면 공격합니다. 예측자가 이전 턴을 지키지 않은 경우 현재 턴을 가드합니다. 그렇지 않으면, 'W'예측자가 절 하지 않는 한, 이전 턴에서 적이했던 것과 같은 움직임을합니다 .

C 버전 :

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

void print_and_exit(char* str)
{
    puts(str);
    exit(0);
}

int main(int argc, char** argv){

    srand(time(NULL));
    int random = rand() % 5;
    char* moves[] = {"B", "G", "I", "P", "O"};

    if(argc == 5)
        print_and_exit(moves[random]);

    if(atoi(argv[5]) <= 0)
        print_and_exit(moves[0]);
    if(atoi(argv[6]) <= 0)
        print_and_exit(moves[4]);
    if(argv[2][strlen(argv[2])-1] == 'G')
        print_and_exit(moves[4]);
    if(argv[1][strlen(argv[1])-1] != 'G')
        print_and_exit(moves[1]);

    if(argv[2][strlen(argv[2])-1] != 'W'){
        char buf[2]={0};
        *buf = argv[2][strlen(argv[2])-1];
        print_and_exit(buf);
    }

    print_and_exit(moves[0]);

}

GCC (컴파일러)를 설치 하고 컴파일을 위해 " Predictor.c " 라는 파일에 코드를 저장하십시오 .

gcc Predictor.c -o Predictor

" Predictor " 라는 실행 파일 이 생성됩니다. 를 사용하여 실행

Predictor

자바 버전 :

public class Predicator{

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }

    public static void main(String[] argv){

        int random = (int)(Math.random() * 5);
        String moves[] = {"B", "G", "I", "P", "O"};

        if(argv.length == 4)
            print_and_exit(moves[random]);
        else if(Integer.valueOf(argv[5]) <= 0)
            print_and_exit(moves[0]);
        else if(Integer.valueOf(argv[6]) <= 0)
            print_and_exit(moves[4]);
        else if(argv[2].charAt((argv[2].length())-1) == 'G')
            print_and_exit(moves[4]);
        else if(argv[1].charAt((argv[1].length())-1) != 'G')
            print_and_exit(moves[1]);
        else if(argv[2].charAt((argv[1].length())-1) != 'W'){
                    print_and_exit(""+argv[2].charAt((argv[2].length())-1));
        }
        else
            print_and_exit(moves[0]);
    }
}

javac (컴파일러)를 설치 하고 컴파일을 위해 " Predicator.java " 라는 파일에 코드를 저장하십시오 .

javac Predicator.java

" Predicator.class " 라는 클래스 파일 이 생성됩니다. 를 사용하여 실행

java Predicator

마스터이 (파이썬)

마스터 어 s 신은 초기 게임에서 많은 호의를 얻습니다. 그들이 가장 적게 기대할 때 공격을 시도합니다.

import sys, random

class MasterYi(object):
    def __init__(self):
        self.attack = lambda: random.choice(['I','P','O'])
        self.bow   = "B"
        self.guard = "G"
        self.wait  = "W"
        if len(sys.argv)>6:
            self.hist = sys.argv[1]; self.ohist = sys.argv[2]
            self.hp   = sys.argv[3]; self.ohp   = sys.argv[4]
            self.hon  = sys.argv[5]; self.ohon  = sys.argv[6]
        else:
            self.hist = [];          self.ohist = []
            self.hp   = sys.argv[1]; self.ohp   = sys.argv[2]
            self.hon  = sys.argv[3]; self.ohon  = sys.argv[4]
        self.last  = self.hist  and self.hist[-1]  or "W"
        self.olast = self.ohist and self.ohist[-1] or "W"
        self.oGuarder = len(self.ohist)>4 and self.ohist[-4]==self.ohist[-2]=="G"

    def move(self):
        if self.hon < 1: return self.bow
        if self.olast == "G": return self.attack
        if self.hon > 6:
            if self.oGuarder: return self.bow
            if self.ohon > 6: return self.guard
            if self.ohon < 7: return self.attack
            return self.attack
        if self.ohon > 6: return self.guard
        return self.bow

Yi = MasterYi()
print(Yi.move())

실행하려면 : 다른 이름으로 저장 MasterYi.py

python MasterYi.py <args>

카피 산 ^_(C)

상대방의 모든 움직임을 복사합니다. 그가 잃을 것이라고 확신합니다. 엮다:gcc copy-san.c

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc == 5) {
        putchar('B');
    } else {
        char *enemy_hist = argv[2];
        size_t len = strlen(enemy_hist);
        putchar(enemy_hist[len - 1]);
    }
    putchar('\n');
    return 0;
}

헤비 (자바)

Hebi는 뱀의 길을 따릅니다.

뱀은 신들의 축복을 필요로하지 않습니다.

뱀은 파업을 strike 다. 해변의 파도처럼, 들어온 것은 돌아 오는 길을 뒤로 물러납니다.

뱀은 절대 기다리지 않습니다.

뱀은 적절 함이 없으며, 그렇지 않으면 파이썬으로 작성되었을 것입니다.

실행 지침 :

> javac hebi.java
> java hebi

코드 본문 :

public class hebi{

    public static void main(String args[]){

        if( (args.length < 5) || (args[0].length() % 18 == 0) ) System.out.println( "IPO".charAt((int)(Math.random()*3)) );
        else{

            int hist_size = args[0].length();

            if      (hist_size % 3 == 1) System.out.println("G");
            else if (hist_size % 3 == 2) System.out.println("B");
            else{

                if     (hist_size % 18 ==  9) System.out.println(args[0].charAt(hist_size -  3));
                else if(hist_size % 18 == 12) System.out.println(args[0].charAt(hist_size -  9));
                else if(hist_size % 18 == 15) System.out.println(args[0].charAt(hist_size - 15));
                else{

                    char move_head = args[0].charAt( (hist_size / 18) * 18 );
                    char move_mid;
                    if( hist_size % 18 == 3 ){
                        if     ( move_head == 'I' ) move_mid = "PO".charAt((int)(Math.random()*2));
                        else if( move_head == 'O' ) move_mid = "IP".charAt((int)(Math.random()*2));
                        else                        move_mid = "OI".charAt((int)(Math.random()*2));
                        System.out.println(move_mid);
                    }
                    else{
                        move_mid = args[0].charAt( ((hist_size / 18) * 18) + 3 );
                        char move_tail;

                        if( move_head == 'I' ){
                            if( move_mid == 'P' ) move_tail = 'O';
                            else                  move_tail = 'P';
                        }else if( move_head == 'P' ){
                            if( move_mid == 'O' ) move_tail = 'I';
                            else                  move_tail = 'O';
                        }else{
                            if( move_mid == 'I' ) move_tail = 'P';
                            else                  move_tail = 'I';
                        }

                        System.out.println( move_tail );

                    }

                }

            }

        }

    }

}

명예 (자바)

존경 할만한 가치는 무엇보다도 존중합니다. 즉, 다른 사람보다 그의 영광입니다. 적 사무라이의 명예가 크거나 같으면 절합니다. 그보다 더 명예로운 사람은 없을 것이다. 그렇지 않으면 무작위로 움직입니다. 그는 두 번 연속으로 경비를하지 않습니다.

컴파일하기:

> javac TheHonourable.java
> java TheHonourable

출처:

public class TheHonourable {
    public static void main(String[] args) {
        char move;

        if (args.length < 5) {
            move = 'B';
        } else if (Integer.valueOf(args[5]) >= Integer.valueOf(args[4])){
            move = 'B';
        } else {
            move =  (args[0].endsWith("G")) ?
                    "IPO".charAt((int)(Math.random()*3)) :
                    "GIPO".charAt((int)(Math.random()*4));
        }

        System.out.print(move);
    }
}

축복받은 사무라이 ^_(파이썬)

이 사무라이는 가능한 한 오랫동안 신의 호의를 유지하려고합니다. 그는 성검을 얻기 위해 서두르고 나서 파업 중 하나로 가드와 어택을 번갈아 가며 필요할 때 명예를 재입고합니다. 상대방이 곧 쓰러 질 것 같으면 서두르고 죽인다. 그는 자신의 패턴을 추적 할 수있는 상대에게 쉽게 넘어 질 것이지만 항상 두 피해로 공격하는 전략은 매우 효과적입니다.

import sys
import random
class BlessedSamurai(object):
    def __init__(self):
        if len(sys.argv) < 7:
            print("B")
        else:
            self.attack = ['O', 'I', 'P']
            self.hp = sys.argv[3]
            self.ohp = sys.argv[4]
            self.hon = sys.argv[5]
            self.last = sys.argv[1][-1]
            print(self.move())

    def move(self):
        #check if I have low health or should rush the kill
        if (self.hp < 5 or self.ohp < 5) and self.hon > 0:
            return(random.choice(self.attack))
        # charge honour to get SOTG
        elif self.hon < 7:
            return 'B'
        #Alternate guarding and attacking
        else:
            if self.last == 'G':
                return(random.choice(self.attack))
            return 'G'
Sam = BlessedSamurai()

실행하려면 :
BlessedSamurai.py로 저장

python BlessedSamurai.py <args>

허무 라이 ^{_{(C ++)}}

그의 상대를 존경하고 약간 편집증입니다. 그는 여전히 자신이 사무라이라고 믿을 수 없기 때문에 다른 사무라이가 할 수있는 일을 할 수 있는지 알고 싶어합니다. 그의 꿈은 결코 사라지지 않고 현실이되었습니다. 그의 머리 비용이들 수 있습니다 ...

#include <stdio.h>
#include <string>
#include <sstream>

using namespace std;

char getLastAttack(string enemy_history)
{
    size_t found = enemy_history.find_last_of("IPO");
    if(found == string::npos)
    {
        return 'I';
    }

    return enemy_history[found];
}

int main(int argc, const char * argv[])
{
    if(argc != 7){
        printf("B");
        return 0;
    }

    string enemy_history(argv[2]);

    int ho;
    string honour(argv[5]);
    stringstream(honour) >> ho;

    if(ho > 20){
        char atk = getLastAttack(enemy_history);
        printf("%c", atk);
        return 0;
    }

    char lastMove = enemy_history[enemy_history.length()-1];
    if(lastMove == 'W' || lastMove == 'G')
        lastMove = 'B';
    printf("%c", lastMove);
    return 0;
}

이니 키 ^{_{(C ++)}}

가능한 한 열심히칩니다. 위험에 처했을 때 막을 수없는 공격 모드로 들어갑니다.

#include <stdio.h>
#include <string>
#include <sstream>

using namespace std;

char getLastAttack(string enemy_history)
{
    size_t found = enemy_history.find_last_of("IPO");
    if(found == string::npos)
    {
        return 'I';
    }

    return enemy_history[found];
}

int main(int argc, const char * argv[])
{
    if(argc != 7){
        printf("B");
        return 0;
    }

    string history(argv[1]);
    string enemy_history(argv[2]);
    string health(argv[3]);
    string enemy_health(argv[4]);
    string honour(argv[5]);
    string enemy_honour(argv[6]);

    int he, enemy_he, ho, enemy_ho;
    stringstream(health) >> he;
    stringstream(enemy_health) >> enemy_he;
    stringstream(honour) >> ho;
    stringstream(enemy_honour) >> enemy_ho;

    if(ho > 6 || ((he < 6 || enemy_he < 6) && ho > 0))
    {
        char atk = getLastAttack(enemy_history);
        printf("%c", atk);
        return 0;
    }


    printf("B");
    return 0;
}

둘 다 C ++로 작성되었습니다. 컴파일하기:

g++ iniqy.cpp -o iniqy

Linux에서 실행하려면 다음을 수행하십시오. ./iniqy

Windows에서 실행하려면 iniqy.exe

터미네이터 ^_(루비)

터미네이터는 자신의 건강에주의를 기울이지 않습니다. 터미네이터는 명예에 대한 개념이 없습니다. 터미네이터는 미래에서 보내져 단순히 상대를 종료하기로 결정합니다. 상대방의 움직임을 보면서 그렇게 할 수 있습니다. 현재의 기술로는 터미네이터의 동작을 예측할 수없는 복잡한 방식으로 동작을 샘플링하고 적절한 응답을 계산합니다. 실제로, 2015 년에 거주하는 사람에게는 터미네이터가 다소 임의적으로 보일 수 있습니다 ...

responses = {
  ?W => %w(B I),
  ?B => %w(I O),
  ?G => %w(B B),
  ?I => %w(G P),
  ?P => %w(B O),
  ?O => %w(G I)
}

if ARGV.size > 4
  pool = ARGV[1].chars.map{ |c| responses[c] }.flatten
  puts pool.sample
else
  puts %w(O I P B).sample
end

에이전트 38 ^[1] (C)

광범위한 유전자 조작의 산물로, 에이전트 38은 슈퍼의 체격과 정신 시력이 ^[2] -samurai을, 확실히 그 힘없이 모두 우수하다 ^{[표창장은 필요로했다]} 결함 ^{[표창장은 필요로했다]} 경쟁.

//Agent 38
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#ifdef _WIN32
#include <Windows.h>
unsigned int tick_count(){
    return GetTickCount();
}
#else
#include <sys/time.h>
unsigned int tick_count(){
    struct timeval t;
    gettimeofday(&t, NULL);
    return 1000 * t.tv_sec + t.tv_usec / 1000;
}
#endif

float program[5][4][4][4][4]={
    {{{{-1.192779,0.693321,-1.472931,-0.054087},{0.958562,0.557915,0.883166,-0.631304},{-0.333221,1.410731,0.496346,0.087134},{0.459846,0.629780,-0.479042,-0.025909}},{{0.547976,1.059051,-0.748062,-0.675350},{-0.607591,-0.152156,-0.400350,-0.685337},{1.686450,0.628706,0.312865,0.324119},{1.652558,0.403733,-0.456481,-0.081492}},{{0.371629,-0.036948,-0.982682,0.065115},{1.360809,0.681294,0.505074,0.782737},{-0.545192,0.954937,-0.727853,0.273542},{-0.575777,1.615253,-0.064885,-0.516893}},{{0.577015,-0.112664,0.456595,-0.007560},{-0.660930,-0.738453,0.668093,1.716388},{1.972322,0.108558,0.535114,-0.337916},{0.640208,-0.019680,-0.769389,0.873087}}},{{{-0.021140,-0.095956,-0.098309,-0.280295},{-0.926284,1.724028,0.278855,0.678060},{0.153006,-1.860947,-0.577699,-1.931683},{-0.187152,0.529719,-1.164157,0.125499}},{{0.582208,-0.835029,-0.329857,0.088176},{-0.030797,0.389396,0.584636,-0.025866},{-0.736538,1.624658,0.690493,0.387515},{0.973253,-0.530825,1.934379,-0.872921}},{{0.812884,0.138399,-1.452478,-1.504340},{-0.119595,0.986078,-0.993806,1.102894},{0.848321,-0.268764,0.876110,0.782469},{0.948619,-0.557342,0.749764,-0.712915}},{{-1.195538,0.783784,-1.973428,-0.873207},{0.085426,-0.241360,-0.534561,-0.372105},{0.029696,-0.906821,0.932227,-0.834607},{0.764903,-0.276117,-1.346102,-0.093012}}},{{{0.168113,0.855724,1.817381,-0.547482},{0.468312,0.923739,-0.723461,0.798782},{-0.875978,-0.942505,-0.684104,-0.046389},{0.893797,-0.071382,0.283264,0.811233}},{{0.391760,0.309392,-0.045396,-0.977564},{0.085694,0.257926,-0.775461,0.060361},{0.486737,-0.175236,0.806258,-0.196521},{0.691731,-0.070052,0.636548,0.464838}},{{0.532747,-1.436236,-0.900262,-0.697533},{0.566295,0.650852,0.871414,-0.566183},{-0.075736,-0.886402,0.245348,-0.438080},{-0.811976,0.022233,-0.685647,0.323351}},{{-1.864578,1.141054,1.636157,-0.455965},{0.592333,0.890900,-0.259255,0.702826},{0.404528,0.905776,0.917764,0.051214},{0.761990,0.766907,-0.595618,-0.558207}}},{{{0.209262,-1.126957,-0.517694,-0.875215},{0.264791,0.338225,0.551586,0.505277},{0.183185,0.782227,0.888956,0.687343},{0.271838,0.125254,1.071891,-0.849511}},{{0.261293,-0.445399,0.170976,-0.401571},{0.801811,0.045041,-0.990778,-0.013705},{-0.343000,-0.913162,0.840992,0.551525},{-0.526818,-0.231089,0.085968,0.861459}},{{0.540677,-0.844281,-0.888770,0.438555},{0.802355,-0.825937,0.472974,-0.719263},{-0.648519,1.281454,0.470129,-0.538160},{-0.851015,0.985721,-0.993719,0.558735}},{{1.164560,-0.302101,0.953803,0.277318},{0.886169,0.623929,1.274299,-0.559466},{-0.948670,0.807814,-1.586962,-0.502652},{-0.069760,1.387864,-0.423140,0.285045}}}},
    {{{{0.747424,-0.044005,0.402212,-0.027484},{0.785297,0.169685,0.734339,-0.984272},{-0.656865,-1.397558,0.935961,-0.490159},{-0.099856,-0.293917,0.129296,-0.920536}},{{0.546529,-0.488280,-0.516120,-1.112775},{0.155881,-0.103160,0.187689,0.485805},{0.918357,0.829929,0.619437,0.877277},{0.389621,0.360045,0.434281,0.456462}},{{-0.803458,-0.525248,-0.467349,0.714159},{-0.648302,-0.005998,-0.812863,0.205664},{0.591453,0.653762,-0.227193,-0.946375},{0.080461,0.311794,0.802115,-1.115836}},{{-0.495051,-0.869153,-0.179932,0.925227},{-1.950445,1.908723,-0.378323,-0.472620},{-0.688403,-1.470251,1.991375,-1.698926},{-0.955808,-0.260230,0.319449,-1.368107}}},{{{-0.029073,-0.622921,-1.095426,-0.764465},{-0.362713,-0.123863,0.234856,-0.772613},{0.697097,0.103340,0.831709,0.529785},{0.103735,-0.526333,-0.084778,0.696831}},{{-0.670775,0.289993,-0.082204,-1.489529},{0.336070,0.322759,0.613241,0.743160},{0.298744,-1.193191,0.848769,-0.736213},{0.472611,-0.830342,0.437290,-0.467557}},{{-0.529196,-0.245683,0.809606,-0.956047},{-1.725613,0.187572,0.528054,-0.996271},{-0.330207,0.206237,0.218373,0.187079},{0.243388,0.625787,-0.388859,0.439888}},{{-0.802928,-0.811282,0.788538,0.948829},{0.966371,1.316717,0.004928,0.832735},{-0.226313,0.364653,0.724902,-0.579910},{-0.544782,-0.143865,0.069256,-0.020610}}},{{{-0.393249,0.671239,-0.481891,0.861149},{-0.662027,-0.693554,-0.564079,-0.477654},{0.070920,-0.052125,-0.059709,0.473953},{-0.280146,-0.418355,0.703337,0.981932}},{{-0.676855,0.102765,-0.832902,-0.590961},{1.717802,0.516057,-0.625379,-0.743204},{-0.170791,-0.813844,-0.269250,0.707447},{0.057623,0.472053,-0.211435,0.147894}},{{-0.298217,0.577550,1.845773,0.876933},{0.617987,0.502801,0.951405,0.122180},{0.924724,-0.166798,0.632685,-0.466165},{-0.834315,-0.864180,-0.274019,0.568493}},{{0.669850,-0.961671,0.790462,0.738113},{-0.534215,-0.556158,0.653896,0.031419},{0.065819,0.220394,0.153365,-0.373006},{0.886610,-0.742343,1.282099,0.198137}}},{{{0.092579,-0.026559,-1.121547,0.143613},{-0.289030,0.265226,-0.350741,-0.897469},{-0.918046,0.038521,-1.515900,0.488701},{-0.759326,-1.782885,-1.787784,0.249131}},{{-0.849816,-0.857074,-0.843467,-0.153686},{0.998653,0.356216,0.926775,0.300663},{-0.749890,-0.003425,-0.607109,0.317334},{-0.561644,0.446478,-0.898901,0.711265}},{{0.232020,-0.445016,0.618918,0.162098},{0.381030,-0.036170,0.084177,0.766972},{0.493139,0.189652,-0.511946,-0.273525},{0.863772,-0.586968,0.829531,-0.075552}},{{0.191787,-0.627198,0.975013,-0.448483},{-0.197885,0.151927,-0.558646,-1.308541},{-0.582967,1.207841,0.746132,0.245631},{0.314827,-0.702463,-0.301494,0.787569}}}},
    {{{{0.670028,-1.825749,-0.739187,0.482428},{0.175521,-0.020120,-0.154805,0.187004},{0.971728,-0.160181,-0.164031,-0.868147},{-0.954732,-0.175713,0.791116,0.294173}},{{-0.958337,-0.843157,-0.472882,0.273517},{-0.999058,0.824762,-0.223130,-0.150628},{0.393747,-0.301297,0.095572,-0.798950},{-0.119787,0.746673,0.955094,0.259353}},{{0.951590,0.225539,0.503282,0.668746},{-0.384898,-0.979592,-0.005485,-0.191883},{-0.692369,-0.642401,-0.825598,0.171933},{-0.321919,-0.498635,0.449704,0.780842}},{{-0.387902,0.522435,0.565608,0.166193},{-0.799671,-0.295871,-0.702573,-0.151006},{0.040550,-0.468503,0.651076,0.636352},{-0.839299,-0.090651,0.428761,0.187043}}},{{{-0.369823,0.377011,0.422936,0.284752},{-0.181514,-0.701449,0.748768,0.540533},{0.734381,0.149410,-0.867043,-0.397142},{-0.770904,-0.581897,-1.578306,-0.402638}},{{0.859015,-0.540358,0.202715,-0.975354},{-0.773629,-0.382342,-0.022498,-0.129286},{-0.901210,-0.641866,1.219216,0.731525},{0.740457,0.858546,-0.408661,-0.364897}},{{-0.830865,-1.370657,-1.226303,-0.392147},{-0.810554,-0.975232,-0.717845,-0.825379},{-0.150096,-0.664533,0.347084,0.243443},{-0.447383,0.842164,1.491342,0.380295}},{{-0.383958,0.811219,0.160459,0.841601},{1.631515,0.371637,0.110000,0.467783},{-0.689356,-0.004289,-0.081057,-0.317243},{0.092451,-0.181268,-0.575747,-0.580061}}},{{{0.908549,-0.013975,-0.880165,-0.938937},{-0.225713,0.449478,0.372569,-0.229889},{0.255711,-0.264752,0.307982,0.260505},{0.314966,-0.540905,0.743032,-0.078475}},{{-0.307472,-1.268296,0.020383,1.798401},{-0.150954,0.909716,-0.407903,0.379046},{0.621853,-0.003629,-0.582697,0.614618},{-0.122843,-0.627133,-0.217968,0.608322}},{{0.071923,0.807315,0.538905,-0.630660},{0.495641,0.240202,-0.920822,-0.258533},{-1.760363,-0.448525,-0.351553,-0.551666},{0.152720,0.900531,0.061966,-0.544377}},{{0.648923,0.450945,-1.530020,1.570190},{0.536210,0.078454,0.577168,0.464872},{-0.888258,-0.950748,0.781474,0.958593},{0.463631,0.319614,-0.248374,-0.413144}}},{{{0.293463,0.236284,1.721511,0.107408},{-0.790508,-0.072027,-0.559467,-0.955839},{-0.777662,-0.169876,0.896220,0.776105},{0.003944,-0.745496,-0.236446,-0.824604}},{{-1.770746,-0.051266,-0.174258,0.003074},{-0.339553,-0.868807,-0.032754,-0.494847},{-0.896712,0.957339,-0.003444,-1.582125},{-0.699883,0.626691,0.799635,-0.542343}},{{-0.635123,-0.755960,0.576373,-0.899530},{-0.393745,0.718900,0.312400,0.511415},{-0.647565,0.368431,0.214726,0.892693},{-0.511960,-0.513262,0.885908,-0.536478}},{{-0.590074,0.623328,0.268674,-0.401391},{0.308868,-0.869862,0.233132,0.243337},{-0.242908,-0.557192,-0.728454,0.867029},{0.156435,-0.805308,-0.815392,-1.437798}}}},
    {{{{0.613484,1.454566,-0.363858,0.634053},{0.535096,-0.641079,-0.607553,0.852559},{0.959100,-0.398621,0.375819,0.385756},{-0.601982,0.494128,0.809699,0.608804}},{{-1.390871,-0.943062,1.556671,0.966501},{-0.013242,0.152716,-0.089592,0.230793},{0.933785,0.119358,0.057387,0.502033},{-0.332925,0.537509,-0.081436,-0.701995}},{{-0.435117,0.996885,0.646630,-0.092342},{0.004343,-0.737514,-0.716187,-0.946819},{0.814258,-0.766971,-0.488162,-0.531619},{-0.923069,0.683915,-0.023809,-1.242992}},{{-0.909155,-0.166488,-0.159273,-0.908121},{-0.783871,-0.522598,0.691845,-0.164065},{1.255966,0.051373,-0.566025,0.820081},{0.186583,0.266032,-0.793747,-0.510092}}},{{{0.890639,0.970042,-0.507885,-0.029557},{-0.771142,-0.875802,0.400070,-1.264247},{-0.881146,0.570950,-0.051624,0.347612},{0.312110,-0.374885,0.600112,0.388460}},{{-0.417107,-0.309284,-0.128477,0.689671},{-0.695866,1.254585,-0.381883,-0.313415},{0.433565,0.919626,0.159180,-0.657310},{-1.396139,0.346053,0.108768,0.061238}},{{-0.776695,0.084491,0.045357,0.312823},{-0.379268,1.217006,-0.014838,-1.032272},{-1.251344,-0.366283,-0.124786,0.729754},{0.979936,0.669519,-0.900018,-0.596954}},{{-0.998834,0.593942,0.375639,-0.627459},{0.297281,0.400240,0.839707,0.960262},{-0.872143,0.574040,-0.559580,-1.965570},{-0.559218,-0.778780,-0.955526,-0.253380}}},{{{-1.919625,-1.911049,0.025035,0.754917},{-0.110993,0.535933,-0.572788,-0.856476},{-0.810836,-0.496261,1.128368,1.758826},{-0.564368,-1.849772,-0.251560,0.635528}},{{0.768196,-0.934122,0.207228,0.884610},{-0.356145,0.265792,-0.835582,0.377675},{-0.410745,0.613212,0.245560,-0.873826},{1.725191,-0.263344,-0.077167,-0.976379}},{{-0.736299,-0.109476,0.044512,-0.004005},{0.692230,0.316670,0.267247,-1.076821},{-0.903184,0.189762,-0.674111,0.219113},{0.639162,1.347521,0.428823,-0.765664}},{{-0.509165,0.458806,-0.851011,0.455027},{-0.218564,-0.063492,0.889320,-0.762062},{0.145950,0.985037,-0.489372,-0.879851},{0.352346,-0.127275,0.896496,-0.596037}}},{{{0.402678,1.479855,0.089187,0.967153},{-0.431225,0.402980,0.883584,-0.900324},{0.262233,-0.647278,0.637005,0.142678},{-0.003253,-0.671924,0.969458,-0.316752}},{{0.345185,-0.477503,-0.326822,-0.106251},{0.239521,1.617125,0.632651,0.969976},{-1.015183,-0.676629,0.955842,0.134925},{-0.319063,-0.493157,-0.488088,0.713008}},{{-0.468621,1.301292,-1.826501,1.138666},{0.170247,-0.661171,0.895204,-0.400700},{-0.077645,-0.978179,-0.245724,0.245282},{-0.258300,0.287261,-0.006274,0.549716}},{{-0.932247,-0.274950,0.920451,0.016237},{0.888865,-0.845248,1.661716,-0.108960},{0.712357,0.586609,-0.867356,0.355058},{-0.540912,0.892622,0.302627,0.247194}}}},
    {{{{0.817578,0.719047,0.438903,0.637398},{0.750466,-0.911799,-0.609606,0.358541},{-1.782979,-0.851717,-0.802122,0.735913},{0.490604,-0.417822,-0.332074,0.836756}},{{-0.650232,-0.442026,0.874916,0.705671},{0.217602,-0.755841,0.573944,0.279365},{-0.713729,0.358880,-0.308992,0.778297},{0.832099,-0.916695,-0.887834,1.041483}},{{1.019467,1.099488,-0.130674,-0.241995},{0.792572,0.756977,0.518186,0.070411},{-0.815779,-0.790757,-1.027439,-0.163698},{0.721461,-0.403364,0.656609,-0.367364}},{{-0.279333,-0.742041,0.515832,-0.408114},{0.834577,0.736056,0.900594,0.276357},{0.726000,0.464991,-0.569281,0.098139},{-0.582324,0.875666,-0.681556,-0.903009}}},{{{1.300969,-0.798351,0.107230,1.611284},{0.239211,0.418231,-0.795764,-0.398818},{-0.939666,1.768175,-0.297023,-0.064087},{-0.239119,-0.365132,0.864138,0.595560}},{{1.898313,-0.343816,1.066256,0.876655},{-0.053636,0.544756,-0.937927,0.189233},{0.445371,-0.656790,-0.675091,0.753163},{-0.293330,-0.002717,0.341173,0.095493}},{{0.951658,0.513912,-0.678347,-0.981140},{-0.020791,0.571138,-0.890648,0.881789},{-1.783345,0.909598,-0.393155,0.240630},{-0.057908,-0.237435,-0.124993,-0.754091}},{{-0.014153,0.127172,0.097134,0.538952},{0.167943,0.786395,0.946153,-0.762513},{-0.562758,0.675657,-0.226395,0.979761},{0.850214,0.818309,0.397074,-0.372059}}},{{{0.803316,-0.659538,-1.987864,-0.186366},{-0.259213,0.315848,-0.427898,0.326521},{-0.168181,-0.620898,0.562309,0.722064},{-1.949690,0.307720,-0.147760,0.603492}},{{0.898339,0.986228,0.724530,0.105193},{0.066046,0.037689,-0.553543,0.597864},{0.296553,0.165199,0.500125,-0.395978},{0.790120,-1.873361,0.354841,-0.187812}},{{-0.559746,0.357012,0.373903,-0.113564},{-0.671918,-0.919720,0.258328,-0.283453},{0.008365,0.597272,0.355827,0.391287},{0.355297,-0.631888,0.221383,1.448221}},{{0.259199,-0.491776,0.721151,0.391427},{0.494000,0.652814,-0.153306,-0.615687},{0.142167,-0.601161,0.281702,0.563390},{0.904019,1.284241,0.901663,0.244620}}},{{{-0.664638,-0.564596,0.839897,0.153358},{-0.506883,0.822337,-0.974957,-0.098112},{-0.962870,-0.274566,0.418039,-0.020525},{-0.965969,0.954587,-0.250493,-0.031592}},{{-0.966475,0.455338,0.868491,0.723032},{-0.002141,0.021922,-0.131429,-0.601106},{-1.240003,1.483318,1.612920,-0.653210},{-0.505979,0.005588,-0.087506,-0.705789}},{{-0.203137,0.765652,-0.132974,-0.900534},{0.731132,0.133467,-1.086363,0.600763},{1.795911,-0.411613,-1.990494,0.405937},{0.729332,-0.119175,-0.979213,0.362346}},{{-0.049014,0.228577,-1.728796,-0.898348},{-0.540969,1.245881,-0.820859,0.285859},{0.430751,-0.373652,0.034535,0.434466},{0.365354,0.243261,0.910114,1.497873}}}}
};
float eval_polynomial(float variables[4],int program_index,int variable_index,int indices[4]){
    if(variable_index==4)return program[program_index][indices[0]][indices[1]][indices[2]][indices[3]];
    float result=0,base=1;
    for(int power=0;power<4;++power){
        indices[variable_index]=power;
        result+=base*eval_polynomial(variables,program_index,variable_index+1,indices);
        base*=variables[variable_index];
    }
    return result;
}
int main(int argc,char *argv[]){
    srand(tick_count());
    rand();
    float variables[4],probability[5],total=0;
    int i,indices[4],temp;
    for(i=0;i<4;++i){
        sscanf(argv[i-4+argc],"%d",&temp);
        variables[i]=temp;
    }
    temp=variables[1];
    variables[1]=variables[2];
    variables[2]=temp;
    if(variables[1]==0){ //bow if our honour is 0
        putchar('B');
        return 0;
    }

    variables[0]/=20;variables[2]/=20;
    variables[1]=1/(variables[1]+1);variables[3]=1/(variables[3]+1);
    for(i=0;i<5;++i){
        probability[i]=eval_polynomial(variables,i,0,indices);
        if(probability[i]<0)probability[i]=0;
        total+=probability[i];
        probability[i]=total;
    }
    total*=(float)rand()/RAND_MAX;
    for(i=0;i<5;++i)if(total<probability[i]){
        putchar("BGIPO"[i]);
        return 0;
    }
    putchar('B');
    return 0;
}

_{[1] 완전히 관련이없는 숫자 [2] 시간의 1 %가 사실임을 보증 함}

YAGMCSE

몬테 카를로 방법은 괜찮은 플레이를 보여줍니다, 여기 또 다른 일반적인 몬테 카를로 시뮬레이션 항목이 있습니다!

이 콘테스트의 다른 출품작과는 달리이 출품작에는 수많은 무작위 게임 시뮬레이션이 사용되므로 최적의 성능을 위해서는 -O3 플래그를 사용해야합니다.

다음 명령으로 프로그램을 컴파일하십시오. gcc monte.c -o monte -O3 -std = c99

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#include <Windows.h>
unsigned int tick_count(){
    return GetTickCount();
}
#else
#include <sys/time.h>
unsigned int tick_count(){
    struct timeval t;
    gettimeofday(&t, NULL);
    return 1000 * t.tv_sec + t.tv_usec / 1000;
}
#endif

const int turn_limit=500;
enum Move{
    WAIT,BOW,GUARD,QUICK,PARRY,OVERHEAD
};
struct Player{
    int health,honour;
    enum Move lastMove;
};
typedef struct Player Player;
//<command> <history> <enemy_history> <your_health> <enemy_health> <your_honour> <enemy_honour>
//<command> <your_health> <enemy_health> <your_honour> <enemy_honour>
int damage_table[6][6][2]={
    {{0,0},{0,0},{0,0},{1,0},{1,0},{1,0}}, //P1 is waiting
    {{0,0},{0,0},{0,0},{1,0},{1,0},{1,0}}, //P1 is bowing
    {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}}, //P1 is guarding
    {{0,1},{0,1},{0,0},{0,0},{1,0},{0,1}}, //P1 is using quick draw
    {{0,1},{0,1},{0,0},{0,1},{0,0},{1,0}}, //P1 is parrying
    {{0,1},{0,1},{0,0},{1,0},{0,1},{0,0}} //P1 is using overhead attack
};
enum Move decode_move(char x){
    switch(x){
        case 'W': return WAIT; break;
        case 'B': return BOW; break;
        case 'G': return GUARD; break;
        case 'I': return QUICK; break;
        case 'P': return PARRY; break;
        case 'O': return OVERHEAD; break;
    }
    return WAIT;
}
struct SimulationStat{
    enum Move first_me_move;
    int win,draw,lose,compound;
};
int stat_compare(const void*a,const void*b){
    return ((struct SimulationStat*)b)->compound-((struct SimulationStat*)a)->compound;
}
struct SimulationStat monte_carlo(int num_iters,enum Move first_me_move,Player original_me,Player original_opponent){
    struct SimulationStat simulation_result={first_me_move,0,0,0};

    for(int iter=0;iter<num_iters;++iter){
    Player me=original_me,opponent=original_opponent;
        int turn,game_result;
        for(turn=0;turn<turn_limit;++turn){
            enum Move me_move,opponent_move=rand()%(OVERHEAD-BOW+1)+BOW;
            if(turn==0)me_move=first_me_move;
            else me_move=rand()%(OVERHEAD-BOW+1)+BOW;

            //update honour for guarding
            if(me.lastMove==GUARD&&me_move==GUARD)--me.honour;
            if(opponent.lastMove==GUARD&&opponent_move==GUARD)--opponent.honour;

            int me_attacking=me_move==QUICK||me_move==PARRY||me_move==OVERHEAD,opponent_attacking=opponent_move==QUICK||opponent_move==PARRY||opponent_move==OVERHEAD;

            //update health of players
            me.health-=damage_table[me_move][opponent_move][0]*(1+(opponent.honour>=7));
            opponent.health-=damage_table[me_move][opponent_move][1]*(1+(me.honour>=7));

            //update honour for attacking (Sword of the Gods is revoked after the player attacks with an original honour value of 7)
            if(me_attacking)--me.honour;
            if(opponent_attacking)--opponent.honour;

            //printf("%d %d\n",me.health,me.honour);
            //printf("%d %d\n",opponent.health,opponent.honour);

            //check if any of the terminating conditions are met
            //c. both players fall off the graces of the gods (me.honour<0&&opponent.honour<0)
            if(me.honour<0&&opponent.honour<0){
                game_result=0; //draw
                break;
            }
            //a. player 1 falls off the graces of the gods (me.honour<0)
            else if(me.honour<0){
                game_result=-1; //loss
                break;
            }
            //b. player 2 falls off the graces of the gods (opponent.honour<0)
            else if(opponent.honour<0){
                game_result=1; //win
                break;
            }
            //d. both players are dead (me.health<0&&opponent.health<0)
            else if(me.health<0&&opponent.health<0){
                game_result=0; //draw
                break;
            }
            //e. player 1 is dead (me.health<0)
            else if(me.health<0){
                game_result=-1; //loss
                break;
            }
            //f. player 2 is dead (opponent.health<0)
            else if(opponent.health<0){
                game_result=1; //win
                break;
            }
        }
        //both players get struck down by the guards for being boring
        if(turn==turn_limit)game_result=0; //draw

        if(game_result==1)++simulation_result.win;
        else if(game_result==0)++simulation_result.draw;
        else ++simulation_result.lose;
    }
    return simulation_result;
}
int main(int argc,char*argv[]){
    //const int num_iters=200000,num_shortlist_iters=1000000;
    const int num_iters=20000,num_shortlist_iters=55000;

    srand(tick_count());
    Player me,opponent;
    if(argc==5){
        sscanf(argv[1],"%d",&me.health);
        sscanf(argv[2],"%d",&opponent.health);
        sscanf(argv[3],"%d",&me.honour);
        sscanf(argv[4],"%d",&opponent.honour);
        me.lastMove=WAIT;
        opponent.lastMove=WAIT;
    }else{
        sscanf(argv[3],"%d",&me.health);
        sscanf(argv[4],"%d",&opponent.health);
        sscanf(argv[5],"%d",&me.honour);
        sscanf(argv[6],"%d",&opponent.honour);
        me.lastMove=decode_move(argv[1][strlen(argv[1])-1]);
        opponent.lastMove=decode_move(argv[2][strlen(argv[2])-1]);
    }

    struct SimulationStat results[6];
    results[0].first_me_move=WAIT;
    results[0].win=0;
    results[0].draw=0;
    results[0].lose=num_iters;
    results[0].compound=-num_iters*2-1000; //waiting is worse than any other action

    for(enum Move first_me_move=BOW;first_me_move<=OVERHEAD;++first_me_move){
        results[first_me_move]=monte_carlo(num_iters,first_me_move,me,opponent);
        struct SimulationStat *cur=&results[first_me_move];
        cur->compound=cur->win*4+cur->draw*1-cur->lose*2;
    }
    qsort(results,OVERHEAD-WAIT+1,sizeof(*results),stat_compare);

    for(int i=0;i<OVERHEAD-BOW+1;++i){
        struct SimulationStat *cur=&results[i];
//        fprintf(stderr,"%c: %f%% win, %f%% draw, %f%% lose => %d\n","WBGIPO"[cur->first_me_move],(double)cur->win/num_iters*100.,(double)cur->draw/num_iters*100.,(double)cur->lose/num_iters*100.,cur->compound);
    }

    for(int i=0;i<2;++i){
        results[i]=monte_carlo(num_shortlist_iters,results[i].first_me_move,me,opponent);
        struct SimulationStat *cur=&results[i];
        cur->compound=cur->win*2+cur->draw*1;
    }
    qsort(results,2,sizeof(*results),stat_compare); 

    for(int i=0;i<2;++i){
        struct SimulationStat *cur=&results[i];
//        fprintf(stderr,"%c: %f%% win, %f%% draw, %f%% lose => %d\n","WBGIPO"[cur->first_me_move],(double)cur->win/num_shortlist_iters*100.,(double)cur->draw/num_shortlist_iters*100.,(double)cur->lose/num_shortlist_iters*100.,cur->compound);
    }
    putchar("WBGIPO"[results[0].first_me_move]);
    return 0;
}