Comme le premier week-end d'octobre approche, organisons notre propre fête de la bière!

Contexte

Vous et d'autres programmeurs avez été embauchés par les producteurs locaux de saucisses à Munich, en Allemagne. Les producteurs de saucisses fournissent à l'Oktoberfest toutes les saucisses dont le Volksfest géant a besoin. Vous réussissez à entendre votre patron expliquer aux autres employés pourquoi vous et les autres avez été embauchés sans aucune expérience préalable dans le domaine des saucisses. Vous réalisez que vous avez été embauché pour vos compétences en programmation irréprochables - et votre patron souhaite apparemment que vous codiez un analyseur de saucisses.

Cette année, les producteurs de saucisses ont décidé d’augmenter la variété de saucisses à l’Oktoberfest - mais ils n’ont aucune idée de la quantité importée.

Défi

Vous devez aider votre chef à déterminer la quantité de saucisses d'un certain type importé. Vous devrez programmer un analyseur de saucisses indiquant le type et le nombre de toutes les saucisses importées par les producteurs. Votre patron a acheté un lecteur de disquette spécial pour cette occasion, auquel il donne un saucisson stdin.

Contribution

Un certain nombre de saucisses sur stdin, chaque saucisse séparée par un espace. Les saucisses sont données au format suivant:

Prinskorv (P)

 ¤
| |
| |
| |
 ¤

Salchichón (S)

 l
| |
| |
| |
| |
 l

Landjäger (L)

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

Kabanos (K)

.
|
|
|
|
|
.

Cotechino Modena (C)

 ___
|   |
|   |
|   |
|___|

Rød pølse (R)

 ^
| |
| |
| |
| |
 v

Sortie

Les occurrences d'une saucisse donnée avec un identifiant de quelle sorte de saucisse il s'agit, séparées par un espace. L'identifiant est la première lettre du nom de la saucisse. L'ordre n'est pas important.

La sortie doit être écrite dans stdout, les retours à la ligne et les espaces sont autorisés.

Exemples

Contribution

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

Sortie

4R 1K

Contribution

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

Sortie

1L 1C 1S 2P

Contribution

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

Sortie

2S 1P

Le programmeur avec le programme le plus court en octets est payé par les gars de la saucisse (gagne)!

Saucisse

Prinskorv
Prinskorv qui se traduit directement par "prince-saucisse" est une petite saucisse suédoise qui est souvent vendue sous forme de liens. Habituellement frit dans une poêle et servi avec une portion généreuse de moutarde.

Salchichón
Salchichón est une saucisse estivale espagnole souvent à base de viande de porc, bien que certaines recettes utilisent d'autres viandes comme le bœuf, le veau ou le cheval. La viande et le gras sont hachés finement, assaisonnés de sel, de poivre, de noix de muscade, d'origan et d'ail, puis insérés dans des intestins de porc naturels et épais.

Landjäger
Landjäger est une saucisse semi-séchée préparée traditionnellement dans le sud de l'Allemagne, en Autriche, en Suisse et en Alsace. Il est populaire comme collation lors d'activités telles que la randonnée. Il a également une histoire en tant que nourriture de soldat, car il se conserve sans réfrigération et se présente en portions uniques.

Kabanos
Kabanos est une saucisse sèche polonaise longue et fine faite de porc ou de dinde casher. Leur goût est fumé et leur texture peut être douce ou très sèche en fonction de la fraîcheur. Les Kabanosy sont souvent assaisonnés uniquement avec du poivre. Contrairement aux autres viandes, ces saucisses sont généralement consommées seules à l'apéritif et, sauf lorsqu'elles sont casher, souvent accompagnées de fromage.

Cotechino Modena Le
Cotechino Modena ou Cotechino di Modena est une saucisse fraîche à base de viande de porc, de graisse ou de couenne, et provient de Modène, en Italie, où elle a le statut IGP. Le Cotechino est souvent servi avec des lentilles ou des haricots cannellini avec une sauce accompagnée de purée de pommes de terre, en particulier vers le nouvel an.

Rød pølse
Le Rød pølse (saucisse rouge) est un type de saucisse de porc bouillie rouge vif très répandue au Danemark. Comme les stands de hot-dogs sont omniprésents au Danemark, certains considèrent le røde pølser comme l'un des plats nationaux.

Toutes les informations sur les saucisses copiées sans vergogne de Wikipedia

Pyth, 30 octets

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

Essayez-le en ligne: démonstration ou suite de tests

Explication:

Comme tous les autres participants, je ne regarde que la première ligne de la contribution. Disons que la première ligne de l'entrée est \ / ___ l ¤ ¤ ____.

Au début, je divise par des espaces, ce qui me donne la liste

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

Maintenant , nous voulons Chevauchée '/'s et ''s et la chose sorte restante.

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

Maintenant, je peux courir-longueur-encoder.

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

En fin de compte, l'ordre (ascii-value) de ces caractères ou de la chaîne '___' peut être bien associé aux nombres [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     

Et cela peut être utilisé pour les mapper directement aux lettres 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 octets

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

Sauvegardé encore 2 autres octets grâce à ... devinez qui? :RÉ

Ignore toutes les entrées sauf la première ligne, supprime tous les /s et les espaces, les convertit en identificateurs de cible, les trie, utilise le codage de longueur d'exécution et imprime le résultat.

Démo en direct.

Version 32 octets

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

Démo en direct.

A sauvé 2 autres octets grâce à @Jakube!

Version de 34 octets

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

Démo en direct.

2 octets sauvés grâce à @Jakube!

Version de 36 octets

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

Démo en direct.

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

C'est assez simple mais voici une explication quand même:

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 octets

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

Testez-le ici.

Explication

La première ligne de chaque type de saucisse est unique et, comme les saucisses sont alignées en haut, il suffit de compter les caractères pertinents de cette première ligne. Deux types nécessitent un traitement spécial:

• Landjäger (L) ont les deux \et /. Nous voulons nous débarrasser de l’un d’eux, puis nous pourrons compter l’autre comme tous les autres personnages.
• Cotechino Modena (C) possède trois traits de soulignement. Nous devons donc diviser le nombre de traits de soulignement par 3. Cependant, il est en fait plus court pour traiter les traits de soulignement individuellement en remplaçant simplement leur passage dans l'entrée (qui appartiendra toujours à une seule saucisse) par le personnage cible Ctout de suite.

Maintenant pour le code actuel:

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

Certains octets pourraient probablement être supprimés, mais rien ne permet d’approcher les langues de golf.

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

ImportString[#,"Table"][[1]]retourne une liste des chaînes séparées par des espaces apparaissant dans la ligne supérieure de l'entrée. La chaîne peut inclure n'importe lequel des éléments de la liste {"¤","l","/","___",".","^"}, y compris les répétitions. Chaque élément est associé à un type unique de saucisse.

Tally compte le nombre de fois que chaque chaîne apparaît.

/.{"¤"->"P","l"->"S",...remplace ¤par P, lavec Set ainsi de suite.

Reverse place chaque décompte avant l'élément auquel il est associé.

Les deux Rows formateront la sortie.

MATLAB, 113

En supposant que les espaces de fin soient autorisés (oui, ils le sont), voici une fonction anonyme MATLAB:

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

Et une explication:

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

Semble fonctionner correctement. A toujours l'espace de fuite, mais gère maintenant toutes les saucisses correctement.

Perl, 84 77 octets

Quelqu'un pourrait probablement se raser un peu ...

84 octets

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

77 octets

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

Panne:

Prenez la première ligne de STDIN, convertissez les valeurs en codes de lettre, supprimez les déchets superflus. Le dmodificateur ne devrait pas vraiment être nécessaire, mais je me suis heurté à des problèmes unicode étranges sur le ¤personnage sans ce dernier.

Utilisez une référence symbolique pour créer et / ou incrémenter une variable pour chaque caractère trouvé.

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

Diviser la variable C par 3 en raison du triple soulignement

$C /= 3;

Parcourez l’alphabet et imprimez les variables majuscules d’une lettre avec lettre si elles ont une valeur supérieure à zéro

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

Résultat du test: http://ideone.com/alpUlI

Edit : Coupez 7 octets en faisant translittérer la valeur de retour anonyme directement dans split.

Perl, 172 octets

Daresay peut encore être coupé en tranches de cette saucisse, mais voici une entrée pour dix.

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

Version non-golfée

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

Résultats de 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 octets

Je suis sûr que vous pouvez abréger cela, mais il n'y avait pas encore de solution Python, alors allons-y:

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

Explication

C'est assez simple, certains pourraient même dire lisible, mais voici une courte explication quand même:

La première ligne d'entrée est lue, car chaque saucisse peut être déterminée à partir de la première ligne seulement.

Maintenant, la a={z:x.count(y)for y,z in zip('¤l/.^_','PSLKRC')}compréhension du dictionnaire associe l’identifiant de chaque type de saucisse ( z) au nombre de chaque type de saucisse ( x.count(y), oùy est le caractère définissant saucisse).

Nous divisons ensuite le nombre de saucisses Cotechino Modena (C) par 3 en raison du triple trait de soulignement.

Enfin , nous imprimons le résultat: print(' '.join(str(a[x])+x for x in a if a[x])). Cela crée le nombre de sorties de chaque saucisse, une à la fois, mais uniquement si cette saucisse a été vue au moins une fois ( a[x]n'est pas nul => vrai). Chaque chaîne de comptage est jointe par un espace et imprimée.