Con nhỏ của tôi có một món đồ chơi như thế này:

Đồ chơi này bao gồm 10 thùng nhỏ có thể xếp chồng lên nhau, chúng ta sẽ đánh số từ 1 (cái nhỏ nhất) đến 10 (cái lớn nhất). Đôi khi anh ta làm những đống nhỏ và đồ chơi kết thúc như thế này:

Chúng ta có thể biểu diễn sơ đồ các cọc như thế này:

      1  6
4  9  2  7
5  10 3  8
----------  <-- Floor
1  2  3  4  <-- Pile #

Hoặc, đặt nó theo một cách khác:

[[4,5],[9,10],[1,2,3],[6,7,8]]

Bộ cọc xô này có thể dễ dàng đóng gói lại để xây dựng lại bộ ban đầu (hình ảnh đầu tiên) chỉ bằng cách đặt liên tiếp các cọc nhỏ hơn vào trong các thùng lớn hơn:

                             1                            1  6
                             2                            2  7
      1  6                   3        6                   3  8
4  9  2  7                   4  9     7                   4  9
5  10 3  8                   5  10    8                   5  10
---------- > [Pile 3 to 1] > ---------- > [Pile 4 to 2] > ---------- > [Pile 1 to 2] > Done!
1  2  3  4                   1  2  3  4                   1  2  3  4

Tuy nhiên, đôi khi con tôi cố gắng xây dựng các tòa tháp, hoặc ném xô đi, và các cọc cuối cùng không nhất quán và bộ ban đầu không thể được xây dựng lại chỉ bằng cách đặt một đống bên trong một cái khác. Ví dụ về điều này:

[[1,3,2],[4]] (the kid tried to build a tower by placing a bigger bucket
               over a smaller one, we would need to reorder the buckets
               first)
[[1,3,4],[2]] (the kid left aside an unordered bucket, we would need to remove
               bucket #1 from pile #1 before restacking)
[[1,2,3],[5]] (the kid lost a bucket, we need to find it first)

Thử thách

Đưa ra một danh sách các danh sách số nguyên biểu thị một bộ cọc xô, trả về giá trị trung thực nếu danh sách đó đại diện cho một bộ cọc có thể đóng gói lại dễ dàng hoặc falsey trong bất kỳ trường hợp nào khác.

• Đầu vào sẽ được cung cấp dưới dạng danh sách các số nguyên, biểu thị các nhóm từ trên xuống dưới cho mỗi ngăn xếp.
• Sẽ không có cọc bắt đầu trống (bạn sẽ không nhận được [[1,2,3],[],[4,5]]đầu vào).
• Tổng số xô có thể là bất kỳ trong phạm vi số nguyên hợp lý.
• Con tôi chỉ có một bộ xô nên sẽ không có yếu tố trùng lặp.
• Bạn có thể chọn bất kỳ hai giá trị nhất quán (và nhất quán) cho tính trung thực hoặc falsey.
• Các nhóm sẽ được gắn nhãn từ # 1 đến #N, là Nsố nguyên lớn nhất trong danh sách các số nguyên. Con tôi vẫn chưa biết khái niệm về số không.
• Bạn có thể nhận được đầu vào ở bất kỳ định dạng hợp lý nào miễn là nó đại diện cho một nhóm các thùng. Chỉ cần xác định nó trong câu trả lời của bạn nếu bạn thay đổi cách bạn nhận được đầu vào.
• Đây là môn đánh gôn , vì vậy có thể chương trình / chức năng ngắn nhất cho mỗi ngôn ngữ sẽ giành chiến thắng!

Ví dụ

Input:  [[4,5],[9,10],[1,2,3],[6,7,8]]
Output: Truthy

Input:  [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]
Output: Truthy

Input:  [[2,3,4],[1],[5,6,7]]
Output: Truthy

Input:  [[1,2],[5,6],[7,8,9]]
Output: Falsey (buckets #3 and #4 are missing)

Input:  [[2,3,4],[5,6,7]]
Output: Falsey (bucket #1 is missing)

Input:  [[1,3,4],[5,7],[2,6]]
Output: Falsey (non-restackable piles)

Input:  [[1,4,3],[2],[5,6]]
Output: Falsey (one of the piles is a tower)

Thạch , 6 5 byte

Cảm ơn @Lynn vì đã tiết kiệm 1 byte.

ṢFµJ⁼

Hãy thử trực tuyến! (đi kèm với phần chân thử nghiệm)

Giải trình

ṢFµJ⁼    Main link. Argument: piles
Ṣ          Sort the piles by the size of the top bucket.
 F         Stack the piles, putting the left one to the top.
   J       See what a full pile with this many buckets would look like.
    ⁼      See if that looks like the pile you built.

Python 2 , 53 52 byte

Cảm ơn byte xnor

lambda x:sum(sorted(x),[0])==range(len(sum(x,[]))+1)

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

JavaScript (ES6), 59 58 byte

a=>!(a.sort((a,[b])=>a[i=0]-b)+'').split`,`.some(v=>v-++i)

Giải trình

a=>                                                        // given a 2D-array 'a'
     a.sort((a,[b])=>a[i=0]-b)                             // sort by first item
                              +''                          // flatten
    (                            ).split`,`                // split again
                                           .some(v=>v-++i) // i such that a[i] != i+1?
   !                                                       // true if none was found

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

let f =

a=>!(a.sort((a,[b])=>a[i=0]-b)+'').split`,`.some(v=>v-++i)

// truthy
console.log(f([[4,5],[9,10],[1,2,3],[6,7,8]]))
console.log(f([[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]))
console.log(f([[2,3,4],[1],[5,6,7]]))

// falsy
console.log(f([[1,2],[5,6],[7,8,9]]))
console.log(f([[2,3,4],[5,6,7]]))
console.log(f([[1,3,4],[5,7],[2,6]]))
console.log(f([[1,4,3],[2],[5,6]]))

05AB1E , 4 byte

{˜āQ

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

Haskell , 54 byte

import Data.List
f l=(sort l>>=id)==[1..length$l>>=id]

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

Haskell , 37 byte

import Data.List
(<[1..]).concat.sort

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

Kiểm tra xem danh sách được sắp xếp nối có nhỏ hơn về mặt từ vựng so với danh sách vô hạn hay không [1,2,3,...]. Vì không có bản sao, nên bất kỳ nhóm nào bị thiếu hoặc nhóm không theo thứ tự sẽ gây ra giá trị lớn hơn kở kvị trí thứ nhất, làm cho danh sách kết quả lớn hơn ..

Bình thường, 6 byte

UItMsS

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

Giải trình:

UItMsSQ
UI      Invariant from U (range(len(A)) for our purpose)
  tM     Map t (A - 1 for our purpose)
    s     s (flatten 1-deep for our purpose)
     S     S (sort for our purpose)
      Q     Q (autoinitialized to input) (implicit)

PRITAL (SWI), 54 byte

s(L):-sort(L,M),flatten(M,N),last(N,O),numlist(1,O,N).

Bây giờ thì tốt hơn rồi. Vẫn còn khá dài dòng, than ôi.

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

Vị s/1ngữ lấy một danh sách làm đối số và là đúng nếu danh sách là danh sách các nhóm có thể xếp chồng dễ dàng.

Cải thiện thuật toán: nếu tôi sắp xếp danh sách trước khi tôi làm phẳng nó, điều này buộc tất cả các danh sách con phải được sắp xếp để vị ngữ là đúng. Hơi "mượn" từ câu trả lời Jelly của Pietu1998 . Nhờ đó tôi có thể bỏ đi forallhơn một nửa chương trình (xem bên dưới để biết câu trả lời ban đầu).

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

Vị ngữ là đúng nếu tất cả các mệnh đề của nó là đúng:

s(L) :-
    sort(L,M),                % M is L sorted in ascending order
    flatten(M,N),             % N is the 1-dimention version of M
    last(N,O),                % O is the last elemnt of N
    numlist(1,O,N).           % N is the list of all integers from 1 to O

Câu trả lời trước, PRITAL (SWI), 109 byte

s(L):-flatten(L,M),sort(M,N),last(N,O),numlist(1,O,N),forall(member(A,L),(A=[B|_],last(A,C),numlist(B,C,A))).

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

Pyth , 9 16 11 byte (Đã sửa)

Sử dụng một phương pháp hoàn toàn khác với câu trả lời khác. Một cách tiếp cận ngắn hơn, 7 byte có thể được tìm thấy dưới đây.

!.EtM.++0sS

Phòng thử nghiệm.

Giải trình

! .EtM. ++ 0sSQ -> Chương trình đầy đủ, với đầu vào ẩn ở cuối.

          SQ -> Sắp xếp đầu vào theo thành phần cao nhất trong mỗi danh sách con.
         s -> Làm phẳng.
       +0 -> Chuẩn bị 0.
     . + -> Nhận các đặc điểm của danh sách (nghĩa là sự khác biệt giữa các yếu tố liên tiếp)
   tM -> Giảm từng phần tử.
 .E -> Bất kỳ yếu tố trung thực nào (1s là trung thực, 0 là sai lệch)
! -> Phủ định (để có các giá trị trung thực / sai lệch nhất quán)

Cái này hoạt động ra sao?

Chúng ta hãy lấy một vài ví dụ, để dễ hiểu hơn. Giả sử đầu vào là [[1,3,4],[5,7],[2,6]]. Cốt lõi của thuật toán này là mỗi delta trong danh sách không được làm phẳng phải là 1 để các thùng có thể xếp chồng lên nhau.

• Đầu tiên, Sbiến nó thành [[1, 3, 4], [2, 6], [5, 7]].

• Sau đó, slàm phẳng nó : [1, 3, 4, 2, 6, 5, 7].

• Chuẩn bị 0trước một:[0, 1, 3, 4, 2, 6, 5, 7]

• .+được deltas của danh sách , [1, 2, 1, -2, 4, -1, 2].

• tMgiảm từng phần tử , [0, 1, 0, -3, 3, -2, 1].

• Bất kỳ 0số nguyên nào là trung thực trong Pyth, vì vậy chúng tôi kiểm tra xem có phần tử trung thực nào không .E(có nghĩa là ngăn xếp không thể được hình thành chính xác). Chúng tôi nhận được True.

• !phủ nhận kết quả, mà biến Truethành False.

Nếu đầu vào là, ví dụ, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]thuật toán sẽ hoạt động theo cách này:

• Sắp xếp theo phần tử cao nhất: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]và được làm phẳng, với phần được đặt 0trước : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

• Đồng bằng : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Tất cả được giảm dần : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• Không có yếu tố trung thực, vì vậy chúng tôi nhận được False. Bằng cách phủ định logic, kết quả làTrue .

Bình , 7 byte

qSlsQsS

Phòng thử nghiệm.

Cổng của câu trả lời Python và một biến thể của giải pháp @ Erik .

Brachylog , 5 byte

oc~⟦₁

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

Giải thích thống nhất:

?o₀c₀~⟦₁.
?         The input (implicit)
 o₀       Sorted (subscript default = 0 => ascending)
   c₀     Concatenated (subscript default = 0 => no length check)
     ~    Inverse (find the input)
      ⟦₁   Range (subscript = 1 => [1..input])
        . The output (implicit)

Giải thích phân tích:

Trước hết, chúng tôi sắp xếp danh sách các danh sách, và sau đó chúng tôi ghép (nghĩa là làm phẳng 1 độ sâu) ( oc) để các thùng được xếp chồng lên nhau từ phải sang trái nếu có thể. Sau đó, để kiểm tra xem các thùng đã được xếp chồng chính xác chưa (nghĩa là không có xô hoặc tháp bị thiếu), chúng tôi kiểm tra xem danh sách kết quả có nằm trong phạm vi bao gồm từ 1 đến chiều dài của nó không. Bây giờ, thay vì kiểm tra bằng danh sách với phạm vi [1..n] có độ dài của nó ( {l⟦₁?}), chúng tôi cố gắng tìm đầu vào cho hàm tạo ra một phạm vi ( ~⟦₁) như vậy , nếu có. Nếu một đầu vào được tìm thấy, thì chương trình kết thúc mà không có vấn đề gì, vì vậy nó kích hoạt một true.trạng thái. Nếu không tìm thấy đầu vào, chương trình thất bại, kích hoạt false.trạng thái.

Python 2 , 43 byte

lambda l:sum(sorted(l),[0])<range(len(`l`))

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

Kiểm tra xem danh sách được sắp xếp nối có nhỏ hơn về mặt từ vựng so [1,2,3,...N]với lớn không N. Vì không có bản sao, nên bất kỳ nhóm nào bị thiếu hoặc nhóm không theo thứ tự sẽ gây ra giá trị lớn hơn kở kvị trí thứ nhất, làm cho danh sách kết quả lớn hơn. Độ dài chuỗi của đầu vào đủ làm giới hạn trên do mỗi số có nhiều hơn 1 ký tự.

MATL , 5 byte

Sgtf=

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

(Nhập liệu ngầm, nói {[4,5],[9,10],[1,2,3],[6,7,8]} )

S - sắp xếp các mảng đầu vào theo thứ tự từ điển ({[1,2,3],[4,5],[6,7,8],[9,10]} )

g - chuyển đổi thành một mảng duy nhất (cell2mat )

t - nhân đôi điều đó

f- tìm chỉ số của các giá trị khác không. Vì đầu vào ở đây là tất cả các số không, nên trả về danh sách các chỉ số từ 1 đến chiều dài (mảng) ([1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10] )

= - kiểm tra xem mảng có bằng phạm vi từ 1 đến chiều dài không (mảng)

Japt , 13 12 11 byte

Điều này có thể có thể ngắn hơn.

ñÎc äaT e¥1

• Lưu 1 byte nhờ ETH

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

Giải trình

                :Implicit input of 2D array `U`
ñÎ              :Sort sub-arrays by their first element
  c             :Flatten
      T         :Prepend 0
    äa          :Consecutive absolute differences
        e¥1     :Does every element equal 1?

Scala, 49 byte

p=>{val s=p.sortBy(_(0)).flatten
s==(1 to s.max)}

Ung dung:

piles: List[List[Int]] =>
{
  val sorted = piles.sortBy(pile=>pile(0)).flatten //Since piles are sequential, we can sort them by their first element
  sorted == (1 to sorted.max) //If all the buckets are present and in order, after sorting them it should be equivalent to counting up from 1 to the max bucket
}

Japt , 9 byte

ñg c
eUÌõ

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

R , 58 byte

function(v,a=unlist(v[order(sapply(v,min))]))any(a-seq(a))

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

Lưu ý: FALSE là kết quả trung thực, TRUE là kết quả sai

• -3 byte nhờ @JayCe

Giải trình :

a=unlist(v[order(sapply(v,min))])  # order the list of vector by the min value and flatten
all(a==seq(a=a))                   # if the flattened list is equal to 1:length then it's ok

C # (.NET Core) , 157 145 132 byte

-13 byte nhờ TheLethalCoder

l=>{var k=l.OrderBy(x=>x[0]).SelectMany(x=>x);return!Enumerable.Range(1,k.Count()).Zip(k,(x,y)=>x==y).Any(x=>!x);}

Số lượng byte cũng bao gồm

using System.Linq;

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

Ung dung:

l => {
        var k = l.OrderBy(x=>x[0])              // First, sort stacks by first bucket
                 .SelectMany(x => x);           // Concatenate stacks into one
        return !Enumerable.Range(1, k.Count())  // Create a sequence [1...n]
               .Zip(k, (x, y) => x == y)        // Check if our big stack corresponds the sequence
               .Any(x => !x);                   // Return if there were any differences
     };

CJam , 11 byte

{$:+:(_,,=}

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

Ồ :(... vâng!{$:+_,,:)=}

Than , 19 byte (không cạnh tranh?)

Ａ▷m⟦▷s▷vθυ⟧θ⁼θ…·¹Ｌθ

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

-10 byte chỉ nhờ ASCII .

-3 byte chỉ nhờ ASCII cho lần triển khai tiếp theo (xem lịch sử sửa đổi để biết phiên bản có thể cạnh tranh).

-cho truthy, cho falsy.

Đầu vào là một danh sách đơn của một danh sách các danh sách, vì cách Char than lấy đầu vào.

Java 10, 213 byte

import java.util.*;m->{Arrays.sort(m,(a,b)->Long.compare(a[0],b[0]));var r=Arrays.stream(m).flatMapToInt(Arrays::stream).toArray();return Arrays.equals(r,java.util.stream.IntStream.range(1,r.length+1).toArray());}

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

Có vẻ như đó là một ý tưởng tốt khi tôi bắt đầu, nhưng những nội dung này chỉ làm cho nó dài hơn .. Chắc chắn có thể được đánh gôn bằng cách sử dụng một cách tiếp cận thủ công hơn ..

Lấy cảm hứng từ @EriktheOutgolfer 4-byte 05AB1E câu trả lời 's . 4 so với 213 byte, rofl ..>.>

Giải trình:

import java.util.*;      // Required import for Arrays
m->{                     // Method with 2D integer-array parameter and boolean return-type
  Arrays.sort(m,         //  Sort the 2D input-array on:
    (a,b)->Long.compare(a[0],b[0])); 
                         //  The first values of the inner arrays
var r=Arrays.stream(m).flatMapToInt(Arrays::stream).toArray();
                         //  Flatten the 2D array to a single integer-array
return Arrays.equals(r,  //  Check if this integer-array is equal to:
  java.util.stream.IntStream.range(1,r.length+1).toArray());} 
                         //  An integer-array of the range [1, length+1]