Phần cướp

Phần cảnh sát có thể được tìm thấy ở đây .

Thử thách

Nhiệm vụ của bạn là vượt qua các đệ trình của cảnh sát trong cùng một ngôn ngữ và cùng một phiên bản (ví dụ: Python 3.5 ≠ Python 3.4 , do đó không được phép). Một đệ trình bị vượt quá khi độ dài tính bằng byte ngắn hơn lần gửi ban đầu. Bạn chỉ cần đánh gôn ít nhất 1 byte để bẻ khóa trình. Ví dụ: nếu tác vụ là thực hiện 2 × n và việc gửi là như sau:

print(2*input())

Bạn có thể vượt qua cảnh sát bằng cách làm như sau:

print 2*input()

Hoặc thậm chí điều này (vì lambda được cho phép):

lambda x:2*x

Đăng bài này với tiêu đề sau:

##{language name}, <s>{prev byte count}</s> {byte count}, {cop's submission + link}

Ví dụ:

Python 2, 16 12 byte, Adnan (+ liên kết để gửi)

lambda x:2*x

Tính A005843 , (bù = 0).

Trong trường hợp đó, bạn đã bẻ khóa trình.

Chấm điểm

Người nào phá được nhiều bài dự thi nhất là người chiến thắng.

Quy tắc

• Đệ trình crack phải cùng ngôn ngữ với đệ trình cảnh sát.
• Đầu vào giống nhau sẽ dẫn đến cùng một đầu ra (vì vậy a (2) = 4 nên giữ nguyên 4).
• Đối với các ngôn ngữ như Python, bạn có thể nhập các thư viện có tiêu chuẩn được bao gồm trong ngôn ngữ. (Vì vậy, không có numpy / sympy, v.v.)
• Đầu vào và đầu ra đều ở dạng thập phân (cơ sở 10).

Ghi chú

Thử thách này đã kết thúc. Người chiến thắng trong phần Robbers là feerum . Điểm số cuối cùng cho CnR được hiển thị dưới đây:

• feerum : 16 vết nứt
• Dennis : 12 vết nứt
• Neak rò rỉ : 6 vết nứt
• Lynn : 4 vết nứt
• dặm : 3 vết nứt
• Martin Ender : 2 vết nứt
• Emigna : 2 vết nứt
• jimmy23013 : 1 vết nứt
• Sp3000 : 1 vết nứt
• ngẫu nhiên : 1 vết nứt
• alephalpha : 1 vết nứt
• nimi : 1 vết nứt
• Dưa hấu phá hủy : 1 vết nứt
• Dom Hastings : 1 vết nứt

Cheddar, 7 6 byte, Hạ cấp

(<<)&1

Điều này có vẻ hiệu quả, nhưng tôi luôn không thể hiểu ngôn ngữ một cách chính xác.

Thạch ,54 byte , George V. Williams

RÆḊḞ

Hãy thử nó ở đây.

Một tính năng ẩn!

Nếu tôi nhớ chính xác, ÆḊ(A) = sqrt (det (AA ^T )) là n! nhân với số đo Lebesgue n chiều của một đơn vị được hình thành bởi n điểm đầu vào và gốc trong không gian m chiều. Khi n = 1 nó suy biến thành khoảng cách Euclide. Không có gì lạ cả ...

Lục giác , 91 33 byte, Xanh lam

1""?{\>{+/</+'+./_'..@'~&/!}'+=($

Mở ra:

    1 " " ?
   { \ > { +
  / < / + ' +
 . / _ ' . . @
  ' ~ & / ! }
   ' + = ( $
    . . . .

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

Trông vẫn hơi khó chơi nhưng tôi đoán là tôi đã đăng nó trước khi FryAmTheEggman đánh bại tôi. ;)

Giải trình

Dưới đây là một số đường dẫn thực thi được mã hóa màu:

Tuy nhiên, đây là những khó khăn không cần thiết do chơi golf. Đây là mã chính xác với bố cục saner:

Cái đó tốt hơn. Và cuối cùng, đây là sơ đồ bộ nhớ, trong đó mũi tên màu đỏ cho biết vị trí và hướng ban đầu của con trỏ bộ nhớ (MP):

Các ý chính là tôi lặp đi lặp lại tính toán số Fibonacci trên ba cạnh nhãn f (i) , f (i + 1) và f (i + 2) trong khi theo dõi các iterator trên mép Một , B và C . Trong khi làm như vậy, vai trò của các cạnh này được hoán đổi theo chu kỳ sau mỗi lần lặp. Hãy xem điều này xảy ra như thế nào ...

Mã bắt đầu trên đường dẫn màu xám thực hiện một số thiết lập ban đầu. Lưu ý rằng f (i) đã có giá trị ban đầu chính xác là 0.

1   Set edge f(i+1) to 1.
""  Move the MP to edge A.
?   Read input n into edge A.
)   Increment n.

Bây giờ đường dẫn màu xanh là vòng lặp chính. _và >chỉ là những tấm gương.

(     Decrement n.
<     If the result is zero or less, continue on the red path, otherwise
      perform another iteration of the main loop.
{     Move the MP to edge f(i+2).
+     Add edges f(i) and f(i+1) into this edge, computing the next Fibonacci number.
'     Move the MP to the edge opposite A.
~     Multiply by -1 to ensure that it's non-positive (the edge may have a positive
      value after a few iterations).
&     Copy the current value of n from A.
'     Move back and to the right again.
+     Copy n by adding it to zero. Since we know that the other adjacent edge
      is always zero, we no longer need to use ~&.
'+'+  Repeat the process twice, moving n all the way from A to B.
=     Reverse the orientation of the MP so that it points at f(i) which now
      becomes f(i+2) for the next iteration.

Bằng cách này, MP di chuyển xung quanh bộ ba cạnh bên trong, tính toán các số Fibonacci liên tiếp cho đến khi nđạt đến không. Cuối cùng, đường dẫn màu đỏ được thực thi:

{}    Move the MP to f(i).
!     Print it.
@     Terminate the program.

Các sơ đồ được tạo bằng HexagonyColorer và EsotericIDE của Timwi's .

Haskell, 5 4 byte, xnor

(^)1

Cà ri đơn giản.

Mèo xếp chồng, 14 13 byte, frageum

^]T{_+:}_

với các -nmcờ cho +4 byte. Hãy thử trực tuyến!

Được rồi, vòng lặp đó là hạt. Tôi đã thử một số cách tiếp cận, chẳng hạn như vũ phu cưỡng bức một bảng chữ cái giảm và buộc vũ phu 3x+2hoặc 5x+4và cố gắng mở rộng nó, nhưng tôi không bao giờ mong đợi giải pháp thực sự chứa một vòng lặp.

Cách tốt nhất để xem cách thức hoạt động của nó là thêm một Dcờ để gỡ lỗi (vì vậy hãy chạy với -nmD) và bật gỡ lỗi cho liên kết TIO ở trên. Một {}vòng lặp ghi nhớ đỉnh của ngăn xếp ở đầu vòng lặp và thoát ra khi đỉnh của ngăn xếp lại là giá trị đó. Phần bên trong của vòng lặp thực hiện một số phép trừ và chu kỳ thú vị của ba phần tử trên cùng của ngăn xếp, đó là cách vòng lặp được chạy trong rất nhiều lần lặp.

Sesos, 14 11 byte, Neak Leaky

Tính n ² . Hãy thử nó ở đây.

Đổ lục giác:

0000000: 16c0f7 959d9b 26e83e ce3d                         ......&.>.=

Từ lắp ráp:

set numin
set numout
get
jmp
  jmp, sub 1, fwd 1, add 1, fwd 1, add 2, rwd 2, jnz
  fwd 2, sub 1
  rwd 1, sub 1
  jmp, sub 1, rwd 1, add 1, fwd 1, jnz
  rwd 1
jnz
fwd 2
put

Thật đáng ngạc nhiên, 776 759 byte, dưa hấu phá hủy

| |||||||| | |
|| |||||| |
||| |||| |
|||| || |
||||| || |
|||| |||| |
||| |||||| |
|| |||||||| |
| |||||||||| |
|| |||||||| |
||| ||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
||||||||| |
||||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||||| |
|||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |

Tôi đã cố đọc mã nguồn cho ngôn ngữ này nhưng nó quá khó hiểu. Đối với một điều, ip[1]là một số dòng trong khi ip[0]là số cột, trong khi các cptọa độ được sử dụng theo cách khác xung quanh. Tuy nhiên, đôi khi giá trị của cpđược gán cho ip. Tôi đã từ bỏ việc cố gắng hiểu chương trình đang làm gì và tìm ra cách mã hóa chuỗi hướng dẫn giống hệt nhau bằng cách sử dụng ít thanh hơn.

Brachylog , 27 21 byte, gây tử vong

yrb:1a:+a:[1]c*.
:2/.

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

J, 17 12 byte, dặm

+/@(]!2*-)i:

Khá giống với bản gốc chỉ hơn chơi golf. :)

i:có +1phạm vi so với i.là hữu ích (và kỳ lạ). Nếu bạn sử dụng i.ở đây n=0sẽ không chính xác nhưng may mắn i:giải quyết được điều đó.

Hãy thử trực tuyến tại đây.

M, 10 6 byte, Dennis

R×\³¡Ṫ

Với n , nó tính toán n ^th -level thừa của n . Đây là một bài tập thú vị!

Mã có khả năng chạy như Jelly để bạn có thể dùng thử trực tuyến .

Giải trình

R×\³¡Ṫ  Input: n
R       Create the range [1, 2, ..., n]
   ³¡   Repeat n times starting with that range
 ×\       Find the cumulative products
     Ṫ  Get the last value in the list
        Return implicitly

Người tuyết, 50 44 byte, Doorknob

((}#2nMNdE0nR1`wRaC2aGaZ::nM;aF;aM:`nS;aF*))

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

Haskell, 15 14 byte, xnor

until odd succ

Tôi đã dành một vài giờ không có kết quả để học giải mã cú pháp "vô nghĩa" ... untilthay vào đó tôi đã tìm thấy điều này.

Hoặc đối với 13 byte ít sai lệch , until odd(+1).

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3

Pyke, 11 9 byte, cá bùn

hVoeX*oe+

Hãy thử nó ở đây!

Làm thế nào nó hoạt động

          Implicit input: n (accumulator), n (iterations)
h         Increment the number of iterations.
 V        Do the following n + 1 times.
  o         Iterator. Pushes its value (initially 0) and increments it.
   e        Perform integer division by 2.
            This pushes 0 the first time, then 1, then 2, etc.
    X       Square the result.
     *      Multiply the accumulator and the result.
      oe    As before.
        +   Add the result to the accumulator.
            This sets the accumulator to a(0) = 0 in the first iteration and
            applies the recursive formula in all subsequent ones.

05AB1E , 7 4, Biểu tượng

LnOx

Từ công thức tính tổng bình phương của các số nguyên dương 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, nếu chúng ta nhân lên cả hai cạnh của 2 ta được Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, đây là một công thức thay thế cho chuỗi này. - Mike Warburton (mikewarb (AT) gmail.com), ngày 08 tháng 9 năm 2007

Thạch, 22 21 byte, Dennis

_²×c×Ḥc¥@÷⁸÷’{S
‘µR+ç

Tôi đã dành vài giờ để đọc mã nguồn Jelly cho lần cuối cùng, vì vậy tôi cũng có thể sử dụng "kỹ năng" này để sử dụng. Tôi hy vọng @Dennis sẽ chia sẻ với chúng tôi những khám phá toán học của anh ấy cho phép một công thức ngắn hơn (giả sử có một cái gì đó và không chỉ các thủ thuật Jelly kỳ lạ!).

J, 20 19 byte, dặm

[:+/2^~+/@(!|.)\@i.

Điều này sẽ tính toán sản phẩm dưới dạng tổng của các số Fibonacci bình phương, được tính bằng tổng các hệ số nhị thức.

Rất may, chính @miles đã đăng mã để tạo ra các số Fibonacci trong bình luận này .

Acc !! , 526 525 byte, DLosc

N
Count x while _%60-46 {
(_+_%60*5-288)*10+N
}
_/60
Count i while _/27^i {
_+27^i*(_/27^i*26-18)
}
_*3+93
Count i while _/27^i/27%3 {
_-i%2*2+1
Count j while _/3^(3*j+2-i%2)%3 {
_+3^(1+i%2)
Count k while _/3^(3*k+1+i%2)%3-1 {
_+3^(3*k+1+i%2)*26
}
}
}
Count i while _/27^i/3 {
_-_/27^i/3%27*27^i*3+_/3^(3*i+1+_%3)%3*3
}
_/3
Count i while _/100^i {
_*10-(_%100^i)*9
}
Count i while _/100^i/10 {
_+_/100^i/10%10
Count j while i+1-j {
_+(_%10-_/100^(j+1)%10)*(100^(j+1)-1)
}
}
_/100
Count j while _/100^j {
Write _/100^j%10+48
}

Tôi không biết làm thế nào điều này hoạt động, nhưng tôi đã có thể phát hiện ra một cải tiến nhỏ.

24c24
< _+_/100^i*100^i*9
---
> _*10-(_%100^i)*9

Haskell, 10 byte, xnor

gcd=<<(2^)

Ví dụ sử dụng: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

Cách thức hoạt động: Từ trang oeis, chúng tôi thấy điều đó a(n) = gcd(2^n, n)hoặc được viết bằng cú pháp Haskell : a n = gcd (2^n) n. Các hàm với mẫu f x = g (h x) xcó thể được chuyển thành không có điểm thông qua hàm =<<: f = g =<< h, do gcd=<<(2^)đó dịch trở lại gcd (2^x) x.

Sesos, 14 9 byte, Neak Leaky

Tính n mod 16 . Hãy thử nó ở đây.

Lục bình:

0000000: 17f84a 750e4a 7d9d0f                              ..Ju.J}..

Hội,, tổ hợp:

set numin
set numout
set mask
get
jmp, sub 1, fwd 1, add 16, rwd 1, jnz
fwd 1
jmp, sub 16, fwd 1, add 1, rwd 1, jnz
fwd 1
put

Python, 39 17 byte, dưa hấu có thể phá hủy

lambda n:n*-~n>>1

05AB1E, 9 4 byte, Emigna

>n4÷

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

Thay vào đó, tính toán hàm này:

Hexagony , 7 6 byte, Adnan

?!/$(@

Mở ra:

 ? ! 
/ $ (
 @ .

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

Cùng một ý tưởng, bố cục hơi khác nhau.

MATL, 11 10 byte, Luis Mendo

YftdAwg_p*

Thay vì thực hiện -1 ^ chiều dài (mảng), nó chuyển đổi các phần tử thành các giá trị Boolean (luôn luôn là 1), phủ định chúng và lấy sản phẩm của các phần tử.

Thạch, 11 10, Dennis

Ḥ’_Rc’*@RP

Phiên bản Vectorized của cách tiếp cận tương tự.

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

05AB1E, 10 8 byte, Ad Nam

µNÂÂQ>i¼

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

Brachylog, 11 10 byte, gây tử vong

yb:AcLrLc.

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

Giải trình

Brachylog là một ngôn ngữ có nguồn gốc từ Prolog, có khả năng lớn nhất là chứng minh mọi thứ.

Ở đây, chúng tôi chứng minh những tuyên bố này:

yb:AcLrLc.
yb:AcL       Inclusive range from 1 to input, concatenated with A, gives L
     LrL     L reversed is still L
       Lc.   L concatenated is output

Thạch, 9 8 byte, Dennis

œċr0$L€Ḅ

Lấy làm tiếc! Tôi không thể tìm thấy giải pháp dự định của bạn.

Điều này phụ thuộc vào thực tế C(n+k-1, k)là số cách chọn kgiá trị nthay thế.

Lưu ý: Điều này không hiệu quả vì nó tạo ra các tập hợp có thể để đếm chúng, vì vậy hãy cố gắng tránh sử dụng các giá trị lớn của n trực tuyến.

Dùng thử trực tuyến hoặc Xác minh lên đến n .

Sau này tôi đã tìm thấy một phiên bản 8 byte khác đủ hiệu quả để tính n = 1000. Điều này sẽ tính toán các giá trị bằng cách sử dụng hệ số nhị thức và tránh tạo ra các danh sách.

Ḷ+c’Ṛ;1Ḅ

Dùng thử trực tuyến hoặc Xác minh lên đến n .

Giải trình

œċr0$L€Ḅ  Input: n
  r0$     Create a range [n, n-1, ..., 0]
œċ        Create all combinations with replacement for
          (n, n), (n, n-1), ..., (n, 0)
     L€   Find the length of each
       Ḅ  Convert it from binary to decimal and return

Ḷ+c’Ṛ;1Ḅ  Input: n
Ḷ         Creates the range [0, 1, ..., n-1]
 +        Add n to each in that range
   ’      Get n-1
  c       Compute the binomial coefficients between each
    Ṛ     Reverse the values
     ;1   Append 1 to it
       Ḅ  Convert it from binary to decimal and return

M, 9 8 byte, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 29 byte, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2