L'innovation est un jeu de cartes où les joueurs se battent à travers les âges, de la préhistoire aux temps modernes, pour tenter de gagner des succès plus rapidement que leurs adversaires.

Chaque carte Innovation est unique et fournit au joueur un certain nombre d'icônes. Si nous traitons chaque carte comme une grille 2x3, alors trois des quatre emplacements sur les bords gauche et inférieur seront toujours occupés par des icônes (les symboles dans les hexagones noirs ne sont pas comptés).

Le jeu a 6 types d'icônes (châteaux, couronnes, feuilles, ampoules, usines et horloges), que nous représenterons arbitrairement en utilisant les caractères 012345. Utilisant #pour représenter l'hexagone noir, nous pouvons utiliser quatre caractères pour représenter les icônes sur chaque carte. Par exemple, les cartes ci-dessus sont

0.. #.. 3.. 1..  -> 03#0 #331 355# 144#
3#0 331 55# 44#

Désormais, dans Innovation, les cartes dans la zone de jeu sont regroupées en piles * qui sont réparties de quatre manières. Pour chaque exemple, nous utiliserons les cartes ci-dessus, en supposant que la carte la plus à gauche 03#0, est en haut de la pile.

Pas d'évasement: seule la carte du dessus est visible

0..
3#0

Échapper à gauche : la carte du dessus est entièrement visible, ainsi que le tiers droit de toutes les cartes ci-dessous

0..|.|.|.|
3#0|1|#|#|

Échapper à droite : la carte du dessus est entièrement visible, ainsi que le tiers gauche de toutes les cartes ci-dessous

1|3|#|0..
4|5|3|3#0

Splay up : la carte du haut est entièrement visible, ainsi que la moitié inférieure de toutes les cartes ci-dessous.

0..
3#0
---
331
---
55#
---
44#

Le défi

L'entrée sera une chaîne unique séparée par des espaces composée de deux parties:

• Une direction d'évasement, qui est l'une des !<>^, représentant respectivement aucun évasement, évasement à gauche, évasement à droite ou évasement vers le haut.
• Une liste de cartes non vide, chacune de 4 caractères et composée des caractères 012345#. La carte la plus à gauche est en haut de la pile et chaque carte en contient exactement une #.

Les réponses peuvent être des fonctions, des programmes complets ou l'équivalent . Vous pouvez choisir si la direction d'affichage est la première ou la dernière, c'est-à-dire choisir l'un des deux formats ci-dessous:

> 03#0 #331 355# 144#
03#0 #331 355# 144# >

La sortie sera une liste de six nombres représentant le nombre pour chaque icône, par exemple pour les exemples de cartes ci-dessus:

! 03#0 #331 355# 144#  ->  2 0 0 1 0 0
< 03#0 #331 355# 144#  ->  2 1 0 1 0 0
> 03#0 #331 355# 144#  ->  2 1 0 3 1 1
^ 03#0 #331 355# 144#  ->  2 1 0 3 2 2

Par exemple, le boîtier sans affichage comportait deux 0icônes et une 3icône indiquant la première ligne. Notez que nous ne comptons pas #s, car les hexagones noirs ne sont pas des icônes.

Vous pouvez choisir n'importe quelle manière raisonnable et non ambiguë de représenter la liste, par exemple séparée par des délimiteurs ou en utilisant la représentation de la liste naturelle de votre langue.

Cas de test

! 113#  ->  0 2 0 1 0 0
< 113#  ->  0 2 0 1 0 0
> 113#  ->  0 2 0 1 0 0
^ 113#  ->  0 2 0 1 0 0
! 000# 12#2  ->  3 0 0 0 0 0
< 000# 12#2  ->  3 0 1 0 0 0
> 000# 12#2  ->  3 1 1 0 0 0
^ 000# 12#2  ->  3 0 2 0 0 0
! 000# 111# 222#  ->  3 0 0 0 0 0
< 000# 111# 222#  ->  3 0 0 0 0 0
> 000# 111# 222#  ->  3 2 2 0 0 0
^ 000# 111# 222#  ->  3 2 2 0 0 0
! 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  0 0 0 2 0 1
< 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  1 1 2 5 1 1
> 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  0 3 3 7 1 1
^ 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  2 4 4 10 1 2

Notez que quelque chose comme !est une entrée non valide, car la liste est garantie d'être non vide.

^{* Aux fins de ce défi, nous ignorons les couleurs des poils.}

CJam, 44 37 36 octets

Merci à Sp3000 de m'avoir rappelé que je complique les choses et que j'économise 7 octets.

rci7%"3>0<2<1>"2/=6,slS%{W$~+}*fe=p;

Testez-le ici.

Explication

Quelques observations:

• Nous voulons toujours compter la première carte entière.
• Toutes les répartitions entraîneront la suppression d'un préfixe ou d'un suffixe des icônes. !les supprime tous (qui est soit un préfixe soit un suffixe de quatre caractères), <supprime les trois premiers caractères, >supprime les deux derniers caractères, ^supprime le premier caractère.

Donc, tout ce dont nous avons besoin est un court chemin pour mapper le mode d'affichage à la troncature correcte:

rci   e# Read the splay mode and convert to its character code.
7%    e# Take modulo 7. This maps "<!>^" to [4 5 6 3], respectively. Modulo 4 those are
      e# are all distinct (namely [0 1 2 3], respectively).
"3>0<2<1>"
      e# Push this string.
2/    e# Split it into chunks of 2, ["3>" "0<" "2<" "1>"]. Each chunk is CJam code which
      e# performs one of the truncations.
=     e# Select the correct snippet. This works, because array indexing is cyclic in CJam.
6,s   e# Push the string "012345".
lS%   e# Read the remainder of the input and split into space-separated tokens.
{     e# Now we're abusing the fold operation to apply our snippet to every card except
      e# the first, while also combining them all back into a single string.
  W%  e#   Copy the bottom of the stack (the truncation snippet).
  ~   e#   Evaluate it.
  +   e#   Append it the string we're building.
}*
fe=   e# For each character in "012345", count the occurrences in our new string.
p     e# Pretty-print the array.
;     e# Discard the truncation snippet which was still at the bottom of the stack.

Nous pouvons remarquer que les extraits de troncature ont en réalité beaucoup de structure. Chaque mode d'affichage correspond à un numéro [0 1 2 3](spécifiquement, dans l'ordre "!^><"), et deux d'entre eux ont >et deux ont <. J'espérais trouver deux hachages qui produiraient magiquement ces parties séparément, car cela économiserait un tas d'octets, mais jusqu'à présent, je n'ai rien pu trouver. Je peux mapper "!^><"sur des nombres de parité alternée avec 31%(pour sélectionner le bon caractère "<>"), mais je n'ai rien trouvé qui les mappe parfaitement [0 1 2 3]dans cet ordre. (Sauf la solution naïve "!^><"#qui, malheureusement, ne sauvegarde aucun octet.)

Notez également qu'il est en fait un peu plus flexible. !peut également être implémenté comme n>pour n'importe quel n > 3(en supprimant tout comme préfixe). Malheureusement, je n'ai pas non plus trouvé de fonction simple pour une telle carte.

Pyth, 39 36 33 31 octets

Jtczdm/s+hJm@yk%*%Chz33T19tJ`d6

Essayez-le en ligne. Suite de tests.

Explication

• Jtczd: divisez la saisie par des espaces, supprimez la première partie et enregistrez le reste J.
• m… 6: Répétez ce qui suit pour les numéros 0 à 5.
  • m… tJ: Répétez ce qui suit pour toutes les cartes sauf la première.
    • Chz: récupère le point de code du premier caractère en entrée.
    • %*%… 33T19: Mappez les points de code de !<>^(33, 60, 62, 94) aux nombres 0, 4, 5, 14. Le calcul exact effectué est cp % 33 * 10 % 19.
    • yk: récupère le pouvoir de la carte actuelle. Il s'agit d'une liste de toutes les sous-séquences de la carte.
    • @: récupère l'élément du jeu de puissance correspondant à l'indice calculé précédemment.
  • +hJ: ajoutez la première carte au résultat.
  • s: concatène les cartes traitées ensemble.
  • /… `d: Compte les occurrences du nombre actuel dans le résultat.