Đây là một thách thức chuỗi câu trả lời liên quan đến OEIS.

Ồ, lý do cho điều này là bởi vì một công ty cần một chương trình để in ra các chuỗi OEIS của họ thực sự xấu và họ có mọi ngôn ngữ.

Định dạng chuỗi câu trả lời hoạt động theo cách sau:

Ai đó đăng câu trả lời đầu tiên, từ đó tất cả các giải pháp tiếp theo xuất phát. Câu trả lời này là một chương trình, với một số N, nhập số N trong chuỗi OEIS của bất kỳ chỉ số nào họ chọn (chúng tôi sẽ gọi đó là chuỗi 1), bằng bất kỳ ngôn ngữ nào họ chọn (ngôn ngữ 1)

Một số người khác xuất hiện và chọn trình tự của riêng họ (điều đó phải khác với trình tự trước đó và với tất cả các trình tự trước đó). Họ tạo ra một chương trình, bằng một ngôn ngữ khác (phải khác với tất cả các ngôn ngữ trước đó), đưa ra một số N trong ngôn ngữ 1 đưa ra số thứ N của chuỗi 1 và, cho một số trong ngôn ngữ 2 xuất ra số thứ tự thứ N 2.

Quá trình này tiếp tục quảng cáo vô hạn.

Thuật ngữ thứ n của một chuỗi là thuật ngữ xuất hiện n lần sau lần đầu tiên, làm việc từ mục đầu tiên. Ở đây chúng tôi sử dụng lập chỉ mục 0 và 1, để dễ dàng cho các lập trình viên!

Không sử dụng lại ngôn ngữ hoặc trình tự.

Đầu vào phải là số nguyên hoặc biểu diễn chuỗi của số nguyên và đầu ra phải là giá trị chính xác của chuỗi. Xử lý lỗi (đầu vào không int) là không cần thiết.

Bạn không được đăng hai lần liên tiếp.

Bạn phải đợi một giờ hoặc nhiều hơn trước khi đăng lại.

Bất cứ ai là người cuối cùng để đăng bài sau một tuần không có câu trả lời (người không phá vỡ chuỗi) sẽ giành chiến thắng, mặc dù cuộc thi có thể tiếp tục vô thời hạn. Nếu bạn là người cuối cùng và có thể cho thấy rằng bạn có thể thêm một ngôn ngữ nữa, bạn sẽ tiếp tục thử thách cho đến khi người chiến thắng tiếp theo.

Bạn có thể giả sử rằng đầu vào hoặc đầu ra sẽ không nằm ngoài phạm vi số của ngôn ngữ của bạn (ví dụ: giả sử rằng giới hạn của IEEE sẽ không bị vượt qua bởi bất kỳ chuỗi nào) nhưng đừng là kẻ lừa đảo và lạm dụng điều này bằng cách sử dụng một ngôn ngữ chỉ có 1.

Bất kỳ trình tự nào cũng có thể được chọn, miễn là nó chưa được sử dụng trước đó.

Đầu vào không thể nằm ngoài giới hạn cho chuỗi bạn đang sử dụng.

Hai phiên bản ngôn ngữ khác nhau là các ngôn ngữ khác nhau (Python 2 và Python 3 được coi là các ngôn ngữ khác nhau của riêng chúng). Điều này không cứng nhắc, nhưng theo nguyên tắc thông thường, nếu nó được tách ra từ một phiên bản khác của cùng ngôn ngữ trên TIO, thì nó lại khác.

Điều này không bị cấm, nhưng hãy thử một lần không sử dụng công thức mà OEIS đưa ra.

Nếu mã kết quả của bạn dài hơn 65536 ký tự, hãy cung cấp liên kết để truy cập mã đó (ví dụ Pastebin).

Đó là tất cả và đó là tất cả. Sẵn sàng? Bộ? VUI VẺ!

Đúng, đây là "Một OEIS khác" nhưng được đưa vào nhiều người chơi. Tôi nghĩ rằng nó sẽ được mát mẻ.

15. Bình luận viên , A020739

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0#
/*	
박망희		   		0#
;*/	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

C #
Brainfuck
Runic bùa
Jelly
Gol> <>
Javascript (Node.js) (Tất cả 1s)
ở giữa dấu ngoặc
Khoảng trắng (Tất cả 3s)
05AB12 (Tất cả 0s)
không thể đọc
Grass
Width
AlphaBeta
Aheui (Tất cả 2s)

Tôi đã có một vài kế hoạch với Bình luận viên, nhưng chỉ có một liên lạc còn sống sót với tất cả các ngôn ngữ khác. Một lỗi gây ra trong Jelly (iirc) và tôi không thể giải quyết nó vì tôi không biết tại sao Jelly lại diễn giải các byte theo cách nó đã làm.

4. Thạch , A000312

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/

C # (Trình biên dịch tương tác Visual C #)
Brainfuck
Runic Enchantments
Jelly

Giải trình:

Chúng tôi chỉ chiếm tài khoản cho dòng cuối cùng, tất cả các dòng khác bị bỏ qua.

;/**/ Argument: z
;/    Reduce z by ; (concatenation) [1]
      z is an integer, so this just returns z itself.
   */ Reduce z by * (exponentiation) [2]
      Again, this returns z itself.
  *   Exponentiation: return [1] ** [2]
      This resolves to (z ** z).

Để làm cho C # bỏ qua mã, chúng tôi đang cố gắng đưa nó vào một nhận xét. Tuy nhiên, một dòng bắt đầu bằng /không hợp lệ trong Jelly, vì /cần một toán hạng. Toán hạng chúng ta đang sử dụng ở đây là ;vì nó cũng hoàn toàn phù hợp như một dấu chấm phẩy trong C #. Trong thực tế, dấu chấm phẩy và bình luận nhiều dòng trống cùng nhau tạo ra một liên kết tính 2 z = z z . Lưu ý rằng việc gửi hàm trong C # vẫn hợp lệ, vì không có sự đồng thuận chung nào không cho phép nhiều câu lệnh trong một lần gửi hàm ẩn danh (ví dụ: nhập khẩu).$^2z=z^z$

16. Java 8 , A000290

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*  
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Không bao giờ nghĩ rằng tôi sẽ thấy ngày mà tôi có thể thêm câu trả lời Java là câu trả lời thứ 16 trong chuỗi polyglot! : D

$a(n)=40-n$
$a(n)=1+n\text{ mod }2$
$a(n)=4^n$
$a(n)=n^n$
$a(n)=-n$
$a(n)=1$
$a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0$
$a(n)=3$
$a(n)=0$
$a(n)=n$
$a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor$
$a(n)=n+1\text{ with }n\geq2$
$a(n)=1\Vert n$a ( n ) = 2 a ( n ) = 2 n + 6 a ( n ) = n 2
$a(n)=2$
$a(n)=2n+6$
$a(n)=n^2$

Giải trình:

Hãy để tôi bắt đầu bằng cách nói rằng mặc dù tôi đã nghe từ mỗi ngôn ngữ này trước đây trên CGCC, tôi chỉ có kỹ năng với Java, C #, 05AB1E và Whitespace, ngoài ra có thể đọc được phần JavaScript của mã. Các ngôn ngữ khác hầu như không quen thuộc với tôi, vì vậy tôi hy vọng sau những thay đổi tôi có để làm cho Java tương tác với C # / JavaScript, hầu hết các ngôn ngữ khác vẫn sẽ hoạt động.

Vấn đề chính đầu tiên cần giải quyết là Java n->vs C # / JavaScript n=>. Java hỗ trợ các giá trị unicode như một phần của mã, do đó, sử dụng như sau:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

Sẽ được giải thích như thế này trong C # / JavaScript:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

Nhưng như điều này trong Java:

//
/*
n=>//*/n->

Điều này là do \u000Angắt dòng, \u002Fđang /và \u002Anằm *trong Java.

Sau đó, để phân biệt trình tự giữa Java và C # / JavaScript, tôi đã thêm vào như sau:

""+n==""+n?...:n*n

nơi ...hiện có 5/2>2?1:40-nvà n*nlà phần Java của mã cho chuỗi oeis A000290 (bình phương aka ).$a(n)=n^2$

Tại sao điều này làm việc? Trong Chuỗi Java là các Đối tượng, nơi ==được sử dụng để kiểm tra xem các tham chiếu của các đối tượng có đang trỏ đến cùng một vị trí không (hoặc để kiểm tra xem các nguyên hàm có bằng nhau không) và thực tế Object.equals(Object)phải được sử dụng để kiểm tra xem các giá trị của các Đối tượng này có giống nhau không. Vì vậy, ""+n==""+nsẽ là falsey trong Java, nhưng sự thật trong C # / JavaScript.

Sau đó đã được khắc phục (bằng cách sử dụng lại các dòng mới hiện có để không phá vỡ chương trình Whitespace), một số điều đã được sửa. Bốn trong số các chương trình hiện tại đã thất bại: Runic Enchantments, Jelly, Unreadable và Commentator.

Việc sửa lỗi cho Unreadable rất dễ dàng. Chúng tôi đã thêm bốn """"trước đầu tiên ', vì vậy chúng tôi chỉ cần đặt 'một nơi nào đó sớm hơn (tôi đặt nó ở cuối dòng đầu tiên) và xóa phần đầu '""""ra khỏi phần Không thể đọc được của mã ở phía dưới.

Sau đó, Jelly đã đưa ra một IndexError: pop from empty list. Tôi không quá thành thạo về Jelly, vì vậy tôi không biết chính xác tại sao nó lại gây ra lỗi này. Nếu tôi nhớ chính xác thì dòng cuối cùng sẽ là liên kết chính của chương trình Jelly và vì mã trong dòng cuối cùng đó không sử dụng bất kỳ liên kết nào khác, nên mọi thứ khác sẽ bị bỏ qua. Nhưng bằng cách nào đó phần ""+n==""+nvẫn đưa ra một số vấn đề. Tôi đã có thể khắc phục điều này bằng cách thêm /**/vào trước dòng đó.

Đối với Runic Enchantments, nó không còn xuất ra bất cứ thứ gì nữa. @ Draco18s đã chỉ ra cho tôi rằng Runic Enchantments bắt đầu >đồng thời, nhưng chỉ >2?1:40-n/và /ip@có liên quan. Đây là một sự giúp đỡ rất lớn để hiểu được dòng chảy của chương trình Runic bùa, và tôi đã có thể sửa chữa các con đường bằng cách thêm một /**/lúc >2?1:40-/**/n:n*n, và thay đổi vị trí của các //ip@, //và không gian trên dòng cuối cùng.

Tất cả những gì còn lại là Bình luận viên. Vào thời điểm đó, tôi nhận ra rằng các bản sửa lỗi trước đây của mình về việc thêm /**/không phải là một ý tưởng hay, vì nó sẽ tạo ra một đống rác bổ sung do các nội trang /*(chuyển đổi hoạt động thành ký tự và đầu ra unicode) và */(đầu ra hoạt động dưới dạng số) ..>.> Sau một chút loay hoay và thử một số thứ, cách khắc phục hóa ra rất dễ dàng: Tôi đã thêm một cái etrước #dòng đầu tiên. e#là nội dung để phủ nhận một hoạt động, khắc phục các sự cố gây ra bởi mã tôi đã thêm (rõ ràng).

6. JavaScript (Node.js) , A000012

//
n=>5/2>2?1:40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (A022996) : Vì 5/2==2hàm trả về 40-n(Dòng 2)

BF (A000034) : Phần được thêm vào chỉ đẩy toàn bộ băng một ô sang phải, các phần khác không thay đổi (Dòng 2-3)

Runic (A000302) : Sau ?khi 2bỏ qua 1:và các hoạt động khác theo sau 4(Dòng 2)

Jelly (A000312) : Dòng cuối cùng không thay đổi

Gol> <> (A001361) : Cột đầu tiên không thay đổi

JS (ES6) (A000012) : Vì 5/2>2hàm trả về 1(Dòng 2)

Lén ternary 5/2>2?1:40-nvào phần C #. Trong C # vì 5/2==2hàm trả về 40-n, trong khi trong JS, 5/2>2các hàm trả về 1. Các nhận xét kiểu C khiến cho việc thêm các ngôn ngữ thực tế hơn (cụ thể là C và Python) gần như không thể. Nhiều không gian hơn được thêm vào các dòng 4-5 để đảm bảo rằng phần Runic hoạt động.

8. Khoảng trắng , A010701

//   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

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

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Paranthetic

Tôi không biết Whitespace hoạt động như thế nào. Tôi đã rất cố gắng để nhân đầu vào với một giá trị khác, nhưng nó vẫn phàn nàn về số học infix, vì vậy tôi đã làm việc đầu vào, đầu ra làm việc và đẩy giá trị lên ngăn xếp, vì vậy tôi chỉ làm việc đó.

Giá trị đầu vào dường như bị mất khi đẩy 3vào ngăn xếp, nhưng ồ. Thưởng thức một chuỗi 3 giây. Chương trình thực hiện kỹ thuật đầu vào , cuối cùng nó loại bỏ nó.

_{Tôi cũng không biết Paranthetic hoạt động như thế nào, vì vậy tôi thực sự không thể xác minh rằng việc gửi đó là hợp lệ, nhưng theo như tôi có thể nói mã Whitespace không can thiệp.}

_{Câu trả lời trong tương lai: lưu ý rằng các tab trong Runic là một lệnh rộng duy nhất và chơi havoc với bố cục mã.}

11. Cỏ , A000030

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Grass bỏ qua tất cả các nhân vật ngoại trừ w, vvà W; một cách thuận tiện, ba ký tự này bị bỏ qua bởi một số ngôn ngữ được sử dụng trước đó. May mắn thay, chuỗi A000030 (trả về chữ số ban đầu trong cơ sở 10) vẫn có sẵn, vì mã hóa các hàm thậm chí hơi phức tạp trong Grass nằm ngoài khả năng của tôi.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript
dấu ngoặc
Khoảng trắng
05AB1E
thể đọc

Phần có liên quan cho Grass là wvWwwWWwwwwwwWwWWWw. Dưới đây là sự hiểu biết (có lẽ còn thiếu sót) của tôi về cách thức hoạt động: ngăn xếp được khởi tạo là OUT::SUCC::w::IN::ε(đó wchỉ là ký tự w). Mỗi hướng dẫn thêm một phần tử vào ngăn xếp (chúng không bao giờ được bật); số ws hoặc Ws cho biết độ sâu trong ngăn xếp; vhướng dẫn tách.

wv        # identity
Www       # identity OUT
WWwwwwww  # identity IN (read in 1 character)
Ww        # apply the function identity IN
WWWw      # apply the function identity OUT to the value at the top of the stack

Nếu đầu vào là 1234, ở cuối, ngăn xếp có thể trông như thế này : 1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε.

Nó có thể được rút ngắn lại (chẳng hạn như không cần xác định id OUT), nhưng tôi đã dừng lại ngay khi tìm thấy một phiên bản hoạt động.

Nếu ai đó biết Grass muốn sửa / cải thiện lời giải thích, xin vui lòng chỉnh sửa câu trả lời của tôi!

17. Pepe , A000578

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Phiên dịch trực tuyến

C #
Brainfuck
Runic bùa
Jelly
Gol> <>
Javascript (Node.js) (Tất cả 1s)
ở giữa dấu ngoặc
Khoảng trắng (Tất cả 3s)
05AB12 (Tất cả 0s)
không thể đọc
Grass
Width
AlphaBeta
Aheui (Tất cả 2s)
Bình Luận Viên
Java

Bạn sẽ phải bào chữa cho liên kết Pepe vì không chứa nguồn đầy đủ: Trình thông dịch bỏ qua bất kỳ mã nào không phải là Pepe (bất kỳ ký tự nào không có trong tập hợp RE re) và vì vậy liên kết ngắn của nó không làm phiền mã hóa nó. Giá trị đầu vào Ditto.

$a(n) = n^3$

AlphaBeta đã bắt đầu ném lỗi sau khi viết đầu ra, nhưng như một câu trả lời trước đó đã đưa ra vấn đề đó, tôi đã để nó một mình. Tôi đã lên kế hoạch sửa nó cho câu trả lời này, nhưng tôi cần dành thời gian đào sâu vào các bước nhảy để giải quyết vấn đề. Lỗi với đầu vào >0rất dễ sửa, nhưng việc đưa ra nó 0sẽ tạo ra lỗi tương tự và sẽ mất thời gian để tìm lại mã để sửa lỗi cho nó. Tôi ước tôi có thể sử dụng Wthay vì UUUUUUUUUU, nhưng nó chơi tàn phá với mã Grass.

1. C # (Trình biên dịch tương tác Visual C #) A022996

n=>40-n

Cũng hoạt động trong C # (.NET Core), C # (trình biên dịch Mono C #), C # (Mono C # Shell) và C # (Trình biên dịch Visual C #)

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

9. 05AB1E , A000004

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (Visual C # Interactive Compiler)
Brainfuck
Runic bùa
Jelly
Gol> <>
JavaScript (Node.js)
ở giữa dấu ngoặc
Khoảng trắng
05AB1E

7. dấu ngoặc , A019590

//
n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (A022996)

BF (A000034)

Runic (A000302)

Thạch (A000312)

Gol> <> (A001361)

JS (ES6) (A000012)

Parenthetic (A019590)

Parenthetic bỏ qua tất cả mọi thứ trừ các nhân vật (và ). 1Mặc dù vậy, tôi đã phải chèn s trước mỗi dấu ngoặc đơn đóng để ngăn Jelly khỏi hoảng sợ (EDIT: Tôi đã bỏ qua một người )chưa từng có bởi 1, vì vậy rõ ràng không phải tất cả đều cần một, nhưng bây giờ đã quá muộn để đánh bại nó). Mã thực tế xác định một lambda được gọi ((())), có thể được gọi trên một số để mang lại kết quả (1 chỉ mục).

10. Không thể đọc được , A001477

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Paranthetic
Whitespace
05AB1E

Không thể đọc được, như tên gọi của nó, là không thể đọc được. Để lập trình nó, tôi phải sử dụng một mẫu và sau đó chuyển đổi từ văn bản có thể đọc thành mã Không thể đọc được.

[A=READ()];DO{(A+1)?:BOTH(PRINT(A),[A=READ()])}
[A=READ()]: '""""""'"""'""""""""""
PRINT(A): '"'"""""""'"""
A?: '""'"""
Functioning:
['""""""'"""'""""""""""];'"""""{('""'"""""""'""")?:'""""('"('"""""""'"""),['""""""'"""'""""""""""])}

Tất cả những gì nó làm là đọc từng ký tự trong đầu vào và đầu ra nó. Một trong những chuỗi nhàm chán hơn, nhưng tốt cho một ngôn ngữ khó làm việc. Tôi cũng đã sử dụng trình tự A000030 trước khi vòng lặp hoạt động.

_{Làm việc thông qua máy tính để bàn từ xa là một nỗi đau, bạn nghĩ rằng mọi thứ hoạt động, thực hiện tất cả các liên kết, sau đó nhận ra rằng một trong số họ đã phá vỡ và không nhận thấy.}

14. Aheui , A007395

Thay đổi một chút để làm cho AlphaBeta hoạt động.

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
/*  
박망희*/               



n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Aheui loại bỏ bất kỳ nhân vật không phải người Hàn Quốc, do đó 박망희, bị loại bỏ, in ra 2và chấm dứt.

C #
Brainfuck
Runic bùa
Jelly
Gol> <>
Javascript (Node.js)
ở giữa dấu ngoặc
Khoảng trắng
05AB12
thể đọc
Grass
Width
AlphaBeta
Aheui

2. Brainfuck , A000034

n=>40-n
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.

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

C #

3. Bùa mê , A000302

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //

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

C #

BF

Nếu bạn cần trợ giúp để duy trì chức năng Runic, có IDE bí truyền cũng như IDE của riêng tôi (được xây dựng trong Unity3D) trong nhánh chính của Runic's git repo . IDE bí truyền không xử lý việc hiển thị định hướng IP rất tốt (chủ yếu là không có khả năng của tôi để thêm như vậy vào khung hiện có).

Tất cả các BF tạo ra một loạt các IP tự chấm dứt do thực hiện các hành động không hợp lệ (chủ yếu là do tràn ngăn xếp) trong khi >C # cư trú trong ngăn xếp với một 4, các phản hồi của các nhà tạo nhận xét (nhân bản trong Runic), đạt được ip@để thực thi x^4trên một nhập x và in kết quả.

5. Gol> <> , A001361

//
n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/
//I01-* h
//
 ;/**/

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

C #
Brainfuck
Runic
Jelly

Sử dụng các dấu nhận xét một dòng trong C # để chuyển hướng IP cá sang mã tác vụ I01-*h, đọc đầu vào, nhân với -1 và xuất kết quả. Gol> <> làm cho việc đọc đầu vào và bỏ ngăn xếp thành một số dễ dàng so với nguyên> <>.

Các không gian được chèn để đảm bảo luồng IP và Runic thích hợp, trong đó cả C # và Jelly đều bỏ qua khoảng trắng hàng đầu trên dòng cuối cùng (và là một tế bào NOP trong cả hai loại nấm).

12. Chiều rộng , A020725

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

1 chỉ mục. Đầu ra bằng mã thoát.

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

Các ký tự duy nhất có liên quan đến Width là a-zA-Z. Mã Độ rộng chạy như sau:

qnnAcaAcAAI

Ba nhân vật đầu tiên qnn, là no-ops. Acđọc một số nguyên từ đầu vào, alà số không, và sau đó AcAAtăng số nguyên lên một. Ikết thúc chương trình và phần trên cùng của ngăn xếp sẽ trở thành mã thoát. Tất cả các chữ cái khác trong chương trình được bỏ qua kể từ khi chương trình kết thúc.

C #
Brainfuck
Runic bùa
Jelly
Gol> <>
JavaScript
dấu ngoặc
Khoảng trắng
05AB1E
thể đọc
Grass

13. AlphaBeta , A162672

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Ban đầu tôi đã dự định sử dụng chuỗi A000030 và mã JCL, nhưng điều đó đã bị làm phiền (tôi không đổ lỗi cho chúng, đây là một chuỗi tốt cho các ngôn ngữ lấy đầu vào là một byte). Mã ban đầu cho mục này sau khi phải chọn một chuỗi mới là:

JiiiiihhZUUUUUNYAxcccccbCLDLxyzUUUUTTxxyzJCLOzWRxyxyzcccccbbCL
^                                                                 Read input (single byte)
                 ^          ^^^      ^^^^    ^  ^^^^^             Clear regisers
        ^                                            ^^^^^^^^^    Input = 0: print 0
 ^^^^^^^ ^^^^^                 ^^^^^^         ^                   Set jump locations
                  ^^^^^^^^                                        Print `1`
                          ^^                                      Print initial byte
                                         ^^^                      Read and print input
                                            ^                     (and loop)

Chuỗi xxxhoặc xyzxyzlà các bộ đệm hữu ích để thực hiện các mục tiêu dễ dàng (46 dễ dàng hơn là "5 * 10-4" - 9 hướng dẫn - so với "4 * 10 + 6 - mười hướng dẫn - nhưng 50 thậm chí là 50 đơn giản hơn: chỉ năm). Bạn sẽ thấy một vài trong số đó.

Nhưng vì có các byte khác trên dòng đầu tiên, các codel nhảy tới cần một số giá trị mới và điều đó đã biến thành:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Tránh thực thi mã này vì mã Width chỉ liên quan đến việc bọc nó Gđể biến nó thành một chuỗi ký tự (không có gì quan trọng trong AlphaBeta), một lệnh để bật đầu ngăn xếp, và sau đó thêm một số Wđể làm cho alpha beta không bị sập khi thoát:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

Tuy nhiên, để tránh xung đột với Grass, thay vì bật lệnh bằng w Cđược sử dụng thay thế. Sau đó, bước nhảy "chương trình thoát" được thay thế bằng UUUUUUthay vì WWWWWWĐiều này không để IP ở đâu đó ở giữa phần còn lại của mã rác, nhưng đủ xa để nó không in bất kỳ lỗi nào. Bất kỳ số lượng Us bổ sung có thể được thêm vào theo cặp nếu điều này trở thành một vấn đề.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

Bổ sung imà Runic kết thúc thực thi là một NOP trên các đầu vào hợp lệ vì không có đầu vào-trái-để-đọc không đẩy gì vào ngăn xếp ("đọc tất cả đầu vào" là một nỗi đau trong Runic).

C #
Brainfuck
Runic bùa
Jelly
Gol> <>
JavaScript
dấu ngoặc
Khoảng trắng
05AB1E
thể đọc
Grass
Width

18.] = [, A010716 , chuỗi cả 5

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'[=====[===]]=[[==========]]=[
/*] 
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Ngôn ngữ này không có trên TIO và trình thông dịch duy nhất của nó được viết bằng ngôn ngữ khác, cũng không có trên TIO. Và người không chơi tốt với Brainfuck tuần trước vào phút cuối, nhưng tôi đã tìm ra điều gì sai sau vài giờ sau khi đăng câu trả lời của Pepe, vì vậy tôi đã lưu nó trong tuần này. Là một ngôn ngữ không có trên TIO, tôi đã coi đây là một ngôn ngữ có thể dễ dàng giải quyết được về bất kỳ mục nào và tiếp tục chuỗi.

• Mã thông dịch viên: https://pastebin.com/raw/yqtpynnh
• Thông dịch viên phiên dịch: https://12me21.github.io/12-basic/

Đặt mã trình thông dịch vào hộp "mã" ở trên cùng, mã từ câu trả lời trong đầu vào, và nhấp chạy và nhận đầu ra (cộng với một số rác bổ sung luôn được in).

Phần hoạt động của] = [là phần này ở cuối dòng đầu tiên:

[=====[===]]=[[==========]]=[

Đó là dấu vết [đã chơi tàn phá với Brainfuck (phần còn lại bị bỏ qua, do cách xử lý [và ]được xử lý bởi Brainfuck) và một khi tôi nhìn vào thông số Brainfuck một lần nữa tôi nhận ra vấn đề và tất cả những gì tôi phải làm là nhét vào ]đâu đó sau dòng đầu tiên (dưới dạng] = [trình thông dịch không đọc dòng mới) và trước Brainfuck. Tôi đã chọn dòng thứ 2.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Khoảng trắng
05AB1E
thể đọc
Grass
Width
AlphaBeta
Aheui (esotope)
Bình Luận Viên
Java (OpenJDK 8)
Pepe

19. Trên thực tế , A005843 (2 * n)

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#,2*1z⌂'[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Phần vận hành: ,2*1z⌂(dòng đầu tiên)

Khi ⌂chấm dứt chương trình, không có mã nào sau đó có hiệu lực và không có ký hiệu nào trước khi nó dẫn đến bất kỳ đầu ra hoặc gây ô nhiễm bộ nhớ hoạt động bất lợi. Phần tồn tại trong một nhận xét (C #, JS, Java), chỉ chứa các ký tự bị bỏ qua (Bình luận viên,] = [, Pepe, Aheui ...), không nằm trên dòng cuối cùng (Jelly), hoặc trong các phần chưa được thực thi của mã (Gol> <>, Runic, AlphaBeta).

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Khoảng trắng
05AB1E
thể đọc
Grass
Width
AlphaBeta
Aheui (esotope)
Bình Luận Viên
Java (OpenJDK 8)
Pepe
] = [(liên kết không thể, xem # 18 để được hướng dẫn)

20. Neim , A008592 (10 * n)

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Tôi không biết Neim hoạt động thế nào. Tôi biết những gì mã ở đây kết thúc, nhưng tôi không biết làm thế nào ngôn ngữ hoạt động.

Ngoài ra, tôi đã nhầm Brainfuck với # 19. Do xung đột lệnh giữa nhiều ngôn ngữ, việc thay đổi đầu vào của Thực tế thành §và sau đó ép buộc nó thành một int với ≈là giải pháp tối ưu.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Khoảng trắng
05AB1E
thể đọc
Grass
Width
AlphaBeta
Aheui (esotope)
Bình Luận Viên
Java (OpenJDK 8)
Pepe
] = [(liên kết không thể, xem # 18 )
Trên thực tế

21. Flobnar , A010709 (Tất cả 4 giây )

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip!4@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

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

Flobnar bắt đầu @và mở rộng ra các mục đánh giá khi các quy tắc ra lệnh ( @đánh giá bất cứ thứ gì ở bên trái, 4đánh giá 4, +đánh giá bất cứ thứ gì ở bên trái được tóm tắt với bất cứ thứ gì ở bên phải, v.v.). Vì vị trí của @chỉ tiếp xúc với Runic, một cách đơn giản !ngăn chặn sự thay đổi của ngăn xếp của Runic.

Cho rằng số liệu đầu vào của Flobnar là "một byte" và đi vào một vòng lặp vô hạn nếu không có byte nào để đọc, tôi quyết định không bận tâm đến bất cứ điều gì phức tạp hơn.

Ngôn ngữ trước

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Khoảng trắng
05AB1E
thể đọc
Grass
Width
AlphaBeta
Aheui (esotope)
Bình Luận Viên
Java (OpenJDK 8)
Pepe ] = [(liên kết không thể, xem # 18 )
Trên thực tế
Neim