Fino alla decimalizzazione del 1971 , il denaro britannico si basava sulla divisione della sterlina in 240 centesimi. Uno scellino è stato di 12 centesimi quindi 20 scellini hanno fatto una sterlina. La più piccola denominazione era la scoreggia a un quarto di centesimo. C'erano molte altre denominazioni e soprannomi per le monete, che possono diventare abbastanza confusi se non sei abituato al sistema.

Sfida

Scrivi un programma o una funzione in grado di convertire (quasi) qualsiasi denominazione di denaro inglese antico in un'altra. Per rendere più semplice per l'utente è necessario supportare plurali e nickname.

Queste sono le denominazioni e i loro termini che devi supportare. Per praticità, il loro valore in termini di distanza conduce ad ogni linea.

1: farthing, farthings
2: halfpence, halfpenny, halfpennies
4: penny, pennies, pence, copper, coppers
8: twopenny, twopennies, twopence, tuppence, half groat, half groats
12: threepence, threepenny, threepennies, threepenny bit, threepenny bits, thruppence, thrupenny, thrupennies, thrupenny bit, thrupenny bits
16: groat, groats
24: sixpence, sixpenny, sixpennies, sixpenny bit, sixpenny bits, tanner, tanners
48: shilling, shillings, bob
96: florin, florins, two bob bit, two bob bits
120: half crown, half crowns
240: crown, crowns
480: half sovereign, half sovereigns
504: half guinea, half guineas
960: pound, pounds, pounds sterling, sovereign, sovereigns, quid, quids
1008: guinea, guineas

^{(Non sono britannico, questo elenco non è affatto autorevole ma sarà sufficiente per la sfida.)}

Tramite stdin o argomento della funzione dovresti prendere una stringa del modulo

[value to convert] [denomination 1] in [denomination 2]

e ritorna o stampa

[value to convert] [denomination 1] is [converted value] [denomination 2]

dove [converted value]sono le [value to convert]unità della denominazione 1 convertite nella denominazione 2.

I [value to convert]e [converted value]sono galleggianti positivi. Nell'output entrambi devono essere arrotondati o troncati con 4 cifre decimali. Se lo si desidera, si può presumere che [value to convert]abbia sempre un punto decimale e zero quando si immette (ad es. 1.0Anziché1 ).

Le denominazioni 1 e 2 possono essere due termini dall'elenco precedente. Non preoccuparti se sono plurali o meno, tratta allo stesso modo tutte le denominazioni e i sinonimi. Si può presumere che il formato di input e le denominazioni siano sempre valide.

Esempi

1 pounds in shilling → 1 pounds is 20 shilling
( 1.0000 pounds is 20.0000 shillingandrebbe bene)

0.6 tuppence in tanner → 0.6 tuppence is 0.2 tanner

24 two bob bits in pounds sterling → 24 two bob bits is 2.4 pounds sterling

144 threepennies in guineas → 144 threepennies is 1.7143 guineas

punteggio

Vince il codice più breve in byte .

Pyth , 146 145

K4J24L?*y>b-5>b\t?2>b\t.5}<b2"hatw"@[1K8K12K16J48J1008*JT96*2J960)xc"fapetucothengrsishtagucrflbo"2<b2AGHcz" in"++G%" is %0.4f"*vhcGdcyjdtcGdytHH

Più leggibile (le righe e i rientri devono essere rimossi per essere eseguiti):

K4J24
L?*y>b-5>b\t?2>b\t.5
  }<b2"hatw"
  @[1K8K12K16J48J1008*JT96*2J960)
   xc"fapetucothengrsishtagucrflbo"2<b2
AGHcz" in"
++G
  %" is %0.4f"
   *vhcGdcyjdtcGdytH
 H

Aggiornamento: si scopre che è più corto di 1 carattere (non è necessario spazio) per tagliare la stringa in un elenco di 2 stringhe di caratteri prima di eseguire l'operazione dell'indice di stringa. /x"string"<b2 2-> xc"string"2<b2. Nient'altro deve essere cambiato.

Come funziona:

• Questo utilizza l'approccio di @ xnor di cercare il valore della valuta usando le sue prime due lettere, così come il trucco di rilevare l'iniziale halfo two, rimuoverlo e richiamare nuovamente la funzione.

• Per cercare il valore dei primi due caratteri, trova la posizione delle prime due lettere della valuta in una stringa, quindi si divide per 2 e assume il valore di quell'indice nell'elenco. Questo è molto più breve di un dict in Pyth.

• Utilizza il fatto che x(trova all'interno della stringa) restituisce -1 in caso di errore per evitare di inserire po(libbre) qu(quid) o so(sovrani) nella stringa e restituisce semplicemente l'ultimo elemento dell'elenco, 960, per impostazione predefinita.

• Riorganizzando l'ordine delle valute nel sistema di ricerca e inizializzando attentamente, con K4e J24, tutti gli spazi che sarebbero stati necessari per separare i numeri nell'elenco sono stati rimossi.

• Utilizza l'operatore di doppia assegnazione di pyth A, sull'input diviso inper ottenere l'inizio e la fine dell'input in variabili separate.

• Fa essenzialmente la stessa ricerca alla fine, anche se pyth non ha .split(_,1), quindi è un po 'più ingombrante.

Esempi:

$ pyth programs/currency.pyth <<< '5 florins in half guineas'
5 florins is 0.9524 half guineas

$ pyth programs/currency.pyth <<< '0.4 quid in sixpenny bits'
0.4 quid is 16.0000 sixpenny bits

Rubino, 345 306 302 288 287 278 273 253 252 242 232 221 202 190 byte

f=->s{" !#+/7OďǿȗϟЏ'"[%w{fa fp ^pe|co r..p ^gr x|ta sh|^b fl|b f.c ^c f.s .gu d|v ^g .}.index{|k|s[/#{k}/]}].ord-31}
$><<gets.sub(/ (.+ i)n /){" #{r=$1}s %0.4f ".%$`.to_f/f[$']*f[r]}

Riceve input da STDIN e stampa su STDOUT.

Sto usando brevi espressioni regolari per abbinare solo le denominazioni desiderate per ciascun valore. Esistono due matrici, una con regex e una con valori, con indici corrispondenti. L'array regex è un array delimitato da spazi letterale e l'array value è compresso in una stringa di caratteri UTF-8.

Sto selezionando l'indice nei valori cercando una regex che corrisponda a ciascuna denominazione. Sto anche inadempiendo al caso tuppence / half-groat (valore 8), perché quello richiedeva la regex più lunga. Allo stesso modo, alcuni dei modelli presuppongono che altri valori siano già stati associati a modelli precedenti, quindi ogni regex distingue solo il valore desiderato solo da quelli rimanenti. Usando questo, potrei probabilmente radere via un altro paio di byte riorganizzando l'ordine delle denominazioni.

Grazie a Ventero per avermi aiutato a battere Pyth rendendolo più breve!

Python 3: 264 239 caratteri

f=lambda c:c[:2]in"hatw"and f(c[5-(c>'t'):])*2/4**(c<'t')or[1,4,4,4,8,12,16,24,24,48,48,96,240,1008,960]['fapecoentuthgrsitashboflcrgu'.find(c[:2])//2]
a,b=input().split(" in ")
x,c=a.split(" ",1)
print(a,"is %0.4f"%(eval(x)*f(c)/f(b)),b)

La funzione fottiene il valore shilling della stringa cdi valuta imprimendo le prime due lettere usando il dizionario trovandole in una stringa. I prefissi "metà" e "due" vengono rilevati e considerati tagliando il prefisso e lo spazio e applicando un moltiplicatore. Poiché "halfpenny" manca di spazio dopo "half", questo si traduce in "enny", ma viene gestito con una voce "en" fittizia.

Grazie a @isaacg e @grc per molti miglioramenti nella ricerca del dizionario.

Python 2 - 345 358

s=str.startswith
h='half'
u,v=raw_input().split(' in ')
a,b=u.split(' ',1)
C=dict(fa=1,pe=4,twop=8,tu=8,thr=12,gr=16,si=24,ta=24,sh=48,b=48,fl=96,c=240,po=960,so=960,q=960,gu=1008)
C.update({h+'p':2,h+' gr':8,'two ':96,h+' c':120,h+' s':480,h+' gu':504})
for c in iter(C):
 if s(b,c):k=C[c]
 if s(v,c):f=C[c]
print u+' is %0.4f '%(eval(a)*k/f)+v

Richiede che il numero di input sia un float in python ie 144.1

Penso che questo potrebbe essere abbreviato in Python 3 ...

... Confermato grazie a @xnor. Ha anche confermato che avere un algoritmo migliore è molto importante;)

Haskell - 315 byte

w x=f(u x)*v(u x)
f=maybe 1 id.l"ha tw tu th si"[0.5,2,2,3,6]
v x@(_:xs)|Just w<-l"bo cr gr gu so co fa fl pe po qu sh ta"[12,60,4,252,240,1,0.25,24,1,240,240,12,6]x=w|True=v xs
l k v x=take 2 x`lookup`zip(words k)v
u=unwords
i s|(n:x,_:t)<-span(/="in")$words s=u$n:x++["is",show$read n*w x/w t]++t
main=interact i

JavaScript (ES5), 344

I=prompt()
n=I.match(/[\d.]+ /)[0]
A=I.slice(n.length).split(" in ")
function m(x){return{fi:1,he:2,p:4,pe:4,cr:4,tn:8,hg:8,tp:12,te:12,g:16,gs:16,sn:24,tr:24,si:48,b:48,fn:96,to:96,hc:120,c:240,cs:240,hs:480,hgtrue:504,ps:960,se:960,q:960,ga:1008}[x[0]+(x[5]||"")+(x[10]=="a"||"")]}
alert(n+A[0]+" is "+(n*m(A[0])/m(A[1])).toFixed(4)+" "+A[1])

Sono andato con un approccio con funzione hash ... Penso di aver sottovalutato (relativamente) quanto complesso sarebbe il processo di input (rispetto all'approccio regex, che non mi importerebbe del numero).

Basato sulla risposta di @ FryAmTheEggMan, con un modo diverso di testare str.startwith :

Python 2: 317

h='half'
C=dict(fa=1,pe=4,twop=8,tu=8,thr=12,gr=16,si=24,ta=24,sh=48,b=48,fl=96,c=240,po=960,so=960,q=960,gu=1008)
C.update({h+'p':2,h+' gr':8,'two ':96,h+' c':120,h+' s':480,h+' gu':504})
u,v=raw_input().split(' in ')
a,b=u.split(' ',1)
s=lambda x:x and C.get(x, s(x[:-1]))
print u+' is %0.4f '%(eval(a)*s(b)/s(v))+v

JavaScript ES6, 264 273

f=t=>{s=t.split(x=' in')
c=d=>{'t0sh|bo0^p|co0f0fp0fl|b b0gu0d|v0wn0gr0f g|t..?p0f s0f gu0f c0x|an'.split(0).map((e,i)=>{v=s[d].match(e)?[12,48,4,1,2,96,1008,960,240,16,8,480,504,120,24][i]:v})
return v}
return s.join(' is '+~~(1e4*t.split(' ')[0]*c(0)/c(1))/1e4)}

t=prompt()
s=t.split(x=' in')
c=function(d){'t0sh|bo0^p|co0f0fp0fl|b b0gu0d|v0wn0gr0f g|t..?p0f s0f gu0f c0x|an'.split(0).map(function(e,i){v=s[d].match(e)?[12,48,4,1,2,96,1008,960,240,16,8,480,504,120,24][i]:v})
return v}
alert(s.join(' is '+~~(1e4*t.split(' ')[0]*c(0)/c(1))/1e4))

Questo ottiene il valore di ogni valuta controllandola con varie regex, a partire dalla più ampia /t/; il valore viene sovrascritto se viene rilevata un'altra corrispondenza. Potrebbe esserci un modo per radere via un paio di byte riordinando la stringa regex. Puoi testarlo usando lo snippet sopra (È formattato solo per usare le finestre di dialogo e rimuovere le funzioni della freccia ES6 in modo che tutti possano testare facilmente il codice). Grazie ad Alconja per i suggerimenti.