Mein kleines Kind hat so ein Spielzeug:

Dieses Spielzeug besteht aus 10 stapelbaren kleinen Eimern, die von 1 (der kleinste) bis 10 (der größte) nummeriert werden. Manchmal macht er kleine Stapel und das Spielzeug endet so:

Wir können die Pfähle wie folgt schematisch darstellen:

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

Oder anders ausgedrückt:

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

Dieser Satz von Eimern kann leicht wieder gestapelt werden, um den ursprünglichen Satz (das erste Bild) wiederherzustellen, indem Stapel von kleineren Eimern nacheinander in Stapel von größeren Eimern platziert werden:

                             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

Trotzdem versucht mein Kind manchmal, Türme zu bauen, oder wirft Eimer weg, und die Stapel werden inkonsistent, und das ursprüngliche Set kann nicht wiederhergestellt werden, indem nur ein Stapel in den anderen gelegt wird. Beispiele hierfür:

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

Herausforderung

Geben Sie bei einer Liste von Listen mit ganzen Zahlen, die eine Gruppe von Eimerstapeln darstellen, einen Wahrheitswert zurück, wenn die Listen eine leicht wieder stapelbare Gruppe von Stapeln darstellen, oder in einem anderen Fall Falsch.

• Die Eingabe erfolgt als Liste mit ganzen Zahlen, die die Bereiche von oben nach unten für jeden Stapel darstellen.
• Es wird keine leeren Startstapel geben (Sie werden nicht [[1,2,3],[],[4,5]]als Eingabe erhalten).
• Die Gesamtzahl der Buckets kann innerhalb eines vernünftigen ganzzahligen Bereichs liegen.
• Mein Kind hat nur einen Satz Eimer, damit es keine doppelten Elemente gibt.
• Sie können zwei beliebige konsistente (und kohärente) Werte für truthy oder falsey auswählen.
• Die Buckets werden mit # 1 bis #N bezeichnet, wobei es sich um Ndie größte Ganzzahl in der Liste der Ganzzahlen handelt. Mein Kind kennt das Konzept der Null immer noch nicht.
• Sie können die Eingabe in jedem vernünftigen Format erhalten, sofern es sich um eine Reihe von Eimern handelt. Geben Sie es einfach in Ihrer Antwort an, wenn Sie die Art und Weise ändern, in der Sie die Eingabe erhalten.
• Das ist Code-Golf , also kann das kürzeste Programm / die kürzeste Funktion für jede Sprache gewinnen!

Beispiele

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)

Gelee , 6 5 Bytes

Vielen Dank an @Lynn für das Speichern von 1 Byte.

ṢFµJ⁼

Probieren Sie es online! (kommt mit Fußzeile der Testsuite)

Erläuterung

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

Danke für das Byte xnor

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

Probieren Sie es online!

JavaScript (ES6), 59-58 Byte

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

Erläuterung

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

Testfälle

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 Bytes

{˜āQ

Probieren Sie es online!

Haskell , 54 Bytes

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

Probieren Sie es online!

Haskell , 37 Bytes

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

Probieren Sie es online!

Überprüft, ob die verkettete sortierte Liste lexikografisch kleiner als die unendliche Liste ist [1,2,3,...]. Da es keine Duplikate gibt, würde ein fehlender oder nicht ordnungsgemäßer Bucket einen höheren Wert als kan der kdritten Stelle verursachen, wodurch die resultierende Liste größer wird.

Pyth, 6 Bytes

UItMsS

Probieren Sie es hier aus.

Erläuterung:

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 Bytes

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

Nun , das ist besser. Leider immer noch ziemlich ausführlich.

Probieren Sie es online!

Das s/1Prädikat nimmt eine Liste als Argument und ist wahr, wenn die Liste eine Liste von leicht stapelbaren Buckets ist.

Verbesserung des Algorithmus: Wenn ich die Liste sortiere, bevor ich sie reduziert habe, werden alle Unterlisten sortiert, damit das Prädikat wahr ist. Etwas "entlehnt" von Pietu1998's Jelly-Antwort . Dank dessen kann ich das ausgeben, forallwas mehr als die Hälfte des Programms ist (siehe unten für die ursprüngliche Antwort).

Wie funktioniert es?

Das Prädikat ist wahr, wenn alle seine Klauseln wahr sind:

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

Vorherige Antwort, PROLOG (SWI), 109 Bytes

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

Probieren Sie es online!

Pyth , 9 16 11 Bytes (Fest)

Verwendet eine völlig andere Methode als die andere Antwort. Ein kürzerer 7-Byte-Ansatz ist nachstehend aufgeführt.

!.EtM.++0sS

Test Suite.

Erläuterung

! .EtM. ++ 0sSQ -> Vollständiges Programm mit impliziter Eingabe am Ende.

          SQ -> Sortieren Sie die Eingabe nach dem höchsten Element in jeder Unterliste.
         s -> Abflachen.
       +0 -> 0 voranstellen.
     . + -> Ermittelt die Deltas der Liste (dh Unterschiede zwischen aufeinanderfolgenden Elementen)
   tM -> Dekrementiere jedes Element.
 .E -> Jedes wahrheitsgemäße Element (Einsen sind wahr, Nullen sind falsch)
! -> Negieren (um kohärente wahrheitsgemäße / falsche Werte zu haben)

Wie funktioniert das?

Nehmen wir ein paar Beispiele, die das Verständnis erleichtern. Nehmen wir an, die Eingabe ist [[1,3,4],[5,7],[2,6]]. Der Kern dieses Algorithmus besteht darin, dass jedes Delta in der nicht abgeflachten Liste 1 sein muss, damit die Buckets stapelbar sind.

• Zunächst Smacht es in [[1, 3, 4], [2, 6], [5, 7]].

• Dann sflacht es: [1, 3, 4, 2, 6, 5, 7].

• Voranstellen 0:[0, 1, 3, 4, 2, 6, 5, 7]

• .+Ruft die Deltas der Liste ab [1, 2, 1, -2, 4, -1, 2].

• tMdekrementiert jedes Element [0, 1, 0, -3, 3, -2, 1].

• Jede Nicht- 0Ganzzahl ist in Pyth wahr, also prüfen wir, ob es ein wahres Element gibt .E(was bedeutet, dass der Stapel nicht korrekt gebildet werden kann). Wir bekommen True.

• !negiert das Ergebnis, das sich Truein verwandelt False.

Wenn die Eingabe beispielsweise so wäre, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]würde der Algorithmus folgendermaßen funktionieren:

• Sortiert nach dem höchsten Element: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]und abgeflacht, mit einem 0vorangestellt: [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]. Alle get verringert: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• Es gibt kein wahres Element, also bekommen wir False. Durch logische Verneinung ist das Ergebnis True.

Pyth , 7 Bytes

qSlsQsS

Test Suite.

Port of the Python-Antwort und eine Variante von @ Eriks Lösung .

Brachylog , 5 Bytes

oc~⟦₁

Probieren Sie es online!

Erklärte Vereinigungen:

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

Analytische Erklärung:

First of all we sort the list of lists, and then we concatenate (i.e. flatten 1-deep) (oc) so that the buckets get stacked right-to-left if possible. Then, to check if the buckets have been stacked correctly (i.e. no missing buckets or towers), we check that the resulting list is an inclusive range from 1 to its length. Now, instead of equal-checking the list with the [1..n] range of its length ({l⟦₁?}), we try to find an input to a function that generates such a range (~⟦₁), if there is one. If an input is found, then the program ends with no issues, so it triggers a true. status. If no input is found, the program fails, triggering a false. status.

Python 2, 43 bytes

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

Try it online!

Checks whether the concatenated sorted list is lexicographically smaller than [1,2,3,...N] for large N. Since there are no duplicates, any missing bucket or out-of-order bucket would cause a value greater than k in the k'th place, making the resulting list be bigger. The string-length of the input suffices as an upper bound since each numbers takes more than 1 character.

MATL, 5 bytes

Sgtf=

Try it online!

(Implicit input, say {[4,5],[9,10],[1,2,3],[6,7,8]})

S - sort input arrays in lexicographic order ({[1,2,3],[4,5],[6,7,8],[9,10]})

g - convert into a single array (cell2mat)

t - duplicate that

f - find indices of non-zero values. Since input here is all non-zeros, returns the list of indices from 1 to length(array) ([1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10])

= - check that the array is equal to the range 1 to length(array)

Japt, 13 12 11 bytes

This could probably be shorter.

ñÎc äaT e¥1

• 1 byte saved thanks to ETH

Try it or run all test cases

Explanation

                :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)}

Ungolfed:

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 bytes

ñg c
eUÌõ

Try it online!

R, 58 bytes

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

Try it online!

N.B. : FALSE is the truthy outcome, TRUE is the falsy one

• -3 bytes thanks to @JayCe

Explanation :

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 bytes

-13 bytes thanks to 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);}

Byte count also includes

using System.Linq;

Try it online!

Ungolfed:

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 bytes

{$:+:(_,,=}

Try it online!

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

Charcoal, 19 bytes (non-competing?)

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

Try it online!

-10 bytes thanks to ASCII-only.

-3 bytes thanks to ASCII-only for a subsequent implementation (see revision history for possibly competing version).

- for truthy, for falsy.

Input is a singleton list of a list of lists, because of how Charcoal takes input.

Java 10, 213 bytes

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

Try it online.

It seemed like a good idea when I started, but these builtins only make it longer.. Can definitely be golfed by using a more manual approach..

Inspired by @EriktheOutgolfer's 4-byte 05AB1E answer. 4 vs 213 bytes, rofl.. >.>

Explanation:

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]