def create_form(draft, rmap, opts):
if opts.label not in rmap['forms']:
raise FormNotFoundError(label=opts.label)
with open(rmap['forms'][opts.label]) as y:
spec = yaml_load(y)
with open_datasource(rmap, spec['source']) as db:
initial = []
if 'comments' in spec:
wrapped = map(comment_yaml, wrap_text(spec['comments'], 78))
initial.extend(wrapped)
initial.append("# new values")
initial.append("# ----------")
avails = dict(map(lambda x: (x['name'], parse_column_default(x)),
spec['columns']))
initial.extend(yaml_dump(avails).split('\n'))
try:
if opts.values:
reviewed = avails
reviewed.update(parse_opt_values(opts.values))
else:
_, yaml_str = edit(draft, opts, initial="\n".join(initial))
reviewed = yaml_load(yaml_str)
db.execute(text(spec['insert']), **reviewed)
return 0, "Record created successfully!"
except (YAMLParserError, YAMLScannerError) as e:
err = EditError('YAML Parsing Error: %s' % str(e))
err.original_exception = e
raise err
except sqlexc.StatementError as e:
err = EditError('SQL Statement Error: %s' % str(e))
err.original_exception = e
raise err
def get_summary(doc: Document, limit: float, wrap: int) -> StringList:
"""Get summary of `doc` as StringList of lines
Arguments:
doc {Document} -- document
limit {float} -- length of summary
wrap {int} -- column wrap
Returns:
StringList -- lines of document
"""
sentences = doc.summarize(limit)
text = ' '.join(sentences)
return [text] if wrap < 1 else wrap_text(text, width=wrap)
def bubble_sort(L):
'''Sortiert die gegebene Liste L mit Bubble-Sort.'''
remain = len(L)-1
done = False
swap_counter = [ [] for i in range(len(L)) ]
while not done:
done = True
for i in range(remain):
if L[i] > L[i+1]:
done = False
# print("Swapping %s_%s and %s_%s" % (L[i],i,L[i+1],i+1))
L[i], L[i+1] = L[i+1], L[i]
swap_counter[i] += [1]
swap_counter[i+1] += [-1]
swap_counter[i], swap_counter[i+1] = swap_counter[i+1], swap_counter[i]
remain -= 1
total_swaps = sum([ len(swaps) for swaps in swap_counter ])
wrong_direction_swaps = sum([ abs( abs(sum(swaps))-len(swaps) ) for swaps in swap_counter ])//2
print(wrap_text( "Von %d Vertauschungen, gingen %d in die falsche Richtung und nochmal soviele wurden gebraucht um diese Rückgängig zu machen. Insgesamt waren also %d%% der Vertauschungen unnötig" % (total_swaps,wrong_direction_swaps,round(2*wrong_direction_swaps/total_swaps*100)) ),"\n")
return 2*wrong_direction_swaps/total_swaps*100
def edit_form(draft, rmap, opts):
if opts.label not in rmap['forms']:
raise FormNotFoundError(label=opts.label)
with open(rmap['forms'][opts.label]) as y:
spec = yaml_load(y)
can_edits = map(lambda x: x['name'],
filter(lambda x: 'noedit' not in x.get('perms', []),
spec['columns']))
defaults = dict(map(lambda x: (x['name'], parse_column_default(x)),
filter(lambda x: 'noedit' not in x.get('perms', []),
spec['columns'])))
with open_datasource(rmap, spec['source']) as db:
row = db.execute(text(spec['detail']), dict(pk=opts.pk)).fetchone()
if not row:
raise RecordNotFoundError()
initial = []
if 'comments' in spec:
wrapped = map(comment_yaml, wrap_text(spec['comments'], 78))
initial.extend(wrapped)
can_shows = map(lambda x: x['name'],
filter(lambda x: 'noshow' not in x.get('perms', []),
spec['columns']))
original_data = dict(filter(lambda x: x[0] in can_shows,
dict(row).iteritems()))
original = yaml_dump(original_data).split('\n')
initial.append("")
initial.append("# originial values")
initial.append("# ----------------")
initial.extend(map(comment_yaml, original))
initial.append("# new values")
initial.append("# ----------")
edit_form = defaults
edit_form.update(dict((filter(lambda x: x[0] in can_edits,
dict(row).items()))))
initial.extend(yaml_dump(edit_form).split('\n'))
try:
if opts.values:
reviewed = edit_form
update_nested_dict(reviewed, parse_opt_values(opts.values))
else:
_, yaml_str = edit(draft, opts, initial="\n".join(initial))
reviewed = yaml_load(yaml_str)
for (k, v) in reviewed.iteritems():
if isinstance(v, dict):
reviewed[k].update(dict(map(
lambda x: (x[0], unicode(x[1])), v.iteritems())))
db.execute(text(spec['update']), pk=opts.pk, **reviewed)
return 0, "Record updated successfully!"
except (YAMLParserError, YAMLScannerError) as e:
err = EditError('YAML Parsing Error: %s' % str(e))
err.original_exception = e
raise err
except sqlexc.StatementError as e:
err = EditError('SQL Statement Error: %s' % str(e))
err.original_exception = e
raise err
'''Sortiert die gegebene Liste von ganzen Zahlen mit in-place Counting-Sort.'''
C = [0 for i in range(max(L)+1)]
for i in range(len(L)):
C[L[i]] += 1
l_i = 0
for c_i in range(len(C)):
while C[c_i] != 0:
L[l_i] = c_i
l_i += 1
C[c_i] -= 1
# Tests
from random import randint
for i in range(10):
L = [ randint(0,9) for i in range(20) ]
counting_sort(L)
print(L)
print()
# Aufgabenteil c)
from textwrap import fill as wrap_text
print(wrap_text("Der Algorythmus besteht aus zwei Teilen. Zunächst werden alle Elemente von L aufgerufen und in C summiert. Dabei ist die Laufzeit T1=c1*n wobei n=len(L). Danach werden alle addierten einsen aus C n=sum(C)=len(L) wieder in L abgespeichert T2=c2*n. Allerdings muss in diesem Schritt auch noch mindestens m=len(C)=max(L) mal verglichen werden, ob das Element von C bereits 0 ist. Damit ergibt sich T3=c3*m. Insgesamt haben wir damit eine Laufzeit von T=(c1+c2)*n+c3*m=O(n+m)."))
print()
print(wrap_text("Der Speicheraufwand ist durch die Länge von C, also den Betrag des größten Elements von L, m=len(C)=max(L) gegeben S(m)=c1*m=O(m)."))
print()
# Aufgabenteil b)
print(wrap_text("Der in-place Counting-Sort Algorythmus ist nicht zum sortieren nach Geburtstagen geeignet. Es treten zwei Probleme auf:"))
print(wrap_text("1. kann der Algorythmus nur Listen aus ganzen Zahlen sortieren, da die gegebene Liste mit den in C gespeicherten Plätzen überschrieben wird. C speichert aber nur Positionen von ganzen Zahlen und keine Daten. Dies lässt sich nur lösen, wenn die in-place Eigenschaft aufgegeben wird."))
print(wrap_text("2. Außerdem ist der Algorythmus noch nicht einmal zur Sortierung von Geburtsdaten an sich geeignet. Geburtstage sind 8-stellige Zahlen (YYYMMDD), somit bräuchte man eine über 20-millionen-stellige Hilfsliste C und selbst, wenn man den Algorythmus so verändern würde, dass C nicht bei 0 losläuft sondern einen Startwert akzeptiert, so hätte man immernoch 1 Million Stellen in C für die letzten hundert Jahre und proportionale Laufzeit und Speicherverbrauch. Die Lösung wäre eine Radix-Sort-Variante, welche nacheinander Tage, Monate und Jahre sortiert. Diese lässt sich mit diesem Algorythmus aber wegen der fehlenden Stabilität nich implementieren. "))