Un casinò utilizza il seguente mazzo di carte. ( *È uno dei semi delle carte D, S, Co H.)

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

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

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

Dopo ogni notte, i vecchi mazzi vengono scartati e tagliati a metà per evitare il riutilizzo. Di conseguenza, il casinò ha una grande stanza piena di metà delle carte tagliate.

Purtroppo l'economia è cattiva e il casinò è in difficoltà finanziarie. La cosa più ragionevole per risparmiare denaro sembra essere il riciclo, quindi i proprietari del casinò decidono di ricollegare le vecchie carte. Quindi assumono una squadra per costruire una macchina che lo farà.

Fai parte del team e il tuo compito è aiutarti a identificare la carta.

Scrivi un programma o una funzione che prenderà un'immagine d'arte ASCII di una carta a metà sotto forma di una stringa e restituirà una stringa di quale carta sia.

L'input è una stringa 11x5, più i caratteri di interruzione di riga (CR, LF o CRLF, devi solo supportarne una). Se necessario, puoi assumere spazi vuoti finali alla fine di ogni riga di input. L'input non conterrà alcun carattere non valido (diverso da _|-HSCDe spazio e interruzione di riga).

La metà di una carta sarà simile a questa:

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

che dovrebbe essere identificato come la regina di cuori:

H12

Il casinò ha un budget limitato, quindi questo è il golf del codice: vince il programma più corto.

CJam, 16 15 13 12 byte

q2*A~<$e`3=(

Provalo qui.

Spiegazione

L'idea di base è quella di manipolare la stringa in modo che possiamo far funzionare per noi la codifica di lunghezza di esecuzione integrata di CJam.

Facciamo un esempio (quello della domanda). La stringa di input è

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

Lo ripetiamo due volte:

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

E rimuovi l'ultima riga:

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

Quindi ordiniamo questa stringa. Ora avrà un sacco di nuove righe all'inizio, e quindi questo (accorciato di alcuni spazi per evitare una barra di scorrimento orizzontale):

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

Mentre il carattere seme varierà, sarà sempre una lettera maiuscola, che si trova nella quarta sequenza della stringa ordinata (tenendo conto della nuova riga). Quando lo codifichiamo per lunghezza, lo otteniamo

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

Quindi tutto ciò che dobbiamo fare è selezionare il quarto elemento e invertirlo.

Ecco una ripartizione del codice attuale:

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 (versione recente), 16 byte

p/KsP*2.zJ@S{K2J

Provalo online: Pyth Compiler / Executor

Spiegazione:

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

jk@.rSsP*2.z2

Pyth aveva una build nella codifica run-length. Ma solo per poco tempo. Se qualcuno vuole provare questo: Clona il repository Pyth e controlla il commit 6a6dccd.

Questo programma funziona più o meno allo stesso modo della soluzione CJam di 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 byte

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

Guardando più opzioni di golf qui. Ecco come funziona:

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.

Provalo online qui

Python 2, 80 68 66 byte

Provalo qui

Duplica l'input, trova tutte le lettere tranne l'ultima riga (i primi caratteri di coppia nell'ultima riga non possono essere lettere), quindi stampa la prima lettera e quante.

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

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

Uscita :H12

Versione precedente che utilizza regex (68):

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

Grazie a Sp3000 per l'aiuto del golf.

APL, 39 byte

Sono sicuro che questo potrebbe essere molto più breve, ma è un inizio.

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

Ciò crea una funzione monadica denominata che accetta una stringa di input e restituisce una stringa contenente il seme e il valore della carta. Puoi provarlo online !

Spiegazione:

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

I suggerimenti sono i benvenuti come sempre!

J, 26 byte

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

Uso:

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

Lettura del codice da sinistra a destra:

• Otteniamo il seme dall'input come il 5 ° carattere distinto in esso ( 4{~.).
• Count ( +/) il numero in cui il carattere appare totale nell'input ( [) e nell'input senza gli ultimi 9 caratteri ( _9}.[).
• Infine concateniamo il seme ( ]) alla rappresentazione di stringa della somma risultante ( ":).

Perl, 75 byte

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

Versione 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 byte

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

Questo crea una funzione senza nome che accetta una stringa come input e restituisce il seme e il valore della carta. Per chiamarlo, dagli un nome, ad es f=s->(...).

Ungolfed + spiegazione:

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

I suggerimenti sono i benvenuti come sempre!

Bash + coreutils, 73

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