Un casino utilise le jeu de cartes suivant. ( *Est l' une des combinaisons de cartes D, S, Cou H.)

 _________    _________    _________    _________    _________
|         |  |         |  |         |  |         |  |         |
|         |  |         |  |    *    |  |  *   *  |  |  *   *  |
|         |  |    *    |  |         |  |         |  |         |
|    *    |  |         |  |    *    |  |         |  |    *    |
|         |  |    *    |  |         |  |         |  |         |
|         |  |         |  |    *    |  |  *   *  |  |  *   *  |
|_________|  |_________|  |_________|  |_________|  |_________|

 _________    _________    _________    _________    _________
|         |  |         |  |         |  |         |  |         |
|  *   *  |  |  *   *  |  |  *   *  |  |  *   *  |  |  *   *  |
|         |  |         |  |  *   *  |  |  *   *  |  |  *   *  |
|  *   *  |  |  * * *  |  |         |  |    *    |  |  *   *  |
|         |  |         |  |  *   *  |  |  *   *  |  |  *   *  |
|  *   *  |  |  *   *  |  |  *   *  |  |  *   *  |  |  *   *  |
|_________|  |_________|  |_________|  |_________|  |_________|

 _________    _________    _________
|         |  |         |  |         |
|  *   *  |  |  *   *  |  |  * * *  |
|  *   *  |  |  * * *  |  |  *   *  |
|  * * *  |  |  *   *  |  |  * * *  |
|  *   *  |  |  * * *  |  |  *   *  |
|  *   *  |  |  *   *  |  |  * * *  |
|_________|  |_________|  |_________|

Après chaque nuit, les vieux ponts sont jetés et coupés en deux pour éviter leur réutilisation. En conséquence, le casino a une grande salle pleine de moitiés de cartes coupées.

Malheureusement, l'économie est mauvaise et le casino est en difficulté financière. La chose la plus raisonnable pour économiser de l'argent semble être le recyclage, donc les propriétaires de casino décident de recoller les vieilles cartes. Ils embauchent donc une équipe pour construire une machine qui le fera.

Vous faites partie de l'équipe et votre travail consiste à aider à identifier la carte.

Écrivez un programme ou une fonction qui prendra une image d'art ASCII d'une moitié de carte sous la forme d'une chaîne et renverra une chaîne de quelle carte il s'agit.

L'entrée est une chaîne 11x5, plus des caractères de saut de ligne (CR, LF ou CRLF, vous n'avez besoin que d'en prendre en charge une). Si nécessaire, vous pouvez supposer des espaces de fin à la fin de chaque ligne d'entrée. L'entrée ne contiendra aucun caractère invalide (autre que _|-HSCDet espace et saut de ligne).

Une moitié de carte ressemblera à ceci:

 _________
|         |
|  H   H  |
|  H H H  |
---H---H---

qui devrait être identifiée comme la Reine de Cœur:

H12

Le casino a un budget limité, c'est donc le golf de code: le programme le plus court gagne.

CJam, 16 15 13 12 octets

q2*A~<$e`3=(

Testez-le ici.

Explication

L'idée de base est de manipuler la chaîne de manière à ce que le codage intégré de CJam fonctionne pour nous.

Passons en revue un exemple (celui de la question). La chaîne d'entrée est

 _________
|         |
|  H   H  |
|  H H H  |
---H---H---

Nous le répétons deux fois:

 _________
|         |
|  H   H  |
|  H H H  |
---H---H---
 _________
|         |
|  H   H  |
|  H H H  |
---H---H---

Et supprimez la dernière ligne:

 _________
|         |
|  H   H  |
|  H H H  |
---H---H---
 _________
|         |
|  H   H  |
|  H H H  |

Ensuite, nous trions cette chaîne. Il y aura maintenant un tas de nouvelles lignes au début, puis cela (raccourci de quelques espaces pour éviter une barre de défilement horizontale):

                                    ---------HHHHHHHHHHHH__________________||||||||||||

Bien que le caractère du costume varie, ce sera toujours une lettre majuscule, trouvée dans la quatrième manche de la chaîne triée (en tenant compte de la nouvelle ligne). Lorsque nous encodons cela, nous obtenons

[8 '\n] [46 ' ] [9 '-] [12 'H] [18 '_] [12 '|]]

Il nous suffit donc de sélectionner le quatrième élément et de l'inverser.

Voici une ventilation du code réel:

q              e# Read the input.
 2*            e# Repeat twice.
   A~<         e# Remove the last 11 characters, i.e. the last line.
      $        e# Flatten into a single string and sort its characters.
       e`      e# Run-length encode: turns the sorted string into 5 pairs of numbers
               e# and characters.
         3=    e# Select the one corresponding to the suit.
           (   e# Pull off the number so that its printed after the suit.

Pyth (version récente), 16 octets

p/KsP*2.zJ@S{K2J

Essayez-le en ligne: Pyth Compiler / Executor

Explication:

       .z           read all lines from input
     *2             duplicate all lines
    P               remove the last line
   s                combine all lines to a big string
  K                 store in K

            {K      set(K), removes duplicate chars
           S        sort, this will result in the list [' ', '-', color, '_', '|']
          @   2     take the element at index 2
         J          and store it in J

p/K      J     J    print J + (count J in K)

Pyth 4.0, 13 octets

[email protected]*2.z2

Pyth avait une construction en encodage de longueur d'exécution. Mais seulement pour peu de temps. Si quelqu'un veut essayer ceci: clonez le dépôt Pyth et extrayez le commit 6a6dccd.

Ce programme fonctionne à peu près de la même manière que la solution CJam de Martin.

      sP*2.z        like in the 16 bytes solution
     S              sort
   .r               run-length-encoding
  @         2       element at index 2 
jk                  join by "" and print

CJam, 22 octets

qN/)'--\s"_| "-_]s)\,)

En regardant plus d'options de golf ici. Voici comment cela fonctionne:

qN/                       e# Read the entire input from STDIN and split it on new lines
   )'--                   e# Take out the last line and remove - from it
       \                  e# Stack contains the half HSDC now. We swap this with rest of
                          e# the input
        s                 e# join the rest of the input array to a single string
         "_| "-           e# Remove anything other than HSCD
               _]s        e# Copy this and convert everything on stack into a single
                          e# string. Now we have the total HSCD in the complete card
                  )       e# Take out the last of HSCD. This serves as first character of
                          e# the output
                   \,)    e# Swap and take length of rest of the HSCD. Increment it by 1
                          e# as we removed 1 in the previous step.

Essayez-le en ligne ici

Python 2, 80 68 66 octets

Essayez-le ici

Dupliquez l'entrée, recherchez toutes les lettres sauf la dernière ligne (les premiers caractères de la dernière ligne ne peuvent pas être des lettres), puis imprimez la première lettre et le nombre.

s=(input()*2)[:-9]
for c in"CDHS":
    if c in s:print c+`s.count(c)`

Entrée :' _________\n| |\n| H H |\n| H H H |\n---H---H---'

Sortie :H12

Version précédente qui utilise regex (68):

import re
r=re.findall('[C-S]',(input()*2)[:-9])
print r[0]+`len(r)`

Merci à Sp3000 pour son aide au golf.

APL, 39 octets

Je suis sûr que cela pourrait être beaucoup plus court, mais c'est un début.

f←{X←(∊⍵[⍳46]⍵)∩'HDCS'⋄((⊃X),0⍕⍴X)~' '}

Cela crée une fonction monadique nommée qui accepte une chaîne d'entrée et renvoie une chaîne contenant le costume et la valeur de la carte. Vous pouvez l' essayer en ligne !

Explication:

f ← {                         ⍝ Define the function f.
     X←                       ⍝ Assign X as
       (∊⍵[⍳46]⍵)             ⍝ the right input duplicated, no center line
                 ∩ 'HDCS'     ⍝ intersect 'HDCS'.
                              ⍝ X is now a vector like 'HHHHHH'.
     ((⊃X)                    ⍝ Return the first element of X
          ,                   ⍝ concatenated with
           0⍕⍴X)              ⍝ the length of X as a string
                ~' '          ⍝ without a space.
}

Les suggestions sont les bienvenues comme toujours!

J, 26 octets

(],[:":@(+/)]=[,_9}.[)4{~.

Usage:

   ((],[:":@(+/)]=[,_9}.[)4{~.) input
H12

Lecture du code de gauche à droite:

• Nous obtenons la combinaison de l'entrée en tant que 5ème caractère distinct ( 4{~.).
• Count ( +/) le nombre total de caractères dans l'entrée ( [) et l'entrée sans les 9 derniers caractères ( _9}.[).
• Enfin, nous concaténons la combinaison ( ]) à la représentation sous forme de chaîne de la somme résultante ( ":).

Perl, 75 octets

@r=();foreach ((<>)[2,2,3,3,4]){push@r,$1 while(/([CDSH])/g)}print $r[0].@r

Version non golfée

@r=(); # Collect matches in this array
foreach ((<>)               # Read stdin as a single array of lines
                            # Note that for a subroutine use @_ for (<>)
         [2,2,3,3,4]) {     # Look at the 3rd, 4th rows twice, 5th row once
    push @r, $1             # Collect individual character matches
        while (/([CDSH])/g) # As long as one of the suits matches
}
print $r[0]                 # Each element of array is matching letter
      .@r                   # Array reference in scalar context gives length

Julia, 58 octets

s->(m=matchall(r"[A-Z]",s*s[1:46]);join([m[1],length(m)]))

Cela crée une fonction sans nom qui prend une chaîne en entrée et retourne la couleur et la valeur de la carte. Pour l'appeler, donnez-lui un nom, par exemple f=s->(...).

Non golfé + explication:

function f(s)
    # Find all alphabetic characters in the input joined with itself
    # excluding the second center line, which begins at the 47th
    # character

    m = matchall(r"[A-Z]", s * s[1:46])

    # Take the first match and the number of matches as an array,
    # collapse the array into a string, and return it

    join([m[1], length(m)])
end

Les suggestions sont les bienvenues comme toujours!

Bash + coreutils, 73

sed '$q;s/.*/&&/'|fold -1|sort|uniq -c|sed -nr 's/ +(\w+) ([C-S])/\2\1/p'