DÉFI
Étant donné un ensemble de lettres groupées, placez-les sur le tableau afin qu'elles couvrent entièrement la zone.
Représentation au conseil d'administration (alias le SHIP DECK)
- La carte est une grille 6x6.
- Il y aura toujours 36 carrés au total.
- Les colonnes sont marquées AF.
- Les lignes sont marquées 1-6.
Exemple:
A B C D E F
+---+---+---+---+---+---+
1 : : : : : : :
+---+---+---+---+---+---+
2 : : : : : : :
+---+---+---+---+---+---+
3 : : : : : : :
+---+---+---+---+---+---+
4 : : : : : : :
+---+---+---+---+---+---+
5 : : : : : : :
+---+---+---+---+---+---+
6 : : : : : : :
+---+---+---+---+---+---+
ENTRÉE (alias les caisses)
- Une chaîne multiligne contenant l'ensemble des lettres groupées.
- Les caisses sont fabriquées à partir de groupes de lettres identiques.
- Les caisses sont IMMUTABLES, ce qui signifie qu'elles ne peuvent pas être tournées ou retournées.
- Le point de départ de chaque caisse est en haut à gauche (doit être pris en compte lors du déplacement d'une caisse sur le pont).
- À partir du point supérieur gauche d'une caisse, les carrés identiques suivants ne peuvent être qu'à droite ou en dessous.
- N'importe quelle lettre peut être utilisée pour représenter une caisse. Les caisses commencent toujours à la lettre
[a]
et remontent l'alphabet. - Les caisses sont étiquetées par leur lettre (c.-à-d. Caisse A, caisse B, etc.)
- Le nombre de caisses peut varier (il n'est pas toujours de 10, malgré les exemples donnés).
- Il y a 24 caractères séparant chaque bloc de caisses par ligne. (début de [a] au début de [b] séparés par 24 caractères, etc.)
Exemple:
[a][a][a] [b] [c][c]
[a] [b][b][b] [c]
[a] [b][b]
[d] [e] [f][f][f][f][f]
[d][d] [e]
[d][d] [e]
[e]
[e][e]
[g] [h] [i]
[g] [i]
[i]
PRODUCTION
Il est nécessaire d'imprimer une série de commandes qui placent les caisses dans des positions sur le pont afin qu'il soit complètement couvert (pas d'espaces vides).
Le format de la commande est le suivant:
HAUL <crate> TO <column> <row>
c'est-à-dire HAUL E TO A 1
Pour plus de précision, il y aura toujours une solution pour l'entrée donnée.
CAS D'ESSAI <- Cliquez pour en savoir plus.
Contribution
[a][a][a] [b] [c][c][c]
[a][a] [b]
[a] [b][b]
[b][b]
[d] [e] [f]
[d] [f]
[d] [f]
[d]
[d]
[g][g] [h] [i]
[i][i]
[i]
[i][i]
[j][j][j]
Production
HAUL I TO A 1
HAUL B TO A 3
HAUL A TO B 1
HAUL J TO D 6
HAUL D TO F 1
HAUL F TO E 1
HAUL C TO C 5
HAUL G TO D 4
HAUL E TO D 3
HAUL H TO C 6
Résultat:
A B C D E F
+---+---+---+---+---+---+
1 : i : a : a : a : f : d :
+---+---+---+---+---+---+
2 : i : i : a : a : f : d :
+---+---+---+---+---+---+
3 : b : i : a : e : f : d :
+---+---+---+---+---+---+
4 : b : i : i : g : g : d :
+---+---+---+---+---+---+
5 : b : b : c : c : c : d :
+---+---+---+---+---+---+
6 : b : b : h : j : j : j :
+---+---+---+---+---+---+
NOTATION
C'est le code-golf donc la réponse la plus courte en caractères gagne.
code-golf
sequence
decision-problem
parsing
board-game
Jonathan Picazo
la source
la source
Réponses:
Python 3.6,
435437385331 octetsAppelez
F()
avec la chaîne de caisse.Géré à jouer au golf beaucoup plus:
re
bibliothèque.Restructuré le code pour supprimer les boucles redondantes.
Le code précédent a construit une liste de toutes les positions d'une caisse dans
F()
, puis itéré sur la liste dansR()
. Le nouveau code crée une position d'une caisseF()
etR()
essaie toutes les positions possibles.Dans le code précédent,
R()
recueilli une solution possible dansa
,F()
puis itéré sur la solution retournée. Dans le nouveau code,R()
imprime directement les commandes HAULExplication
L'idée de base est de représenter le pont du navire et les caisses sous forme de bitmap. En utilisant des bitmaps, le déplacement d'une caisse devient un décalage de sa bitmap et la vérification du chevauchement entre les caisses devient un ET bit par bit et test pour zéro.
Code non golfé:
F()
analyse la chaîne de définition de caisse et construit les bitmap. Une expression régulière recherche (ligne 9) chaque ligne de la chaîne de définition de caisse pour les caisses (une lettre suivie d'un ']'). Lorsqu'une correspondance est trouvée, la correspondance (ligne, col) est ajoutée à un dictionnaire saisi par la lettre (lignes 11-13). Pour l'exemple de chaîne de définition de caisse donnée dans le problème:Les coordonnées de chaque caisse sont normalisées (ligne 17), de sorte que chaque caisse commence à (0,0) et que chaque bloc ait une unité de largeur (au lieu de 3 à la '[a]').
Une image bitmap est ensuite créée pour chaque caisse en fonction des coordonnées normalisées (ligne 18).
Le pont est traité comme une grille 7 x 7. La colonne «G» et la ligne 7 sont utilisées pour détecter le moment où une forme s'étend hors de la planche. Un bitmap a un 1 si les caisses occupent le carré correspondant sur le pont. Les bits 48 à bit à 42 correspondent aux carrés A1 à A7, les bits 41 à 35 correspondent aux carrés B1 à B7, etc.
R(used, bitmaps)
utilise ensuite les bitmaps pour rechercher récursivement des emplacements de caisses qui n'essaient pas de placer deux caisses dans le même carré.used
est un masque de bits indiquant quels carrés ne peuvent pas être utilisés parce qu'ils sont déjà occupés par une caisse ou parce qu'ils sont hors du plateau (c'est-à-dire la colonne G et la ligne 7).bitmaps
est une liste de caisses qui doivent encore être placées.Le cas de base pour la récursivité est quand il n'y a plus de caisses à placer, c'est-à-dire qu'il
bitmaps
est vide (ligne 23). Dans ce cas, True est renvoyé pour indiquer qu'une solution a été trouvée.Sinon, un nom de caisse et son bitmap sont extraits de la liste des bitmaps (ligne 26). Bien que le bitmap de caisse ne soit pas vide (ligne 28), vérifiez si l'emplacement actuel de la caisse, représenté par le bitmap de caisse, est en conflit avec les caisses précédemment placées. À la ligne 29,
not used & crate_bitmap
est Faux siused
et lescrate_bitmap
deux ont un 1 dans la même position de bit, indiquant un conflit. S'il n'y a pas de conflit,R()
est appelé récursivement (ligne 30) pour essayer de placer les caisses restantes.Si l'appel récursif
R()
renvoie True, cela signifie qu'une solution a été trouvée et que l'emplacement actuel des caisses fait partie de cette solution. Ainsi, la commande correspondante pour déplacer les caisses est imprimée et True est propagée vers le haut des appels récursifs (lignes 31-32).Une fois créé dans
F()
, chaque bitmap de caisse représente les carrés de deck qui seraient occupés par les caisses s'ils étaient placés à la position A1. Décaler un bitmap d'un bit vers la droite correspond à déplacer les caisses en position A2. Un décalage à droite de sept bits correspond au déplacement des caisses vers B1, etc. Par exemple, les images bitmap suivantes représentent les caisses «a» à différentes positions:Si un placement possible de caisses ne fonctionne pas parce qu'il entre en conflit avec une caisse précédemment placée (ligne 30) ou parce qu'il n'y a pas de placement valide des caisses restantes (ligne 31). Les caisses sont déplacées vers une position différente en déplaçant le masque de bits d'un bit vers la droite (ligne 35).
Shift
garde une trace du nombre de lieux où le bitmap a été déplacé, ce qui correspond à la position actuelle des caisses.Si le bitmap est vide (zéro), cela indique que tous les placements possibles ont été essayés. False est retourné (ligne 37) pour indiquer un échec afin qu'un appel à
R()
plus tôt dans la récursivité essaie un autre placement pour ses caisses.Pour garantir que les caisses ne s'étendent pas sur le côté du pont, des bits correspondant à la colonne G et à la ligne 7 sont définis
used
pour l'appel initial àR()
(ligne 20).4432676798719
est le jeu vide correspondant à0b0000001000000100000010000001000000100000011111111
la source
Python 2 , 864 octets
Essayez-le en ligne!
Explication
De nombreux octets sont utilisés pour analyser les caisses bidimensionnelles entrées via une seule chaîne. Les caisses sont représentées comme une liste imbriquée de valeurs booléennes.
Une fois les caisses analysées, la fonction prend en compte toutes les positions possibles de toutes les caisses. Pour ce faire, il s'appelle itérativement. Lorsqu'il trouve une position impossible (si la caisse doit être placée à l'extérieur du pont ou au-dessus d'une autre caisse), il tue la branche d'arbre de récursivité actuelle pour améliorer les performances.
Quand il voit qu'une certaine combinaison de placements a abouti à une plate-forme complètement couverte, il imprime l'historique de placement de caisse enregistré et quitte globalement en tentant une division sans espoir. Les instructions de transport imprimées sont même triées par ordre alphabétique.
Python 2 , 812 octets
Essayez-le en ligne!
Explication
La chaîne de caisse est analysée et transformée en un nid répertorié de booléens représentant chaque caisse.
Une fonction itérative génère toutes les listes possibles de longueur égale à la quantité de caisses fournies contenant les entiers
0 <= x < 36
(toutes les positions possibles du pont du navire). Chaque liste est interprétée comme une instruction pour positionner toutes les caisses et testée. Si la liste d'instructions testée aboutit à un jeu sans espaces vides, la liste d'instructions doit être valide et est imprimée.Étant extrêmement inefficace, je ne l'ai pas testé sur le cas de test fourni, mais sur des scénarios avec moins de caisses (voir le lien TIO). Parce que l'algorithme recherche dans tous les arrangements possibles, il essaie de les examiner
36**10 = 3.656e15
. Pourtant, en théorie, cela devrait encore fonctionner.la source
H
/M
hors de la déclaration de fonction, car les avoir dans la déclaration rend les fonctions non réutilisables. Bon vieux Python.[i]
avec[b]
, cela fonctionne . L'algorithme pourrait être amélioré en triant d'abord les caisses afin que celles plus volumineuses soient testées avant les petites.JavaScript, 366
Remarque: cette fonction peut analyser une entrée plus compacte, car elle ne se soucie pas de l'espacement de 24 caractères et les trous dans les caisses sont autorisés.
Je pense qu'on pourrait jouer un peu plus au golf, mais maintenant c'est court et pas trop lent, donc je l'aime tel quel
Moins golfé
Beaucoup de cas de test
la source