Sfida

Dato un numero (in virgola mobile / decimale), restituisce il suo reciproco, ovvero 1 diviso per il numero. L'output deve essere un numero in virgola mobile / decimale, non solo un numero intero.

Specifica dettagliata

• È necessario ricevere input sotto forma di un numero in virgola mobile / decimale ...
  • ... che ha almeno 4 cifre significative di precisione (se necessario).
  • Più è meglio, ma non conta nel punteggio.
• È necessario eseguire l'output, con qualsiasi metodo di output accettabile ...
  • ... il reciproco del numero.
  • Questo può essere definito come 1 / x, x⁻¹.
  • È necessario produrre almeno 4 cifre significative di precisione (se necessario).

L'input sarà positivo o negativo, con valore assoluto compreso nell'intervallo [0.0001, 9999] incluso. Non ti verranno mai date più di 4 cifre oltre il punto decimale, né più di 4 a partire dalla prima cifra diversa da zero. L'output deve essere accurato fino alla quarta cifra dalla prima diversa da zero.

(Grazie @MartinEnder)

Ecco alcuni input di esempio:

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

Nota che non ti verranno mai dati input con precisione superiore a 4 cifre.

Ecco una funzione di esempio in Ruby:

def reciprocal(i)
    return 1.0 / i
end

Regole

• Sono consentite tutte le forme di output accettate
• Scappatoie standard vietate
• Questo è code-golf , vince la risposta più breve in byte, ma non verrà selezionata.

chiarimenti

• Non riceverai mai l'input 0.

bounties

Questa sfida è ovviamente banale nella maggior parte delle lingue, ma può offrire una sfida divertente in lingue più esoteriche e insolite, quindi alcuni utenti sono disposti a assegnare punti per farlo in lingue insolitamente difficili.

• @DJMcMayhem assegnerà un premio di +150 punti alla risposta più breve di scaglie di cervello, dal momento che la scoria di cervello è notoriamente difficile per i numeri in virgola mobile

• @ L3viathan assegnerà un premio di +150 punti alla risposta OLIO più breve . OIL non ha un tipo nativo in virgola mobile, né ha divisione.

• @Riley assegnerà un premio di +100 punti alla risposta sed più breve.

• @EriktheOutgolfer assegnerà un premio di +100 punti alla risposta Sesos più breve. La divisione in derivati ​​del brainfuck come Sesos è molto difficile, per non parlare della divisione in virgola mobile.

• Io ( @Mendeleev ) assegnerò una taglia di +100 punti alla risposta Retina più breve.

Se c'è una lingua in cui pensi che sarebbe divertente vedere una risposta e sei disposto a pagare il rappresentante, sentiti libero di aggiungere il tuo nome in questo elenco (ordinato in base all'importo della taglia)

Classifica

Ecco uno snippet di stack per generare una panoramica dei vincitori in base alla lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Dal momento che Brain-Flak non supporta i numeri in virgola mobile, ho dovuto usare il -cflag per inserire input e output con stringhe, quindi +1.

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

Provalo online!

Spiegazione

La prima cosa di cui dobbiamo occuparci è il caso negativo. Poiché il reciproco di un numero negativo è sempre negativo, possiamo semplicemente aggrapparci al segno negativo fino alla fine. Iniziamo facendo una copia della parte superiore dello stack e sottraendo 45 (il valore ASCII di -) da esso. Se questo è uno mettiamo uno zero in cima allo stack, altrimenti non facciamo nulla. Quindi prendiamo la parte superiore dello stack da mettere alla fine del programma. Se l'input iniziato con a -questo è comunque un -caso contrario, finiamo per raccogliere lo zero che abbiamo inserito.

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

Ora che è fuori mano, dobbiamo convertire le realizzazioni ASCII di ogni cifra in valori reali lì (0-9). Rimuoveremo anche il punto decimale .per semplificare i calcoli. Dato che dobbiamo sapere dove è iniziato il punto decimale quando lo reinseriamo in seguito, memorizziamo un numero per tenere traccia di quante cifre erano davanti al. al punto di partenza.

Ecco come funziona il codice:

Iniziamo sottraendo 46 (il valore ASCII di .) da ciascun elemento dello stack (spostandoli simultaneamente tutti sullo offstack). Questo renderà ogni cifra due in più di quanto dovrebbe essere ma farà .esattamente lo zero.

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

Ora spostiamo tutto nello stack di sinistra fino a quando non colpiamo uno zero (sottraendo due da ogni cifra mentre andiamo):

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

Registriamo l'altezza dello stack

([]<

Sposta tutto il resto nella pila a sinistra (sottraendo ancora una volta gli ultimi due da ogni cifra mentre li spostiamo)

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

E metti giù l'altezza dello stack che abbiamo registrato

>)

Ora vogliamo combinare le cifre in un unico numero di base 10. Vogliamo anche fare una potenza di 10 con il doppio delle cifre di quel numero da usare nel calcolo.

Iniziamo impostando un 1 in cima allo stack per aumentare la potenza di 10 e spingendo l'altezza dello stack meno di uno nello stack per l'uso del loop.

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

Ora eseguiamo il loop dell'altezza dello stack meno 1 volte,

{
 ({}[()]<

Ogni volta che moltiplichiamo l'elemento superiore per 100 e sotto di esso moltipliciamo l'elemento successivo per 10 e lo aggiungiamo al numero seguente.

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

Terminiamo il nostro ciclo

 >)
}{}

Ora abbiamo finalmente finito con l'installazione e possiamo iniziare il calcolo effettivo.

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

Era quello ...

Dividiamo la potenza di 10 per la versione modificata dell'input usando l' algoritmo di divisione di 0 ' ' come si trova sul wiki . Questo simula la divisione di 1 per input nell'unico modo in cui Brain-Flak sa come.

Infine, dobbiamo formattare il nostro output in ASCII appropriato.

Ora che abbiamo scoperto neche dobbiamo eliminare il e. Il primo passo per farlo è convertirlo in un elenco di cifre. Questo codice è una versione modificata dell'algoritmo divmod di 0 ' ' .

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

Ora prendiamo il numero e aggiungiamo il punto decimale al suo posto. Il solo fatto di pensare a questa parte del codice fa tornare il mal di testa, quindi per ora lo lascerò come esercizio per il lettore per capire come e perché funziona.

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

Metti il ​​segno negativo in basso o un carattere nullo se non c'è segno negativo.

>)

Python 2 , 10 byte

1..__div__

Provalo online!

Retina , 99 91 byte

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

Provalo online!

Woohoo, sotto-100! Ciò è sorprendentemente efficiente, considerando che crea (e quindi combacia) una stringa con più di 10 ⁷ caratteri in un punto. Sono sicuro che non sia ancora ottimale, ma al momento sono abbastanza soddisfatto del punteggio.

I risultati con valore assoluto inferiore a 1 verranno stampati senza lo zero iniziale, ad es. .123O-.456 .

Spiegazione

L'idea di base è quella di utilizzare la divisione intera (perché è abbastanza facile con regex e l'aritmetica unaria). Per essere sicuri di ottenere un numero sufficiente di cifre significative, dividiamo l'input in 10 ⁷ . In questo modo, qualsiasi input fino a 9999 risulta comunque in un numero di 4 cifre. In effetti, ciò significa che stiamo moltiplicando il risultato per 10 ^7, quindi dobbiamo tenerne traccia quando in seguito reinseriremo il punto decimale.

1`\.|$
8$*;

Iniziamo sostituendo il punto decimale o la fine della stringa se non c'è un punto decimale con 8 punti e virgola. Il primo è essenzialmente il punto decimale stesso (ma sto usando i punti e virgola perché non hanno bisogno di essere salvati), gli altri 7 indicano che il valore è stato moltiplicato per 10 ⁷ (questo non è ancora il caso, ma sappiamo che lo faremo più tardi).

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

Innanzitutto trasformiamo l'input in un numero intero. Finché ci sono ancora cifre dopo il punto decimale, spostiamo una cifra in primo piano e rimuoviamo uno dei punti e virgola. Questo perché spostando il punto decimale a destra moltiplica l'input per 10 e quindi divide il risultato per 10 . A causa delle restrizioni di input, sappiamo che ciò accadrà al massimo quattro volte, quindi ci sono sempre abbastanza punti e virgola da rimuovere.

\d+
$*1,10000000$*

Ora che l'input è un numero intero, lo convertiamo in unario e aggiungiamo 10 ⁷ 1 s (separati da a ,).

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

Dividiamo il numero intero in 10 ⁷ contando il numero di riferimenti all'adattamento ( $#2). Questa è la divisione intera unaria standard a,b-> b/a. Ora dobbiamo solo correggere la posizione del punto decimale.

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

Questo è sostanzialmente l'inverso del secondo stadio. Se abbiamo ancora più di un punto e virgola, ciò significa che dobbiamo ancora dividere il risultato per 10 . Facciamo questo spostando i punti e virgola di una posizione a sinistra e rilasciando un punto e virgola fino a raggiungere l'estremità sinistra del numero, oppure rimaniamo con un solo punto e virgola (che è il punto decimale stesso).

1`;
.

Ora è un buon momento per trasformare il primo (e forse solo) di ;nuovo in ..

;
0

Se rimangono ancora dei punti e virgola, abbiamo raggiunto l'estremità sinistra del numero, quindi la divisione per 10 inserirà nuovamente zeri dietro il punto decimale. Questo può essere fatto facilmente sostituendo ogni rimanente ;con un 0, poiché sono immediatamente dopo il punto decimale.

sì , 5 byte

|0~-e

Provalo online!Questo prende input dalla parte superiore della pila e lascia l'output nella parte superiore della pila. Il collegamento TIO accetta l'input dagli argomenti della riga di comando, che è in grado solo di accettare l'input intero.

Spiegazione

yup ha solo pochi operatori. Quelli usati in questa risposta sono ln (x) (rappresentato da |), 0 () (costante, ritorno della funzione nilare 0), - (sottrazione), ed exp (x) (rappresentato da e). ~cambia i primi due membri nello stack.

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

Questo utilizza l'identità

il che implica questo

LOLCODE , 63 , 56 byte

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

7 byte salvati grazie a @devRicher!

Questo definisce una funzione 'r', che può essere chiamata con:

r 5.0

o qualsiasi altro NUMBAR.

Provalo online!

sed , 575 + 1 ( -rbandiera) = 723 718 594 588 576 byte

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/

Provalo online!

Nota: i float per i quali il valore assoluto è inferiore a 1 dovranno essere scritti senza uno 0 iniziale come .5invece di 0.5. Anche il numero di posizioni decimali è uguale a , dove nè il numero di posizioni decimali nel numero (quindi dare 13.0come input darà più posizioni decimali che dare13 come input)

Questa è la mia prima presentazione di sed su PPCG. Le idee per la conversione da decimale a unario sono state prese da questa straordinaria risposta . Grazie a @seshoumara per avermi guidato attraverso sed!

Questo codice esegue ripetute divisioni lunghe per ottenere il risultato. La divisione richiede solo ~ 150 byte. Le conversioni unario-decimali occupano la maggior parte dei byte e pochi altri byte vanno a supportare numeri negativi e input a virgola mobile

Spiegazione

Spiegazione su 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/

Le modifiche

• s:s/(.)/(.)/g:y/\1/\2/g:g per salvare 1 byte ad ogni sostituzione (5 in totale)
• Ho salvato un sacco di byte guardando un bel convertitore da decimale a unario su "Suggerimenti per giocare a golf in sed"
• Ho cambiato alcune sostituzioni ruotando attorno a prendersi cura del segno meno per salvare 6 byte.
• Utilizzato \nanziché ;come separatore, sono stato in grado di accorciare le sostituzioni "moltiplicare per 10" per salvare 12 byte (grazie a @Riley e @seshoumara per avermelo mostrato)

JSFuck , 3320 byte

JSFuck è uno stile di programmazione esoterico ed educativo basato sulle parti atomiche di JavaScript. Utilizza solo sei caratteri diversi ()[]+!per scrivere ed eseguire il codice.

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

Provalo online!

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

OLIO , 1428 1420 byte

Oh bene. Ho pensato che avrei potuto provarlo, e alla fine ci sono riuscito. C'è solo un aspetto negativo: ci vuole quasi tanto tempo per correre quanto ci è voluto per scrivere.

Il programma è separato in più file, che hanno tutti i nomi di file a 1 byte (e contano per un byte aggiuntivo nel mio calcolo byte). Alcuni file fanno parte dei file di esempio del linguaggio OIL, ma non esiste un modo reale per chiamarli coerentemente (non esiste ancora un percorso di ricerca o qualcosa del genere in OIL, quindi non li considero una libreria standard), ma ciò significa anche che (al momento della pubblicazione) alcuni file sono più dettagliati di quelli necessari, ma di solito solo di pochi byte.

I calcoli sono precisi su 4 cifre di precisione, ma calcolano anche un semplice reciproco (come l'input 3 ) richiede molto tempo (oltre 5 minuti) per il completamento. A scopo di test, ho anche fatto una variante minore che è accurata a 2 cifre, che richiede solo pochi secondi per funzionare, per dimostrare che funziona.

Mi dispiace per l'enorme risposta, vorrei poter usare una sorta di tag spoiler. Potrei anche metterne la maggior parte su gist.github.com o qualcosa di simile, se lo si desidera.

Qui andiamo main:, 217 byte (il nome del file non conta per i byte):

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 (controlla se una determinata stringa si trova in un'altra data stringa), 74 + 1 = 75 byte:

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 (unisce due stringhe date), 20 + 1 = 21 byte:

5
0
5
1
13
0
2
0
4
0

c (dato un simbolo, divide la stringa data alla sua prima occorrenza), 143 + 1 = 144 byte (questo ovviamente è ancora golfabile):

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 (data una stringa, ottiene i primi 4 caratteri), 22 + 1 = 23 byte:

5
0
12
0
20
13
21
4

4

e (divisione di alto livello (ma con pericolo di divisione zero)), 138 + 1 = 139 byte:

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 (sposta un punto di 4 posizioni a destra; "divide" per 10000), 146 + 1 = 147 byte:

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 (controlla se una stringa inizia con un determinato carattere), 113 + 1 = 114 byte:

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 (restituisce tutto tranne il primo carattere di una determinata stringa), 41 + 1 = 42 byte:

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

0
4
0

i (sottrae due numeri), 34 + 1 = 35 byte:

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

j (divisione di basso livello che non funziona in tutti i casi), 134 + 1 = 135 byte:

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

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 (restituisce valore assoluto), 58 + 1 = 59 byte:

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

0
6
10

m (addizione), 109 + 1 = 110 byte:

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

%

%è una funzione che dà il reciproco del suo input. Puoi eseguirlo in questo modo

   % 2
0.5

Taxi , 467 byte

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.

Provalo 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 byte / sequenze di tasti

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

Poiché V è retrocompatibile, puoi provarlo online!

x86_64 Linguaggio macchina Linux, 5 byte

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

Per verificare ciò, è possibile compilare ed eseguire il seguente programma 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) );
  }
}

Provalo online!

C, 15 12 byte

#define f 1/

Provalo online!

16 13 byte, se deve gestire anche l'input intero:

#define f 1./

Quindi puoi chiamarlo con f(3) invece di f(3.0).

Provalo online!

Grazie a @hvd per giocare a golf a 3 byte!

MATLAB / Ottava, 4 byte

@inv

Crea un handle di funzione (denominato ans ) nell'integratoinv funzione integrata

Demo online

05AB1E , 1 byte

z

Provalo online!

z # pop a  push 1 / a

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

Avvertimento: il programma consumerà tutta la memoria di sistema nel tentativo di eseguire e richiederà più tempo per terminare di quanto si sarebbe disposti ad aspettare! Vedi sotto per una spiegazione e una versione veloce, ma meno 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:

Questo si basa sul risposta Retina di Martin Ender. Conto \tdalla riga 2 come una scheda letterale (1 byte).

Il mio contributo principale è al metodo di conversione da decimale a semplice unario (riga 2) e viceversa (riga 5). Sono riuscito a ridurre significativamente la dimensione del codice necessario per farlo (di circa 40 byte combinati), rispetto ai metodi mostrati in un suggerimento precedente . Ho creato una risposta di suggerimento separata con i dettagli, in cui fornisco frammenti pronti all'uso. Poiché 0 non è consentito come input, sono stati salvati alcuni byte in più.

Spiegazione: per comprendere meglio l'algoritmo di divisione, leggere prima la risposta Retina

Il programma è teoricamente corretto, il motivo per cui consuma così tante risorse computazionali è che il passo di divisione viene eseguito centinaia di migliaia di volte, più o meno a seconda dell'input, e il regex utilizzato dà origine a un incubo di backtracking. La versione veloce riduce la precisione (da qui il numero di passaggi di divisione) e cambia la regex per ridurre il backtracking.

Sfortunatamente, sed non ha un metodo per contare direttamente quante volte un backreference rientra in un modello, come in 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

Per una versione veloce e sicura del programma, ma meno precisa, puoi provarla online .

Japt , 2 byte

La soluzione ovvia sarebbe

1/U

che è, letteralmente, 1 / input. Tuttavia, possiamo fare di meglio:

pJ

Questo è equivalente a input ** Jed Jè impostato su -1 per impostazione predefinita.

Provalo online!

Curiosità: come pè la funzione di potere, così qè la funzione di root ( p2= **2, q2= **(1/2)); questo significa che qJfunzionerà anche, da allora -1 == 1/-1e quindi x**(-1) == x**(1/-1).

Javascript ES6, 6 byte

x=>1/x

Provalo online!

Javascript passa alla divisione in virgola mobile.

APL, 1 byte

÷

÷Calcola il reciproco quando usato come funzione monadica. Provalo online!

Utilizza il set di caratteri Dyalog Classic.

Cheddar , 5 byte

1&(/)

Provalo online!

Questo utilizza &, che lega un argomento a una funzione. In questo caso, 1è legato al lato sinistro di /, che ci dà 1/x, per un argomento x. Questo è più corto del canonico x->1/xdi 1 byte.

In alternativa, nelle versioni più recenti:

(1:/)

Java 8, 6 byte

x->1/x

Quasi uguale alla risposta JavaScript .

MATL , 3 byte

l_^

Provalo su MATL Online

Spiegazione

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

Python, 12 byte

lambda x:1/x

Uno per 13 byte:

(-1).__rpow__

Uno per 14 byte:

1 .__truediv__

Mathematica, 4 byte

1/#&

Ti fornisce un esatto razionale se gli dai un esatto razionale e un risultato in virgola mobile se gli dai un risultato in virgola mobile.

ZX Spectrum BASIC, 13 byte

1 INPUT A: PRINT SGN PI/A

Gli appunti:

• Ogni riga costa 2 byte per il numero di riga, 2 byte per la lunghezza della riga e 1 byte per la riga nuova
• I letterali numerici vengono convertiti in binari al momento dell'analisi, con un costo aggiuntivo di 6 byte, quindi l'utilizzo di SGN PIanziché letterale1 .
• Le parole chiave richiedono 1 byte ciascuna.

Versione ZX81 per 17 byte:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 byte

(1/)

Provalo online!

R, 8 byte

1/scan()

Abbastanza diretto. Emette direttamente l'inverso dell'input.

Un'altra soluzione, ma più lunga di 1 byte può essere:, scan()^-1o anche scan()**-1per un byte aggiuntivo. Entrambi ^e **il simbolo del potere.

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

Ans⁻¹

-1 byte grazie a Timtech .

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

Anse ⁻¹sono token a un byte .

TI-Basic restituisce implicitamente l'ultimo valore valutato ( Ans⁻¹).

Jelly, 1 byte

İ

Try it online!

C, 30 bytes

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