У моєї маленької дитини така іграшка:

Ця іграшка складається з 10 відстійних маленьких відро, яких ми будемо налічувати від 1 (найменшого) до 10 (найбільшого). Іноді він робить невеликі палі, іграшка закінчується так:

Ми можемо схематично зобразити палі таким чином:

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

Або, по-іншому:

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

Цей набір паль відра легко перекомпонувати, щоб відновити початковий набір (перше зображення), лише послідовно розміщуючи палі менших відров усередині паль великих розмірів:

                             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

Тим не менш, іноді моя дитина намагається будувати вежі або викидає відра, а палі в кінцевому підсумку є непослідовними, і оригінальний набір неможливо відновити, просто помістивши одну купу в іншу. Приклади цього:

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

Виклик

З огляду на список списків цілих чисел, що представляють собою набір паль ковшів, поверніть тритипове значення, якщо списки представляють набір паль, що легко перезавантажуються, або фальси в будь-якому іншому випадку.

• Введення подається у вигляді списку цілих чисел, що представляють відрізки зверху вниз для кожного стека.
• Там не будуть порожніми , починаючи палі (ви не отримаєте в [[1,2,3],[],[4,5]]якості вхідних даних).
• Загальна кількість відра може бути будь-якою в межах розумного цілого діапазону.
• У моєї дитини є лише один набір відро, щоб не було дублюючих елементів.
• Ви можете вибрати будь-які два послідовних (і когерентних) значення для truthy або falsey.
• Відра будуть позначені від 1 до # N, будучи Nнайбільшим цілим числом у списках цілих чисел. Моя дитина досі не знає поняття нуля.
• Ви можете отримувати вхід у будь-якому розумному форматі до тих пір, поки він являє собою набір купи відра. Просто вкажіть це у своїй відповіді, якщо ви зміните спосіб отримання вводу.
• Це код-гольф , тому може виграти найкоротша програма / функція для кожної мови!

Приклади

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)

Желе , 6 5 байт

Дякуємо @Lynn за збереження 1 байта.

ṢFµJ⁼

Спробуйте в Інтернеті! (поставляється із колонтитулом тестового набору)

Пояснення

Ṣ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 байти

Дякуємо за байнер xnor

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

Спробуйте в Інтернеті!

JavaScript (ES6), 59 58 байт

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

Пояснення

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

Тестові справи

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 байти

{˜āQ

Спробуйте в Інтернеті!

Haskell , 54 байти

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

Спробуйте в Інтернеті!

Хаскелл , 37 байт

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

Спробуйте в Інтернеті!

Перевіряє, чи об'єднаний відсортований список лексикографічно менший, ніж нескінченний список [1,2,3,...]. Оскільки немає дублікатів, будь-яке відсутнє відро або відро, яке не вийшло з ладу, призведе до значення, більшого, ніж kу k'-му місці, що зробить список, що виходить більше.

Pyth, 6 байт

UItMsS

Спробуйте тут.

Пояснення:

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 байти

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

Тепер це краще. Ще досить багатослівний, на жаль.

Спробуйте в Інтернеті!

s/1Предикат приймає список в якості аргументу і вірно , якщо список список легко нарощуваних відра.

Вдосконалення алгоритму: якщо я сортую список перед тим, як його вирівняти, це змушує всі списки сортувати за присудком. Трохи "запозичили" у відповіді "Желе " Pietu1998 . Завдяки цьому я можу скинути, forallщо становить більше половини програми (див. Нижче оригінальну відповідь).

Як це працює?

Присудок вірний, якщо всі його пропозиції є істинними:

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

Попередня відповідь, PROLOG (SWI), 109 байт

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

Спробуйте в Інтернеті!

Pyth , 9 16 11 байт (виправлено)

Використовує зовсім інший метод, ніж інші відповіді. Коротший, 7-байтний підхід можна знайти нижче.

!.EtM.++0sS

Тестовий сюїт.

Пояснення

! .EtM. ++ 0sSQ -> Повна програма, з неявним введенням в кінці.

          SQ -> Сортувати вхідні дані за найвищим елементом у кожному підсписі.
         s -> Згладити.
       +0 -> Додайте 0.
     . + -> Отримайте дельти списку (тобто відмінності між послідовними елементами)
   tM -> Зменшення кожного елемента.
 .E -> Будь-який елементарний інструмент (1s - непростий, 0s - хибний)
! -> Negate (мати когерентні значення truthy / falesy)

Як це працює?

Візьмемо пару прикладів, які полегшують розуміння. Припустимо, вхід є [[1,3,4],[5,7],[2,6]]. Основою цього алгоритму є те, що кожна дельта в незамкненому списку повинна бути 1, щоб відра могли бути складені.

• Спочатку Sперетворює його на [[1, 3, 4], [2, 6], [5, 7]].

• Тоді, sзгладжує його: [1, 3, 4, 2, 6, 5, 7].

• Наперед 0перед:[0, 1, 3, 4, 2, 6, 5, 7]

• .+отримує дельти списку [1, 2, 1, -2, 4, -1, 2].

• tMдекрементируется кожен елемент, [0, 1, 0, -3, 3, -2, 1].

• Будь-яке не 0ціле число є truthy в Pyth, тому ми перевіряємо, чи є якийсь елемент truthy з .E(що означає, що стек не може бути сформований правильно). Ми отримуємо True.

• !заперечує результат, який перетворюється Trueна False.

Якби вхід був, наприклад, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]алгоритм працював би таким чином:

• Сортування за найвищим елементу: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]і сплющені, з 0префіксом: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

• Дельти: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Все прибудуть декрементируется: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• Немає правдивого елемента, тому ми отримуємо False. За логічним запереченням результат є True.

Pyth , 7 байт

qSlsQsS

Тестовий сюїт.

Порт відповіді Python та варіація рішення @ Еріка .

Брахілог , 5 байт

oc~⟦₁

Спробуйте в Інтернеті!

Пояснення об’єднань:

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

Аналітичне пояснення:

Перш за все ми сортуємо список списків, а потім з'єднуємо (тобто вирівнюємо 1-углиб) ( oc), щоб відра укладалися справа наліво, якщо можливо. Потім, щоб перевірити, чи правильно відкладені відра (тобто відсутні відсутні відра чи вежі), ми перевіряємо, що отриманий список є діапазоном включно від 1 до його довжини. Тепер, замість рівних перевірок списку діапазоном [1..n] його довжини ( {l⟦₁?}), ми намагаємось знайти вхід до функції, яка генерує такий діапазон ( ~⟦₁), якщо такий є. Якщо вхід знайдений, програма закінчується без проблем, тому вона запускає true.статус. Якщо введення не знайдено, програма виходить з ладу, запускаючи false.статус.

Python 2 , 43 байти

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

Спробуйте в Інтернеті!

Перевіряє, чи є об'єднаний відсортований список лексикографічно меншим, ніж [1,2,3,...N]для великого N. Оскільки немає дублікатів, будь-яке відсутнє відро або відро, яке не вийшло з ладу, призвело б до значення, більше, ніж kу k'-му місці, зробивши отриманий список більшим. Довжина рядка введення достатня як верхня межа, оскільки кожне число має більше 1 символу.

MATL , 5 байт

Sgtf=

Спробуйте в Інтернеті!

(Неявне введення, скажімо {[4,5],[9,10],[1,2,3],[6,7,8]})

S- сортування вхідних масивів у лексикографічному порядку ( {[1,2,3],[4,5],[6,7,8],[9,10]})

g- перетворити в єдиний масив ( cell2mat)

t - дублювати це

f- знайти індекси ненульових значень. Оскільки введення тут є всіма нулями, повертає список індексів від 1 до length (масив) ( [1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10])

= - перевірте, що масив дорівнює діапазону від 1 до довжини (масив)

Japt , 13 12 11 байт

Можливо, це може бути коротшим.

ñÎc äaT e¥1

• 1 байт збережено завдяки ETH

Спробуйте або запустіть усі тестові приклади

Пояснення

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

Скала, 49 байт

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

Безголовки:

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 байт

ñg c
eUÌõ

Спробуйте в Інтернеті!

R , 58 байт

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

Спробуйте в Інтернеті!

Примітка: ЛАЖКА - це правдивий результат, ІСТИНА - хибний

• -3 байти завдяки @JayCe

Пояснення:

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 байт

-13 байт завдяки 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);}

Кількість байтів також включає

using System.Linq;

Спробуйте в Інтернеті!

Безголовки:

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 байт

{$:+:(_,,=}

Спробуйте в Інтернеті!

Ой :(... так!{$:+_,,:)=}

Вугілля деревне , 19 байт (неконкуренто?)

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

Спробуйте в Інтернеті!

-10 байт завдяки лише ASCII .

-3 байти завдяки ASCII лише для подальшої реалізації (див. Історію редагування для можливо конкуруючої версії).

-за правду, за хибність .

Введення - це однотонний список списків через те, як вугілля приймає дані.

Java 10, 213 байт

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

Спробуйте в Інтернеті.

Коли я почав, це здавалося гарною ідеєю, але ці вбудовані вироби лише довше. Можливо, гольф можна використовувати, використовуючи більш ручний підхід ..

Натхненний @EriktheOutgolfer 4-байтовий 05AB1E відповідь «s . 4 vs 213 байт, rofl ..>.>

Пояснення:

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]