หมายเหตุ: นี่คือตำรวจ 'กระทู้ที่หนึ่งควรโพสต์รหัสสัญญาณรบกวน นี่คือเธรดของโจรที่แหล่งแตกที่ควรโพสต์และเชื่อมโยงกับคำตอบของตำรวจ

ภารกิจ:เขียนโปรแกรมที่ปลอดภัยที่สั้นที่สุดซึ่งคูณสแควร์รูทของจำนวนเต็มnด้วยกำลังสองของn

นี่คือตำรวจและโจรดังนั้นกฎคือ:

• ในคำตอบของคุณให้โพสต์ซอร์สโค้ดเวอร์ชันที่มีสัญญาณรบกวนของคุณ (ตัวอักษรควรเขียนตามลำดับใด ๆ ) รุ่นที่มีสัญญาณรบกวนไม่ควรทำงาน!
• คุณสามารถรับอินพุตด้วยวิธีมาตรฐานใด ๆ ก็ได้เช่นเดียวกันสำหรับเอาต์พุต ห้ามใช้ Hardcoding
• หลังจากรหัสถูกถอดรหัสโดยโจร (หากเกิดเหตุการณ์นี้) คุณต้องพูดถึงว่ารหัสของคุณถูกถอดรหัสในชื่อของคุณและเพิ่มสปอยเลอร์ในร่างกายของคำตอบของคุณด้วยรหัสที่แน่นอนของคุณ
• เช่นเดียวกับคำตอบที่ปลอดภัย (พูดถึงว่าปลอดภัยและเพิ่มสปอยเลอร์ )
• รหัสนี้ถือว่าปลอดภัยหากไม่มีใครถอดรหัสได้ใน 5 วันหลังจากโพสต์และคุณสามารถระบุได้ในชื่อเรื่อง
• คุณต้องระบุภาษาการเขียนโปรแกรมของคุณ
• คุณควรระบุจำนวนไบต์ของคุณ
• คุณต้องระบุกลไกการปัดเศษในคำตอบของคุณ (ดูด้านล่าง)

คุณสามารถสันนิษฐานได้ว่าผลลัพธ์ต่ำกว่า 2 ³²และnนั้นเป็นค่าบวกเสมอ หากผลลัพธ์เป็นจำนวนเต็มคุณต้องส่งคืนค่าที่แน่นอนโดยมีหรือไม่มีจุดทศนิยม มิฉะนั้นความแม่นยำทศนิยมขั้นต่ำจะเป็นทศนิยม 3 ตำแหน่งพร้อมกลไกการปัดเศษใด ๆ ที่คุณเลือก แต่สามารถรวมได้มากกว่า คุณต้องระบุกลไกการปัดเศษในคำตอบของคุณ คุณไม่ได้รับอนุญาตให้ส่งคืนเป็นเศษส่วน (เศษ, คู่ส่วน - ขออภัย, Bash!)

ตัวอย่าง:

In -> Out

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

คำตอบที่ปลอดภัยที่สั้นที่สุดภายในสิ้นเดือนเมษายนจะถูกพิจารณาว่าเป็นผู้ชนะ

05AB1E, 20 ไบต์ - ปลอดภัย

อีกวิธีที่แตกต่างอย่างสิ้นเชิงจากคำตอบก่อนหน้าของฉัน

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

ไม่มีการปัดเศษ

ตัวอย่างการวิ่ง

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

ฉันไม่สงสัยเลยว่า @Emigna กำลังจะแตกมันในระยะเวลาอันสั้น แต่ก็ต้องลอง! :-D

วิธีการแก้

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

นี่คือการใช้ความจริงที่ว่าลำดับนี้:

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

ลู่เข้าสู่ sqrt (x) และรวดเร็วเป็นสองเท่าในที่นั้น (ขออภัยไม่พบวิธีจัดรูปแบบสมการทางคณิตศาสตร์ใน PCG)

คำอธิบายโดยละเอียด

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)

ลองออนไลน์!

Python 3 , 44 ไบต์ ( แตก )

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

ไม่มีการปัดเศษ ความแม่นยำจุดลอยตัว

MATL , 12 ไบต์ ( แตกโดย @tehtmi )

'Un&0P'/^:+1

ไม่มีการปัดเศษ ใช้จุดลอย

โซลูชันที่ตั้งใจ (แตกต่างจากที่พบโดย @tehtmi):

:&+n10U'P'/^

คำอธิบาย

:&+ % 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 ไบต์ ( ถอดรหัสโดย @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

สังเกตช่องว่างที่จุดเริ่มต้น ไม่มีการปัดเศษ แต่ใช้ตัวเลขทศนิยมเพื่อความแม่นยำจะถูก จำกัด

Perl, 42 ไบต์ (ปลอดภัย)

มีโค้ดและ-pแฟล็ก41 ไบต์(ไม่มีแฟล็กอื่น)

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

ผลลัพธ์จะไม่ถูกปัดเศษ (หรือค่อนข้างกลมถึงจุดเดียวกัน Perl จะมีการปัดเศษขึ้นโดยทำ $_ = (sqrt $_) * ($_ ** 2) )

วิธีการแก้:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(โดยไม่ต้อง\ก่อน&- สปอยเลอร์ markdown ดูเหมือนจะไม่ชอบ$ตามด้วย&)
ลองออนไลน์!

คำอธิบาย:

.i44<4}{|~เป็น$_**2*sqrtแต่กับตัวละครทุกตัวที่ถูกแทนที่ด้วยตัวละครที่มีรหัส ASCII + 10 (รหัส ASCII ของ$คือ36ดังนั้นจึงกลายเป็น.ที่มีรหัส ASCII 46ฯลฯ )
วัตถุประสงค์s/./chr-10+ord$\&/greคือเพื่อยกเลิกการเปลี่ยนแปลงนี้: มันจะแทนที่ตัวละครแต่ละตัวด้วยตัวละครที่มีรหัส ASCII 10 ที่ต่ำกว่า ( chr-10+ord$\&อาจจะเป็นที่ชัดเจนเป็นchr(ord($\&)-10)ที่chrส่งกลับตัวอักษรที่สอดคล้องกับรหัส ASCII และordส่งกลับรหัส ASCII ที่สอดคล้องกับตัวอักษร)
ในที่สุดevalประเมินสตริงนี้และคำนวณผลซึ่งถูกเก็บไว้ใน$_ซึ่งจะถูกพิมพ์โดยปริยายที่ปลายขอบคุณ-pธง

อ็อกเทฟ 43 ไบต์ (ปลอดภัย)

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

นี่คือสคริปต์ที่ต้องการอินพุตจากบรรทัดคำสั่ง (ไม่ใช่ฟังก์ชั่น) มันเป็นความแม่นยำจุดลอยตัว (ดังนั้นจึงไม่มีการปัดเศษ)

วิธีการแก้:

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

คำอธิบาย:

eval( <string> ) % Evaluated the string inside the brackets and executes it
ทุกสิ่งที่อยู่ในevalสายจะถูกประเมินเป็น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'

การเพิ่มเวกเตอร์แรกลงในสตริงนี้จะแปลงเป็นเวกเตอร์จำนวนเต็ม:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalแปลงโดยปริยายให้เป็นสตริงและตัวเลขเหล่านี้จะเกิดขึ้นเมื่อ: input('')^2.5

C, 50 ไบต์ ( ถอดรหัสโดย fergusq )

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

ใช้การปัดเศษ IEEE754 มาตรฐาน ตามที่ระบุไว้โดยคำตอบของ fergusq อาจต้อง-lmขึ้นอยู่กับคอมไพเลอร์ของคุณ

Mathematica 131 ไบต์ที่ไม่ใช่การแข่งขัน ?, แตก

สิ่งนี้ได้รับการถอดรหัสโดย@ lanlock4 ! อย่างไรก็ตามฉันยังคงมีจุดเชื่อมต่ออินเทอร์เน็ตเพื่อมอบให้กับผู้ที่พบวิธีการแก้ปัญหาเดิมที่ตัวละครทุกตัวมีความจำเป็นจริง ๆ ....

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

นี่เป็นปริศนา แม้ว่าคุณอาจใช้ตัวละครด้านบนตามที่คุณต้องการได้ แต่ฉันตั้งใจจะให้คำตอบทำตามแบบฟอร์ม

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

โดยที่บรรทัดแรกและบรรทัดที่สามเป็นเพียง wrapper เพื่อทำการปัดเศษและแสดงผลตามกฎหมาย (มันเขียนทุกเอาต์พุตไปยังตำแหน่งทศนิยมสามตำแหน่งที่ถูกปัดเศษ) และบรรทัดที่สองคือเวอร์ชันที่แปลงสัญญาณของความกล้าของรหัส ตัวอย่างผลลัพธ์:

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

(Mathematica ไม่ใช่ซอฟต์แวร์ฟรี แต่มีWolfram sandboxซึ่งเป็นไปได้ที่จะทดสอบโค้ดในปริมาณเล็กน้อยตัวอย่างเช่นการตัดและวางโค้ด

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

กำหนดฟังก์ชั่นซึ่งคุณสามารถเรียกเช่นนั้นf@6หรือf[9]ที่จะทำสิ่งเดียวกันกับรุ่น unscrambled ของรหัสข้างต้น ดังนั้นสิ่งนี้จะต้องไม่ใช่การแข่งขันจริง ๆ ?)

Swift - 64 ไบต์ (ปลอดภัย)

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

ไม่มีการปัดเศษและแสดงผล.0ถึงแม้ว่าจะเป็นจำนวนเต็ม

Haskell, 16 ไบต์ ( แคร็กโดย @nimi )

()*...25=eglopxx

ไม่มีการปัดเศษโดยเฉพาะ

R, 28 ไบต์ ( ถอดรหัสโดย @Flounderer )

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

ความแม่นยำจุดลอยตัวมาตรฐาน R

C #, 172 ไบต์ ( ถอดรหัสโดย SLuck49 )

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

รหัสนี้เป็นโปรแกรมแบบเต็ม

ในตอนแรกมีอักขระเว้นวรรคเจ็ดตัว

อินพุตถูกอ่านจาก STDIN และพิมพ์ไปยัง STDOUT ผลลัพธ์อยู่ในdoubleไม่มีการปัดเศษ

รหัสดั้งเดิมไม่ถูกปรับแต่ง:

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 ไบต์ ( แตกโดย @IlmariKaronen )

****..22255666=>____

ความแม่นยำจาวาสคริปต์มาตรฐาน

Python 2, 60 Bytes ( ถอดรหัสโดย @notjagan )

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

ไม่มีการปัดเศษที่เกี่ยวข้อง แม่นยำถึง 10 หลักทศนิยม

Python 3.6, 59 ไบต์

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

ไม่มีการปัดเศษ ความแม่นยำจุดลอยตัว

Haskell, 64 ไบต์, ( ถอดรหัสโดย Laikoni )

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

การดำเนินการจุดลอยน้ำมาตรฐาน Haskell

รุ่นเดิมของฉันคือ:

สินค้า. ((($ Succ $ $ cos 0) (พลิก (**).) [id, recip])). พลิก (ID)

ฟูเรียร์ , 124 119 ไบต์

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

ไม่มีช่องว่างหรืออักขระขึ้นบรรทัดใหม่

รากที่สองจะถูกปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุดเนื่องจากดูเหมือนว่าฟูริเยร์จะไม่จัดการกับสิ่งอื่นนอกจากจำนวนเต็ม (และเนื่องจาก @ATaco ได้รับอนุญาตฉันหวังว่านี่จะโอเค)

แก้ไขข้อผิดพลาดในการแก้ไขหากคุณได้ทำการถอดรหัสแล้ว

รับรู้ว่าฉันเข้าใจผิดส่วนหนึ่งของรหัสและใช้อักขระมากกว่าที่ฉันต้องการ

ถ้าฉันพลาดอะไรก็บอกให้ฉันรู้

แจ้ง 7 , 71 ไบต์ ( ถอดรหัสโดย @Ilmari Karonen )

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

รหัสประกอบด้วย 17 ช่องว่างและ 2 บรรทัดใหม่ นี่เป็นโปรแกรม Infrom 7 เต็มรูปแบบที่กำหนดฟังก์ชั่นที่พิมพ์ผลลัพธ์ด้วยความแม่นยำทศนิยม 5 ตำแหน่ง

R, 19 ไบต์(ถอดรหัสโดย @Steadybox)

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

การปัดเศษแบบมาตรฐาน

R, 33 ไบต์(ถอดรหัสโดย @plannapus)

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

R, 31 ไบต์(ถอดรหัสโดย @plannapus)

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

อ็อกเทฟ 30 ไบต์ (ปลอดภัย)

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

ค่อนข้างง่ายกว่าอันแรกของฉัน ไม่ควรยากเกินไป แต่หวังว่ามันจะเป็นปริศนาที่สนุก

โอห์ม 11 ไบต์

M ⁿ¡D¼½;+1I

ใช้กับ-cธง ใช้การเข้ารหัส CP-437

OCaml , 13 ไบต์ ( ถอดรหัสโดย @Dada )

2*fn-5f>f*u .

ไม่มีการปัดเศษ (ภายในขอบเขต IEEE 754)

Javascript, 123 ไบต์, แคร็กโดย notjagan

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

รหัสนี้เป็นฟังก์ชั่นเต็มรูปแบบ

มีอักขระเว้นวรรคหนึ่งตัวที่จุดเริ่มต้นของรายการอักขระ

การปัดเศษของคำตอบนี้คือความแม่นยำจุดลอยสำหรับ Javascript ความถูกต้องอยู่ภายใน 10 ^ -6 สำหรับทุกคำตอบ

สั้นลงเพราะความแม่นยำไม่จำเป็นต้องได้รับการบำรุงรักษาค่อนข้างสูงอย่างที่ฉันคิดไว้

ฉันรู้ว่ามันจะง่ายกว่าในการแก้ปัญหามากกว่าที่ฉันทำไว้ในตอนแรก แต่มันอยู่ที่นั่นแล้ว: พี

รหัสเริ่มต้น:

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

วิธีการของนิวตันใช้ 5 ครั้งจากพลังที่อยู่ใกล้ที่สุดเท่ากับ 2

Python 3.6 - 52 ไบต์ ( ถอดรหัสโดย @xnor )

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

การปัดเศษ Python มาตรฐาน

Ruby, 35 ไบต์ ( ถอดรหัสโดยxsot )

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

ไม่มีการปัดเศษ ความแม่นยำจุดลอยตัว

05AB1E , 47 ไบต์

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

ไม่ปัดใช้ความแม่นยำของจุดลอย

CJam, 8 ไบต์ ( แคร็กโดย E n mig m na )

WYdYl##+

ไม่มีการปัดเศษ ใช้ความแม่นยำสองเท่า

R, 32 ไบต์ ( แตกโดย @plannapus )

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

ความแม่นยำจุดลอยตัวมาตรฐาน

Excel, 26 ไบต์

=(())*//11122AAAIINPQRSST^

ไม่มีการปัดเศษ

หมายเหตุ: เนื่องจาก Excel เป็นซอฟต์แวร์ที่ต้องชำระเงินจึงสามารถใช้งานได้ฟรีใน LibreOffice

RProgN 2 , 6 ไบต์ ( ถอดรหัสโดย @notjagan )

š2]^*\

ไม่มีการปัดเศษแสดงทศนิยมจำนวนมาก ไม่แสดงรายการใด ๆ สำหรับโซลูชันจำนวนเต็ม