Anak kecil saya punya mainan seperti ini:

Mainan ini terdiri dari 10 ember kecil yang dapat ditumpuk, yang akan kami beri nomor dari 1 (yang terkecil) hingga 10 (yang terbesar). Terkadang dia membuat tumpukan kecil dan mainan berakhir seperti ini:

Secara skematis kita dapat mewakili tumpukan seperti ini:

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

Atau, dengan kata lain:

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

Set tumpukan ember ini mudah dipasang kembali untuk membangun kembali set asli (gambar pertama) hanya dengan secara berurutan menempatkan tumpukan ember yang lebih kecil di dalam tumpukan ember yang lebih besar:

                             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

Meskipun demikian, kadang-kadang anak saya mencoba membangun menara, atau membuang ember, dan tumpukan tersebut akhirnya menjadi tidak konsisten dan set aslinya tidak dapat dibangun kembali hanya dengan menempatkan satu tumpukan di dalam tumpukan lainnya. Contoh dari ini:

[[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)

Tantangan

Diberikan daftar daftar bilangan bulat yang mewakili satu set tumpukan ember, kembalikan nilai yang sebenarnya jika daftar tersebut mewakili kumpulan tumpukan yang mudah diulang kembali, atau kesalahan dalam hal lain.

• Input akan diberikan sebagai daftar daftar bilangan bulat, mewakili ember dari atas ke bawah untuk setiap tumpukan.
• Tidak akan ada tumpukan awal yang kosong (Anda tidak akan mendapatkan [[1,2,3],[],[4,5]]input).
• Jumlah total ember dapat berupa apa pun dalam rentang bilangan bulat yang wajar.
• Anak saya hanya memiliki satu set ember sehingga tidak akan ada elemen rangkap.
• Anda dapat memilih dua nilai yang konsisten (dan koheren) untuk truey atau falsey.
• Bucket akan dilabeli dari # 1 hingga #N, menjadi Nbilangan bulat terbesar dalam daftar bilangan bulat. Anak saya masih belum tahu konsep nol.
• Anda dapat menerima input dalam format beralasan apa pun asalkan itu mewakili setumpuk ember. Tetapkan saja dalam jawaban Anda jika Anda mengubah cara Anda menerima input.
• Ini adalah kode-golf , jadi semoga program / fungsi terpendek untuk setiap bahasa menang!

Contohnya

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)

Jelly , 6 5 byte

Terima kasih kepada @Lynn karena telah menghemat 1 byte.

ṢFµJ⁼

Cobalah online! (dilengkapi dengan footer test-suite)

Penjelasan

Ṣ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

Terima kasih untuk byte xnor

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

Cobalah online!

JavaScript (ES6), 59 58 byte

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

Penjelasan

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

Uji kasus

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

Cobalah online!

Haskell , 54 byte

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

Cobalah online!

Haskell , 37 byte

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

Cobalah online!

Cek apakah daftar yang disatukan secara leksikografis lebih kecil dari daftar yang tak terbatas [1,2,3,...]. Karena tidak ada duplikat, setiap ember yang hilang atau ember yang tidak sesuai pesanan akan menyebabkan nilai lebih besar daripada kdi ktempat yang pertama, membuat daftar yang dihasilkan menjadi lebih besar ..

Pyth, 6 byte

UItMsS

Coba di sini.

Penjelasan:

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)

PROLOG (SWI), 54 byte

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

Nah, itu lebih baik. Masih cukup bertele-tele, sayang.

Cobalah online!

Itu s/1 predikat mengambil daftar sebagai argumen dan benar jika daftar adalah daftar ember mudah stackable.

Peningkatan dalam algoritma: jika saya mengurutkan daftar sebelum saya meratakannya, ini memaksa semua sublists untuk diurutkan agar predikat benar. Sedikit "meminjam" dari jawaban Jelly Pietu1998 . Berkat itu saya dapat membuang forallyang lebih dari setengah dari program (lihat di bawah untuk jawaban yang asli).

Bagaimana cara kerjanya?

Predikat itu benar jika semua klausa itu benar:

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

Jawaban sebelumnya, PROLOG (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))).

Cobalah online!

Pyth , 9 16 11 byte (Tetap)

Menggunakan metode yang sama sekali berbeda dari jawaban lainnya. Pendekatan 7 byte yang lebih pendek dapat ditemukan di bawah.

!.EtM.++0sS

Test Suite.

Penjelasan

! .EtM. ++ 0sSQ -> Program lengkap, dengan input implisit di akhir.

          SQ -> Urutkan input berdasarkan elemen tertinggi di setiap sublist.
         s -> Ratakan.
       +0 -> Sertakan a 0.
     . + -> Dapatkan delta dari daftar (yaitu perbedaan antara elemen berurutan)
   tM -> Mengurangi setiap elemen.
 .E -> Elemen kebenaran apa pun (1d benar, 0d salah)
! -> Negate (untuk memiliki nilai-nilai kebenaran / kepalsuan yang masuk akal)

Bagaimana cara kerjanya?

Mari kita ambil beberapa contoh, yang membuatnya lebih mudah untuk dipahami. Anggap inputnya [[1,3,4],[5,7],[2,6]]. Inti dari algoritma ini adalah bahwa setiap delta dalam daftar tidak rata harus 1 agar ember dapat ditumpuk.

• Pertama, Smengubahnya menjadi [[1, 3, 4], [2, 6], [5, 7]].

• Kemudian, smerata itu: [1, 3, 4, 2, 6, 5, 7].

• Letakkan 0di depan:[0, 1, 3, 4, 2, 6, 5, 7]

• .+mendapat delta dari daftar [1, 2, 1, -2, 4, -1, 2],.

• tMmengurangi setiap elemen [0, 1, 0, -3, 3, -2, 1],.

• Setiap non- 0integer benar dalam Pyth, jadi kami memeriksa apakah ada elemen kebenaran dengan .E(yang berarti tumpukan tidak dapat dibentuk dengan benar). Kami mendapatkan True.

• !meniadakan hasil, yang berubah Truemenjadi False.

Jika inputnya, misalnya, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]algoritma akan bekerja seperti ini:

• Diurutkan oleh elemen tertinggi: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]dan diratakan, dengan 0prepended: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

• Delta: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Semua get dikurangi: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• Tidak ada unsur kebenaran, jadi kita dapatkan False. Dengan negasi logis, hasilnya adalah True.

Pyth , 7 byte

qSlsQsS

Test Suite.

Port of the Python menjawab dan variasi dari solusi @ Erik .

Brachylog , 5 byte

oc~⟦₁

Cobalah online!

Unifikasi yang dijelaskan:

?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)

Penjelasan analitis:

Pertama-tama kita mengurutkan daftar, dan kemudian kita menggabungkan (yaitu meratakan 1-dalam) ( oc) sehingga ember ditumpuk dari kanan ke kiri jika memungkinkan. Kemudian, untuk memeriksa apakah bucket telah ditumpuk dengan benar (mis. Tidak ada bucket atau menara yang hilang), kami memeriksa bahwa daftar yang dihasilkan adalah kisaran inklusif dari 1 hingga panjangnya. Sekarang, alih-alih memeriksa daftar dengan rentang [1..n] yang panjangnya ( {l⟦₁?}), kami mencoba mencari input ke fungsi yang menghasilkan kisaran seperti itu ( ~⟦₁), jika ada. Jika input ditemukan, maka program berakhir tanpa masalah, sehingga memicu true.status. Jika tidak ada input yang ditemukan, program gagal, memicu false.status.

Python 2 , 43 byte

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

Cobalah online!

Cek apakah daftar yang disatukan secara leksikografis lebih kecil daripada [1,2,3,...N]besar N. Karena tidak ada duplikat, setiap ember yang hilang atau ember yang tidak sesuai pesanan akan menyebabkan nilai lebih besar dari kpada ktempatnya, membuat daftar yang dihasilkan menjadi lebih besar. Panjang string input mencukupi sebagai batas atas karena setiap angka membutuhkan lebih dari 1 karakter.

MATL , 5 byte

Sgtf=

Cobalah online!

(Masukan implisit, katakanlah {[4,5],[9,10],[1,2,3],[6,7,8]})

S- urutkan susunan input dalam urutan leksikografis ( {[1,2,3],[4,5],[6,7,8],[9,10]})

g- dikonversi menjadi satu array ( cell2mat)

t - duplikat itu

f- temukan indeks nilai bukan nol. Karena input di sini adalah semua bukan nol, kembalikan daftar indeks dari 1 ke panjang (array) ( [1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10])

= - periksa apakah array sama dengan rentang 1 hingga panjang (array)

Japt , 13 12 11 byte

Ini mungkin bisa lebih pendek.

ñÎc äaT e¥1

• 1 byte disimpan berkat ETH

Cobalah atau jalankan semua test case

Penjelasan

                :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 Bytes

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

Tidak Disatukan:

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Ìõ

Cobalah online!

R , 58 byte

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

Cobalah online!

NB: SALAH adalah hasil yang benar, BENAR adalah yang palsu

• -3 byte berkat @JayCe

Penjelasan:

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 terima kasih kepada 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);}

Jumlah byte juga termasuk

using System.Linq;

Cobalah online!

Tidak Disatukan:

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

{$:+:(_,,=}

Cobalah online!

Oww :(... ya!{$:+_,,:)=}

Arang , 19 byte (tidak bersaing?)

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

Cobalah online!

-10 byte berkat ASCII saja .

-3 byte terima kasih kepada ASCII-only untuk implementasi selanjutnya (lihat histori revisi untuk kemungkinan versi yang bersaing).

-untuk kebenaran, untuk kepalsuan.

Input adalah daftar tunggal dari daftar daftar, karena cara Arang mengambil input.

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());}

Cobalah online.

Sepertinya ide yang bagus ketika saya mulai, tetapi bawaan ini hanya membuatnya lebih lama .. Pasti bisa bermain golf dengan menggunakan pendekatan yang lebih manual ..

Terinspirasi oleh jawaban 4-byte 05AB1E @EriktheOutgolfer . 4 vs 213 byte, rofl ..>.>

Penjelasan:

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]