Introduction et crédit

Supposons que vous êtes barman. La plupart du temps, vous avez beaucoup de gens heureux dans votre bar, mais beaucoup ne boivent que la même boisson et trop peu à votre goût et vous voulez changer cela. Vous introduisez donc un système où le prix d'une boisson est variable, selon le nombre déjà vendu, mais jamais plus ou moins cher que certains seuils. Pour une raison étrange, vous oubliez toujours de suivre correctement toutes les boissons et les prix vendus et vous devez donc penser à un court (= mémorable!) Morceau de code qui fait le calcul pour vous compte tenu de la quantité de boissons consommées.

Ce défi est déjà apparu à l'examen de mi-session en 2012 lors du cours de programmation fonctionnelle de mon université et j'ai l'autorisation de mon professeur de le poster ici. On nous a fourni un exemple de solution dans la langue de l'examen.

Contribution

Votre entrée sera une liste de chaînes qui ne contiennent pas d'espaces - ce sont les noms des boissons vendues. Prenez la saisie en utilisant votre méthode de saisie préférée et généralement acceptée.

Production

Votre sortie sera un numéro unique - c'est le revenu que vous avez généré ce soir. Donnez la sortie en utilisant votre méthode de sortie préférée et généralement acceptée.

Que faire?

Cela s'applique à chaque boisson individuellement:

• Le prix de départ est de 10.
• Chaque fois que la boisson est achetée, son prix est augmenté de 1 pour le prochain acheteur.
• Le prix maximal est de 50. Si la boisson a été achetée pour 50, le nouveau prix sera à nouveau de 10.

Votre tâche consiste à trouver le revenu global, généré par la liste d'entrée des boissons compte tenu des règles ci-dessus.

Dans le cas où vous vous demandez: "50 dollars, c'est vraiment sacrément cher pour un verre!", Il s'agit de 50 décis, donc 50 * 0,1 * unité, mais j'ai opté pour 10-50 pour ne pas exclure les langues sans arithmétique à virgule flottante.

Qui gagne?

C'est du code-golf , donc le code le plus court en octets gagne! Des règles standard s'appliquent.

Cas d'angle potentiels

Si la liste d'entrée est vide, la sortie doit être 0.
La liste d'entrée ne peut pas être supposée être triée par boisson.

Exemples

[] -> 0
["A"] -> 10
["A","B"] -> 20
["A","A","B"] -> 31
["A","B","A"] -> 31
["A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A"] -> 1240
["A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","B","B","C","C","D"] -> 1304 
["D","A","A","C","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","B","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","C"] -> 1304
["A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","B","B","C","C","D","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A"] -> 1304

JavaScript (ES6), 50 octets

a=>a.map(x=>t+=d[x]=d[x]<50?d[x]+1:10,t=0,d={})&&t

Python 2, 79 74 54 48 octets

Augmentation massive du nombre d'octets en repensant le problème. Je voudrais me débarrasser du intcasting mais mon cerveau ne fonctionne pas . Faire usage del.pop() pour éviter de rogner la liste deux fois et une bonne vieille récursion lambda :)

f=lambda l:l and l.count(l.pop())%41+10+f(l)or 0

^{merci à Jonathan Allan pour avoir économisé 6 octets :)}

Mon ancienne version de 54 octets dont j'étais assez fier :)

f=lambda l:int(l>[])and~-l.count(l[0])%41+10+f(l[1:])

Pyth, 15 octets

ssm<*lQ}T50/Qd{

Un programme qui prend l'entrée d'une liste et imprime le résultat.

Suite de tests (première ligne pour permettre plusieurs entrées)

Comment ça fonctionne

ssm<*lQ}T50/Qd{   Program. Input: Q
ssm<*lQ}T50/Qd{Q  Implicit input fill
              {Q  Deduplicate Q
  m               Map over that with variable d:
       }T50        Yield [10, 11, 12, ..., 48, 49, 50]
    *lQ            Repeat len(Q) times
   <       /Qd     First Q.count(d) elements of that
 s                Flatten
s                 Sum
                  Implicitly print

Gelée , 14 11 10 octets

50⁵rṁЀĠSS

TryItOnline!

Comment?

50⁵rṁЀĠSS - Main link: list of drink names                e.g. ['d', 'a', 'b', 'a', 'c']
       Ġ   - group indices by values                       e.g. [[2, 4], [3], [5], [1]]
  ⁵        - 10
50         - 50
   r       - inclusive range, i.e. [10, 11, 12, ..., 48, 49, 50]
    ṁЀ    - mould left (the range) like €ach of right(Ð)  e.g. [[10, 11], [10], [10], [10]]
                 note: moulding wraps, so 42 items becomes [10, 11, 12, ..., 48, 49, 50, 10]
        S  - sum (vectorises)                              e.g. [40, 11]
         S - sum                                           e.g. 51

05AB1E , 16 15 octets

Merci à Emigna d' avoir enregistré un octet!

ÎÙv¹y¢L<41%T+OO

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Perl 41 octets

Comprend +1 pour -p

$\+=$H{$_}+=$H{$_}?$H{$_}>49?-40:1:10;}{

Prend des informations sur les nouvelles lignes.

Incrémente une valeur de hachage de: 10 si c'est undef, -40si c'est-à- > 49dire 50, ou 1autrement. Ceci est ensuite ajouté au $\séparateur de sortie, que les -pimpressions.

Exemple:

$ echo -e 'A\nB\nA' | perl -pe '$\+=$H{$_}+=$H{$_}?$H{$_}>49?-40:1:10;}{'
31

05AB1E , 13 octets

{.¡€gL<41%T+O

Explication

["A","B","A"] utilisé comme exemple.

{               # sort input
                # STACK: ["A","A","B"]
 .¡             # split on different
                # STACK: [["A","A"],["B"]]
   €g           # length of each sublist
                # STACK: [2,1]
     L          # range [1 ... x] (vectorized)
                # STACK: [1,2,1]
      <         # decrease by 1
                # STACK: [0,1,0]
       41%      # mod 41
                # STACK: [0,1,0]
          T+    # add 10
                # STACK: [10,11,10]
            O   # sum
                # OUTPUT: 31

C ++ 14, 105 octets

En tant que lambda générique sans nom retournant via le paramètre de référence. Nécessite une entrée pour être un conteneur stringqui a push_back, commevector<string> .

Utiliser l' %41+10astuce de la réponse Python de Kade .

[](auto X,int&r){r=0;decltype(X)P;for(auto x:X){int d=0;for(auto p:P)d+=x==p;r+=d%41+10;P.push_back(x);}}

Crée un conteneur vide Pen mémoire de ce qui a déjà été servi. Le prix est calculé en comptant le xdansP .

Non golfé et utilisation:

#include<iostream>
#include<vector>
#include<string>

using namespace std;

auto f=
[](auto X, int& r){
  r = 0;
  decltype(X) P;
  for (auto x:X){
    int d = 0;
    for (auto p:P)
      d += x==p;
    r += d % 41 + 10;
    P.push_back(x);
  }
}
;

int main(){
 int r;
 vector<string> V;
 f(V,r);cout << r << endl;
 V={"A"};
 f(V,r);cout << r << endl;
 V={"A","B"};
 f(V,r);cout << r << endl;
 V={"A","B","C"};
 f(V,r);cout << r << endl;
 V={"A","A"};
 f(V,r);cout << r << endl;
 V={"A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A"};
 f(V,r);cout << r << endl;
 V={"A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","B","B","C","C","D"};
 f(V,r);cout << r << endl;
 V={"A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","A","B","C"};
 f(V,r);cout << r << endl;
}

Mathematica, 64 octets

On dirait que ça devrait être plus court.

Tr[(19+#)#/2&/@(Length/@Gather@#//.z_/;z>41:>Sequence[41,z-41])]&

Length/@Gather@#compte les répétitions de chaque boisson. //.z_/;z>41:>Sequence[41,z-41]divise tout entier zsupérieur à 41 en 41et z-41, pour refléter la baisse des prix. Ensuite, chacun des décomptes est branché à la formule (19+#)#/2, qui est le coût total des #boissons tant qu'il #ne dépasse pas 41. Enfin, Trrésume ces coûts.

k, 22 octets

L'argument peut être n'importe quelle liste - chaînes, chiffres, etc.

{+/,/10+(#:'=x)#\:!41}

La qtraduction est plus facile à lire:

{sum raze 10+(count each group x)#\:til 41}

C #, 193 octets + 33

33 octets supplémentaires pour using System.Collections.Generic;

void m(string[]a){int t=0;Dictionary<string,int>v=new Dictionary<string,int>();foreach(string s in a){if(v.ContainsKey(s)){v[s]=v[s]==50?10:v[s]+1;}else{v.Add(s,10);}t+=v[s];}Console.WriteLine(t);}

Je suis sûr que cela peut être ignoré, les dictionnaires ne sont certainement pas la meilleure façon de le faire et je pourrais probablement travailler un ternaire dans mon if. A part ça, je pense que ça va!

Exemples:

a = {"A", "A", "A", "B", "B", "C"};
//output = 64

a = {"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A",, "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A", "A" ,"A" "A" ,"A", "A" ,"A", "B", "B", "C"};
//output 727

Non golfé

void m(string[] a)
{
    int t=0;
    Dictionary<string,int> v = new Dictionary<string,int>();
    foreach(string s in a)
    {
        if(v.ContainsKey(s))
        {
            v[s]=v[s]==50?10:v[s]+1;
        }
        else
        {
            v.Add(s,10);
        }
        t+=v[s];
    }
    Console.Write(t);
}

Clojure, 79 octets

#(apply +(mapcat(fn[l](for[i(range l)](+(mod i 41)10)))(vals(frequencies %)))))

Compte les fréquences des boissons, puis calcule le prix de base comme 10 + (i % 41). mapcatles concatène et apply +calcule la somme.

PHP, 47 octets

while($k=$argv[++$i])$s+=10+$p[$k]++%41;echo$s;

prend l'entrée des arguments de la ligne de commande; courir avec -r.