Вы и друг идете в бар. Бармен относится к вам хорошо, поэтому вы решаете дать ему чаевые. Таким образом, вы достаете свой надежный карманный компьютер и пишете быструю программу для расчета чаевых, поскольку в ней нет встроенного калькулятора. Но ждать! Ваши ключи оператора сломаны! Ваша задача - рассчитать 20% чаевых для любой заданной суммы ввода. Входные данные теста будут иметь вид xx.xx, например, 20,96. Вот правила:

• Не использовать следующие операторы в математической форме: + - * / %(спасибо Wally West)
• Не использовать встроенные функции процента или API
• Нет доступа к сети
• Не использовать evalили аналогичные
• Нет калькулятора Windows (да, люди ответили ранее)
• Нет встроенных функций подсказки (не то, чтобы у любого языка была такая)

Выходные данные должны быть округлены до двух десятичных знаков.

Оценка основана на длине в байтах.

-20%, если ваша программа может принять любую сумму чаевых. Вход для суммы будет дан в виде хх например 35, а не 0,35

Javascript 81

РЕДАКТИРОВАТЬ : Результат теперь реальное округление, а не усечены.

Не используйте здесь ЛЮБУЮ математику, только манипуляции со строками и побитовые операторы.
Все +символы являются конкатенацией строк или преобразованием строки в число с плавающей точкой .
Работает для любого входа и выхода xx.xx в формате (x) x.xx

s='00'+(prompt().replace('.','')<<1);(+s.replace(/(.*)(...)/,'$1.$2')).toFixed(2)

Трюк объяснил: 20% делится на 10 и умножается на 2.

• Сделайте деление на 10, переместив точку влево (манипуляции со строками)
• Умножьте каждую часть на 2, сдвинув биты влево (побитовая операция)

J (9 знаков)

Краткий ответ на J:

^.(^.2)^~ 32

Чистая Баш, 50 43 символов

Я уверен, что это будет лучше, но вот начало:

a=$[10#${1/.}<<1]
echo ${a%???}.${a: -3:2}

Согласно комментариям:

• /здесь не оператор деления, это часть расширения параметра подстановки шаблона
• % здесь не оператор по модулю, это часть расширения параметра
• - здесь не оператор вычитания, это отрицание, которое было разрешено согласно комментариям

Выход:

$ ./20pct.sh 0,96
0,19
$ ./20pct.sh 20,96
4,19
$ ./20pct.sh 1020,96
204,19
$ 

Python 98 * 0,8 = 78,4

d=`len('X'*int("{}{:>02}".format(*(raw_input()+".0").split('.')))*2)`;print'%s.%s'%(d[:-3],d[-3:])

Python 74 (без бонуса)

d=len('X'*int(raw_input().replace('.',''))*2);print'%s.%s'%(d[:-3],d[-3:])

Заметка

• + используется для объединения строк
• * используется для создания копий строки

Ungolfed

def tip():
    amount = raw_input()
    #Add an extra decimal point so that we can accept integer
    #amount
    amount += ".0"
    #Split the integer and decimal part
    whole, frac = amount.split('.')
    #Multiply amount by 100 :-)
    amount = "{}{:>02}".format(whole, frac)
    #Create amount copies of a character
    st = 'X'*amount
    #Double it
    st *= 2
    #Calculate the Length
    d = len(st)
    #Display the result as 3 decimal fraction
    print'%s.%s'%(d[:-3],d[-3:])

Заметка

В духе вопроса, я считаю, что следующее решение, хотя следует всем правилам вопроса, является злоупотреблением

Python 41

print __import__("operator")(input(),0.2)

в заключение

Если вы настаиваете на том, что математические символы запрещены, то это 90-символьное решение

Python 90 (без какого-либо математического символа)

print' '.join(str(int(raw_input().replace(".",""))<<1)).replace(' ','.',1).replace(' ','')

APL (9 символов, новый код из 7 символов, фиксированный из 13 символов)

Вычислить 20% от указанной суммы.

{⍟⍵*⍨*.2} 32

В APL *есть экспоненциальный оператор.

Попробуйте онлайн .

But why use a function for that? See this new version:

⍟(*.2)* 32

Try it online.

Please, before downvoting, the * is not forbidden as a KEY and it doesn't mean multiplication here.

OK, here is the version rounding to 2 decimals (Dyalog APL):

⎕PP←2⋄⍟(*.2)* 32.01

R, 30 27 36 34

Обновлено с округлением до 2 знаков после запятой

Спас 2 персонажа благодаря планнапу

Создает вектор от 0 до x и принимает 2-й элемент.

a=function(x)round(seq(0,x,l=6)[2],2)

Пример:

> a(20.36)
[1] 4.07

Дальнейшее объяснение:

seq(0,x,len=6)

создает вектор длиной 6 от 0 до входного значения x с равными интервалами между значениями.

> seq(0,5,len=6)
[1] 0 1 2 3 4 5

Первое значение составляет 0%, второе 20%, третье 40% и т. Д.

dc + sed + pipes (44 characters)

My third answer (one APL, one J, and now one with the old and venerable dc).

dc -e 5o?p|sed -e 's/\(.\)$/.\1/'|dc -e 5i?p

It will ask for an INTEGER input and compute 20% with a tricky way. Input is converted to base 5 (easy to do with many other tools but wait...); a dot is appended before the last digit with sed (unfortunately, dc can't handle strings very well), and THEN, dc converts back from base 5 on a float number (not all tools can do that).

Python, 88

Это не где-то близко, но это демонстрирует, как нормальное умственное разделение на пять должно быть сделано. Это предполагает, что входные данные должны иметь форму xx.xx

import math
a,b=raw_input().split('.')
print'%.2f'%math.ldexp(float(a[0]+'.'+a[1]+b),1)

Или для ввода любой длины требуется добавление 3 символов.

import math
a,b=raw_input().split('.')
print'%.2f'%math.ldexp(float(a[:-1]+'.'+a[-1]+b),1)

Объяснение: Мы берем входные данные как строку, а затем перемещаем десятичную точку на одно место вперед (деление на 10). Затем мы бросаем его на поплавок и используемldexp функцию для умножения на 2.

Обратите внимание, что в этом ответе +используются операторы конкатенации строк, и %они используются для форматированияprint .

Если вы настаиваете на том, чтобы не использовать ни один из этих символов, вот решение из 159 символов:

import math
a,b=raw_input().split('.')
l=[a[0]]
l.append('.')
l.append(a[1])
l.append(b)
c=str(math.ldexp(float(''.join(l)),1))
print ''.join([c[0:2],c[2:4]])

dc + sed - 45 * 0,8 = 36

(Вдохновленный ответ по ברוכאל )

• Обрабатывает любое количество чаевых (целое число или число с плавающей запятой)

Пример выполнения (ввод принят через STDIN):

$ dc -e 5o?.0+p|sed 's/\(.\)\./.\1/'|dc -e 5i?p
42
8.400
$ dc -e 5o?.0+p|sed 's/\(.\)\./.\1/'|dc -e 5i?p
20.96
4.1920

Математика, 19

Log[(E^.2)^Input[]]

Нет использование математических операторов +, -, *, /, или %. Использует свойства логарифмов для вычисления ответа; когда вы упрощаете выражение, вы получаете.2*Input[]

С бонусом ( 30 * 0,8 = 24 ):

Log[((E^.01)^Input[])^Input[]]

Сначала введите процент, а затем сумму.

Когда вы упрощаете выражение, вы получаете Input[]*Input[]*.01.

Спасибо ברוכאל за помощь в сокращении кода.

TI-89 Basic - 39 * 0,8 = 31,2

Input y:Input x:Disp ln(((e^y)^.01)^x))

Работает, введя два числа, затем используя свойства логарифма для вычисления x * y / 100.

Если я могу предположить ввод от размещения в глобальных переменных xи y, то это намного короче, для оценки 17 * 0,8 = 13,6 :

ln(((e^y)^.01)^x)

Без бонуса ( 12 ):

ln((e^.2)^x)

Но если его нужно обернуть в функцию, то это работает ( 38 символов, для 30.4 ):

:f(x,y):Func:ln(((e^y)^.01)^x):EndFunc

PHP 107 * .8 = 85,6

не могу действительно бегать за гольф-кодом с PHP, но по крайней мере я могу работать со строками. принимает оба числа в качестве аргументов командной строки.

<? @$r=strrev;unset($argv[0]);echo$r(substr_replace($r(str_replace('.','',array_product($argv)))),'.',2,0);

пришлось дважды поменять его, так как я не могу использовать -2 :(

Python, 81 80 89 символов

a,b=map(str,raw_input().split('.'));c=str(int(a+b)<<1).zfill(4);print c[:-3]+'.'+c[-3:-1]

объяснение

x = raw_input()       # say 20.96
a , b = x.split('.')  # a = 20 , b = 96
c = a + b             # c = '2096'      # string concatenation , multiplying by 100
d = int(c)<<1         # multiply by 2 by bitshift left , c = 4096
e = str(d).zfill(4)   # zfill pads 0's making the string 
                      # atleast 4 chars which is required 
                      # for decimal notation next

#     divide by 1000 (4) + . (4.) + fraction rounded to 2 decimals (4.09)
print        e[:-3]      +   '.'  +              e[-3:-1]

Технически, это обман, поскольку он усекает до двух десятичных знаков вместо округления, но я могу утверждать, что он округляется (лучше для вас, меньше чаевых).

JavaScript 251 (принудительное ограничение: нет +, -, *,? Или% любым способом)

Хотя я знаю, что это не победит, я подумал, что постараюсь получить очки брауни за счет очень строгого подхода и даже не думать об использовании операторов с ограничениями в любой форме или форме ... в результате я придумал эта красота ...

A=(x,y)=>{for(;x;)b=x^y,x=(a=x&y)<<1,y=b;return y};D=(x,y,i=x,j=0)=>{for(;i>=y;)i=A(i,A(~y,1)),j=A(j,1);return j};alert(parseFloat((x="00".concat(String(D(prompt().replace(".",""),5)))).substr(0,A(x.length,y=A(~2,1))).concat(".").concat(x.substr(y))))

Я использовал побитовые операции для создания функции Add A , а затем начал цепочку оттуда:

Функция целочисленного деления Dиспользовала серию Negated Addition (вычитание в форме A(x,A(~y,1)над циклом; остальное - манипуляции со строками и конкатенация, чтобы избежать использования+ операторов конкатенации ...

Число должно быть предоставлено в десятичной форме с двумя десятичными разрядами, чтобы это работало ...

Perl, 50 60 байт

$_=<>;s|\.||;$_<<=1;$_="00$_";m|\d{3}$|;printf'%.2f',"$`.$&"

Ввод ожидается в STDIN. Он должен содержать десятичный разделитель с двумя десятичными цифрами. Вывод записывается в STDOUT.

Обновление: шаг $_<<=1удаляет ведущие нули. Поэтому m|\d{3}$|не будет соответствовать для счетов <1. Поэтому $_="00$было добавлено десять байтов , теперь даже0.00 работает.

Примеры:

• Вход:, 20.96выход:4.19
• Вход:, 12.34выход:2.47

Безголовая версия:

$_=<>;
s|\.||; # multiply by 100
$_ <<= 1; # multiply by 2
$_="00$_";
m|\d{3}$|; # divide by 1000
printf '%.2f'," $`.$&"

Сначала число читается из STDIN. Затем удаляется десятичная точка, которая умножается на 100. Затем сумма удваивается с помощью оператора сдвига. Затем десятичная точка вставляется заново, а результат печатается и округляется до двух десятичных цифр.

50 байтов, если счет ≥ 1:

Если x.xxбольше или равно 1.00, то 10 байтов могут быть удалены:

$_=<>;s|\.||;$_<<=1;m|\d{3}$|;printf'%.2f',"$`.$&"

JavaScript (ES6) (Regex) 142

Regex великолепен и может делать много вещей. Это может даже сделать математику!

a=('x'.repeat(prompt().replace('.', ''))+'xxxx').match(/^((x*)\2{99}(x{0,99}))\1{4}x{0,4}$/);c=a[3].length;alert(a[2].length+'.'+(c<10?'0'+c:c))

Читаемая версия:

function tip(m) {
    var s = 'x'.repeat(m.replace('.', '')) + 'xxxx';
    var a = s.match(/^((x*)\2{99}(x{0,99}))\1{4}x{0,4}$/);
    var c = a[3].length;
    if (c < 10) c = '0' + c;
    return a[2].length + '.' + c;
}

tip()Функция ожидает строки аргумента, а не номер.

Все экземпляры *, /, +которые не связаны с математическими операциями.

• + это конкатенация строк во всех случаях, когда она используется.
• * является частью синтаксиса RegExp
• / является разделителем литерала RegExp

Ввод должен использоваться в .качестве десятичной точки, и после десятичной точки должно быть 2 цифры.

Фрагмент стека

<button onclick = "a=('x'.repeat(prompt().replace('.', ''))+'xxxx').match(/^((x*)\2{99}(x{0,99}))\1{4}x{0,4}$/);c=a[3].length;alert(a[2].length+'.'+(c<10?'0'+c:c))">Try it out</button>

Haskell 32 символа -20% = 25,6 символа

t y x=log $(^x)$(**0.01)$ exp y

Злоупотребляет тем фактом, что показатели становятся умножением в логарифмах.