Costi delle risorse della rete elettrica

introduzione

Nel gioco da tavolo Power Grid , una parte integrante del gioco è l'atto di acquistare risorse per alimentare le tue centrali elettriche. Esistono quattro tipi di risorse utilizzate nel gioco (cinque, se includi energia rinnovabile, ma ovviamente non puoi acquistare risorse per questo). Questi sono carbone, petrolio, immondizia e uranio. Il mercato delle risorse si presenta così:

1---- | 2---- | 3---- | 4---- | 5---- | 6---- | 7---- | 8---- | 10  | 12
CCC   | CCC   | CCC   | CCC   | CCC   | CCC   | CCC   | CCC   |  U  |  U
OOO U | OOO U | OOO U | OOO U | OOO U | OOO U | OOO U | OOO U | 14  | 16
GGG   | GGG   | GGG   | GGG   | GGG   | GGG   | GGG   | GGG   |  U  |  U

Quando le risorse vengono acquistate, vengono prelevate dalla sinistra del mercato, dove sono più economiche. Quando nuove risorse vengono aggiunte al mercato, vengono aggiunte da destra. Come si può vedere, questo produce un equilibrio tra domanda e offerta: se vengono acquistate più risorse di un determinato tipo di quelle che vengono rifornite ogni round, il prezzo di quella risorsa aumenterà. Allo stesso modo, se è inferiore, il costo si ridurrà.

Carbone, petrolio e immondizia aumentano tutti di costo alla stessa velocità, mentre l'uranio si ridimensiona molto più velocemente. Una singola unità di una risorsa non uranio costa 8 - floor((<units available> - 1) / 3). Una singola unità di Uranio costa 13 - <units available>se ci sono 5 o più unità disponibili e in caso 18 - (2 * <units available>)contrario.

Ad esempio, all'inizio del gioco ci sono tutte e 24 le unità di carbone disponibili per l'acquisto. Se il primo giocatore desidera acquistare 4 unità di carbone, le prime tre unità costerebbero 1 ciascuna e il 4 costerebbe 2, rendendo il costo totale 5. Questo lascia 20 unità disponibili. Se il secondo giocatore desidera acquistare anche 4 unità di carbone, il costo sarebbe (2 * 2 + 2 * 3) = 10.

La sfida

La tua sfida è quella di scrivere un programma o una funzione che calcoli il costo di acquisto di una determinata quantità di una determinata risorsa, supponendo che ci sia una determinata quantità di quella risorsa presente sul mercato.

L'invio deve accettare, in qualsiasi formato di input ragionevole e in qualsiasi ordine, i seguenti parametri:

• Il tipo di risorsa - garantito per essere uno di [C, O, G, U].
• La quantità di quella risorsa presente sul mercato - garantita come un numero intero non negativo. Se il tipo di risorsa non è U, non sarà maggiore di 24. Se il tipo di risorsa è U, non sarà maggiore di 12.
• La quantità di quella risorsa che un giocatore vorrebbe acquistare - è garantita come un numero intero non negativo che è inferiore o uguale alla quantità già presente sul mercato.

L'output dovrebbe essere il costo delle risorse richieste.

Regole aggiuntive

• Le formule fornite sono solo a scopo illustrativo, non esitate a utilizzare qualsiasi metodo di calcolo dei costi che ti piace.
• I codici lettera per i diversi tipi di risorse (C, O, G, U) possono essere sostituiti dai loro equivalenti minuscoli. È inoltre possibile sostituire le lettere per i numeri, nel modulo C=0, O=1, G=2, U=3o C=1, O=2, G=3, U=4.
• Questo è code-golf , quindi il più piccolo invio in byte sarà il vincitore.
• Se l'invio richiede l'inserimento in un ordine o formato diverso da quello specificato nella sezione precedente, è necessario fornire dettagli.

Casi test

Formato del test case:

resource type, amount in market, amount to buy
> result

Casi test:

C, 24, 4
> 5

C, 20, 4
> 10

O, 3, 3
> 24

U, 1, 1
> 16

C, 1, 1
> 8

G, 0, 0
> 0

O, 10, 7
> 44

U, 12, 4
> 10

G, 11, 4
> 22

Javascript (ES6), 71 59 byte

f=(t,m,b)=>b&&(t>2?m>4?13-m:18-m*2:9+~(~-m/3))+f(t,m-1,b-1)

Prende type, market_amounte buy_amountcome argomenti. typeè un numero intero compreso tra 0 e 3.

dimostrazione

f=(t,m,b)=>b&&(t>2?m>4?13-m:18-m*2:9+~(~-m/3))+f(t,m-1,b-1)
function run() { var tests = document.getElementById("tests").value.split("\n"), test, C = 0, O = 1, G = 2, U = 3; console.clear(); for (var test of tests) { console.log(test); console.log("> " + eval(test)); } }

<textarea rows="10" id="tests">f(C, 24, 4)&#10;f(C, 20, 4)&#10;f(O, 3, 3)&#10;f(U, 1, 1)&#10;f(C, 1, 1)&#10;f(G, 0, 0)&#10;f(O, 10, 7)&#10;f(U, 12, 4)&#10;f(G, 11, 4)</textarea><br/><button onclick="run()">Run</button>

Python 3, 71 69 byte

Grazie a @xnor per -2 byte

f=lambda r,a,b:b and[8-int(~-a/3),max(18-2*a,13-a)][r>2]+f(r,a-1,b-1)

Una funzione che accetta input tramite argomento del tipo di risorsa con indice zero r, l'importo disponibile ae l'importo da acquistareb e restituisce il costo.

Questo fa uso del fatto che Trueed Falseequivale a 1e 0in Python, consentendo l'uso delle espressioni booleane di indicizzarle in elenchi.

Come funziona

f=lambda r,a,b           Function with input resource type r, amount available a and amount
                         to buy b
b and...                 Base case: return 0 if b=0
[8-int(~-a/3),...][r>2]  If not uranium, yield the unit cost 8-floor((a-1)/3)...
max(18-2*a,13-a)         ..else yield the current uranium unit cost
...f(r,a-1,b-1)          Decrement a and b, then pass to function
...+...                  Add the cost of each unit to give the total cost
:...                     Return the above

Provalo su Ideone

Befunge, 142 byte

&2`#v_&&>:!#v_\:1-3/8\-v
v:&&<   ^-1\ -1p15+g15 <
v>#<v       <
! v5<
# 1:
>^g-
| 81
\ 4\
: *-
4 -1
` .p
# @^15+g15<
>:49+\-   ^
|
>:2*92*\- ^

Provalo qui!Prende l'input come 3 numeri interi, dove il tipo di risorsa è 0,1,2,3. L'output è un numero intero.

Non ho idea se questo può essere giocato a golf meglio. Non c'è molto spazio bianco, ma le nuove linee probabilmente fanno male.

Python 2.7, 85 byte:

F,G,H=input();B=0;exec"B+=[[18-(2*G),13-G][G>5],8-((G-1)/3)][F!='U'];G-=1;"*H;print B

Basato sulla risposta di R. Kap, ma puoi radere un byte fino a 85 rimuovendo la divisione extra / for floor. Poiché questi sono tutti numeri interi, viene automaticamente ridotto a un numero intero.

Python 2.7, 86 byte:

F,G,H=input();B=0;exec"B+=[[18-(2*G),13-G][G>5],8-((G-1)//3)][F!='U'];G-=1;"*H;print B

Accetta input da un array nel formato [resource type, units available, units to purchase]. L'output è un numero intero. Proverò a giocare a golf più nel tempo.

Provalo online! (Ideone)

Lua, 107 101 byte

Funzione ricorsiva che deve essere chiamata con f(resource,stock,buy). la risorsa deve essere un numero compreso tra 0 e 3. L'output viene eseguito tramite il valore restituito.

Grazie LeakyNun per avermi salvato 6 byte: (25-y+(y-1)%3)/3è più corto di 8-math.floor((y-1)/3)5 byte e mi permette di guadagnare un byte in più grazie al suo posizionamento.

function f(x,y,z)return z<1 and 0or(x<3 and(25-y+(y-1)%3)/3or(y<5 and 18-y*2or 13-y))+f(x,y-1,z-1)end

Ungolfed

function f(x,y,z)                      -- define a function f with 3 parameters
  return z<1                           -- if we don't buy anything else
           and 0                       --   return 0
         or(                           -- else
           x<3                         --   if we're not buying Uranium
             and (25-y+(y-1)%3)/3      --     return 8-floor((stock-1)/3)                       
           or(y<5                      --   elseif there's less than 5 Uranium left
                and 18-y*2             --     return 18-stock*2
              or 13-y))                --   else return 13-stock
         +f(x,y-1,z-1)                 -- if we bought this iteration
                                       -- add f(resource,stock-1,toBuy-1) 
                                       -- to the returned value
end

Puoi testare questo codice online copiando e incollando il seguente frammento.

function f(x,y,z)return z<1 and 0or(x<3 and(25-y+(y-1)%3)/3or(y<5 and 18-y*2or 13-y))+f(x,y-1,z-1)end
print(f(1,24,4))
print(f(2,20,4))
print(f(0,10,7))
print(f(3,1,1))
print(f(3,12,4))