Comme l'architecture du cerveau humain est complètement différente d'un processeur moderne, cette question n'a aucun sens pratique.

Les humains peuvent gagner des algorithmes CPU en utilisant le fait que "trouver une paire correspondante" peut être une opération pour un ensemble qui n'est pas trop grand.

Mon algorithme:

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);
}

, Au moins c'est ce que j'utilise dans la vraie vie, et je le trouve très efficace. L'inconvénient est qu'il nécessite une surface plane, mais il est généralement abondante.

Cas 1 - : Toutes les chaussettes sont identiques (c'est ce que je fais dans la vraie vie, par la voie).

Choisissez deux d'entre eux pour faire une paire. La constante de temps.

Cas 2: Il y a un nombre constant de combinaisons (propriété, Couleur, Taille, texture, etc.).

Utiliser radix tri. C'est un temps linéaire car la comparaison n'est pas nécessaire.

Cas 3 : le nombre de combinaisons n'est pas connu à l'avance (cas général).

Nous devons faire comparaison pour vérifier si deux chaussettes viennent en paire. Choisissez l'un des algorithmes de tri basés sur la comparaison O(n log n).

Cependant, dans la vie réelle, lorsque le nombre de chaussettes est relativement faible (constant), ces algorithmes théoriquement optimaux ne fonctionneraient pas bien. Cela pourrait prendre encore plus de temps que la recherche séquentielle, qui nécessite théoriquement un temps quadratique.

Non-algorithmique réponse, mais "efficace" quand je le fais:

• Étape 1) jetez toutes vos chaussettes existantes

• Étape 2) Allez à Walmart {[14] } et achetez-les par paquets de 10-n Paquet de blanc et m paquets de noir. Pas besoin d'autres couleurs dans tous les jours vie.

Pourtant, de temps en temps, je dois le faire à nouveau (chaussettes Perdues, chaussettes endommagées, etc.), et je déteste jeter les chaussettes parfaitement bonnes trop souvent (et je souhaitais qu'ils continuent à vendre le même référence de chaussettes!), donc j'ai récemment adopté une approche différente.

Réponse algorithmique:

Considérer que si vous dessinez une seule chaussette pour la deuxième pile de chaussettes, comme vous le faites, vos chances de trouver la chaussette correspondant à un naïf recherche est très faible.

• alors prenez-en cinq au hasard, et mémorisez leur forme ou leur longueur.

Pourquoi cinq? Habituellement les humains sont bons se souviennent entre cinq et sept éléments différents dans le travail mémoire - un peu comme l'équivalent humain d'un RPN pile - cinq est une sécurité par défaut.

• Prenez - en un de la pile de 2n-5.

• Maintenant, cherchez une correspondance (correspondance de modèle visuel - les humains sont bons à cela avec une petite pile) à l'intérieur des cinq que vous avez dessinés, si vous n'en trouvez pas, ajoutez-le à vos cinq.

• Gardez au hasard choisir des chaussettes de la pile et comparer à vos chaussettes 5+1 pour un match. Comme votre pile se développe, il permettra de réduire votre la performance mais augmenter vos chances. Beaucoup plus rapide.

N'hésitez pas à écrire la formule pour calculer le nombre d'échantillons que vous devez tirer pour une chance de 50% d'un match. IIRC c'est une loi hypergéométrique.

Je le fais tous les matins et j'ai rarement besoin de plus de trois tirages - mais j'ai des n paires similaires (environ 10, à donner ou à prendre les perdues) de chaussettes blanches en forme de m. Maintenant, vous pouvez estimer la taille de ma pile de stocks :-)

BTW, j'ai trouvé que la somme de la les coûts de transaction du tri de toutes les chaussettes chaque fois que j'avais besoin d'une paire étaient beaucoup moins que de le faire une fois et de lier les chaussettes. Un juste-à-temps fonctionne mieux parce qu'alors vous n'avez pas à lier les chaussettes, et il y a aussi un rendement marginal décroissant (c'est-à-dire que vous continuez à chercher ces deux ou trois chaussettes que quand quelque part dans la lessive et que vous devez finir d'assortir vos chaussettes et vous perdez du temps là-dessus).

Ce que je fais, c'est que je prends la première chaussette et la pose (disons, sur le bord du bol à linge). Ensuite, je prends une autre chaussette et vérifie si c'est la même chose que la première chaussette. Si c'est le cas, je les enlève tous les deux. Si ce n'est pas le cas, je le pose à côté de la première chaussette. Ensuite, je prends la troisième chaussette et compare cela aux deux premières (si elles sont toujours là). Etc.

Cette approche peut être assez facilement implémentée dans un tableau, en supposant que" supprimer " les chaussettes est une option. En fait, vous n'avez même pas besoin d'enlever les chaussettes. Si vous n'avez pas besoin de trier les chaussettes (voir ci-dessous), vous pouvez simplement les déplacer et vous retrouver avec un tableau qui a toutes les chaussettes disposées par paires dans le tableau.

En supposant que la seule opération pour socks est de comparer pour l'égalité, cet algorithme est fondamentalement toujours un n² algorithme, bien que je ne connaisse pas le cas moyen (jamais appris à calculer cela).

Tri, bien sûr améliore l'efficacité, en particulier dans la vraie vie, où vous pouvez facilement insérer une chaussette entre deux autres chaussettes. Dans le calcul, La même chose pourrait être réalisée par un arbre, mais c'est un espace supplémentaire. Et, bien sûr, nous sommes de retour à NlogN (ou un peu plus, s'il y a plusieurs chaussettes qui sont les mêmes par critères de tri, mais pas de la même paire).

Autre que cela, je ne peux penser à rien, mais cette méthode semble être assez efficace dans la vie réelle. :)

Cela pose la mauvaise question. La bonne question à poser est, pourquoi je passe du temps à trier les chaussettes? Combien cela coûte-t-il sur une base annuelle, lorsque vous évaluez votre temps libre pour X unités monétaires de votre choix?

Et le plus souvent, ce n'est pas seulement Tout temps libre, c'est le matin temps libre, que vous pourriez passer au lit, ou siroter votre café, ou partir un peu tôt et ne pas être pris dans la circulation.

, Il est souvent bon de prendre du recul, et penser un moyen de contourner le problème.

Et il y a un moyen!

Trouve une chaussette que tu aimes. Prendre en compte toutes les caractéristiques pertinentes: la couleur dans différentes conditions d'éclairage, la qualité globale et la durabilité, le confort dans différentes conditions climatiques et l'absorption des odeurs. Il est également important, ils ne devraient pas perdre leur élasticité dans le stockage, de sorte que les tissus naturels sont bons, et ils devraient être disponibles dans un emballage en plastique.

C'est mieux s'il n'y a pas de différence entre le pied gauche et le pied droit chaussettes, mais ce n'est pas essentiel. Si les chaussettes sont symétriques Gauche-Droite, trouver une paire est une opération O(1), et trier les chaussettes est une opération approximative O(M), où M est le nombre de places dans votre maison, que vous avez jonchées de chaussettes, idéalement un petit nombre constant.

Si vous avez choisi une paire de fantaisie avec une chaussette gauche et droite différente, faire un tri de seau complet pour les seaux de pied gauche et droit prendre O (N + M), où N est le nombre de chaussettes et M est le même que ci-dessus. Quelqu'un d'autre peut donner l' la formule pour les itérations moyennes de trouver la première paire, mais le pire des cas pour trouver une paire avec recherche aveugle est N / 2 + 1, ce qui devient astronomiquement improbable pour un N. raisonnable. cela peut être accéléré en utilisant des algorithmes de reconnaissance d'image avancés et des heuristiques, lors de la numérisation de la pile de chaussettes non triées avec Mk1 Eyeball .

Ainsi, un algorithme pour atteindre L'efficacité d'appariement de chaussette O(1) (en supposant une chaussette symétrique) est:

1. Vous devez estimer combien de paires de chaussettes dont vous aurez besoin pour le reste de votre vie, ou peut-être jusqu'à votre retraite et de passer à des climats plus chauds, sans avoir besoin de porter des chaussettes plus jamais. Si vous êtes jeune, vous pouvez également estimer combien de temps il faut avant que nous aurons tous des robots de tri des chaussettes dans nos maisons, et tout le problème devient hors de propos.

2. Vous devez savoir comment vous pouvez commander votre chaussette sélectionnée en vrac, et combien cela coûte, et livrent-ils.

3. Commandez le chaussettes!

4. Débarrassez-vous de vos vieilles chaussettes.

Une autre étape 3 impliquerait de comparer les coûts d'achat de la même quantité de chaussettes peut-être moins chères quelques paires à la fois au fil des ans et d'ajouter le coût de tri des chaussettes, mais croyez-moi: acheter en vrac est moins cher! En outre, les chaussettes dans le stockage augmentent en valeur au taux d'inflation des prix des actions, ce qui est plus que ce que vous obtiendriez sur de nombreux investissements. Là encore, il y a aussi le coût de stockage, mais les chaussettes vraiment ne prenez pas beaucoup d'espace sur l'étagère supérieure d'un placard.

Problème résolu. Alors, il suffit d'obtenir de nouvelles chaussettes, jeter / donner vos anciens loin, et vivre heureux pour toujours sachant que vous économisez de l'argent et du temps tous les jours pour le reste de votre vie.

La limite théorique est O (n) car vous devez toucher chaque chaussette (à moins que certaines soient déjà appariées d'une manière ou d'une autre).

Vous pouvez obtenir des O(n) avec radix tri. Vous avez juste besoin de choisir quelques attributs pour les seaux.

1. Vous pouvez d'abord choisir (le sien, le mien) - les diviser en 2 piles,
2. ensuite, utilisez des couleurs ( peut avoir n'importe quel ordre pour les couleurs, par exemple par ordre alphabétique par nom de couleur) - divisez-les en piles par couleur (n'oubliez pas de garder l'ordre initial de l'étape 1 pour tous chaussettes dans la même pile),
3. puis longueur de la chaussette,
4. puis texture, ....

Si vous pouvez choisir un nombre limité d'attributs, mais assez d'attributs qui peuvent identifier de manière unique chaque paire, vous devriez être fait dans O(k * n), qui est O(n) si nous pouvons considérer k est limité.

Comme une solution pratique:

1. faites rapidement des tas de chaussettes facilement distinguables. (Disons par couleur)
2. Quicksort chaque pile et utiliser la longueur de la chaussette pour la comparaison. En tant qu'humain, vous pouvez prendre une décision assez rapide quelle chaussette utiliser pour partitionner qui évite le pire des cas. (Vous pouvez voir plusieurs chaussettes en parallèle, l'utiliser à votre avantage!)
3. arrêtez de trier les piles quand elles ont atteint un seuil auquel vous êtes à l'aise pour trouver des paires de points et des chaussettes impairables instantanément

Si vous avez 1000 chaussettes, avec 8 couleurs et une distribution moyenne, vous pouvez faire 4 piles de chaque 125 chaussettes en temps c * n. Avec un seuil de 5 chaussettes, vous pouvez trier chaque pile en 6 courses. (Compter 2 secondes pour lancer une chaussette sur la pile droite, cela vous prendra un peu moins de 4 heures.)

Si vous n'avez que 60 chaussettes, 3 couleurs et 2 sortes de chaussettes (la vôtre / celle de votre femme), vous pouvez trier chaque pile de 10 chaussettes en 1 courses ( encore une fois seuil = 5). (Compter 2 secondes, il vous faudra 2 min).

Le tri de seau initial accélérera votre processus, car il divise vos N chaussettes en K seaux dans c*n Temps de sorte que vous n'aurez qu'à faire c*n*log(k) travail. (En ne prenant pas en compte le seuil). Donc dans tout ce que vous faites à propos de n*c*(1 + log(k)), où c est le temps de jeter une chaussette sur une pile.

Cette approche sera favorable par rapport à tout c*x*n + O(1) méthode à peu près aussi longtemps que log(k) < x - 1.

En informatique cela peut être utile: Nous avons une collection de n choses, un ordre (longueur) et aussi une relation d'équivalence (des informations supplémentaires, par exemple la couleur des chaussettes). La relation d'équivalence nous permet de faire une partition de la collection d'origine, et dans chaque classe d'équivalence notre ordre est toujours maintenu. Le mappage d'une chose à sa classe d'équivalence peut être fait dans O (1), donc seul O(n) est nécessaire pour assigner chaque élément à une classe. Maintenant, nous avons utilisé nos Informations supplémentaires et pouvons procéder de toute manière pour trier chaque classe. L'avantage est que les ensembles de données sont déjà nettement plus petits.

La méthode peut également être imbriquée, si nous avons plusieurs relations d'équivalence - > faire des piles de couleur, que dans chaque partition de pile sur la texture, que trier sur la longueur. Toute relation d'équivalence qui crée une partition avec plus de 2 éléments qui ont une taille à peu près égale apportera une amélioration de la vitesse de tri (à condition que nous puissions assigner directement une chaussette à sa pile), et le tri peut se produire très rapidement sur ensembles de données plus petits.

Cette question Est en fait profondément philosophique. Au fond, il s'agit de savoir si le pouvoir des gens à résoudre des problèmes (le "wetware" de notre cerveau) est équivalent à ce qui peut être accompli par des algorithmes.

Un algorithme évident pour le tri des chaussettes est:

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

Maintenant, l'informatique dans ce problème est tout au sujet des étapes

1. "si s paires avec une chaussette t dans N". À quelle vitesse pouvons-nous "se souvenir" de ce que nous avons vu jusqu'à présent?
2. "supprimer t de N" et "ajouter s à N". Combien coûte le suivi de ce que nous avons vu jusqu'à présent?

Les êtres humains utiliseront diverses stratégies pour les réaliser. la mémoire humaine est associative , quelque chose comme une table de hachage où les ensembles d'entités de valeurs stockées sont associés aux valeurs correspondantes elles-mêmes. Par exemple, le concept de "voiture rouge" correspond à toutes les voitures rouges dont une personne est capable de se souvenir. Quelqu'un avec une mémoire parfaite a une cartographie parfaite. La plupart des gens sont imparfaits à cet égard (et la plupart des autres). La carte associative a une capacité limitée. Les mappages peuvent bip hors d'existence dans diverses circonstances (une bière de trop), être enregistrés par erreur(" je pensais que son nom était Betty, pas Nettie"), ou ne jamais être écrasés même si nous observons que la vérité a changé ("dad's car" évoque "Orange Firebird" quand nous savions qu'il avait échangé cela contre la Camaro rouge).

Dans le cas des chaussettes, un rappel parfait signifie regarder une chaussette s produit toujours la mémoire de son frère t, y compris suffisamment d'informations (où il est sur la planche à repasser) pour localiser t en temps constant. Une personne avec une mémoire photographique accomplit à la fois 1 et 2 en temps constant sans faute.

Quelqu'un avec une mémoire moins que parfaite pourrait utiliser quelques classes d'équivalence de bon sens basées sur des fonctionnalités dans sa capacité à suivre: taille (papa, Maman, Bébé), couleur (verdâtre, rougeâtre, etc.), le motif (argyle, plaine, etc.), style (footie, genou-haut, etc.). De sorte que le fer à repasser serait divisé en sections pour les catégories. Cela permet généralement à la catégorie d'être située en temps constant par la mémoire, mais une recherche linéaire à travers la catégorie "seau" est nécessaire.

Quelqu'un sans mémoire ou imagination du tout (désolé) va juste garder les chaussettes dans une pile et faire une recherche linéaire de la pile entière.

Un monstre soigné peut utiliser des étiquettes numériques pour les paires comme quelqu'un l'a suggéré. Cela ouvre la porte à une commande totale, ce qui permet à l'humain de utilisez exactement les mêmes algorithmes que nous pourrions avec un CPU: recherche binaire, arbres,hachages, etc.

Donc, le "meilleur" algorithme dépend des qualités du wetware / matériel / logiciel qui l'exécute et de notre volonté de" tricher " en imposant un ordre total sur les paires. Certes, un "meilleur" meta -algorithme est d'embaucher le meilleur sock-sorter du monde: une personne ou une machine qui peut acquérir et stocker rapidement un énorme ensemble N d'ensembles d'attributs de chaussette dans une mémoire associative 1-1 avec une recherche en temps constant, d'insertion et de suppression. Les gens et les machines comme celui-ci peuvent être achetés. Si vous en avez un, vous pouvez coupler toutes les chaussettes en temps O (N) pour n paires, ce qui est optimal. Les balises total order vous permettent d'utiliser le hachage standard pour obtenir le même résultat avec un ordinateur humain ou matériel.

Vous essayez de résoudre le mauvais problème.

Solution 1: {[2] } chaque fois que vous mettez des chaussettes sales dans votre panier à linge, attachez-les dans un petit noeud. De cette façon, vous n'aurez pas à faire de tri après le lavage. Pensez-y comme enregistrer un index dans une base de données Mongo. Un peu de travail à venir pour des économies de PROCESSEUR à l'avenir.

Solution 2: Si c'est l'hiver, vous n'avez pas à porter des chaussettes de correspondance. Nous sommes des programmeurs. Personne ne doit savoir, tant qu'il travail.

Solution 3: répartir le travail. Vous souhaitez effectuer un processus CPU aussi complexe de manière asynchrone, sans bloquer l'interface utilisateur. Prends ce tas de chaussettes et mets-les dans un sac. Cherchez seulement une paire quand vous en avez besoin. De cette façon, la quantité de travail qu'il faut est beaucoup moins perceptible.

J'espère que cela aide!

Voici une limite inférieure Omega(n log n) dans le modèle basé sur la comparaison. (La seule opération valide est de comparer deux chaussettes.)

Supposons que vous sachiez que vos chaussettes 2n sont arrangées de cette façon:

P₁ p₂ p₃ ... p_n p_{, f(1)} p_f(2) ... p_f(n)

Où f est une permutation inconnue de l'ensemble {1,2,...,et}. Sachant cela ne peut pas rendre le problème plus difficile. Il y a n! sorties possibles (matchings entre first et deuxième moitié), ce qui signifie que vous avez besoin de log (n!) = Omega (n Log n) comparaisons. Ceci peut être obtenu par Tri.

Puisque vous êtes intéressé par les connexions au problème de distinction d'élément: prouver L'Omega (n log n) lié à la distinction d'élément est plus difficile, car la sortie est binaire oui / non. Ici, la sortie doit être une correspondance et le nombre de sorties possibles suffit pour obtenir une limite décente. Cependant, il existe une variante liée à la distinction des éléments. Supposons qu'on vous donne des chaussettes 2n et je me demande s'ils peuvent être jumelés de manière unique. Vous pouvez obtenir une réduction de ED par l'envoi d' (un₁, un₂, ... un_n) (a₁, un₁, un₂, un₂, ... un_n, un_n). (Entre parenthèses, la preuve de la dureté de L'ED est très intéressante, via la topologie .)

Je pense qu'il devrait y avoir un Omega (n²) lié au problème d'origine si vous n'autorisez que les tests d'égalité. Mon intuition est: considérez un graphique où vous ajoutez un edge après un test, et soutiennent que si le graphique n'est pas dense, la sortie n'est pas déterminée de manière unique.

Coût: Chaussettes mobiles - > haut, trouver / rechercher des chaussettes en ligne - > petit

Ce que nous voulons faire est de réduire le nombre de déplacements, et de compenser avec le nombre de recherches. En outre, nous pouvons utiliser l'environnement multithreded de L'Homo Sapiens pour contenir plus de choses dans le cache descision.

X = le vôtre, Y = vos conjoints

De la pile A de toutes les chaussettes:

Choisissez deux chaussettes, placez la chaussette X correspondante dans la ligne X et la chaussette Y dans la ligne Y à la prochaine position disponible.

Ne jusqu'à ce que A soit vide.

Pour chaque ligne X et Y

1. Choisissez la première chaussette en ligne, recherchez le long de la ligne jusqu'à ce qu'elle trouve la chaussette correspondante.

2. Mettre dans la ligne finale correspondante de chaussettes.

3. facultatif pendant que vous recherchez la ligne et que la chaussette actuelle que vous regardez est identique à la précédente, faites l'étape 2 pour ces chaussettes.

Éventuellement à la première étape, vous prenez deux chaussettes de cette ligne à la place de deux, comme la mémoire de mise en cache est assez grande, nous pouvons rapidement identifier si l'une ou l'autre chaussette correspond à celle en cours sur la ligne que vous observez. Si vous avez la chance d'avoir trois bras, vous pouvez éventuellement analyser trois chaussettes en même temps étant donné que la mémoire du sujet est assez grande.

Faites Jusqu'à ce que X et Y soient vides.

Terminé

Cependant, comme cela a une complexité similaire à celle du tri de sélection, le temps pris est beaucoup moins dû aux vitesses d'E / S(chaussettes mobiles) et recherche(recherche d'une chaussette dans la ligne).

C'est comment je fais, pour p paires de chaussettes (n = 2p individuels chaussettes):

• Prenez une chaussette au hasard de la pioche.
• pour la première chaussette, ou si toutes les chaussettes précédemment choisies ont été jumelées, placez simplement la chaussette dans la première " fente "d'un" tableau " de chaussettes non appariées devant vous.
• Si vous avez une ou plusieurs chaussettes non appariées sélectionnées, vérifiez votre chaussette actuelle par rapport à toutes les chaussettes non appariées du tableau.
  • Il est possible de séparez les chaussettes en classes ou types généraux (blanc/noir, cheville/équipage, athlétique/robe) lors de la construction de votre tableau, et "drill-down" pour comparer seulement comme-pour-comme.
  • Si vous trouvez une correspondance acceptable, mettez les deux chaussettes ensemble et retirez - les du tableau.
  • Si vous ne le faites pas, placez la chaussette actuelle dans la première fente ouverte du tableau.
• répétez avec chaque chaussette.

Le pire scénario de ce schéma est que chaque paire de chaussettes est assez différente qu'il doit correspondre exactement, et que le premier n/2 chaussettes que vous choisissez sont tous différents. C'est votre O(n²) scénario, et c'est extrêmement improbable. Si le nombre de types uniques de chaussettes t est inférieur au nombre de paires p = N / 2 , et que les chaussettes de chaque type sont suffisamment semblables (généralement en termes d'usure) pour que n'importe quelle chaussette de ce type puisse être jumelée avec n'importe quelle autre, alors comme je l'ai déduit ci-dessus, le nombre pour comparer à l'est t, après quoi le prochain vous tirez sera correspondre à l'un des dissociée des chaussettes. Ce scénario est beaucoup plus probable dans le tiroir à chaussettes moyen que dans le pire des cas, et réduit la complexité du pire des cas à O(n*t) où généralement t .

Approche du monde réel:

Aussi rapidement que possible, retirez les chaussettes de la pile non triée une à la fois et placez-les en piles devant vous. Les piles doivent être disposées un peu de manière efficace dans l'espace, avec toutes les chaussettes pointant dans la même direction; le nombre de piles est limité par la distance que vous pouvez facilement atteindre. La sélection d'une pile sur laquelle mettre une chaussette devrait être-aussi rapidement que possible - en mettant une chaussette sur une pile de chaussettes apparemment semblables; le type occasionnel I (mettre une chaussette sur une pile à laquelle elle n'appartient pas) ou de type II (mettre une chaussette dans sa propre pile quand il y a une pile existante de chaussettes similaires) l'erreur peut être tolérée - la considération la plus importante est speed . Une fois que toutes les chaussettes sont en piles, Passez rapidement par les piles multi-chaussettes en créant des paires et en les enlevant (celles-ci se dirigent vers le tiroir). S'il y a des chaussettes non assorties dans la pile, empilez-les à leur meilleur (dans la contrainte aussi rapide que possible) pile. Lorsque toutes les piles multi-chaussettes ont été traité, faites correspondre les chaussettes paiables restantes qui n'ont pas été appariées en raison d'erreurs de type II. Whoosh, vous avez terminé-et j'ai beaucoup de chaussettes et ne les lavez pas jusqu'à ce qu'une grande partie soit sale. Une autre note pratique: je retourne le haut d'une paire de chaussettes vers le bas sur l'autre, en profitant de leurs propriétés élastiques, de sorte qu'ils restent ensemble tout en étant transporté dans le tiroir et dans le tiroir.

De votre question, il est clair que vous n'avez pas beaucoup d'expérience réelle avec la lessive :). Vous avez besoin d'un algorithme qui fonctionne bien avec un petit nombre de chaussettes non paiables.

Les réponses jusqu'à présent ne font pas bon usage de nos capacités de reconnaissance de formes humaines. Le jeu de Set fournit un indice de la façon de bien le faire: mettez toutes les chaussettes dans un espace bidimensionnel afin que vous puissiez les reconnaître et les atteindre facilement avec vos mains. Cela vous limite à une surface d'environ 120 * 80 cm ou si. De là, sélectionnez les paires que vous reconnaissez et supprimez-les. Mettre des chaussettes dans l'espace libre et répétez. Si vous lavez pour les personnes avec des chaussettes facilement reconnaissables (les petits enfants viennent à l'Esprit), vous pouvez faire un tri radix en sélectionnant d'abord ces chaussettes. Cet algorithme fonctionne bien que lorsque le nombre de chaussettes est faible

Prenez une première chaussette et placez-la sur une table. Maintenant, choisissez une autre chaussette; si elle correspond à la première cueillie, placez-la sur le dessus de la première. Sinon, placez - le sur la table à une petite distance du premier. Choisissez une troisième chaussette; si elle correspond à l'une des deux précédentes, placez-la sur elles ou bien placez-la à une petite distance de la troisième. Répétez jusqu'à ce que vous avez ramassé toutes les chaussettes.

Pour dire à quel point il est efficace de coupler des chaussettes à partir d'une pile, nous devons d'abord définir la machine, car l'appariement ne se fait pas que ce soit par un turing ou par une machine à accès aléatoire, qui sont normalement utilisés comme base pour une analyse algorithmique.

La machine

La machine est une abstraction d'un élément du monde réel appelé être humain. Il est capable de lire de l'environnement grâce à une paire d'yeux. Et notre modèle de machine est capable de manipuler l'environnement par en utilisant 2 bras. Les opérations logiques et arithmétiques sont calculées en utilisant notre cerveau (espérons-le; -)).

Nous devons aussi considérer le temps d'exécution intrinsèque des opérations atomiques qui peuvent être effectuées avec ces instruments. En raison de contraintes physiques, les opérations qui sont effectuées par un bras ou un œil ont une complexité temporelle non constante. C'est parce que nous ne pouvons pas déplacer un tas sans fin de chaussettes avec un bras ni un œil ne peut voir la chaussette supérieure sur un tas sans fin de chaussette.

Cependant, la physique mécanique nous donne aussi quelques goodies. Nous ne sommes pas limités à déplacer au plus une chaussette avec un bras. Nous pouvons nous déplacer tout un couple d'entre eux à la fois.

Donc, en fonction de l'analyse précédente, les opérations suivantes doivent être utilisés dans l'ordre décroissant:

• opérations logiques et arithmétiques
• lectures environnementales
• modifications environnementales

Nous pouvons également utiliser le fait que les gens n'ont qu'un quantité limitée de chaussettes. Donc, une modification de l'environnement peut impliquer toutes les chaussettes dans le tas.

, L'algorithme

Voici donc ma suggestion:

1. étaler toutes les chaussettes dans la pile sur le sol.
2. trouvez une paire en regardant les chaussettes sur le sol.
3. répétez à partir de 2 jusqu'à ce qu'aucune paire ne puisse être faite.
4. répétez de 1 jusqu'à ce qu'il n'y ait pas de chaussettes sur le sol.

Opération 4 est nécessaire, parce que lors de la propagation des chaussettes sur le sol certains les chaussettes peuvent cacher les autres. Voici l'analyse de l'algorithme:

L'analyse

L'algorithme se termine avec une forte probabilité. Cela est dû au fait que l'on est incapable de trouver des paires de chaussettes à l'étape numéro 2.

Pour l'analyse suivante de l'appariement des paires de chaussettes n, nous supposons qu'au moins la moitié des chaussettes 2n ne sont pas masquées après l'étape 1. Donc, dans le cas Moyen, nous pouvons trouver des paires n/2. Cela signifie que la boucle est l'étape 4 est exécutée O(log n) fois. L'étape 2 est exécutée O(n^2) fois. Nous pouvons donc conclure:

• l'algorithme implique O(ln n + n) modifications environnementales (étape 1 {[6] } Plus la cueillette de chaque paire de chaussette du sol)
• l'algorithme implique O(n^2) lectures environnementales de l'étape 2
• l'algorithme implique O(n^2) des opérations logiques et arithmétiques pour comparer une chaussette avec une autre à l'étape 2

Nous avons Donc un total d'exécution de la complexité de O(r*n^2 + w*(ln n + n)) où r et w sont les facteurs pour les opérations environnementales de lecture et d'écriture environnementales respectivement pour une quantité raisonnable de chaussettes. Le coût des opérations logiques et arithmétiques est omis, car nous supposons qu'il faut une quantité constante d'opérations logiques et arithmétiques pour décider si 2 chaussettes appartiennent à la même paire. Cela peut ne pas être réalisable dans tous les scénarios.

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);
  }
}

Je suis sorti avec une autre solution qui ne promettait pas moins d'opérations, ni moins de consommation de temps, mais il faut essayer de voir si elle peut être une heuristique assez bonne pour fournir moins de consommation de temps dans d'énormes séries d'appariement de chaussettes.

Conditions Préalables: Il n'y a aucune garantie qu'il y a même des chaussettes. Si ils sont de la même couleur, cela ne signifie pas qu'ils ont la même taille ou de modèle. Les chaussettes sont mélangées au hasard. Il peut y avoir un nombre impair de chaussettes (certaines sont manquantes, nous ne savons pas combien). Préparez-vous à mémoriser une variable "index" et définissez-la sur 0.

Le résultat ont un ou deux piles: 1. "apparié" et 2. "manquant"

Heuristique:

1. trouvez la chaussette la plus distinctive.
2. trouve sa correspondance.
3. S'il n'y a pas de correspondance, mettez-la sur la pile "manquante".
4. répéter à partir de 1. jusqu'à ce qu'il n'y ait plus de chaussettes les plus distinctives.
5. S'il y a moins de 6 chaussettes, allez à 11.
6. associez aveuglément toutes les chaussettes à son voisin (ne l'emballez pas)
7. Trouvez toutes les paires appariées, emballez-les et déplacez les paires emballées sur la pile" appariée"; S'il n'y avait pas de nouvelles correspondances-incrémenter "index" de 1
8. Si "index" est supérieur à 2 (cela pourrait dépendre de la valeur de sock nombre parce qu'avec un plus grand nombre de chaussettes il y a moins de chance de associez-les aveuglément) aller à 11
9. mélangez le reste
10. aller à 1
11. oubliez "index"
12. choisissez un chaussette
13. Trouver sa paire
14. S'il n'y a pas de paire pour la chaussette, déplacez - la sur la pile "manquante"
15. Si match trouvé paire il, Pack paire et le déplacer à la" apparié " pile
16. S'il y en a encore plus, alors une chaussettes passe à 12
17. S'il n'en reste qu'un, passez à 14
18. Sourire satisfait :)

En outre, il pourrait être ajouté vérifier les chaussettes endommagées aussi, comme si la suppression de ceux-ci. Il pourrait être inséré entre 2 et 3, et entre 13 et 14.

Je suis impatient d'entendre parler de toute expérience ou correction.

Les chaussettes, qu'elles soient réelles ou une structure de données analogue, seraient fournies par paires.

La réponse la plus simple est avant de permettre à la paire d'être séparée, une structure de données unique pour la paire aurait dû être initialisée qui contenait un pointeur vers la chaussette gauche et droite, permettant ainsi aux chaussettes d'être référencées directement ou via leur paire. Une chaussette peut également être étendu pour contenir un pointeur vers son partenaire.

Cela résout tout problème d'appariement de calcul en le supprimant avec une couche d'abstraction.

En appliquant la même idée au problème pratique de l'appariement des chaussettes, la réponse apparente est: Ne laissez jamais vos chaussettes être non appariées. Les chaussettes sont fournies en paire, mises dans le tiroir en paire (peut - être en les ballant ensemble), portées en paire. Mais le point où unpairing est possible est dans la rondelle, donc tout ce qui est nécessaire est un mécanisme physique qui permet aux chaussettes de rester ensemble et d'être lavées efficacement.

Il y a deux physique possibilités:

Pour un objet 'pair' qui garde un pointeur sur chaque chaussette, nous pourrions avoir un sac en tissu que nous utilisons pour garder les chaussettes ensemble. Cela semble être une surcharge massive.

Mais pour que chaque chaussette garde une référence à l'autre, il y a une solution soignée: un popper (ou un' snap button ' si vous êtes Américain), comme ceux-ci:

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

Alors tout ce que vous faites est de casser vos chaussettes ensemble juste après vous enlevez-les et mettez-les dans votre panier de lavage, et encore une fois vous avez supprimé le problème de devoir jumeler vos chaussettes avec une abstraction physique du concept de "paire".

Quand je trie des chaussettes, je fais un tri approximatif radix , en laissant tomber des chaussettes près d'autres chaussettes du même type de couleur/motif. Sauf dans le cas où je peux voir une correspondance exacte à/près de l'endroit où je suis sur le point de laisser tomber la chaussette, j'extrait la paire à ce moment-là.

Presque tous les autres algorithmes (y compris la réponse de notation supérieure par usr) trient, puis suppriment les paires. Je trouve que, en tant qu'humain, il est préférable de minimiser le nombre de chaussettes considérées en même temps.

Je pour ce faire:

1. choisir une chaussette distinctive (tout ce qui attire mon attention en premier dans la pile).
2. Commencer un tri de base à partir de cet emplacement conceptuel en tirant des chaussettes de la pile en fonction de la similitude avec celle-ci.
3. placez la nouvelle chaussette près de la pile actuelle, avec une distance basée sur sa différence. Si vous vous trouvez en mettant la chaussette sur une autre parce qu'elle est identique, formez la paire là-bas et retirez-les. Cela signifie que les comparaisons futures prennent moins d'efforts pour trouver le bon endroit.

Cela tire parti de la capacité humaine à faire une correspondance floue dans le temps O (1), ce qui équivaut quelque peu à l'établissement d'une carte de hachage sur un dispositif informatique.

En tirant d'abord les chaussettes distinctives, vous laissez de l'espace pour "zoomer" sur les caractéristiques qui sont moins distinctives, pour commencer.

Après avoir éliminé la couleur fluro, les chaussettes à rayures et les trois paires de chaussettes longues, vous pourriez vous retrouver avec la plupart du temps Blanc chaussettes grossièrement triées par la façon dont ils sont usés.

À un moment donné, les différences entre les chaussettes sont assez petites pour que d'autres personnes ne remarquent pas la différence, et aucun effort de correspondance supplémentaire n'est nécessaire.

Chaque fois que vous prenez une chaussette, mettez - la au même endroit. Alors la prochaine chaussette vous chercher, si il ne correspond pas à la première chaussette, la mettre à côté de la première. Si elle le fait, il y a une paire. De cette façon, peu importe combien de combinaisons il y a, et il n'y a que deux possibilités pour chaque chaussette que vous ramassez - soit il a une correspondance qui est déjà dans votre tableau de chaussettes, ou ce n'est pas le cas, ce qui signifie que vous l'ajoutez à un endroit dans le tableau.

Cela signifie également que vous aurez presque certainement jamais toutes vos chaussettes dans le tableau, parce que les chaussettes seront enlevés comme ils sont assortis.

Considérons une table de hachage de taille 'N'.

Si nous supposons une distribution normale, alors le nombre estimé d '"insertions" pour avoir au moins une chaussette mappée à un seau est NlogN (c'est-à-dire que tous les seaux sont pleins)

J'avais dérivé ceci comme une partie d'un autre puzzle, mais je serais heureux d'être prouvé faux. Voici mon article de blog sur le même

Let ' n ' correspond à une limite supérieure approximative sur le nombre de nombre de couleurs uniques / motif de chaussettes que vous avoir.

Une fois que vous avez une collision (aka : une correspondance), retirez simplement cette paire de chaussettes. Répétez la même expérience avec le prochain lot de chaussettes NlogN. La beauté de cela est que vous pourriez faire des comparaisons parallèles NlogN (résolution de collision) en raison de la façon dont l'esprit humain fonctionne. :-)

Si l'opération" move "est assez coûteuse, et que l'opération" compare " est bon marché, et que vous devez déplacer l'ensemble de toute façon, dans un tampon où la recherche est beaucoup plus rapide que dans le stockage d'origine... il suffit d'intégrer le tri dans le mouvement obligatoire.

J'ai trouvé que l'intégration du processus de tri dans la suspension pour sécher en fait un jeu d'enfant. J'ai besoin de ramasser chaque chaussette de toute façon, et l'accrocher (déplacer) et il m'en coûte rien pour l'accrocher dans un endroit spécifique sur les cordes. Maintenant il suffit de ne pas forcer recherche de l'ensemble du tampon (les chaînes) je choisis de placer des chaussettes par couleur / nuance. Plus sombre à gauche, plus lumineux à droite, plus coloré avant etc. Maintenant, avant d'accrocher chaque chaussette, je regarde dans son "bon voisinage" si un correspondant est déjà là-cela limite le "scan" à 2-3 autres chaussettes - et si c'est le cas, j'accroche l'autre juste à côté. Ensuite, je les roule en paires tout en les retirant des cordes, lorsqu'elles sont sèches.

Maintenant, cela peut ne pas sembler si différent de "former des piles par couleur" suggéré par top réponses mais d'abord, en ne choisissant pas des piles discrètes mais des plages, Je n'ai aucun problème à classer si" violet "va à la pile" rouge "ou" bleue"; ça va juste entre. Et puis en intégrant deux opérations (suspendre pour sécher et trier), la surcharge de tri pendant la suspension est comme 10% de ce que le tri séparé serait.

J'espère pouvoir apporter quelque chose de nouveau à ce problème. J'ai remarqué que toutes les réponses négligent le fait qu'il y a deux points où vous pouvez effectuer prétraitement , sans ralentir vos performances globales de blanchisserie.

En outre, nous n'avons pas besoin d'assumer un grand nombre de chaussettes, même pour les grandes familles. Les chaussettes sont sorties du tiroir et sont usées, et elles sont jetées dans un endroit (peut-être un bac) où elles restent avant d'être lavées. Alors que je ne voudrais pas appeler dit bin a LIFO-Stack, je dirais qu'il est sûr de supposer que

1. les gens jettent leurs deux chaussettes à peu près dans la même zone de la bin,
2. le bac n'est randomisé à aucun moment, et donc
3. tout sous-ensemble pris en haut de cette corbeille contient généralement les deux chaussettes d'une paire.

Étant donné que toutes les machines à laver que je connais sont de taille limitée (peu importe combien de chaussettes vous devez laver), et la randomisation réelle se produit dans la machine à laver, peu importe combien chaussettes, nous avons, nous avons toujours de petits sous-ensembles qui contiennent presque pas de singletons.

Nos deux étapes de prétraitement sont "mettre les chaussettes sur la corde à linge" et "prendre les chaussettes de la corde à linge", ce que nous devons faire, afin d'obtenir des chaussettes qui sont non seulement propres mais aussi sèches. Comme pour les machines à laver, les cordes à linge sont finies, et je suppose que nous avons toute la partie de la ligne où nous mettons nos chaussettes en vue.

Voici l'algorithme pour 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 
 }
}

Ne perdez pas votre temps à déplacer des chaussettes ou à chercher le meilleur match, tout cela devrait être fait en O (n), ce dont nous aurions également besoin pour les mettre sur la ligne non triée. Les chaussettes ne sont pas encore jumelées, nous n'avons que plusieurs grappes de similarité sur la ligne. Il est utile que nous ayons un ensemble limité de chaussettes ici, car cela nous aide à créer de "bons" clusters (par exemple, s'il n'y a que des chaussettes noires dans l'ensemble des chaussettes, le regroupement par couleurs ne serait pas le la voie à suivre)

Voici l'algorithme pour 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
 }

Je dois souligner que pour améliorer la vitesse des étapes restantes, il est sage de ne pas choisir au hasard la chaussette suivante, mais de prendre séquentiellement chaussette après chaussette de chaque cluster. Les deux étapes de prétraitement ne prennent pas plus de temps que de simplement mettre les chaussettes sur la ligne ou dans le panier, ce que nous devons faire quoi qu'il arrive, donc cela devrait grandement améliorer les performances du linge.

Après ça, c'est facile à faire l'algorithme de partitionnement de hachage. Habituellement, environ 75% des chaussettes sont déjà appariées, me laissant avec un très petit sous-ensemble de chaussettes, et ce sous-ensemble est déjà (un peu) clusterisé (Je n'introduis pas beaucoup d'entropie dans mon panier après les étapes de prétraitement). Une autre chose est que les clusters restants ont tendance à être assez petits pour être manipulés à la fois, il est donc possible de sortir un cluster entier du panier.

Voici l'algorithme pour sort_remaining_clusters ():

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

Après cela, il ne reste que quelques chaussettes. C'est là que j'introduit des chaussettes précédemment non appariées dans le système et traite les chaussettes restantes sans algorithme spécial - les chaussettes restantes sont très peu nombreuses et peuvent être traitées visuellement très rapidement.

Pour toutes les chaussettes restantes, je suppose que leurs homologues ne sont toujours pas lavés et les rangent pour la prochaine itération. Si vous enregistrez une croissance de chaussettes non appariées au fil du temps (une " fuite de chaussette"), vous devriez vérifier votre bac-il pourrait être randomisé (avez-vous des chats qui dorment là-bas?)

Je sais que ces algorithmes prennent beaucoup d'hypothèses: un bac qui agit comme une sorte de pile LIFO, une machine à laver limitée et normale, et une corde à linge limitée et normale - mais cela fonctionne toujours avec un très grand nombre de chaussettes.

À propos du parallélisme: Tant que vous jetez les deux chaussettes dans le même bac, vous pouvez facilement paralléliser toutes ces étapes.

J'ai pris des mesures simples pour réduire mon effort dans un processus prenant O (1) Temps.

En réduisant mes entrées à l'un des deux types de chaussettes (chaussettes blanches pour les loisirs, chaussettes noires pour le travail), je n'ai qu'à déterminer laquelle des deux chaussettes que j'ai en main. (Techniquement, puisqu'ils ne sont jamais lavés ensemble, j'ai réduit le processus à O (0) Temps)

Un effort initial est nécessaire pour trouver des chaussettes souhaitables, et d'acheter en quantité suffisante pour éliminer le besoin de votre existant chaussette. Comme je l'avais fait avant mon besoin de chaussettes noires, mon effort est minime, mais le kilométrage peut varier.

Un tel effort initial a été vu à plusieurs reprises dans le code très populaire et efficace. Les exemples incluent #DEFIN'ing pi à plusieurs décimales (d'autres exemples existent, mais c'est celui qui vient à l'esprit en ce moment).

Créez une table de hachage qui sera utilisée pour les chaussettes inégalées, en utilisant le motif comme hachage. Itérer sur les chaussettes, un par un. Si la chaussette a une correspondance de motif dans la table de hachage, sortez la chaussette de la table et faites une paire. Si la chaussette n'a pas d'allumette, mettez-la dans la table.

Le problème du tri les n paires de chaussettes est O(n). Avant de les jeter dans le panier à linge , enfilez le panier gauche vers le panier droit. En les sortant, vous coupez le fil et mettez chaque paire dans votre tiroir - 2 opérations sur n paires, donc O (n).

Maintenant, la question suivante est simplement de savoir si vous faites votre propre lessive et votre femme fait la sienne. C'est un problème probable dans un domaine de problèmes entièrement différent. :)

J'ai fini d'associer mes chaussettes en ce moment, et j'ai trouvé que la meilleure façon de le faire est la suivante:

• Choisissez l'une des chaussettes et rangez - la (Créez un' seau ' pour cette paire)
• si le suivant est la paire du précédent, mettez-le dans le compartiment existant, sinon créez-en un nouveau.

Dans le pire des cas, cela signifie que vous aurez n / 2 seaux différents, et vous aurez n - 2 déterminations sur ce que le seau contient la paire de actuelle de la chaussette. Évidemment, cet algorithme fonctionne bien si vous n'avez que quelques paires; Je l'ai fait avec 12 paires.

Ce n'est pas si scientifique, mais ça marche bien:)

Ma solution ne correspond pas exactement à vos besoins, car elle nécessite formellement O(n) un espace "supplémentaire". Cependant, compte tenu de mes conditions, il est très efficace dans mon application pratique. Ainsi, je pense que cela devrait être intéressant.

Combiner avec une autre tâche

La condition spéciale dans mon cas est que je n'utilise pas de machine de séchage, juste accrocher mes chiffons sur un sèche-linge ordinaire. Les chiffons suspendus nécessitent des opérations O(n) (en passant, je considère toujours bin packing problème ici) et le problème par sa nature nécessite l'espace "supplémentaire" linéaire. Quand je prends une nouvelle chaussette du seau, j'essaie de l'accrocher à côté de sa paire si la paire est déjà accrochée. Si c'est une chaussette d'une nouvelle paire, je laisse un peu d'espace à côté.

La Machine Oracle est meilleure ; -)

Cela nécessite évidemment un travail supplémentaire pour vérifier si la chaussette correspondante est déjà suspendue quelque part et cela rendrait la solution O(n^2) avec un coefficient d'environ 1/2 pour un ordinateur. Mais dans ce cas le "facteur humain" est en fait un avantage - je peux généralement très rapidement (presque O(1)) identifier la chaussette correspondante si elle était déjà suspendue (probablement une mise en cache imperceptible dans le cerveau est impliquée) - considérez-la comme une sorte d ' "oracle" limité comme dans Oracle Machine; -) nous, les humains avons ces avantages par rapport aux machines numériques dans certains cas; -)

L'avoir presque O(n)!

Reliant ainsi le problème de l'appariement des chaussettes avec le problème des chiffons suspendus, je reçois O(n) " extra Espace " gratuitement, et avoir une solution qui est d'environ O(n) dans le temps, nécessite juste un peu plus de travail que de simples chiffons suspendus et permet d'accéder immédiatement à une paire complète de chaussettes, même dans un très mauvais lundi matin... ;-)