Number
system:sage

{{{id=71|
# Diese Definition von prepend sollte immer funktionieren:

def prepend(a,u):
  if type(u)==type(""):
     return a+u
  elif type(u)==type([]):
     return [a]+u
  elif type(u)==type(()):
     return (a,)+u
///
}}}

{{{id=72|
prepend('x','alpha')
///
'xalpha'
}}}

{{{id=73|
prepend(9,[1,2,3])
///
[9, 1, 2, 3]
}}}

{{{id=76|
prepend(9,(1,2,3))
///
(9, 1, 2, 3)
}}}

{{{id=77|
prepend('x',['alpha','beta','gamma'])
///
['x', 'alpha', 'beta', 'gamma']
}}}

{{{id=0|
# Vergleichen Sie die folgende Funktion mit dem Beispiel 10 vom 1. bungsblatt

def q(u):
  if len(u)==0:
    return u
  else:
    return prepend(u[0]^2, q(u[1:]))
///
}}}

{{{id=90|
q(range(20))
///
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
}}}

{{{id=87|
# Es gibt dafr auch die vordefiniert Funktion: map

# Dazu definieren wir zuerst:

def sq(x):
  return x^2
///
}}}

{{{id=88|
map(sq,range(20))
///
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
}}}

{{{id=81|
# Die folgende sollte Sie mit dem Beispiel 11 vom 1. bungsblatt vergleichen.
# Und natrlich ausprobieren.

def e(u):
  if len(u)==0:
    return 0
  else:
    return u[0] + 10 * e(u[1:])
///
}}}

{{{id=82|
e([4,5,6,7])
///
7654
}}}

{{{id=83|
# Definieren Sie nun eine Umkehrfunktion dazu, also eine solche, die zu einer Zahl die Dezimalentwicklung berechnent.

def d(u):
  if u==0:
    return []
  else:
    return prepend(u%10,d(u//10))
///
}}}

{{{id=84|
d(2008)
///
[8, 0, 0, 2]
}}}

{{{id=85|
# Verallgemeinern sie die beiden vorigen Funktionen fr eine beliebige Basis statt 10, insbesondere fr 5,8,16,2,60
///
}}}

{{{id=2|
# Diese Funtkion sollte sie mit dem 2. bungsblatt vergleichen.

def prefixes(u):
  if len(u)==0:
    return [u]
  else:
    return prepend(u[:0], prependall(u[0],prefixes(u[1:])))

def prependall(a,L):
  if len(L)==0:
    return([])
  else:
    return prepend(prepend(a,L[0]), prependall(a,L[1:]))
///
}}}

{{{id=3|
prependall('x',['alpha','beta','gamma'])
///
['xalpha', 'xbeta', 'xgamma']
}}}

{{{id=4|
prefixes('alpha')
///
['', 'a', 'al', 'alp', 'alph', 'alpha']
}}}

{{{id=6|
prependall('x',[])
///
[]
}}}

{{{id=7|
prefixes([])
///
[[]]
}}}

{{{id=34|
# Diese Funktion ordnet jeder natrlichen Zahl ein paar von natrlichen Zahlen zu
def N_NN(n):
  q=floor(sqrt(n+0.01))
  b=min(n-q^2,q)
  a=max(0,q^2+q+b-n)
  return [a,b]
# Testen Sie die Funktion
///
}}}

{{{id=91|
# Mit map knnen wir sie auf eine ganze Liste anwenden

map(N_NN, range(30))
///
[[0, 0], [1, 0], [1, 1], [0, 1], [2, 0], [2, 1], [2, 2], [1, 2], [0, 2], [3, 0], [3, 1], [3, 2], [3, 3], [2, 3], [1, 3], [0, 3], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4], [3, 4], [2, 4], [1, 4], [0, 4], [5, 0], [5, 1], [5, 2], [5, 3], [5, 4]]
}}}

{{{id=39|
# Wir knnen Sie auch graphisch darstellen:

list_plot(map(N_NN,range(100)),plotjoined=True,rgbcolor=(1,0,1),alpha=0.5,marker='o')
///
}}}

{{{id=92|
# Dies lt uns vermuten, da alle Paare irgendwann vorkommen.
///
}}}

{{{id=93|
# Diese Funktion ordnet umgekehrt jedem Paar natrlicher Zahlen eine Zahl zu.

def NN_N(p):
  a,b = p
  m = max(a,b)
  return m^2+ min(b,m) + max(b-a,0)
///
}}}

{{{id=94|
# Listen lassen sich auch auf die folgende Weise zusammenbauen:

pp = [ [x,y] for x in range (5) for y in range (5) ]
pp
///
[[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2], [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]]
}}}

{{{id=95|
map (NN_N,pp)
///
[0, 3, 8, 15, 24, 1, 2, 7, 14, 23, 4, 5, 6, 13, 22, 9, 10, 11, 12, 21, 16, 17, 18, 19, 20]
}}}

{{{id=96|
# Tatschlich sind diese beiden Funktionen zueinander invers:
///
}}}

{{{id=97|
map(NN_N, map(N_NN, range(100))) == range(100)
///
True
}}}

{{{id=98|
map(N_NN, map(NN_N, pp)) == pp
///
True
}}}

{{{id=29|
# Wir definieren nun eine Funktion, die jeder natrlichen Zahl eine ganze Zahl zuordnet.

def N_Z(n):
  a = ceil(n/2)
  s = 2*(n%2) - 1
  return s*a
///
}}}

{{{id=42|
map(N_Z,range(10))
///
[0, 1, -1, 2, -2, 3, -3, 4, -4, 5]
}}}

{{{id=43|
# Gelingt es Ihnen hier, die Umkehrfunktion zu definieren?

def Z_N(z):
  n = abs(z)*2
  if z>0:
    n = n-1
  return n
///
}}}

{{{id=45|
map(Z_N,range(-10,10))
///
[20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0, 1, 3, 5, 7, 9, 11, 13, 15, 17]
}}}

{{{id=44|
map(Z_N,map(N_Z,range(100))) == range(100)
///
True
}}}

{{{id=47|
map(N_Z,map(Z_N,range(-100,100))) == range(-100,100)
///
True
}}}

{{{id=30|
# Damit sind wir nun auch in der Lage, eine Funktion zu definieren, die jeder natrlichen Zahl umkehrbar eindeutig ein Paar ganzer Zahlen zuordnet:

def N_ZZ(n):
   a,b = N_NN(n)
   return [N_Z(a),N_Z(b)]
///
}}}

{{{id=41|
map(N_ZZ,range(50))
///
[[0, 0], [1, 0], [1, 1], [0, 1], [-1, 0], [-1, 1], [-1, -1], [1, -1], [0, -1], [2, 0], [2, 1], [2, -1], [2, 2], [-1, 2], [1, 2], [0, 2], [-2, 0], [-2, 1], [-2, -1], [-2, 2], [-2, -2], [2, -2], [-1, -2], [1, -2], [0, -2], [3, 0], [3, 1], [3, -1], [3, 2], [3, -2], [3, 3], [-2, 3], [2, 3], [-1, 3], [1, 3], [0, 3], [-3, 0], [-3, 1], [-3, -1], [-3, 2], [-3, -2], [-3, 3], [-3, -3], [3, -3], [-2, -3], [2, -3], [-1, -3], [1, -3], [0, -3], [4, 0]]
}}}

{{{id=48|
list_plot(map(N_ZZ,range(100)),plotjoined=True,rgbcolor=(1,0,1),alpha=0.5,marker='o')
///
}}}

{{{id=99|
# Gelingt es Ihnen, hier die Umkehrfunktion selbst zu definieren?
///
}}}

{{{id=49|
# Das Bild oben zeigt, da N_ZZ etwas Unordnung produziert. 
# Die folgende Funktion erzeugt eine schne Spirale:

def NZZ(n):
  q=floor(sqrt(n+0.01))
  a=(q+1)//2
  m=(2*a-1)^2
  if n-m < 2*a:
     x = a
     y = n-m-a+1
  elif n-m < 4*a:
     x = a-(n-m-2*a+1)
     y = a
  elif n-m < 6*a:
     x = -a
     y = a-(n-m-4*a+1)
  else:
     x = n-m-6*a+1-a
     y = -a
  return [x,y]
///
}}}

{{{id=55|
map(NZZ,range(93))
///
[[0, 0], [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1], [2, -1], [2, 0], [2, 1], [2, 2], [1, 2], [0, 2], [-1, 2], [-2, 2], [-2, 1], [-2, 0], [-2, -1], [-2, -2], [-1, -2], [0, -2], [1, -2], [2, -2], [3, -2], [3, -1], [3, 0], [3, 1], [3, 2], [3, 3], [2, 3], [1, 3], [0, 3], [-1, 3], [-2, 3], [-3, 3], [-3, 2], [-3, 1], [-3, 0], [-3, -1], [-3, -2], [-3, -3], [-2, -3], [-1, -3], [0, -3], [1, -3], [2, -3], [3, -3], [4, -3], [4, -2], [4, -1], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4], [3, 4], [2, 4], [1, 4], [0, 4], [-1, 4], [-2, 4], [-3, 4], [-4, 4], [-4, 3], [-4, 2], [-4, 1], [-4, 0], [-4, -1], [-4, -2], [-4, -3], [-4, -4], [-3, -4], [-2, -4], [-1, -4], [0, -4], [1, -4], [2, -4], [3, -4], [4, -4], [5, -4], [5, -3], [5, -2], [5, -1], [5, 0], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [4, 5], [3, 5]]
}}}

{{{id=51|
list_plot(map(NZZ,range(100)),plotjoined=True,rgbcolor=(1,0,1),alpha=0.5,marker='o')
///
}}}

{{{id=52|
# Die Umkehrung dazu:

def ZZN(p):
  x,y = p
  a = max(abs(x),abs(y))
  m=(2*a-1)^2
  if y>-x and y<=x:
    return m + a + y -1
  elif y>= -x and y>x:
    return m + 3*a - x  -1
  elif y >= x:
    return m + 5*a - y - 1
  else:
    return m + 7*a + x - 1
///
}}}

{{{id=56|
map (ZZN,pp)
///
[0, 3, 14, 33, 60, 1, 2, 13, 32, 59, 10, 11, 12, 31, 58, 27, 28, 29, 30, 57, 52, 53, 54, 55, 56]
}}}

{{{id=57|
map(ZZN, map(NZZ, range(2008))) == range(2008)
///
True
}}}

{{{id=59|
pp = [[x,y] for x in range (-10,10) for y in range (-10,10)]
///
}}}

{{{id=60|
map(NZZ,map(ZZN,pp)) == pp
///
True
}}}

{{{id=61|

///
}}}

{{{id=100|

///
}}}