直到1971年十进制化，英国货币的基础是将英镑分为240便士。一先令为12便士，所以20先令等于一磅。最小的面额是一分钱的四分之一。硬币还有许多其他面额和昵称，如果您不习惯该系统，可能会造成很多困惑。

挑战

编写一个程序或函数，可以将（几乎）任何面额的旧英语货币转换为其他任何货币。为了使用户更轻松，您需要支持复数形式和昵称。

这些是您必须支持的面额及其同义词。为方便起见，它们在零食中的价值领先于每一行。

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

^{（我不是英国人，此列表绝不权威，但足以应付挑战。）}

通过stdin或function参数，您应该采用以下形式的字符串

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

并返回或打印

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

其中[converted value]是[value to convert]面额1的单位转换为现金种类2。

该[value to convert]和[converted value]是正的浮动。在输出中，两者都应四舍五入或舍入到小数点后4位。如果需要，您可以假设[value to convert]输入时总是有一个小数点和零（例如1.0代替1）。

命名1和2可以是上面列表中的任何两个术语。不必担心它们是否为复数，将所有面额和同义词都一样。您可以假设输入格式和面额始终有效。

例子

1 pounds in shilling→ 1 pounds is 20 shilling
（1.0000 pounds is 20.0000 shilling可以）

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

计分

以字节为单位的最短代码获胜。

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

更具可读性（必须删除换行符和缩进才能运行）：

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

更新：结果是，在运行字符串索引操作之前，将字符串切成2个字符串的列表要短1个字符（无需空格）。/x"string"<b2 2-> xc"string"2<b2。无需更改。

怎么运行的：

• 这使用@xnor的方法，即使用前两个字母来查找货币值，以及检测首字母halfor 的技巧two，将其删除并再次调用该函数。

• 要查找前两个字符的值，它会找到货币中前两个字母在字符串中的位置，然后除以2，并取值列表中该索引处的值。这比pyth中的命令短得多。

• 使用以下事实：x在失败时（在字符串内查找）返回-1，以避免在字符串中放入po（磅）qu（quid）或so（主权），并且默认情况下仅返回列表的最后一个元素960。

• 通过在检索系统重新排列货币秩序，认真初始化，与K4和J24，将已经需要分隔列表中的号码的所有空间被拆除。

• A在分割的输入上使用pyth的对偶赋值运算符， in以在单独的变量中获取输入的开始和结尾。

• 最后，虽然pyth没有no .split(_,1)，但是基本上进行了相同的查找，因此它比较麻烦。

例子：

$ 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

红宝石，345 306 302 288 287 278 273 253 252 242 232个 221 202 190字节

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

从STDIN接收输入并打印到STDOUT。

我正在使用简短的正则表达式来为每个值仅匹配所需的面额。在相应的索引处有两个数组，一个带有正则表达式，一个带有值。regex数组是用空格分隔的数组文字，而value数组打包为一串UTF-8字符。

我通过搜索与每种面额匹配的正则表达式来选择值的索引。我也默认使用tuppence / half-groat情况（值8），因为这需要最长的正则表达式。同样，某些模式假定其他值已被较早的模式匹配，因此每个正则表达式仅将所需值与其余值区分开。使用此方法，我可能可以通过重新排列面额顺序来减少另外两个字节。

感谢Ventero帮助我击败了Pyth，使其变得更短！

Python 3中：264 239个字符

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)

该函数通过在字典中找到f字符串中c的前两个字母来对它们进行指纹识别，从而获得货币字符串的先令价值。通过截去前缀和空格并应用乘数，可以检测和解释前缀“ half”和“ two”。由于“ halfpenny”在“ half”之后没有空格，因此结果为“ enny”，但这是通过虚构的“ en”条目处理的。

感谢@isaacg和@grc对字典查找进行了大量改进。

Python 2-345358

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

要求输入数字是python中的浮点数，即 144.1

我认为这可以在python 3中缩短...

...感谢@xnor。还证实了拥有更好的算法很重要；）

Haskell-315字节

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

我采用了哈希函数方法...我想我（相对）低估了输入处理的复杂度（相对于正则表达式方法，它不在乎数字）。

基于@FryAmTheEggMan的答案，采用不同的测试方式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))

通过从最广泛的正则表达式检查各种正则表达式来获得每种货币的价值/t/。如果遇到另一个匹配项，则该值将被覆盖。通过重新排序正则表达式字符串，可能有一种方法可以减少几个字节。您可以使用上面的代码片段对其进行测试（它的格式仅设置为使用对话框并删除ES6箭头功能，以便每个人都可以轻松地测试代码）。感谢Alconja的建议。