Sen ve bir arkadaş bir bara giriyorsunuz. Barmen size iyi davranıyor, bu yüzden ona bahşiş vermeye karar veriyorsunuz. Böylece güvenilir cep bilgisayarınızı çekin ve yerleşik bir hesap makinesi olmadığından sizin için bir ipucu hesaplamak için hızlı bir program yazın. Fakat bekle! Operatör anahtarlarınız bozuldu! Göreviniz herhangi bir giriş miktarı için% 20 bahşiş hesaplamaktır. Test girişleri xx.xx şeklinde olacaktır, örneğin 20.96. İşte kurallar:

• Matematiksel form operatörlerinde aşağıdakilerin kullanımı yoktur: + - * / %(Teşekkürler Wally West)
• Yerleşik yüzde işlevlerinin veya API'ların kullanımı yok
• Ağa erişim yok
• Kullanılmaz evalveya benzeri değildir
• Windows Hesap Makinesi yok (evet daha önce insanlar bununla cevap verdi)
• Yerleşik uç işlevi yok (Herhangi bir dilin bir tane olması gerekmez)

Çıktı iki ondalık basamağa yuvarlanmalıdır.

Puan, bayt cinsinden uzunluğa dayanır.

Programınız herhangi bir ipucu miktarını kabul edebiliyorsa -20% . Miktar girişi xx biçiminde verilecektir, örneğin 35 0,35 değil

Javascript 81

EDIT : Sonuç artık kesilmemiş gerçek bir yuvarlama.

Burada HERHANGİ bir matematik kullanmayın , sadece string manipülasyonu ve bitsel operatörler.
Tüm +karakter dizge birleştirme veya dönüşüm kayan dize .
(X) x.xx formatında tüm xx.xx giriş ve çıkışları için çalışır

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

Hile açıkladı:% 20, 10'a bölünür ve 2 ile çarpılır.

• Noktayı sola hareket ettirerek 10'a bölün (dize düzenleme)
• Bitleri sola hareket ettirerek her parçayı 2 ile çarpın (bitsel işlem)

J (9 karakter)

J'de kısa bir cevap:

^.(^.2)^~ 32

Saf bash, 50 43 karakter

Bunun yenileceğinden eminiz, ama işte bir başlangıç:

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

Yorumlara göre:

• /burada bir bölüm operatörü değil, bir kalıp değiştirme parametresi genişletmesinin parçasıdır
• % burada bir modulo operatörü değil, bir parametre genişletmesinin parçasıdır
• - burada bir çıkarma operatörü değil, yorumlara göre izin verilen bir olumsuzlama

Çıktı:

$ ./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 (bonus olmadan)

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

Not

• + dize birleştirme için kullanılır
• * dizenin kopyalarını oluşturmak için kullanılır

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

Not

Sorunun ruhuna göre, aşağıdaki çözümün, sorunun tüm kurallarına uymasına rağmen, bir kötüye kullanım olduğuna inanıyorum.

Python 41

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

En sonunda

Matematiksel sembollerin yasak olduğu konusunda ısrar ederseniz, 90 karakterlik bir çözümdür

Python 90 (herhangi bir matematiksel sembol olmadan)

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

APL (9 karakter, 7 karakter içeren yeni kod, 13 karakterle sabit)

Verilen miktarın% 20'sini hesaplayın.

{⍟⍵*⍨*.2} 32

APL'de *üstel operatördür.

Çevrimiçi deneyin .

Ama neden bunun için bir işlev kullanıyorsunuz? Bu yeni sürüme bakın:

⍟(*.2)* 32

Çevrimiçi deneyin .

Lütfen, indirmeden önce, *bir ANAHTAR olarak yasak değildir ve burada çarpma anlamına gelmez.

Tamam, işte 2 ondalığa yuvarlanan sürüm (Dyalog APL):

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

R, 30 27 36 34

2 ondalık basamağa yuvarlanacak şekilde güncellendi

Plannapus sayesinde 2 karakter kaydetti

0'dan x'e kadar bir vektör oluşturur ve 2. öğeyi alır.

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

Misal:

> a(20.36)
[1] 4.07

Daha fazla açıklama:

seq(0,x,len=6)

0'dan 6'ya kadar bir uzunluk vektörü oluşturur ve bu değerler arasındaki aralık eşittir.

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

İlk değer% 0, ikinci% 20, üçüncü% 40 vb. Olur.

dc + sed + dikey çizgi (44 karakter)

Benim üçüncü cevabım (bir APL, bir J ve şimdi bir eski ve saygıdeğer dc ile).

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

INTEGER girişi isteyecek ve zor bir şekilde% 20 hesaplayacaktır. Giriş, temel 5'e dönüştürülür (diğer birçok araçla yapmak kolaydır, ancak bekleyin ...); sed ile son basamaktan önce bir nokta eklenir (ne yazık ki, dc dizeleri çok iyi işleyemez) ve SONRA, dc kayan bir sayı üzerinde taban 5'ten geri dönüşür (tüm araçlar bunu yapamaz).

Python, 88

Bu, neredeyse kısa bir yer değil, ancak bu, beşe kadar normal bir zihinsel bölünmenin nasıl yapılması gerektiğini gösterir. Bu, girdinin xx.xx biçiminde olması gerektiğini varsayar.

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

Veya herhangi bir uzunlukta giriş için 3 karakter eklenmesi gerekir.

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

Açıklama: Girdiyi dize olarak alıyoruz, sonra ondalık noktayı bir basamak ileri taşıyoruz (10'a bölerek). Daha sonra onu bir şamandıraya döküyoruz ve ldexpişlevi 2 ile çarpmak için kullanıyoruz.

Bu yanıtta, +dize birleştirme işleçleri ve %biçimlendirmek için kullanıldığını unutmayın print.

Bu karakterlerden herhangi birini kullanmama konusunda ısrar ediyorsanız, 159 karakterlik bir çözüm aşağıdadır:

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

(Esinlenerek cevap tarafından ברוכאל )

• Herhangi bir uç miktarını (tamsayı veya float) işler

Örnek çalışmalar (giriş STDIN ile kabul edilir):

$ 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

Mathematica, 19

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

Matematiksel operatörler hiçbir kullanımı +, -,* ,/ , veya %. Cevabı hesaplamak için logaritma özelliklerini kullanır; ifadeyi basitleştirdiğinizde,.2*Input[]

Bonus ile ( 30 * 0.8 = 24 ):

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

Önce yüzdeyi, ardından miktarı girin.

İfadeyi basitleştirdiğinizde, Input[]*Input[]*.01 .

Kodu kısaltmayla ilgili yardım için ברוכאל teşekkürler .

TI-89 Temel - 39 * 0.8 = 31.2

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

İki sayıyı girerek, ardından hesaplamak için logaritma özelliklerini kullanarak çalışır x * y / 100 .

Global değişkenlerdeki yerleşimden girdi varsayabilir xve 17 * 0.8 = 13.6y puanı için bu çok daha kısadır :

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

Bonus olmadan ( 12 ):

ln((e^.2)^x)

Ancak bir işleve sarılması gerekiyorsa, bu işe yarar ( 30.4 için 38 karakter ):

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

PHP 107 * .8 = 85.6

PHP ile kod golf için gerçekten çalışamaz, ama en azından dizelerde çalışabilir. her iki sayıyı da komut satırı bağımsız değişkenleri olarak kabul eder.

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

-2 :( kullanamadığım için iki kez tersine çevirmek zorunda kaldım

Python, 81 80 89 karakter

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

açıklama

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]

Teknik olarak, bu yuvarlamak yerine iki ondalık sayıya kesildiği için hile yapıyor ancak aşağı yuvarladığını iddia edebilirim (Sizin için daha iyi, daha az ipucu).

JavaScript 251 (zorunlu kısıtlama: hiçbir +, -, *,? Veya% herhangi bir şekilde)

Bunun kazanamayacağını bilsem de, çok katı bir yaklaşımla brownie puanları almaya çalışacağımı ve kısıtlı operatörleri herhangi bir şekilde veya biçimde kullanmayı düşünmeyeceğimi düşündüm ... sonuç olarak, bu güzellik...

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

Ekle işlevini oluşturmak için bitsel işlemleri kullandım Ave oradan zincirlemeye başladım:

Tamsayı bölme işlevi Dbir dizi Negatif Toplama (çıkarma şeklindeA(x,A(~y,1) bir döngü üzerinden ; geri kalanı dize manipülasyonu ve birleşimidir.+ birleştirme işleçleri ...

Bunun çalışması için sayı, ondalık formda iki ondalık basamakla sağlanmalıdır ...

Perl, 50 60 bayt

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

Girişin STDIN'de olması bekleniyor. İki ondalık basamaklı ondalık ayırıcı içermelidir. Çıktı STDOUT'a yazılır.

Güncelleme: Adım $_<<=1önde gelen sıfırları kaldırır. bu nedenlem|\d{3}$| <1 faturalarıyla eşleşmez. Bu nedenle on bayt$_="00$ eklendi, Şimdi bile0.00 çalışıyor.

Örnekler:

• Giriş: 20.96çıkış:4.19
• Giriş:, 12.34çıkış:2.47

Ungolfed sürümü:

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

İlk olarak numara STDIN'den okunur. Daha sonra ondalık nokta kaldırılır, bu 100 ile çarpılır. Daha sonra miktar, bir kaydırma operatörü tarafından iki katına çıkar. Sonra ondalık nokta yeniden yerleştirilir ve sonuç yazdırılır ve iki ondalık basamağa yuvarlanır.

Fatura, 1 ise 50 bayt:

Eğer x.xxbüyük veya eşit olan 1.00, daha sonra 10 bayt çıkarılabilir:

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

JavaScript (ES6) (Normal İfade) 142

Regex harika ve birçok şey yapabilir. Hatta matematik bile yapabilir!

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

Okunabilir sürüm:

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()Yerine Number daha fonksiyon beklediği Dize argüman.

Tüm örnekleri *, /,+ matematik işlemleri ile ilgili değildir.

• + tüm örneklerinde dize birleşimidir.
• * RegExp sözdiziminin bir parçasıdır
• / RegExp değişmezinin sınırlayıcısıdır

Giriş gerekir kullanmak .ondalık noktası olarak, orada olmalı ondalık noktadan sonra 2 basamaklı.

Yığın Pasajı

<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 Karakter -20% = 25.6 Karakter

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

Logaritmalarda üslerin çoğalması gerçeğini kötüye kullanır.