До десятичности в 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

^{(Я не британец, этот список ни в коем случае не является авторитетным, но его будет достаточно для вызова.)}

С помощью стандартного аргумента или функции вы должны получить строку вида

[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

счет

Самый короткий код в байтах побеждает.

Пиф , 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

Обновление: Оказывается, это на 1 символ короче (без пробела), чтобы разбить строку в список из 2-х символьных строк перед запуском операции индекса строки. /x"string"<b2 2-> xc"string"2<b2. Больше ничего не нужно менять.

Как это работает:

• При этом используется подход @ xnor, который заключается в поиске значения валюты с использованием первых двух букв, а также в приеме определения начального halfили twoудаления его и повторного вызова функции.

• Чтобы найти значение первых двух символов, он находит расположение первых двух букв валюты в строке, затем делит на 2 и принимает значение по этому индексу в списке. Это намного короче, чем диктат в пите.

• Использует тот факт, что x(найти в строке) возвращает -1 при невозможности избежать помещения po(фунтов) qu(quid) или so(суверенных) в строку и просто возвращает последний элемент списка, 960, по умолчанию.

• Путем изменения порядка валют в поисковой системе и тщательной инициализации с помощью K4и J24все пробелы, необходимые для разделения чисел в списке, были удалены.

• Использует оператор двойного присваивания pyth при разбивке Aвходных данных, inчтобы получить начало и конец входных данных в отдельных переменных.

• По сути, делает тот же поиск в конце, хотя Pyth не имеет .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

Ruby, 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.

Я использую короткие регулярные выражения, чтобы соответствовать только желаемым номиналам для каждого значения. Есть два массива, один с регулярными выражениями и один со значениями, с соответствующими индексами. Массив регулярных выражений является литералом массива с разделителями-пробелами, а массив значений упакован в строку символов UTF-8.

Я выбираю индекс по значениям путем поиска регулярного выражения, соответствующего каждому наименованию. Я также по умолчанию использую случай tuppence / half-groat (значение 8), потому что для этого требуется самое длинное регулярное выражение. Аналогично, некоторые из шаблонов предполагают, что другие значения уже сопоставлены с более ранними шаблонами, поэтому каждое регулярное выражение только отличает желаемое значение только от остальных. Используя это, я мог бы, вероятно, сбрить еще пару байтов, изменив порядок номиналов.

Спасибо Вентеро за то, что он помог мне победить Пита, сделав его короче!

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путем снятия отпечатков пальцев с первых двух букв, используя словарь , находя их в строке. Префиксы «половина» и «два» обнаруживаются и учитываются путем выбора префикса и пробела и применения множителя. Поскольку «полпенни» не хватает пробела после «половины», это приводит к «enny», но это обрабатывается с вымышленной записью «en».

Спасибо @isaacg и @grc за большое улучшение поиска по словарю.

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

Требуется, чтобы входной номер был числом с плавающей точкой в ​​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 за предложения.