Thử thách này có liên quan đến một số tính năng của ngôn ngữ MATL, như là một phần của sự kiện Ngôn ngữ của tháng 5 năm 2018 . Liên kết thách thức: Chức năng clipboard: sao chép .

Giới thiệu

Chức năng clipboard của MATL lưu trữ ("bản sao") các đầu vào cho bốn cuộc gọi gần đây nhất tới các chức năng nhận đầu vào thông thường. Các hàm thông thường là loại hàm phổ biến nhất trong MATL. Nhập liệu có nghĩa là chức năng mất ít nhất một đầu vào. Nội dung clipboard được lưu trữ có thể được đẩy lên ngăn xếp ("dán").

Thử thách này sẽ lấy nội dung clipboard làm đầu vào. Nó sẽ được giả định rằng tất cả các hàm đã tạo ra trạng thái clipboard đó lấy một hoặc nhiều số nguyên dương làm đầu vào. Vì vậy, trạng thái clipboard có thể được biểu diễn bằng một danh sách các danh sách các số. (Để biết thêm thông tin về cách điền vào bảng tạm, hãy xem thử thách liên quan; nhưng điều đó không cần thiết cho hiện tại).

Giải thích nội dung clipboard

ví dụ 1

Các đầu danh sách bên đề cập đến việc gần đây nhất gọi hàm, và như vậy, Do đó, nhà nước vào clipboard

[[11, 28], [12, 16], [4], [5, 6]]

chỉ ra rằng chức năng cuộc gọi cuối cùng mất hai đầu vào, cụ thể là 11, 28; cuộc gọi thứ hai đã lấy đầu vào 12, 16; vv (Trạng thái clipboard này được tạo bởi mã trong ví dụ đầu tiên của thử thách liên quan).

Ví dụ 2

Nếu không có đủ các lệnh gọi hàm , một số danh sách bên trong trong bảng tạm sẽ trống:

[[7, 5], [], [], []]

(Điều này được tạo ra bởi một chương trình chỉ cần thêm 7và 5).

Ví dụ 3

Các cuộc gọi chức năng có thể có bất kỳ số lượng đầu vào , nhưng luôn luôn ít nhất 1(các chức năng không có đầu vào không thay đổi trạng thái clipboard). Vì vậy, sau đây cũng có thể.

[[3], [2, 40, 34], [7, 8, 15], []]

Truy cập nội dung clipboard

Nội dung của bảng tạm chức năng được đẩy lên ngăn xếp bằng hàm MATL M(nhân tiện, đây không phải là chức năng bình thường, mà là chức năng của bảng tạm). Hàm này lấy một số nguyên dương làm đầu vào và đẩy một số nội dung trong bảng tạm vào ngăn xếp, như sau. Với tham chiếu đến trạng thái clipboard trong ví dụ 1:

[[11, 28], [12, 16], [4], [5, 6]]

• 1Mtrả về tất cả các đầu vào cho lệnh gọi hàm gần đây nhất. Vì vậy, đối với ví dụ được xem xét, nó đưa ra 11, 28.
• Tương tự như vậy, 2M, 3Mvà 4Mtrả lại toàn bộ đầu vào cho phần thứ hai, thứ ba và thứ tư gọi hàm gần đây nhất. Vì vậy, 2Mcho 12, 16; 3Mcho đi 4; và 4Mcho 5, 6.
• Các số vượt quá 4chọn đầu vào riêng lẻ cho các cuộc gọi chức năng đã thực hiện nhiều hơn một đầu vào. Vì vậy, 5Mtrả về đầu vào cuối cùng cho cuộc gọi gần đây nhất . Trong trường hợp của chúng tôi điều này cho 28. 6Mtrả về đầu vào riêng lẻ trước đó , đó là 11. 7Mtrả về đầu vào cuối cùng của cuộc gọi cuối cùng thứ hai, nghĩa là 16, và 8Mcho 12. Bây giờ, 9Mcho 6. Lưu ý cách 4bỏ qua đầu vào vì đó là đầu vào duy nhất trong lệnh gọi hàm của nó. Cuối cùng, 10Mcho 5.

Đối với trạng thái clipboard trong ví dụ 3:

[[3], [2, 40, 34], [7, 8, 15], []]

• 1Mcho 3. 2Mcho 2, 40, 34. 3Mcho 7, 8, 15.
• 4Mcó hành vi không xác định (cho mục đích của thử thách này), vì chỉ có ba lệnh gọi hàm.
• 5Mcho 34. 6Mcho 40. 7Mcho 2. 8Mcho 15. 9Mcho 8, 10Mcho 7.
• 11M,, 12M... cũng có hành vi không xác định .

Các thách thức

Đầu vào :

• trạng thái clipboard, như một danh sách các danh sách, hoặc bất kỳ định dạng hợp lý nào khác;
• một số nguyên dương n .

Đầu ra : kết quả của hàm gọi Mvới n là đầu vào. Đầu ra sẽ là một hoặc một vài số có dấu phân cách rõ ràng hoặc ở bất kỳ định dạng hợp lý nào, chẳng hạn như danh sách hoặc mảng.

Làm rõ:

• Trạng thái clipboard bao gồm bốn danh sách các số. Một số danh sách theo dõi có thể trống, như trong ví dụ 2 và 3. Nếu được ưu tiên, bạn có thể nhập bảng tạm mà không có các danh sách trống đó. Vì vậy, ví dụ 3 sẽ trở thành [[3], [2, 40, 34], [7, 8, 15]].
• Tất cả các số trong bảng tạm sẽ là số nguyên dương, có thể có nhiều hơn một chữ số.
• Số n được đảm bảo là hợp lệ. Vì vậy, ví dụ 3 ở trên, nkhông thể 4hoặc 11.

Quy tắc bổ sung:

• Đầu vào và đầu ra có thể được thực hiện bằng bất kỳ phương tiện hợp lý .

• Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm .

• Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Clipboard state
Number
Output(s)

[[11, 28], [12, 16], [4], []]
2
12, 16

[[11, 28], [12, 16], [4], []]
5
28

[[7, 144], [12], [4, 8], [3, 4, 6]]
1
7, 144

[[7, 144], [12], [4, 8], [3, 4, 6]]
10
4

[[30], [40], [50, 60], [70, 80, 90]]
2
40

[[30], [40], [50, 60], [80, 90]]
7
90

[[15], [30], [2, 3, 5], [4, 5, 10]]
3
2, 3, 5

[[15], [30], [2, 3, 5], [4, 5, 10]]
7
2

Thạch , 8 byte

ḊƇUẎ⁸;⁹ị

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

Haskell , 56 51 47 byte

^{-5 -9 byte nhờ Laikoni (khớp mẫu để đảm bảo độ dài> 1 và sử dụng dochú thích trên mức độ hiểu danh sách)!}

c!n=([]:c++do l@(_:_:_)<-c;reverse$pure<$>l)!!n

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

Pointfree, 58 55 byte

^{-3 byte nhờ Laikoni (di chuyển ([]:)và thay thế id)!}

Ngoài ra, chúng tôi có thể sử dụng phiên bản miễn phí này

(!!).(([]:)<>map pure.(>>=reverse).filter((1<).length)).

APL (Dyalog Unicode) , 17 byte

{⍺⊃⍵⍪∊⊖¨⍵⌿⍨1<≢¨⍵}

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

JavaScript (Node.js) , 57 byte

a=>n=>a.map(e=>e[1]&&a.push(...[...e].reverse()))&&a[n-1]

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

Đây là một chức năng ẩn danh, curried. Chạy nó với( function code )(clipboard)(n)

Giải trình

a=>n=>{
    // The strategy is to append the individual clipboard inputs to the end of a,
    // after the function calls (lists). We then return a[n-1] to offset JavaScript's
    // zero indexing.
    a.map(e=>{
        e[1]&& // if this list has more than one element...
            a.push(...[...e].reverse()) // add each element to a, in reverse order.
            // reverse() modifies the original array, so we have to use [...e] to "clone" e
    })
    return a[n-1]
}

JavaScript (ES6), 72 byte

Đưa đầu vào theo cú pháp currying (clipboard)(n).

a=>m=>a[m-1]||(g=r=>(r=r|a[k][1]&&a[k].pop())?--m<5?r:g(1):g(!++k))(k=0)

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

Python 2 , 60 56 byte

cảm ơn Jonathan Allan cho -4 byte.

lambda l,n:(l+sum([b[::-1]for b in l if b[1:]],[]))[n-1]

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

Java 8, 110 byte

Một lambda (bị quấy rầy) lấy trạng thái clipboard là một int[][]và số là một intvà trả về inthoặc int[](một số duy nhất có thể được trả về thông qua một trong hai loại).

s->n->{if(--n<4)return s[n];else{int i=0,l;for(n-=4;(l=s[i].length)<=n|l<2;i++)n-=l>1?l:0;return s[i][l+~n];}}

Dùng thử trực tuyến

Ung dung

s ->
    n -> {
        if (--n < 4)
            return s[n];
        else {
            int i = 0, l;
            for (
                n -= 4;
                (l = s[i].length) <= n | l < 2;
                i++
            )
                n -= l > 1 ? l : 0;
            return s[i][l + ~n];
        }
    }

05AB1E , 12 byte

Díʒg<Ā}˜«s<è

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

Giải trình

D              # duplicate input list
 í             # reverse each
  ʒg<Ā}        # filter, keep only elements that are longer than 1
       ˜       # flatten
        «      # append to original list
         s<    # decrement the second input
           è   # get the element in the list at that index

Husk , 12 byte

!S+(m;ṁ↔f(¬ε

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

Giải trình

Khá nhiều cổng trực tiếp của câu trả lời Haskell:

!S+(m;ṁ↔f(¬ε  -- example inputs: [[1],[2,3],[4],[5,6,7],[]] 7
 S+           -- concatenate itself with itself modified by
        f(    -- | filter
           ε  -- | | length 1
          ¬   -- | | not
              -- | : [[2,3],[5,6,7],[]]
      ṁ       -- | map and flatten
       ↔      -- | | reverse
              -- | : [3,2,7,6,5]
              -- | map
              -- | | pure
              -- | : [[3],[2],[7],[6],[5]]
              -- : [[1],[2,3],[4],[5,6,7],[],[3],[2],[7],[6],[5]]
!             -- index into it: [2]

R , 58 byte

function(M,n)c(M,unlist(lapply(M[lengths(M)>1],rev)))[[n]]

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

Lấy Mnhư một listvectơ c(); thay thế [[bằng list(, [với c(và ]bằng) nên chuyển đổi các trường hợp thử nghiệm thành các trường hợp thử nghiệm R.

Đối với các đầu vào n<=4có "hành vi không xác định", trả về NULLvà đối với các đầu vào không hợp lệ khác, sẽ đưa ra lỗi "đăng ký ngoài giới hạn".

function(M,n)
                                        [[n]]	# take the nth element of
c(M,                                   )	# M concatenated with:
    unlist(                           )		# the individual elements of
           lapply(               ,rev)		# in-place reversals of
                  M[lengths(M)>1]		# elements of M with length > 1

Stax , 12 14 13 byte

àJ├∙ε╝F▀ÿi☻Ia

Chạy và gỡ lỗi nó

Giải trình:

vsc{%vfr$r+@]|u Full program, unpacked, implicit input
vs              Decrement the number and get the list
  c{  f         Copy and filter:
    %v            Length not equal to 1?
       r$r      Reverse, flatten, and reverse again
          +     Concat orig array and and modified array
           @]|u Index, wrap into array, uneval

Stax, 12 byte

Å{b≈\☼╣Δ@░ ‼

Giải nén:

{vsc{%vfr$r+@}

Đây là một khối, vì vậy tôi có thể thoát khỏi ]|u, nhưng tôi không biết điều này có hợp lệ không vì nó đóng gói một khối.

J , 33 22 byte

-11 byte (ngắn hơn 1/3) nhờ giải pháp của FrownyFrog!

{0;],|.&.>;/@;@#~1<#&>

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

Giải pháp ban đầu của tôi:

J , 33 byte

<:@[{(,[:<"0@;[:|.&.>(1<#)&>#])@]

Không vui - tôi khá chắc chắn rằng nó có thể được chơi gôn hơn nữa.

Giải trình:

Một hàm dyadic, lấy trạng thái clipboard làm đối số cứng nhắc của nó, đối số bên trái là n

<:@[ trừ 1 từ đối số bên trái

{chọn iphần tử thứ (tính ở trên) từ danh sách bên phải

(...) toàn bộ danh sách

# bản sao

] từ danh sách trạng thái clipboard

(1<#) danh sách con có độ dài lớn hơn 1

|.&.> xoay từng danh sách con được sao chép

<"0@; raze và hộp - đặt mỗi số vào một hộp riêng

, nối thêm danh sách mới vào danh sách trạng thái clipboard

@] làm cho toàn bộ động từ trong (...) đơn âm

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

Lõi V + , 53 45 43 42 40 byte

^{-9 byte nhờ DJMcMayhem (sử dụng VGÇ /dhơn :,$g/^[^ ]*$/d, D@"ddhơn "aDÀddvà !!hơn :.!)!}

Lần thử đầu tiên của tôi tại V (mẹo chào mừng!), Đoạn mã dưới đây đang sử dụng các ký tự được khoanh tròn (ví dụ: ⓞfor \xf) để dễ đọc:

jäGⓞVGÇ /d
ⓞò!!tr \  \\n|tac
jòHD@"ddjdG

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

Hexdump

00000000: 6ae4 470f 5647 c720 2f64 0a0f f221 2174  j.G.VG. /d...!!t
00000010: 7220 5c20 205c 5c6e 7c74 6163 0a6a f248  r \  \\n|tac.j.H
00000020: 4440 2264 646a 6447                      D@"ddjdG

Giải trình

Dòng đầu tiên chứa n và các dòng bên dưới chứa các mục của bảng tạm, mỗi mục được phân tách bằng dấu cách nếu có nhiều đầu vào:

j                        " move to the beginning of the clipboard entries
 äG                      " duplicate the clipboard
   ⓞ                    " <C-o> move cursor to the beginning of the 2nd copy
     VG                  " select everything from cursor to the end of buffer and ..
       Ç /d              " .. delete every line that doesn't contain a space

ⓞ                       " <C-o> move cursor to the beginning of the 2nd copy (now without single arguments)
  ò                   ò  " do the following until the end of buffer
   !!                    "   on the current line execute the shell command
     tr \  \\n           "   replace spaces with newlines
              |tac⮠     "   and reverse the lines
                    j    "   move to next line

H                        " go to the beginning of buffer (where n is)
 D                       " delete n (stores it in register ")
  @"                     " that many times ..
    dd                   " .. remove the line
      j                  " move cursor to next line
       dG                " delete everything from here to the end of buffer

Màu đỏ , 91 byte

func[b n][a: copy[]foreach c b[if 1 < length? c[append a reverse copy c]]pick append b a n]

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

C (gcc) , 176 byte

#define p printf("%d ",
int*_,i;f(x,n)int**x;{if(n<5){for(_=x[2*n-2];_-x[2*n-1];++_)p*_);}else{n-=4;for(i=0;i<8;i+=2)if(n&&x[i]+1-x[i+1])for(_=x[i+1];_-x[i]&&n;--_,--n);p*_);}}

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

Lấy mảng là một danh sách gồm 4 cặp con trỏ bắt đầu / kết thúc, sau đó n.

Sự miêu tả:

#define p printf("%d ",  // This gives us the short-hand for printing
int*_,                   // This defines _ as a pointer to int
i;                       // This defines i as an integer
f(x,n)int**x;{           // This defines f as a function taking int **x and int n
                         // NOTE: x is {start, end, start, end, start, end, start, end}
if (n<5) {               // This is for the 1-4 case
  for(_=x[2*n-2];        // Loop _ from the 'end pointer' 
  _-x[2*n-1];++_)        // Until the 'start pointer'
  p*_);                  // Using the short-hand, print *_
}else{                   // This is for the 5+ case
  n-=4;                  // Cut n to improve indexing
  for(i=0;i<8;i+=2)      // Loop over each 'start pointer index'
    for(_=x[i+1];        // Loop _ from the 'end pointer'
        _-x[i]&&n;       // Until the 'start pointer' or n becomes 0
        --_,--n);        // Decreasing n each time
  p*_);}}                // _ now points to the 'correct' index, so print it