Not: Bu, şifreli kodun girilmesi gereken polislerin ipliğidir. İşte çatlak kaynağın kaydedilmesi ve polisin cevabına bağlanması gereken soyguncuların ipliği .

Görev: En kısa yaz güvenli hangi çarpar bir tamsayı karekökünü programını n karesi ile n

Bu polis ve soyguncular , yani kurallar:

• Cevabınıza, kaynak kodunuzun şifreli bir versiyonunu gönderin (karakterler herhangi bir sırayla yazılmalıdır). Şifreli versiyon olmamalıdır çalışır!
• Herhangi bir standart şekilde girdi alabilirsiniz, aynı çıktı için de geçerlidir. Hard kodlama yasaktır
• Kod soyguncular tarafından çözüldükten sonra (bu olursa), kodunuzun başlığınızda kırıldığından bahsetmeli ve cevap kodunuzla cevabınızın gövdesine bir spoyler eklemelisiniz .
• Aynısı güvenli cevaplar için de geçerlidir (güvenli olduğunu belirtin ve spoiler ekleyin )
• Kodun gönderilmesinden sonraki 5 gün içinde kimse çatlamadıysa, kod güvenli kabul edilir ve isteğe bağlı olarak bunu başlığında belirtebilirsiniz.
• Programlama dilinizi belirtmelisiniz
• Bayt sayınızı belirtmelisiniz
• Cevabınızdaki yuvarlama mekanizmasını belirtmelisiniz (aşağıya bakınız)

Sonucun 2 ^32'den düşük olduğunu ve n'nin daima pozitif olduğunu varsayabilirsiniz . Sonuç bir tamsayıysa, tam değeri ondalık basamaklı veya ondalık basamağa döndürmeniz gerekir; Aksi halde, minimum ondalık kesinliği, seçtiğiniz herhangi bir yuvarlama mekanizmasına sahip 3 ondalık basamak olacaktır, fakat daha fazlasını içerebilir. Cevabınızdaki yuvarlama mekanizmasını belirtmelisiniz. Kesir olarak geri dönmenize izin verilmiyor (pay, payda çifti - pardon, Bash!)

Örnekler:

In -> Out

4 -> 32.0 (or 32)
6 -> 88.18163074019441 (or 88.182 following the rules above)
9 -> 243.0
25 -> 3125.0

Nisan ayının sonunda en kısa güvenli cevap kazanan olarak kabul edilecektir.

05AB1E, 20 bayt - güvenli

Önceki cevaplarımdan tamamen farklı bir yaklaşım.

****++/133DDFPTs}¹¹Ð

Yuvarlama yok.

Örnek çalıştırmalar

In   -> Out
0    -> 0
4    -> 32.0
6    -> 88.18163074019441
25   -> 3125.0
7131 -> 4294138928.896773

Hiç şüphem yok @Emigna bir anda onu kıracak, ama ha, denemek zorunda! :-D

Çözüm

D1TFÐ*D¹3*+s3*¹+/*}P

Bu, bu dizinin olduğu gerçeğini kullanıyor:

u_0 = 1, u_ {n + 1} = u_n * (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x)

sqrt (x) 'e yakınlaşır ve bu noktada kübik olarak hızlıdır (üzgünüm, PCG'de matematik denklemlerinin nasıl biçimlendirileceğini bulamadım).

Detaylı açıklama

D1TFÐ*D¹3*+s3*¹+/*}P
D1                   # Duplicate the input, then push a 1: stack is now [x, x, 1] (where x is the input)
  TF                 # 10 times (enough because of the cubic convergence) do
    Ð                # triplicate u_n
     *               # compute u_n ^ 2
      D              # and duplicate it
       ¹3*+          # compute u_n ^ 2 + 3 x
           s         # switch that last term with the second copy of u_n ^ 2
            3*¹+     # compute 3 u_n ^ 2 + x
                /    # compute the ratio (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x)
                 *   # compute u_n * (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x), i.e. u_{n+1}, the next term of the sequence
                  }  # end of the loop
                   P # compute the product of the whole stack, which at that point contains u_10 (a sufficiently good approximation of sqrt(x)), and the 2 copies of the input from the initial D: we get x ^ 2 * sqrt(x)

Çevrimiçi deneyin!

Python 3 , 44 bayt ( kırık )

'**:(((paraboloid / rabid,mad,immoral))):**'

Yuvarlama yok. Kayan nokta doğruluğu.

MATL , 12 bayt ( @tehtmi tarafından çatlak )

'Un&0P'/^:+1

Yuvarlama yok; kayan nokta kullanır.

Amaçlanan çözüm (@tehtmi tarafından bulunanlardan farklı):

:&+n10U'P'/^

açıklama

:&+ % Create a matrix of size n × n, where n is implicit input
n % Number of elements. Gives n^2
10U % 10 squared. Gives 100
'P' % 'P' (ASCII code 80)
/ % Divide. Gives 1.25
^ % Power. Implicit display

Röda , 28 bayt ( @tehtmi tarafından çatlak )

 (),.025^^cdfhnnnopprstuu{|}

Başlangıçtaki boşluğa dikkat edin. Yuvarlama yok, ancak kayan nokta sayıları kullanır, bu nedenle hassasiyet sınırlıdır.

Perl, 42 bayt (Güvenli)

41 bayt kod ve -pbayrak vardır (başka bayrak yoktur).

/"/4~~r..rso4r<_$4va=eg1de|i/h0-&$c={}l+"

Sonuç yuvarlanmaz (ya da yerine Perl'in yaptığı kadar yuvarladığı noktaya yuvarlanmış $_ = (sqrt $_) * ($_ ** 2)).

Çözüm:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
( \önce &- markdown spoyleri $takip etmekten hoşlanmıyor gibi görünüyor &)
Çevrimiçi deneyin!

Açıklama:

.i44<4}{|~olup $_**2*sqrt, ancak her bir karakterin ASCII kod ile karakter ile + 10 ikame ile (ASCII kod $olup 36, bu olur böylece .ASCII kod 46, vs.).
Bunun amacı, s/./chr-10+ord$\&/grebu dönüşümü geri almaktır: Her karakteri, karakter kodu yerine 10 düşük kodlu karakter ile değiştirir. ( chr-10+ord$\&Muhtemelen daha net chr(ord($\&)-10)burada chrbir ASCII koduna karşı gelen karakter verir ve ordbir karaktere tekabül eden ASCII kod döndürür).
Son olarak, evalbu dizgiyi değerlendirir ve böylece bayrakla $_örtük olarak basılmış olarak depolanan sonucu hesaplar -p.

Oktav, 43 bayt (Güvenli)

$'()*+,-/23579:[]aelnouv'*,-23:[]lu',-23]',

Bu komut satırından giriş gerektiren bir komut dosyasıdır (bir işlev değildir). Kayar nokta doğruluğu (yani yuvarlama yok).

Çözüm:

eval(-[5,-2:3,-3:2]+['nlouu*$$',39,']2/7'])

Açıklama:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Görüşme içindeki her şey Nasıleval değerlendirilir input('')^2.5

?

-[5,-2:3,-3:2] % A vector: [-5, 2, 1, 0, -1, -2, -3, 3, 2, 1, 0, -1, -2]
['nlouu**$$',39,']2/7'] % This is a string: nlouu**$ concatenated with the number
. % 39 (ASCII ']'), and ']2/7'. Thus, combined: 'nlouu**$$']2/7'

İlk dizgiyi bu dizgeye eklemek, tamsayı vektörüne
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evaldönüştürür : tam olarak bunu dizgeye dönüştürür ve bu sayılar şöyle olur: input('')^2.5

C, 50 bayt ( fergusq tarafından çatlak )

%(())   ,-12225;>\\aaabbdddeeefffllnoooprrttuuuuw{

Standart IEEE754 yuvarlama kullanır. Fergusq'un cevabında belirtildiği gibi -lm, derleyicinize bağlı olarak gerekebilir .

Mathematica, 131 bayt, rekabetçi olmayan ?, kırık

Bu edilmiş çatlatan @ lanlock4 ! Ancak, hala orijinal çözümü bulan, tüm karakterlerin gerçekte gerekli olduğu birisine ihsan edecek internet noktalarım var.

f[y_]:=With[{x=@@@@@@#####^^&&&(((()))){{}}111111,,+-/y},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

Bu bir bulmaca olarak tasarlanmıştır. Yukarıdaki karakterleri istediğiniz gibi kullanabilirsiniz, ancak cevabın formu takip etmesi kesinlikle gerekiyor.

f[y_]:=With[{x=
    @@@@@@#####^^&&&(((()))){{}}111111,,+-/y
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

burada birinci ve üçüncü satırlar, yuvarlamayı ve gösterimi yasal hale getirmek için yalnızca bir sarıcıdır (her çıktısını tam olarak üç ondalık basamağa yazar, yuvarlanır) ve ikinci satır kodun bağırsaklarının şifrelenmiş sürümüdür. Örnek çıktılar:

6 -> 88.182
9 -> 243.000
9999 -> 9997500187.497

(Mathematica özgür olmayan bir yazılımdır, ancak mütevazı miktarda kodu test etmenin mümkün olduğu bir Wolfram sanal alanı vardır . Örneğin, kodu kesme ve yapıştırma

f[y_]:=With[{x=
    y^2.5
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

Daha sonra f@6veya gibi çağırabileceğiniz f[9], yukarıdaki kodun şifrelenmemiş versiyonuyla aynı şeyi yapan bir fonksiyon tanımlar . Peki bu gerçekten rekabet etmemeli mi?)

Swift - 64 bayt (Güvenli)

prot Fdnufi;nooitamunc xetgru(->atl)Ior:n{tFn pg,F(ao.o25t)(w)l}

Yuvarlama yok ve .0sonuç bir tamsayı olsa bile görüntüler .

Haskell, 16 bayt ( @nimi tarafından çatlak )

()*...25=eglopxx

Belirli bir yuvarlama yok

R, 28 bayt ( @ Flounderer tarafından Cracked )

funny(p1)-tio(^*^)/pc(2)<p2;

Standart R kayan nokta doğruluğu.

C #, 172 bayt ( SLuck49 tarafından Cracked )

       (((((())))))***,,,,......1225;;;;;;<====>CFLMMMMMPPPRSSSSSWaaaaaaabbbbcccddddddeeeeeeeeeeegghiiiiiiiillllllmmnnnnnnnooooooooqqqqrrrssssssssstttttttttuuuuuuuvvwyy{{}}

Bu kod tam bir programdır.

Başlangıçta yedi tane boşluk karakteri var.

Giriş, STDIN formundan okunur ve STDOUT'a yazdırılır. Sonuç double, hiçbir yuvarlama yapılmamıştır.

Orijinal Kod ungolfed:

using System;
using S = System.Console;

class P
{
    static void Main()
    {
        var t = S.ReadLine();
        double q = int.Parse(t);
        Func<double, double, double> M = Math.Pow;
        S.Write(M(q, 2 * .25) * M(q * q, 1));
    }
}

JavaScript (ES7), 20 bayt ( @IlmariKaronen Cracked )

****..22255666=>____

Standart JavaScript hassasiyeti.

Python 2, 60 Bayt ( @notjagan tarafından Cracked )

 3n0)4  5)594p3(p5*5i9t4542)0/*((8(t.84- 90945 u)i*48/95n8r8

Yuvarlama dahil değil. 10 ondalık basamağa kadar doğru.

Python 3.6, 59 bayt

ba(,b5,d' (,a/([m:'-)oa)(bl*aadplma dba](r)d )l*d,:)*m:-mml

Yuvarlama yok. Kayan nokta doğruluğu.

Haskell, 64 bayt, ( Laikoni tarafından çatlak )

$$$$$$(((((())))))**,...0<<<>>>[]cccccdddeffiiiiilloopppprrsstuu

Standart Haskell kayan nokta işlemleri.

Orijinal versiyonum:

Ürün. ((($ sukk $ Cos $ 0) (Flip (**).) [kimlik, tilki kuyruğu])). Flip (id)

Fourier , 124 119 Bayt

((()))*******--011111<=>>>HHINNNN^^^eeehhhhkkkkmmmmmmmmmmmmmmmmossuuuuuuuuuuuuuuuuu{{{{{{{{{{}}}}}}}}}}~~~~~~~~~~~~~~~~

Beyaz boşluk veya yeni satır karakteri yok.

Karekök en yakın tam sayıya yuvarlanır, çünkü Fourier tamsayılardan başka bir şeyle ilgilenmiyor gibi görünüyor (ve @ATaco'nun izni olduğu için, umarım bu iyidir)

bir düzenleme hatası düzeltildi, eğer zaten bu durumu kırdıysanız, önceki işlevdeydi

Kodun bir bölümünü yanlış anladığımı farkettim ve ihtiyacım olandan daha fazla karakter kullanıyordum.

Eğer bir şeyi kaçırırsam bana haber ver

Bilgilendirme 7 , 71 bayt ( @Ilmari Karonen tarafından çatlak )

""()**-..:[]
                 RT
aaaabeeeffilmmnnnnnooooooqrrrrrssstuuy

Kod 17 boşluk ve 2 yeni satır içeriyor. Bu, sonucu 5 ondalık basamağa kadar hassas basan bir işlev tanımlayan tam bir Infrom 7 programıdır.

R, 19 bayt (@ Steadybox tarafından Cracked)

mensana(4*5*c(.1)):

Standart yuvarlama

R, 33 bayt (@ plannapus tarafından Cracked)

(rofl(17)^coins(2*e)/pisan(10))--

R, 31 bayt (@ plannapus tarafından çatlak)

h=f`l`u`n`c`t`i`o`n([],[])^(.9)

Oktav, 30 bayt (Güvenli)

(((((())))))**++/:@eeeiiijmsu~

Birincisinden biraz daha basit. Çok zor olmamalı, ama umarım eğlenceli bir bilmecedir.

Ohm, 11 bayt

M ⁿ¡D¼½;+1I

-cBayrak ile kullanın . CP-437 kodlamasını kullanır.

OCaml , 13 bayt ( @Dada tarafından çatlak )

2*fn-5f>f*u .

Yuvarlama yok (IEEE 754 kapsamında).

Javascript, 123 bayt, Notjagan tarafından Cracked

 """"""((((((((()))))))))********,--.....//2;;======>>Seeeeeeegggggggggggghhhhhhhhhhhilllllnnnnnnnnnnorrrsstttttttttttttu{}

Bu kod tam bir fonksiyondur

Karakter listesinin başında bir boşluk karakteri var

Bu cevabın yuvarlanması Javascript için kayan nokta kesinliğidir, her cevap için doğruluk 10 ^ -6 arasındadır.

Kısaltılmış, çünkü hassasiyetin düşündüğüm kadar yüksek tutulmasına gerek yoktu.

Çözmenin daha başlangıçta yaptığımdan daha kolay olacağını fark ettim ama zaten oradaydı: P

İlk kod:

g=t=>t-(t*t-n)/("le".length*t);e=h=>{n=h*h*h*h*h,s=2**(n.toString("ng".length).length/"th".length);return g(g(g(g(g(s)))))}

Newton yöntemi, 2'ye en yakın güçten 5 kez uygulandı

Python 3.6 - 52 bayt ( @xnor tarafından çatlak )

f=lambda x:x**125*77*8+8/5/((('aafoort.hipie.xml')))

Standart Python yuvarlama

Yakut, 35 bayt ( xsot tarafından çatlak )

'a'0-a<2<e<2<l<3<v<4<4<4<5<5<6>7{9}

Yuvarlama yok. Kayan nokta doğruluğu.

05AB1E , 47 bayt

)*.2555BFHIJJKKKPQRST``cgghilnstwx}«¹¹Áöž‚„…………

Yuvarlak değil, kayan nokta doğruluğu kullanır.

CJam, 8 bayt ( E n mig m na tarafından çatlak )

WYdYl##+

Yuvarlama yok. Çift hassasiyet kullanır.

R, 32 bayt ( @ plannapus tarafından Cracked )

i=na*0.5f*n(2*s*cos(t))*22*s*12u

Standart kayan nokta doğruluğu.

Excel, 26 bayt

=(())*//11122AAAIINPQRSST^

Yuvarlama yok.

Not: Excel yazılımı ödendiğinden, bu da ücretsiz LibreOffice'de çalışır.

RProgN 2 , 6 Bayt ( @notjagan tarafından Cracked )

š2]^*\

Yuvarlama yok, birçok ondalık basamak görüntüler. Bir tamsayı çözümü için herhangi bir görüntülemiyor.