set tabstop=4
set shiftwidth=4
set expandtab

Na sam koniec warto dodać, że mimo iż Vim może być postrzegany jako stary edytor, trudny w użyciu a posługują się nim tylko starzy wyjadacze-programiści z poprzedniej epoki, to ma on wiele funkcji których nie oferuje nawet Notepad++, a programowanie bez odrywania rąk od klawiatury jest o wiele mniej męczące. Polecam cheatsheet: http://www.qitty.net/lnx/vim-cheatsheet.png

Program('main.cpp')

Na Windows domyślnie zostanie wykorzystany (o ile dostępny) kompilator Microsoftu. Jeśli jednak chcemy użyć g++, wystarczy dopisać jeszcze jedną linię:

env = Environment(tools = ['mingw'], CC = 'gcc', CCFLAGS = '-O2')
env.Program('main.cpp')

Piewsze lody przełamane, kolejne próby będą sprawdzały łatwość dołączania zewnętrzych bibliotek jak boost czy qt.

Na wszelki, skopiowany kod poprawki poniżej:

— ZSI-2.1-a1/ZSI/ServiceContainer.py 2007-08-08 00:56:37.000000000 +0200
+++ ServiceContainer.py 2008-06-19 13:50:11.000000000 +0200
@@ -5,6 +5,7 @@

import urlparse, types, os, sys, cStringIO as StringIO, thread,re
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+from SocketServer import ThreadingMixIn
from ZSI import ParseException, FaultFromException,
FaultFromZSIException, Fault
from ZSI import _copyright, _seqtypes, _get_element_nsuri_name, resolvers
from ZSI import _get_idstr
@@ -30,6 +31,7 @@
SimpleWSResource
SOAPRequestHandler
ServiceContainer
+ ThreadedServiceContainer
„”"
class NoSuchService(Exception): pass
class UnknownRequestException(Exception): pass
@@ -141,12 +143,16 @@
return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)

-def AsServer(port=80, services=()):
+def AsServer(port=80, services=(), threaded=False):
”’port –
services — list of service instances
+ threaded — in modo multithread ?
”’
address = (”, port)
- sc = ServiceContainer(address, services)
+ if threaded:
+ sc = ThreadedServiceContainer(address, services)
+ else:
+ sc = ServiceContainer(address, services)
sc.serve_forever()

@@ -467,6 +473,11 @@
def removeNode(self, url):
self._nodes.removeNode(url)

+class ThreadedServiceContainer(ThreadingMixIn, ServiceContainer):
+ ”’Multithreaded version of ServiceContainer.
+ ”’
+ pass
+

class SimpleWSResource(ServiceSOAPBinding):

# gry - lista skladajaca sie z list reprezentujacych gre. Kazda reprezentacja
# gry to kolejna lista zaiwerajaca ilosc 'kijkow' na kolejnych stosach
def graj(gry):
    sg = (0, 0, 1, 1, 2, 2, 3)
    for gra in gry:
        g = []
        reszty = []
        for stos in gra:
            reszta = int(stos)%7
            g.append(sg[reszta])
            reszty.append(reszta)
        wynik = reduce(lambda x,y: x^y, g)

        if wynik :
            print "Julia wins."
        else :
            print "Robert wins.\n"

Lekki problem pojawia się przy ustalaniu ruchu wygrywającego. Nie wiem czy istnieje jakieś szybsze rozwiązanie niż takie trochę brute-force’owe która ja wykorzystałem. Polega ono na stwierdzeniu na jakiej pozycji ( wygrywającej czy przegrywającej ) znalazł by się gracz gdyby nie było jednego stosiku, a następnie obliczeniu czy da się odjąć taką liczbę patyczków żeby zostawić przeciwnika na pozycji przegrywającej.
Dodatkowo oprócz wskazania ruchu wygrywającego należy wskazać ten podczas którego bierze się najwięcej patyczków ze stosu o najmniejszym numerze, co w lekki sposób komplikuje sprawę.:

        stos_wygrywajacy = 0;
        licznik = 0
        blokada_5 = False
        blokada_3 = False

        # odwrocenie list, sprawdzanie od konca
        gra_rev = gra[:]
        gra_rev.reverse()

        g_rev = g[:]
        g_rev.reverse()

        reszty.reverse()
        for reszta in reszty:
            # lista reszt bez kolejnych stosow
            tmpr = reszty[:]
            tmpr.pop(licznik)

            # xor wartosci f. Sprague-Grundy'ego
            # bez kolejnych stosow
            tmpg = g_rev[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg ,0)

            if sg[reszta-5] == tmpw and int(gra_rev[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = len(reszty) - licznik
                blokada_5 = True
            elif sg[reszta-3] == tmpw and int(gra_rev[licznik]) >= 3 and blokada_5 == False:
                wygrywajacy = 3
                stos_wygrywajacy = len(reszty) - licznik
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra_rev[licznik]) >= 2 and blokada_5 == False and blokada_3 == False:
                wygrywajacy = 2
                stos_wygrywajacy = len(reszty) - licznik

            licznik += 1

Jeśli ktoś zna szybsze rozwiązanie chętnie je przeanalizuję
Zaznaczam, że nie dam sobie głowy uciąć że algorytm jest poprawny, bo nie ma już możliwości zgłoszenia rozwiązania – upłynęły terminy.

EDIT:
Lekko poprawiona wersja, działa trochę szybciej, natomiast i tak nie umożliwia zdobycia maximum punktów. Jesli nie ma jakiejś sztuczki na ruch wygrywający, a podejrzewam że coś jest, to lepiej zakodzić to w C…

        stos_wygrywajacy = 0
        blokada_3 = False
        blokada_2 = False
        licznik = 0
        for reszta in reszty :
            tmpg = g[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg, 0)

            if sg[reszta-5] == tmpw and int(gra[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = licznik + 1
                break
            elif sg[reszta-3] == tmpw and int(gra[licznik]) >= 3 and blokada_3 == False:
                wygrywajacy = 3
                stos_wygrywajacy = licznik + 1
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra[licznik]) >= 2 and blokada_3 == False and blokada_2 == False:
                wygrywajacy = 2
                stos_wygrywajacy = licznik + 1
                blokada_2 = True
            licznik += 1

Python to język bardzo wysokiego poziomu w związku z tym tworzenie aplikacji w nim powinno być szybkie. I może samo tworzenie jest, ale jak już się Pythona dobrze zna. Dostarczona dokumentacja jest średnio czytelna i korzystanie z niej nie było zbyt wygodne. Żeby korzystać z docs’ów Pythona trzeba mieć chyba jakiś dar.

„Although both PHP and Python have excellent core documentation, Python’s is more extensive and generally higher quality.”

No niestety nie moge się z tym zgodzić…
Nie wiem jakie są powody że ludzie tak się zachwycają owym Pythonem. Ja bardzo się zniechęciłem gdy zobaczyłem że nie ma ani kwantyfikatowór dostępu, ani definicji pól klasy. Pola można sobie dodawać dowolnie w tracie działania, żadne deklaracje nie są wymagane. To takie wbudowane __set i _call z php.
Napisanie programiku do logowania się do „wioski” w grze plemiona zajęło mi koło 2,5h.
Linii mamy 32, co daje jakie 4,5 minuty na napisanie linii, a wiadomo że nie wszystkie linie są sobie równe.

import urllib, urllib2, cookielib

class PlemionaTool :
  def connect(self, username, password, world) :
    try:
      cookies = cookielib.CookieJar()
      self._world = world
      self._connection_handler = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookies))
      headers = {"User-Agent": "Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11"}
      login_data = urllib.urlencode({"user": username,
                                              "clear": "true",
                                              "password": password,
                                              "server": world,
                                              "login-btn-input": "",
                                              "cookie" : "false"})
      request_http = "http://www.plemiona.pl/index.php?action=login"
      req = urllib2.Request(request_http, login_data, headers)
      self._connection_handler.open(req)
    except urllib2.HTTPError:
        print "Jakis zonk"

  def headquater(self) :
    response = self._connection_handler.open("http://" + self._world +     ".plemiona.pl/game.php?village=NUMER_WIOSKI&screen=main")
    page = response.read()
    return page

def main():
  pt = PlemionaTool()
  pt.connect("LOGIN", "HASLO", "SWIAT")
  print pt.headquater()

if __name__ == '__main__':
  main()

Z zalet można wymienić wysokopoziomowość. Nie trzeba się męczyć z odbiorem, obróbką i wysyłaniem cookies, nie trzeba się też bawić z przechwytywć żadnego wyjątku jak np. HTTPRedirect z Delphi.