print('R')

import sys

winning_match = {
    'R': 'P',
    'P': 'S',
    'S': 'R'
}

responses = [other for self, other in sys.argv[1:]]

if responses:
    last = responses[-1]
    print(winning_match[last])
else:
    print('P')

bot_name = 'YOUR_SCRIPT_HERE.py'

import subprocess as sp

base_args = ['python', bot_name]
previous_runs = []
for run in range(5):
    args = base_args + previous_runs
    bot = sp.run(args, stdout=sp.PIPE)
    response = bot.stdout.decode().strip()
    
    print('Round #{0}:'.format(run))
    print('Response Received: {0}'.format(response))
    print('Response Understood: {0}'.format(response in 'RPS'))
    print()
    
    # let's pretend your opponent always does Paper...
    previous_runs.append('{0}{1}'.format(response, 'P'))

import random

print(random.choice('RPS'))

"""
sirius.py

A serious attempt at a Rock-Paper-Scissors bot.
"""

import collections, random, sys

# initial responses, assuming random play
responses = {}
for me in 'RPS':
    for them in 'RPS':
        responses[me + them] = collections.Counter('RPS')

# update based on history of plays
history = sys.argv[1:]
for history_index in range(1, len(history)):
    state = history[history_index - 1]
    response = history[history_index][1]
    responses[state].update(response)

# get the current state
if history:
    state = history[-1]
else:
    state = 'RP'

# guess the opponent's next move
guess = random.choice(list(responses[state].elements()))

# play what would beat that guess
beat = dict(zip('RPS', 'PSR'))
print(beat[guess])

responses = {}
for me in 'RPS':
   for them in 'RPS':
       responses[me + them] = collections.Counter('RPS')

(Oct-08-2016, 10:13 PM)wavic Wrote: This define a set(), right? But you initiate as a dictionary. Or I am wrong?

responses = {}
for me in 'RPS':
    for them in 'RPS':
        responses[me + them] = collections.Counter('RPS')

# nilabot - nilamo
import sys

winning_match = {'R':'S', 'P':'R', 'S':'P'}
lookup = {}
# indexes match our current record... 0=tied, 1=winning, -1=losing
strategies = ['PRP', 'RSR', 'SPR']

''' lookup will end up looking like...
        RR: 0, RS: 1, RP: -1
    for all 9 combinations.
    0 is a tie, -1 a loss, +1 a win
'''
def populate_lookup():
    for left, loser in winning_match.items():
        for right in winning_match.keys():
            result = 0
            if right == loser:
                result = 1
            elif left != right:
                result = -1
            lookup[left+right] = result
    
def current_results(rounds):
    return sum(lookup[round] for round in rounds)

def current_strategy(rounds):
    current_strategy_length = len(rounds) % 3
    if current_strategy_length:
        strat_starts_with = rounds[-current_strategy_length][0]
        for strategy in strategies:
            if strategy.startswith(strat_starts_with):
                return strategy[current_strategy_length]
    return None
    
def get_response(rounds):
    strategy = current_strategy(rounds)
    # if we're in the middle of a strategy, keep going with it
    if strategy:
        return strategy
    # find out which strategy we should start next
    populate_lookup()
    record = current_results(rounds)
    ndx = 0 if record == 0 else 1 if record > 0 else -1
    
    response = strategies[ndx][0]
    return response
    
if __name__ == '__main__':
    rounds = sys.argv[1:]
    print(get_response(rounds))