Desafio

Dado um número (ponto flutuante / decimal), retorne seu recíproco, ou seja, 1 dividido pelo número. A saída deve ser um número decimal / ponto flutuante, não apenas um número inteiro.

Especificação detalhada

• Você deve receber entrada na forma de um número decimal / ponto flutuante ...
  • ... com pelo menos 4 dígitos significativos de precisão (se necessário).
  • Mais é melhor, mas não conta na pontuação.
• Você deve produzir, com qualquer método de saída aceitável ...
  • ... o recíproco do número.
  • Isso pode ser definido como 1 / x, x⁻¹.
  • Você deve produzir com pelo menos 4 dígitos significativos de precisão (se necessário).

A entrada será positiva ou negativa, com valor absoluto no intervalo [0,0001, 9999] inclusive. Você nunca terá mais que 4 dígitos além do ponto decimal, nem mais que 4 começando com o primeiro dígito diferente de zero. A saída precisa ser precisa até o quarto dígito, a partir do primeiro dígito diferente de zero.

(Obrigado @MartinEnder)

Aqui estão algumas entradas de amostra:

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

Observe que você nunca receberá entradas com mais de 4 dígitos de precisão.

Aqui está uma função de exemplo no Ruby:

def reciprocal(i)
    return 1.0 / i
end

Regras

• Todas as formas de saída aceitas são permitidas
• Falhas padrão proibidas
• Isso é código-golfe , a resposta mais curta em bytes vence, mas não será selecionada.

Esclarecimentos

• Você nunca receberá a entrada 0.

Recompensas

Esse desafio é obviamente trivial na maioria dos idiomas, mas pode oferecer um desafio divertido em idiomas mais esotéricos e incomuns; portanto, alguns usuários desejam conceder pontos por fazer isso em idiomas incomumente difíceis.

• O @DJMcMayhem concederá uma recompensa de +150 pontos à resposta mais curta ao cérebro, já que o cérebro é notoriamente difícil para números de ponto flutuante

• A @ L3viathan concederá uma recompensa de +150 pontos à resposta mais curta do OIL . OIL não possui um tipo de ponto flutuante nativo nem possui divisão.

• A @Riley concederá uma recompensa de +100 pontos à resposta sed mais curta.

• O @EriktheOutgolfer concederá uma recompensa de +100 pontos à resposta mais curta do Sesos. A divisão em derivados do cérebro como o Sesos é muito difícil, sem falar na divisão de ponto flutuante.

• Eu ( @Mendeleev ) atribuirei uma recompensa de +100 pontos à resposta mais curta da Retina.

Se houver um idioma que você acha divertido ver uma resposta e estiver disposto a pagar o representante, adicione seu nome a esta lista (classificado pelo valor da recompensa)

Entre os melhores

Aqui está um snippet de pilha para gerar uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](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 o Brain-Flak não suporta números de ponto flutuante, tive que usar a -cflag para ordenar a entrada e a saída com strings, daí o +1.

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

Experimente online!

Explicação

A primeira coisa que precisamos cuidar é o caso negativo. Como o recíproco de um número negativo é sempre negativo, podemos simplesmente manter o sinal negativo até o fim. Começamos fazendo uma cópia do topo da pilha e subtraindo 45 (o valor ASCII de -) dela. Se for esse o caso, colocamos um zero no topo da pilha; se não, não fazemos nada. Em seguida, pegamos o topo da pilha para ser colocado no final do programa. Se a entrada começou com um -este ainda é um -no entanto, se ele é não acabamos pegando que o zero que colocamos.

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

Agora que isso está fora do caminho, precisamos converter as realizações ASCII de cada dígito para os valores reais (0-9). Também vamos remover o ponto decimal .para facilitar os cálculos. Como precisamos saber onde o ponto decimal começou quando o reinserimos posteriormente, armazenamos um número para rastrear quantos dígitos estavam à frente do .na barra.

Aqui está como o código faz isso:

Começamos subtraindo 46 (o valor ASCII de .) de cada elemento da pilha (movendo-os simultaneamente para o offstack). Isso fará com que cada dígito seja mais dois do que deveria, mas fará .exatamente o zero.

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

Agora, movemos tudo para a pilha esquerda até atingirmos um zero (subtraindo dois de cada dígito enquanto avançamos):

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

Registramos a altura da pilha

([]<

Mova todo o resto para a pilha esquerda (subtraindo novamente os dois últimos de cada dígito à medida que os movemos)

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

E colocar a altura da pilha que registramos

>)

Agora queremos combinar os dígitos em um único número base 10. Também queremos fazer uma potência de 10 com o dobro dos dígitos como esse número para uso no cálculo.

Começamos configurando um 1 no topo da pilha para aumentar a potência de 10 e empurrando a altura da pilha menos uma para a pilha on para o uso de loop.

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

Agora fazemos um loop na altura da pilha menos 1 vezes,

{
 ({}[()]<

Cada vez que multiplicamos o elemento superior por 100 e, por baixo, multiplicamos o próximo elemento por 10 e adicionamos isso ao número abaixo.

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

Terminamos nosso loop

 >)
}{}

Agora, finalmente terminamos a configuração e podemos começar o cálculo real.

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

Foi isso ...

Dividimos o poder de 10 pela versão modificada da entrada usando o algoritmo de divisão inteira de 0, como encontrado no wiki . Isso simula a divisão de 1 pela entrada da única maneira que o Brain-Flak sabe.

Por fim, temos que formatar nossa saída no ASCII apropriado.

Agora que descobrimos ne, precisamos remover o e. O primeiro passo para isso é convertê-lo em uma lista de dígitos. Este código é uma versão modificada de 0 ' 's algoritmo DIVMOD .

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

Agora pegamos o número e adicionamos o ponto decimal de volta aonde ele pertence. Só de pensar nessa parte do código traz dores de cabeça, por enquanto, deixarei como um exercício para o leitor descobrir como e por que funciona.

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

Coloque o sinal negativo ou um caractere nulo se não houver sinal negativo.

>)

Python 2 , 10 bytes

1..__div__

Experimente online!

Retina , 99 91 bytes

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

Experimente online!

Woohoo, abaixo dos 100! Isso é surpreendentemente eficiente, considerando que ele cria (e combina contra) uma sequência com mais de 10 ⁷ caracteres em um ponto. Tenho certeza de que ainda não é o ideal, mas estou muito feliz com o placar no momento.

Resultados com valor absoluto menor que 1 serão impressos sem o zero inicial, por exemplo, .123ou -.456.

Explicação

A idéia básica é usar a divisão inteira (porque isso é bastante fácil com regex e aritmética unária). Para garantir que obtivemos um número suficiente de dígitos significativos, dividimos a entrada em 10 ⁷ . Dessa forma, qualquer entrada até 9999 ainda resulta em um número de 4 dígitos. Efetivamente, isso significa que multiplicamos o resultado por 10 ^7; portanto, precisamos acompanhar isso quando mais tarde reinserir o ponto decimal.

1`\.|$
8$*;

Começamos substituindo o ponto decimal, ou o final da string, se não houver ponto decimal por 8 ponto e vírgula. O primeiro deles é essencialmente o próprio ponto decimal (mas estou usando ponto e vírgula porque eles não precisam ser escapados), os outros 7 indicam que o valor foi multiplicado por 10 ⁷ (ainda não é o caso, mas sabemos que faremos isso mais tarde).

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

Primeiro, transformamos a entrada em um número inteiro. Enquanto ainda houver dígitos após o ponto decimal, movemos um dígito para a frente e removemos um dos pontos e vírgulas. Isso ocorre porque mover o ponto decimal para a direita multiplica a entrada por 10 e, portanto, divide o resultado por 10 . Devido às restrições de entrada, sabemos que isso acontecerá no máximo quatro vezes; portanto, sempre há ponto e vírgula suficiente para ser removido.

\d+
$*1,10000000$*

Agora que a entrada é um número inteiro, a convertemos para unária e anexamos 10 ⁷ 1 s (separados por a ,).

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

Dividimos o número inteiro em 10 ⁷ , contando quantas referências anteriores se encaixam ( $#2). Esta é a divisão inteira unária padrão a,b-> b/a. Agora só precisamos corrigir a posição do ponto decimal.

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

Isso é basicamente o inverso do segundo estágio. Se ainda tivermos mais de um ponto e vírgula, isso significa que ainda precisamos dividir o resultado por 10 . Fazemos isso movendo os pontos e vírgulas uma posição para a esquerda e soltando um ponto e vírgula até atingirmos a extremidade esquerda do número ou ficamos com apenas um ponto e vírgula (que é o próprio ponto decimal).

1`;
.

Agora é uma boa hora para transformar o primeiro (e possivelmente apenas) de ;volta ..

;
0

Se ainda houver ponto-e-vírgula, chegamos ao final esquerdo do número, portanto, dividir por 10 novamente inserirá zeros atrás do ponto decimal. Isso é feito facilmente, substituindo cada ;um por um 0, já que eles estão imediatamente após o ponto decimal.

sim , 5 bytes

|0~-e

Experimente online! Isso pega a entrada da parte superior da pilha e deixa a saída na parte superior da pilha. O link TIO recebe entrada de argumentos da linha de comando, que é capaz apenas de receber entrada inteira.

Explicação

O yup possui apenas alguns operadores. Os usados ​​nesta resposta são ln (x) (representado por |), 0 () (constante, função nilar retornando 0), - (subtração) e exp (x) (representado por e). ~alterna os dois principais membros da pilha.

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

Isso usa a identidade

o 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 salvos graças a @devRicher!

Isso define uma função 'r', que pode ser chamada com:

r 5.0

ou qualquer outro NUMBAR.

Experimente online!

sed , 575 + 1 ( -rsinalizador) = 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/

Experimente online!

Nota: as flutuações para as quais o valor absoluto é menor que 1 terão que ser escritas sem um 0 inicial como em .5vez de 0.5. Além disso, o número de casas decimais é igual a , onde né o número de casas decimais no número (assim, fornecer 13.0como entrada fornecerá mais casas decimais do que fornecer 13como entrada)

Esta é a minha primeira submissão sed no PPCG. Idéias para a conversão decimal em unário foram extraídas dessa resposta surpreendente . Obrigado a @seshoumara por me guiar pelo sed!

Esse código executa divisão longa repetida para obter o resultado. A divisão leva apenas ~ 150 bytes. As conversões decimais unárias ocupam o máximo de bytes, e alguns outros bytes vão para números negativos e entradas de ponto flutuante

Explicação

Explicação sobre o 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/

Edições

• s:s/(.)/(.)/g:y/\1/\2/g:g economizar 1 byte em cada substituição (5 no total)
• Economizou uma tonelada de bytes observando um bom conversor de decimal para unário em "Dicas para jogar golfe no sed"
• Eu mudei em torno de algumas substituições girando em torno de cuidar do sinal de menos para salvar 6 bytes.
• Utilizado em \nvez de ;separador, pude reduzir as substituições "multiplicar por 10" para economizar 12 bytes (obrigado a @Riley e @seshoumara por me mostrarem isso)

JSFuck , 3320 bytes

O JSFuck é um estilo de programação esotérico e educacional baseado nas partes atômicas do JavaScript. Ele usa apenas seis caracteres diferentes ()[]+!para escrever e executar código.

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

Experimente online!

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

OIL , 1428 1420 bytes

Ah bem. Eu pensei que poderia muito bem experimentá-lo e, no final, consegui. Há apenas uma desvantagem: leva quase tanto tempo para ser executado quanto para escrever.

O programa é separado em vários arquivos, que possuem todos os nomes de arquivos de 1 byte (e contam para um byte adicional no meu cálculo de bytes). Alguns dos arquivos fazem parte dos arquivos de exemplo do idioma do OIL, mas não existe uma maneira real de chamá-los consistentemente (ainda não há caminho de pesquisa ou algo parecido no OIL, por isso não os considero uma biblioteca padrão), mas isso também significa que (no momento da postagem) alguns dos arquivos são mais detalhados que necessários, mas geralmente apenas com alguns bytes.

Os cálculos são precisos com 4 dígitos de precisão, mas o cálculo mesmo de um simples recíproco (como a entrada 3) leva um tempo muito longo (mais de 5 minutos) para ser concluído. Para fins de teste, também criei uma variante menor com precisão de 2 dígitos, que leva apenas alguns segundos para ser executada, a fim de provar que funciona.

Sinto muito pela enorme resposta, gostaria de poder usar algum tipo de tag de spoiler. Eu também poderia colocar a maior parte no gist.github.com ou algo semelhante, se desejado.

Aqui vamos nós:, main217 bytes (o nome do arquivo não conta 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 (verifica se uma determinada sequência está em outra), 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 (junta duas cadeias de caracteres), 20 + 1 = 21 bytes:

5
0
5
1
13
0
2
0
4
0

c (dado um símbolo, divide a sequência especificada na sua primeira ocorrência), 143 + 1 = 144 bytes (este ainda é obviamente ainda jogável):

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 uma sequência, obtém os 4 primeiros caracteres), 22 + 1 = 23 bytes:

5
0
12
0
20
13
21
4

4

e (divisão de alto nível (mas com perigo de divisão zero)), 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 (move um ponto 4 posições para a direita; "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 (verifica se uma sequência começa com um determinado caractere), 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 (retorna tudo, exceto o primeiro caractere de uma determinada sequência), 41 + 1 = 42 bytes:

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

0
4
0

i (subtrai dois números), 34 + 1 = 35 bytes:

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

j (divisão de baixo nível que não funciona em todos os 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 (multiplicação), 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 (retornar valor absoluto), 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 (adição), 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

%

%é uma função que fornece o recíproco de sua entrada. Você pode executá-lo assim

   % 2
0.5

Táxi , 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.

Experimente online!

Ungolfed:

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 / pressionamentos de tecla

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

Como o V é compatível com versões anteriores, você pode experimentá-lo online!

x86_64 linguagem de máquina Linux, 5 bytes

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

Para testar isso, você pode compilar e executar o seguinte 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) );
  }
}

Experimente online!

C, 15 12 bytes

#define f 1/

Experimente online!

16 13 bytes, se precisar manipular a entrada inteira também:

#define f 1./

Então você pode chamá-lo com em f(3)vez de f(3.0).

Experimente online!

Graças a @hvd por jogar 3 bytes!

MATLAB / oitava, 4 bytes

@inv

Cria um identificador de função (nomeado ans) para a invfunção interna

Demo Online

05AB1E , 1 byte

z

Experimente online!

z # pop a  push 1 / a

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

Aviso: o programa consumirá toda a memória do sistema tentando executar e precisará de mais tempo para terminar do que você gostaria de esperar! Veja abaixo uma explicação e uma versão rápida, mas 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:

Isso se baseia na resposta da Retina de Martin Ender. Eu conto \tda linha 2 como uma guia literal (1 byte).

Minha principal contribuição é o método de conversão de decimal para unário simples (linha 2) e vice-versa (linha 5). Consegui reduzir significativamente o tamanho do código necessário para fazer isso (em ~ 40 bytes combinados), em comparação com os métodos mostrados na dica anterior . Criei uma resposta de dica separada com os detalhes, onde forneço snippets prontos para usar. Como 0 não é permitido como entrada, mais alguns bytes foram salvos.

Explicação: para entender melhor o algoritmo de divisão, leia a resposta Retina primeiro

O programa está teoricamente correto, a razão pela qual consome tantos recursos computacionais é que a etapa de divisão é executada centenas de milhares de vezes, mais ou menos dependendo da entrada, e o regex usado gera um pesadelo de retorno. A versão rápida reduz a precisão (daí o número de etapas de divisão) e altera o regex para reduzir o retorno.

Infelizmente, o sed não possui um método para contar diretamente quantas vezes uma referência traseira se encaixa em um padrão, como na 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 uma versão rápida e segura do programa, mas menos precisa, você pode tentar isso online .

Japonês , 2 bytes

A solução óbvia seria

1/U

o que é, literalmente 1 / input,. No entanto, podemos fazer um melhor:

pJ

Isso é equivalente a input ** Je Jé definido como -1 por padrão.

Experimente online!

Curiosidade: assim como pa função power, qa função root ( p2= **2, q2= **(1/2)); isso significa que qJtambém funcionará, desde -1 == 1/-1e, portanto x**(-1) == x**(1/-1),.

Javascript ES6, 6 bytes

x=>1/x

Experimente online!

O Javascript é padronizado como divisão de ponto flutuante.

APL, 1 byte

÷

÷Calcula recíproco quando usado como função monádica. Experimente online!

Usa o conjunto de caracteres Dyalog Classic.

Queijo Cheddar , 5 bytes

1&(/)

Experimente online!

Isso usa &, que vincula um argumento a uma função. Nesse caso, 1está vinculado ao lado esquerdo de /, o que nos dá 1/x, para uma discussão x. Isso é menor que o canônico x->1/xem 1 byte.

Como alternativa, nas versões mais recentes:

(1:/)

Java 8, 6 bytes

x->1/x

Quase o mesmo que a resposta JavaScript .

MATL , 3 bytes

l_^

Experimente no MATL Online

Explicação

    % 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

Um para 13 bytes:

(-1).__rpow__

Um por 14 bytes:

1 .__truediv__

Mathematica, 4 bytes

1/#&

Fornece um racional exato se você der um racional exato e um resultado de ponto flutuante se você der um resultado de ponto flutuante.

ZX Spectrum BASIC, 13 bytes

1 INPUT A: PRINT SGN PI/A

Notas:

• Cada linha custa 2 bytes para o número da linha, 2 bytes para o comprimento da linha e 1 byte para a nova linha
• Literais numéricos são convertidos em binários no momento da análise, custando 6 bytes extras, portanto, o uso de em SGN PIvez de literal 1.
• As palavras-chave recebem 1 byte cada.

Versão ZX81 para 17 bytes:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 bytes

(1/)

Experimente online!

R, 8 bytes

1/scan()

Bem direto. Emite diretamente o inverso da entrada.

Outra solução, porém com 1 byte de comprimento, pode ser: scan()^-1ou até mesmo scan()**-1para um byte adicional. Ambos ^e **o símbolo do poder.

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

Ans⁻¹

-1 byte graças à Timtech .

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

Anse ⁻¹são tokens de um byte .

TI-Basic retorna implicitamente o último valor avaliado ( Ans⁻¹).

Geléia , 1 byte

İ

Experimente online!

C, 30 bytes

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