Wyzwanie

Biorąc pod uwagę liczbę (zmiennoprzecinkową / dziesiętną), zwróć jej odwrotność, tj. 1 podzieloną przez liczbę. Dane wyjściowe muszą być liczbą zmiennoprzecinkową / dziesiętną, a nie tylko liczbą całkowitą.

Szczegółowa specyfikacja

• Musisz otrzymać dane wejściowe w postaci liczby zmiennoprzecinkowej / dziesiętnej ...
  • ... który ma co najmniej 4 znaczące cyfry precyzji (w razie potrzeby).
  • Więcej jest lepsze, ale nie liczy się w wyniku.
• Musisz generować dane przy użyciu dowolnej akceptowalnej metody wyjściowej ...
  • ... odwrotność liczby.
  • Można to zdefiniować jako 1 / x, x⁻¹.
  • Musisz generować co najmniej 4 znaczące cyfry precyzji (w razie potrzeby).

Dane wejściowe będą dodatnie lub ujemne, z wartością bezwzględną w zakresie [0,0001, 9999] włącznie. Nigdy nie otrzymasz więcej niż 4 cyfr po przecinku, ani więcej niż 4, zaczynając od pierwszej niezerowej cyfry. Dane wyjściowe muszą być dokładne do 4. cyfry od pierwszej niezerowej.

(Dzięki @MartinEnder)

Oto kilka przykładowych danych wejściowych:

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

Zauważ, że nigdy nie otrzymasz danych, które mają więcej niż 4 cyfry dokładności.

Oto przykładowa funkcja w Ruby:

def reciprocal(i)
    return 1.0 / i
end

Zasady

• Wszystkie akceptowane formy produkcji są dozwolone
• Standardowe luki zabronione
• To jest golfowy kod , najkrótsza odpowiedź w bajtach wygrywa, ale nie zostanie wybrana.

Wyjaśnienia

• Nigdy nie otrzymasz danych wejściowych 0.

Nagrody

To wyzwanie jest oczywiście trywialne w większości języków, ale może stanowić zabawne wyzwanie w bardziej ezoterycznych i nietypowych językach, więc niektórzy użytkownicy chętnie przyznają punkty za wykonanie tego w niezwykle trudnych językach.

• @DJMcMayhem przyzna nagrodę +150 punktów za najkrótszą odpowiedź na uderzenie mózgu, ponieważ uderzenie mózgu jest niezwykle trudne dla liczb zmiennoprzecinkowych

• @ L3viathan przyzna nagrodę +150 punktów za najkrótszą odpowiedź OIL . OIL nie ma natywnego typu zmiennoprzecinkowego, ani nie ma podziału.

• @ Riley przyzna nagrodę +100 punktów za najkrótszą odpowiedź sed.

• @EriktheOutgolfer przyzna nagrodę +100 punktów za najkrótszą odpowiedź Sesos. Podział na pochodne ruchy mózgów takie jak Sesos jest bardzo trudny, nie mówiąc już o podziale zmiennoprzecinkowym.

• Ja ( @Mendeleev ) przyznam nagrodę w wysokości +100 punktów za najkrótszą odpowiedź Retiny .

Jeśli istnieje język, w którym Twoim zdaniem fajnie byłoby zobaczyć odpowiedź, a chcesz zapłacić przedstawicielowi, dodaj swoje imię i nazwisko do tej listy (posortowane według kwoty nagrody)

Tabela liderów

Oto fragment kodu w celu wygenerowania przeglądu zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik to suma dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Ponieważ Brain-Flak nie obsługuje liczb zmiennoprzecinkowych, musiałem użyć -cflagi do wprowadzania i wyprowadzania ciągów, stąd +1.

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

Wypróbuj online!

Wyjaśnienie

Pierwszą rzeczą, którą musimy się zająć, jest przypadek negatywny. Ponieważ odwrotność liczby ujemnej jest zawsze ujemna, możemy po prostu trzymać się znaku ujemnego do końca. Zaczynamy od wykonania kopii górnej części stosu i odejmowania od niej 45 (wartość ASCII -). Jeśli tak, to umieszczamy zero na górze stosu, jeśli nie, nic nie robimy. Następnie podnosimy górę stosu, aby odłożyć go na koniec programu. Jeśli dane wejściowe rozpoczęte od a -są nadal, to -jeśli tak nie jest, to ostatecznie zbieramy to zero, które umieściliśmy.

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

Teraz to nie przeszkadza, musimy przekonwertować realizacje ASCII każdej cyfry na tam rzeczywiste wartości (0-9). Zamierzamy również usunąć kropkę dziesiętną, .aby ułatwić obliczenia. Ponieważ musimy wiedzieć, gdzie zaczyna się kropka dziesiętna, kiedy wstawimy ją później, przechowujemy liczbę, aby śledzić, ile cyfr było przed .offstackiem.

Oto jak to robi kod:

Zaczynamy od odejmowania 46 (wartość ASCII .) od każdego elementu na stosie (jednocześnie przenosząc je wszystkie do stosu). To sprawi, że każda cyfra będzie o dwa więcej niż powinna, ale spowoduje .dokładnie zero.

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

Teraz przenosimy wszystko na lewy stos, dopóki nie osiągniemy zera (odejmując dwa z każdej cyfry podczas jazdy):

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

Rejestrujemy wysokość stosu

([]<

Przenieś wszystko inne na lewy stos (ponownie odejmując ostatnie dwa od każdej cyfry podczas ich przenoszenia)

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

I odłóż zapisaną wysokość stosu

>)

Teraz chcemy połączyć cyfry w jedną podstawową liczbę 10. Chcemy również uzyskać potęgę 10 z podwójną liczbą jako tą liczbą do wykorzystania w obliczeniach.

Zaczynamy od ustawienia 1 na wierzchu stosu, aby uzyskać moc 10 i przesunięcie wysokości stosu minus jeden na stos, aby użyć pętli.

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

Teraz pętlujemy wysokość stosu minus 1 razy,

{
 ({}[()]<

Za każdym razem mnożymy górny element przez 100, a pod nim mnożymy następny element przez 10 i dodajemy go do poniższej liczby.

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

Kończymy naszą pętlę

 >)
}{}

Teraz w końcu skończymy z konfiguracją i możemy rozpocząć faktyczne obliczenia.

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

To było to...

Dzielimy moc 10 przez zmodyfikowaną wersję danych wejściowych za pomocą algorytmu dzielenia liczb całkowitych 0, który znajduje się na wiki . To symuluje podział 1 przez wejście, jedyny sposób, w jaki Brain-Flak wie, jak to zrobić.

Na koniec musimy sformatować dane wyjściowe w odpowiednim ASCII.

Teraz, gdy odkryliśmy, neże musimy wyjąć e. Pierwszym krokiem do tego jest przekonwertowanie go na listę cyfr. Kod ten jest zmodyfikowaną wersją 0 ' „s algorytm divmod .

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

Teraz bierzemy liczbę i dodajemy przecinek dziesiętny tam, gdzie należy. Samo myślenie o tej części kodu przywraca ból głowy, więc na razie zostawię to jako ćwiczenie dla czytelnika, aby dowiedzieć się, jak i dlaczego to działa.

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

Umieść znak ujemny lub znak zerowy, jeśli nie ma znaku ujemnego.

>)

Python 2 , 10 bajtów

1..__div__

Wypróbuj online!

Retina , 99 91 bajtów

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

Wypróbuj online!

Woohoo, sub-100! Jest to zaskakująco wydajne, biorąc pod uwagę, że tworzy (a następnie dopasowuje) ciąg zawierający więcej niż ¹⁰⁷ znaków w jednym punkcie. Jestem pewien, że nie jest jeszcze optymalny, ale w tej chwili jestem całkiem zadowolony z wyniku.

Wyniki o wartości bezwzględnej mniejszej niż 1 zostaną wydrukowane bez wiodącego zera, np . .123Lub -.456.

Wyjaśnienie

Podstawową ideą jest użycie podziału na liczby całkowite (ponieważ jest to dość łatwe w przypadku wyrażeń regularnych i arytmetyki jednoargumentowej). Aby uzyskać wystarczającą liczbę cyfr znaczących, dzielimy dane wejściowe na 10 ⁷ . W ten sposób każde wejście do 9999 nadal daje 4-cyfrową liczbę. W efekcie oznacza to, że mnożymy wynik przez 10 ^7, więc musimy to śledzić, gdy później ponownie wstawimy przecinek dziesiętny.

1`\.|$
8$*;

Zaczynamy od zastąpienia kropki dziesiętnej lub końca łańcucha, jeśli nie ma kropki dziesiętnej 8 średnikami. Pierwszy z nich to sam przecinek dziesiętny (ale używam średników, ponieważ nie trzeba ich uciekać), pozostałe 7 wskazują, że wartość została pomnożona przez 10 ⁷ (jeszcze tak nie jest, ale wiemy, że zrobimy to później).

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

Najpierw przekształcamy dane wejściowe w liczbę całkowitą. Dopóki po przecinku są jeszcze cyfry, przesuwamy jedną cyfrę do przodu i usuwamy jeden z średników. Jest tak, ponieważ przesunięcie punktu dziesiętnego w prawo zwielokrotnia wartość wejściową przez 10 , a zatem dzieli wynik przez 10 . Ze względu na ograniczenia wejściowe wiemy, że stanie się to maksymalnie cztery razy, więc zawsze jest wystarczająco dużo średników, aby je usunąć.

\d+
$*1,10000000$*

Teraz, gdy dane wejściowe są liczbami całkowitymi, konwertujemy je na jednoargumentowe i dodajemy 10 ⁷ 1 s (oddzielone znakiem a ,).

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

Dzielimy liczbę całkowitą na 10 ⁷ , licząc, ile odwołań wstecznych do niej pasuje ( $#2). Jest to standardowy podział na liczbę całkowitą jednoargumentową a,b-> b/a. Teraz musimy tylko skorygować pozycję przecinka dziesiętnego.

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

Jest to w zasadzie odwrotność drugiego etapu. Jeśli nadal mamy więcej niż jeden średnik, oznacza to, że nadal musimy podzielić wynik przez 10 . Robimy to, przesuwając średniki o jedną pozycję w lewo i upuszczając jeden średnik, aż dotrzemy do lewego końca liczby lub pozostanie nam tylko jeden średnik (który jest samą kropką dziesiętną).

1`;
.

Teraz jest dobry czas, aby zmienić pierwszy (i być może tylko) z ;powrotem w ..

;
0

Jeśli pozostały jeszcze średniki, osiągnęliśmy lewy koniec liczby, więc ponowne podzielenie przez 10 spowoduje wstawienie zer za kropką dziesiętną. Można to łatwo zrobić, zamieniając każdą pozostałą ;na 0, ponieważ i tak są one bezpośrednio po przecinku.

tak , 5 bajtów

|0~-e

Wypróbuj online! To pobiera dane wejściowe z góry stosu i pozostawia dane wyjściowe na górze stosu. Łącze TIO pobiera dane wejściowe z argumentów wiersza poleceń, które mogą przyjmować tylko liczby całkowite.

Wyjaśnienie

yup ma tylko kilku operatorów. Te użyte w tej odpowiedzi to ln (x) (reprezentowane przez |), 0 () (stała, zwracanie funkcji zerowej 0), - (odejmowanie) i exp (x) (reprezentowane przez e). ~zamienia dwa górne elementy na stosie.

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

To używa tożsamości

co implikuje to

LOLCODE , 63 , 56 bajtów

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

7 bajtów zapisanych dzięki @devRicher!

Definiuje to funkcję „r”, którą można wywołać za pomocą:

r 5.0

lub jakikolwiek inny NUMBAR.

Wypróbuj online!

sed , 575 + 1 ( -rflaga) = 723 718 594 588 576 bajtów

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/

Wypróbuj online!

Uwaga: .5liczby zmiennoprzecinkowe, dla których wartość bezwzględna jest mniejsza niż 1, będą musiały zostać zapisane bez wiodącego 0, zamiast zamiast 0.5. Również liczba miejsc po przecinku jest równa , gdzie njest liczba miejsc po przecinku w liczbie (więc podanie 13.0jako danych wejściowych da więcej miejsc po przecinku niż podanie 13jako danych wejściowych)

To jest moje pierwsze zgłoszenie sed na PPCG. Pomysły na konwersję dziesiętną na unarną zaczerpnięto z tej niesamowitej odpowiedzi . Dzięki @seshoumara za prowadzenie mnie przez sed!

Ten kod wykonuje powtarzający się długi podział, aby uzyskać wynik. Podział zajmuje tylko ~ 150 bajtów. Konwersje w jednostkach dziesiętnych zajmują najwięcej bajtów, a kilka innych bajtów przechodzi na obsługę liczb ujemnych i danych zmiennoprzecinkowych

Wyjaśnienie

Wyjaśnienie dotyczące 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/

Edycje

• s:s/(.)/(.)/g:y/\1/\2/g:g aby zaoszczędzić 1 bajt przy każdej zamianie (łącznie 5)
• Zaoszczędź mnóstwo bajtów, patrząc na ładny konwerter dziesiętny na unarowy w „Poradach dla golfa w sed”
• Zmieniłem kilka podstawień, które zajmowały się dbaniem o znak minus, aby zaoszczędzić 6 bajtów.
• Używane \nzamiast ;jako separatora, to udało mi się skrócić „pomnożyć przez 10” substytucji zapisać 12 bajtów (dzięki @Riley i @seshoumara za pokazanie mi tego)

JSFuck , 3320 bajtów

JSFuck to ezoteryczny i edukacyjny styl programowania oparty na atomowych częściach JavaScript. Używa tylko sześciu różnych znaków ()[]+!do pisania i wykonywania kodu.

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

Wypróbuj online!

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

OLEJ , 1428 1420 bajtów

No cóż. Pomyślałem, że równie dobrze mogę spróbować, i ostatecznie udało mi się. Jest tylko jeden minus: pisanie zajmuje prawie tyle samo czasu, co pisanie.

Program jest podzielony na wiele plików, które mają wszystkie 1-bajtowe nazwy plików (i liczą się jako jeden dodatkowy bajt w moich obliczeniach bajtów). Niektóre pliki są częścią przykładowych plików w języku OIL, ale nie ma prawdziwego sposobu na ich konsekwentne wywoływanie (w OIL nie ma jeszcze ścieżki wyszukiwania ani niczego podobnego, więc nie uważam ich za standardową bibliotekę), ale oznacza to również, że (w momencie publikowania) niektóre pliki są bardziej szczegółowe niż to konieczne, ale zwykle tylko o kilka bajtów.

Obliczenia są dokładne z dokładnością do 4 cyfr, ale obliczenie nawet prostej wzajemności (takiej jak dane wejściowe 3) zajmuje naprawdę dużo czasu (ponad 5 minut). Do celów testowych stworzyłem również niewielki wariant, który ma dokładność do 2 cyfr, a uruchomienie zajmuje tylko kilka sekund, aby udowodnić, że działa.

Przepraszam za ogromną odpowiedź, chciałbym móc użyć jakiegoś spoilera. Mógłbym również umieścić większość tego na gist.github.com lub coś podobnego, w razie potrzeby.

Proszę bardzo: main217 bajtów (nazwa pliku się nie liczy dla bajtów):

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 (sprawdza, czy dany ciąg znajduje się w danym innym ciągu), 74 + 1 = 75 bajtów:

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 (łączy dwa podane ciągi), 20 + 1 = 21 bajtów:

5
0
5
1
13
0
2
0
4
0

c (biorąc pod uwagę symbol, dzieli dany ciąg przy jego pierwszym wystąpieniu), 143 + 1 = 144 bajtów (ten oczywiście oczywiście jest jeszcze grywalny):

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 (podany ciąg otrzymuje pierwsze 4 znaki), 22 + 1 = 23 bajty:

5
0
12
0
20
13
21
4

4

e (podział wysokiego poziomu (ale z niebezpieczeństwem zerowego podziału)), 138 + 1 = 139 bajtów:

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 (przesuwa kropkę o 4 pozycje w prawo; „dzieli” przez 10000), 146 + 1 = 147 bajtów:

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 (sprawdza, czy ciąg zaczyna się od danego znaku), 113 + 1 = 114 bajtów:

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 (zwraca wszystko oprócz pierwszego znaku danego ciągu), 41 + 1 = 42 bajty:

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

0
4
0

i (odejmuje dwie liczby), 34 + 1 = 35 bajtów:

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

j (podział niskiego poziomu, który nie działa we wszystkich przypadkach), 134 + 1 = 135 bajtów:

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 (mnożenie), 158 + 1 = 159 bajtów:

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 (zwracana wartość bezwzględna), 58 + 1 = 59 bajtów:

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

0
6
10

m (dodatek), 109 + 1 = 110 bajtów:

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 bajt

%

%jest funkcją podającą odwrotność swoich danych wejściowych. Możesz uruchomić to w ten sposób

   % 2
0.5

Taxi , 467 bajtów

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.

Wypróbuj online!

Nie golfowany:

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 bajtów / naciśnięć klawiszy

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

Ponieważ V jest wstecznie kompatybilny, możesz wypróbować online!

x86_64 język maszynowy Linux, 5 bajtów

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

Aby to przetestować, możesz skompilować i uruchomić następujący program 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) );
  }
}

Wypróbuj online!

C, 15 12 bajtów

#define f 1/

Wypróbuj online!

16 13 bajtów, jeśli musi również obsługiwać wprowadzanie liczb całkowitych:

#define f 1./

Możesz więc zadzwonić za pomocą f(3)zamiast f(3.0).

Wypróbuj online!

Dzięki @hvd za grę w golfa 3 bajty!

MATLAB / Octave, 4 bajty

@inv

Tworzy uchwyt funkcji (o nazwie ans) do wbudowanej invfunkcji

Demo online

05AB1E , 1 bajt

z

Wypróbuj online!

z # pop a  push 1 / a

GNU sed , 377 362 + 1 (flaga r) = 363 bajtów

Ostrzeżenie: program zje całą pamięć systemową podczas próby uruchomienia i zajmie więcej czasu, niż będziesz gotów czekać! Poniżej znajduje się wyjaśnienie i szybka, ale mniej precyzyjna wersja.

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:

Jest to oparte na odpowiedzi Retiny autorstwa Martina Endera. Liczę \tod wiersza 2 jako dosłowną tabulator (1 bajt).

Moim głównym wkładem jest metoda konwersji z dziesiętnej na zwykłą jednoargumentową (linia 2) i odwrotnie (linia 5). Udało mi się znacznie zmniejszyć rozmiar kodu potrzebnego do tego (o około 40 bajtów łącznie), w porównaniu do metod pokazanych w poprzedniej wskazówce . Stworzyłem osobną odpowiedź ze wskazówkami , w której podaję gotowe do użycia fragmenty. Ponieważ 0 nie jest dozwolone jako dane wejściowe, zapisano jeszcze kilka bajtów.

Objaśnienie: aby lepiej zrozumieć algorytm podziału, najpierw przeczytaj odpowiedź Retina

Program jest teoretycznie poprawny, dlatego zużywa tyle zasobów obliczeniowych, że krok podziału jest uruchamiany setki tysięcy razy, mniej więcej w zależności od danych wejściowych, a użyte wyrażenie regularne powoduje koszmar cofania się. Szybka wersja zmniejsza precyzję (stąd liczbę kroków podziału) i zmienia wyrażenie regularne w celu ograniczenia cofania.

Niestety, sed nie ma metody bezpośredniego liczenia, ile razy odniesienie wsteczne pasuje do wzoru, jak w Retinie.

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

Aby uzyskać szybką i bezpieczną wersję programu, ale mniej precyzyjną, możesz wypróbować to online .

Japt , 2 bajty

Oczywistym rozwiązaniem byłoby

1/U

co jest dosłownie 1 / input. Możemy jednak zrobić jedno lepiej:

pJ

Jest to równoważne input ** Ji Jdomyślnie ustawione na -1.

Wypróbuj online!

Ciekawostka: podobnie jak pfunkcja mocy, podobnie qjak funkcja root ( p2= **2, q2= **(1/2)); oznacza to, że również qJbędzie działać, ponieważ -1 == 1/-1i dlatego x**(-1) == x**(1/-1).

JavaScript ES6, 6 bajtów

x=>1/x

Wypróbuj online!

JavaScript domyślnie dzieli się na zmiennoprzecinkowe.

APL, 1 bajt

÷

÷Oblicza odwrotność, gdy jest używana jako funkcja monadyczna. Wypróbuj online!

Wykorzystuje zestaw znaków Dyalog Classic.

Cheddar , 5 bajtów

1&(/)

Wypróbuj online!

Wykorzystuje to &, co wiąże argument z funkcją. W tym przypadku 1jest związany z lewą stroną /, co daje nam 1/xargument x. Jest to krótszy niż kanoniczny x->1/xo 1 bajt.

Alternatywnie, w nowszych wersjach:

(1:/)

Java 8, 6 bajtów

x->1/x

Prawie taka sama jak odpowiedź JavaScript .

MATL , 3 bajty

l_^

Wypróbuj w MATL Online

Wyjaśnienie

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

Python, 12 bajtów

lambda x:1/x

Jeden na 13 bajtów:

(-1).__rpow__

Jeden na 14 bajtów:

1 .__truediv__

Mathematica, 4 bajty

1/#&

Zapewnia dokładną wymierność, jeśli podasz dokładną wymierność, oraz wynik zmiennoprzecinkowy, jeśli podasz wynik zmiennoprzecinkowy.

ZX Spectrum BASIC, 13 bajtów

1 INPUT A: PRINT SGN PI/A

Uwagi:

• Każda linia kosztuje 2 bajty dla numeru linii, 2 bajty dla długości linii i 1 bajt dla nowej linii
• SGN PILiteralne liczby są konwertowane na binarne w czasie analizy, co kosztuje dodatkowe 6 bajtów, dlatego użycie zamiast literału1 .
• Słowa kluczowe zajmują 1 bajt.

Wersja ZX81 dla 17 bajtów:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 bajty

(1/)

Wypróbuj online!

R, 8 bajtów

1/scan()

Całkiem proste. Bezpośrednio wyprowadza odwrotność wejścia.

Innym, ale o 1 bajt dłuższym rozwiązaniem może być: scan()^-1lub nawet scan()**-1dodatkowy bajt. Zarówno ^i **symbol mocy.

TI-Basic (TI-84 Plus CE), 6 5 2 bajtów

Ans⁻¹

-1 bajt dzięki Timtech .

-3 bajty Ansdzięki dzięki Григорий Перельман .

Ansi ⁻¹są jednobajtowymi tokenami .

TI-Basic domyślnie zwraca ostatnią ocenianą wartość ( Ans⁻¹).

Galaretka , 1 bajt

İ

Wypróbuj online!

C, 30 bajtów

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