Telefilm senza fine

Non sto parlando di Beautiful, ma di tutti i telefilm che ho seguito fin’ora.
Non hanno una fine! Li abbandonano sospesi a metà! Costa tanto fare 1 episodio di conclusione?
L’ultima serie che ho visto, Stargate Universe, terzo capitolo della “saga” di Stargate, 14 anni di telefilm, uno si aspetta qualcosa di decente alla fine.
Invece, ultimo episodio, tutti che si ibernano sulla nave su cui si svolge l’ultima serie, tranne il protagonista che non riesce a far funzionare il meccanismo per potersi ibernare, dopo 40 episodi di tentativi di tornare sulla Terra, guerre con alieni, lotte per la sopravvivenza.
Pam, fine. 14 anni di Stargate in fumo. Potevano fare un solo episodio, era uguale!
Altro telefilm, Flash Forward. Nella prima puntata, tutto il mondo sviene e tutti hanno una visione su cosa gli accadrà sei mesi dopo. 20 e rotti episodi di indagini, ricerche, scoperte, azione. Arriva l’ultimo episodio e che succede? Con milioni di interrogativi aperti, svengono tutti di nuovo, altro flash forward e poi fine del telefilm. Ma si può?
Stessa cosa per Primeval, lascia tutti i protagonisti appollaiati su un albero nel Triassico. Anche se sembra sia stata annunciata una nuova serie, quindi rimane da sperare, sempre che si concluda qualcosa in 6 episodi da 40 minuti l’uno.

Dio che rabbia, e io che ci tenevo a vedere il finale di Stargate >.<

Bound Sort

Ho inventato un algortimo di ordinamento piuttosto efficiente (non chiedetemi quanto perchè ho provato a capire come si misuri l’efficienza di un algoritmo ma è una causa persa). L’ho confrontato con un’implementazione il bubble sort, e su liste abbastanza lunghe (dai 15 elementi in su, anche ripetuti) è decisamente migliore.
L’ho chiamato Bound sort poichè crea la lista ordinata a partire dai suoi estremi destro e sinistro.

Ecco i passaggi dell’algoritmo:

  1. Si trova il numero maggiore della lista, memorizzando il valore più grande che trova man mano che itera nella lista
  2. Si trova il numero minore della lista, memorizzando il valore più piccolo che trova man mano che itera nella lista
  3. Si aggiungono tutti i numeri della lista uguali al maggiore alla fine di una seconda lista
  4. Si aggiungono tutti i numeri della lista uguali al minore all’inizio della seconda lista
  5. Si rimuovono dalla prima lista tutti gli elementi uguali al maggiore o al minore trovati
  6. Si ripete il procedimento finchè non rimangono più numeri nella prima lista
  7. La seconda lista conterrà tutti gli elementi della prima in ordine crescente

Ed eccone un’implementazione in VB.NET:

Function BoundSort(ByVal ListToSort As List(Of Integer)) As Integer()
Dim SortedList(0 To ListToSort.Count - 1) As Integer
Dim Min as Integer
Dim Max as Integer
Dim posMax As Integer = ListToSort.Count - 1
Dim posMin As Integer = 0
Dim n As Integer

Do
      Min = ListToSort.Item(0)
      Max = ListToSort.Item(ListToSort.Count - 1)

      'trovo il maggiore e il minore
      n = 0
      For Each n In ListToSort
            If n < Min Then Min = n
            If n > Max Then Max = n
      Next

      'aggiungo alla fine della lista i maggiori
      n = 0
      For Each n In ListToSort
            If n = Max Then
                  SortedList(posMax) = n
                  posMax -= 1
            End If
      Next

      'aggiungo all'inizio della lista i minori
      n = 0
      For Each n In ListToSort
            If n = Min Then
                  SortedList(posMin) = n
                  posMin += 1
            End If
      Next

      'elimino maggiori e minori
      ListToSort.RemoveAll(Function(x As Integer) x = Max Or x = Min)
Loop Until ListToSort.Count = 0
Return SortedList
End Function

Il fatto che usi una lista invece che un array è puramente pratico, poichè operazione di aggiunta/rimozione sono molto più facili per una lista piuttosto che per un array.

Il doodle chitarra di Google spopola in rete

E’ diventato un vero fenomeno di Internet il doodle interattivo che Google ha messo quest’oggi in occasione del 96° anniversario della nascita di Les Pauls.
Su Facebook, una pagina dedicata a questo doodle ha fatto 38.000 fans in 22 ore, da record.
Ancora una volta Google meraviglia con i simpatici loghi, come quello di un po’ di tempo fa chiamato “Nautilus” in onore di Jules Verne, in cui si poteva esplorare un micro-abisso marino guardandolo da un oblò a forma di “Google”. Mi era piaciuto particolarmente in quanto fan di “20’000 leghe sotto i mari”, ma questo devo dire che l’ha superato!

Un po’ tutti credo ci siamo divertiti cinque minuti a suonare qualcosa, qualcuno con più dedizione di altri: