Poiché il primo fine settimana di ottobre si avvicina, facciamo il nostro Oktoberfest!

sfondo

Tu e alcuni altri programmatori siete stati assunti dai ragazzi della salsiccia locale a Monaco, in Germania. I salsicce forniscono all'Oktoberfest tutte le salsicce di cui il gigante Volksfest ha bisogno. Riesci a sentire il tuo capo mentre parla agli altri impiegati del perché tu e gli altri siete stati assunti senza alcuna precedente esperienza relativa alla salsiccia. Ti rendi conto di essere stato assunto per le tue impeccabili capacità di programmazione - e apparentemente il tuo capo vuole che tu scriva un analizzatore di salsicce.

Quest'anno, i ragazzi della salsiccia hanno deciso di aumentare la varietà di salsicce all'Oktoberfest, ma non hanno idea di quanto abbiano importato.

Sfida

Devi aiutare il tuo capo a capire quanta salsiccia di un certo tipo ha effettivamente importato. Dovrai programmare un analizzatore di salsicce che fornisca il tipo e il numero di ogni salsiccia importata dai salsicce. Il tuo capo ha acquistato un floppy drive speciale per questa occasione a cui, dato un salame, lo convoglia stdin.

Ingresso

Un certo numero di salsicce su stdin, ogni salsiccia separata da uno spazio. Le salsicce sono fornite nel seguente formato:

Prinskorv (P)

 ¤
| |
| |
| |
 ¤

Salchichón (S)

 l
| |
| |
| |
| |
 l

Landjäger (L)

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

Kabanos (K)

.
|
|
|
|
|
.

Cotechino Modena (C)

 ___
|   |
|   |
|   |
|___|

Rød pølse (R)

 ^
| |
| |
| |
| |
 v

Produzione

Le occorrenze di una determinata salsiccia insieme a un identificatore di quale tipo di salsiccia è, separato da uno spazio. L'identificatore è la prima lettera nel nome della salsiccia. L'ordine non è importante.

L'output deve essere scritto in stdout, sono consentite nuove righe e spazi finali.

Esempi

Ingresso

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

Produzione

4R 1K

Ingresso

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

Produzione

1L 1C 1S 2P

Ingresso

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

Produzione

2S 1P

Il programmatore con il programma più breve in byte viene pagato dai ragazzi della salsiccia (vince)!

Curiosità sulla salsiccia

Prinskorv
Prinskorv che si traduce direttamente in "principe-salsiccia" è una piccola salsiccia svedese che viene spesso venduta in link. Di solito fritto in padella e servito con generosa porzione di senape.

Salchichón Il
salchichón è una salsiccia estiva spagnola spesso preparata con carne di maiale, sebbene alcune ricette utilizzino altre carni tra cui bue, vitello o cavallo. La carne e il grasso vengono tagliati a pezzetti sottili, conditi con sale, pepe, noce moscata, origano e aglio e quindi inseriti in grossi intestini di maiale naturali.

Landjäger
Landjäger è una salsiccia semi-secca tradizionalmente prodotta nella Germania meridionale, in Austria, Svizzera e Alsazia. È popolare come spuntino durante attività come l'escursionismo. Ha anche una storia come cibo da soldato perché si conserva senza refrigerazione e viene fornito in porzioni a pasto singolo.

Kabanos
Kabanos è una salsiccia secca lunga e sottile polacca fatta di carne di maiale o tacchino kosher. Hanno un sapore affumicato e possono essere morbidi o molto secchi nella consistenza a seconda della freschezza. I Kabanosy sono spesso conditi solo con pepe. A differenza di altre carni, queste salsicce sono in genere consumate da sole come antipasto e, tranne quando sono kosher, spesso servite con formaggio.

Cotechino Modena
Cotechino Modena o Cotechino di Modena è una salsiccia fresca a base di carne di maiale, lombata e cotenna, proveniente da Modena, Italia, dove ha lo status IGP. Il cotechino viene spesso servito con lenticchie o fagioli cannellini con salsa e purè di patate, soprattutto nel periodo di Capodanno.

Rød pølse
Il Rød pølse (salsiccia rossa) è un tipo di salsiccia di maiale bollita di colore rosso molto comune in Danimarca. Dato che le bancarelle di hot dog sono onnipresenti in Danimarca, alcune persone considerano il røde pølser come uno dei piatti nazionali.

Tutte le informazioni sulla salsiccia sono state spudoratamente copiate da Wikipedia

Pyth, 30 byte

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

Provalo online: Dimostrazione o Test Suite

Spiegazione:

Come tutti gli altri partecipanti, guardo solo la prima riga dell'input. Diciamo che la prima riga dell'input è \ / ___ l ¤ ¤ ____.

All'inizio mi sono diviso per spazi, il che mi dà l'elenco

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

Ora vogliamo ottenere giro di '/'s e ''s e sorta la cosa che rimane.

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

Ora posso codificarlo per tutta la lunghezza.

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

A quanto pare, l'ordine (valore ASCII) di questi caratteri o della stringa '___' può essere mappato piacevolmente ai numeri [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 questo può essere usato per mapparli direttamente alle lettere 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 byte

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

Salvato ancora altri 2 byte grazie a ... indovina chi? : D

Ignora tutti gli input tranne la prima riga, rimuove tutto / s e gli spazi, li traduce negli identificativi di destinazione, li ordina, usa la codifica di lunghezza e stampa il risultato.

Dimostrazione dal vivo.

Versione a 32 byte

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

Dimostrazione dal vivo.

Salvati altri 2 byte grazie a @Jakube!

Versione a 34 byte

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

Dimostrazione dal vivo.

Salvato 2 byte grazie a @Jakube!

Versione a 36 byte

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

Dimostrazione dal 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` `

È piuttosto semplice ma ecco comunque una spiegazione:

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 byte

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

Provalo qui.

Spiegazione

La prima riga di ogni tipo di salsiccia è unica e poiché le salsicce sono allineate in alto, è sufficiente contare i caratteri rilevanti in quella prima riga. Due tipi richiedono un trattamento speciale:

• Landjäger (L) hanno entrambi \e /. Vogliamo sbarazzarci di uno di loro, quindi possiamo contare l'altro come tutti gli altri personaggi.
• Cotechino Modena (C) ha tre caratteri di sottolineatura, quindi dobbiamo dividere il conteggio dei trattini bassi per 3. Tuttavia, in realtà è più breve trattare i caratteri di sottolineatura individualmente semplicemente sostituendo le loro serie nell'input (che apparterrà sempre a una sola salsiccia) con il personaggio bersaglio Cimmediatamente.

Ora per il codice effettivo:

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

Alcuni byte potrebbero probabilmente essere rasati, ma nulla per avvicinarsi alle lingue del golf.

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

ImportString[#,"Table"][[1]]restituisce un elenco di stringhe separate da spazio che appare nella riga superiore dell'input. La stringa può includere uno qualsiasi degli elementi nell'elenco {"¤","l","/","___",".","^"}, comprese le ripetizioni. Ogni elemento è associato a un tipo unico di salsiccia.

Tally conta il numero di volte in cui appare ciascuna di queste stringhe.

/.{"¤"->"P","l"->"S",...sostituisce ¤con P, lcon Se così via.

Reverse posiziona ogni conteggio prima dell'elemento a cui è associato.

I due Rows formattano l'output.

MATLAB, 113

Supponendo che gli spazi finali siano consentiti (sì, lo sono), ecco una funzione anonima MATLAB:

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

E una spiegazione:

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

Sembra funzionare correttamente. Ha ancora lo spazio finale, ma ora gestisce correttamente tutte le salsicce.

Perl, 84 77 byte

Qualcuno potrebbe probabilmente radersi un po 'fuori da questo ...

84 byte

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

77 byte

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

Abbattersi:

Prendi la prima riga di STDIN, traslittera i valori in codici di lettere, elimina immondizia aggiuntiva. Il dmodificatore non dovrebbe davvero essere necessario, ma ho riscontrato strani problemi di Unicode su¤ personaggio senza di esso.

Utilizzare il riferimento simbolico per creare e / o incrementare la variabile per ogni carattere trovato.

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

Dividi la variabile C per 3, a causa del carattere di sottolineatura triplo

$C /= 3;

Passa attraverso l'alfabeto e stampa le variabili maiuscole a lettera singola insieme alla lettera se hanno un valore maggiore di zero

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

Risultato del test: http://ideone.com/alpUlI

Modifica : tagliare 7 byte facendo passare direttamente il valore di ritorno anonimo al valore di traslitterazione split.

Perl, 172 byte

Daresay in più può ancora essere tagliato fuori da questa salsiccia, ma ecco un antipasto per dieci.

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

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

Risultati del test

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

Sono abbastanza sicuro che puoi accorciarlo, ma non esisteva già una soluzione Python, quindi eccoci qui:

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

Spiegazione

È piuttosto semplice, alcuni potrebbero persino dirlo leggibile, ma ecco comunque una breve spiegazione:

Viene letta la prima riga di input, poiché ogni salsiccia può essere determinata solo dalla prima riga.

Ora a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}è una comprensione del dizionario che mappa l'identificatore di ogni tipo di salsiccia ( z) al conteggio di ogni tipo di salsiccia ( x.count(y), dovey è il carattere che definisce la salsiccia).

Dividiamo quindi il conteggio delle salsicce Cotechino Modena (C) per 3 a causa del carattere di sottolineatura triplo.

Infine stampiamo il risultato: print(' '.join(str(a[x])+x for x in a if a[x])). Questo crea il conteggio delle uscite di ogni salsiccia una alla volta, ma solo se quella salsiccia è stata vista almeno una volta ( a[x]non è zero => Verità). Ogni stringa di conteggio è unita da uno spazio e stampata.