Ya que se acerca el primer fin de semana de octubre, ¡tengamos nuestro propio Oktoberfest!

Fondo

Usted y algunos otros programadores han sido contratados por los salchichas locales en Munich, Alemania. Los tipos de salchichas proporcionan a Oktoberfest todas las salchichas que el gigante Volksfest necesita. Se las arregla para escuchar a su jefe hablando con los otros empleados sobre por qué usted y los demás fueron contratados sin ninguna experiencia previa relacionada con la salchicha. Te das cuenta de que te contrataron por tus habilidades de programación impecables, y tu jefe aparentemente quiere que codifiques un analizador de salchichas.

Este año, los salchichas han decidido aumentar la variedad de salchichas en el Oktoberfest, pero no tienen idea de cuánto han importado.

Reto

Debes ayudar a tu jefe a determinar cuánta salchicha de cierto tipo realmente importó. Tendrá que programar un analizador de salchichas que genere el tipo y la cantidad de cada salchicha que importaron. Su jefe ha comprado una unidad de disquete especial para esta ocasión que, dada una salchicha, la canaliza stdin.

Entrada

Una serie de salchichas stdin, cada salchicha separada por un espacio. Las salchichas se dan en el siguiente formato:

Prinskorv (P)

 ¤
| |
| |
| |
 ¤

Salchichón (S)

 l
| |
| |
| |
| |
 l

Landjäger (L)

\ /
| |
| |
| |
| |
/ \

Kabanos (K)

.
|
|
|
|
|
.

Cotechino Modena (C)

 ___
|   |
|   |
|   |
|___|

Rød pølse (R)

 ^
| |
| |
| |
| |
 v

Salida

Las ocurrencias de una salchicha dada junto con un identificador de qué tipo de salchicha es, separada por un espacio. El identificador es la primera letra en el nombre de la salchicha. El orden no es importante.

La salida se escribirá en stdout, se permiten líneas y espacios finales.

Ejemplos

Entrada

 ^   ^   ^   ^  .
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
 v   v   v   v  |
                .

Salida

4R 1K

Entrada

\ /  ___   l   ¤   ¤
| | |   | | | | | | |
| | |   | | | | | | |
| | |   | | | | | | |
| | |___| | |  ¤   ¤
/ \        l

Salida

1L 1C 1S 2P

Entrada

 l   ¤   l
| | | | | |
| | | | | |
| | | | | |
| |  ¤  | |
 l       l

Salida

2S 1P

¡El programador con el programa más corto en bytes es pagado por los salchichas (gana)!

Trivia de salchichas

Prinskorv
Prinskorv que se traduce directamente como "príncipe-salchicha" es una pequeña salchicha sueca que a menudo se vende en enlaces. Generalmente se fríe en una sartén y se sirve con una generosa ración de mostaza.

Salchichón El
salchichón es una salchicha española de verano que a menudo se hace con carne de cerdo, aunque algunas recetas usan otras carnes, como buey, ternera o caballo. La carne y la grasa se cortan en trozos delgados, se sazonan con sal, pimienta, nuez moscada, orégano y ajo y luego se insertan en los intestinos gruesos de cerdo natural.

Landjäger
Landjäger es una salchicha semiseca elaborada tradicionalmente en el sur de Alemania, Austria, Suiza y Alsacia. Es popular como aperitivo durante actividades como el senderismo. También tiene una historia como alimento de soldado porque se mantiene sin refrigeración y viene en porciones de una sola comida.

Kabanos
Kabanos es una salchicha seca polaca larga y delgada hecha de cerdo o pavo kosher. Son de sabor ahumado y pueden ser de textura suave o muy seca dependiendo de la frescura. Kabanosy a menudo se sazonan solo con pimienta. A diferencia de otras carnes, estas salchichas generalmente se comen solas como aperitivo y, excepto cuando son kosher, a menudo se sirven con queso.

Cotechino Modena
Cotechino Modena o Cotechino di Modena es una salchicha fresca hecha de cerdo, fatback y corteza de cerdo, y proviene de Modena, Italia, donde tiene el estado de IGP. Cotechino a menudo se sirve con lentejas o frijoles cannellini con una salsa junto con puré de papas, especialmente alrededor del Año Nuevo.

Rød pølse
Rød pølse (salchicha roja) es un tipo de salchicha de cerdo hervida de color rojo brillante muy común en Dinamarca. Dado que los puestos de perritos calientes son omnipresentes en Dinamarca, algunas personas consideran que el røde pølser es uno de los platos nacionales.

Toda la información de salchichas copiada descaradamente de Wikipedia

Pyth, 30 bytes

jdm+hd@"SKLCRP"%Ced45rS-czd\/8

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

Como todos los demás participantes, solo miro la primera línea de la entrada. Digamos que la primera línea de la entrada es \ / ___ l ¤ ¤ ____.

Al principio me dividí por espacios, lo que me da la lista

['\\', '/', '', '___', '', '', 'l', '', '', '¤', '', '', '¤', '', '___']

Ahora queremos obtener '/'s y ''s y ordenar el resto.

['\\', '___', '___', 'l', '¤', '¤']

Ahora puedo ejecutar-length-codificarlo.

[[1, '\\'], [2, '___'], [1, 'l'], [2, '¤']]

Como resultado, el orden (valor ascii) de estos caracteres o de la cadena '___' se puede asignar muy bien a los números [0, 1, 2, 3, 4, 5].

char/string |  l   .   \    ___    ^   ¤  
-------------------------------------------
value       | 108  46  92 6250335  94 164  
value%45    |  18   1   2      15   4  29    
(value%45)%6|   0   1   2       3   4   5     

Y esto se puede utilizar para asignarlos directamente a las letras SKLCRP.

jdm+hd@"SKLCRP"%Ced45rS-czd\/8
                        czd     split the input string at spaces
                       -   \/   remove "/"s (and also ""s)
                      S         sort
                     r       8  run-length-encode
  m                             map each pair d of ^ to:
   +hd                            d[0] + 
                Ced               convert d[1] to a number
               %   45             mod 45
      @"SKLCRP"                   take the ^th element in the string (mod 6)
jd                              join by spaces

Pyth, 36 34 32 30 bytes

XjdsMrShM-czd\\8"¤_l/^.KRLSCP

Guardado otros 2 bytes gracias a ... ¿adivina quién? :RE

Ignora toda la entrada, excepto la primera línea, elimina todos los /espacios y espacios, la traduce a los identificadores de destino, la ordena, utiliza la codificación de longitud de ejecución e imprime el resultado.

Demo en vivo.

Versión de 32 bytes

XjdsMrS-hMfTczd\\8"¤_l/^.KRLSCP

Demo en vivo.

¡Ahorré otros 2 bytes gracias a @Jakube!

Versión de 34 bytes

jdsMrSX-hMfTczd\\"¤_l/^.KRLSCP")8

Demo en vivo.

¡Ahorré 2 bytes gracias a @Jakube!

Versión de 36 bytes

jdsMrSX-hMfTczd\/"¤_l\\^.""PCSLRK"8

Demo en vivo.

Javascript (ES6), 105

a=>[...'¤l/._^'].map((g,h)=>(f=(a.split(g).length-1)/'222261'[h],f?f+'PSLKCR'[h]:0)).filter(b=>b).join` `

Es bastante simple, pero aquí hay una explicación de todos modos:

input=>
  // list of all unique characters of the sausages
  [...'¤l/._^'].map((sausage_char, index)=>(
    // find all occurrences of the character in the string
    occurrences = (input.split(sausage_char).length - 1)
      / '222261'[index], // divide by the number of that character in its sausage
      // when dividing and multiplying by numbers in strings, JS automatically casts them
    occurrences ? // is there anything for this sausage?
      occurrences + 'PSLKCR'[index] : // add the sausage's letter and count
      0 // return 0 so it can be filtered out
  ))
  // filter out the 0s
  .filter(b=>b)
  // return a space-separated string
  .join` `

CJam, 38 35 33 bytes

l'_%'C*"l¤\^./""SPLRK "erS-$e`S*

Pruébalo aquí.

Explicación

La primera línea de cada tipo de salchicha es única, y dado que las salchichas están alineadas en la parte superior, es suficiente contar los caracteres relevantes en esa primera línea. Dos tipos requieren un tratamiento especial:

• Landjäger (L) tiene ambos \y /. Queremos deshacernos de uno de ellos, luego podemos contar el otro como todos los demás personajes.
• Cotechino Modena (C) tiene tres guiones bajos, por lo que debemos dividir el recuento de guiones bajos por 3. Sin embargo, en realidad es más corto tratar los guiones bajos individualmente simplemente reemplazando series de ellos en la entrada (que siempre pertenecerá a una sola salchicha) con el personaje objetivo de Cinmediato.

Ahora para el código real:

l         e# Read one line from STDIN.
'_%       e# Split on runs of underscores.
'C*       e# Join back together by C's.
"l¤\^./"  e# Push a string with characters corresponding to each type, and a slash.
"SPLRK "  e# Push a string with the corresponding letters and a space.
er        e# Transliterate, turning each identifying character into the correct
          e# letter and all slashes into spaces.
S-        e# Remove spaces (which also gets rid of what used to be slashes).
$         e# Sort the string to group each letter.
e`        e# Run-length encode.
S*        e# Join by spaces.

Mathematica 116

Algunos bytes probablemente podrían reducirse, pero nada para acercarse a los idiomas de golf.

Row[Row/@Reverse/@Tally@ImportString[#,"Table"][[1]]/.{"¤"->"P","l"->"S","/"->"L","___"->"C","."->"K","^"->"R"}," "] &

ImportString[#,"Table"][[1]]devuelve una lista de cadenas separadas por espacios que aparecen en la línea superior de la entrada. La cadena puede incluir cualquiera de los elementos de la lista {"¤","l","/","___",".","^"}, incluidas las repeticiones. Cada elemento está asociado con un tipo único de salchicha.

Tally cuenta el número de veces que aparece cada cadena de este tipo.

/.{"¤"->"P","l"->"S",...reemplaza ¤con P, lcon Sy así sucesivamente.

Reverse coloca cada cuenta antes del elemento al que está asociado.

Los dos Rows formatean la salida.

MATLAB, 113

Suponiendo que los espacios finales están permitidos (sí lo están), aquí hay una función anónima de MATLAB:

@(a)arrayfun(@(p,m)fprintf([(m>32&&p)*'%d%c ' ''],p,m),histc(strtok(strrep(a,'___','_'),10),'./\^_l¤'),'K LRCSP')

Y una explicación:

@(a) %Anonymous function, with an input a
    arrayfun(@(p,m) %Loop through the two input arrays (see later)
                   fprintf( %Print to console
                           [(m>32&&p)*'%d%c ' ''] %Essentially this means if p>0 and m>' ', print an integer followed by a char, then a space
                                                 ,p,m) %The values from the array input is what is getting printed
                                                      ,histc( %Make an array of how many times 
                                                                       strtok(strrep(a,'___','_'),10), %Keep only the first line (as that is where the interesting bit is) and also replace ___ with _ for the 'C'
                                                             './\^_l¤'), %these inputs appear (which will be passed in turn as the 'p' variable to cellfun)
                                                                        'K LRCSP' %These are the characters to be printed with the count representing each sausage (it will be placed in the 'm' input of arrayfun)
             )

Parece funcionar correctamente. Todavía tiene el espacio final, pero ahora maneja todas las salchichas correctamente.

Perl, 84 77 bytes

Alguien probablemente podría afeitarse un poco de esto ...

84 bytes

($s=<>)=~y|_^\.l\\¤|CRKSLP|d;$$_++for split//,$s;$C/=3;for(A..Z){print"$$_$_ "if$$_}

77 bytes

$$_++for split//,<>=~y|_^\.l\\¤|CRKSLP|dr;$C/=3;for(A..Z){print"$$_$_ "if$$_}

Descompostura:

Tome la primera línea de STDIN, transcriba valores en códigos de letras, elimine basura adicional. El dmodificador realmente no debería ser necesario, pero me encontré con problemas unicode extraños en el ¤personaje sin él.

Utilice la referencia simbólica para crear y / o incrementar la variable para cada carácter encontrado.

$$_++ for split //, <> =~ y|_^\.l\\¤|CRKSLP|dr;

Dividir la variable C entre 3, debido al triple subrayado

$C /= 3;

Recorra el alfabeto e imprima las variables mayúsculas de una letra junto con la letra si tienen un valor mayor que cero

for (A..Z) {
    print "$$_$_ " if $$_;
}

Resultado de la prueba: http://ideone.com/alpUlI

Editar : corta 7 bytes haciendo transliterar el valor de retorno anónimo directamente en split.

Perl, 172 bytes

Daresay aún más se puede cortar de esta salchicha, pero aquí hay un entrante para diez.

$a=<>;$a=~s/¤/h/g;$a=~s/_+/_/g;$a=~s/(\/| |\n)//g;$a=~s/\\/x/g;$h{$_}++ for split(//,$a);foreach (sort keys %h){print $h{$_};$_=~tr/^.hlx_/RKPSLC/;print "$_ ";}print "\n"

Versión sin golf

$a=<>;              # get 1st line
$a=~s/¤/h/g;        # convert ¤ to h, avoid unicode hassles
$a=~s/_+/_/g;       # multiple consecutive _ to single _
$a=~s/(\/| |\n)//g; # strip / and spaces
$a=~s/\\/x/g;       # convert \\ to x to avoid regexp hassles

# build hash that counts occurences of character
$h{$_}++ for split(//,$a);

# print the answers
foreach (sort keys %h) {
 print $h{$_};
 $_=~tr/^.hlx_/RKPSLC/;
 print "$_ ";
}
print "\n";

Resultados de la prueba

$ perl meaty.pl <test1.txt
1K 4R
$ perl meaty.pl <test2.txt
1C 2P 1S 1L
$ perl meaty.pl <test3.txt
1P 2S
$

Python 3, 120 bytes

Estoy bastante seguro de que puede acortar esto, pero aún no había una solución de Python, así que aquí vamos:

x=input()
a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}
a['C']//=3
print(' '.join(str(a[x])+x for x in a if a[x]))

Explicación

Es bastante simple, algunos incluso podrían decir legible, pero de todos modos aquí hay una breve explicación:

Se lee la primera línea de entrada, ya que cada salchicha se puede determinar solo desde la primera línea.

Ahora a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}es una comprensión del diccionario que asigna el identificador de cada tipo de salchicha ( z) al recuento de cada tipo de salchicha ( x.count(y)donde yestá el carácter que define la salchicha).

Luego dividimos el recuento de salchichas Cotechino Modena (C) por 3 debido al triple guión bajo.

Por último, imprimir el resultado: print(' '.join(str(a[x])+x for x in a if a[x])). Esto crea el recuento de salida de cada salchicha de uno en uno, pero solo si esa salchicha se vio al menos una vez ( a[x]no es cero => Verdad). Cada cadena de conteo se une por un espacio y se imprime.