내 작은 아이는 다음과 같은 장난감을 가지고 있습니다.

이 완구는 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]]입력으로 얻지 못할 것입니다 ).
• 버킷의 총 수는 적절한 정수 범위 내에있을 수 있습니다.
• 내 아이는 버킷 세트가 하나뿐이므로 중복 요소가 없습니다.
• 진실 또는 거짓에 대해 일관된 (일관된) 값을 선택할 수 있습니다.
• 버킷은 # 1에서 #N까지 레이블이 지정되며 N정수 목록에서 가장 큰 정수입니다. 내 아이는 여전히 제로의 개념을 모른다.
• 버킷 더미를 나타내는 한 적절한 형식으로 입력을받을 수 있습니다. 입력을받는 방식을 변경하는 경우 답변에 지정하십시오.
• 이것은 code-golf 이므로 각 언어마다 가장 짧은 프로그램 / 기능이 이길 수 있습니다!

예

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 바이트

1 바이트를 저장해 준 @Lynn에게 감사합니다.

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

파이썬 2 , 53 52 바이트

바이트 xnor에 감사합니다

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

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

하스켈 , 54 바이트

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

온라인으로 사용해보십시오!

하스켈 , 37 바이트

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

온라인으로 사용해보십시오!

연결된 정렬 목록이 사전 순으로 무한 목록보다 작은 지 확인합니다 [1,2,3,...]. 더 중복, 누락 된 버킷 또는 순차적 (out-of-order)가 없기 때문에 버킷은보다 값 이상을 야기 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)

프롤로그 (SWI), 54 바이트

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

이제 사용자들은 더 나은. 여전히 매우 장황하다.

온라인으로 사용해보십시오!

그만큼 s/1술어는 인수로 목록을 소요하고 목록을 쉽게 쌓을 수 양동이의 목록입니다 마찬가지입니다.

알고리즘 개선 : 목록 을 병합 하기 전에 정렬하면 조건자가 true가되도록 모든 하위 목록 이 정렬됩니다. 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-> Flatten.
       +0-> 0 앞에 붙습니다.
     . +-> 목록의 델타를 구합니다 (예 : 연속 요소의 차이점).
   tM-> 각 요소를 줄입니다.
 .E-> 모든 진실 요소 (1은 진실, 0은 거짓)
! -> Negate (일관된 진실 / 거짓 가치를 갖기 위해)

어떻게 작동합니까?

이해하기 쉽도록 몇 가지 예를 들어 보겠습니다. 입력이이라고 가정 해 봅시다 [[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.

• !을 Negate 온하는 결과 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 솔루션의 변형 .

Brachylog , 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)

분석 설명 :

우선 우리는리스트의리스트를 정렬 한 다음 가능 oc하면 버킷이 오른쪽에서 왼쪽으로 쌓 이도록 연결합니다 (즉, 1- 깊이를 평평하게 합니다). 그런 다음 버킷이 올바르게 쌓여 있는지 (즉, 누락 된 버킷이나 타워가 없는지) 확인하기 위해 결과 목록이 1에서 길이까지의 포괄적 인 범위인지 확인합니다. 이제 길이 ( {l⟦₁?}) 의 [1..n] 범위로 목록을 동일하게 확인하는 대신 그러한 범위 ( ~⟦₁)가있는 경우 해당 범위를 생성하는 함수에 대한 입력을 찾습니다 . 입력이 발견되면 프로그램은 문제없이 종료되므로 true.상태를 트리거합니다 . 입력이 없으면 프로그램이 실패하고 false.상태 가 트리거 됩니다.

파이썬 2 , 43 바이트

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

온라인으로 사용해보십시오!

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]