Ieri stavo accoppiando i calzini dalla biancheria pulita e ho capito che il modo in cui lo stavo facendo non è molto efficiente. Stavo facendo una ricerca ingenua, raccogliendo un calzino e "ripetendo" la pila per trovare la sua coppia. Ciò richiede l'iterazione di n / 2 * n / 4 = n ² /8 calzini in media.

Come informatico stavo pensando a cosa avrei potuto fare? L'ordinamento (in base alla dimensione / colore / ...) ovviamente mi è venuto in mente per ottenere una soluzione O (NlogN).

Hashing o altre soluzioni non sul posto non sono un'opzione, perché non sono in grado di duplicare i miei calzini (anche se potrebbe essere bello se potessi).

Quindi, la domanda è sostanzialmente:

Dato un mucchio di npaia di calze, contenente 2nelementi (supponiamo che ogni calza abbia esattamente una coppia corrispondente), qual è il modo migliore per accoppiarli in modo efficiente con spazio extra logaritmico? (Credo di poter ricordare quella quantità di informazioni se necessario.)

Apprezzerò una risposta che affronta i seguenti aspetti:

• Una soluzione teorica generale per un numero enorme di calze.
• Il numero effettivo di calze non è così grande, non credo al mio coniuge e ho più di 30 paia. (Ed è abbastanza facile distinguere tra i miei calzini e i suoi; può essere usato anche questo?)
• È equivalente al problema della distinzione tra elementi ?

Sono state proposte soluzioni di ordinamento, ma l' ordinamento è un po 'troppo : non abbiamo bisogno di ordine; abbiamo solo bisogno di gruppi di uguaglianza .

Quindi l' hashing sarebbe abbastanza (e più veloce).

1. Per ogni colore di calze, forma una pila . Scorrere su tutte le calze nel cestino di input e distribuirle sulle pile di colori .
2. Scorrere su ciascuna pila e distribuirla per qualche altra metrica (ad es. Modello) nella seconda serie di pile
3. Applicare in modo ricorsivo questo schema fino a quando non sono state distribuite tutte le calze su pile molto piccole che è possibile elaborare visivamente immediatamente

Questo tipo di partizionamento hash ricorsivo viene effettivamente eseguito da SQL Server quando deve unire hash o aggregare hash su enormi set di dati. Distribuisce il flusso di input della build in molte partizioni indipendenti. Questo schema si ridimensiona in modo lineare a quantità arbitrarie di dati e più CPU.

Non è necessario il partizionamento ricorsivo se è possibile trovare una chiave di distribuzione (chiave hash) che fornisce abbastanza bucket da consentire a ciascun bucket di essere abbastanza piccolo da essere elaborato molto rapidamente. Sfortunatamente, non penso che i calzini abbiano una tale proprietà.

Se ogni calzino avesse un numero intero chiamato "PairID", si potrebbe facilmente distribuirli in 10 secchi secondo PairID % 10(l'ultima cifra).

Il miglior partizionamento del mondo reale a cui riesco a pensare è la creazione di un rettangolo di pile : una dimensione è il colore, l'altra è il modello. Perché un rettangolo? Perché abbiamo bisogno di O (1) accesso casuale alle pile. (Anche un cuboide 3D funzionerebbe, ma non è molto pratico.)

Aggiornare:

Che dire del parallelismo ? Possono più esseri umani abbinare le calze più velocemente?

1. La strategia di parallelizzazione più semplice consiste nel fare in modo che più lavoratori prendano dal paniere di input e mettano i calzini sulle pile. Questo aumenta solo così tanto: immagina 100 persone che combattono su 10 pile. I costi di sincronizzazione (che si manifestano come collisioni manuali e comunicazioni umane) distruggono l'efficienza e l'accelerazione (vedi la Legge sulla scalabilità universale !). È soggetto a deadlock ? No, perché ogni lavoratore deve solo accedere a una pila alla volta. Con un solo "blocco" non può esserci un deadlock. Livelocks potrebbe essere possibile a seconda di come gli umani coordinano l'accesso alle pile. Potrebbero semplicemente usare il backoff casualecome le schede di rete lo fanno a livello fisico per determinare quale scheda può accedere esclusivamente al cavo di rete. Se funziona per le schede di rete , dovrebbe funzionare anche per gli esseri umani.
2. Ridimensiona quasi indefinitamente se ogni lavoratore ha il proprio set di pile . I lavoratori possono quindi prendere grossi pezzi di calzini dal paniere di input (pochissima contesa in quanto lo fanno raramente) e non devono sincronizzarsi quando distribuiscono i calzini (perché hanno pile di thread locali). Alla fine, tutti i lavoratori devono unire le proprie pile. Credo che si possa fare in O (log (conteggio dei lavoratori * pile per lavoratore)) se i lavoratori formano un albero di aggregazione .

Che dire del problema di distinzione tra elementi ? Come afferma l'articolo, il problema di distinzione tra elementi può essere risolto O(N). Questo è lo stesso per il problema dei calzini (inoltre O(N), se hai bisogno di un solo passo di distribuzione (ho proposto più passaggi solo perché gli umani sono cattivi nei calcoli - un passo è sufficiente se li distribuisci md5(color, length, pattern, ...), cioè un hash perfetto di tutti gli attributi)).

Chiaramente, non si può andare più veloci di O(N), quindi abbiamo raggiunto il limite inferiore ottimale .

Sebbene le uscite non siano esattamente le stesse (in un caso, solo un booleano. Nell'altro caso, le coppie di calze), le complessità asintotiche sono le stesse.

Poiché l'architettura del cervello umano è completamente diversa da una CPU moderna, questa domanda non ha senso pratico.

Gli umani possono conquistare algoritmi CPU utilizzando il fatto che "trovare una coppia corrispondente" può essere un'operazione per un set che non è troppo grande.

Il mio algoritmo:

spread_all_socks_on_flat_surface();
while (socks_left_on_a_surface()) {
     // Thanks to human visual SIMD, this is one, quick operation.
     pair = notice_any_matching_pair();
     remove_socks_pair_from_surface(pair);
}

Almeno questo è quello che sto usando nella vita reale, e lo trovo molto efficiente. Il rovescio della medaglia è che richiede una superficie piana, ma di solito è abbondante.

Caso 1 : tutte le calze sono identiche (questo è quello che faccio nella vita reale a proposito).

Scegline due per crearne una coppia. Tempo costante.

Caso 2 : esiste un numero costante di combinazioni (proprietà, colore, dimensioni, trama, ecc.).

Usa ordinamento radix . Questo è solo tempo lineare poiché il confronto non è richiesto.

Caso 3 : il numero di combinazioni non è noto in anticipo (caso generale).

Dobbiamo fare un confronto per verificare se due calzini vengono accoppiati. Scegli uno degli O(n log n)algoritmi di ordinamento basati sul confronto.

Tuttavia nella vita reale quando il numero di calze è relativamente piccolo (costante), questi algoritmi teoricamente ottimali non funzionerebbero bene. Potrebbe richiedere anche più tempo della ricerca sequenziale, che teoricamente richiede un tempo quadratico.

Risposta non algoritmica, ma "efficiente" quando lo faccio:

• passaggio 1) scartare tutte le calze esistenti

• passaggio 2) vai a Walmart e acquistali con pacchetti da 10 - n pacchetti di bianco e m pacchetti di nero. Non c'è bisogno di altri colori nella vita di tutti i giorni.

Eppure, a volte, devo farlo di nuovo (calzini persi, calzini danneggiati, ecc.), E odio scartare calzini perfettamente buoni troppo spesso (e avrei desiderato che continuassero a vendere lo stesso riferimento di calzini!), Quindi di recente ho preso un approccio diverso.

Risposta algoritmica:

Considera che se disegni una sola calza per la seconda pila di calze, mentre stai facendo, le tue probabilità di trovare la calza corrispondente in una ricerca ingenua sono abbastanza basse.

• Quindi prendine cinque a caso e memorizza la loro forma o la loro lunghezza.

Perché cinque? Di solito gli umani sono bravi a ricordare tra cinque e sette diversi elementi nella memoria di lavoro - un po 'come l'equivalente umano di uno stack RPN - cinque è un default sicuro.

• Prendi uno dalla pila di 2n-5.

• Ora cerca una corrispondenza (corrispondenza del modello visivo - gli umani sono bravi a farlo con una piccola pila) all'interno dei cinque che hai disegnato, se non ne trovi uno, quindi aggiungilo ai tuoi cinque.

• Continua a scegliere casualmente i calzini dallo stack e confrontali con i tuoi calzini 5 + 1 per una partita. Man mano che il tuo stack cresce, ridurrà le tue prestazioni ma aumenterà le tue probabilità. Più veloce.

Sentiti libero di scrivere la formula per calcolare quanti campioni devi pescare per una probabilità del 50% di una partita. IIRC è una legge ipergeometrica.

Lo faccio ogni mattina e raramente ho bisogno di più di tre pareggi - ma ho ncoppie simili (circa 10, dai o prendi quelle perse) di mcalzini bianchi sagomati. Ora puoi stimare la dimensione della mia pila di scorte :-)

A proposito , ho scoperto che la somma dei costi di transazione per ordinare tutti i calzini ogni volta che avevo bisogno di un paio era molto meno che farlo una volta e legare i calzini. Un just-in-time funziona meglio perché quindi non devi legare le calze e c'è anche un ritorno marginale decrescente (cioè, continui a cercare quelle due o tre calze che quando sei da qualche parte nella lavanderia e che ti servono per finire di abbinare le calze e perdere tempo).

Quello che faccio è che raccolgo il primo calzino e lo poso (diciamo, sul bordo del catino). Quindi raccolgo un altro calzino e controllo per vedere se è uguale al primo calzino. Se lo è, li rimuovo entrambi. In caso contrario, l'ho messo accanto al primo calzino. Quindi raccolgo il terzo calzino e lo confronto con i primi due (se sono ancora lì). Eccetera.

Questo approccio può essere facilmente implementato in un array, supponendo che la "rimozione" di calze sia un'opzione. In realtà, non è nemmeno necessario "rimuovere" le calze. Se non hai bisogno di ordinare i calzini (vedi sotto), puoi semplicemente spostarli e finire con un array che ha tutti i calzini disposti in coppie nell'array.

Supponendo che l'unica operazione per i calzini sia il confronto per uguaglianza, questo algoritmo è fondamentalmente ancora un algoritmo n ² , anche se non conosco il caso medio (non ho mai imparato a calcolarlo).

L'ordinamento, ovviamente, migliora l'efficienza, soprattutto nella vita reale in cui è possibile "inserire" facilmente una calza tra altre due calze. Nel calcolo lo stesso potrebbe essere raggiunto da un albero, ma questo è uno spazio extra. E, naturalmente, torniamo a NlogN (o un po 'di più, se ci sono più calze uguali per criteri di ordinamento, ma non della stessa coppia).

A parte questo, non riesco a pensare a nulla, ma questo metodo sembra essere abbastanza efficace nella vita reale. :)

Questa è la domanda sbagliata. La domanda giusta da porsi è: perché trascorro il tempo a selezionare i calzini? Quanto costa su base annuale, quando dai valore al tuo tempo libero per X unità monetarie di tua scelta?

E il più delle volte, questo non è solo qualsiasi tempo libero, che di mattina il tempo libero, che si potrebbe essere spesa a letto, o sorseggiando un caffè, o di lasciare un po 'presto e non essere catturati nel traffico.

Spesso è utile fare un passo indietro e pensare a come ovviare al problema.

E c'è un modo!

Trova un calzino che ti piace. Prendi in considerazione tutte le caratteristiche rilevanti: colore in diverse condizioni di illuminazione, qualità generale e durata, comfort in diverse condizioni climatiche e assorbimento degli odori. È anche importante che non debbano perdere elasticità durante lo stoccaggio, quindi i tessuti naturali sono buoni e dovrebbero essere disponibili in un involucro di plastica.

È meglio se non ci sono differenze tra i calzini per piede sinistro e destro, ma non è fondamentale. Se le calze sono simmetriche sinistra-destra, trovare una coppia è un'operazione O (1) e ordinare le calze è un'operazione O (M) approssimativa, dove M è il numero di posti nella tua casa, che hai disseminato di calze, idealmente alcuni piccolo numero costante.

Se hai scelto un paio di fantasia con diversi calzini sinistro e destro, eseguendo una sorta di secchio pieno sui secchi sinistro e destro prendi O (N + M), dove N è il numero di calzini e M è uguale a quello sopra. Qualcun altro può dare la formula per iterazioni medie di ricerca della prima coppia, ma il caso peggiore per trovare una coppia con ricerca cieca è N / 2 + 1, che diventa un caso astronomicamente improbabile per un ragionevole N. Questo può essere accelerato usando l'immagine avanzata algoritmi di riconoscimento ed euristica durante la scansione del mucchio di calze non ordinate con Mk1 Eyeball .

Quindi, un algoritmo per raggiungere l'efficienza di accoppiamento del calzino O (1) (supponendo calzino simmetrico) è:

1. Devi stimare quante paia di calze avrai bisogno per il resto della tua vita, o forse fino a quando non ti ritirerai e ti trasferirai in climi più caldi senza la necessità di indossare mai più calze. Se sei giovane, potresti anche stimare quanto tempo ci vorrà prima che avremo tutti i robot di smistamento delle calze nelle nostre case e l'intero problema diventerà irrilevante.

2. Devi scoprire in che modo puoi ordinare il calzino selezionato in blocco, quanto costa e come lo consegnano.

3. Ordina le calze!

4. Sbarazzati delle tue vecchie calze.

Un passaggio 3 alternativo comporterebbe il confronto dei costi di acquisto della stessa quantità di calzini forse più economici poche paia alla volta nel corso degli anni e l'aggiunta del costo di smistamento dei calzini, ma credetemi: comprarlo alla rinfusa è più economico! Inoltre, le calze nello stoccaggio aumentano di valore al tasso di inflazione dei prezzi delle azioni, che è più di quanto si otterrebbe su molti investimenti. Poi di nuovo c'è anche un costo di archiviazione, ma le calze in realtà non occupano molto spazio sul ripiano superiore di un armadio.

Problema risolto. Quindi, prendi solo nuovi calzini, butta / dona i tuoi vecchi e vivi per sempre felici e contenti sapendo che stai risparmiando tempo e denaro ogni giorno per il resto della tua vita.

Il limite teorico è O (n) perché è necessario toccare ogni calzino (a meno che alcuni non siano già associati in qualche modo).

Puoi ottenere O (n) con l' ordinamento radix . Devi solo selezionare alcuni attributi per i bucket.

1. Per prima cosa puoi scegliere (la sua, la mia): dividerli in 2 pile,
2. quindi usa i colori (può avere qualsiasi ordine per i colori, ad esempio in ordine alfabetico per nome del colore) - dividili in pile per colore (ricorda di mantenere l'ordine iniziale dal passaggio 1 per tutte le calze nella stessa pila),
3. poi la lunghezza della calza,
4. quindi trama, ....

Se puoi scegliere un numero limitato di attributi, ma abbastanza attributi che possono identificare in modo univoco ogni coppia, dovresti farlo in O (k * n), che è O (n) se possiamo considerare che k è limitato.

Come soluzione pratica:

1. Crea rapidamente pile di calzini facilmente distinguibili. (Dì per colore)
2. Quicksort ogni pila e utilizzare la lunghezza della calza per il confronto. Come essere umano puoi prendere una decisione abbastanza veloce quale calzino usare per partizionare che evita il caso peggiore. (Puoi vedere più calze in parallelo, usale a tuo vantaggio!)
3. Smetti di ordinare le pile quando hanno raggiunto una soglia in cui ti senti a tuo agio nel trovare istantaneamente coppie di punti e calzini spaiati

Se hai 1000 calze, con 8 colori e una distribuzione media, puoi creare 4 pile di ogni 125 calze in un tempo * c. Con una soglia di 5 calzini puoi ordinare ogni pila in 6 corse. (Contando 2 secondi per lanciare una calza sulla pila destra ci vorranno poco meno di 4 ore.)

Se hai solo 60 calzini, 3 colori e 2 tipi di calzini (tuoi / di tua moglie) puoi ordinare ogni pila di 10 calzini in 1 corsa (di nuovo soglia = 5). (Contando 2 secondi ci vorranno 2 minuti).

L'ordinamento iniziale dei bucket velocizzerà il tuo processo, perché divide i tuoi n socks in k secchi in c*ntempo, quindi dovrai solo c*n*log(k)lavorare. (Non tenendo conto della soglia). Quindi, tutto sommato, fai del n*c*(1 + log(k))lavoro, dove c è il momento di gettare un calzino su una pila.

Questo approccio sarà favorevole rispetto a qualsiasi c*x*n + O(1)metodo all'incirca finché log(k) < x - 1.

In informatica ciò può essere utile: abbiamo una raccolta di n cose , un ordine su di esse (lunghezza) e anche una relazione di equivalenza (informazioni extra, ad esempio il colore dei calzini). La relazione di equivalenza ci consente di creare una partizione della collezione originale e in ogni classe di equivalenza il nostro ordine è ancora mantenuto. La mappatura di una cosa alla sua classe di equivalenza può essere fatta in O (1), quindi è necessario solo O (n) per assegnare ciascun oggetto a una classe. Ora abbiamo usato le nostre informazioni extra e possiamo procedere in qualsiasi modo per ordinare ogni classe. Il vantaggio è che i set di dati sono già significativamente più piccoli.

Il metodo può anche essere nidificato, se abbiamo più relazioni di equivalenza -> crea pile di colori, che all'interno di ogni partizione di pila sulla trama, che ordina per lunghezza. Qualsiasi relazione di equivalenza che crea una partizione con più di 2 elementi che hanno dimensioni pari a circa porterà un miglioramento della velocità rispetto all'ordinamento (a condizione che possiamo assegnare direttamente un calzino alla sua pila) e l'ordinamento può avvenire molto rapidamente su set di dati più piccoli.

Stai cercando di risolvere il problema sbagliato.

Soluzione 1: ogni volta che mettete dei calzini sporchi nel cesto della biancheria, annodateli con un nodo. In questo modo non dovrai fare alcun ordinamento dopo il lavaggio. Pensalo come registrare un indice in un database Mongo. Un piccolo lavoro in anticipo per alcuni risparmi della CPU in futuro.

Soluzione 2: se è inverno, non è necessario indossare calze abbinate. Siamo programmatori. Nessuno ha bisogno di sapere, finché funziona.

Soluzione 3: diffondere il lavoro. Volete eseguire un processo CPU così complesso in modo asincrono, senza bloccare l'interfaccia utente. Prendi quel mucchio di calzini e mettili in una borsa. Cerca un paio solo quando ne hai bisogno. In questo modo la quantità di lavoro necessaria è molto meno evidente.

Spero che sia di aiuto!

Questa domanda è in realtà profondamente filosofica. Fondamentalmente si tratta di stabilire se il potere delle persone di risolvere i problemi (il "wetware" del nostro cervello) equivale a ciò che può essere realizzato con gli algoritmi.

Un ovvio algoritmo per l'ordinamento dei calzini è:

Let N be the set of socks that are still unpaired, initially empty
for each sock s taken from the dryer
  if s matches a sock t in N
    remove t from N, bundle s and t together, and throw them in the basket
  else
    add s to N

Ora l'informatica in questo problema riguarda tutti i passaggi

1. "se s si accoppia con una calza t in N". Quanto velocemente possiamo "ricordare" ciò che abbiamo visto finora?
2. "rimuovi t da N" e "aggiungi s a N". Quanto costa tenere traccia di ciò che abbiamo visto finora?

Gli esseri umani useranno varie strategie per realizzarle. La memoria umana è associativa , qualcosa di simile a una tabella hash in cui set di funzionalità di valori memorizzati sono associati ai valori corrispondenti stessi. Ad esempio, il concetto di "macchina rossa" è associato a tutte le macchine rosse che una persona è in grado di ricordare. Qualcuno con una memoria perfetta ha una mappatura perfetta. La maggior parte delle persone è imperfetta in questo senso (e la maggior parte degli altri). La mappa associativa ha una capacità limitata. Le mappature possono essere sospese fuori dall'esistenza in varie circostanze (una birra di troppo), essere registrato per errore ("Pensavo che il suo nome fosse Betty, non Nettie"), o mai essere sovrascritto anche se osserviamo che la verità è cambiata ("la macchina di papà" evoca "arancione Firebird" quando sapevamo che lo aveva scambiato con il rosso Camaro).

Nel caso dei calzini, il richiamo perfetto significa che guardare un calzino sproduce sempre la memoria del fratello t, comprese informazioni sufficienti (dove si trova sull'asse da stiro) per localizzarlo tin tempo costante. Una persona con memoria fotografica compie sia 1 che 2 in tempo costante a colpo sicuro.

Qualcuno con una memoria tutt'altro che perfetta potrebbe usare alcune classi di equivalenza di buon senso basate su caratteristiche all'interno della sua capacità di tracciare: dimensioni (papa, mamma, bambino), colore (verdastro, rossastro, ecc.), Modello (argyle, pianura, ecc.) , stile (footie, gambaletto, ecc.). Quindi l'asse da stiro sarebbe diviso in sezioni per le categorie. Questo di solito consente alla categoria di essere posizionata in tempo costante dalla memoria, ma è quindi necessaria una ricerca lineare attraverso la categoria "bucket".

Qualcuno senza memoria o immaginazione (scusate) manterrà le calze in una pila e farà una ricerca lineare dell'intera pila.

Un mostro ordinato potrebbe usare etichette numeriche per le coppie come qualcuno ha suggerito. Questo apre le porte a un ordinamento totale, che consente all'essere umano di utilizzare esattamente gli stessi algoritmi che potremmo avere con una CPU: ricerca binaria, alberi, hash, ecc.

Quindi l'algoritmo "migliore" dipende dalle qualità del wetware / hardware / software che lo sta eseguendo e dalla nostra volontà di "imbrogliare" imponendo un ordine totale sulle coppie. Certamente un "miglior" meta- algoritmo è assumere il selezionatore di calzini migliore del mondo: una persona o una macchina che può acquisire e immagazzinare rapidamente un enorme set di set di attributi di calzino in una memoria associativa 1-1 con ricerca del tempo costante, inserire, ed elimina. Sia le persone che le macchine come questa possono essere acquistate. Se ne hai uno, puoi accoppiare tutti i calzini in O (N) per N coppie, il che è ottimale. I tag di ordine totale consentono di utilizzare l'hash standard per ottenere lo stesso risultato con un computer umano o hardware.

Costo: spostamento dei calzini -> alti, ricerca / ricerca di calzini in linea -> piccoli

Quello che vogliamo fare è ridurre il numero di mosse e compensare con il numero di ricerche. Inoltre, possiamo utilizzare l'ambiente multithreded dell'Homo Sapiens per contenere più elementi nella cache di descrizione.

X = Tuo, Y = I tuoi coniugi

Dal mucchio A di tutte le calze:

Scegli due calzini, posiziona il calzino X corrispondente nella linea X e il calzino Y nella linea Y nella successiva posizione disponibile.

Fallo fino a quando A è vuoto.

Per ogni riga X e Y

1. Scegli la prima calza in linea, cerca lungo la linea fino a trovare la calza corrispondente.

2. Inserire nella corrispondente linea finita di calze.

3. Facoltativo Mentre stai cercando la linea e la calza attuale che stai osservando è identica alla precedente, esegui il passaggio 2 per queste calze.

Facoltativamente al primo passaggio, prendi due calzini da quella linea anziché due, poiché la memoria della cache è abbastanza grande che possiamo identificare rapidamente se uno dei calzini corrisponde a quello attuale sulla linea che stai osservando. Se sei abbastanza fortunato da avere tre braccia, potresti eventualmente analizzare tre calze allo stesso tempo, dato che la memoria del soggetto è abbastanza grande.

Fallo fino a quando sia X che Y sono vuoti.

Fatto

Tuttavia, poiché ciò ha una complessità simile a quella dell'ordinamento selettivo, il tempo impiegato è molto inferiore a causa della velocità di I / O (spostamento dei calzini) e della ricerca (ricerca della linea per un calzino).

Ecco un limite inferiore Omega (n log n) nel modello basato sul confronto. (L'unica operazione valida è quella di confrontare due calzini.)

Supponi di sapere che le tue calze 2n sono disposte in questo modo:

p ₁ p ₂ p ₃ ... p _n p _{f (1)} p _{f (2)} ... p _{f (n)}

dove f è una permutazione sconosciuta dell'insieme {1,2, ..., n}. Sapere questo non può rendere il problema più difficile. Non ci sono! possibili output (corrispondenze tra la prima e la seconda metà), il che significa che è necessario il confronto log (n!) = Omega (n log n). Questo è ottenibile ordinando.

Dato che sei interessato alle connessioni al problema della distinzione tra elementi: dimostrare che Omega (n log n) è associato alla distinzione tra elementi è più difficile, perché l'output è sì / no binario. Qui, l'uscita deve essere una corrispondenza e il numero di possibili uscite è sufficiente per ottenere un limite decente. Tuttavia, esiste una variante connessa alla distinzione tra elementi. Supponiamo che ti vengano dati 2 calzini e chiedi se possono essere accoppiati in modo univoco. Puoi ottenere una riduzione da ED inviando (a ₁ , a ₂ , ..., a _n ) a (a ₁ , a ₁ , a ₂ , a ₂ , ..., a _n , a _n ). (Tra parentesi, la prova della durezza dell'ED è molto interessante, tramite la topologia.)

Penso che dovrebbe esserci un Omega (n ² ) associato al problema originale se si consentono solo test di uguaglianza. La mia intuizione è: considera un grafico in cui aggiungi un bordo dopo un test e sostiene che se il grafico non è denso, l'output non viene determinato in modo univoco.

Questo è come io in realtà faccio, per p paia di calzini ( n = 2p singoli calze):

• Prendi una calza a caso dalla pila.
• Per il primo calzino, o se tutti i calzini scelti in precedenza sono stati accoppiati, posiziona semplicemente il calzino nel primo "slot" di un "array" di calzini spaiati di fronte a te.
• Se hai selezionato uno o più calzini non accoppiati selezionati, controlla il calzino attuale con tutti i calzini non accoppiati dell'array.
  • È possibile separare i calzini in classi o tipi generali (bianco / nero, caviglia / equipaggio, atletica / vestito) durante la costruzione dell'array e "drill-down" per confrontare solo like-for-like.
  • Se trovi una corrispondenza accettabile, metti insieme entrambi i calzini e rimuovili dall'array.
  • In caso contrario, inserire la calza corrente nel primo slot aperto dell'array.
• Ripeti con ogni calza.

Lo scenario peggiore di questo schema è che ogni paio di calzini è abbastanza diverso da corrispondere esattamente e che i primi calzini n / 2 che scegli sono tutti diversi. Questo è il tuo scenario O (n ² ) ed è estremamente improbabile. Se il numero di tipi unici di calzino t è inferiore al numero di paia p = n / 2 e i calzini di ciascun tipo sono abbastanza simili (di solito in termini di usura) che qualsiasi calzino di quel tipo può essere accoppiato con qualsiasi altro, quindi, come ho dedotto in precedenza, il numero massimo di calze che dovrai mai confrontare è t , dopo di che il prossimo che tirerai saràabbinare uno dei calzini spaiati. Questo scenario è molto più probabile nel cassetto delle calze medio rispetto al caso peggiore e riduce la complessità del caso peggiore a O (n * t) dove di solito t << n .

Approccio nel mondo reale:

Il più rapidamente possibile, rimuovi i calzini dalla pila non ordinata uno alla volta e mettili in pile di fronte a te. Le pile dovrebbero essere disposte in modo un po 'efficiente nello spazio, con tutte le calze che puntano nella stessa direzione; il numero di pile è limitato dalla distanza facilmente raggiungibile. La scelta di una pila su cui mettere una calza dovrebbe essere - il più rapidamente possibile - mettendo una calza su una pila di calzini apparentemente simili; si può tollerare l'errore occasionale di tipo I (mettere una calza su una pila a cui non appartiene) o di tipo II (mettere una calza nella propria pila quando esiste una pila di calzini simili) - la considerazione più importante è la velocità .

Una volta che tutte le calze sono in pile, passa rapidamente attraverso le pile multi-calza creando coppie e rimuovendole (queste sono dirette al cassetto). Se ci sono calzini non corrispondenti nella pila, raggruppali nuovamente nella pila migliore (entro il limite del più veloce possibile). Quando tutte le pile multi-calzino sono state elaborate, abbinare le calze accoppiabili rimanenti che non sono state accoppiate a causa di errori di tipo II. Whoosh, hai finito - e ho un sacco di calzini e non li lavo fino a quando una grande frazione è sporca. Un'altra nota pratica: capovolgo la parte superiore di uno di un paio di calzini sull'altro, sfruttando le loro proprietà elastiche, in modo che rimangano uniti mentre vengono trasportati nel cassetto e mentre sono nel cassetto.

Dalla tua domanda è chiaro che non hai molta esperienza reale con il bucato :). È necessario un algoritmo che funzioni bene con un numero limitato di calze non accoppiabili.

Le risposte fino ad ora non fanno buon uso delle nostre capacità di riconoscimento dei modelli umani. Il gioco di Set fornisce un indizio su come farlo bene: metti tutte le calze in uno spazio bidimensionale in modo da poterle riconoscere bene e raggiungerle facilmente con le mani. Questo ti limita a un'area di circa 120 * 80 cm circa. Da lì seleziona le coppie che riconosci e rimuovile. Metti le calze extra nello spazio libero e ripeti. Se ti lavi per le persone con calzini facilmente riconoscibili (i bambini piccoli vengono in mente), puoi fare un ordinamento radix selezionando prima quelle calze. Questo algoritmo funziona bene solo quando il numero di calze singole è basso

Prendi un primo calzino e mettilo su un tavolo. Ora scegli un altro calzino; se corrisponde al primo selezionato, posizionalo sopra al primo. In caso contrario, posizionalo sul tavolo a una piccola distanza dal primo. Scegli un terzo calzino; se corrisponde a uno dei due precedenti, posizionalo sopra di essi oppure posizionalo a una piccola distanza dal terzo. Ripeti finché non avrai raccolto tutti i calzini.

Per dire quanto sia efficace accoppiare i calzini da una pila, dobbiamo prima definire la macchina, perché l'accoppiamento non viene effettuato né da un turing né da una macchina ad accesso casuale, che sono normalmente utilizzate come base per un analisi algoritmica.

La macchina

La macchina è un'astrazione di un elemento del mondo reale chiamato essere umano. È in grado di leggere dall'ambiente tramite un paio di occhi. E il nostro modello di macchina è in grado di manipolare l'ambiente utilizzando 2 bracci. Le operazioni logiche e aritmetiche sono calcolate usando il nostro cervello (si spera ;-)).

Dobbiamo anche considerare la durata intrinseca delle operazioni atomiche che possono essere eseguite con questi strumenti. A causa di vincoli fisici, le operazioni eseguite da un braccio o da un occhio presentano una complessità temporale non costante. Questo perché non possiamo spostare un mucchio infinitamente grande di calzini con un braccio né un occhio può vedere il calzino superiore su un mucchio infinitamente grande di calzini.

Tuttavia, anche la fisica meccanica ci offre alcuni vantaggi. Non ci limitiamo a muovere al massimo una calza con un braccio. Possiamo spostarne un paio intero in una volta.

Pertanto, a seconda dell'analisi precedente, le seguenti operazioni devono essere utilizzate in ordine decrescente:

• operazioni logiche e aritmetiche
• letture ambientali
• modifiche ambientali

Possiamo anche sfruttare il fatto che le persone hanno solo un numero molto limitato di calze. Quindi una modifica ambientale può coinvolgere tutti i calzini nella pila.

L'algoritmo

Quindi ecco il mio suggerimento:

1. Distribuisci tutti i calzini nella pila sul pavimento.
2. Trova un paio guardando le calze sul pavimento.
3. Ripetere da 2 fino a quando non è possibile effettuare alcuna coppia.
4. Ripeti da 1 fino a quando non ci sono calze sul pavimento.

L'operazione 4 è necessaria, perché quando si distribuiscono le calze sul pavimento alcune calze potrebbero nasconderne altre. Ecco l'analisi dell'algoritmo:

Le analisi

L'algoritmo termina con alta probabilità. Ciò è dovuto al fatto che non è possibile trovare paia di calze nel passaggio numero 2.

Per la seguente analisi di runtime di accoppiamento di npaia di calze, supponiamo che almeno la metà delle 2ncalze non sia nascosta dopo il passaggio 1. Quindi, nel caso medio, possiamo trovare n/2coppie. Ciò significa che il ciclo è il passo 4 viene eseguito O(log n)volte. Il passaggio 2 è eseguito O(n^2)volte. Quindi possiamo concludere:

• L'algoritmo prevede O(ln n + n)modifiche ambientali (fase 1 O(ln n)più raccolta di ogni paio di calze dal pavimento)
• L'algoritmo prevede O(n^2)letture ambientali dal passaggio 2
• L'algoritmo prevede O(n^2)operazioni logiche e aritmetiche per confrontare un calzino con un altro nel passaggio 2

Quindi abbiamo una complessità di runtime totale di O(r*n^2 + w*(ln n + n))dove re wsono i fattori per le operazioni di lettura ambientale e di scrittura ambientale rispettivamente per un numero ragionevole di calze. Il costo delle operazioni logiche e aritmetiche viene omesso, perché supponiamo che ci voglia una quantità costante di operazioni logiche e aritmetiche per decidere se 2 calze appartengono alla stessa coppia. Questo potrebbe non essere fattibile in tutti gli scenari.

List<Sock> UnSearchedSocks = getAllSocks();
List<Sock> UnMatchedSocks = new list<Sock>();
List<PairOfSocks> PairedSocks = new list<PairOfSocks>();

foreach (Sock newSock in UnsearchedSocks)
{
  Sock MatchedSock = null;
  foreach(Sock UnmatchedSock in UnmatchedSocks)
  {
    if (UnmatchedSock.isPairOf(newSock))
    {
      MatchedSock = UnmatchedSock;
      break;
    }
  }
  if (MatchedSock != null)
  {
    UnmatchedSocks.remove(MatchedSock);
    PairedSocks.Add(new PairOfSocks(MatchedSock, NewSock));
  }
  else
  {
    UnmatchedSocks.Add(NewSock);
  }
}

Sono uscito con un'altra soluzione che non prometterebbe un minor numero di operazioni, né un minor consumo di tempo, ma dovrebbe essere provato a vedere se può essere un buon euristico per fornire un minor consumo di tempo in enormi serie di accoppiamenti di calze.

Presupposti: non esiste alcuna garanzia che esistano le stesse calze. Se sono dello stesso colore, ciò non significa che abbiano le stesse dimensioni o lo stesso motivo. I calzini vengono mescolati casualmente. Può esserci un numero dispari di calze (alcune mancano, non sappiamo quante). Preparati a ricordare un "indice" variabile e impostalo su 0.

Il risultato avrà una o due pile: 1. "abbinato" e 2. "mancante"

Euristico:

1. Trova la calza più distintiva.
2. Trova la sua corrispondenza.
3. Se non c'è partita, mettila nella pila "mancante".
4. Ripeti dal 1. fino a quando non ci sono più calzini più distintivi.
5. Se ci sono meno di 6 calze, vai a 11.
6. Abbina ciecamente tutte le calze al vicino (non imballarlo)
7. Trova tutte le coppie abbinate, impacchettalo e sposta le coppie impaccate nella pila "abbinata"; Se non ci sono nuove corrispondenze, incrementa "indice" di 1
8. Se "indice" è maggiore di 2 (questo potrebbe dipendere dal valore in base al numero del calzino perché con un numero maggiore di calzini ci sono meno possibilità di abbinarli ciecamente) vai a 11
9. Mescola il resto
10. Vai a 1
11. Dimentica "indice"
12. Scegli un calzino
13. Trova la sua coppia
14. Se non ci sono coppie per la calza, spostala nella pila "mancante"
15. Se la corrispondenza trovata la accoppia, impacchetta la coppia e la sposta nella pila "abbinata"
16. Se ce ne sono ancora più di una, vai a 12
17. Se è rimasto solo uno, vai a 14
18. Sorriso soddisfatto :)

Inoltre, potrebbe essere aggiunto verificare anche la presenza di calze danneggiate, come se la rimozione di quelle. Potrebbe essere inserito tra 2 e 3 e tra 13 e 14.

Non vedo l'ora di conoscere eventuali esperienze o correzioni.

Quando ordino i calzini, eseguo un ordinamento radix approssimativo , facendo cadere calzini vicino ad altri calzini dello stesso tipo di colore / modello. Tranne nel caso in cui riesco a vedere una corrispondenza esatta in / vicino alla posizione che sto per rilasciare la calza, estraggo la coppia in quel punto.

Quasi tutti gli altri algoritmi (inclusa la risposta di punteggio superiore di usr ) ordinano, quindi rimuovono le coppie. Trovo che, come essere umano, sia meglio ridurre al minimo il numero di calze considerate contemporaneamente.

Lo faccio per:

1. Scegliere una calza distintiva (qualunque cosa attiri per prima cosa nella pila).
2. Iniziare una specie di radix da quella posizione concettuale estraendo i calzini dalla pila in base alla somiglianza con quello.
3. Posiziona la nuova calza vicino alla pila attuale, con una distanza basata su quanto è diversa. Se ti ritrovi a mettere il calzino sopra l'altro perché è identico, forma la coppia lì e rimuovili. Ciò significa che i confronti futuri richiedono meno sforzi per trovare il posto giusto.

Questo sfrutta la capacità umana di fuzzy-match nel tempo O (1), che è in qualche modo equivalente alla creazione di una mappa hash su un dispositivo di elaborazione.

Tirando prima i calzini distintivi, si lascia spazio per "ingrandire" le caratteristiche che sono meno distintive, per cominciare.

Dopo aver eliminato il colore fluro, i calzini a strisce e le tre paia di calzini lunghi, potresti ritrovarti con calzini per lo più bianchi approssimativamente ordinati in base a quanto sono consumati.

Ad un certo punto, le differenze tra i calzini sono abbastanza piccole che le altre persone non noteranno la differenza e non sono necessari ulteriori sforzi di abbinamento.

Ogni volta che raccogli un calzino, mettilo in un posto. Quindi il calzino successivo che raccogli, se non corrisponde al primo calzino, posizionalo accanto al primo. Se lo fa, ce n'è un paio. In questo modo non importa davvero quante combinazioni ci siano e ci sono solo due possibilità per ogni calzino che raccogli: o ha una corrispondenza che è già nella tua gamma di calzini, oppure no, il che significa che aggiungilo a un posto nell'array.

Questo significa anche che quasi sicuramente non avrai mai tutte le calze nell'array, perché le calze verranno rimosse quando vengono abbinate.

Considera una tabella hash di dimensioni 'N'.

Se assumiamo una distribuzione normale, il numero stimato di "inserimenti" per avere almeno un calzino mappato su un bucket è NlogN (ovvero, tutti i bucket sono pieni)

Ne avevo ricavato come parte di un altro enigma, ma sarei felice di essere smentito. Ecco il mio articolo sul blog sullo stesso

Lascia che 'N' corrisponda a un limite superiore approssimativo sul numero di colori / motivi unici di calze che hai.

Una volta che hai una collisione (aka: una partita), rimuovi semplicemente quel paio di calzini. Ripeti lo stesso esperimento con il prossimo lotto di calze NlogN. Il bello è che potresti fare paragoni paralleli di NlogN (risoluzione delle collisioni) a causa del modo in cui funziona la mente umana. :-)

I calzini, siano essi reali o una struttura dati analoga, verrebbero forniti in coppia.

La risposta più semplice è prima di consentire la separazione della coppia, una singola struttura di dati per la coppia avrebbe dovuto essere inizializzata che conteneva un puntatore alla calza sinistra e destra, consentendo così di fare riferimento alle calze direttamente o tramite la loro coppia. Una calza può anche essere estesa per contenere un puntatore al suo partner.

Ciò risolve qualsiasi problema di accoppiamento computazionale rimuovendolo con uno strato di astrazione.

Applicando la stessa idea al problema pratico dell'abbinamento dei calzini, la risposta apparente è: non permettere che i tuoi calzini siano mai spaiati. I calzini sono forniti in coppia, messi nel cassetto in coppia (forse unendoli insieme), indossati in coppia. Ma il punto in cui è possibile l'abbinamento è nella lavatrice, quindi tutto ciò che serve è un meccanismo fisico che consenta alle calze di stare insieme e di essere lavate in modo efficiente.

Esistono due possibilità fisiche:

Per un oggetto "coppia" che mantiene un puntatore su ogni calza potremmo avere una borsa di stoffa che usiamo per tenere insieme i calzini. Sembra un enorme sovraccarico.

Ma per ogni calzino per mantenere un riferimento all'altro, esiste una soluzione ordinata: un bottone automatico (o un 'pulsante a scatto' se sei americano), come questi:

http://www.aliexpress.com/compare/compare-invisible-snap-buttons.html

Quindi tutto ciò che fai è agganciare le calze subito dopo averle tolte e metterle nel cestello del lavaggio, e di nuovo hai rimosso il problema di dover accoppiare le calze con un'astrazione fisica del concetto di "coppia".

Se l'operazione "sposta" è piuttosto costosa e l'operazione "confronta" è economica e devi comunque spostare l'intero set in un buffer in cui la ricerca è molto più veloce rispetto alla memoria originale ... basta integrare l'ordinamento nell'obbligatorio mossa.

Ho scoperto che integrare il processo di smistamento in appeso ad asciugare lo rende un gioco da ragazzi. Devo comunque raccogliere ogni calzino e appenderlo (muoverlo) e non mi costa nulla appenderlo in un punto specifico sulle corde. Ora, solo per non forzare la ricerca dell'intero buffer (le stringhe), ho scelto di posizionare i calzini per colore / tonalità. Più scuro a sinistra, più luminoso a destra, più colorato davanti ecc. Ora prima di appendere ogni calzino, guardo nella sua "giusta vicinanza" se ne esiste già uno corrispondente - questo limita la "scansione" ad altri 2-3 calzini - e se lo è , Appendo l'altro proprio accanto ad esso. Quindi li arrotolo a coppie mentre lo rimuovo dalle corde, quando sono asciutti.

Ora, questo potrebbe non sembrare molto diverso dal "formare pile per colore" suggerito dalle risposte migliori ma prima, non scegliendo pile discrete ma intervalli, non ho problemi a classificare se "viola" va a "rosso" o "blu"; va solo in mezzo. E poi integrando due operazioni (appendere ad asciugare e ordinare) l'overhead dello smistamento mentre appeso è come il 10% di quello che sarebbe lo smistamento separato.

Ho finito di abbinare le mie calze proprio ora e ho scoperto che il modo migliore per farlo è il seguente:

• Scegli una delle calze e mettila via (crea un 'secchio' per quella coppia)
• Se il successivo è la coppia di quello precedente, inseriscilo nel bucket esistente, altrimenti creane uno nuovo.

Nel peggiore dei casi significa che avrai n / 2 secchi diversi e avrai n-2 determinazioni su ciò che bucket contiene la coppia della calza corrente. Ovviamente, questo algoritmo funziona bene se hai solo poche coppie; L'ho fatto con 12 coppie.

Non è così scientifico, ma funziona bene :)

La mia soluzione non corrisponde esattamente alle tue esigenze, in quanto richiede formalmente O(n)spazio "extra". Tuttavia, considerando le mie condizioni, è molto efficace nella mia applicazione pratica. Quindi penso che dovrebbe essere interessante.

Combina con altre attività

La condizione speciale nel mio caso è che non uso asciugatrice, appendo semplicemente i miei panni su un normale asciugabiancheria. I panni appesi richiedono O(n)operazioni (a proposito, qui considero sempre il problema dell'imballaggio del cestino ) e il problema per sua natura richiede lo spazio "extra" lineare. Quando prendo una nuova calza dal secchio, provo ad appenderla accanto alla sua coppia se la coppia è già appesa. Se è una calza da una nuova coppia, lascio un po 'di spazio accanto.

Oracle Machine is Better ;-)

Richiede ovviamente un po 'di lavoro extra per verificare se c'è già il calzino corrispondente appeso da qualche parte e renderebbe la soluzione O(n^2)con coefficiente circa 1/2per un computer. Ma in questo caso il "fattore umano" è in realtà un vantaggio - di solito riesco a O(1)identificare molto rapidamente (quasi ) il calzino corrispondente se fosse già stato appeso (probabilmente è coinvolta una cache del cervello impercettibile) - lo considero una specie di "oracolo" limitato come in Oracle Machine ;-) In alcuni casi, gli umani hanno questi vantaggi rispetto alle macchine digitali ;-)

Quasi O(n)!

In questo modo, collegando il problema dell'abbinamento delle calze al problema dei panni appesi ottengo O(n)"spazio extra" gratuitamente, e ho una soluzione che è circa O(n)nel tempo, richiede solo un po 'più di lavoro rispetto ai semplici panni appesi e consente di accedere immediatamente a un paio completo di calzini anche in un brutto lunedì mattina ... ;-)

Spero di poter contribuire con qualcosa di nuovo a questo problema. Ho notato che tutte le risposte trascurano il fatto che ci sono due punti in cui è possibile eseguire la preelaborazione , senza rallentare le prestazioni generali del bucato.

Inoltre, non abbiamo bisogno di assumere un gran numero di calze, anche per le famiglie numerose. Le calze vengono estratte dal cassetto e vengono indossate, quindi vengono gettate in un posto (forse un bidone) dove rimangono prima di essere lavate. Anche se non chiamerei detto bin uno stack LIFO, direi che è sicuro supporre che

1. la gente butta entrambe le calze all'incirca nella stessa area del cestino,
2. il cestino non è randomizzato in nessun punto e quindi
3. qualsiasi sottoinsieme prelevato dalla parte superiore di questo cestino generalmente contiene entrambi i calzini di una coppia.

Poiché tutte le lavatrici che conosco hanno dimensioni limitate (indipendentemente dal numero di calzini che devi lavare) e l'effettiva randomizzazione si verifica in lavatrice, indipendentemente dal numero di calzini che abbiamo, abbiamo sempre piccoli sottogruppi che contengono quasi single.

Le nostre due fasi di preelaborazione sono "mettere le calze sul filo del bucato" e "Prendere le calze dal filo del bucato", che dobbiamo fare per ottenere calzini non solo puliti ma anche asciutti. Come per le lavatrici, i fili per il bucato sono limitati e presumo che abbiamo l'intera parte della linea in cui mettiamo in vista le nostre calze.

Ecco l'algoritmo per put_socks_on_line ():

while (socks left in basket) {
 take_sock();
 if (cluster of similar socks is present) { 
   Add sock to cluster (if possible, next to the matching pair)
 } else {
  Hang it somewhere on the line, this is now a new cluster of similar-looking socks.      
  Leave enough space around this sock to add other socks later on 
 }
}

Non perdere tempo spostando i calzini o cercando la migliore corrispondenza, tutto ciò dovrebbe essere fatto in O (n), che avremmo anche bisogno di metterli sulla linea non ordinata. I calzini non sono ancora accoppiati, abbiamo solo diversi cluster di somiglianza sulla linea. È utile disporre di un numero limitato di calze qui, poiché ciò ci aiuta a creare cluster "buoni" (ad esempio, se nel set di calze ci sono solo calze nere, il raggruppamento per colore non sarebbe la strada da percorrere)

Ecco l'algoritmo per take_socks_from_line ():

while(socks left on line) {
 take_next_sock();
 if (matching pair visible on line or in basket) {
   Take it as well, pair 'em and put 'em away
 } else {
   put the sock in the basket
 }

Devo sottolineare che, al fine di migliorare la velocità dei passaggi rimanenti, è saggio non scegliere casualmente la calza successiva, ma prendere sequenzialmente calza dopo calza da ciascun cluster. Entrambe le fasi di preelaborazione non richiedono più tempo del semplice mettere le calze sulla linea o nel cestino, cosa che non dobbiamo fare in alcun modo, quindi questo dovrebbe migliorare notevolmente le prestazioni del bucato.

Dopodiché, è facile eseguire l'algoritmo di partizionamento hash. Di solito, circa il 75% delle calze è già accoppiato, lasciandomi con un piccolo sottoinsieme di calze, e questo sottoinsieme è già (un po ') raggruppato (non introduco molta entropia nel mio cestino dopo le fasi di preelaborazione). Un'altra cosa è che i cluster rimanenti tendono ad essere abbastanza piccoli da essere gestiti immediatamente, quindi è possibile estrarre un intero cluster dal cestino.

Ecco l'algoritmo per sort_remaining_clusters ():

while(clusters present in basket) {
  Take out the cluster and spread it
  Process it immediately
  Leave remaining socks where they are
}

Dopodiché, sono rimasti solo alcuni calzini. È qui che introduco nel sistema calze precedentemente non accoppiate ed elaboro le calze rimanenti senza alcun algoritmo speciale: le calze rimanenti sono pochissime e possono essere elaborate visivamente molto velocemente.

Per tutte le calze rimanenti, presumo che le loro controparti siano ancora non lavate e le metto via per la prossima iterazione. Se si registra una crescita di calzini non accoppiati nel tempo (una "perdita di calzino"), è necessario controllare il cestino: potrebbe essere randomizzato (ci sono gatti che dormono lì?)

So che questi algoritmi prendono molte ipotesi: un cestino che funge da una sorta di pila LIFO, una lavatrice normale limitata e una stendibiancheria limitata e normale - ma questo funziona ancora con un numero molto elevato di calze.

Informazioni sul parallelismo: finché lanci entrambe le calze nello stesso cestino, puoi facilmente parallelizzare tutti questi passaggi.

Ho adottato semplici misure per ridurre i miei sforzi in un processo che richiede tempo O (1).

Riducendo i miei input a uno dei due tipi di calzini (calzini bianchi per la ricreazione, calzini neri per il lavoro), ho solo bisogno di determinare quale dei due calzini ho in mano. (Tecnicamente, dal momento che non vengono mai lavati insieme, ho ridotto il processo a O (0).)

È necessario un certo sforzo iniziale per trovare calze desiderabili e acquistare in quantità sufficiente da eliminare la necessità delle calze esistenti. Dato che l'avevo fatto prima del mio bisogno di calze nere, il mio sforzo era minimo, ma il chilometraggio poteva variare.

Un tale sforzo iniziale è stato visto molte volte in un codice molto popolare ed efficace. Gli esempi includono # DEFINE 'pi in diversi decimali (esistono altri esempi, ma quello è quello che viene in mente in questo momento).

Crea una tabella hash che verrà utilizzata per calze senza eguali, usando il modello come hash. Scorri i calzini uno per uno. Se la calza ha una corrispondenza del modello nella tabella hash, togli la calza dal tavolo e creane una coppia. Se la calza non ha una corrispondenza, inseriscila nel tavolo.

Il problema di ordinare le tue n paia di calze è O (n) . Prima di gettarli nel cesto della biancheria , infilare quello sinistro a quello destro. Quando li togli, tagli il filo e metti ogni coppia nel tuo cassetto - 2 operazioni su n coppie, quindi O (n).

Ora la domanda successiva è semplicemente se fai il bucato e tua moglie fa la sua. Questo è un problema probabilmente in un dominio completamente diverso di problemi . :)