Défi

Étant donné un nombre (virgule flottante / décimale), retournez sa réciproque, c'est-à-dire 1 divisé par le nombre. La sortie doit être un nombre à virgule flottante / décimal, pas seulement un entier.

Spécifications détaillées

• Vous devez recevoir une entrée sous la forme d'un nombre à virgule flottante / décimal ...
  • ... qui a au moins 4 chiffres significatifs de précision (si nécessaire).
  • Plus c'est mieux, mais ne compte pas dans le score.
• Vous devez produire, avec toute méthode de sortie acceptable ...
  • ... l'inverse du nombre.
  • Cela peut être défini comme 1 / x, x⁻¹.
  • Vous devez générer au moins 4 chiffres significatifs de précision (si nécessaire).

L'entrée sera positive ou négative, avec une valeur absolue dans la plage [0,0001, 9999] inclus. Vous ne recevrez jamais plus de 4 chiffres après le point décimal, ni plus de 4 à partir du premier chiffre non nul. La sortie doit être précise jusqu'au 4e chiffre du premier non nul.

(Merci @MartinEnder)

Voici quelques exemples d'entrées:

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

Notez que vous ne recevrez jamais d'entrées ayant plus de 4 chiffres de précision.

Voici un exemple de fonction dans Ruby:

def reciprocal(i)
    return 1.0 / i
end

Règles

• Toutes les formes de sortie acceptées sont autorisées
• Échappatoires standard interdites
• Il s'agit de code-golf , la réponse la plus courte en octets gagne, mais ne sera pas sélectionnée.

Clarifications

• Vous ne recevrez jamais l'entrée 0.

Bounties

Ce défi est évidemment trivial dans la plupart des langues, mais il peut offrir un défi amusant dans des langues plus ésotériques et inhabituelles, donc certains utilisateurs sont prêts à attribuer des points pour avoir fait cela dans des langues inhabituellement difficiles.

• @DJMcMayhem accordera une prime de +150 points à la réponse de brain-flak la plus courte, car brain-flak est notoirement difficile pour les nombres à virgule flottante

• @ L3viathan accordera une prime de +150 points à la réponse OIL la plus courte . L'HUILE n'a pas de type natif à virgule flottante, ni de division.

• @Riley attribuera une prime de +100 points à la réponse sed la plus courte.

• @EriktheOutgolfer attribuera une prime de +100 points à la réponse Sesos la plus courte. La division dans les dérivés de brainfuck tels que Sesos est très difficile, encore moins la division en virgule flottante.

• I ( @Mendeleev ) accordera une prime de +100 points à la réponse Retina la plus courte.

S'il y a une langue dans laquelle vous pensez qu'il serait amusant de voir une réponse et que vous êtes prêt à payer le représentant, n'hésitez pas à ajouter votre nom dans cette liste (trié par montant de prime)

Classement

Voici un extrait de pile pour générer un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](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 octets

Étant donné que Brain-Flak ne prend pas en charge les nombres à virgule flottante, j'ai dû utiliser l' -cindicateur dans l'ordre d'entrée et de sortie avec des chaînes, d'où le +1.

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

Essayez-le en ligne!

Explication

La première chose dont nous devons nous occuper est le cas négatif. Étant donné que l'inverse d'un nombre négatif est toujours négatif, nous pouvons simplement conserver le signe négatif jusqu'à la fin. Nous commençons par faire une copie du haut de la pile et en soustrayant 45 (la valeur ASCII de -) de celle-ci. Si c'est un, nous mettons un zéro en haut de la pile, sinon nous ne faisons rien. Ensuite, nous ramassons le haut de la pile à déposer à la fin du programme. Si l'entrée a commencé par un -c'est toujours un -cependant si ce n'est pas nous finissons par ramasser ce zéro que nous avons placé.

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

Maintenant que c'est hors de propos, nous devons convertir les réalisations ASCII de chaque chiffre en valeurs réelles (0-9). Nous allons également supprimer le point décimal .pour faciliter les calculs. Étant donné que nous devons savoir où le point décimal a commencé lorsque nous le réinsérons plus tard, nous stockons un nombre pour garder une trace du nombre de chiffres qui se trouvaient devant le .sur la pile.

Voici comment le code fait cela:

Nous commençons par soustraire 46 (la valeur ASCII de .) de chaque élément de la pile (en les déplaçant simultanément sur le hors-pile). Cela fera de chaque chiffre deux de plus que ce qui devrait être, mais fera .exactement zéro.

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

Maintenant, nous déplaçons tout sur la pile de gauche jusqu'à ce que nous atteignions un zéro (en soustrayant deux de chaque chiffre pendant que nous allons):

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

Nous enregistrons la hauteur de la pile

([]<

Déplacez tout le reste sur la pile de gauche (en soustrayant à nouveau les deux derniers de chaque chiffre lorsque nous les déplaçons)

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

Et mettez la hauteur de pile que nous avons enregistrée

>)

Maintenant, nous voulons combiner les chiffres en un seul numéro de base 10. Nous voulons également faire une puissance de 10 avec deux fois les chiffres que ce nombre à utiliser dans le calcul.

Nous commençons par mettre en place un 1 sur le dessus de la pile pour faire la puissance de 10 et en poussant la hauteur de pile moins un sur la pile pour l'utilisation de la boucle.

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

Maintenant, nous bouclons la hauteur de la pile moins 1 fois,

{
 ({}[()]<

Chaque fois que nous multiplions l'élément supérieur par 100 et en dessous il multiplie l'élément suivant par 10 et l'ajoutons au nombre ci-dessous.

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

Nous terminons notre boucle

 >)
}{}

Maintenant, nous avons enfin terminé la configuration et pouvons commencer le calcul réel.

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

C'était ça...

Nous divisons la puissance de 10 par la version modifiée de l'entrée en utilisant l' algorithme de division entière de 0 tel que trouvé sur le wiki . Cela simule la division de 1 par l'entrée de la seule façon dont Brain-Flak sait comment.

Enfin, nous devons formater notre sortie en ASCII approprié.

Maintenant que nous avons constaté que nenous devons supprimer le e. La première étape consiste à le convertir en une liste de chiffres. Ce code est une version modifiée de 0 ' l » algorithme de divmod .

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

Maintenant, nous prenons le nombre et ajoutons le point décimal à sa place. Le simple fait de penser à cette partie du code ramène des maux de tête, donc pour l'instant je vais le laisser comme un exercice au lecteur pour comprendre comment et pourquoi cela fonctionne.

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

Mettez le signe négatif ou un caractère nul s'il n'y a pas de signe négatif.

>)

Python 2 , 10 octets

1..__div__

Essayez-le en ligne!

Rétine , 99 91 octets

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

Essayez-le en ligne!

Woohoo, moins de 100! Ceci est étonnamment efficace, étant donné qu'il crée (et correspond ensuite à) une chaîne avec plus de 10 ⁷ caractères à un moment donné. Je suis sûr que ce n'est pas encore optimal, mais je suis assez satisfait du score pour le moment.

Les résultats avec une valeur absolue inférieure à 1 seront imprimés sans le zéro de tête, par exemple .123ou-.456 .

Explication

L'idée de base est d'utiliser la division entière (car c'est assez facile avec l'expression régulière et l'arithmétique unaire). Pour garantir que nous obtenons un nombre suffisant de chiffres significatifs, nous divisons l'entrée en 10 ⁷ . De cette façon, toute entrée jusqu'à 9999 donne toujours un nombre à 4 chiffres. En effet, cela signifie que nous multiplions le résultat par 10 ⁷ , nous devons donc garder une trace de cela lors de la réinsertion ultérieure du séparateur décimal.

1`\.|$
8$*;

Nous commençons par remplacer le point décimal, ou la fin de la chaîne s'il n'y a pas de point décimal avec 8 points-virgules. Le premier d'entre eux est essentiellement le point décimal lui-même (mais j'utilise des points-virgules car ils n'ont pas besoin d'être échappés), les 7 autres indiquent que la valeur a été multipliée par 10 ⁷ (ce n'est pas encore le cas, mais nous savons que nous le ferons plus tard).

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

Nous transformons d'abord l'entrée en un entier. Tant qu'il reste des chiffres après le point décimal, nous déplaçons un chiffre vers l'avant et supprimons l'un des points-virgules. En effet, déplacer le séparateur décimal vers la droite multiplie l'entrée par 10 et divise donc le résultat par 10 . En raison des restrictions d'entrée, nous savons que cela se produira au maximum quatre fois, il y a donc toujours suffisamment de points-virgules à supprimer.

\d+
$*1,10000000$*

Maintenant que l'entrée est un entier, nous le convertissons en unaire et ajoutons 10 ⁷ 1 s (séparés par un ,).

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

Nous divisons l'entier en 10 ⁷ en comptant le nombre de références qui lui correspondent ( $#2). Ceci est la division unaire standard standard a,b-> b/a. Il ne nous reste plus qu'à corriger la position du point décimal.

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

Il s'agit essentiellement de l'inverse de la deuxième étape. Si nous avons encore plus d'un point-virgule, cela signifie que nous devons encore diviser le résultat par 10 . Nous faisons cela en déplaçant les points-virgules d'une position vers la gauche et en déposant un point-virgule jusqu'à ce que nous atteignions l'extrémité gauche du nombre, ou que nous nous retrouvions avec un seul point-virgule (qui est le point décimal lui-même).

1`;
.

Il est maintenant un bon moment pour tourner la première (et peut - être seulement) de ;nouveau dans ..

;
0

S'il reste des points-virgules, nous avons atteint l'extrémité gauche du nombre, donc une nouvelle division par 10 insérera des zéros derrière la virgule décimale. Cela se fait facilement en remplaçant chaque reste ;par un 0, car ils sont de toute façon immédiatement après le point décimal.

oui , 5 octets

|0~-e

Essayez-le en ligne! Cela prend l'entrée du haut de la pile et laisse la sortie en haut de la pile. Le lien TIO prend l'entrée des arguments de la ligne de commande, qui est uniquement capable de prendre une entrée entière.

Explication

yup n'a que quelques opérateurs. Ceux utilisés dans cette réponse sont ln (x) (représenté par |), 0 () (constant, fonction nilaire renvoyant 0), - (soustraction) et exp (x) (représenté par e). ~bascule les deux premiers membres de la pile.

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

Cela utilise l'identité

ce qui implique que

LOLCODE , 63 , 56 octets

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

7 octets enregistrés grâce à @devRicher!

Ceci définit une fonction «r», qui peut être appelée avec:

r 5.0

ou tout autre NUMBAR.

Essayez-le en ligne!

sed , 575 + 1 ( -rflag) = 723 718 594 588 576 octets

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/

Essayez-le en ligne!

Remarque: les flottants pour lesquels la valeur absolue est inférieure à 1 devront être écrits sans 0 de tête comme .5au lieu de 0.5. De plus, le nombre de décimales est égal à , où nest le nombre de décimales dans le nombre (donc donner 13.0en entrée donnera plus de décimales que donner 13en entrée)

Ceci est ma première soumission sed sur PPCG. Des idées pour la conversion décimale-unaire ont été tirées de cette réponse étonnante . Merci à @seshoumara de m'avoir guidé à travers sed!

Ce code effectue une longue division répétée pour obtenir le résultat. La division ne prend que ~ 150 octets. Les conversions décimales unaires prennent le plus d'octets, et quelques autres octets servent à prendre en charge les nombres négatifs et les entrées à virgule flottante

Explication

Explication sur 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/

Modifications

• s:s/(.)/(.)/g:y/\1/\2/g:g pour économiser 1 octet à chaque substitution (5 au total)
• Économisez une tonne d'octets en regardant un joli convertisseur décimal-unaire sur "Conseils pour jouer au golf à sed"
• J'ai changé autour de certaines substitutions tournées autour de la prise en charge du signe moins pour économiser 6 octets.
• Utilisé \nau lieu de ;comme séparateur, j'ai pu raccourcir les substitutions "multiplier par 10" pour économiser 12 octets (merci à @Riley et @seshoumara de me l'avoir montré)

JSFuck , 3320 octets

JSFuck est un style de programmation ésotérique et éducatif basé sur les parties atomiques de JavaScript. Il utilise seulement six caractères différents ()[]+!pour écrire et exécuter du code.

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

Essayez-le en ligne!

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

HUILE , 1428 1420 octets

Tant pis. J'ai pensé que je pourrais aussi bien l'essayer, et j'ai finalement réussi. Il n'y a qu'un seul inconvénient: il faut presque autant de temps pour exécuter que pour écrire.

Le programme est séparé en plusieurs fichiers, qui ont tous les noms de fichiers à 1 octet (et comptent pour un octet supplémentaire dans mon calcul d'octets). Certains fichiers font partie des fichiers d'exemple du langage OIL, mais il n'y a pas vraiment de moyen de les appeler de manière cohérente (il n'y a pas encore de chemin de recherche ou quelque chose comme ça dans OIL, donc je ne les considère pas comme une bibliothèque standard), mais cela signifie également que (au moment de la publication) certains fichiers sont plus verbeux que nécessaire, mais généralement de quelques octets seulement.

Les calculs sont précis à 4 chiffres de précision, mais le calcul d'une simple réciproque (comme l'entrée 3) prend beaucoup de temps (plus de 5 minutes). À des fins de test, j'ai également fait une variante mineure précise à 2 chiffres, qui ne prend que quelques secondes à exécuter, afin de prouver que cela fonctionne.

Je suis désolé pour l'énorme réponse, j'aimerais pouvoir utiliser une sorte de balise de spoiler. Je pourrais également en mettre la majeure partie sur gist.github.com ou quelque chose de similaire, si vous le souhaitez.

C'est mainparti:, 217 octets (le nom de fichier ne compte pas pour les octets):

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 (vérifie si une chaîne donnée est dans une autre chaîne donnée), 74 + 1 = 75 octets:

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 (joint deux chaînes données), 20 + 1 = 21 octets:

5
0
5
1
13
0
2
0
4
0

c (étant donné un symbole, divise la chaîne donnée lors de sa première occurrence), 143 + 1 = 144 octets (celui-ci est évidemment toujours jouable au golf):

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 (étant donné une chaîne, obtient les 4 premiers caractères), 22 + 1 = 23 octets:

5
0
12
0
20
13
21
4

4

e (division de haut niveau (mais avec un danger de division zéro)), 138 + 1 = 139 octets:

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 (déplace un point de 4 positions vers la droite; "divise" par 10000), 146 + 1 = 147 octets:

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 (vérifie si une chaîne commence par un caractère donné), 113 + 1 = 114 octets:

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 (retourne tout sauf le premier caractère d'une chaîne donnée), 41 + 1 = 42 octets:

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

0
4
0

i (soustrait deux nombres), 34 + 1 = 35 octets:

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

j (division de bas niveau qui ne fonctionne pas dans tous les cas), 134 + 1 = 135 octets:

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 (multiplication), 158 + 1 = 159 octets:

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 (retourne la valeur absolue), 58 + 1 = 59 octets:

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

0
6
10

m (ajout), 109 + 1 = 110 octets:

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 octet

%

%est une fonction donnant l'inverse de son entrée. Vous pouvez l'exécuter comme ceci

   % 2
0.5

Taxi , 467 octets

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.

Essayez-le en ligne!

Non 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 octets / touches

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

Puisque V est rétrocompatible, vous pouvez L' essayer en ligne!

Langage machine Linux x86_64, 5 octets

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

Pour tester cela, vous pouvez compiler et exécuter le programme C suivant

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

Essayez-le en ligne!

C, 15 12 octets

#define f 1/

Essayez-le en ligne!

16 13 octets, s'il a besoin de gérer également les entrées entières:

#define f 1./

Vous pouvez donc l'appeler avec f(3)au lieu de f(3.0).

Essayez-le en ligne!

Merci à @hvd pour avoir joué au golf 3 octets!

MATLAB / Octave, 4 octets

@inv

Crée un descripteur de fonction (nommé ans) pour la invfonction intégrée

Démo en ligne

05AB1E , 1 octet

z

Essayez-le en ligne!

z # pop a  push 1 / a

GNU sed , 377362 + 1 (drapeau r) = 363 octets

Attention: le programme va consommer toute la mémoire système essayant de s'exécuter et nécessitera plus de temps pour terminer que vous ne seriez prêt à attendre! Voir ci-dessous pour une explication et une version rapide, mais moins précise.

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:

Ceci est basé sur la réponse Retina de Martin Ender. Je compte à \tpartir de la ligne 2 comme un onglet littéral (1 octet).

Ma principale contribution est à la méthode de conversion de décimal en unaire simple (ligne 2), et vice versa (ligne 5). J'ai réussi à réduire considérablement la taille du code nécessaire pour ce faire (de ~ 40 octets combinés), par rapport aux méthodes indiquées dans un conseil précédent . J'ai créé une astuce distincte avec les détails, où je fournis des extraits prêts à l'emploi. Étant donné que 0 n'est pas autorisé en entrée, quelques octets supplémentaires ont été enregistrés.

Explication: pour mieux comprendre l'algorithme de division, lisez d'abord la réponse Retina

Le programme est théoriquement correct, la raison pour laquelle il consomme autant de ressources de calcul est que l'étape de division est exécutée des centaines de milliers de fois, plus ou moins en fonction de l'entrée, et le regex utilisé donne lieu à un cauchemar de retour en arrière. La version rapide réduit la précision (d'où le nombre d'étapes de division) et modifie l'expression régulière pour réduire le retour en arrière.

Malheureusement, sed n'a pas de méthode pour compter directement combien de fois une rétro-référence s'intègre dans un modèle, comme dans la rétine.

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

Pour une version rapide et sûre du programme, mais moins précise, vous pouvez l' essayer en ligne .

Japt , 2 octets

La solution évidente serait

1/U

qui est, littéralement, 1 / input. Cependant, nous pouvons faire mieux:

pJ

Ceci est équivalent à input ** Jet Jest défini sur -1 par défaut.

Essayez-le en ligne!

Fait amusant: tout comme pla fonction de puissance, qla fonction racine l'est aussi ( p2= **2, q2= **(1/2)); cela signifie que qJcela fonctionnera aussi, depuis -1 == 1/-1, et donc x**(-1) == x**(1/-1).

Javascript ES6, 6 octets

x=>1/x

Essayez-le en ligne!

Javascript par défaut est une division en virgule flottante.

APL, 1 octet

÷

÷ Calcule réciproque lorsqu'il est utilisé comme fonction monadique. Essayez-le en ligne!

Utilise le jeu de caractères Dyalog Classic.

Cheddar , 5 octets

1&(/)

Essayez-le en ligne!

Ceci utilise &, qui lie un argument à une fonction. Dans ce cas, 1est lié au côté gauche de /, ce qui nous donne 1/x, pour un argument x. C'est plus court que le canonique x->1/xd'un octet.

Alternativement, dans les versions les plus récentes:

(1:/)

Java 8, 6 octets

x->1/x

Presque la même que la réponse JavaScript .

MATL , 3 octets

l_^

Essayez-le sur MATL Online

Explication

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

Python, 12 octets

lambda x:1/x

Un pour 13 octets:

(-1).__rpow__

Un pour 14 octets:

1 .__truediv__

Mathematica, 4 octets

1/#&

Vous fournit un rationnel exact si vous lui donnez un rationnel exact et un résultat en virgule flottante si vous lui donnez un résultat en virgule flottante.

ZX Spectrum BASIC, 13 octets

1 INPUT A: PRINT SGN PI/A

Remarques:

• Chaque ligne coûte 2 octets pour le numéro de ligne, 2 octets pour la longueur de la ligne et 1 octet pour la nouvelle ligne
• Les littéraux numériques sont convertis en binaire au moment de l'analyse, ce qui coûte 6 octets supplémentaires, d'où l'utilisation de SGN PIau lieu de littéral 1.
• Les mots-clés prennent 1 octet chacun.

Version ZX81 pour 17 octets:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 octets

(1/)

Essayez-le en ligne!

R, 8 octets

1/scan()

Assez simple. Émet directement l'inverse de l'entrée.

Une autre solution, mais d'un octet plus long, peut être:, scan()^-1ou même scan()**-1pour un octet supplémentaire. Les deux ^et **le symbole de puissance.

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

Ans⁻¹

-1 octet grâce à Timtech .

-3 octets avec Ansremerciements à Григорий Перельман .

Anset ⁻¹sont des jetons d'un octet .

TI-Basic renvoie implicitement la dernière valeur évaluée ( Ans⁻¹).

Gelée , 1 octet

İ

Essayez-le en ligne!

C, 30 octets

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