Bạn và một người bạn bước vào một quán bar. Người pha chế đối xử tốt với bạn, vì vậy bạn quyết định mách anh ta. Vì vậy, bạn rút máy tính bỏ túi đáng tin cậy của bạn và viết một chương trình nhanh chóng để tính toán tiền boa cho bạn vì nó không có máy tính tích hợp. Nhưng chờ đã! Khóa điều hành của bạn bị hỏng! Nhiệm vụ của bạn là tính tiền tip 20% cho bất kỳ số tiền đầu vào nào. Các đầu vào kiểm tra sẽ ở dạng xx.xx, ví dụ 20,96. Đây là các quy tắc:

• Không sử dụng các mục sau trong toán tử dạng toán học: + - * / %(Cảm ơn Wally West)
• Không sử dụng các hàm hoặc API được xây dựng theo phần trăm
• Không truy cập mạng
• Không sử dụng evalhoặc tương tự
• Không có Máy tính Windows (có người đã trả lời trước đó)
• Không có chức năng tip được xây dựng (Không phải ngôn ngữ nào cũng có)

Đầu ra phải được làm tròn đến hai chữ số thập phân.

Điểm dựa trên chiều dài tính bằng byte.

-20% nếu chương trình của bạn có thể chấp nhận bất kỳ số tiền tip nào. Đầu vào cho số tiền sẽ được cung cấp dưới dạng xx, ví dụ 35 chứ không phải 0,35

Javascript 81

EDIT : Kết quả bây giờ là một làm tròn thực sự, không bị cắt cụt.

Không sử dụng bất kỳ toán học nào ở đây, chỉ cần thao tác chuỗi và toán tử bitwise.
Tất cả các +char là nối chuỗi hoặc chuyển đổi chuỗi thành float .
Hoạt động cho mọi đầu vào và đầu ra xx.xx ở định dạng (x) x.xx

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

Trick giải thích: 20% được chia cho 10 và nhân với 2.

• Thực hiện chia cho 10 bằng cách di chuyển dấu chấm sang trái (thao tác chuỗi)
• Nhân mỗi phần với 2 bằng cách di chuyển các bit sang trái (hoạt động theo bit)

J (9 ký tự)

Một câu trả lời ngắn trong J:

^.(^.2)^~ 32

Bash tinh khiết, 50 43 ký tự

Chắc chắn điều này sẽ bị đánh bại, nhưng đây là một sự khởi đầu:

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

Theo ý kiến:

• /không phải là một toán tử phân chia ở đây, nó là một phần của việc mở rộng tham số thay thế mẫu
• % không phải là toán tử modulo ở đây, nó là một phần của việc mở rộng tham số
• - không phải là một toán tử trừ ở đây, nó là một phủ định, được cho phép theo các bình luận

Đầu ra:

$ ./20pct.sh 0.96
.19
$ ./20pct.sh 20,96
4.19
$ ./20pct.sh 1020,96
204,19
$ 

Con trăn 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 (không có tiền thưởng)

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

Ghi chú

• + được sử dụng để nối chuỗi
• * được sử dụng để tạo các bản sao của chuỗi

Bị đánh cắp

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

Ghi chú

Theo tinh thần của câu hỏi, tôi tin rằng giải pháp sau đây mặc dù tuân theo tất cả các quy tắc của câu hỏi là lạm dụng

Con trăn 41

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

Cuối cùng

Nếu bạn khăng khăng rằng các ký hiệu toán học bị cấm, thì cô ấy là một giải pháp 90 ký tự

Python 90 (không có bất kỳ ký hiệu toán học nào)

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

APL (9 ký tự, mã mới có 7 ký tự, được cố định với 13 ký tự)

Tính 20% số tiền đã cho.

{⍟⍵*⍨*.2} 32

Trong APL *là toán tử mũ.

Hãy thử trực tuyến .

Nhưng tại sao sử dụng một chức năng cho điều đó? Xem phiên bản mới này:

⍟(*.2)* 32

Hãy thử trực tuyến .

Xin vui lòng, trước khi hạ cấp, *không bị cấm như là một chìa khóa và nó không có nghĩa là nhân ở đây.

OK, đây là phiên bản làm tròn thành 2 số thập phân (Dyalog APL):

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

R, 30 27 36 34

Cập nhật để làm tròn đến 2 chữ số thập phân

Đã lưu 2 ký tự nhờ vào plannapus

Tạo một vectơ từ 0 đến x và lấy phần tử thứ 2.

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

Thí dụ:

> a(20.36)
[1] 4.07

Giải thích thêm:

seq(0,x,len=6)

tạo một vectơ có độ dài 6 từ 0 đến giá trị đầu vào x, với các giá trị ở giữa cách đều nhau.

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

Giá trị đầu tiên là 0%, 20% thứ hai, 40% thứ ba, v.v.

dc + sed + ống (44 ký tự)

Câu trả lời thứ ba của tôi (một APL, một J, và bây giờ là một với dc cũ và đáng kính).

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

Nó sẽ yêu cầu một đầu vào INTEGER và tính toán 20% với một cách khó khăn. Đầu vào được chuyển đổi thành cơ sở 5 (dễ thực hiện với nhiều công cụ khác nhưng chờ ...); một dấu chấm được thêm vào trước chữ số cuối cùng với sed (thật không may, dc không thể xử lý chuỗi rất tốt) và THEN, dc chuyển đổi trở lại từ cơ sở 5 trên một số float (không phải tất cả các công cụ đều có thể làm điều đó).

Con trăn, 88

Đây không phải là nơi gần ngắn, nhưng điều này chứng tỏ cách phân chia tinh thần bình thường theo năm nên được thực hiện. Điều này giả định rằng đầu vào phải có dạng xx.xx

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

Hoặc đối với đầu vào có độ dài bất kỳ, cần thêm 3 ký tự.

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

Giải thích: Chúng tôi lấy đầu vào dưới dạng chuỗi, sau đó di chuyển dấu thập phân một vị trí về phía trước (chia cho 10). Sau đó chúng tôi thả nó lên một cái phao và sử dụngldexp hàm để nhân nó với 2.

Lưu ý rằng trong câu trả lời này, các +toán tử nối chuỗi và% được sử dụng để định dạng print.

Nếu bạn khăng khăng không sử dụng bất kỳ ký tự nào trong số này, thì đây là giải pháp 159 ký tự:

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

(Lấy cảm hứng từ câu trả lời của ברוכאל )

• Xử lý bất kỳ số tiền tip (số nguyên hoặc float)

Chạy ví dụ (đầu vào được chấp nhận qua 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

Toán học, 19

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

Không sử dụng các toán tử toán học của +, -, *, /, hoặc %. Sử dụng các thuộc tính của logarit để tính toán câu trả lời; khi bạn đơn giản hóa biểu thức, bạn nhận được.2*Input[]

Với phần thưởng ( 30 * 0,8 = 24 ):

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

Nhập tỷ lệ phần trăm đầu tiên, sau đó số tiền.

Khi bạn đơn giản hóa biểu thức, bạn nhận được Input[]*Input[]*.01.

Cảm ơn ב ž TOUR vì đã giúp rút ngắn mã.

TI-89 Cơ bản - 39 * 0,8 = 31,2

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

Hoạt động bằng cách nhập hai số, sau đó sử dụng các thuộc tính logarit để tính toán x * y / 100.

Nếu tôi có thể giả sử đầu vào từ vị trí trong các biến toàn cục xvà ythì điều này ngắn hơn nhiều, với số điểm 17 * 0,8 = 13,6 :

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

Không có tiền thưởng ( 12 ):

ln((e^.2)^x)

Nhưng nếu nó cần được bọc trong một hàm, thì nó hoạt động ( 38 ký tự, trong 30.4 ):

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

PHP 107 * .8 = 85,6

thực sự không thể chạy cho golf-code với PHP, nhưng ít nhất tôi có thể hoạt động trên các chuỗi. chấp nhận cả hai số làm đối số dòng lệnh.

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

đã phải đảo ngược nó hai lần vì tôi không thể sử dụng -2 :(

Con trăn, 81 80 89 ký tự

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

Giải trình

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]

Về mặt kỹ thuật, điều này là gian lận khi nó cắt thành hai số thập phân thay vì làm tròn nó nhưng tôi có thể lập luận rằng nó làm tròn xuống (Tốt hơn cho bạn, ít tiền hơn).

JavaScript 251 (hạn chế bắt buộc: không +, -, * ,? Hoặc% theo bất kỳ cách nào)

Trong khi tôi biết điều này sẽ không thắng, tôi đã hình dung rằng tôi sẽ cố gắng đạt được điểm brownie bằng cách tiếp cận rất nghiêm ngặt và thậm chí không nghĩ đến việc sử dụng các toán tử bị hạn chế dưới bất kỳ hình dạng hoặc hình thức nào ... kết quả là, tôi đã nghĩ ra vẻ đẹp này...

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

Tôi đã sử dụng các thao tác bitwise để tạo chức năng Thêm Avà sau đó bắt đầu kết nối từ đó:

Hàm phân chia số nguyên đã Dsử dụng một loạt Bổ sung phủ định (phép trừ dưới dạng A(x,A(~y,1)vòng lặp; phần còn lại là thao tác chuỗi và nối chuỗi để tránh sử dụng +toán tử nối ...

Số phải được cung cấp ở dạng thập phân với hai chữ số thập phân để làm việc này ...

Perl, 50 60 byte

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

Đầu vào dự kiến ​​tại STDIN. Nó phải chứa dấu phân cách thập phân có hai chữ số thập phân. Đầu ra được ghi vào STDOUT.

Cập nhật: Bước $_<<=1loại bỏ các số 0 hàng đầu. Do đó, m|\d{3}$|sẽ không khớp với các hóa đơn <1. Do đó, mười byte $_="00$đã được thêm vào, Bây giờ thậm chí0.00 hoạt động.

Ví dụ:

• Đầu vào : 20.96, đầu ra:4.19
• Đầu vào : 12.34, đầu ra:2.47

Phiên bản bị đánh cắp:

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

Đầu tiên số được đọc từ STDIN. Sau đó, dấu chấm thập phân được loại bỏ, được nhân với 100. Sau đó, số tiền được nhân đôi bởi một toán tử dịch chuyển. Sau đó, dấu chấm thập phân được xác nhận lại và kết quả được in và làm tròn thành hai chữ số thập phân.

50 byte, nếu hóa đơn 1:

Nếu x.xxlớn hơn hoặc bằng 1.00, thì 10 byte có thể bị xóa:

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

JavaScript (ES6) (Regex) 142

Regex là tuyệt vời và nó có thể làm nhiều thứ. Nó thậm chí có thể làm toán!

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

Phiên bản dễ đọ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;
}

Các tip() dự đoán chức năng chuỗi đối số, chứ không phải là số.

Tất cả các trường hợp *, /, +không liên quan đến hoạt động toán học.

• + là nối chuỗi trong tất cả các trường hợp nó được sử dụng.
• * là một phần của cú pháp RegExp
• / là dấu phân cách của RegExp theo nghĩa đen

Đầu vào phải sử dụng .làm dấu thập phân và phải có có 2 chữ số sau dấu thập phân.

Đoạn trích

<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 Chars -20% = 25,6 Chars

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

Lạm dụng thực tế là số mũ trở thành phép nhân trong logarit.