Lưu ý: Đây là chủ đề của cảnh sát , nơi người ta nên đăng mã bị xáo trộn. Đây là chủ đề của tên cướp nơi nguồn bị bẻ khóa nên được đăng và liên kết với câu trả lời của cảnh sát.

Nhiệm vụ: Viết chương trình an toàn ngắn nhất nhân số căn bậc hai của một số nguyên n với bình phương n

Đây là cảnh sát và kẻ cướp , vì vậy các quy tắc là:

• Trong câu trả lời của bạn, hãy đăng một phiên bản được xáo trộn của mã nguồn của bạn (các ký tự phải được viết theo bất kỳ thứ tự nào). Phiên bản tranh giành không nên hoạt động!
• Bạn có thể lấy đầu vào theo bất kỳ cách tiêu chuẩn nào, tương tự với đầu ra. Mã hóa bị cấm
• Sau khi mã bị bẻ khóa bởi kẻ cướp (nếu điều này xảy ra), bạn phải đề cập rằng mã của bạn đã bị bẻ khóa trong tiêu đề của bạn và thêm một spoiler vào cơ thể câu trả lời của bạn với mã chính xác của bạn
• Điều tương tự cũng áp dụng cho các câu trả lời an toàn (đề cập rằng nó an toàn và thêm spoiler )
• Mã được coi là an toàn nếu không có ai bẻ khóa trong 5 ngày sau khi đăng nó và bạn có thể tùy ý chỉ định rằng trong tiêu đề
• Bạn phải xác định ngôn ngữ lập trình của bạn
• Bạn nên chỉ định số byte của bạn
• Bạn phải nêu cơ chế làm tròn trong câu trả lời của bạn (xem bên dưới)

Bạn có thể giả sử rằng kết quả thấp hơn 2 ³² và n luôn dương. Nếu kết quả là một số nguyên, bạn phải trả về giá trị chính xác có hoặc không có dấu thập phân; mặt khác, độ chính xác thập phân tối thiểu sẽ là 3 chữ số thập phân với bất kỳ cơ chế làm tròn nào bạn chọn, nhưng có thể bao gồm nhiều hơn. Bạn phải nêu cơ chế làm tròn trong câu trả lời của bạn. Bạn không được phép trả về dưới dạng phân số (cặp tử số, mẫu số - xin lỗi, Bash!)

Ví dụ:

In -> Out

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

Câu trả lời ngắn nhất an toàn vào cuối tháng 4 sẽ được coi là người chiến thắng.

05AB1E, 20 byte - an toàn

Một cách tiếp cận hoàn toàn khác với câu trả lời trước đây của tôi.

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

Không làm tròn số.

Ví dụ chạy

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

Tôi không nghi ngờ gì nữa @Emigna sẽ bẻ khóa nó trong nháy mắt, nhưng eh, người ta phải thử! : -D

Dung dịch

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

Điều này đang sử dụng thực tế là trình tự này:

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

hội tụ đến sqrt (x) và nhanh chóng về cơ bản (xin lỗi, không tìm thấy cách định dạng phương trình toán học trong PCG).

Giải thích chi tiết

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)

Hãy thử trực tuyến!

Python 3 , 44 byte ( đã bẻ khóa )

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

Không làm tròn số. Điểm nổi chính xác.

MATL , 12 byte ( bị bẻ khóa bởi @tehtmi )

'Un&0P'/^:+1

Không làm tròn số; sử dụng điểm nổi.

Giải pháp dự định (khác với giải pháp được tìm thấy bởi @tehtmi):

:&+n10U'P'/^

Giải trình

:&+ % 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 byte ( Được bẻ khóa bởi @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

Lưu ý không gian lúc đầu. Không làm tròn, nhưng nó sử dụng số dấu phẩy động nên độ chính xác bị hạn chế.

Perl, 42 byte (An toàn)

Có 41 byte mã và -pcờ (không có cờ nào khác).

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

Kết quả không được làm tròn (hoặc được làm tròn đến cùng một điểm mà Perl sẽ làm tròn bằng cách thực hiện $_ = (sqrt $_) * ($_ ** 2)).

Dung dịch:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(không có \trước &spoiler - markdown dường như không thích $theo sau &)
Hãy thử trực tuyến!

Giải trình:

.i44<4}{|~là $_**2*sqrtnhưng với tất cả các nhân vật thay thế bằng nhân vật với mã ascii của nó + 10 (mã ascii của $là 36, vì vậy nó trở nên .có ascii code đang 46, vv).
Mục đích của s/./chr-10+ord$\&/gresau đó là hoàn tác việc chuyển đổi này: nó thay thế từng ký tự bằng ký tự với mã ascii 10 thấp hơn. ( chr-10+ord$\&Có lẽ là rõ ràng hơn như chr(ord($\&)-10)nơi chrtrả về nhân vật tương ứng với một mã ascii, và ordtrả về mã ascii tương ứng với một nhân vật).
cuối cùng, evalđánh giá chuỗi này, và do đó tính kết quả, được lưu trữ $_, được in ngầm ở cuối nhờ -pcờ.

Octave, 43 byte (An toàn)

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

Đây là một tập lệnh yêu cầu đầu vào từ dòng lệnh (nó không phải là một chức năng). Đó là độ chính xác của dấu phẩy động (vì vậy không làm tròn số).

Dung dịch:

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

Giải trình:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Tất cả mọi thứ trong evalcuộc gọi được đánh giá như input('')^2.5

thế nào?

-[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'

Thêm vectơ đầu tiên vào chuỗi này sẽ chuyển đổi nó thành vectơ số nguyên:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalngầm chuyển đổi nó thành một chuỗi và những con số này thực sự là: input('')^2.5

C, 50 byte ( Bị bẻ khóa bởi fergusq )

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

Sử dụng làm tròn chuẩn IEEE754. Như được lưu ý bởi câu trả lời của fergusq, có thể yêu cầu -lmtùy thuộc vào trình biên dịch của bạn.

Mathicala, 131 byte, không cạnh tranh?, Đã bị bẻ khóa

Điều này đã bị bẻ khóa bởi @ lanlock4 ! Tuy nhiên, tôi vẫn có các điểm internet để ban cho một người tìm ra giải pháp ban đầu, nơi tất cả các nhân vật thực sự cần thiết ....

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

Điều này được dự định như một câu đố. Mặc dù bạn có thể sử dụng các ký tự trên theo cách bạn muốn, tôi chắc chắn có ý định cho câu trả lời theo mẫu

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

trong đó các dòng đầu tiên và thứ ba chỉ là một trình bao bọc để làm tròn và hiển thị hợp pháp (nó ghi mọi đầu ra thành chính xác ba chữ số thập phân, được làm tròn) và dòng thứ hai là phiên bản được xáo trộn của các đoạn mã. Đầu ra mẫu:

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

(Mathematica là phần mềm không miễn phí, nhưng có một hộp cát Wolfram nơi có thể kiểm tra số lượng mã khiêm tốn. Ví dụ: cắt và dán mã

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

định nghĩa một hàm mà sau đó bạn có thể gọi như f@6hoặc f[9], nó thực hiện tương tự như phiên bản mã được xắp xếp lại ở trên. Vì vậy, điều này thực sự phải không cạnh tranh?)

Swift - 64 byte (An toàn)

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

Không làm tròn và hiển thị .0ngay cả khi kết quả là số nguyên.

Haskell, 16 byte ( Được bẻ khóa bởi @nimi )

()*...25=eglopxx

Không làm tròn đặc biệt

R, 28 byte ( Được bẻ khóa bởi @Flounderer )

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

Độ chính xác điểm R chuẩn.

C #, 172 byte ( Được bẻ khóa bởi SLuck49 )

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

Mã này là một chương trình đầy đủ.

Có bảy nhân vật không gian khi bắt đầu.

Đầu vào được đọc mẫu STDIN và được in thành STDOUT. Kết quả là trong double, không làm tròn số.

Mã gốc không được mã hóa:

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 byte ( Được bẻ khóa bởi @IlmariKaronen )

****..22255666=>____

Độ chính xác JavaScript chuẩn.

Python 2, 60 byte ( Được bẻ khóa bởi @notjagan )

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

Không làm tròn liên quan. Chính xác đến 10 chữ số thập phân.

Python 3.6, 59 byte

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

Không làm tròn số. Điểm nổi chính xác.

Haskell, 64 byte, ( bị bẻ khóa bởi Laikoni )

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

Hoạt động điểm nổi Haskell tiêu chuẩn.

Phiên bản gốc của tôi là:

sản phẩm. ((($ succ $ cos $ 0) (flip (**).) [id, người nhận])). flip (id)

Fourier , 124 119 byte

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

Không có khoảng trắng hoặc ký tự dòng mới.

Căn bậc hai được làm tròn đến số nguyên gần nhất vì Fourier dường như không xử lý bất cứ thứ gì ngoài số nguyên (và vì @ATaco có sự cho phép, tôi hy vọng điều này ổn)

đã sửa một lỗi chỉnh sửa, nếu bạn đã bẻ khóa này, thì trước đó là chức năng

Nhận ra rằng tôi đã hiểu nhầm một phần của mã và đang sử dụng nhiều ký tự hơn mức tôi cần

Nếu tôi bỏ lỡ bất cứ điều gì hãy cho tôi biết

Thông báo 7 , 71 byte ( Được bẻ khóa bởi @Ilmari Karonen )

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

Mã bao gồm 17 khoảng trắng và 2 dòng mới. Đây là chương trình Infrom 7 đầy đủ xác định chức năng in kết quả với độ chính xác là 5 chữ số thập phân.

R, 19 byte (Được bẻ khóa bởi @Steadybox)

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

Làm tròn tiêu chuẩn

R, 33 byte (Được bẻ khóa bởi @plannapus)

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

R, 31 byte (Được bẻ khóa bởi @plannapus)

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

Octave, 30 byte (An toàn)

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

Một chút đơn giản hơn so với cái đầu tiên của tôi. Không nên quá khó, nhưng hy vọng đó là một câu đố vui.

Ồ, 11 byte

M ⁿ¡D¼½;+1I

Sử dụng với -ccờ. Sử dụng mã hóa CP-437.

OCaml , 13 byte ( Được bẻ khóa bởi @Dada )

2*fn-5f>f*u .

Không làm tròn số (trong phạm vi IEEE 754).

Javascript, 123 byte, bị bẻ khóa bởi notjagan

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

Mã này là một chức năng đầy đủ

Có một nhân vật không gian ở đầu danh sách các nhân vật

Làm tròn câu trả lời này là độ chính xác của dấu phẩy động cho Javascript, độ chính xác nằm trong khoảng 10 ^ -6 cho mỗi câu trả lời.

Ngắn hơn vì độ chính xác không cần phải duy trì ở mức cao như tôi nghĩ.

Tôi đã nhận ra rằng nó sẽ dễ giải quyết hơn nhiều so với lúc đầu tôi đã làm nhưng nó đã ở đó: P

Mã ban đầu:

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

Phương pháp Newton, áp dụng 5 lần từ công suất gần nhất của 2

Python 3.6 - 52 byte ( Được bẻ khóa bởi @xnor )

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

Làm tròn Python chuẩn

Ruby, 35 byte (bị bẻ khóa bởi xsot )

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

Không làm tròn số. Điểm nổi chính xác.

05AB1E , 47 byte

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

Không tròn, sử dụng độ chính xác điểm nổi.

CJam, 8 byte (Được bẻ khóa bởi E n Mig m na )

WYdYl##+

Không làm tròn số. Sử dụng chính xác gấp đôi.

R, 32 byte ( Được bẻ khóa bởi @plannapus )

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

Độ chính xác điểm nổi chuẩn.

Excel, 26 byte

=(())*//11122AAAIINPQRSST^

Không làm tròn số.

Lưu ý: Vì Excel là phần mềm trả phí, nên phần mềm này cũng hoạt động trong LibreScript miễn phí

RProgN 2 , 6 byte ( Được bẻ khóa bởi @notjagan )

š2]^*\

Không làm tròn, hiển thị nhiều vị trí thập phân. Không hiển thị bất kỳ cho một giải pháp số nguyên.