Um cassino usa o seguinte baralho de cartas. ( *É um dos ternos do cartão D, S, Cou H.)

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

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

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

Após cada noite, os decks antigos são descartados e cortados ao meio para evitar a reutilização. Como resultado, o cassino possui uma grande sala cheia de metades de cartões cortados.

Infelizmente, a economia está ruim e o cassino está com problemas financeiros. A coisa mais razoável para economizar dinheiro parece ser a reciclagem, então os proprietários do cassino decidem colar os cartões antigos novamente. Então eles contratam uma equipe para construir uma máquina que fará isso.

Você faz parte da equipe e seu trabalho é ajudar a identificar o cartão.

Escreva um programa ou função que terá uma imagem artística ASCII de um cartão na forma de uma sequência e retornará uma sequência de qual cartão é.

A entrada é uma string 11x5, além de caracteres de quebra de linha (CR, LF ou CRLF, você só precisa suportar um). Você pode assumir espaços em branco à direita no final de cada linha de entrada, se necessário. A entrada não conterá caracteres inválidos (além de _|-HSCDespaço e quebra de linha).

Uma metade do cartão ficará assim:

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

que deve ser identificado como a rainha de copas:

H12

O cassino tem um orçamento limitado, então esse é o código de golfe: o programa mais curto vence.

CJam, 16 15 13 12 bytes

q2*A~<$e`3=(

Teste aqui.

Explicação

A idéia básica é manipular a string para que possamos fazer com que a codificação interna de comprimento de execução do CJam funcione para nós.

Vamos passar por um exemplo (o da pergunta). A sequência de entrada é

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

Repetimos isso duas vezes:

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

E remova a última linha:

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

Então nós classificamos essa string. Agora ele terá várias linhas novas no início, e então isso (reduzido por alguns espaços para evitar uma barra de rolagem horizontal):

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

Embora o caractere do terno varie, sempre será uma letra maiúscula, encontrada na quarta execução da sequência classificada (representando a nova linha). Quando codificamos o comprimento da execução, obtemos

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

Então, tudo o que precisamos fazer é escolher o quarto elemento e revertê-lo.

Aqui está um detalhamento do código real:

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 (versão recente), 16 bytes

p/KsP*2.zJ@S{K2J

Experimente on-line: Compilador / Executor Pyth

Explicação:

       .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)

Pitão 4.0, 13 bytes

jk@.rSsP*2.z2

Pyth teve uma construção na codificação de comprimento de execução. Mas apenas por pouco tempo. Se alguém quiser tentar isso: Clone o repositório Pyth e faça o checkout do commit 6a6dccd.

Este programa funciona da mesma maneira que a solução 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 bytes

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

Olhando para mais opções de golfe aqui. Aqui está como funciona:

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.

Experimente online aqui

Python 2, 80 68 66 bytes

Experimente aqui

Duplique a entrada, encontre todas as letras em todas, exceto a última linha (os primeiros caracteres da última linha não podem ser letras) e, em seguida, imprima a primeira letra e quantas.

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

Entrada :' _________\n| |\n| H H |\n| H H H |\n---H---H---'

Saída :H12

Versão anterior que usa o regex (68):

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

Obrigado ao Sp3000 pela ajuda no golfe.

APL, 39 bytes

Tenho certeza de que isso pode ser muito mais curto, mas é um começo.

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

Isso cria uma função monádica nomeada que aceita uma sequência de entrada e retorna uma sequência contendo o naipe e o valor do cartão. Você pode experimentá-lo online !

Explicação:

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.
}

Sugestões são bem-vindas como sempre!

J, 26 bytes

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

Uso:

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

Lendo o código da esquerda para a direita:

• Obtemos o naipe da entrada como o quinto caractere distinto (4{~. ).
• Count ( +/) o número total de caracteres que ocorre na entrada ( [) e a entrada sem os últimos 9 caracteres (_9}.[ ).
• Finalmente, concatenamos o suit ( ]) à representação de string da soma resultante ( ":).

Perl, 75 bytes

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

Versão ungolfed

@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 bytes

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

Isso cria uma função sem nome que recebe uma string como entrada e retorna o naipe e o valor do cartão. Para chamá-lo, dê um nome, por exemplo f=s->(...).

Ungolfed + explicação:

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

Sugestões são bem-vindas como sempre!

Bash + coreutils, 73

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