Usted y un amigo entran a un bar. El camarero te trata bien, así que decides darle propina. Entonces saca su confiable computadora de bolsillo y escribe un programa rápido para calcular una propina para usted, ya que no tiene una calculadora incorporada. ¡Pero espera! ¡Sus llaves de operador están rotas! Su tarea es calcular una propina del 20% para cualquier cantidad de entrada dada. Las entradas de prueba tendrán la forma de xx.xx, por ejemplo, 20.96. Estas son las reglas:

• No se utiliza lo siguiente en operadores de forma matemática: + - * / %(Gracias Wally West)
• Sin uso de funciones porcentuales o API incorporadas
• No acceder a la red
• No uso de evalo similar
• Sin calculadora de Windows (sí, la gente ha respondido con ella antes)
• Sin funciones de tip incorporadas (no es que cualquier idioma tenga una)

La salida debe redondearse a dos decimales.

La puntuación se basa en la longitud en bytes.

-20% si su programa puede aceptar cualquier cantidad de propina. La entrada para la cantidad se dará en forma de xx, por ejemplo 35 no 0.35

Javascript 81

EDITAR : El resultado ahora es un redondeo real, no truncado.

No use NINGUNA matemática aquí, solo manipulación de cadenas y operadores bit a bit.
Todos los caracteres +son concatenación de cadenas o conversión de cadena a flotante .
Funciona para cualquier entrada y salida xx.xx en formato (x) x.xx

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

Truco explicado: el 20% se divide por 10 y se multiplica por 2.

• Haz una división por 10 moviéndote el punto a la izquierda (manipulación de cuerdas)
• Multiplique cada parte por 2 moviendo bits hacia la izquierda (operación bit a bit)

J (9 caracteres)

Una respuesta corta en J:

^.(^.2)^~ 32

Pure bash, 50 43 caracteres

Estoy bastante seguro de que esto será mejor, pero aquí hay un comienzo:

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

Según los comentarios:

• /no es un operador de división aquí, es parte de una expansión del parámetro de sustitución de patrón
• % no es un operador de módulo aquí, es parte de una expansión de parámetros
• - no es un operador de resta aquí, es una negación, que se permitió según los comentarios

Salida:

$ ./20pct.sh 0.96
.19
$ ./20pct.sh 20.96
4.19
$ ./20pct.sh 1020.96
204,19
PS 

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 (sin bonificación)

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

Nota

• + se usa para la concatenación de cadenas
• * usado para crear copias de cadena

Sin golf

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

Nota

En el espíritu de la pregunta, creo que la siguiente solución, aunque sigue todas las reglas de la pregunta, es un abuso

Python 41

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

Finalmente

Si insiste en que los símbolos matemáticos están prohibidos, ella es una solución de 90 caracteres

Python 90 (sin ningún símbolo matemático)

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

APL (9 caracteres, nuevo código con 7 caracteres, corregido con 13 caracteres)

Calcule el 20% de la cantidad dada.

{⍟⍵*⍨*.2} 32

En APL *es el operador exponencial.

Pruébalo en línea .

Pero, ¿por qué usar una función para eso? Ver esta nueva versión:

⍟(*.2)* 32

Pruébalo en línea .

Por favor, antes de votar, *no está prohibido como CLAVE y no significa multiplicación aquí.

OK, aquí está la versión redondeando a 2 decimales (Dyalog APL):

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

R, 30 27 36 34

Actualizado a redondear a 2 decimales

Salvado 2 personajes gracias a plannapus

Crea un vector de 0 a xy toma el segundo elemento.

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

Ejemplo:

> a(20.36)
[1] 4.07

Explicación adicional:

seq(0,x,len=6)

crea un vector de longitud 6 desde 0 hasta el valor de entrada x, con los valores intermedios igualmente espaciados.

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

El primer valor es entonces 0%, el segundo 20%, tercero 40%, etc.

dc + sed + tuberías (44 caracteres)

Mi tercera respuesta (una APL, una J, y ahora una con el viejo y venerable DC).

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

Solicitará una entrada INTEGER y calculará el 20% de una manera complicada. La entrada se convierte a la base 5 (fácil de hacer con muchas otras herramientas pero espere ...); se agrega un punto antes del último dígito con sed (desafortunadamente, dc no puede manejar cadenas muy bien), y ENTONCES, dc convierte de nuevo desde la base 5 en un número flotante (no todas las herramientas pueden hacer eso).

Python, 88

Esto no es para nada corto, pero esto demuestra cómo debe hacerse una división mental normal por cinco. Esto supone que la entrada debe tener la forma xx.xx

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

O para la entrada de cualquier longitud, se requiere una adición de 3 caracteres.

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

Explicación: Tomamos la entrada como una cadena, luego movemos el punto decimal un lugar hacia adelante (dividiendo por 10). Luego lo lanzamos a un flotador y usamos la ldexpfunción para multiplicarlo por 2.

Tenga en cuenta que en esta respuesta, +son operadores de concatenación de cadenas y %se utilizan para formatear print.

Si insiste en no usar ninguno de estos caracteres, aquí hay una solución de 159 caracteres:

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

(Inspirado por la respuesta de ברוכאל )

• Maneja cualquier cantidad de propina (entero o flotante)

Ejecuciones de ejemplo (la entrada se acepta a través de 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

Mathematica, 19

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

Sin el uso de los operadores matemáticos de +, -, *, /, o %. Utiliza propiedades de logaritmos para calcular la respuesta; cuando simplificas la expresión, obtienes.2*Input[]

Con la bonificación ( 30 * 0.8 = 24 ):

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

Ingrese el porcentaje primero, luego la cantidad.

Cuando simplificas la expresión, obtienes Input[]*Input[]*.01.

Gracias a ברוכאל por ayudarme a acortar el código.

TI-89 Basic - 39 * 0.8 = 31.2

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

Funciona ingresando los dos números y luego usando las propiedades del logaritmo para calcular x * y / 100.

Si puedo asumir la entrada de la ubicación en variables globales xy y, entonces, esto es mucho más corto, para un puntaje de 17 * 0.8 = 13.6 :

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

Sin bonificación ( 12 ):

ln((e^.2)^x)

Pero si necesita ser envuelto en una función, entonces esto funciona ( 38 caracteres, para 30.4 ):

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

PHP 107 * .8 = 85.6

Realmente no puedo correr para code-golf con PHP, pero al menos puedo operar en cadenas. acepta ambos números como argumentos de línea de comandos.

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

tuve que revertirlo dos veces ya que no puedo usar -2 :(

Python, 81 80 89 caracteres

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

Explicación

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]

Técnicamente, esto es trampa, ya que se trunca a dos decimales en lugar de redondearlo, pero puedo argumentar que se redondea (mejor para ti, menos propina).

JavaScript 251 (restricción forzada: no +, -, *,? O% de ninguna manera)

Si bien sé que esto no ganará, pensé que trataría de obtener puntos de brownie adoptando un enfoque muy estricto y ni siquiera pensar en usar los operadores restringidos en cualquier forma ... como resultado, se me ocurrió esta belleza...

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

Usé operaciones bit a bit para crear la función Agregar A, y luego comencé a encadenar desde allí:

La función de división de enteros Dutilizaba una serie de suma negada (sustracción en forma de A(x,A(~y,1)un bucle; el resto es manipulación de cadenas y concatenación para evitar el uso de +operadores de concatenación ...

El número debe proporcionarse en forma decimal con dos lugares decimales para que esto funcione ...

Perl 50 60 bytes

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

La entrada se espera en STDIN. Debe contener el separador decimal con dos dígitos decimales. La salida se escribe en STDOUT.

Actualización: el paso $_<<=1elimina los ceros a la izquierda. Por lo tantom|\d{3}$| lo , no coincidiría con las facturas <1. Por lo tanto, $_="00$se agregaron diez bytes , ahora incluso 0.00funciona.

Ejemplos:

• Entrada: 20.96salida:4.19
• Entrada: 12.34salida:2.47

Versión sin golf:

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

Primero se lee el número de STDIN. Luego se elimina el punto decimal, que se multiplica por 100. Luego, la cantidad se duplica por un operador de desplazamiento. Luego se reinserta el punto decimal y el resultado se imprime y se redondea a dos dígitos decimales.

50 bytes, si factura ≥ 1:

Si x.xxes mayor o igual que 1.00, entonces se pueden eliminar 10 bytes:

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

JavaScript (ES6) (Regex) 142

Regex es genial y puede hacer muchas cosas. ¡Incluso puede hacer matemáticas!

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

Versión legible:

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

los tip() función espera el argumento String, en lugar de Number.

Todas las instancias de *, /, +no están relacionados con las operaciones matemáticas.

• + es la concatenación de cadenas en todos los casos en que se usa.
• * es parte de la sintaxis RegExp
• / es el delimitador del literal de RegExp

La entrada debe usarse .como punto decimal, y debe haber 2 dígitos después del punto decimal.

Fragmento de pila

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

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

Abusa del hecho de que los exponentes se convierten en multiplicación en logaritmos.