File d'attente d'impression

Avènement du Code 2024 Jour 5

Partie 1

Il y aura de l'ordre !

Ça va être génial.

J'aime l'avertissement supplémentaire selon lequel les règles relatives aux pages non incluses dans une mise à jour ne doivent pas être prises en compte.

J'ai une vague idée de la façon d'aborder ce puzzle.

Mais je devrai élaborer ma stratégie ici pour obtenir de la clarté et m'assurer que je suis prêt à écrire du vrai code.

Trébuchant sur une stratégie, j'espère

C'est drôle. J'ai l'impression de savoir comment résoudre ce problème en procédant à un contrôle excessif.

Voici ce à quoi je pense.

Convertissez la première des deux listes en un catalogue de numéros de page en toutes les pages qu'elle doit précéder :

De ceci :

47|53
97|13
97|61
...

À ceci :

{
  47: [53],
  97: [13, 61],
  ...
}

Mais comment puis-je l'utiliser ?

Attendez. Pivotez !!

En regardant la première mise à jour des pages d'exemple :

75,47,61,53,29

Et revoir la preuve approfondie pour vérifier son ordre correct...

...me fait penser à l'approche trop fastidieuse :

Find all page ordering rules whose two pages are both in the page update list
Find the index of each page
If the first is less than the second
  The order is correct

Inconvénients, en termes de performances :

• Cela nécessite de parcourir l'ensemble des règles d'ordre des pages pour chaque liste
• Cela ressemble à une factorielle dans la tâche de vérifier toutes les paires de nombres possibles

Je ne suis pas trop sûr de cette approche.

Retour à mon objet de clés et listes d'avant.

Et si je rendais l'objet plus complet :

47|53
97|13
97|61
...

becomes:

{
  47: [ [53], [] ],
  53: [ [], [47] ],
  97: [ [13, 61], [] ],
  13: [ [], [97] ],
  61: [ [], [97] ]
}

• La première liste imbriquée catalogue les numéros qui doivent la précéder
• La deuxième liste imbriquée catalogue les numéros qui doivent la suivre

En théorie (et pseudocode) :

For each number in the list
  Create an ordered list of the previous numbers
    Check each one for inclusion in the catalogued list associated with that number
      If they are all in there
        Set a flag to true
  Create an ordered list of the subsequent numbers
    Check each one for inclusion in the catalogued list associated with that number
      If they are all in there
        Set a flag to true
  If both flags are true
    Number is in the correct order

Un exemple de procédure pas à pas :

75

Before: []
After: [47,61,53,29]

Catalog:
{
  75: [ [29, 47, 53, 61, 13], [97] ]
}

Before: Empty - success

After: [True, True, True, True]

All True? Yes - success

Correct Order

Je pense vraiment qu'il est temps d'écrire un algorithme qui construit au moins mon objet de catalogue.

Construire l'algorithme de catalogage

Séparation des règles de la liste de mise à jour :

let [rules, updates] = input.split('\n\n')

Analyse de l'entrée dans une liste de listes de 2 éléments où chaque élément est un nombre :

rules = rules.split('\n').map(el => el.split('|').map(Number))

Réduire cette liste en un objet plein de clés et de valeurs de liste :

rules = rules.reduce((obj, item) => {
  if (!(item[0] in obj)) {
    obj[item[0]] = []
  }
  obj[item[0]].push(item[1])
  return obj
}, {})

Est-ce que cela fonctionne comme prévu ?

Oui, il affiche cet objet :

{
  '29': [ 13 ],
  '47': [ 53, 13, 61, 29 ],
  '53': [ 29, 13 ],
  '61': [ 13, 53, 29 ],
  '75': [ 29, 53, 47, 61, 13 ],
  '97': [ 13, 61, 47, 29, 53, 75 ]
}

Remarquez que je suis revenu à l'enregistrement uniquement des numéros qui doivent venir après un numéro donné.

C'est parce que je ne pense pas devoir vérifier les deux côtés.

Je peux me tromper.

Mais je vais procéder sous cette hypothèse.

Vérification de tous les numéros après chaque numéro

Je vais travailler sur le premier exemple de mise à jour, qui devrait s'afficher comme correct.

Tout d'abord, je dois analyser l'entrée en listes de nombres :

updates = updates.split("\n").map((el) => el.split(",").map(Number));

Ensuite, extrayez la première liste pour tester :

let test = updates[0];

Maintenant, passons au vrai travail.

Première tentative :

47|53
97|13
97|61
...

Cela semblait fonctionner jusqu'à ce que je l'essaye sur le cinquième exemple d'élément de liste :

{
  47: [53],
  97: [13, 61],
  ...
}

Mon algorithme vérifie que chaque numéro existe en tant que clé dans le catalogue et vérifie tous les numéros de sa liste associée pour une correspondance.

Mais le 13 n'est pas au catalogue. Mon algorithme suppose à tort un verdict correct.

Et quand il arrive à 29, puisqu'il n'y a plus de chiffres, cela suppose aussi que c'est correct.

Je dois donc ajuster ma stratégie.

Deuxième tentative :

75,47,61,53,29

Cela génère la bonne réponse pour chaque exemple de liste !

Il vérifie correctement chaque numéro de la sous-liste de numéros qui apparaissent après chaque numéro pour l'inclusion du numéro en cours de vérification (le numéro qui précède immédiatement la sous-liste).

Ainsi, dans le cas de :

Find all page ordering rules whose two pages are both in the page update list
Find the index of each page
If the first is less than the second
  The order is correct

Quand il rencontre 13, il recherche 29 et voit 13, ce qui signifie qu'ils sont dans le mauvais ordre.

Brancher ceci dans une réduction et additionner les nombres du milieu

Ce n'était pas aussi difficile que je le pensais :

47|53
97|13
97|61
...

becomes:

{
  47: [ [53], [] ],
  53: [ [], [47] ],
  97: [ [13, 61], [] ],
  13: [ [], [97] ],
  61: [ [], [97] ]
}

Il génère la bonne réponse pour l'exemple de saisie !

Comment cela va-t-il se passer avec ma contribution au puzzle ???

Cela a encore généré la bonne réponse !!!

Woohoo!!!

J'ai l'impression d'avoir trop réfléchi à cela pendant un moment. Puis la réponse est devenue claire lorsque j'ai vu ce qui ne fonctionnait pas.

Des trucs amusants !

Quels nouveaux défis la partie 2 apportera-t-elle... ?

Partie 2

Un exercice de tri

J'aurais probablement dû voir ça venir.

Heureusement, je pense que mon algorithme m'a bien préparé pour cela.

Je vais devoir trier chaque liste.

Le tri fonctionne en comparant deux valeurs et en effectuant l'une des deux choses en fonction de l'un des trois résultats :

• Si un -1 est renvoyé par la fonction de tri, la première valeur précède la seconde
• Si un 1 est renvoyé, la deuxième valeur doit précéder la première
• Si un 0 est renvoyé, aucune valeur n'est déplacée puisqu'elles sont égales

Mon algorithme génère des listes de valeurs booléennes.

Lorsque toutes les valeurs booléennes sont vraies, le nombre qui les a générées correctement précède chacune d'elles.

Cependant, si des valeurs booléennes sont fausses, l'un de ces nombres doit précéder le nombre actuel.

Mais si je devais comparer deux nombres et que leurs deux listes avaient une fausse valeur, comment pourrais-je savoir lequel devrait venir en premier ?

Je n'ai vraiment qu'un moyen de traiter les cas où une liste est toutes vraie et l'autre ne l'est pas, ou les deux sont toutes vraies.

Hmmmm.

Je pense que je dois effectuer mon test sur deux nombres à la fois plutôt que sur une liste de nombres.

Exactement comme dans le fonctionnement du tri : a vs b

Ajuster mon algorithme pour un combat 1 contre 1 au lieu de 1 contre plusieurs

Après quelques réflexions, vérifications ternaires et remises en question, je suis arrivé à un algorithme fonctionnel :

47|53
97|13
97|61
...

L'exécuter sur chacun des exemples de mises à jour dans un ordre incorrect produit une liste correctement ordonnée !

Je suis ravi de le présenter sur toutes les listes dans les deux entrées et j'espère terminer aujourd'hui avec deux étoiles d'or bien méritées !

Surplombant un énorme... détail mineur

J'ai exécuté mon algorithme sur l'exemple d'entrée et j'ai obtenu un nombre plus grand que celui indiqué.

Je ne savais pas pourquoi. L'impression de chaque liste correctement triée a prouvé que ses éléments sont dans le bon ordre.

Puis j'ai relu les instructions :

uniquement les mises à jour mal ordonnées

C'est logique ! J'additionnais la valeur moyenne de chaque liste !

Corriger ce problème nécessite un petit slice() pour dupliquer la liste, puis comparer les versions stringifiées :

{
  47: [53],
  97: [13, 61],
  ...
}

Alto ! J'obtiens la bonne réponse pour l'exemple de saisie.

Je croise les doigts pour que je reçoive ma contribution au puzzle !

En effet !!!

SWEEEEET !!

Deux étoiles d'or. Tout à moi !

Quel autre puzzle amusant.

Il a fallu quelques jours pour réfléchir et élaborer des stratégies.

Mais j'ai finalement trouvé mon chemin à travers le brouillard.

En avant le jour 6 !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!