Đây câu trả lời-chaining Thách thức là chính thức kết thúc, kết quả là chiến thắng của mì Hướng dẫn , với tổng cộng 7 câu trả lời. Bất kỳ câu trả lời nào khác đều được chào đón, nhưng nó sẽ không ảnh hưởng đến câu trả lời được chấp nhận cho thử thách này, cũng như người chiến thắng.

Bài tập:

In tất cả các ước số dương của một số xđược lấy làm đầu vào.

Đầu vào:

Một số duy nhất xlà số (trong cơ sở 10) có các ước số dương nên được tính.

Đầu ra:

Tất cả các ước số tích cực của x. Bất kỳ định dạng nào được phép, bao gồm \n, ,, ;và khoảng trắng như dải phân cách, miễn là nó dễ hiểu. Đầu ra cũng có thể là một mảng của Số nguyên hoặc Chuỗi (ví dụ [1, 2, 3, 5, 30]:). Bạn có thể xuất các ước số thành thiết bị xuất chuẩn, bảng điều khiển hoặc tương đương trong ngôn ngữ của bạn hoặc chúng có thể được trả về từ một hàm .

Quy tắc

• Một người dùng không thể trả lời hai lần liên tiếp
• Câu trả lời của bạn có thể xóa, thêm hoặc thay thế tối đa 15 ký tự từ câu trả lời trước (khoảng trắng không được tính), ngoài ra Câu trả lời 2 có thể "biến đổi" tối đa 20 ký tự để bắt đầu mọi thứ
• Bạn không được phép đăng câu trả lời bằng ngôn ngữ lập trình đã có câu trả lời, ngoại lệ là phiên bản hoàn toàn khác của ngôn ngữ đó (ví dụ: Nếu tôi đăng câu trả lời Python 2.7, bạn có thể gửi câu trả lời Python 3, nhưng không gửi Python 2.6)
• Sơ hở tiêu chuẩn không được phép
• Bạn không được phép sử dụng tích hợp sẵn để có được ước số , vì lợi ích của thử thách này
• Bạn phải bao gồm số câu trả lời và tên ngôn ngữ trong tiêu đề của câu hỏi và số lượng ký tự được thay đổi so với câu trả lời trước đó

Chấm điểm

Người dùng có nhiều bài nộp nhất sau khi giải quyết xong. Trong trường hợp hòa, người dùng có số điểm cao nhất trong một câu trả lời của họ sẽ thắng. Nếu có một sự ràng buộc ở điểm số, thì người dùng có bài nộp cũ nhất (câu trả lời có điểm cao nhất) sẽ được tuyên bố là người chiến thắng.

Lưu ý: "giải quyết" <=> 7 3 ngày đã trôi qua kể từ khi câu trả lời cuối cùng được gửi

Ví dụ:

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

Hoặc bất kỳ đầu ra tương đương khác đáp ứng các điều kiện được đề cập.

Lưu ý cuối cùng : Câu hỏi này tốt hơn nếu bạn sắp xếp các câu trả lời theo câu cũ nhất. Tôi sẽ đăng câu trả lời đầu tiên trong Python 2.7, vì vậy bạn nên đăng câu trả lời thứ hai tùy thuộc vào câu trả lời đó. Chúc may mắn và vui vẻ!

Bảng xếp hạng:

Danh sách này có thể bị lỗi thời, miễn phí để chỉnh sửa nó:

1) Thuật sĩ lúa mì [Nhà lãnh đạo hiện tại 🏆] : 7 câu trả lời - Python 1.6 , 05AB1E , Trên thực tế , Del | m | t , WSF , Brain-Flak , Lenguage

2) Riley: 3 câu trả lời - Nghiêm túc , CJam , 2sable

3) Jonathan Allan: 2 câu trả lời - Python 3 , Jelly

3) ETHproductions: 2 câu trả lời - Japt , Pyth

3) Mistah Figgins: 2 câu trả lời - Befunge-98 , Brain-Flak Classic

6) Riker: 1 câu trả lời - MATL

6) dzaima: 1 câu trả lời - SOGL 0.8.2

6) LegionMammal978: 1 câu trả lời - Khoảng trắng

6) Nick Clifford: 1 câu trả lời - Ohm

6) Lynn: 1 câu trả lời - GolfScript

6) MickyT: 1 câu trả lời - Cubix

Máy tính khoảng cách

Bạn có thể sử dụng đoạn mã này để tính khoảng cách giữa hai mục:

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}

<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>

Trả lời 20, Brain-Flak , 11

Tôi muốn dành thời gian để cảm ơn tất cả mọi người đã giúp đóng góp cho mục tiêu này:

• Riley, 20 byte

• LegionMammal, 15 byte

• Sản phẩm ETH, 11 byte

• Lynn, 1 byte

Những người dùng sau đây không thể đóng góp byte trực tiếp nhưng đã giúp đỡ theo những cách khác:

• Mistah Figgins

• DJMcMayhem

• feerum

Cảm ơn tất cả mọi người đã làm điều này có thể!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

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

Trả lời 3: MATL, Khoảng cách 15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

Trả lời 7, Japt, 15

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

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

Thay đổi #b∫I:b;\?t thành ò f!vU(10 điểm) và thêm một số mã Brain-Flak bằng cách thay đổi ~(()thành ((()<>))(5 điểm). Tôi tin rằng mã chúng tôi đang làm việc là

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

Giải trình

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

Trả lời 8, 05AB1E , 14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

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

Giải trình

May mắn thay 05AB1E có một trình thông dịch Python dựng sẵn (các loại). Để thực hiện việc này, chúng tôi đẩy

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

như một chuỗi trên đỉnh của ngăn xếp. Chúng tôi phải sử dụng chuỗi ký tự thay vì nhận xét ở đây vì 05AB1E thực sự không thích nhận xét trong mã Python của nó. Chúng ta cũng phải thoát khỏi" mã gốc vì nó khiến chuỗi kết thúc sớm.

Khi chuỗi đã được đẩy, chúng tôi sử dụng .e để thực thi nó dưới dạng mã python.

Làm việc hướng tới Brain-Flak

Tôi đã có thể thêm 5 nhân vật nữa vào mục tiêu đưa ra câu trả lời Brain-Flak. Tôi đã có thể thêm 6 nhưng than ôi tôi quên khoảng trắng không được tính vào điểm số.

Cho đến nay chúng ta có:

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

Trả lời 13, Pyth , 15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

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

Giải trình

Vì vậy, tôi không biết nhiều về Pyth, nhưng điều tôi biết là mã nguồn ở dạng cây, mỗi lệnh lấy một số lượng đối số cụ thể ở bên phải. Cây của chương trình chia số tôi đã viết trông như thế này:

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Qlà đầu vào. fnhận hai đối số, Fvà A, và trả về các mục Ttrong Anơi F(T)trả về một giá trị truthy. Trong trường hợp này, Flà một hàm trả về logic KHÔNG của Q%T, và Alà SQ, tạo ra phạm vi [1...Q]. Điều này có tác dụng lọc chỉ các số nguyên Tở [1...Q]đâu Q%T == 0.

Để tránh phân tích phần còn lại của mã, toàn bộ nội dung được gói trong một chuỗi, sau đó |Q"...trả về OR logic Qvà chuỗi. Vì Qluôn luôn tích cực, nó luôn luôn trung thực và do đó luôn được trả về từ OR logic.

Làm việc hướng tới Brain-Flak

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

Trả lời 16, GolfScript, 15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

Tôi đã thêm ~:␤),(;{␤\%!},p#, sử dụng dòng mới làm tên biến để phù hợp với ràng buộc kích thước và đặt toàn bộ chương trình trở lại vào một dòng để nhận xét nó. Đây là khoảng cách 14. Sau đó, tôi đã thêm {trước }printdivcho Brain-Flak.

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

Làm việc hướng tới Brain-Flak

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

Trả lời 17, CJam , 15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

Làm việc theo hướng Brain-Flak (30 để đi)

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

Trả lời 4 - Thạch , 4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

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

Mã liên quan:

Rḍ⁸T

Các )hoạt động như một sự phá vỡ giữa các liên kết xa như liên quan đến trình phân tích cú pháp (tôi tin).

Việc xây dựng trong sẽ là ÆD, thay vì điều này tạo ra một loạt từ 1đầu vào với R, kiểm tra các quan hệ chia hết bởi các đầu vào với ḍ⁸, sau đó trả về một danh sách các chỉ số truthy một dựa trên với T.

Trả lời 9, khoảng trắng, 15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

Trường hợp <SPACES>được thay thế bởi chuỗi sau, trong đó T0x09, Llà 0x0A và Slà 0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Dòng chữ mới được thêm vào cho rõ ràng. Lưu ý rằng các quy tắc chỉ xác định các ký tự không phải khoảng trắng. Không, không thể giúp tôi.

Làm việc hướng tới Brain-Flak

Tôi không biết chuyện gì đang xảy ra trước đó, vì vậy bây giờ chúng tôi có:

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

Trả lời 18, WSF , 15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(Điều này nhận đầu vào và đầu ra thông qua mã ký tự)

Giải trình

WSF về cơ bản là brainfuck ngoại trừ nó sử dụng khoảng trắng thay vì tập hợp các toán tử thông thường của brainfuck. Đây là đoạn mã được dịch ngược thành brainfuck:

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

Tiến tới Brain-Flak

Vì WSF chỉ là khoảng trắng nên tôi có thể thêm 15 ký tự nữa vào mã Brain-Flak. Điều này đặt chúng tôi ở 15 câu trả lời, vì vậy hãy đăng nó.

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

Vì tôi sẽ không tự mình đăng câu trả lời Brain-flak, tôi nghĩ rằng tôi sẽ dành thời gian để cảm ơn mọi người đã giúp đóng góp cho mục tiêu này:

• Riley, 16 byte

• LegionMammal, 15 byte

• Sản phẩm ETH, 11 byte

• Lynn, 1 byte

Những người dùng sau đây không thể đóng góp byte trực tiếp nhưng đã giúp đỡ theo những cách khác:

• Mistah Figgins

Cảm ơn tất cả mọi người đã làm điều này có thể!

Trả lời 19, 2sable , 15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

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

Tôi đã xóa khoảng trắng thừa, bao bọc mọi thứ tồn tại trước đó thành một chuỗi, sau đó:

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

Trả lời 21, Cubix , 15

Cuối cùng cũng xoay sở để phù hợp với điều này :) Rất may là sau khi câu trả lời Brain-Flak được thực hiện, bởi vì tôi nghĩ rằng tôi sẽ cản trở. Cần đủ 15 để thực hiện.

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Bản đồ này đến khối sau

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

Bạn có thể thử nó ở đây , nhưng bạn sẽ cần phải dán nó vào. Tôi nghi ngờ một số điều đặc biệt đang gây ra vấn đề cho permalink.

Mã về cơ bản là hơn 2 dòng. Các phần quan trọng là:

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )Điều này nhận được đầu vào, hoán đổi đỉnh của ngăn xếp (0 cũng sẽ hoạt động tốt) và gia tăng
% ?Nhận mod và kiểm tra. Nếu 0 tiếp tục chuyển tiếp hoặc thả xuống chuyển hướng
; O N oThả kết quả mod và xuất số theo sau là dòng
uU mới vào dòng bên dưới
Thực hiện theo thứ tự
; - ! @ Xóa 10 khỏi ngăn xếp, trừ số từ đầu vào, kiểm tra và chấm dứt nếu không
< ; uChuyển hướng mục tiêu cho thử nghiệm đầu tiên. Xóa đầu ngăn xếp (kết quả mod hoặc trừ) và quay ngược lên để tăng

Trả lời 6, Python 1.6, 15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

Tôi xóa các %ký hiệu và nhận xét dòng đầu tiên và một chút dòng cuối cùng. Điều này một mình chi phí 10 trong số 15 điểm của tôi. Tuy nhiên tôi vẫn chưa xong; vì Python 1 không phải +=thay thế i+=1bằng việc i=i+1tôi phải trả thêm 3 điểm. Vì tôi còn 2 cái nên tôi cũng thêm vào ((đầu. Tôi đang lên kế hoạch thực hiện một bài nộp trong Brain-Flak sau đó và tôi cần parens.

Trả lời 10, Ohm , khoảng cách 5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

... nơi <SPACES>được thay thế bởi chuỗi quái dị đó từ câu trả lời của Whitespace .

Một chút câu trả lời táo tợn, vì mọi thứ khác chỉ là một sợi dây không được thực hiện.

Trả lời 12, Nghiêm túc , 15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

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

Sự khác biệt duy nhất từ câu trả lời trên thực tế là Nghiêm túc sử dụng backticks để đánh dấu một chức năng trong đó Thực tế sử dụng⌠ và ⌡và chúng tôi chỉ làm cho nhân vật thêm vào một chuỗi sau đó bật và loại bỏ nó.

Làm việc hướng tới Brain-Flak

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

Trả lời 14, Del | m | t , 15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

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

Giải trình

Tôi thực sự bắt đầu lạm dụng thực tế là khoảng trắng không được tính vào sự khác biệt ở đây. Del | m | t không thực sự quan tâm đến tất cả các ký tự của bạn, vì vậy phần lớn mã là một chuỗi các khoảng trắng và vận chuyển trở lại vào đầu chương trình. Các phần có thể nhìn thấy thực tế của mã hoàn toàn không được thực thi.

Đây là đoạn mã được chuyển thành một kiểu "hợp lý" hơn:

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

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

Làm thế nào nó hoạt động ở mức thấp

Để bắt đầu, chúng tôi có O R ^ V điều này phục vụ đầu vào ở vòng lặp đầu tiên và hoạt động như một lần không hoạt động.

Sau đó chúng tôi sử dụng Ođể tạo một bản sao của đầu vào cho sau này.

@ A K Tnhớ lại biến được lưu trong vị trí bộ nhớ -1 (ở đầu chương trình, giá trị này là 0) và A Jtăng nó. O @ A K ULưu trữ giá trị gia tăng bây giờ trở lại vị trí bộ nhớ -1 cho vòng lặp tiếp theo của chúng tôi xung quanh.

Ntính toán mod của bản sao của đầu vào mà chúng ta đã thực hiện một lúc trước và giá trị vừa được gọi lại từ bộ nhớ và Rphủ nhận nó.

Cùng với nhau N R tạo ra một boolean cho biết liệu đầu vào của chúng ta có chia hết cho ĐKDV hay không.

Chúng tôi lưu trữ một bản sao của boolean này vào không gian bộ nhớ -2 bằng cách sử dụng O @ B K Uvà gọi lại giá trị từ không gian bộ nhớ -2 bằng cách sử dụng@ A K T .

Chúng tôi trao đổi hai phần tử trên cùng Qđể đảm bảo rằng boolean nằm trên cùng và xuất giá trị nếu boolean là đúng khi sử dụng ^ X.

Nếu boolean là sai, chúng ta có một giá trị bổ sung cần được xóa để chúng ta nhớ lại boolean mà chúng ta đã lưu trữ trong không gian -2 với @ B K Tvà bật một giá trị nếu nó sai R ^ P.

Chúng tôi nhân đôi giá trị đầu vào bằng Ovà trừ giá trị ở bộ nhớ -1 với @ A K T K. Nếu đây là số không, chúng tôi thoát R ^ _.

Cuối cùng, chúng ta có @ ^bỏ qua bất kể giá trị tiếp theo là gì. Chúng ta cần điều này bởi vì có một loạt rác (thực ra chỉ là một @biểu tượng) được tạo bởi phần mã hiển thị.

Một khi nó đạt đến điểm cuối, nó lặp lại từ đầu.

Làm thế nào nó hoạt động ở mức cao

Ý tưởng cơ bản là chúng ta có một giá trị được lưu trữ chủ yếu tại vị trí bộ nhớ -1 được tăng lên mỗi khi chúng ta lặp. Nếu giá trị đó chia đầu vào của chúng ta, chúng ta sẽ xuất nó và khi hai giá trị bằng nhau, chúng ta kết thúc thực hiện.

Tiến tới Brain-Flak

Vì khoảng trắng không được tính vào sự khác biệt, tôi có thể thay đổi mã mà không tốn bất kỳ điểm nào trong số 15 điểm của mình và do đó tất cả chúng đều được đầu tư vào mã Brain-Flak.

Đây là chỗ đứng hiện tại của chúng tôi.

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

Trả lời 15, Befunge-98, 15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

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

(Có lẽ có rất nhiều khoảng trắng không cần thiết, nhưng tôi không thể bận tâm đến việc đánh gôn ngay bây giờ)

Tôi đã sử dụng tất cả 15 cho chương trình Befunge, vì vậy lần này không có thay đổi nào đối với Brain-flak.

Chiến lược chính của tôi cho việc này là gửi IP đi theo chiều dọc và sử dụng khoảng trắng để thực thi các ký tự nhất định từ mã có sẵn.

Giải trình:

Mã quan trọng đối với chương trình Befunge là đây:

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

Tương đương với:

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line

Trả lời 2 - Python 3 , 5

n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

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

Trả lời 5 - SOGL 0.8.2 , 9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

Giải trình:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

Lưu ý: hiện tại trình thông dịch cần \nthay thế s ¶để không tính nó là đầu vào, nhưng bản thân trình phân tích cú pháp xem xét cả hai có thể hoán đổi cho nhau.

Trả lời 11, thật ra , 15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

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

Giải trình

Trên thực tế có một nội dung đẹp ÷ để tìm các yếu tố của một số, tuy nhiên chúng tôi không được phép sử dụng các nội dung đó.

Tôi bắt đầu bằng cách lưu trữ đầu vào vào các thanh ghi để nó sẽ không bị tổn hại bởi những gì sẽ đến. Tôi làm điều này bằng cách sử dụng╩ nhưng tôi có thể dễ dàng sử dụng một trong những lệnh khác có sẵn.

Sau đó, tôi dán mã mà chúng tôi đã có (Tôi đã xóa tất cả các khoảng trắng vì nó gây khó chịu khi làm việc, tôi có thể làm điều này vì "khoảng trắng không được tính"). May mắn là điều này không có gì nhiều khi ngăn xếp trống.

Sau đó, chúng tôi có phần còn lại của chương trình

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

Làm việc hướng tới Brain-Flak

Tất cả công việc đó và tôi chỉ có thể có thêm một paren.

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

23, Brain-Flak Classic, 13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Ban đầu, @Wheat Wizard đã đăng đoạn mã kinh điển như trong câu trả lời 22:

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

Đây là 17 ký tự tắt. Tuy nhiên, tôi đã có thể nén điều này bằng cách di chuyển {})thêm quyền bên phải trong mã được đề xuất để có được

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

Mà chỉ có 13 ký tự! Vì vậy, tất cả những gì tôi đã làm là thêm / xóa dấu ngoặc để lấy mã đề xuất.

Mã ban đầu tôi đã đăng có một lỗi đánh máy, giờ nó đã được sửa. ( Cảm ơn @WheatWizard! )

Trả lời 1 - Python 2.7

n=input()
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

Khoảng cách: NA - Câu trả lời đầu tiên

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

22, Lenguage , 15

Lenguage là một esolang chỉ quan tâm đến thời gian chương trình không liên quan đến nội dung của nó. Vì vậy, chúng tôi có thể tạo bất kỳ chương trình kéo dài nào chúng tôi muốn bằng cách đệm chương trình cuối cùng với khoảng trắng phù hợp. Lenguage được biên dịch thành brainfuck vì vậy chúng tôi sẽ sử dụng lại chương trình brainfuck mà tôi đã viết cách đây một thời gian

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

Tôi đã thực hiện một vài thay đổi cho chương trình chính để tạo điều kiện cho các câu trả lời sau, nhưng kết quả cuối cùng trông như sau:

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Ở đâu <SPACES> đại diện cho 555014291951739769894021307527885530462809719021945 31020486729504671367937656404963353269263683332162717880499306 ký tự không gian.

Tôi có lạm dụng khoảng trắng không tính quy tắc không? Có lẽ.

Làm việc hướng tới Brain-Flak Classic

Chúng tôi đã có tất cả các parens đó rồi nên tôi nghĩ tôi sẽ bắt đầu chúng tôi trên đường tới Brain-Flak Classic.

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