Un casino usa la siguiente baraja de cartas. ( *Es uno de los juegos de la tarjeta D, S, Co H.)

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

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

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

Después de cada noche, las cubiertas viejas se descartan y se cortan por la mitad para evitar su reutilización. Como resultado, el casino tiene una gran sala llena de mitades de cartas cortadas.

Lamentablemente, la economía es mala y el casino tiene problemas financieros. Lo más razonable para ahorrar dinero parece ser el reciclaje, por lo que los propietarios de los casinos deciden volver a unir las tarjetas viejas. Entonces contratan a un equipo para construir una máquina que hará esto.

Usted es parte del equipo y su trabajo es ayudar a identificar la tarjeta.

Escriba un programa o función que tomará una imagen de arte ASCII de la mitad de una tarjeta en forma de cadena, y devolverá una cadena de la tarjeta que es.

La entrada es una cadena de 11x5, más caracteres de salto de línea (CR, LF o CRLF, solo necesita admitir uno). Puede asumir espacios en blanco al final de cada línea de entrada, si es necesario. La entrada no contendrá ningún carácter no válido (que no sea _|-HSCDy espacio y salto de línea).

La mitad de una tarjeta se verá así:

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

que debe identificarse como la Reina de Corazones:

H12

El casino tiene un presupuesto limitado, así que este es el código de golf: gana el programa más corto.

CJam, 16 15 13 12 bytes

q2*A~<$e`3=(

Pruébalo aquí.

Explicación

La idea básica es manipular la cadena de modo que podamos hacer que la codificación de longitud de ejecución incorporada de CJam funcione para nosotros.

Veamos un ejemplo (el de la pregunta). La cadena de entrada es

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

Repetimos eso dos veces:

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

Y elimine la última línea:

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

Luego clasificamos esta cadena. Ahora tendrá un montón de nuevas líneas al comienzo, y luego esto (acortado por unos espacios para evitar una barra de desplazamiento horizontal):

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

Si bien el carácter del palo variará, siempre será una letra mayúscula, que se encuentra en la cuarta ejecución de la cadena ordenada (que representa la nueva línea). Cuando ejecutamos la codificación de longitud, obtenemos

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

Entonces, todo lo que tenemos que hacer es elegir el cuarto elemento e invertirlo.

Aquí hay un desglose del 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 (versión reciente), 16 bytes

p/KsP*2.zJ@S{K2J

Pruébelo en línea: Pyth Compiler / Executor

Explicación:

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

[email protected]*2.z2

Pyth tenía una compilación en codificación de longitud de ejecución. Pero solo por poco tiempo. Si alguien quiere probar esto: Clone el repositorio Pyth y revise el commit 6a6dccd.

Este programa funciona casi de la misma manera que la solución 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)\,)

Mirando más opciones de golf aquí. Así es 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.

Pruébalo en línea aquí

Python 2, 80 68 66 bytes

Pruébalo aquí

Duplique la entrada, encuentre todas las letras en todas menos la última línea (los primeros caracteres en la última línea no pueden ser letras), luego imprima la primera letra y cuántas.

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---'

Salida :H12

Versión anterior que usa regex (68):

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

Gracias a Sp3000 por su ayuda en el golf.

APL, 39 bytes

Estoy seguro de que esto podría hacerse mucho más corto, pero es un comienzo.

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

Esto crea una función monádica con nombre que acepta una cadena de entrada y devuelve una cadena que contiene el palo y el valor de la tarjeta. ¡Puedes probarlo en línea !

Explicación:

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

¡Las sugerencias son bienvenidas como siempre!

J 26 bytes

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

Uso:

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

Leyendo el código de izquierda a derecha:

• Obtenemos el palo de la entrada como el quinto carácter distinto en él ( 4{~.).
• Cuenta ( +/) el número total de caracteres que aparece en la entrada ( [) y la entrada sin los últimos 9 caracteres ( _9}.[).
• Finalmente concatenamos el traje ( ]) a la representación de cadena de la suma resultante ( ":).

Perl, 75 bytes

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

Versión sin golf

@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)]))

Esto crea una función sin nombre que toma una cadena como entrada y devuelve el palo y el valor de la tarjeta. Para llamarlo, dale un nombre, por ejemplo f=s->(...).

Ungolfed + explicación:

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

¡Las sugerencias son bienvenidas como siempre!

Bash + coreutils, 73

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