Na dobry początek…

Dzisiaj kilka prostych ćwiczeń w Pythonie, dla rozruszania szarych komórek i nabrania praktyki w programowaniu. :) Na początek jedno z zadań z Programming Praxis, czyli prosta implementacja algorytmu mnożenia dwóch liczb całkowitych przy pomocy przesuwania o jeden bit w lewo mnożnika i w prawo mnożnej w pętli, w której wykonujemy te operacje i sumujemy wartości mnożnika, aż mnożna będzie mniejsza od 1:

def binaryMultiply(x, y):
    z = 0
    while x >= 1:
        print "%d %d" % (x,y)
        if x % 2 != 0:
            z = z + y
        x >>= 1
        y <<= 1
    return z

x = 14
y = 12
z = binaryMultiply(x, y)
print "Wynik: %d * %d = %d" % (x,y,z)


Drugie zadanie to prosty kalkulator do wykonywania podstawowych operacji przy użyciu tzw. odwróconej notacji polskiej (ang. Reverse Polish Notation), która znakomicie sprawdza się przy traktowaniu danych wejściowych jako stosu (operator matematyczny pobierany jest jako pierwszy z stosu, przez co operacja znana jest na samym początku). Wychodzimy z programu wprowadzając literę „q”:

def doCalculations(stack, w):
    operator = stack.pop()
    if (len(stack) >= 2):
        x = float(stack.pop())
        y = float(stack.pop())
        if (operator == '+'):
            w = y + x
            return True, w
        elif (operator == '-'):
            w = y - x
            return True, w
        elif (operator == '*'):
            w = y * x
            return True, w
        elif (operator == '/'):
            w = y / x
            return True, w
        else:
            return False, 0.0
    else:
        return False, 0.0

def fillStack(stack, expression):
    tokens = expression.split()
    for i in tokens:
        stack.append(i)

def main():
    stack = []
    expression = ''
    while(expression != 'q'):
        expression = raw_input('> ')
        fillStack(stack, expression)
        while(len(stack) > 0):
            w = float()
            flag, w = doCalculations(stack, w)
            if (flag != True):
                continue
            print w

if __name__ == "__main__":
    main()

Nie jest to żadnym wypadku wersja ostateczna; brakuje możliwości wprowadzania bardziej zawiłych poleceń, np. 4 5 + 7 * (czyli (4+5)*7).

I na koniec proste wyszukiwanie duplikatów na liście wypełnionej losowymi liczbami całkowitymi od 0 do 200 algorytmem naiwnym. Niedługo postaram się zrobić wersje bardziej optymalną. ;)

from random import randint
def getDuplicatesNaive(numbers_source):
    numbers = numbers_source
    duplicates = []
    for i in numbers:
        count = 0
        for j in numbers:
            if i == j:
                count = count + 1
        if count >= 2:
            duplicates.append(i)
    #Usuniecie duplikatow na liscie duplikatow
    out = []
    for k in duplicates:
        if k not in out:
            out.append(k)
    return out

def main():
    numbers = []
    i = 0
    while (i < 100):
        numbers.append(randint(0, 200))
        i = i + 1
    dups = getDuplicatesNaive(numbers)
    numbers.sort()
    print numbers
    dups.sort()
    print dups 

if __name__ == "__main__":
    main()

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *

Możesz użyć następujących tagów oraz atrybutów HTML-a: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>