Quiz oder auch: suche Begriff für "nicht-linear"..

Alles, was nicht direkt mit Python-Problemen zu tun hat. Dies ist auch der perfekte Platz für Jobangebote.
EnTeQuAk
User
Beiträge: 986
Registriert: Freitag 21. Juli 2006, 15:03
Wohnort: Berlin
Kontaktdaten:

Montag 30. April 2007, 17:53

Mensch... wie viel ich heute alles lerne... Danke, Leonidas!

MfG EnTeQuAk

PS: ich gebe hiermit wieder zurück ans eigentliche Topic! :)
BlackJack

Montag 30. April 2007, 17:57

Der erste Import in meinen Skripten ist meistens der hier:

Code: Alles auswählen

from __future__ import division
Dann ergibt auch die Division von zwei ganzen Zahlen eine Fliesskommazahl, es sei denn man benutzt ``//``.

Die Schleife diente zum Testen. Ich wollte ja nicht, dass es nur bei genau den 10 Elementen funktioniert, sondern auch mit 0─3 bzw. mit gerader und ungerader Anzahl von Elementen und einer Anzahl die modulo 3 jeweils 0, 1 oder 2 ergibt. Das sind so die Randfälle bei denen ich eventuell Probleme erwartet habe.

Dein Quelltext ging zum Beispiel einfach davon aus, dass es nach dem Entfernen der beiden "Ränder" noch mindestens ein Element in der Mitte geben muss.
Benutzeravatar
jens
Moderator
Beiträge: 8483
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Montag 30. April 2007, 20:42

Uhi :shock: Ihr habt ja wieder losgelegt ;)

Also ich wollte das eigentlich nicht implementieren. Ich dachte nur, das wäre schön, wenn ein Netzwerk Rendering Job so abgearbeitet werden würde.
Wenn man 1000 Frames berechnen läßt, ist es dumm, wenn man am Ende sieht, das es mist ist. Worst-Case: ein Fehler macht sich erst am Ende vom Video richtig bemerkbar, und der ganze Job ist was für die Tonne.

Es ist somit ist es netter, wenn es nicht linear abgearbeitet wird, sondern nach und nach fertiggestellt wird. So kann man nach und nach kontrollieren, ob alles ok ist.

Jetzt wo ihr hier schon Beispiele gemacht habt, hab ich mich gefragt, ob es nicht auch einfach geht. Man läßt weg, das erst Anfang und Ende berechnet werden sollen. Somit siehts dann so aus:

1. Rechne aus dem Aktuellen Block das mittlere Bild.
(Es entstehen zwei Blöcke, vor und nach dem gerechneten Bild
2. Arbeite die Blöcke, wie bei 1. ab

Also bei 1 bis 7 (weils gut passt) sieht es dann so aus:

1,2,3,4,5,6,7
rechne 4
1,2,3,X,5,6,7
rechne 2
1,X,3,X,5,6,7
rechne 6
1,X,3,X,5,X,7
rechne 1
X,X,3,X,5,X,7
rechne 3
X,X,X,X,5,X,7
rechne 5
X,X,X,X,X,X,7
rechne 7
fertig.

Vielleicht gibt es da auch keinen typtischen Begriff für...

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
BlackJack

Montag 30. April 2007, 20:55

Da würde ich sagen passt der Begriff Intervallschachtelung ganz gut.
joost
gelöscht
Beiträge: 134
Registriert: Sonntag 29. April 2007, 13:28

Montag 30. April 2007, 21:28

Das sieht jetzt ja aus wie binäre Suche.
schlangenbeschwörer
User
Beiträge: 419
Registriert: Sonntag 3. September 2006, 15:11
Wohnort: in den weiten von NRW
Kontaktdaten:

Dienstag 1. Mai 2007, 16:56

Ich hab mal was versucht...naja, nicht so perfekt, aber ein Ansatz...
geht auch nicht immer :lol:

Code: Alles auswählen

def splitlist(l):
    if len(l)>1:
        m=int(len(l)/2.0-0.5)
        returnlist=[]
        for x in (l[m],l[0:m],l[m+1:len(l)+1]):
            if x:
                returnlist.append(x)
        return returnlist
    else:
        return  (False,l[0])

def strange_sort(l):
        sorted_list=[]
        splited_list=splitlist(l)
        if splited_list[0]:
            sorted_list.append(splited_list[0])
            sorted_list.append(strange_sort(splited_list[1]))
            sorted_list.append(strange_sort(splited_list[2]))
        else:
            sorted_list.append(splited_list[1])
        return sorted_list
    
l1=[1,2,3,4,5,6,7]
print strange_sort(l1)
Gruß, jj
Antworten