Meydan okuma

Bir (kayan nokta / ondalık) sayı verildiğinde, karşılığını, ör. Çıktı, yalnızca bir tamsayı değil, kayan noktalı / ondalık sayı olmalıdır.

Detaylı özellikleri

• Bir kayan noktalı / ondalık sayı biçiminde giriş almalısınız ...
  • ... (en az 4 önemli hassasiyet hanesine sahiptir (gerekirse).
  • Dahası daha iyidir, ancak skorda sayılmaz.
• Herhangi bir kabul edilebilir çıktı yöntemiyle çıktı vermelisiniz ...
  • ... sayının tersi.
  • Bu, 1 / x, x as olarak tanımlanabilir.
  • En az 4 önemli hassasiyet hanesi ile çıktı yapmanız gerekir (gerekirse).

Girdi, [0.0001, 9999] dahilindeki mutlak değere sahip, pozitif veya negatif olacaktır. Asla ondalık basamağın 4 basamağından, sıfır olmayan ilk basamağından başlayarak 4 basamağından daha fazla rakam girmeyeceksiniz. Çıkışın sıfır olmayan ilk rakamdan 4. basamağa kadar doğru olması gerekir.

(Teşekkürler @MartinEnder)

İşte bazı örnek girişler:

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

Asla 4 basamaktan fazla hassasiyete sahip girdiler almayacağınızı unutmayın.

Ruby'de örnek bir fonksiyon:

def reciprocal(i)
    return 1.0 / i
end

kurallar

• Kabul edilen tüm çıktı biçimlerine izin verilir
• Standart boşluklar yasaklandı
• Bu kod golf , bayt cinsinden en kısa cevap kazanır, ancak seçilmez.

Açıklamalar

• Asla girişi alamazsınız 0.

İkramiyeleri

Bu zorluk çoğu dilde açık bir şekilde önemsizdir, ancak daha ezoterik ve sıradışı dillerde eğlenceli bir meydan okuma sunabilir, bu nedenle bazı kullanıcılar bunu alışılmadık derecede zor dillerde yapmak için puan vermeye isteklidir.

• @DJMcMayhem bir ödüllendireceğiz 150 puan beyin kurşun geçirmez kayan noktalı sayılar için çok zordur, çünkü en kısa beyin kurşun geçirmez cevap lütuf

• @ L3viathan , en kısa OIL cevabına +150 puan ödül verecek. OIL yerel kayan nokta türüne sahip değildir ve bölme de yoktur.

• @Riley , en kısa sed cevabına +100 puan ödül verecek.

• @EriktheOutgolfer bir ödüllendireceğiz 100 puan en kısa Sesos cevaba lütuf. Kayan nokta bölünmesinden bağımsız olarak Sesos gibi beyinböceği türevlerinde bölünme çok zordur.

• I ( @Mendeleev ) en kısa Retina cevabına +100 puan ödül verecek.

Bir cevabı görmenin eğlenceli olacağını düşündüğünüz bir dil varsa ve temsilcisi ödemeyi kabul ediyorsanız, adınızı bu listeye eklemekten çekinmeyin (ödül miktarına göre sıralanır)

Liderler Sıralaması

Kazananların dile göre genel bir bakışını oluşturmak için bir Stack Snippet'i burada bulabilirsiniz.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden çok sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğinizden dolayı), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra büyük afiş snippet'inde görünecek bir bağlantı da yapabilirsiniz:

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

Brain-Flak kayan nokta sayılarını desteklemediği için -cbayrak dizelerini giriş ve çıkış olarak kullanmak zorunda kaldım , bu nedenle + 1.

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

Çevrimiçi deneyin!

açıklama

Dikkat etmemiz gereken ilk şey, olumsuz durum. Negatif sayının karşılığı her zaman negatif olduğu için, sonuna kadar negatif işaretini tutabiliriz. Yığının tepesinin bir kopyasını alarak ve -ondan 45 (ASCII değeri ) çıkararak başlıyoruz . Eğer bu ise, yığının üstüne bir sıfır koyarız, eğer bir şey yapmazsak. Sonra programın sonunda bırakılacak yığının üstünü kaldırırız. Girdi bir ile başladıysa, -bu hala bir durum -ancak eğer değilse, bu sıfırı alıp almayacağız .

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

Şimdi bu, her rakamın ASCII gerçekleştirmelerini oradaki gerçek değerlere (0-9) dönüştürmemiz gerektiğine göre. .Hesaplamaları kolaylaştırmak için ondalık noktasını da kaldıracağız . Yeniden yerleştirdiğimizde ondalık basamağın nerden başladığını bilmemiz gerektiğinden, daha sonra kaç basamakta kaç basamak önünde bulunduğunu takip etmek için bir sayı .saklıyoruz.

İşte kod böyle yapar:

.Yığındaki her bir elemandan 46'yı (ASCII değeri ) çıkartarak başlıyoruz (aynı anda hepsini offstack'e taşıyoruz). Bu, her rakamı olması gerekenden iki kat daha artıracak ama .tam olarak sıfır yapacak .

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

Şimdi sıfıra gelinceye kadar her şeyi soldaki yığına taşıyoruz (biz giderken her bir rakamdan iki tane çıkarıyoruz):

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

İstif yüksekliğini kaydediyoruz

([]<

Her şeyi soldaki yığına taşıyın (bir kere daha son ikisini hareket ettirirken her rakamdan çıkarırız)

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

Ve kaydettiğimiz yığın yüksekliğini koy

>)

Şimdi rakamları tek bir baz 10 numarada birleştirmek istiyoruz. Ayrıca hesaplamada kullanmak için bu sayının iki katı olan 10'luk bir güç elde etmek istiyoruz.

10'un gücünü elde etmek için yığının üstüne 1 ayarlayarak ve yığın yüksekliğini eksi ilmek kullanmak için yığına bir iterek başlarız.

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

Şimdi yığın yüksekliğini eksi 1 kez döndürüyoruz,

{
 ({}[()]<

Her seferinde üst elemanı 100 ile çarpıyoruz ve altında bir sonraki elemanı 10 ile çarpıyoruz ve bunu aşağıdaki sayıya ekliyoruz.

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

Döngünümüzü sonlandırıyoruz

 >)
}{}

Şimdi nihayet ayarlamalar yapıldı ve gerçek hesaplamaya başlayabiliriz.

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

Bu oydu ...

Biz kullanarak giriş modifike edilmiş versiyonu ile 10 gücünü bölmek '0 ile bulunduğu gibi sitesindeki tamsayı bölme algoritmasını wiki'de . Bu, Brain-Flak'ın bildiği tek yolun girişe göre bölünmesini simüle eder.

Son olarak, çıktılarımızı uygun ASCII'ye biçimlendirmeliyiz.

Şimdi bulduk ki onu neçıkarmamız gerekiyor e. Buna ilk adım, onu bir basamak listesine dönüştürmektir. Bu kod, bir modifiye edilmiş versiyonu 0 ' 'in divmod algoritması .

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

Şimdi sayıyı alıyoruz ve ondalık basamağı ait olduğu yere geri ekliyoruz. Sadece kodun bu kısmını düşünmek baş ağrıları yaratıyor, bu yüzden şimdilik onu nasıl ve neden çalıştığını anlamak için okuyucunun alıştırması olarak bırakacağım.

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

Negatif işareti yoksa negatif işaretini aşağı veya boş bir karakter koyun.

>)

Python 2,10 bayt

1..__div__

Çevrimiçi deneyin!

Retina , 99 91 bayt

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

Çevrimiçi deneyin!

Woohoo, 100 yaş altı! Bu yarattığı (ve sonra karşı eşleşir) 10'dan fazla olan bir dize göz önüne alındığında şaşırtıcı derecede etkili olduğu ⁷ bir noktada karakterler. Eminim henüz optimal değildir, fakat şu anda skordan çok memnunum.

1'den küçük mutlak değere sahip sonuçlar, örneğin sıfır .123veya başta sıfır olmadan yazdırılır -.456.

açıklama

Temel fikir, tamsayı bölme kullanmaktır (çünkü regex ve unary aritmetik ile oldukça kolaydır). Yeterli sayıda önemli basamak aldığımızdan emin olmak için girişi 10 ^7'ye böldük . Bu şekilde, 9999'a kadar olan herhangi bir giriş hala 4 basamaklı bir sayıyla sonuçlanır. Etkili bir şekilde, bu, sonucu 10 ^{7 ile} çarptığımız anlamına gelir, bu nedenle daha sonra ondalık basamağı yeniden yerleştirdiğinde bunu takip etmemiz gerekir.

1`\.|$
8$*;

Ondalık noktayı değiştirerek veya 8 noktalı virgül ile ondalık nokta yoksa dizenin sonunu değiştirerek başlarız. Bunlardan ilki, esasen ondalık noktanın kendisidir (ancak kaçmaları gerekmediği için noktalı virgül kullanıyorum), diğer 7 değerin 10 ^{7 ile} çarpıldığını gösterir (bu henüz böyle değil, ama bunu daha sonra yapacağımızı biliyoruz).

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

İlk önce girişi bir tamsayıya dönüştürüyoruz. Ondalık noktadan sonra hala haneler olduğu sürece, bir basamağı öne hareket ettirir ve noktalı virgüllerden birini kaldırırız. Bunun nedeni, ondalık basamağın sağa kaydırılması girişi 10 ile çarpması ve sonucu 10'a bölmesidir . Giriş kısıtlamaları nedeniyle, bunun en fazla dört defa olacağını biliyoruz, bu nedenle kaldırılacak her zaman noktalı virgül vardır.

\d+
$*1,10000000$*

Şimdi girdi bir tamsayı olduğundan, onu birliğe çeviririz ve 10 ⁷ 1 s ekleriz (a ile ayrılır ,).

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

Biz içine tamsayı bölen 10 ⁷ kendisine birçok geribaşvurularla nasıl uyum sayımı ile ( $#2). Bu standart unary tamsayı bölümüdür a,b-> b/a. Şimdi sadece ondalık basamağın konumunu düzeltmemiz gerekiyor.

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

Bu temelde ikinci aşamada tersidir. Hala birden fazla noktalı virgül varsa, bu yine de sonucu 10'a bölmemiz gerektiği anlamına gelir . Bunu, noktalı virgülleri bir konum sola hareket ettirip sayının sol sonuna ulaşana kadar bir noktalı virgül bırakarak ya da yalnızca bir noktalı virgülle (ondalık basamağın kendisidir) bıraktık.

1`;
.

Şimdi, ilkini (ve muhtemelen sadece) ;geri çevirmek için iyi bir zaman ..

;
0

Hala noktalı virgül varsa, sayının soluna ulaştık, bu nedenle 10'a tekrar bölerek ondalık noktasının arkasına sıfır ekleyeceğiz. Bu, kalanların her birini ;a ile değiştirerek kolayca yapılabilir 0, çünkü bunlar zaten ondalık noktadan hemen sonradır.

yup , 5 bayt

|0~-e

Çevrimiçi deneyin! Bu, yığının tepesinden girdi alır ve yığının üstüne çıktı bırakır. TIO bağlantısı yalnızca tamsayı girişi yapabilen komut satırı argümanlarından girdi alır.

açıklama

yup sadece birkaç operatöre sahip. Bu cevapta kullanılanlar ln (x) (ile temsil edilir |), 0 () (sabit, nilary işlevi dönen 0), - (çıkarma) ve exp (x) (ile temsil edilir e) şeklindedir. ~yığındaki ilk iki üyeyi değiştirir.

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

Bu kimliği kullanır

ki bunun anlamı

LOLCODE , 63 , 56 bayt

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

@DevRicher sayesinde 7 bayt kurtarıldı!

Bu, 'r' fonksiyonunu tanımlar:

r 5.0

veya başka bir tane NUMBAR.

Çevrimiçi deneyin!

sed , 575 + 1 ( -rbayrak) = 723 718 594 588 576 bayt

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/

Çevrimiçi deneyin!

Not: mutlak değerin 1'den küçük olduğu değişkenler, .5yerine 0 gibi bir satır başı olmadan yazılmalıdır 0.5. Ayrıca ondalık sayısı eşittir , burada n(veren çok ondalık sayısı oldukça olan 13.0girdi olarak verilmesi daha ondalık yer verecek 13giriş için)

Bu benim PPCG'ye yaptığım ilk başvuru. Onbirinci dönüşte dönüşüm için fikirler bu şaşırtıcı cevaptan alınmıştır . @ Sedhoumara 'ya beni sed ile yönlendirdiğin için teşekkürler!

Bu kod, sonucu elde etmek için tekrarlanan uzun bölümler gerçekleştirir. Bölünme sadece ~ 150 bayt alır. Unary-ondalık dönüşümler en çok baytı alır ve diğer birkaç bayt negatif sayıları ve kayan nokta girişlerini desteklemeye gider.

açıklama

TIO hakkında açıklama

#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/

Düzenlemeler

• s:s/(.)/(.)/g:y/\1/\2/g:g Her ikame için 1 bayt tasarruf etmek (toplamda 5)
• "Sed golf oynamak için ipuçları" başlıklı güzel bir ondalık dönüştürücüye bakarak bir ton bayt kurtardı
• 6 bayt kurtarmak için eksi işareti etrafında dönen etrafında bazı ikameler değişti.
• Kullanılan \nyerine ;ayırıcı olarak, o zaman ben (Bana bunu gösterdiğin için @Riley ve @seshoumara sayesinde) 12 byte kaydetmek için oyuncu değişikliği "10 ile çarpın" kısaltmak başardı

JSFuck , 3320 bayt

JSFuck, JavaScript'in atomik bölümlerine dayanan ezoterik ve eğitici bir programlama stilidir. ()[]+!Kod yazmak ve yürütmek için yalnızca altı farklı karakter kullanır .

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

Çevrimiçi deneyin!

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

YAĞ , 1428 1420 bayt

Oh iyi. Ben de deneyebilirim diye düşündüm ve sonunda başardım. Sadece bir dezavantajı var: Yazması neredeyse uzun sürüyor.

Program, tüm 1 bayt dosya adlarına sahip birden fazla dosyaya ayrılmıştır (ve bayt hesaplamamda bir ek bayt sayılır). Dosyaların bazıları, OIL dilinin örnek dosyalarının bir parçasıdır, ancak bunları sürekli olarak çağırmanın gerçek bir yolu yoktur (henüz OIL'da arama yolu ya da böyle bir şey yoktur, bu yüzden onları standart bir kütüphane olarak görmüyorum), ancak Bu aynı zamanda (gönderim sırasında) dosyaların bir kısmının gerekli olduğundan çok daha fazla, ancak genellikle sadece birkaç byte kadar olduğu anlamına gelir.

Hesaplamalar 4 basamağa kadar doğrudur, ancak basit bir karşılık bile (örneğin giriş) 3 ) çok uzun zaman alır (5 dakikadan fazla). Test amacıyla, çalıştığını kanıtlamak için yalnızca birkaç saniye süren 2 basamağa kadar hassas küçük bir değişken de yaptım.

Büyük cevap için özür dilerim, keşke bir tür spoiler etiketi kullanabilseydim. İstenirse, bunun büyük kısmını gist.github.com adresine veya benzer bir şeye koyabilirim.

İşte başlıyoruz:, main217 bayt (dosya adı bayt için sayılmaz):

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 (verilen bir dizenin verilen başka bir dizgede olup olmadığını kontrol eder), 74 + 1 = 75 bayt:

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 (verilen iki dizgiyi birleştirir), 20 + 1 = 21 bayt:

5
0
5
1
13
0
2
0
4
0

c (bir sembol verildiğinde, verilen dizgiyi ilk çıkışında böler), 143 + 1 = 144 bayt (bu açıkçası hala golf oynamaktadır):

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 (bir dize verilirse ilk 4 karakteri alır), 22 + 1 = 23 bayt:

5
0
12
0
20
13
21
4

4

e (üst düzey bölüm (ancak sıfır bölüm tehlikesiyle)), 138 + 1 = 139 bayt:

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 (bir nokta 4 pozisyonunu sağa hareket ettirir; "10000'e" böler "), 146 + 1 = 147 bayt:

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 (bir dizenin belirli bir karakterle başlayıp başlamadığını kontrol eder), 113 + 1 = 114 bayt:

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 (belirli bir dizginin ilk karakteri dışında her şeyi döndürür), 41 + 1 = 42 bayt:

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

0
4
0

i (iki sayıyı çıkarır), 34 + 1 = 35 bayt:

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

j (her durumda çalışmayan düşük seviyeli bölüm), 134 + 1 = 135 bayt:

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 (çarpma), 158 + 1 = 159 bayt:

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 (mutlak değeri döndür), 58 + 1 = 59 bayt:

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

0
6
10

m (ek), 109 + 1 = 110 bayt:

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 bayt

%

%girişinin karşılığını veren bir fonksiyondur. Bu şekilde çalıştırabilirsin

   % 2
0.5

Taksi , 467 bayt

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.

Çevrimiçi deneyin!

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 bayt / tuş vuruşları

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

V geriye dönük olarak uyumlu olduğundan, çevrimiçi olarak deneyebilirsiniz!

x86_64 Linux makine dili, 5 bayt

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

Bunu test etmek için, aşağıdaki C programını derleyip çalıştırabilirsiniz.

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

Çevrimiçi deneyin!

C, 15 12 bayt

#define f 1/

Çevrimiçi deneyin!

16 13 bayt, eğer tamsayı girişi de gerekiyorsa:

#define f 1./

Böylece arayabilirsin f(3) yerine f(3.0).

Çevrimiçi deneyin!

3 byte golf oynadığı için @hvd'a teşekkürler!

MATLAB / Octave, 4 bayt

@inv

(Adında bir fonksiyon kolu oluşturur anskadar) yerleşik invfonksiyonu

Çevrimiçi Demo

05AB1E , 1 bayt

z

Çevrimiçi deneyin!

z # pop a  push 1 / a

GNU sed , 377 362 + 1 (r bayrağı) = 363 bayt

Uyarı: Program çalışmaya çalışırken tüm sistem belleğini tüketir ve bitirmek için beklediğinizden daha fazla zamana ihtiyaç duyar! Bir açıklama ve hızlı, ancak daha az kesin bir versiyon için aşağıya bakınız.

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:

Bu Martin Ender tarafından Retina cevabı dayanmaktadır . Saydım\t2. satırdan değişmez bir sekme (1 bayt) olarak .

En büyük katkım, ondalık basamağından düz unary'a (satır 2) ve tam tersine (satır 5) dönüştürme yöntemine. Bunu yapmak için gereken kodun boyutunu (bir araya getirilen ~ 40 byte kadar), önceki bir ipucunda gösterilen yöntemlere kıyasla önemli ölçüde azaltmayı başardım . Ayrıntılarla ayrı bir ipucu cevabı oluşturdum , burada snippet'leri kullanmaya hazırım. 0'ın giriş olarak izin verilmediğinden, birkaç bayt daha kaydedildi.

Açıklama: bölme algoritmasını daha iyi anlamak için önce Retina cevabını okuyun.

Program teorik olarak doğrudur, bu kadar çok hesaplama kaynağı tüketmesinin nedeni, bölme adımının girdiye bağlı olarak az çok binlerce kez çalıştırılması ve kullanılan regex'in geriye dönük bir kabusa yol açmasıdır. Hızlı versiyon hassasiyeti azaltır (böylelikle bölme adımlarının sayısı) ve geri izlemeyi azaltmak için regex'i değiştirir.

Maalesef, sed'nin, bir geri dönüşün Retina'da olduğu gibi bir desene kaç kez doğrudan girdiğini doğrudan hesaplayan bir yöntemi yoktur.

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

Programın hızlı ve güvenli bir sürümü için, ancak daha az kesin, bunu çevrimiçi deneyebilirsiniz .

Japt , 2 bayt

Bariz bir çözüm olacaktır

1/U

Bu, kelimenin tam anlamıyla 1 / input. Ancak, daha iyisini yapabiliriz:

pJ

Bu, eşdeğerdir input ** Jve Jvarsayılan olarak -1 olarak ayarlanır.

Çevrimiçi deneyin!

Eğlenceli gerçek: pgüç işlevi gibi, qkök işlevi de ( p2= **2, q2= **(1/2)); Bu, o qJzamandan beri -1 == 1/-1ve bu nedenle de işe yarayacağı anlamına gelir x**(-1) == x**(1/-1).

Javascript ES6, 6 bayt

x=>1/x

Çevrimiçi deneyin!

Javascript varsayılan olarak kayan nokta bölmesine göredir.

APL, 1 bayt

÷

÷Monadik fonksiyon olarak kullanıldığında karşılıklı hesaplar. Çevrimiçi deneyin!

Dyalog Classic karakter kümesini kullanır.

Çedar , 5 bayt

1&(/)

Çevrimiçi deneyin!

Bu &, bir fonksiyona bir argüman bağlayan kullanır . Bu durumda, argüman için bize veren 1, sol tarafına bağlı . Bu 1 bayt kanonikten daha kısadır ./1/xxx->1/x

Alternatif olarak, yeni sürümlerde:

(1:/)

Java 8, 6 bayt

x->1/x

Hemen hemen JavaScript cevabı ile aynı .

MATL , 3 bayt

l_^

MATL Online'da deneyin

açıklama

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

Python, 12 bayt

lambda x:1/x

13 bayt için bir tane:

(-1).__rpow__

14 bayt için bir tane:

1 .__truediv__

Mathematica, 4 bayt

1/#&

Kesin bir rasyonel verirseniz tam bir rasyonel ve kayar nokta bir sonuç verirseniz bir kayar nokta sonucu sağlar.

ZX Spektrumu BASIC, 13 bayt

1 INPUT A: PRINT SGN PI/A

Notlar:

• Her satır, satır numarası için 2 bayt, satır uzunluğu için 2 bayt ve yeni satır için 1 bayt tutar
• Sayısal değişmezler ayrıştırma süresinde ikili değere dönüştürülür, fazladan 6 bayta mal olur, böylece SGN PIdeğişmez yerine kullanılır 1.
• Anahtar kelimeler her biri 1 bayt alır.

17 bayt için ZX81 sürümü:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 bayt

(1/)

Çevrimiçi deneyin!

R, 8 bayt

1/scan()

Oldukça basit. Doğrudan girişin tersini verir.

Başka, ancak 1 bayt daha uzun bir çözüm olabilir: scan()^-1veya scan()**-1ek bir bayt için bile . Hem ^ve **güç sembolü.

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

Ans⁻¹

Timtech sayesinde -1 bayt .

-3 bayt ile AnsГригорий Перельман sayesinde .

Ans ve ⁻¹ vardır tek baytlı simgeler .

TI-Basic, değerlendirilen son değeri örtülü olarak döndürür ( Ans⁻¹).

Jöle , 1 bayt

İ

Çevrimiçi deneyin!

C, 30 bayt

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