Como o primeiro final de semana de outubro está chegando, vamos ter nossa própria Oktoberfest!

fundo

Você e alguns outros programadores foram contratados pelos salsichas locais em Munique, Alemanha. O pessoal da linguiça fornece à Oktoberfest todas as linguiças que o gigante Volksfest precisa. Você consegue ouvir seu chefe conversando com os outros funcionários sobre por que você e os outros foram contratados sem nenhuma experiência anterior relacionada à linguiça. Você percebe que foi contratado por suas habilidades de programação impecáveis ​​- e seu chefe aparentemente quer que você codifique um analisador de salsichas.

Este ano, os salsichas decidiram aumentar a variedade de salsichas na Oktoberfest - mas não têm idéia do quanto importaram.

Desafio

Você precisa ajudar seu chefe a descobrir quanta salsicha de um determinado tipo eles realmente importaram. Você terá que programar um analisador de salsicha que produza o tipo e o número de cada salsicha importada pela galera. Seu chefe comprou uma unidade de disquete especial para esta ocasião, que, dada uma linguiça, é usada para isso stdin.

Entrada

Um número de salsichas stdin, cada salsicha separada por um espaço. As salsichas são fornecidas no seguinte formato:

Prinskorv (P)

 ¤
| |
| |
| |
 ¤

Salchichón (S)

 l
| |
| |
| |
| |
 l

Landjäger (L)

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

Kabanos (K)

.
|
|
|
|
|
.

Cotechino Modena (C)

 ___
|   |
|   |
|   |
|___|

Rød pølse (R)

 ^
| |
| |
| |
| |
 v

Saída

As ocorrências de uma dada salsicha, juntamente com um identificador de que tipo de salsicha é, separadas por um espaço. O identificador é a primeira letra do nome da linguiça. A ordem não é importante.

A saída deve ser gravada stdout, novas linhas e espaços à direita são permitidos.

Exemplos

Entrada

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

Saída

4R 1K

Entrada

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

Saída

1L 1C 1S 2P

Entrada

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

Saída

2S 1P

O programador com o menor programa em bytes é pago pelos salsichas (vitórias)!

Curiosidades sobre salsicha

Prinskorv
Prinskorv, que se traduz diretamente em "príncipe-linguiça", é uma pequena linguiça sueca que é frequentemente vendida em links. Geralmente frito em uma frigideira e servido com uma porção generosa de mostarda.

Salchichón
Salchichón é uma salsicha espanhola de verão geralmente feita com carne de porco, embora algumas receitas usem outras carnes, incluindo boi, vitela ou cavalo. A carne e a gordura são picadas em pedaços finos, temperadas com sal, pimenta, noz-moscada, orégano e alho e depois inseridas no intestino grosso e natural da carne de porco.

Landjäger
Landjäger é uma linguiça semi-seca, tradicionalmente feita no sul da Alemanha, Áustria, Suíça e Alsácia. É popular como um lanche durante atividades como caminhadas. Ele também tem uma história como comida de soldado, porque fica sem refrigeração e vem em porções de uma refeição.

Kabanos
Kabanos é uma lingüiça seca longa e fina polonesa feita de carne de porco ou de peru kosher. São de sabor defumado e podem ter textura macia ou muito seca, dependendo da frescura. Kabanosy são frequentemente temperados apenas com pimenta. Ao contrário de outras carnes, essas salsichas são tipicamente consumidas sozinhas como aperitivo e, exceto quando kosher, geralmente são servidas com queijo.

Cotechino Modena
Cotechino Modena ou Cotechino di Modena é uma linguiça fresca feita de porco, gordura e casca de porco, e vem de Modena, Itália, onde tem status de IGP. Cotechino é frequentemente servido com lentilhas ou cannellini com molho ao lado de purê de batatas, especialmente por volta do ano novo.

Rød pølse
Rød pølse (salsicha vermelha) é um tipo de salsicha de porco cozida e muito vermelha, muito comum na Dinamarca. Como as barracas de cachorro-quente são onipresentes na Dinamarca, algumas pessoas consideram o røde pølser como um dos pratos nacionais.

Todas as informações sobre salsichas copiadas descaradamente da Wikipedia

Pitão, 30 bytes

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

Experimente on-line: Demonstration or Test Suite

Explicação:

Como todos os outros participantes, apenas olho para a primeira linha da entrada. Digamos que a primeira linha da entrada seja \ / ___ l ¤ ¤ ____.

No começo eu divido por espaços, o que me dá a lista

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

Agora queremos começar o passeio de '/'s e ''s e tipo a coisa restante.

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

Agora eu posso codificá-lo no comprimento.

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

Como se vê, a ordem (valor ASCII) desses caracteres ou da sequência '___' pode ser bem mapeada para os 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     

E isso pode ser usado para mapeá-los diretamente para as 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

Pitão, 36 34 32 30 bytes

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

Economizou mais 2 bytes graças a ... adivinha quem? : D

Ignora todas as entradas, exceto a primeira linha, remove todos os /espaços, converte-os nos identificadores de destino, classifica-os, usa a codificação de execução e imprime o resultado.

Demonstração ao vivo.

Versão de 32 bytes

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

Demonstração ao vivo.

Economizou mais 2 bytes graças a @Jakube!

Versão de 34 bytes

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

Demonstração ao vivo.

Guardado 2 bytes graças a @Jakube!

Versão de 36 bytes

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

Demonstração ao 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` `

É bem simples, mas aqui está uma explicação:

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*

Teste aqui.

Explicação

A primeira linha de cada tipo de salsicha é única e, como as salsichas estão alinhadas na parte superior, é suficiente contar os caracteres relevantes nessa primeira linha. Dois tipos requerem tratamento especial:

• Landjäger (L) tem ambos \e /. Queremos nos livrar de um deles, para podermos contar o outro como todos os outros personagens.
• Cotechino Modena (C) possui três sublinhados, portanto, precisamos dividir a contagem de sublinhados por 3. No entanto, é realmente mais curto tratar os sublinhados individualmente, simplesmente substituindo as execuções deles na entrada (que sempre pertencerá a apenas uma salsicha) pelo personagem alvo Cimediatamente.

Agora, para o 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

Alguns bytes provavelmente poderiam ser removidos, mas nada para se aproximar dos idiomas do golfe.

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

ImportString[#,"Table"][[1]]retorna uma lista de cadeias separadas por espaço que aparecem na linha superior da entrada. A sequência pode incluir qualquer um dos elementos da lista {"¤","l","/","___",".","^"}, incluindo repetições. Cada elemento está associado a um tipo único de salsicha.

Tally conta o número de vezes que cada uma dessas strings aparece.

/.{"¤"->"P","l"->"S",...substitui ¤por P, lcom Se assim por diante.

Reverse coloca cada registro antes do item ao qual está associado.

Os dois Rows formatam a saída.

MATLAB, 113

Supondo que espaços à direita sejam permitidos (sim, são), aqui está uma função anônima do MATLAB:

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

E uma explicação:

@(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 corretamente. Ainda tem o espaço à direita, mas agora lida com todas as salsichas corretamente.

Perl, 84 bytes

Alguém provavelmente poderia se livrar um pouco disso ...

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$$_}

Demolir:

Pegue a primeira linha de STDIN, transforme valores em códigos de letras, exclua o lixo extra. O dmodificador não deve ser realmente necessário, mas me deparei com problemas estranhos de unicode no diretório¤ personagem sem ele.

Use referência simbólica para criar e / ou incrementar variável para cada caractere encontrado.

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

Divida a variável C por 3, devido ao sublinhado triplo

$C /= 3;

Percorra o alfabeto e imprima variáveis ​​maiúsculas com uma letra junto com a letra se elas tiverem um valor maior que zero

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

Resultado do teste: http://ideone.com/alpUlI

Edit : Pique 7 bytes fazendo com que o transliterado passe o valor de retorno anônimo diretamente para split.

Perl, 172 bytes

Ainda mais Daresay pode ser cortado desta lingüiça, mas aqui está uma entrada para dez.

$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"

Versão ungolfed

$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";

Resultado dos testes

$ 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

Tenho certeza de que você pode reduzir isso, mas ainda não havia uma solução Python, então vamos lá:

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

Explicação

É bem simples, alguns podem até dizer legível, mas aqui está uma breve explicação:

A primeira linha de entrada é lida, pois cada lingüiça pode ser determinada apenas a partir da primeira linha.

Agora a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')} é uma compreensão de dicionário que mapeia o identificador de cada tipo de lingüiça ( z) para a contagem de cada tipo de lingüiça ( x.count(y), em quey é o caractere que define a lingüiça).

Em seguida, dividimos a contagem de linguiças Cotechino Modena (C) por 3, devido ao sublinhado triplo.

Finalmente, imprimir o resultado: print(' '.join(str(a[x])+x for x in a if a[x])). Isso cria a contagem de saída de cada lingüiça, uma de cada vez, mas somente se essa lingüiça foi vista pelo menos uma vez ( a[x]não é zero => Verdade). Cada sequência de contagem é unida por um espaço e impressa.