Reto

Dado un número (coma flotante / decimal), devuelve su recíproco, es decir, 1 dividido por el número. La salida debe ser un número de coma flotante / decimal, no solo un número entero.

Especificación detallada

• Debe recibir la entrada en forma de número de coma flotante / decimal ...
  • ... que tiene al menos 4 dígitos significativos de precisión (si es necesario).
  • Más es mejor, pero no cuenta en el puntaje.
• Debe generar, con cualquier método de salida aceptable ...
  • ... el recíproco del número.
  • Esto se puede definir como 1 / x, x⁻¹.
  • Debe generar al menos 4 dígitos significativos de precisión (si es necesario).

La entrada será positiva o negativa, con un valor absoluto en el rango [0.0001, 9999] inclusive. Nunca se le darán más de 4 dígitos más allá del punto decimal, ni más de 4 a partir del primer dígito distinto de cero. La salida debe ser precisa hasta el cuarto dígito del primer dígito distinto de cero.

(Gracias @MartinEnder)

Aquí hay algunas entradas de muestra:

0.5134
0.5
2
2.0
0.2
51.2
113.7
1.337
-2.533
-244.1
-0.1
-5

Tenga en cuenta que nunca se le darán entradas que tengan más de 4 dígitos de precisión.

Aquí hay una función de muestra en Ruby:

def reciprocal(i)
    return 1.0 / i
end

Reglas

• Todas las formas aceptadas de salida están permitidas
• Lagunas estándar prohibidas
• Este es el código de golf , la respuesta más corta en bytes gana, pero no se seleccionará.

Aclaraciones

• Nunca recibirá la entrada 0.

Recompensas

Este desafío es obviamente trivial en la mayoría de los idiomas, pero puede ofrecer un desafío divertido en idiomas más esotéricos e inusuales, por lo que algunos usuarios están dispuestos a otorgar puntos por hacerlo en idiomas inusualmente difíciles.

• @DJMcMayhem otorgará una recompensa de +150 puntos a la respuesta más breve de brain-flak, ya que brain-flak es notoriamente difícil para los números de coma flotante

• @ L3viathan otorgará una recompensa de +150 puntos a la respuesta OIL más corta . OIL no tiene ningún tipo de coma flotante nativa, ni tiene división.

• @Riley otorgará una recompensa de +100 puntos a la respuesta sed más corta.

• @EriktheOutgolfer otorgará una recompensa de +100 puntos a la respuesta más breve de Sesos. La división en derivados de cerebro como Sesos es muy difícil, y mucho menos la división de punto flotante.

• Yo ( @Mendeleev ) otorgaré una recompensa de +100 puntos a la respuesta más breve de Retina.

Si cree que sería divertido ver una respuesta en un idioma y está dispuesto a pagar el representante, siéntase libre de agregar su nombre a esta lista (ordenado por cantidad de recompensa)

Tabla de clasificación

Aquí hay un fragmento de pila para generar una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

# Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=114544,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

Brain-Flak , 772 536 530 482 480 + 1 = 481 bytes

Como Brain-Flak no admite números de coma flotante, tuve que usar el -cindicador en orden de entrada y salida con cadenas, de ahí el +1.

(({})[((((()()()()())){}{})){}{}]){((<{}>))}{}({}<{({}[((((()()()){}())()){}{}){}]<>)<>}<>{({}<>[()()])<>}{}([]<{({}<>[()()])<>}>)<>([[]](())){({}()<((((((({}<(((({})({})){}{}){}{})>)({})){}{}){})({})){}{}){})>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>){({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)}{}<>({}()<<>([]){{}({}<>)<>([])}{}<>>){({}[()]<({}<>((((()()()){}){}){}){})<>>)}{}([()()])([]){{}({}<>((((()()()){}){}){}){})<>([])}<>>)

Pruébalo en línea!

Explicación

Lo primero que debemos cuidar es el caso negativo. Como el recíproco de un número negativo siempre es negativo, simplemente podemos mantener el signo negativo hasta el final. Comenzamos haciendo una copia de la parte superior de la pila y restando 45 (el valor ASCII de -). Si este es uno, ponemos un cero en la parte superior de la pila, si no, no hacemos nada. Luego, recogemos la parte superior de la pila para colocar al final del programa. Si la entrada comenzó con un, -esto sigue siendo un -sin embargo, si no es así , terminamos recogiendo ese cero que colocamos.

(({})[((((()()()()())){}{})){}{}]){((<{}>))}{}
({}<

Ahora que eso está fuera del camino, necesitamos convertir las realizaciones ASCII de cada dígito en sus valores reales (0-9). También vamos a eliminar el punto decimal .para facilitar los cálculos. Como necesitamos saber dónde comenzó el punto decimal cuando lo volvemos a insertar más tarde, almacenamos un número para realizar un seguimiento de cuántos dígitos había delante del. la pila.

Así es como el código hace eso:

Comenzamos restando 46 (el valor ASCII de .) de cada elemento en la pila (moviéndolos simultáneamente a todos en la pila). Esto hará que cada dígito sea dos más de lo que debería ser, pero hará que sea .exactamente cero.

{({}[((((()()()){}())()){}{}){}]<>)<>}<>

Ahora movemos todo a la pila izquierda hasta que lleguemos a cero (restando dos de cada dígito mientras avanzamos):

{({}<>[()()])<>}{}

Registramos la altura de la pila

([]<

Mueve todo lo demás a la pila izquierda (una vez más restando los dos últimos de cada dígito a medida que los movemos)

  {({}<>[()()])<>}

Y pon la altura de la pila que registramos

>)

Ahora queremos combinar los dígitos en un solo número base 10. También queremos hacer una potencia de 10 con el doble de dígitos que ese número para usar en el cálculo.

Comenzamos configurando un 1 en la parte superior de la pila para obtener la potencia de 10 y empujando la altura de la pila menos uno a la pila para el uso del bucle.

<>([][(())])

Ahora giramos la altura de la pila menos 1 vez,

{
 ({}[()]<

Cada vez que multiplicamos el elemento superior por 100 y debajo, multiplicamos el siguiente elemento por 10 y lo sumamos al número siguiente.

 ((((((({}<(((({})({})){}{}){}{})>)({})){}{}){})({})){}{}){})

Terminamos nuestro ciclo

 >)
}{}

Ahora finalmente hemos terminado con la configuración y podemos comenzar el cálculo real.

({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)

Eso fue todo...

Dividimos el poder de 10 por la versión modificada de la entrada usando el algoritmo de división de enteros de 0 como se encuentra en la wiki . Esto simula la división de 1 por la entrada de la única forma en que Brain-Flak sabe cómo.

Por último, tenemos que formatear nuestra salida en el ASCII apropiado.

Ahora que hemos descubierto nenecesitamos sacar el e. El primer paso para esto es convertirlo en una lista de dígitos. Este código es una versión modificada del algoritmo divmod de 0 ' ' .

{({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)}{}

Ahora tomamos el número y agregamos el punto decimal donde pertenece. Solo pensar en esta parte del código trae dolores de cabeza, así que por ahora lo dejaré como un ejercicio para que el lector descubra cómo y por qué funciona.

<>({}()<<>([]){{}({}<>)<>([])}{}<>>){({}[()]<({}<>((((()()()){}){}){}){})<>>)}{}([()()])([]){{}({}<>((((()()()){}){}){}){})<>([])}<>

Ponga el signo negativo hacia abajo o un carácter nulo si no hay signo negativo.

>)

Python 2 , 10 bytes

1..__div__

Pruébalo en línea!

Retina , 99 91 bytes

1`\.|$
8$*;
+`;(;*)(\d)
$2$1
\d+
$*1,10000000$*
(1+),(\1)+1*
$#2
+`(\d)(;+);
$2$1
1`;
.
;
0

Pruébalo en línea!

Woohoo, sub-100! Esto es sorprendentemente eficiente, considerando que crea (y luego compara) una cadena con más de 10 ⁷ caracteres en un punto. Estoy seguro de que aún no es óptimo, pero estoy bastante contento con el puntaje en este momento.

Los resultados con un valor absoluto inferior a 1 se imprimirán sin el cero inicial, por ejemplo, .123o-.456 .

Explicación

La idea básica es usar la división de enteros (porque eso es bastante fácil con expresiones regulares y aritmética unaria). Para garantizar que obtengamos un número suficiente de dígitos significativos, dividimos la entrada en 10 ⁷ . De esa manera, cualquier entrada hasta 9999 todavía da como resultado un número de 4 dígitos. Efectivamente, eso significa que estamos multiplicando el resultado por 10 ^7, por lo que debemos hacer un seguimiento de eso cuando más tarde reinserte el punto decimal.

1`\.|$
8$*;

Comenzamos reemplazando el punto decimal, o el final de la cadena si no hay un punto decimal con 8 puntos y comas. El primero de ellos es esencialmente el punto decimal en sí mismo (pero estoy usando punto y coma porque no necesitan escapar), los otros 7 indican que el valor se ha multiplicado por 10 ⁷ (este no es el caso todavía, pero sabemos que lo haremos más tarde).

+`;(;*)(\d)
$2$1

Primero convertimos la entrada en un número entero. Mientras haya dígitos después del punto decimal, movemos un dígito al frente y eliminamos uno de los puntos y comas. Esto se debe a que mover el punto decimal hacia la derecha multiplica la entrada por 10 y, por lo tanto, divide el resultado por 10 . Debido a las restricciones de entrada, sabemos que esto sucederá como máximo cuatro veces, por lo que siempre hay suficientes puntos y comas para eliminar.

\d+
$*1,10000000$*

Ahora que la entrada es un número entero, la convertimos en unario y agregamos 10 ⁷ 1 s (separados por a ,).

(1+),(\1)+1*
$#2

Dividimos el número entero en 10 ⁷ contando cuántas referencias posteriores caben ( $#2). Esta es la división de enteros unarios estándar a,b-> b/a. Ahora solo tenemos que corregir la posición del punto decimal.

+`(\d)(;+);
$2$1

Esto es básicamente lo contrario de la segunda etapa. Si todavía tenemos más de un punto y coma, eso significa que aún debemos dividir el resultado por 10 . Hacemos esto moviendo los puntos y coma una posición hacia la izquierda y soltando un punto y coma hasta que lleguemos al extremo izquierdo del número, o nos quedemos con solo un punto y coma (que es el punto decimal en sí).

1`;
.

Ahora es un buen tiempo para convertir la primera (y posiblemente el único) ;de nuevo en ..

;
0

Si todavía quedan puntos y comas, hemos llegado al extremo izquierdo del número, por lo que dividir entre 10 nuevamente insertará ceros detrás del punto decimal. Esto se hace fácilmente reemplazando cada uno restante ;con un 0, ya que de todos modos están inmediatamente después del punto decimal.

sí , 5 bytes

|0~-e

Pruébalo en línea!Esto toma información de la parte superior de la pila y deja la salida en la parte superior de la pila. El enlace TIO toma datos de los argumentos de la línea de comandos, que solo es capaz de tomar datos enteros.

Explicación

Sí, solo tiene unos pocos operadores. Los que se usan en esta respuesta son ln (x) (representado por |), 0 () (constante, retorno de la función nilar 0), - (sustracción) y exp (x) (representado por e). ~cambia los dos primeros miembros de la pila.

|0~-e     top of the stack: n    stack: [n]
|         pop n, push ln(n)      stack: [ln(n)]
 0        push 0                 stack: [ln(n), 0]
  ~       swap                   stack: [0, ln(n)]
   -      subtract               stack: [-ln(n)]
    e     exp                    stack: [exp(-ln(n))]

Esto usa la identidad

lo que implica que

LOLCODE , 63 , 56 bytes

HOW DUZ I r YR n 
VISIBLE QUOSHUNT OF 1 AN n
IF U SAY SO

¡7 bytes guardados gracias a @devRicher!

Esto define una función 'r', que se puede llamar con:

r 5.0

o cualquier otro NUMBAR.

Pruébalo en línea!

sed , 575 + 1 ( -rbandera) = 723 718 594 588 576 bytes

s/$/\n0000000000/
tb
:b
s/^0+//
s/\.(.)(.*\n)/\1.\2/
tD
bF
:D
s/.*/&&&&&&&&&&/2m
tb
:F
s/\.//
h
s/\n.+//
s/-//
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta
:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

Pruébalo en línea!

Nota: los flotantes para los cuales el valor absoluto es menor que 1 deberán escribirse sin un 0 inicial en .5lugar de 0.5. Además, el número de lugares decimales es igual a , donde nes el número de lugares decimales en el número (por lo que dar 13.0como entrada dará más lugares decimales que dar 13como entrada)

Esta es mi primera presentación de sed en PPCG. Las ideas para la conversión de decimal a unario se tomaron de esta sorprendente respuesta . ¡Gracias a @seshoumara por guiarme a través de sed!

Este código realiza una división larga repetida para obtener el resultado. La división solo toma ~ 150 bytes. Las conversiones decimales unitarias toman la mayor cantidad de bytes, y algunos otros bytes son compatibles con números negativos y entradas de punto flotante

Explicación

Explicación sobre TIO

#Append 10 0's. This is the dividend, I think
s/$/\n0000000000/
tb

#This branch moves the decimal point 1 to the right
:b
#Remove leading 0's (such as from numbers like .05 => 0.5)
s/^0+//
#Move the decimal point 1 to the right
s/\.(.)(.*\n)/\1.\2/
#If the above has resulted in a successful substitution, go to branch D
tD
#else go to branch F
bF

#Multiply the dividend by 10; also keeps the mood positive
:D
s/.*/&&&&&&&&&&/2m
#Then go back to branch b
tb

:F
#Remove decimal point since it is all the way to the right now
s/\.//
h
#Remove "unnecessary" things
s/\n.+//
s/-//

#Convert to unary
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/

#Append the unary number to the pattern space
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/

### END Decimal-to-Unary conversion
### BEGIN Division

#Performs Long Division
#Format looks something like this (can't remember): divisor\ndividend\ncount\nresult
#Count controls how many decimal places the answer should have; dp => 10^numDigits(n)
#Removes divisor from dividend and then add a 0 to result
#Once the dividend becomes too small, append a space to result and remove a zero from count
#Rinse and repeat
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta

### END DIVISION
### BEGIN Unary-to-Decimal conversion

:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//

#"carry over"-ing; .0000000000 => 0.
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx

#Convert each pair of unary 0s to their decimal counterparts
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

Ediciones

• s:s/(.)/(.)/g:y/\1/\2/g:g para guardar 1 byte en cada sustitución (5 en total)
• Ahorró una tonelada de bytes mirando un buen convertidor de decimal a unario en "Consejos para jugar al golf en sed"
• Cambié alrededor de algunas sustituciones que giraron en torno al cuidado del signo menos para guardar 6 bytes.
• Utilizado en \nlugar de ;como separador, pude acortar las sustituciones "multiplicar por 10" para ahorrar 12 bytes (gracias a @Riley y @seshoumara por mostrarme esto)

JSFuck , 3320 bytes

JSFuck es un estilo de programación educativo y esotérico basado en las partes atómicas de JavaScript. Utiliza solo seis caracteres diferentes ()[]+!para escribir y ejecutar código.

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+[+!+[]]+(![]+[+![]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]

Pruébalo en línea!

alert(
  /* empty array       */ []
  /* ['fill']          */ [(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]
  /* ['constructor']   */ [([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]
  /* ('return+1/this') */ ((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+[+!+[]]+(![]+[+![]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]])
  /* ['call']          */ [([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]
  (prompt())
)

ACEITE , 1428 1420 bytes

Oh bien. Pensé que podría intentarlo, y al final lo logré. Solo hay un inconveniente: lleva casi tanto tiempo correr como escribir para escribir.

El programa está separado en varios archivos, que tienen todos los nombres de archivo de 1 byte (y cuentan para un byte adicional en el cálculo de mi byte). Algunos de los archivos son parte de los archivos de ejemplo del lenguaje OIL, pero no hay una forma real de llamarlos constantemente (todavía no hay una ruta de búsqueda ni nada parecido en OIL, por lo que no los considero una biblioteca estándar), pero eso también significa que (en el momento de la publicación) algunos de los archivos son más detallados que necesarios, pero generalmente solo por unos pocos bytes.

Los cálculos tienen una precisión de 4 dígitos de precisión, pero calcular incluso un recíproco simple (como la entrada 3) lleva mucho tiempo (más de 5 minutos) en completarse. Para fines de prueba, también hice una variante menor que tiene una precisión de 2 dígitos, que solo demora unos segundos en ejecutarse, para demostrar que funciona.

Lamento la gran respuesta, desearía poder usar algún tipo de etiqueta de spoiler. También podría poner la mayor parte en gist.github.com o algo similar, si lo desea.

Aquí vamos: main217 bytes (el nombre del archivo no cuenta para bytes):

5
1
1
4
-
14
a
5
Y
10
5
8
14
29
12
1
97
1
97
24
9
24
13
99

1
1
4
31
1
35

14
a
32
.
10
32
8
50
41
1
53
2
14
b
1
1
6
72
14
c
5
0000
14
d
6
6
10
74
5
63
68
1
6
1
6
72
14
b
1
5
1
77
0
14
e
1
0
14
f
1
1
1
31
0
14
b
0
0
4

a (comprueba si una cadena dada está en otra cadena dada), 74 + 1 = 75 bytes:

5
0
5
1
14
g
2
0
10
2
30
24
13
10
1
31
27
18
14
h
1
1
6
4
4
30
3
4
29
N
Y

b (une dos cadenas dadas), 20 + 1 = 21 bytes:

5
0
5
1
13
0
2
0
4
0

c (dado un símbolo, divide la cadena dada en su primera aparición), 143 + 1 = 144 bytes (este obviamente todavía es golfable):

5
0
5
83
12
83
83





10
84
0
21
17
8
13
6
12
1
13
1
1
5
2
14
i
45
1
1
83
1
1
45
2
14
i
57
1
9
45
13
84

1



8
13
1
13
56
13
13

2
4
1
11
4
2

d (dada una cadena, obtiene los primeros 4 caracteres), 22 + 1 = 23 bytes:

5
0
12
0
20
13
21
4

4

e (división de alto nivel (pero con peligro de división cero)), 138 + 1 = 139 bytes:

5
0
5
1
.
.
1
1
6
14
j
0
0
1
0
4
10
11
1
58
21
14
b
4
4
1
1
15
14
k
0
15
1
6
1
14
j
0
0
1
0
5
14
b
4
4
9
8
10
8
11
58
53
10
11
1
58
25
4
4

f (mueve un punto 4 posiciones a la derecha; "divide" por 10000), 146 + 1 = 147 bytes:

5
.
12
0
100
10
101
1
14
10
8
6
6
5
1
6
34
1
6
33
8
33
1
6
37
8
37
10
55
3
48
32
1
102
101
1
1
102
9
55
8
34
8
33
8
37
6
27
1
100
53
13
101


4

4

g (comprueba si una cadena comienza con un carácter dado), 113 + 1 = 114 bytes:

5
0
5
1
12
0
100
12
1
200
1
6
2
1
9
3
8
2
8
3
9
100
9
200
1
2
31
1
3
32
10


39
35
4
38
3
N
10
100
5
44
16
4
46
Y

h (devuelve todo menos el primer carácter de una cadena dada), 41 + 1 = 42 bytes:

5
0
12
0
100
9
100
1
100
12
13
102

0
4
0

i (resta dos números), 34 + 1 = 35 bytes:

5
0
5
1
10
16
1
14
9
9
0
9
1
6
4
0

j (división de bajo nivel que no funciona en todos los casos), 134 + 1 = 135 bytes:

5
0
5
2
10
2
19
52
9
1
2
3
10
23
2
28
17
10
23
0
35
22
9
0
9
2
6
12
8
1
1
3
2
6
17
10
23
2
46
40
9
2
9
3
6
35
4
1
11
4
3
3
4
19
11
4
0

k (multiplicación), 158 + 1 = 159 bytes:

5
0
5
1
8
0
9
0
8
1
9
1
1
5
2
12
0
68
10
69
66
23
29
8
7
14
l
0
0
12
1
68
10
69
66
37
43
8
7
14
l
1
1
10
0
5
56
48
9
0
14
m
2
1
6
43
10
7
3
61
63
4
66
4
2
3
-

l (valor absoluto de retorno), 58 + 1 = 59 bytes:

5
-
12
0
24
10
25
1
13
10
4
0
3
9
24
1
24
20
13
26

0
6
10

m (además), 109 + 1 = 110 bytes:

5
0
5
1
8
0
9
0
8
1
9
1
12
1
46
10
47
45
31
20
10
1
43
42
25
9
1
8
0
6
20
10
1
43
42
36
8
1
9
0
6
31
4
0
3
-

J, 1 byte

%

%es una función que da el recíproco de su entrada. Puedes ejecutarlo así

   % 2
0.5

Taxi , 467 bytes

Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.1 is waiting at Starchild Numerology.Pickup a passenger going to Divide and Conquer.Go to Post Office:w 1 r 2 r 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:e 4 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 1 r.Pickup a passenger going to Post Office.Go to Post Office:e 1 l 1 r.

Pruébalo en línea!

Sin golf:

Go to Starchild Numerology:west 1 left, 2 right, 1 left, 1 left, 2 left.
1 is waiting at Starchild Numerology.
Pickup a passenger going to Divide and Conquer.
Go to Post Office:west 1 right, 2 right, 1 right, 1 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:south 1 left, 1 right.
Pickup a passenger going to Divide and Conquer.
Go to Divide and Conquer:east 4 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:east 1 right.
Pickup a passenger going to Post Office.
Go to Post Office:east 1 left, 1 right.

Vim, 10 8 bytes / pulsaciones de teclas

C<C-r>=1/<C-r>"

Como V es compatible con versiones anteriores, ¡puede probarlo en línea!

x86_64 lenguaje máquina Linux, 5 bytes

0:       f3 0f 53 c0             rcpss  %xmm0,%xmm0
4:       c3                      retq

Para probar esto, puede compilar y ejecutar el siguiente programa C

#include<stdio.h>
#include<math.h>
const char f[]="\xf3\xf\x53\xc0\xc3";
int main(){
  for( float i = .1; i < 2; i+= .1 ) {
    printf( "%f %f\n", i, ((float(*)(float))f)(i) );
  }
}

Pruébalo en línea!

C, 15 12 bytes

#define f 1/

Pruébalo en línea!

16 13 bytes, si necesita manejar la entrada entera también:

#define f 1./

Entonces puedes llamarlo con en f(3)lugar de f(3.0).

Pruébalo en línea!

¡Gracias a @hvd por jugar al golf 3 bytes!

MATLAB / Octave, 4 bytes

@inv

Crea un identificador de función (denominado ans ) para la invfunción incorporada

Demo en línea

05AB1E , 1 byte

z

Pruébalo en línea!

z # pop a  push 1 / a

GNU sed , 377 + 1 (r flag) = 363 bytes

Advertencia: ¡ el programa consumirá toda la memoria del sistema que intenta ejecutarse y requerirá más tiempo para terminar de lo que estaría dispuesto a esperar! Vea a continuación una explicación y una versión rápida, pero menos precisa.

s:\.|$:,,,,,,,,:;:i;s:,(,+)(\w):\2\1:;ti
h;:;s:\w::2g;y:9876543210:87654321\t :;/ /!s:,:@,:;/\s/!t;x;s:-?.::;x;G;s:,.*::m;s:\s::g;/\w/{s:@+:&&&&&&&&&&:;t}
/@,-?@/!{s:^:10000000,:;h;t}
:l;s:(@+)(,-?\1):\2;:;tl;s:,::;s:@+;?@+::
s:-?:&0:;:c;s:\b9+:0&:;s:.9*;:/&:;h;s:.*/::;y:0123456789:1234567890:;x;s:/.*::;G;s:\n::;s:;::;/;/tc
:f;s:(\w)(,+),:\2\1:;tf;s:,:.:;y:,:0:

Esto se basa en la respuesta de Retina de Martin Ender. Yo cuento\t desde la línea 2 como una pestaña literal (1 byte).

Mi principal contribución es al método de conversión de decimal a unario simple (línea 2) y viceversa (línea 5). Logré reducir significativamente el tamaño del código necesario para hacer esto (en ~ 40 bytes combinados), en comparación con los métodos mostrados en un consejo anterior . Creé una respuesta de consejo por separado con los detalles, donde proporciono fragmentos listos para usar. Como 0 no está permitido como entrada, se guardaron algunos bytes más.

Explicación: para comprender mejor el algoritmo de división, lea primero la respuesta Retina

El programa es teóricamente correcto, la razón por la que consume tantos recursos computacionales es que el paso de división se ejecuta cientos de miles de veces, más o menos dependiendo de la entrada, y la expresión regular utilizada da lugar a una pesadilla de retroceso. La versión rápida reduce la precisión (de ahí el número de pasos de división) y cambia la expresión regular para reducir el retroceso.

Desafortunadamente, sed no tiene un método para contar directamente cuántas veces una referencia inversa se ajusta a un patrón, como en Retina.

s:\.|$:,,,,,,,,:             # replace decimal point or end of string with 8 commas
:i                           # loop to generate integer (useful for unary division)
  s:,(,+)(\w):\2\1:          # move 1 digit in front of commas, and delete 1 comma
ti                           # repeat (':i')
h;:                          # backup pattern and start decimal to unary conversion
  s:\w::2g                   # delete decimal digits, except the first (GNU magic)
  y:9876543210:87654321\t :; # transliterate characters
  / /!s:,:@,:                # if no space is present, append a unary digit ('@')
  /\s/!t                     # if no whitespace is present, go back to ':'
  x;s:-?.::;x                # delete first digit and the negative sign from backup
  G;s:,.*::m;s:\s::g         # append backup, delete whitespace and duplicate stuff
/\w/{s:@+:&&&&&&&&&&:        # if decimal digit left, multiply unary number by 10
t}                           # and repeat (':')
/@,-?@/!{                    # if only one unary number found (the input)
  s:^:10000000,:             # prepend decimal 10^7 separated by a comma
h;t}                         # backup pattern and convert new number to unary also
:l                           # start unary division loop (tons of RAM and time!!!)
  s:(@+)(,-?\1):\2;:         # delete as many '@'s from 10^7, as found in unary
                             #input, and add one ';' (new unary digit)
tl                           # repeat (':l')
s:,::;s:@+;?@+::             # delete leftover stuff
s:-?:&0:;:c                  # prepend zero and start unary to decimal conversion
  s:\b9+:0&:                 # if only 9s found, prepend zero to them
  s:.9*;:/&:                 # separate the digit(s) that would change on increment
  h;s:.*/::                  # backup, delete all (non-changing) digits (till '/')
  y:0123456789:1234567890:   # increment changing digit(s)
  x;s:/.*::                  # delete changing digits from backup
  G;s:\n::                   # append backup, delete newline
  s:;::                      # delete one unary digit (';')
/;/tc                        # if unary portion left, repeat (':c')
:f                           # loop to generate floating-point number
  s:(\w)(,+),:\2\1:          # move 1 digit after the commas, and delete 1 comma
tf                           # repeat (':f')
s:,:.:                       # turn first comma into a decimal point
y:,:0:                       # turn the rest of commas into zeroes (final result)
                             # implicit printing

Para una versión rápida y segura del programa, pero menos precisa, puede probar esto en línea .

Japt , 2 bytes

La solución obvia sería

1/U

que es, literalmente, 1 / input. Sin embargo, podemos hacer uno mejor:

pJ

Esto es equivalente a input ** J, y Jse establece en -1 de forma predeterminada.

Pruébalo en línea!

Dato curioso: como pes la función de potencia, también lo qes la función raíz ( p2= **2, q2= **(1/2)); Esto significa que qJfuncionará tan bien, ya que -1 == 1/-1, por lo tanto x**(-1) == x**(1/-1).

Javascript ES6, 6 bytes

x=>1/x

Pruébalo en línea!

El valor predeterminado de Javascript es la división de coma flotante.

APL, 1 byte

÷

÷Calcula recíproco cuando se usa como función monádica. Pruébalo en línea!

Utiliza el conjunto de caracteres Dyalog Classic.

Cheddar , 5 bytes

1&(/)

Pruébalo en línea!

Esto utiliza &, que une un argumento a una función. En este caso, 1está vinculado al lado izquierdo de /, lo que nos da 1/x, para una discusión x. Esto es más corto que el canónico x->1/xen 1 byte.

Alternativamente, en las versiones más nuevas:

(1:/)

Java 8, 6 bytes

x->1/x

Casi lo mismo que la respuesta de JavaScript .

MATL , 3 bytes

l_^

Pruébalo en MATL Online

Explicación

    % Implictily grab input
l_  % Push -1 to the stack
^   % Raise the input to the -1 power
    % Implicitly display the result

Python, 12 bytes

lambda x:1/x

Uno para 13 bytes:

(-1).__rpow__

Uno para 14 bytes:

1 .__truediv__

Mathematica, 4 bytes

1/#&

Le proporciona un racional exacto si le da un racional exacto y un resultado de coma flotante si le da un resultado de coma flotante.

ZX Spectrum BASIC, 13 bytes

1 INPUT A: PRINT SGN PI/A

Notas:

• Cada línea cuesta 2 bytes para el número de línea, 2 bytes para la longitud de la línea y 1 byte para la nueva línea.
• Los literales numéricos se convierten en binarios en tiempo de análisis, con un costo adicional de 6 bytes, por lo tanto, el uso de en SGN PIlugar de literales1 .
• Las palabras clave toman 1 byte cada una.

Versión ZX81 para 17 bytes:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 bytes

(1/)

Pruébalo en línea!

R, 8 bytes

1/scan()

Muy claro. Emite directamente el inverso de la entrada.

Otra solución, pero 1 byte más larga puede ser:, scan()^-1o incluso scan()**-1por un byte adicional. Ambos ^y **el símbolo de poder.

TI-Basic (TI-84 Plus CE), 6 5 2 bytes

Ans⁻¹

-1 byte gracias a Timtech .

-3 bytes con Ansagradecimiento a Григорий Перельман .

Ansy ⁻¹son tokens de un byte .

TI-Basic devuelve implícitamente el último valor evaluado ( Ans⁻¹).

Gelatina , 1 byte

İ

Pruébalo en línea!

C, 30 bytes

float f(float x){return 1./x;}