У моего маленького ребенка есть такая игрушка:

Эта игрушка состоит из 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)

Вызов

Получив список списков целых чисел, представляющих набор стопок, верните истинное значение, если списки представляют легко штабелируемый набор стопок, или false в любом другом случае.

• Входные данные будут представлены в виде списка целых чисел, представляющих сегменты сверху вниз для каждого стека.
• Там не будет пустых стартовых куч (вы не получите в [[1,2,3],[],[4,5]]качестве входных данных).
• Общее количество сегментов может быть любым в пределах разумного целочисленного диапазона.
• У моего ребенка только один набор ведер, поэтому дублирующих элементов не будет.
• Вы можете выбрать любые два непротиворечивых (и связных) значения для истинности или ложности.
• Ведра будут помечены от # 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⁼

Попробуйте онлайн!(поставляется с нижним колонтитулом test-suite)

объяснение

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

Попробуйте онлайн!

Haskell , 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 -> Любой правдивый элемент (1 - это правда, 0 - это ложь)
! -> Отрицание (чтобы иметь согласованные истинные / ложные значения)

Как это работает?

Давайте возьмем пару примеров, которые облегчают понимание. Давайте предположим, что вход [[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нецелое число является правдивым в Pyth, поэтому мы проверяем, есть ли какой-либо правдивый элемент с .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 и вариант решения @ Erik .

Брахилог , 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 до длины (массив) ( [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)}

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

ñg c
eUÌõ

Попробуйте онлайн!

R , 58 байт

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

Попробуйте онлайн!

NB: ЛОЖЬ - правдивый результат, ИСТИНА - ложный

• -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;

Попробуйте онлайн!

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

{$:+:(_,,=}

Попробуйте онлайн!

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

Древесный уголь , 19 байт (не конкурирует?)

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

Попробуйте онлайн!

-10 байт благодаря ASCII-только .

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

-для truthy, для falsy.

Input представляет собой одноэлементный список списков, из-за того, как уголь принимает данные

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 против 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]