Introduzione e credito

Supponi di essere un barista. Ci sono molte persone felici nel tuo bar nella maggior parte dei casi, ma molti bevono sempre la stessa bevanda e troppo pochi per i tuoi gusti e vuoi cambiarlo. Quindi si introduce un sistema in cui il prezzo di una bevanda è variabile, a seconda di quante ne sono già state vendute, ma mai più o meno costose di determinate soglie. Per qualche strana ragione ti dimentichi sempre di tenere traccia di tutte le bevande e dei prezzi venduti e quindi devi pensare a un breve codice (= memorabile!) Che fa la matematica per te data la quantità di bevande consumate.

Questa sfida è già apparsa nell'esame di metà mandato nel 2012 al corso di programmazione funzionale presso la mia università e ho il mio professore che è d'accordo a pubblicarlo qui. Ci è stata fornita una soluzione di esempio nella lingua dell'esame.

Ingresso

Il tuo input sarà un elenco di stringhe che non contengono spazi: questi sono i nomi delle bevande vendute. Prendi l'input usando il tuo metodo di input preferito, generalmente accettato.

Produzione

Il tuo output sarà un singolo numero - questo è il reddito che hai generato stasera. Dai l'output usando il tuo metodo di output preferito, generalmente accettato.

Cosa fare?

Questo vale per ogni bevanda individualmente:

• Il prezzo di partenza è di 10.
• Ogni volta che la bevanda viene acquistata, il suo prezzo viene aumentato di 1 per l'acquirente successivo.
• Il prezzo massimo è 50. Se la bevanda è stata acquistata per 50, il nuovo prezzo sarà di nuovo 10.

Il tuo compito è quello di trovare il reddito complessivo, generato dalla lista di input di bevande date le regole di cui sopra.

Nel caso ti stia chiedendo: "50 dollari sono davvero dannatamente costosi per un drink!", Si tratta di 50 dollari decimi, quindi unità 50 * 0,1 *, ma ho optato per 10-50 per non escludere le lingue senza aritmetica in virgola mobile.

Chi vince?

Questo è code-golf , quindi vince il codice più corto in byte! Si applicano le regole standard.

Casi d'angolo potenziali

Se l'elenco di input è vuoto, l'output deve essere 0.
L'elenco di input non può essere ordinato per bevanda.

Esempi

[] -> 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 byte

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

Python 2, 79 74 54 48 byte

Il massiccio conteggio dei byte aumenta ripensando il problema. Vorrei liberarmi del intcast ma il mio cervello non funziona . Fare uso di l.pop()per evitare di tagliare due volte l'elenco e qualche buona vecchia ricorsione lambda :)

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

^{grazie a Jonathan Allan per aver salvato 6 byte :)}

La mia vecchia versione a 54 byte di cui ero abbastanza orgoglioso :)

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

Pyth, 15 byte

ssm<*lQ}T50/Qd{

Un programma che accetta l'inserimento di un elenco e stampa il risultato.

Suite di test (prima riga per consentire input multipli)

Come funziona

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

Gelatina , 14 11 10 byte

50⁵rṁЀĠSS

TryItOnline!

Come?

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 byte

Grazie a Emigna per aver salvato un byte!

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

Utilizza la codifica CP-1252 . Provalo online!

Perl 41 byte

Include +1 per -p

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

Riceve input su newline.

Incrementa un valore di hash di: 10 se è undef, -40se è > 49cioè 50o 1altrimenti. Questo viene quindi aggiunto al $\separatore di output che -pstampa.

Esempio:

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

05AB1E , 13 byte

{.¡€gL<41%T+O

Spiegazione

["A","B","A"] usato come esempio.

{               # 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 byte

Come lambda generico senza nome che ritorna tramite parametro di riferimento. Richiede input per essere un contenitore stringche ha push_back, comevector<string> .

Usando il %41+10trucco della risposta Python di 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);}}

Crea un contenitore vuoto Pcome memoria che è già stato servito. Il prezzo è calcolato contando il xinP .

Ungolfed e utilizzo:

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

Sembra che dovrebbe essere più breve.

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

Length/@Gather@#conta le ripetizioni di ogni bevanda. //.z_/;z>41:>Sequence[41,z-41]divide in questo qualsiasi numero intero zsuperiore a 41 in 41e z-41, per riflettere il calo dei prezzi. Quindi, ciascuno dei conteggi viene inserito nella formula (19+#)#/2, che è il costo totale delle #bevande fino #a un massimo di 41. Infine, Trriassume tali costi.

k, 22 byte

L'argomento può essere qualsiasi elenco: stringhe, numeri, ecc.

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

La qtraduzione è più facile da leggere:

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

C #, 193 byte + 33

Ulteriori 33 byte per 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);}

Sono sicuro che questo può essere portato all'oblio, i dizionari non sono sicuramente il modo migliore per farlo e probabilmente potrei lavorare un ternario nel mio if. A parte questo, penso che vada bene!

Esempi:

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

Ungolfed

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 byte

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

Conta le frequenze delle bevande, quindi calcola il prezzo base come 10 + (i % 41). mapcatli concatena e apply +calcola la somma.

PHP, 47 byte

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

accetta input dagli argomenti della riga di comando; corri con -r.