Hasta la decimalización en 1971 , el dinero británico se basaba en dividir la libra en 240 centavos. Un chelín fue de 12 centavos, por lo que 20 chelines hicieron una libra. La denominación más pequeña era el pedo en un cuarto de un centavo. Había muchas otras denominaciones y apodos para las monedas, lo que puede ser bastante confuso si no estás acostumbrado al sistema.

Reto

Escriba un programa o función que pueda convertir (casi) cualquier denominación de dinero antiguo en inglés a cualquier otra. Para que sea más fácil para el usuario, debe admitir plurales y apodos.

Estas son las denominaciones y sus términos sinónimos que debe admitir. Por conveniencia, su valor en farthings lidera cada línea.

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

^{(No soy británico, esta lista no es de ninguna manera autorizada, pero será suficiente para el desafío).}

A través de stdin o argumento de función, debe tomar una cadena de la forma

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

y devolver o imprimir

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

donde [converted value]se [value to convert]convierten las unidades de denominación 1 en la denominación 2.

Los [value to convert]y [converted value]son flotadores positivos. En la salida, ambos deben redondearse o truncarse a 4 decimales. Si lo desea, puede suponer que [value to convert]siempre tiene un punto decimal y cero cuando ingresa (por ejemplo, en 1.0lugar de 1).

Las denominaciones 1 y 2 pueden ser dos términos de la lista anterior. No se preocupe si son plurales o no, trate todas las denominaciones y sinónimos de la misma manera. Puede suponer que el formato de entrada y las denominaciones son siempre válidas.

Ejemplos

1 pounds in shilling→ 1 pounds is 20 shilling
( 1.0000 pounds is 20.0000 shillingestaría bien)

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

Tanteo

El código más corto en bytes gana.

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

Más legible (las líneas nuevas y las sangrías deben eliminarse para ejecutarse):

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

Actualización: Resulta que es 1 carácter más corto (no se necesita espacio) para cortar la cadena en una lista de cadenas de 2 caracteres antes de ejecutar la operación de índice de cadena. /x"string"<b2 2-> xc"string"2<b2. Nada más necesita ser cambiado.

Cómo funciona:

• Utiliza el enfoque de @ xnor de buscar el valor de la moneda usando sus dos primeras letras, así como el truco de detectar la inicial halfo two, eliminarla y volver a llamar a la función.

• Para buscar el valor de los dos primeros caracteres, encuentra la ubicación de las dos primeras letras de la moneda en una cadena, luego se divide por 2 y toma el valor en ese índice en la lista. Esto es mucho más corto que un dict en pyth.

• Utiliza el hecho de que x(buscar dentro de la cadena) devuelve -1 en caso de no evitar poner po(libras) qu(quid) o so(soberanos) en la cadena, y simplemente devuelve el último elemento de la lista, 960, por defecto.

• Al reorganizar el orden de las monedas en el sistema de búsqueda e inicializar cuidadosamente, con K4y J24, se eliminaron todos los espacios que habrían sido necesarios para separar los números en la lista.

• Utiliza el operador de asignación dual de pyth A, en la entrada dividida inpara obtener el principio y el final de la entrada en variables separadas.

• Esencialmente realiza la misma búsqueda al final, aunque pyth no tiene .split(_,1), por lo que es algo más engorroso.

Ejemplos:

$ 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

Rubí, 345 306 302 288 287 278 273 253 252 242 232 221 202 190 bytes

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]}

Toma información de STDIN e imprime en STDOUT.

Estoy usando expresiones regulares cortas para hacer coincidir solo las denominaciones deseadas para cada valor. Hay dos matrices, una con expresiones regulares y otra con valores, en los índices correspondientes. La matriz regex es una matriz literal delimitada por espacios, y la matriz de valores está empaquetada en una cadena de caracteres UTF-8.

Estoy seleccionando el índice en los valores buscando una expresión regular que coincida con cada denominación. También estoy por defecto en el caso tuppence / half-groat (valor 8), porque eso requería la expresión regular más larga. Del mismo modo, algunos de los patrones suponen que otros valores ya han sido emparejados por patrones anteriores, por lo que cada expresión regular solo distingue el valor deseado solo de los restantes. Usando esto, probablemente podría recortar otro par de bytes reorganizando el orden de las denominaciones.

¡Gracias a Ventero por ayudarme a vencer a Pyth haciéndolo más corto!

Python 3: 264 239 caracteres

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 función fobtiene el valor de chelín de la cadena de moneda cal tomar las huellas digitales de las dos primeras letras usando el diccionario al encontrarlas en una cadena. Los prefijos "mitad" y "dos" se detectan y explican cortando el prefijo y el espacio y aplicando un multiplicador. Como "halfpenny" carece de un espacio después de "half", esto resulta en "enny", pero eso se maneja con una entrada ficticia "en".

Gracias a @isaacg y @grc por muchas mejoras en la búsqueda del diccionario.

Pitón 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

Requiere que el número de entrada sea flotante en Python, es decir 144.1

Creo que esto podría acortarse en Python 3 ...

... Confirmado gracias a @xnor. También confirmó que tener un mejor algoritmo importa mucho;)

Haskell - 315 bytes

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

Fui con un enfoque de función hash ... Creo que subestimé (relativamente) cuán complejo sería el procesamiento de entrada (sobre el enfoque de expresiones regulares, eso no le importaría el número).

Basado en la respuesta de @ FryAmTheEggMan, con una forma diferente de prueba str.startwith:

Pitón 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))

Esto obtiene el valor de cada moneda al compararlo con varias expresiones regulares, comenzando por la más amplia /t/; el valor se sobrescribe si se encuentra otra coincidencia. Puede haber una manera de reducir un par de bytes reordenando la cadena de expresiones regulares. Puede probarlo con el fragmento anterior (está formateado solo para usar cuadros de diálogo y eliminar las funciones de flecha ES6 para que todos puedan probar el código fácilmente). Gracias a Alconja por las sugerencias.