Sie und ein Freund gehen in eine Bar. Der Barkeeper behandelt Sie gut, und Sie beschließen, ihm ein Trinkgeld zu geben. Sie ziehen also Ihren zuverlässigen Taschencomputer heraus und schreiben ein schnelles Programm, um einen Tipp für Sie zu berechnen, da er keinen eingebauten Taschenrechner enthält. Aber warte! Ihre Vermittlungstasten sind defekt! Ihre Aufgabe ist es, ein Trinkgeld von 20% für einen bestimmten Eingabebetrag zu berechnen. Die Testeingaben haben die Form xx.xx, z. B. 20.96. Hier sind die Regeln:

• Keine Verwendung der folgenden in mathematischer Form Operatoren: + - * / %(Dank Wally West)
• Keine Verwendung von integrierten Prozentfunktionen oder APIs
• Kein Zugriff auf das Netzwerk
• Keine Verwendung von evaloder ähnlichem
• Nein Windows-Rechner (ja, die Leute haben schon einmal damit geantwortet)
• Keine eingebauten Tippfunktionen (nicht, dass irgendeine Sprache eine haben würde)

Die Ausgabe sollte auf zwei Dezimalstellen aufgerundet werden.

Die Bewertung basiert auf der Länge in Byte.

-20%, wenn Ihr Programm Trinkgeld akzeptiert. Die Eingabe für den Betrag erfolgt in Form von xx, z. B. 35, nicht 0,35

Javascript 81

EDIT : Das Ergebnis ist jetzt eine echte Rundung, nicht abgeschnitten.

Verwenden Sie hier KEINE Mathematik, nur Zeichenfolgenmanipulation und bitweise Operatoren.
Alle +Zeichen sind Zeichenfolgenverkettungen oder Konvertierungen von Zeichenfolgen in Gleitkommazahlen .
Funktioniert für alle xx.xx Ein- und Ausgänge im (x) x.xx Format

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

Trick erklärt: 20% wird durch 10 geteilt und mit 2 multipliziert.

• Machen Sie eine Division durch 10, indem Sie den Punkt nach links bewegen (String-Manipulation)
• Multiplizieren Sie jeden Teil mit 2, indem Sie die Bits nach links bewegen (bitweise Operation).

J (9 Zeichen)

Eine kurze Antwort in J:

^.(^.2)^~ 32

Pure Bash, 50 43 Zeichen

Ich bin mir ziemlich sicher, dass das klappt, aber hier ist ein Anfang:

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

Wie aus den Kommentaren hervorgeht:

• /ist hier kein Divisionsoperator, sondern Teil einer Erweiterung des Mustersubstitutionsparameters
• % ist hier kein Modulo-Operator, sondern Teil einer Parametererweiterung
• - ist hier kein Subtraktionsoperator, es ist eine Negation, die laut den Kommentaren erlaubt war

Ausgabe:

$ ./20pct.sh 0.96
.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 (ohne Bonus)

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

Hinweis

• + wird für die Verkettung von Zeichenfolgen verwendet
• * wird zum Erstellen von Kopien von Zeichenfolgen verwendet

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

Hinweis

Im Geiste der Frage glaube ich, dass die folgende Lösung, obwohl sie allen Regeln der Frage folgt, ein Missbrauch ist

Python 41

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

Schließlich

Wenn Sie darauf bestehen, dass die mathematischen Symbole verboten sind, ist sie eine 90-Zeichen-Lösung

Python 90 (ohne mathematisches Symbol)

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

APL (9 Zeichen, neuer Code mit 7 Zeichen, fest mit 13 Zeichen)

Berechnen Sie 20% des angegebenen Betrags.

{⍟⍵*⍨*.2} 32

In APL *ist der Exponentialoperator.

Probieren Sie es online aus .

Aber warum eine Funktion dafür verwenden? Siehe diese neue Version:

⍟(*.2)* 32

Probieren Sie es online aus .

Bitte, vor dem Downvoting ist das *nicht als KEY verboten und es bedeutet hier keine Multiplikation.

OK, hier ist die Version, die auf 2 Dezimalstellen rundet (Dyalog APL):

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

R 30 27 36 34

Auf 2 Dezimalstellen gerundet

2 Zeichen dank Plannapus gespeichert

Erstellt einen Vektor von 0 bis x und nimmt das 2. Element.

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

Beispiel:

> a(20.36)
[1] 4.07

Weitere Erklärung:

seq(0,x,len=6)

Erstellt einen Vektor der Länge 6 von 0 bis zum Eingabewert x, wobei die dazwischen liegenden Werte gleich weit voneinander entfernt sind.

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

Der erste Wert ist dann 0%, der zweite 20%, der dritte 40% usw.

dc + sed + pipes (44 zeichen)

Meine dritte Antwort (eine APL, eine J und jetzt eine mit dem alten und ehrwürdigen DC).

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

Es wird nach einer INTEGER-Eingabe gefragt und 20% auf knifflige Weise berechnet. Die Eingabe wird in Basis 5 konvertiert (einfach mit vielen anderen Tools zu machen, aber warten ...); Ein Punkt wird vor der letzten Ziffer mit sed angehängt (dc kann leider nicht sehr gut mit Strings umgehen), und DANN konvertiert dc von Basis 5 auf eine Gleitkommazahl zurück (nicht alle Werkzeuge können das).

Python, 88

Dies ist nicht annähernd kurz, aber es zeigt, wie eine normale mentale Division durch fünf erfolgen sollte. Dies setzt voraus, dass die Eingabe die Form xx.xx haben muss

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

Für die Eingabe einer beliebigen Länge sind zusätzlich 3 Zeichen erforderlich.

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

Erläuterung: Wir nehmen die Eingabe als Zeichenfolge und verschieben den Dezimalpunkt um eine Stelle vorwärts (dividiert durch 10). Wir werfen es dann in einen Float und ldexpmultiplizieren es mit 2.

Beachten Sie, dass in dieser Antwort die +Zeichenfolgenverkettungsoperatoren und die %zum Formatieren verwendet werden print.

Wenn Sie darauf bestehen, keines dieser Zeichen zu verwenden, finden Sie hier eine Lösung mit 159 Zeichen:

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

(Inspiriert von der Antwort von ברוכאל )

• Verarbeitet einen beliebigen Spitzenbetrag (Integer oder Float)

Beispielläufe (Eingabe wird über STDIN akzeptiert):

$ 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[]]

Keine Verwendung der mathematischen Operatoren von +, -, *, /, oder %. Verwendet Eigenschaften von Logarithmen, um die Antwort zu berechnen. Wenn Sie den Ausdruck vereinfachen, erhalten Sie.2*Input[]

Mit dem Bonus ( 30 * 0,8 = 24 ):

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

Geben Sie zuerst den Prozentsatz und dann den Betrag ein.

Wenn Sie den Ausdruck vereinfachen, erhalten Sie Input[]*Input[]*.01.

Vielen Dank an ברוכאל für die Hilfe bei der Kürzung des Codes.

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

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

Funktioniert durch Eingabe der beiden Zahlen und anschließende Verwendung der Logarithmus-Eigenschaften zur Berechnung x * y / 100.

Wenn ich eine Eingabe von Platzierung in globalen Variablen annehmen kann xund y, so ist dies viel kürzer, für eine Punktzahl von 17 * 0,8 = 13,6 :

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

Ohne Bonus ( 12 ):

ln((e^.2)^x)

Wenn es jedoch in eine Funktion eingeschlossen werden muss, funktioniert dies ( 38 Zeichen, für 30.4 ):

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

PHP 107 * .8 = 85.6

Ich kann nicht wirklich mit PHP für Code-Golf laufen, aber zumindest kann ich mit Strings arbeiten. akzeptiert beide Zahlen als Befehlszeilenargumente.

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

musste es zweimal umkehren, da ich -2 nicht verwenden kann :(

Python, 81 80 89 Zeichen

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

Erläuterung

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]

Technisch gesehen ist dies ein Betrug, da es auf zwei Dezimalstellen verkürzt und nicht gerundet wird, aber ich kann argumentieren, dass es abgerundet wird (besser für Sie, weniger Trinkgeld).

JavaScript 251 (erzwungene Einschränkung: in keiner Weise +, -, *,? Oder%)

Obwohl ich weiß, dass dies nicht gewinnen wird, dachte ich, ich würde versuchen, durch einen sehr strengen Ansatz Brownie-Punkte zu erzielen, und würde nicht einmal daran denken, die eingeschränkten Operatoren in irgendeiner Form zu verwenden diese Schönheit...

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

Ich habe bitweise Operationen verwendet, um die Add-Funktion zu erstellen A, und dann angefangen, von dort aus zu verketten:

Die Ganzzahldivisionsfunktion Dverwendete eine Reihe negierter Additionen (Subtraktion in Form A(x,A(~y,1)einer Schleife; der Rest ist String-Manipulation und Verkettung, um die Verwendung von +Verkettungsoperatoren zu vermeiden).

Die Zahl muss in Dezimalform mit zwei Nachkommastellen angegeben werden, damit dies funktioniert ...

Perl, 50 60 Bytes

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

Die Eingabe wird bei STDIN erwartet. Es muss das Dezimaltrennzeichen mit zwei Dezimalstellen enthalten. Die Ausgabe wird nach STDOUT geschrieben.

Update: Der Schritt $_<<=1entfernt führende Nullen. Daher m|\d{3}$|würde nicht für Rechnungen <1 passen. Daher wurden zehn Bytes $_="00$hinzugefügt, Jetzt 0.00funktioniert sogar .

Beispiele:

• Eingang: 20.96Ausgang:4.19
• Eingang: 12.34Ausgang:2.47

Ungolfed-Version:

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

Zuerst wird die Nummer aus STDIN gelesen. Dann wird der Dezimalpunkt entfernt, das heißt mit 100 multipliziert. Dann wird der Betrag durch einen Verschiebeoperator verdoppelt. Dann wird der Dezimalpunkt erneut eingefügt und das Ergebnis gedruckt und auf zwei Dezimalstellen gerundet.

50 Bytes, wenn Rechnung ≥ 1:

Wenn x.xxgrößer oder gleich ist 1.00, können 10 Bytes entfernt werden:

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

JavaScript (ES6) (Regex) 142

Regex ist großartig und kann viele Dinge. Es kann sogar rechnen!

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

Lesbare Version:

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

Die tip()Funktion erwartet ein String-Argument anstelle von Number.

Alle Instanzen *, /, +sind nicht auf mathematische Operationen zusammenhängen.

• + ist die Verkettung von Zeichenfolgen in allen Fällen, in denen sie verwendet wird.
• * ist Teil der RegExp-Syntax
• / ist das Trennzeichen für das RegExp-Literal

Die Eingabe muss verwenden .als Dezimalpunkt, und es müssen zwei Stellen nach dem Komma sein.

Stapel-Snippet

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

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

Missbraucht die Tatsache, dass Exponenten zu Multiplikationen in Logarithmen werden.