Introdução e crédito

Suponha que você é um barman. Você tem muitas pessoas felizes em seu bar na maioria das vezes, mas muitas só bebem a mesma bebida e são poucas para o seu gosto e você quer mudar isso. Então, você introduz um sistema em que o preço de uma bebida é variável, dependendo de quantos já foram vendidos, mas nunca mais ou menos caro que certos limites. Por alguma estranha razão, você sempre se esquece de acompanhar adequadamente todas as bebidas e preços vendidos e, portanto, precisa pensar em um pequeno código (= memorável!) Que faz as contas para você, considerando a quantidade de bebidas consumidas.

Esse desafio já apareceu no exame intermediário de 2012, no curso de programação funcional da minha universidade, e eu tenho a aprovação do meu professor para publicá-lo aqui. Nos foi fornecida uma solução de exemplo no idioma do exame.

Entrada

Sua entrada será uma lista de cadeias que não contêm espaços - esses são os nomes das bebidas vendidas. Faça a entrada usando o seu método de entrada preferido, geralmente aceito.

Resultado

Sua saída será um número único - essa é a renda que você gerou esta noite. Forneça a saída usando seu método de saída preferido e geralmente aceito.

O que fazer?

Isso se aplica a cada bebida individualmente:

• O preço inicial é 10.
• Cada vez que a bebida é comprada, seu preço é aumentado em 1 para o próximo comprador.
• O preço máximo é 50. Se a bebida tiver sido comprada por 50, o novo preço será 10 novamente.

Sua tarefa é encontrar a renda geral, gerada pela lista de entrada de bebidas, de acordo com as regras acima.

Caso você esteja se perguntando: "50 dólares é realmente muito caro para uma bebida!", Isso é 50 dólares deci, então 50 * 0,1 * unidade, mas eu optei por 10-50 para não excluir idiomas sem aritmética de ponto flutuante.

Quem ganha?

Isso é código-golfe , então o código mais curto em bytes vence! Aplicam-se regras padrão.

Casos de canto em potencial

Se a lista de entrada estiver vazia, a saída será 0.
A lista de entrada não pode ser considerada como classificada por bebida.

Exemplos

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

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

Python 2, 79 74 54 48 bytes

Aumento maciço da contagem de bytes repensando o problema. Eu gostaria de me livrar do intelenco, mas meu cérebro não está funcionando . Fazendo uso l.pop()para evitar aparar a lista duas vezes e alguma boa e velha recursão lambda :)

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

^{graças a Jonathan Allan por salvar 6 bytes :)}

Minha versão antiga de 54 bytes da qual me orgulhava bastante :)

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

Pitão, 15 bytes

ssm<*lQ}T50/Qd{

Um programa que recebe a entrada de uma lista e imprime o resultado.

Conjunto de testes (primeira linha para permitir múltiplas entradas)

Como funciona

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éia , 14 11 10 bytes

50⁵rṁЀĠSS

TryItOnline!

Quão?

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 bytes

Agradecemos a Emigna por salvar um byte!

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

Usa a codificação CP-1252 . Experimente online!

Perl 41 bytes

Inclui +1 para -p

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

Recebe entrada em novas linhas.

Incrementos de um valor de hash: 10 se é undef, -40se é > 49ou seja 50, ou 1o contrário. Isso é então adicionado ao $\separador de saída, que é -pimpresso.

Exemplo:

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

05AB1E , 13 bytes

{.¡€gL<41%T+O

Explicação

["A","B","A"] usado como exemplo.

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

Como lambda sem nome genérico retornando via parâmetro de referência. Requer entrada para ser um contêiner stringque possui push_back, como vector<string>.

Usando o %41+10 truque da resposta 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);}}

Cria um contêiner vazio Pcomo memória o que já foi servido. O preço é calculado contando o xpol P.

Ungolfed e uso:

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

Parece que deve ser mais curto.

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

Length/@Gather@#conta as repetições de cada bebida. //.z_/;z>41:>Sequence[41,z-41]divide qualquer número inteiro zsuperior a 41 em 41e z-41para refletir a queda de preço. Em seguida, cada uma das contagens é conectada à fórmula (19+#)#/2, que é o custo total das #bebidas contanto que #seja no máximo 41. Finalmente, Trresume esses custos.

k, 22 bytes

O argumento pode ser qualquer lista - seqüências de caracteres, números etc.

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

A qtradução é mais fácil de ler:

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

C #, 193 bytes + 33

33 bytes extras para 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);}

Tenho certeza de que isso pode ser jogado no esquecimento, os dicionários definitivamente não são a melhor maneira de fazer isso e eu provavelmente poderia trabalhar um ternário no meu if. Além disso, acho que está tudo bem!

Exemplos:

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 bytes

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

Conta as frequências de bebidas e calcula o preço base como 10 + (i % 41). mapcatconcatena-os e apply +calcula a soma.

PHP, 47 bytes

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

recebe entrada dos argumentos da linha de comando; corra com -r.