Qual è l'algoritmo di ordinamento più oscuro che conosci? [chiuso]

Ho appena letto sul ciclo di cicli tramite un post sul blog di sortvis.org. Questo è probabilmente il più oscuro di cui abbia sentito parlare finora, dal momento che utilizza la matematica con cui non ho familiarità (rilevare i cicli nelle permutazioni degli insiemi di numeri interi).

Qual è il più oscuro che conosci?

Hai mai sentito parlare dell'ordinamento Patience ? Bene ora hai ...

Slowsort funziona moltiplicando e arrendendosi (invece di dividere e conquistare). È interessante perché è sicuramente l'algoritmo di ordinamento meno efficiente che può essere costruito (asintoticamente e con la restrizione che tale algoritmo, pur essendo lento, deve ancora lavorare continuamente per un risultato).

Questo lo compensa da bogosort perché nel migliore dei casi, bogosort è abbastanza efficiente, vale a dire quando l'array è già ordinato. Slowsort non "soffre" di tale comportamento nel migliore dei casi. Anche nel migliore dei casi, ha ancora runtime per ϵ > 0.

Ecco il suo pseudocodice, adattato dall'articolo Wikipedia tedesco :

function slowsort(A, i, j):
  if i >= j: return

  m = (i + j) / 2
  slowsort(A, i, m)
  slowsort(A, m + 1, j)

  if A[j] < A[m]:
    swap(A[j], A[m])

  slowsort(A, i, j - 1)

Non so se questo sia oscuro, ma uno degli "algoritmi" di ordinamento più ridicoli è Bogosort . Anche i link fuori dalla pagina di Bogosort sono divertenti.

E c'è questa gemma nella sezione "quantum bogo-sort".

Probabilmente, anche la creazione di universi 2 ^N richiede molta memoria.

Hmmm ... potresti dirlo :-).

Un altro oscuro "algoritmo" è Intelligent Design Sort , ma nessun algoritmo è più veloce o consuma meno memoria :)

Sleep Sort è piuttosto nuovo.

    #!/bin/bash
    function f() {
        sleep "$1"
        echo "$1"
    }
    while [ -n "$1" ]
    do
        f "$1" &
        shift
    done
    wait

esempio di utilizzo:

    ./sleepsort.bash 5 3 6 3 6 3 1 4 7

Penso che il tipo di bolla sarebbe la risposta sbagliata anche in questa situazione

:)

Volume di Knuth 3 ¹ , nella risposta a uno degli esercizi, fornisce un'implementazione di un algoritmo di ordinamento senza nome che è fondamentalmente un antico codice golf - il tipo più breve che puoi scrivere nel linguaggio assembly MIX. Il codice corto arriva al prezzo oh-so-minor della complessità O (N ³ ) sebbene ...

¹ Almeno nelle precedenti edizioni. Date le modifiche a MIXAL per la nuova edizione, non sono sicuro che sia ancora lì, o abbia anche un po 'di senso nel MIXAL originale.

Per la mia classe di strutture di dati ho dovuto (esplicitamente) dimostrare la correttezza dell'ordinamento di Stooge . Ha un tempo di esecuzione di O (n ^ {log 3 / log 1.5}) = O (n ^ 2.7095 ...).

Non so se sia il più oscuro, ma il tipo di spaghetti è uno dei migliori in situazioni in cui puoi usarlo.

Uno dei libri originali di Knuth, "Ordinamento e ricerca", aveva una piega centrale che mostrava un processo che ordinava un file nastro senza alcun disco rigido. Penso che usasse sei unità nastro e mostrasse esplicitamente quando ciascuna veniva letta in avanti, letta all'indietro, riavvolto o inattivo. Oggi è un monumento a una tecnologia obsoleta.

Una volta ho fatto un ordinamento a bolle nei registri vettoriali nell'assemblatore CRAY. La macchina aveva un'istruzione double shift, che permetteva di spostare il contenuto di un registro vettoriale su / giù di una parola. Inserisci ogni altro punto in due registri vettoriali, quindi potresti fare un ordinamento a bolle completo senza dover fare un altro riferimento di memoria fino a quando non hai finito. Fatta eccezione per la natura N ** 2 del tipo di bolla, era efficiente.

Una volta avevo anche bisogno di fare una sorta di virgola mobile di un vettore di lunghezza 4 il più velocemente possibile per un singolo ordinamento. Lo ha fatto tramite la ricerca di una tabella (il bit di segno di A2-A1 è un bit, il segno di A3-A1 ne forma un altro bit ..., quindi cerchi il vettore di permutazione in una tabella. In realtà era la soluzione più veloce che potevo trovare con. Non funziona bene su architetture moderne, tuttavia, le unità mobili e intere sono troppo separate.

Google Code Jam ha avuto un problema con un algoritmo chiamato Gorosort, che penso abbiano inventato per il problema.

Goro ha 4 braccia. Goro è molto forte. Non si scherza con Goro. Goro deve ordinare una matrice di N numeri interi diversi. Gli algoritmi non sono la forza di Goro; la forza è la forza di Goro. Il piano di Goro è di usare le dita su due delle sue mani per tenere premuti diversi elementi dell'array e colpire il tavolo con il suo terzo e il quarto pugno il più forte possibile. Ciò farà volare in aria gli elementi non garantiti dell'array, rimescolarli casualmente e ricadere nelle posizioni vuote dell'array.

http://code.google.com/codejam/contest/dashboard?c=975485#s=p3

Non ricordare il nome, ma era sostanzialmente

while Array not sorted

  rearrange the array in a random order

Ordinamento Shell

Forse l'algoritmo stesso non è così oscuro, ma chi può nominare un'implementazione che viene effettivamente utilizzata nella pratica? Io posso!

TIGCC (un compilatore basato su GCC per calcolatrici grafiche TI-89/92 / V200) utilizza l'ordinamento Shell per l' qsortimplementazione nella sua libreria standard:

__ATTR_LIB_C__ void qsort(void *list, short num_items, short size, compare_t cmp_func)
{
  unsigned short gap,byte_gap,i,j;                
  char *p,*a,*b,temp;                       
  for (gap=((unsigned short)num_items)>>1; gap>0; gap>>=1)    // Yes, this is not a quicksort,
    {                                                         // but works fast enough...    
      byte_gap=gap*(unsigned short)size;
      for(i=byte_gap; i<((unsigned short)num_items)*(unsigned short)size; i+=size)
        for(p=(char*)list+i-byte_gap; p>=(char*)list; p-= byte_gap)
          {
            a=p; b=p+byte_gap;
            if(cmp_func(a,b)<=0) break;
            for(j=size;j;j--)
              temp=*a, *a++=*b, *b++=temp;
          }
    }
}

L'ordinamento della shell è stato scelto a favore di quicksort per mantenere basse le dimensioni del codice. Sebbene la complessità asintotica sia peggiore, la TI-89 non ha molta RAM (190 KB, meno la dimensione del programma e la dimensione totale di qualsiasi variabile non archiviata), quindi è abbastanza sicuro presumere che il numero di elementi sarà sotto.

Un'implementazione più veloce è stata scritta dopo che mi sono lamentato che era troppo lento in un programma che stavo scrivendo. Utilizza dimensioni di spazio migliori, insieme a ottimizzazioni dell'assemblaggio. Può essere trovato qui: qsort.c