Nächste Seite: 101225__/img Aufwärts: 101225_/tex Vorherige Seite: 101225_/tex/binary4.c
# (c) david vajda
# 10/12/25
# python 3/checksum/dataset and co kg ok
def arith_mean_bin_halfing (X, n):
i = 0
if n > 1:
while i < n/2:
X [i] = X [i] + X [i+int(n/2)-1]
print (X)
i = i + 1
arith_mean_bin_halfing (X, n/2)
# def brith_mean_bin_halfing (X, i, n):
# if n > 0:
# X [i] = brith_mean_bin_halfing (X, i, n/2) + brith_mean_bin_halfing (X, i+(n/2)-1, n/2)
# das geht so nicht, weil, wir haben keine indize daten
# besser, kurze raucherpause, erst indize daten auf schreiben
# achtung! b, c, d version bleibt! ok
# blos, viele moeglichkeiten:
# feld fuer feld, oder y und summe + anderem y oder feld stueck what ever....
# also (1.) moeglichkeit
# die erste moeglichkeit waere die grenze zu halbieren
# n/2, 8, 4, 2, 1
# dann ist die summe
# 0+1, 2+3, 4+5, 6+7, das waeren die teilsummen auf unterster ebene
# 0+3, 4+7, auf der naechsten ebene
# 0
# erstens die laenge der summen
# 2 elemente, 2, 2, 2, 2, ...
# weiter ... 0x0f, n ist die gesamtmenge
# so, auf der untersten ebene gilt, folgendes:
# n/2 elemente, a 2, zum beispiel
# bei 8 elementen, 4x 2 elemenete, 2,2,2,2, vier mal zwei
# oder bei 16 elementen, 2, 2, 2, 2, 2, 2, 2, 2
# in der naechsten ebene, 4, 4, 4, 4
# 2 solutions
# die erste bezieht sich auf grenzen
# das eine sind die grenzen und laengen
# das andere sind die anzahl der elemente
# so, zwei solutions
# erstens kann man versetzt arbeiten
# wenn man es iterativ machen wuerde
# anfang und haelfte, anfang+1, haelfte+1, anfang+2, haelfte+2
# logisch ...
# erster index, erster index+1; erster index+2, erster index+3;
# paarweise auf unterster ebene und zwar von der zahl der haelfte
# paarweise auf der darueber liegenden
# blos die frage: geben wir das als rueckgabewert zurueck und addieren
# die rueckgabewerte
def brith_mean_bin_halfing (X, l, r):
if l != r:
return brith_mean_bin_halfing (X, l+1, r-1) + X [l] + X [r]
else:
return 0
# also, man muss die laenge des feldes auf die haelfte ansetzen
# und die eine haelfte des feldes behandeln, dann die andere ...
# das feld wird immer kuerzer, und zwar so kuerzer, ...
# bis es zwei elemente sind, das wird auf die obere haelfte jeweils
# angewendet und dann auf die untere...
# def brith_mean_bin_halfing (X, r, l):
# if (r-l) == 2:
# y2 = X [r]
# y1 = X [l]
# print (y1, " + ", y2, " = ", y2+y1)
# print (r, " ", l)
# else:
# int((r-l)/2)
# mr = int((r-l)/2)
# ml = int((r-l)/2)
# y2 = brith_mean_bin_halfing (X, r, ml)
# y1 = brith_mean_bin_halfing (X, mr, l)
# brith_mean_bin_halfing (X, l+m, r)
# brith_mean_bin_halfing (X, l, r-m)
# print (l+m, " ", r, " ", l, " ", r-m)
# print ("")
# return y2+y1
def brith_mean_bin_halfing (X, i, d):
# difference, sollte eigentlich laenge sein
if d == 2:
y2 = X [i+0]
y1 = X [i+1]
print (y1, " + ", y2, " = ", y2+y1)
else:
y2 = brith_mean_bin_halfing (X, i, int(d/2))
y1 = brith_mean_bin_halfing (X, i+int(d/2), int(d/2))
print (i, " ", i+int(d/2)-1, " ", i+int(d/2), " ", i+d)
print ("")
return y2+y1
def crith_mean_bin_halfing (X, l, r):
# difference, sollte eigentlich laenge sein
d = int(((r+1)-l)/2)
if d == 1:
y2 = X [l]
y1 = X [r]
print (y1, " + ", y2, " = ", y2+y1)
else:
y2 = crith_mean_bin_halfing (X, r-d+1, r)
y1 = crith_mean_bin_halfing (X, l, l+d-1)
print (l, " ", l+d-1, " ", r-d+1, " ", r)
print ("")
return y2+y1
print ("(c) david vajda")
print ("10/12/25")
print ("python 3/checksum/dataset and co kg ok")
X=[0xe5, 0x10, 0x4a, 0xe0, 0x9c, 0x0b, 0x20, 0xe7, 0xe9, 0xdd, 0x6e, 0x26, 0xeb, 0x16, 0x90, 0xc8];
i=0
n=len(X)
print ("X = [", end="")
while i < n - 1:
print (X[i], end=", ")
i = i + 1
print (X[i], "]")
# ok let's try to make a sum:
print ("ok let's try to make a sum:")
i=0
n=len(X)
y=0
print ("SUM_(i=0)^15 X[i], X = [", end="")
while i < n - 1:
print (X[i], end=", ")
y = y + X [i]
i = i + 1
y = y + X [i]
print (X[i], "]")
print ("SUM_(i=0)^15 X[i] = ", y)
# a total better output means:
print ("a total better output means:")
i=0
n=len(X)
y=0
s=""
print ("SUM_(i=0)^15 X[i], X = [", end="")
while i < n - 1:
y = y + X [i]
s = s + " + " + str (X[i])
print (s, "= " + str (y))
i = i + 1
y = y + X [i]
print (X[i], "]")
print ("SUM_(i=0)^15 X[i] = ", y)
# to the producer from producer: david vajda, bitte nimm
# screenshots auf!
# ok, eine bessere methode geht ab jetzt so
# anstatt, dass wir beginnen wuerden
# den string zu erweitern ohne zu speichern
# anstatt dass wir beginnen,
# die 'y' zu speichern, speichern wir sie auch...
print ("a more total better output means:")
i=0
n=len(X)
y=[0]
s=""
print ("SUM_(i=0)^15 X[i], X = [", end="")
while i < n - 1:
y = y + [X [i]]
print (y)
s = s + " + " + str (X[i])
# print (s, "= " + str (y))
i = i + 1
print (X[i], "]")
print ("SUM_(i=0)^15 X[i] = ", y)
# zum beispiel, ok, das muss nicht weiter ausgebaut werden.
# nun kommt unser ansatz fuer arithmetische mittel, welcher
# art auch immer
# da unser array/feld/liste ... array/feld/what ever
# ... ich habe das buch python (ohne 3, ich weise darauf hin)
# im netz bei linux immer python3
# ... bitte. literatur kaufen ist wichtig!
# zweitens: einstieg in python - ideal fuer programmiereinsteiger
# thomas theis
# jedenfalls, hier steht listen, so weit ich weiss
# ist der begriff, array/feld ... in python3 nicht ueblich
# python ist so weit ich weiss, wie die sprache, die xmaxima (maxima)
# so wie maxima selber benutzt so wie q und r - die sprachen fuer
# artificial intelligence ...
# sehr mathematisch, besonders python3
# das heisst schlaegt man das buch auf, wehen einem begriffe wie
# menge, listen, tupel entgegen... ganz einfach...
# ok, wichtig ist jetzt, da wir aber daher kommen, wie C Programmierer
# koennen wir mal wieder keine elemente loeschen, das heisst,
# wir bedienen uns der methode den 2. operanden jeweils auf 0 zu setzen
# da uns aber dann dieser operand trotzdem nicht wiederfahren sollte,
# oder doch? gucken wir mal: nehmen wir die indizes raus, wieder moeglichkeiten
# auch die rekursion kommt jetzt!!!! kommt jetzt alles!!!
i=0
n=len(X)
y=[0]
s=""
print ("SUM_(i=0)^15 X[i], X = [", end="")
j=1
while (j+i) < n:
X [i] = X [i] + X [i+j]
X [i+j] = 0
print (X)
i = (i + j) % n
j = j * ((2*((i % n) == 0)) + 1*((i % n) != 0))
print (i, j)
print (X[i], "]")
print ("SUM_(i=0)^15 X[i] = ", y)
# arith_mean_bin_halfing (X, len(X))
# print (brith_mean_bin_halfing (X, 0, len(X)-1))
print (brith_mean_bin_halfing (X, 0, len(X)))
print (crith_mean_bin_halfing (X, 0, len(X)-1))