Herausforderung

Geben Sie bei einer (Gleitkomma- / Dezimal-) Zahl den Kehrwert zurück, dh 1 geteilt durch die Zahl. Die Ausgabe muss eine Gleitkomma- / Dezimalzahl sein, nicht nur eine Ganzzahl.

Detaillierte Spezifikation

• Sie müssen eine Eingabe in Form einer Gleitkomma- / Dezimalzahl erhalten ...
  • ... mit mindestens 4 signifikanten Stellen Genauigkeit (falls erforderlich).
  • Mehr ist besser, zählt aber nicht in der Punktzahl.
• Sie müssen mit jeder akzeptablen Ausgabemethode ausgeben ...
  • ... der Kehrwert der Zahl.
  • Dies kann als 1 / x, x & supmin; ¹ definiert werden.
  • Sie müssen mit mindestens 4 signifikanten Stellen Genauigkeit ausgeben (falls erforderlich).

Die Eingabe erfolgt positiv oder negativ mit einem absoluten Wert im Bereich [0,0001, 9999]. Sie erhalten niemals mehr als 4 Stellen nach dem Dezimalpunkt oder mehr als 4 ab der ersten Stelle ungleich Null. Die Ausgabe muss bis zur 4. Stelle von der ersten Stelle ungleich Null genau sein.

(Danke @MartinEnder)

Hier sind einige Beispieleingaben:

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

Beachten Sie, dass Sie niemals Eingaben mit einer Genauigkeit von mehr als 4 Stellen erhalten.

Hier ist eine Beispielfunktion in Ruby:

def reciprocal(i)
    return 1.0 / i
end

Regeln

• Alle akzeptierten Ausgabeformen sind zulässig
• Standardlücken verboten
• Dies ist Code-Golf , die kürzeste Antwort in Bytes gewinnt, wird aber nicht ausgewählt.

Klarstellungen

• Sie werden nie die Eingabe erhalten 0.

Kopfgelder

Diese Herausforderung ist in den meisten Sprachen offensichtlich trivial, kann jedoch in esoterischen und ungewöhnlichen Sprachen eine unterhaltsame Herausforderung darstellen. Einige Benutzer sind daher bereit, Punkte dafür zu vergeben, dass dies in ungewöhnlich schwierigen Sprachen durchgeführt wird.

• @DJMcMayhem wird eine Prämie von +150 Punkten für die kürzeste Brain-Flak-Antwort vergeben, da Brain-Flak für Gleitkommazahlen notorisch schwierig ist

• @ L3viathan vergibt eine Prämie von +150 Punkten für die kürzeste OIL- Antwort. OIL hat weder einen nativen Gleitkommatyp noch eine Division.

• @Riley wird eine Prämie von +100 Punkten für die kürzeste Antwort vergeben.

• @EriktheOutgolfer wird die kürzeste Sesos-Antwort mit +100 Punkten belohnen. Die Aufteilung in Brainfuck-Derivate wie Sesos ist sehr schwierig, geschweige denn die Gleitkommadivision.

• Ich ( @Mendeleev ) werde eine Prämie von +100 Punkten für die kürzeste Retina-Antwort vergeben.

Wenn es eine Sprache gibt, von der Sie glauben, dass es Spaß macht, eine Antwort in zu sehen, und Sie bereit sind, den Repräsentanten zu bezahlen, können Sie Ihren Namen in diese Liste aufnehmen (sortiert nach Kopfgeldbetrag).

Bestenliste

Hier ist ein Stack-Snippet, um eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Da Brain-Flak keine Fließkommazahlen unterstützt, musste ich das -cFlag bei der Ein- und Ausgabe mit Strings verwenden, daher die +1.

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

Probieren Sie es online!

Erläuterung

Als erstes müssen wir uns um den negativen Fall kümmern. Da der Kehrwert einer negativen Zahl immer negativ ist, können wir einfach bis zum Ende am negativen Vorzeichen festhalten. Wir machen zunächst eine Kopie des oberen Teils des Stapels und subtrahieren 45 (den ASCII-Wert von -) davon. Wenn dies eins ist, setzen wir eine Null auf den Stapel, wenn nicht, tun wir nichts. Dann nehmen wir die Oberseite des Stapels auf, um sie am Ende des Programms abzulegen. Wenn die Eingabe mit einem begann, ist -dies immer noch ein, -aber wenn dies nicht der Fall ist , nehmen wir am Ende die von uns gesetzte Null auf.

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

Nun, da dies nicht möglich ist, müssen wir die ASCII-Realisierungen jeder Ziffer in ihre tatsächlichen Werte (0-9) konvertieren. Wir werden auch den Dezimalpunkt entfernen ., um die Berechnungen zu vereinfachen. Da wir wissen müssen, wo der Dezimalpunkt beim späteren .erneuten Einfügen begonnen hat, speichern wir eine Zahl, um zu verfolgen, wie viele Stellen sich vor dem Offstack befanden.

So funktioniert der Code:

Wir beginnen mit dem Subtrahieren von 46 (dem ASCII-Wert von .) von jedem Element auf dem Stapel (wobei alle gleichzeitig auf den Offstack verschoben werden). Dies macht jede Ziffer zwei mehr als es sein sollte, macht aber .genau die Null.

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

Jetzt bewegen wir alles auf den linken Stapel, bis wir eine Null erreichen (wobei wir zwei von jeder Ziffer abziehen, während wir gehen):

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

Wir erfassen die Stapelhöhe

([]<

Bewegen Sie alles andere auf den linken Stapel (noch einmal subtrahieren Sie die letzten beiden von jeder Ziffer, während wir sie bewegen)

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

Und setzen Sie die Stapelhöhe, die wir aufgezeichnet haben

>)

Jetzt wollen wir die Ziffern zu einer einzigen Basis 10 kombinieren. Wir möchten auch eine Zehnerpotenz mit der doppelten Anzahl von Stellen als diese Zahl für die Berechnung verwenden.

Wir beginnen damit, eine 1 auf dem Stapel zu setzen, um die Potenz von 10 zu erhalten, und die Stapelhöhe abzüglich einer 1 auf den Stapel zu schieben, um eine Schleife zu verwenden.

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

Jetzt schleifen wir die Stapelhöhe minus 1 mal,

{
 ({}[()]<

Jedes Mal, wenn wir das oberste Element mit 100 multiplizieren und darunter das nächste Element mit 10 multiplizieren, addieren wir das zu der Zahl darunter.

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

Wir beenden unsere Schleife

 >)
}{}

Nun sind wir mit dem Einrichten fertig und können mit der eigentlichen Berechnung beginnen.

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

Das war's...

Wir dividieren die Potenz von 10 durch die modifizierte Version der Eingabe unter Verwendung des Ganzzahlteilungsalgorithmus von 0, wie er im Wiki zu finden ist . Dies simuliert die Division von 1 durch die Eingabe, wie es nur Brain-Flak weiß.

Zuletzt müssen wir unsere Ausgabe in das entsprechende ASCII formatieren.

Jetzt, da wir herausgefunden haben, müssen newir das herausnehmen e. Der erste Schritt dazu ist die Konvertierung in eine Ziffernliste. Dieser Code ist eine modifizierte Version von 0 ' ‚s divmod Algorithmus .

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

Nun nehmen wir die Zahl und addieren den Dezimalpunkt dahin zurück, wo er hingehört. Wenn ich nur über diesen Teil des Codes nachdenke, bekomme ich wieder Kopfschmerzen. Daher möchte ich es dem Leser als Übung überlassen, herauszufinden, wie und warum es funktioniert.

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

Tragen Sie das negative Vorzeichen oder ein Nullzeichen ein, wenn es kein negatives Vorzeichen gibt.

>)

Python 2 , 10 Bytes

1..__div__

Probieren Sie es online!

Retina , 99 91 Bytes

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

Probieren Sie es online!

Woohoo, unter 100! Dies ist überraschend effizient, wenn man bedenkt, dass eine Zeichenfolge mit mehr als 10 ⁷ Zeichen an einem Punkt erstellt (und dann abgeglichen wird) . Ich bin mir sicher, dass es noch nicht optimal ist, aber ich bin im Moment recht zufrieden mit dem Ergebnis.

Ergebnisse mit einem Absolutwert unter 1 werden ohne die führende Null gedruckt, z . B. .123oder -.456.

Erläuterung

Die Grundidee ist die Verwendung einer Ganzzahldivision (da dies mit Regex und unärer Arithmetik ziemlich einfach ist). Um sicherzustellen, dass wir eine ausreichende Anzahl von signifikanten Stellen erhalten, teilen wir die Eingabe in 10 ⁷ . Auf diese Weise ergibt jede Eingabe bis 9999 immer noch eine 4-stellige Zahl. Im Endeffekt bedeutet dies, dass wir das Ergebnis mit 10 ⁷ multiplizieren, sodass wir dies berücksichtigen müssen, wenn wir später den Dezimalpunkt erneut einfügen.

1`\.|$
8$*;

Wir beginnen damit, den Dezimalpunkt oder das Ende der Zeichenfolge zu ersetzen, wenn es keinen Dezimalpunkt mit 8 Semikolons gibt. Die erste von ihnen ist im Wesentlichen der Dezimalpunkt selbst (aber ich benutze Semikolons, weil sie nicht maskiert werden müssen), die anderen 7 zeigen an, dass der Wert mit 10 multipliziert wurde ⁷ (dies ist noch nicht der Fall, aber wir wissen, dass wir das später tun werden).

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

Wir wandeln die Eingabe zunächst in eine Ganzzahl um. Solange es noch Nachkommastellen gibt, rücken wir eine Stelle nach vorne und entfernen eines der Semikolons. Dies liegt daran, dass durch Bewegen des Dezimalpunkts nach rechts die Eingabe mit 10 multipliziert und das Ergebnis daher durch 10 geteilt wird . Aufgrund der Eingabebeschränkungen wissen wir, dass dies höchstens viermal vorkommt, sodass immer genügend Semikolons zum Entfernen vorhanden sind.

\d+
$*1,10000000$*

Jetzt, da die Eingabe eine Ganzzahl ist, konvertieren wir sie in unär und hängen 10 ⁷ 1 s an (durch a getrennt ,).

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

Wir teilen die Ganzzahl in 10 ^7, indem wir zählen, wie viele Rückverweise darauf passen ( $#2). Dies ist die normale unäre Ganzzahldivision a,b-> b/a. Jetzt müssen wir nur noch die Position des Dezimalpunkts korrigieren.

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

Dies ist im Grunde das Gegenteil der zweiten Stufe. Wenn wir immer noch mehr als ein Semikolon haben, müssen wir das Ergebnis noch durch 10 teilen . Dazu verschieben wir die Semikolons um eine Position nach links und lassen ein Semikolon fallen, bis wir entweder das linke Ende der Zahl erreichen oder nur noch ein Semikolon (das ist der Dezimalpunkt selbst).

1`;
.

Jetzt ist ein guter Zeitpunkt, um die erste (und möglicherweise einzige) ;zurück zu drehen ..

;
0

Wenn noch Semikolons übrig sind, haben wir das linke Ende der Zahl erreicht. Wenn Sie also erneut durch 10 teilen, werden hinter dem Dezimalpunkt Nullen eingefügt. Dies ist einfach zu bewerkstelligen, indem jedes verbleibende ;durch ein ersetzt wird 0, da es ohnehin unmittelbar nach dem Komma steht.

Ja , 5 Bytes

|0~-e

Probieren Sie es online! Dies nimmt die Eingabe von oben auf den Stapel und lässt die Ausgabe oben auf dem Stapel. Die TIO-Verknüpfung nimmt Eingaben von Befehlszeilenargumenten entgegen, die nur Ganzzahleingaben annehmen können.

Erläuterung

yup hat nur wenige Operatoren. Die in dieser Antwort verwendeten sind ln (x) (dargestellt durch |), 0 () (Konstante, Nullfunktion, die zurückkehrt 0), - (Subtraktion) und exp (x) (dargestellt durch e). ~Schaltet die beiden obersten Elemente auf dem Stapel um.

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

Dies verwendet die Identität

was das impliziert

LOLCODE , 63 , 56 Bytes

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

7 Bytes gespart dank @devRicher!

Dies definiert eine Funktion 'r', die aufgerufen werden kann mit:

r 5.0

oder irgendein anderes NUMBAR.

Probieren Sie es online!

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

Probieren Sie es online!

Hinweis: Floats, deren absoluter Wert kleiner als 1 ist, müssen ohne führende 0 wie .5statt geschrieben werden 0.5. Auch die Anzahl der Nachkommastellen ist gleich , wobei ndie Anzahl der Nachkommastellen in der Zahl ist (so dass das Geben 13.0als Eingabe mehr Nachkommastellen ergibt als das Geben 13als Eingabe).

Dies ist mein erster Sed-Beitrag zu PPCG. Aus dieser erstaunlichen Antwort wurden Ideen für die Umwandlung von Dezimalstellen in unäre Werte abgeleitet . Vielen Dank an @seshoumara, der mich durch sed geführt hat!

Dieser Code führt eine wiederholte lange Division durch, um das Ergebnis zu erhalten. Die Aufteilung dauert nur ~ 150 Bytes. Die unären Dezimalumwandlungen benötigen die meisten Bytes, und einige andere Bytes unterstützen negative Zahlen und Gleitkomma-Eingaben

Erläuterung

Erklärung zu 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/

Bearbeitungen

• s:s/(.)/(.)/g:y/\1/\2/g:g bei jeder Ersetzung 1 Byte speichern (insgesamt 5)
• Eine Menge Bytes gespart, indem ein netter Dezimal-Unär-Konverter für "Tipps zum Golfen in Sed" verwendet wurde
• Ich habe mich um einige Ersetzungen gekümmert, bei denen auf das Minuszeichen geachtet wurde, um 6 Bytes zu sparen.
• Verwendet \nstatt ;als Separator, dann konnte ich die „multiplizieren mit 10“ Substitutionen verkürzen 12 Bytes (dank @Riley und @seshoumara dies für das Zeigen Sie mir) speichern

JSFuck , 3320 Bytes

JSFuck ist ein esoterischer und lehrreicher Programmierstil, der auf den atomaren Teilen von JavaScript basiert. Es werden nur sechs verschiedene Zeichen ()[]+!zum Schreiben und Ausführen von Code verwendet.

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

Probieren Sie es online!

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

OIL , 1428 - 1420 Bytes

Naja. Ich dachte, ich könnte es genauso gut versuchen, und es gelang mir am Ende. Es gibt nur einen Nachteil: Das Ausführen dauert fast so lange wie das Schreiben.

Das Programm ist in mehrere Dateien aufgeteilt, die alle 1-Byte-Dateinamen enthalten (und für ein zusätzliches Byte in meiner Byte-Berechnung zählen). Einige der Dateien sind Teil der Beispieldateien der OIL-Sprache, aber es gibt keine echte Möglichkeit, sie konsistent aufzurufen (es gibt noch keinen Suchpfad oder ähnliches in OIL, sodass ich sie nicht als Standardbibliothek betrachte), aber Dies bedeutet auch, dass einige der Dateien (zum Zeitpunkt der Veröffentlichung) ausführlicher sind als erforderlich, jedoch in der Regel nur um einige Bytes.

Die Berechnungen sind auf 4 Stellen genau, aber selbst das Berechnen eines einfachen Reziprokwerts (wie der Eingabe 3) dauert sehr lange (über 5 Minuten). Zu Testzwecken habe ich auch eine kleinere Variante erstellt, die zweistellig ist. Die Ausführung dauert nur wenige Sekunden, um zu beweisen, dass sie funktioniert.

Es tut mir leid für die riesige Antwort, ich wünschte, ich könnte eine Art Spoiler-Tag verwenden. Wenn gewünscht, könnte ich den Großteil auch auf gist.github.com oder ähnliches einstellen.

Los geht's: main217 Bytes (Dateiname zählt nicht für 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 (Prüft, ob eine bestimmte Zeichenfolge in einer anderen Zeichenfolge enthalten ist.) 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 (Verbindet zwei angegebene Zeichenfolgen), 20 + 1 = 21 Byte:

5
0
5
1
13
0
2
0
4
0

c (Wenn ein Symbol angegeben wird, wird die angegebene Zeichenfolge beim ersten Auftreten aufgeteilt.) 143 + 1 = 144 Byte (diese Zeichenfolge ist offensichtlich noch golffähig):

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 (Wenn eine Zeichenfolge angegeben wird, werden die ersten 4 Zeichen abgerufen), 22 + 1 = 23 Byte:

5
0
12
0
20
13
21
4

4

e (High-Level-Division (aber mit Null-Division-Gefahr)), 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 (verschiebt einen Punkt 4 Stellen nach rechts; "dividiert" durch 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 (prüft, ob eine Zeichenfolge mit einem bestimmten Zeichen beginnt), 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 (gibt alles außer dem ersten Zeichen einer bestimmten Zeichenfolge zurück), 41 + 1 = 42 Byte:

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

0
4
0

i (subtrahiert zwei Zahlen), 34 + 1 = 35 Bytes:

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

j (Unterteilung, die nicht in allen Fällen funktioniert), 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 (Multiplikation), 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 (Absolutwert zurückgeben), 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 (Addition), 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

%

%ist eine Funktion, die den Kehrwert ihrer Eingabe angibt. Sie können es so ausführen

   % 2
0.5

Taxi , 467 Bytes

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

Probieren Sie es 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 / Tastenanschläge

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

Da V abwärtskompatibel ist, können Sie es online ausprobieren!

x86_64 Linux-Maschinensprache, 5 Byte

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

Um dies zu testen, können Sie das folgende C-Programm kompilieren und ausführen

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

Probieren Sie es online!

C, 15 12 Bytes

#define f 1/

Probieren Sie es online!

16 bis 13 Bytes, wenn auch Integer-Eingaben verarbeitet werden sollen:

#define f 1./

So können Sie es mit f(3)anstelle von aufrufen f(3.0).

Probieren Sie es online!

Danke an @hvd für das Golfen mit 3 Bytes!

MATLAB / Octave, 4 Bytes

@inv

Erstellt ein Funktionshandle (benannt ans) für die integrierte invFunktion

Online Demo

05AB1E , 1 Byte

z

Probieren Sie es online!

z # pop a  push 1 / a

GNU sed , 377 362 + 1 (r Flag) = 363 Bytes

Warnung: Das Programm verbraucht den gesamten Systemspeicher, der ausgeführt werden soll, und benötigt mehr Zeit, als Sie abwarten möchten. Unten finden Sie eine Erklärung und eine schnelle, aber weniger genaue Version.

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:

Dies basiert auf der Retina-Antwort von Martin Ender. Ich zähle \tab Zeile 2 als wörtliche Registerkarte (1 Byte).

Mein Hauptbeitrag ist die Umrechnungsmethode von dezimal zu unär (Zeile 2) und umgekehrt (Zeile 5). Es ist mir gelungen, die dafür erforderliche Codegröße (um insgesamt ~ 40 Byte) im Vergleich zu den in einem vorherigen Tipp beschriebenen Methoden erheblich zu reduzieren . Ich habe eine separate Tippantwort mit den Details erstellt, in der ich gebrauchsfertige Snippets zur Verfügung stelle. Da 0 nicht als Eingabe zulässig ist, wurden einige Bytes mehr gespeichert.

Erklärung: Um den Teilungsalgorithmus besser zu verstehen, lesen Sie zuerst die Retina-Antwort

Das Programm ist theoretisch korrekt, der Grund, warum es so viel Rechenressourcen verbraucht, ist, dass der Teilungsschritt hunderttausendmal ausgeführt wird, je nach Eingabe mehr oder weniger, und der verwendete reguläre Ausdruck einen Albtraum der Rückverfolgung hervorruft. Die schnelle Version reduziert die Präzision (daher die Anzahl der Teilungsschritte) und ändert die Regex, um das Backtracking zu reduzieren.

Leider hat sed keine Methode, um direkt zu zählen, wie oft eine Rückreferenz in ein Muster passt, wie 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

Für eine schnelle und sichere Version des Programms, aber weniger genau, können Sie dies online versuchen .

Japt , 2 Bytes

Die naheliegende Lösung wäre

1/U

Das ist ganz wörtlich 1 / input. Wir können jedoch eines besser machen:

pJ

Dies entspricht input ** Jund Jist standardmäßig auf -1 gesetzt.

Probieren Sie es online!

Unterhaltsame Tatsache: Wie pdie Potenzfunktion qist auch die Wurzelfunktion ( p2= **2, q2= **(1/2)); das heißt, das qJwird auch funktionieren, da -1 == 1/-1und daher x**(-1) == x**(1/-1).

Javascript ES6, 6 Bytes

x=>1/x

Probieren Sie es online!

Javascript verwendet standardmäßig die Gleitkommadivision.

APL, 1 Byte

÷

÷Berechnet bei Verwendung als monadische Funktion den Kehrwert. Probieren Sie es online!

Verwendet den Dyalog Classic-Zeichensatz.

Cheddar , 5 Bytes

1&(/)

Probieren Sie es online!

Dies verwendet &, was ein Argument an eine Funktion bindet. In diesem Fall 1ist an die linke Seite gebunden /, was uns 1/xzu einem Streit verleitet x. Dies ist x->1/xum 1 Byte kürzer als das kanonische .

Alternativ in den neueren Versionen:

(1:/)

Java 8, 6 Bytes

x->1/x

Fast das gleiche wie die JavaScript-Antwort .

MATL , 3 Bytes

l_^

Probieren Sie es bei MATL Online aus

Erläuterung

    % 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

Eine für 13 Bytes:

(-1).__rpow__

Eine für 14 Bytes:

1 .__truediv__

Mathematica, 4 Bytes

1/#&

Bietet Ihnen ein genaues Rational, wenn Sie es als genaues Rational bezeichnen, und ein Gleitkommaergebnis, wenn Sie es als Gleitkommaergebnis bezeichnen.

ZX Spectrum BASIC, 13 Byte

1 INPUT A: PRINT SGN PI/A

Anmerkungen:

• Jede Zeile kostet 2 Byte für die Zeilennummer, 2 Byte für die Länge der Zeile und 1 Byte für die neue Zeile
• Numerische Literale werden beim Parsen in Binärwerte konvertiert, was zusätzliche 6 Byte kostet, also die Verwendung von SGN PIanstelle von Literalen 1.
• Schlüsselwörter nehmen jeweils 1 Byte ein.

ZX81 Version für 17 Bytes:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 Bytes

(1/)

Probieren Sie es online!

R, 8 Bytes

1/scan()

Ziemlich einfach. Gibt direkt die Inverse des Eingangs aus.

Eine andere, aber 1 Byte längere Lösung kann sein: scan()^-1oder sogar scan()**-1für ein zusätzliches Byte. Beides ^und **das Energiesymbol.

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

Ans⁻¹

-1 Byte dank Timtech .

-3 Bytes mit AnsDank an Григорий Перельман .

Ansund ⁻¹sind Ein-Byte-Token .

TI-Basic gibt implizit den zuletzt ausgewerteten Wert zurück ( Ans⁻¹).

Gelee , 1 Byte

İ

Probieren Sie es online!

C 30 Bytes

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