Vorstellung und Anerkennung

Angenommen, Sie sind ein Barkeeper. Sie haben meistens viele fröhliche Menschen in Ihrer Bar, aber viele trinken immer nur das gleiche Getränk und zu wenig für Ihren Geschmack, und das möchten Sie ändern. Sie führen also ein System ein, bei dem der Preis eines Getränks variabel ist, je nachdem, wie viele bereits verkauft wurden, jedoch niemals mehr oder weniger als bestimmte Schwellenwerte. Aus seltsamen Gründen vergessen Sie immer, alle verkauften Getränke und Preise im Auge zu behalten, und müssen sich daher einen kurzen (= einprägsamen!) Code überlegen, der die Berechnung für Sie in Anbetracht der konsumierten Getränkemenge durchführt.

Diese Herausforderung ist bereits in der Zwischenprüfung im Jahr 2012 im Rahmen des Kurses für funktionale Programmierung an meiner Uni aufgetreten, und ich habe die Berechtigung meines Professors, sie hier zu veröffentlichen. Wir haben eine Musterlösung in der Prüfungssprache erhalten.

Eingang

Ihre Eingabe wird eine Liste von Zeichenfolgen sein, die keine Leerzeichen enthalten - dies sind die Namen der verkauften Getränke. Verwenden Sie für die Eingabe Ihre bevorzugte, allgemein akzeptierte Eingabemethode.

Ausgabe

Ihre Ausgabe wird eine einzelne Zahl sein - dies ist das Einkommen, das Sie an diesem Abend generiert haben. Geben Sie die Ausgabe mit Ihrer bevorzugten, allgemein akzeptierten Ausgabemethode an.

Was ist zu tun?

Dies gilt für jedes Getränk einzeln:

• Der Einstiegspreis beträgt 10.
• Jedes Mal, wenn das Getränk gekauft wird, wird der Preis für den nächsten Käufer um 1 erhöht.
• Der Höchstpreis beträgt 50. Wenn das Getränk für 50 gekauft wurde, beträgt der neue Preis wieder 10.

Ihre Aufgabe ist es, das Gesamteinkommen zu ermitteln, das aus der eingegebenen Getränkeliste nach den oben genannten Regeln generiert wird.

Falls Sie sich fragen: "50 Dollar sind wirklich verdammt teuer für ein Getränk!", Das sind 50-Dezi-Dollar, also 50 * 0,1 * Einheiten, aber ich habe mich für 10-50 entschieden, um Sprachen nicht auszuschließen, ohne Gleitkomma-Arithmetik.

Wer gewinnt?

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes! Es gelten Standardregeln.

Mögliche Eckfälle

Wenn die Eingabeliste leer ist, muss die Ausgabe 0 sein.
Es kann nicht davon ausgegangen werden, dass die Eingabeliste nach Getränken sortiert ist.

Beispiele

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

Die Anzahl der massiven Bytes erhöht sich, indem das Problem überarbeitet wird. Ich möchte die intBesetzung loswerden , aber mein Gehirn funktioniert nicht . Die Nutzung von l.pop()zu vermeiden , dass die Liste Trimmen zweimal und einige gute alte Lambda Rekursion :)

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

^{Danke an Jonathan Allan für das Speichern von 6 Bytes :)}

Auf meine alte 54-Byte-Version war ich sehr stolz :)

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

Pyth, 15 Bytes

ssm<*lQ}T50/Qd{

Ein Programm, das eine Liste eingibt und das Ergebnis druckt.

Testsuite (Erste Zeile, um mehrere Eingaben zuzulassen)

Wie es funktioniert

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

Jelly , 14 11 10 Bytes

50⁵rṁЀĠSS

TryItOnline!

Wie?

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

Danke an Emigna für das Speichern eines Bytes!

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Perl 41 Bytes

Beinhaltet +1 für -p

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

Nimmt Eingaben in Zeilenumbrüchen vor.

Inkrementiert einen Hash-Wert um: 10 Wenn ja undef, -40wenn > 49ja 50, oder auf 1andere Weise. Dies wird dann zum $\Ausgabetrenner hinzugefügt , den der Drucker -pdruckt.

Beispiel:

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

05AB1E , 13 Bytes

{.¡€gL<41%T+O

Erläuterung

["A","B","A"] als Beispiel verwendet.

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

Als generisches unbenanntes Lambda, das über den Referenzparameter zurückgegeben wird. Benötigt Eingabe, um ein Container zu sein string, der hat push_back, wie vector<string>.

Verwenden Sie den %41+10Trick aus Kades Python-Antwort .

[](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);}}

Erstellt einen leeren Container Pals Speicher, der bereits bedient wurde. Der Preis wird durch Zählen der xIn berechnet P.

Ungolfed und Nutzung:

#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

Das Gefühl, es sollte kürzer sein.

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

Length/@Gather@#zählt die Wiederholungen jedes Getränks. //.z_/;z>41:>Sequence[41,z-41]Teilt eine ganze Zahl züber 41 in 41und z-41, um den Preisverfall widerzuspiegeln. Dann wird jede der Zählungen in die Formel eingefügt (19+#)#/2, bei der es sich um die Gesamtkosten von #Getränken handelt, solange sie #höchstens 41 Trbetragen. Fasst schließlich diese Kosten zusammen.

k, 22 Bytes

Das Argument kann eine beliebige Liste sein - Zeichenfolgen, Zahlen usw.

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

Die qÜbersetzung ist leichter zu lesen:

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

C #, 193 Bytes + 33

Weitere 33 Bytes für 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);}

Ich bin mir sicher, dass dies in Vergessenheit geraten kann. Wörterbücher sind definitiv nicht der beste Weg, dies zu tun, und ich könnte wahrscheinlich einen Ternär in mein Wenn einarbeiten. Ansonsten finde ich es okay!

Beispiele:

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

Zählt die Häufigkeit von Getränken und berechnet dann den Grundpreis als 10 + (i % 41). mapcatverkettet sie und apply +berechnet die Summe.

PHP, 47 Bytes

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. renn mit -r.