Lösungen

def sum(nums):
  sum = 0
  for n in nums:
    sum = sum + n
  return sum

def from_to(lower,upper):
  nums = [None] * (upper-lower+1)
  for i in range(lower,upper+1):
    nums[i-lower] = i
  return nums

def is_valid_walk(walk):
  if len(walk) != 10:
    return False
  x = 0
  y = 0
  for step in walk:
    if step == "n":
      y = y + 1
    if step == "s":
      y = y - 1
    if step == "o":
      x = x + 1
    if step == "w":
      x = x - 1
  return x == 0 and y == 0

def is_in_sorted(a,x):
  found = False                                  #1
  i = 0                                          #2
  while not found and i < len(a) and a[i] <= x:  #3
    found = (a[i] == x)                          #4
    i = i + 1                                    #5
  return found                                   #6

n = 10
fibs = [None] * (n+1)
fibs[0] = 0
fibs[1] = 1
for i in range(2, n+1):
  fibs[i] = fibs[i-1] + fibs[i-2]
print(fibs)

def bin_search(a,x):
  # Die Grenzen left und right definieren,
  # in welchem Bereich noch gesucht werden muss.
  # Dieser Bereich wird in jedem Schritt halbiert.
  left  = 0
  right = len(a)
  # right ist der erste Index, der nicht mehr betrachtet werden muss.
  found = False
  while not found and left < right:
    i = (left + right) // 2
    if a[i] < x:
      left = i + 1
      # left = i wäre hier falsch, 
      # da dann z.B. der Aufruf bin_search([0],1) nicht terminiert.
    if a[i] > x:
      right = i
      # right = i - 1 wäre hier falsch,
      # da dann z.B. bin_search([0,1],0) False zurück liefern würde.
    found = a[i] == x
  return found

from datetime import datetime
from is_in_sorted import is_in_sorted

n = 200_000_000
big = [None] * n

for i in range(0,n):
  big[i] = i + 1
print(datetime.now())
print(is_in_sorted(big,n))
print(datetime.now())
print(bin_search(big,n))
print(datetime.now())