Benim küçük çocuğumun böyle bir oyuncağı var:

Bu oyuncak, 1 (en küçük) ile 10 (en büyüğü) arasında bir sayı alacağımız 10 istiflenebilir küçük kovadan oluşur. Bazen küçük kazık yapar ve oyuncak böyle biter:

Bu gibi yığınları şematik olarak gösterebiliriz:

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

Veya başka bir yolla:

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

Bu kova kümeleri, orijinal kümeyi (ilk resim) yeniden inşa etmek için kolayca tekrar takılabilir, ancak daha küçük kova yığınlarını ardışık olarak daha büyük kova yığınlarına yerleştirerek:

                             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

Bununla birlikte, bazen benim çocuğum kuleler inşa etmeye çalışır ya da kovaları çöpe atar ve yığınlar tutarsız kalır ve orijinal set sadece bir yığını diğerinin içine yerleştirerek yeniden oluşturulamaz. Buna örnekler:

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

Meydan okuma

Bir dizi küme kümesini temsil eden tamsayıların bir listesi göz önüne alındığında, eğer listeler kolay bir şekilde yeniden istiflenebilir küme kümesini veya başka bir durumda falsey'i temsil ederse bir gerçeğe uygun değer döndürür.

• Giriş, her yığın için kovaları yukarıdan aşağıya temsil eden tamsayıların bir listesi olarak verilecektir.
• Boş başlangıç ​​yığınları olmayacak ( [[1,2,3],[],[4,5]]girdi olarak elde edemezsiniz ).
• Toplam kova sayısı makul bir tamsayı aralığında olabilir.
• Çocuğumun yalnızca bir kova grubu var, bu yüzden yinelenen öğeler olmayacak.
• Gerçek veya falsey için herhangi iki tutarlı (ve tutarlı) değer seçebilirsiniz.
• Kovalar # 1 ile # N Narasında, tam sayı listelerinde en büyük tam sayı olarak etiketlenir . Benim çocuğum hala sıfır kavramını bilmiyor.
• Girdiyi, bir dizi kümeyi temsil ettiği sürece makul bir biçimde alabilirsiniz. Girdiyi alma şeklinizi değiştirirseniz, cevabınıza sadece belirtin.
• Bu kod golf , yani her dil için en kısa program / işlev kazanabilir!

Örnekler

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)

Jöle , 6 5 bayt

1 byte tasarruf için @Lynn teşekkürler.

ṢFµJ⁼

Çevrimiçi deneyin! (test paketi altbilgisiyle birlikte gelir)

açıklama

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

Bayt xnor için teşekkürler

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

Çevrimiçi deneyin!

JavaScript (ES6), 59 58 bayt

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

açıklama

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

Test durumları

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 bayt

{˜āQ

Çevrimiçi deneyin!

Haskell , 54 bayt

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

Çevrimiçi deneyin!

Haskell , 37 bayt

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

Çevrimiçi deneyin!

Birleştirilmiş sıralama listesinin, sözlük listesinden sonsuz listeden daha küçük olup olmadığını kontrol eder [1,2,3,...]. Yinelenen kopya olmadığından, eksik kova veya sıra dışı kova k, bulunduğu kyerden daha büyük bir değere neden olur , sonuçta ortaya çıkan liste daha büyük olur ..

Pyth, 6 bayt

UItMsS

Burada dene.

Açıklama:

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 bayt

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

Şimdi bu daha iyi. Hala oldukça ayrıntılı, ne yazık ki.

Çevrimiçi deneyin!

s/1Yüklem argüman olarak bir listesini alır ve liste kolayca istiflenebilir kovalar listesidir bu durum geçerlidir.

Algoritmanın iyileştirilmesi: Listeyi düzleştirmeden önce sıralarsam , bu kimliğin doğru olması için sıralanacak tüm alt listeleri zorlar. Pietu1998'in Jelly cevabından hafifçe "ödünç alınmış" . Bu sayede forallprogramın yarısından fazlasını kestirebilirim (asıl cevap için aşağıya bakınız).

O nasıl çalışır?

Tüm cümleleri doğruysa, belirtme geçerlidir:

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

Önceki cevap, PROLOG (SWI), 109 bayt

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

Çevrimiçi deneyin!

Pyth , 9 16 11 bayt (Sabit)

Diğer cevaptan tamamen farklı bir yöntem kullanır. Aşağıda daha kısa, 7 baytlık bir yaklaşım bulunabilir.

!.EtM.++0sS

Test odası.

açıklama

! .EtM. ++ 0sSQ -> Sonunda örtülü giriş olan tam program.

          SQ -> Girişi, her alt listedeki en yüksek elemana göre sıralayın.
         s -> Düzleştir.
       +0 -> 0 a bağlı.
     . + -> Listenin deltalarını alın (yani ardışık öğeler arasındaki farklar)
   tM -> Her elemanı azaltır.
 .E -> Herhangi bir hakikaten öge (1'ler hakikaten, 0s sahtedir)
! -> Negate (tutarlı truthy / falsy değerlerine sahip olmak)

Bu nasıl çalışıyor?

Anlaşmayı kolaylaştıran birkaç örnek alalım. Girişin olduğunu varsayalım [[1,3,4],[5,7],[2,6]]. Bu algoritmanın çekirdeği , kepçelerin istiflenebilmesi için, düzleştirilmemiş listedeki her bir deltanın 1 olması gerektiğidir .

• Öncelikle, Sonu açar [[1, 3, 4], [2, 6], [5, 7]].

• Sonra sonu düzleştirir: [1, 3, 4, 2, 6, 5, 7].

• Önüne bir bağımlı 0:[0, 1, 3, 4, 2, 6, 5, 7]

• .+listenin deltalarını alır [1, 2, 1, -2, 4, -1, 2].

• tMher elemanı azaltır [0, 1, 0, -3, 3, -2, 1],.

• 0Tamsayı olmayan herhangi bir kişi Pyth'ta doğrudur, bu yüzden .E( herhangi bir yığının doğru oluşturulamayacağı anlamına gelir) ile herhangi bir aşiret elemanı olup olmadığını kontrol ederiz . Anlaştık True.

• !ortadan döner sonuç Trueolarak False.

Girdi, örneğin, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]algoritma, bu şekilde çalışacaktı:

• En yüksek elemanı olarak sıralandı: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]ve birlikte, düzleştirilmiş 0de başa: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

• Deltalar: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Tüm olsun indirildiği: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• Gerçek bir öğe yok, öyleyse anlıyoruz False. Mantıksal olumsuzlama ile sonuç True.

Pyth , 7 bayt

qSlsQsS

Test odası.

Python Limanı cevaplar ve @ Erik'in çözümünün bir çeşitlemesi .

Brachylog , 5 bayt

oc~⟦₁

Çevrimiçi deneyin!

Açıklanan birleşimler:

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

Analitik açıklama:

Öncelikle listelerin listesini sıralarız, sonra ocda mümkünse kovaların sağdan sola istiflenebilmesi için birleştiririz (yani 1-derinleşir) ( ). Daha sonra, kovaların doğru şekilde yerleştirilip yerleştirilmediğini kontrol etmek için (örneğin, eksik kova veya kule yok), sonuçta elde edilen listenin 1'den uzunluğuna kadar kapsamlı bir aralık olduğunu kontrol ederiz. Şimdi, listeyi [1..n] uzunluğunun ( {l⟦₁?}) aralığına eşitlemek yerine ~⟦₁, varsa, bu tür bir aralık ( ) üreten bir işleve girdi bulmaya çalışırız . Bir giriş bulunursa, program sorunsuz bir şekilde sona erer, bu nedenle bir true.durumu tetikler . Herhangi bir giriş bulunamazsa, program başarısız olur ve bir false.durum tetiklenir .

Python 2 , 43 bayt

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

Çevrimiçi deneyin!

Birleştirilmiş sıralama listesinin sözlük [1,2,3,...N]büyüklüğüne göre daha küçük olup olmadığını kontrol eder N. Kopya olmadığından, eksik kova veya sıra dışı kova k, bulunduğu kyerden daha büyük bir değere neden olur ve sonuçta ortaya çıkan liste daha büyük olur. Her sayı 1'den fazla karakter aldığından, girişin dize uzunluğu bir üst sınır olarak yeterlidir.

MATL , 5 bayt

Sgtf=

Çevrimiçi deneyin!

(Örtük girdi, söyle {[4,5],[9,10],[1,2,3],[6,7,8]})

S- giriş dizilerini sözlük sırasına göre sırala ( {[1,2,3],[4,5],[6,7,8],[9,10]})

g- tek bir diziye ( cell2mat) dönüştürebilir

t - bunu çoğalt

f- sıfır olmayan değerlerin indekslerini bulun. Buradaki girdilerin tümü sıfır olmadığından, 1'den uzunluktaki (dizi) ( [1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10]) dizinlerin listesini döndürür

= - dizinin 1 uzunluğuna eşit olduğunu kontrol edin (dizi)

Japt , 13 12 11 bayt

Bu muhtemelen daha kısa olabilir.

ñÎc äaT e¥1

• ETH sayesinde 1 bayt kurtarıldı

Deneyin veya tüm test durumlarını çalıştırın

açıklama

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

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 bayt

ñg c
eUÌõ

Çevrimiçi deneyin!

R , 58 bayt

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

Çevrimiçi deneyin!

Not: YANLIŞ gerçeğin bir sonucudur, DOĞRU ise bir yanlıştır

• @JayCe sayesinde -3 bayt

Açıklama:

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 bayt

TheLethalCoder sayesinde -13 bayt

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

Bayt sayısı da içerir

using System.Linq;

Çevrimiçi deneyin!

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 bayt

{$:+:(_,,=}

Çevrimiçi deneyin!

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

Kömür , 19 bayt (rekabet etmeyen?)

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

Çevrimiçi deneyin!

Sadece ASCII sayesinde -10 bayt .

-3 bayt sadece sonraki bir uygulama için ASCII sayesinde (muhtemelen rakip sürüm için revizyon tarihine bakınız).

-truthy için, sahte için.

Giriş, Kömürün nasıl girdiğinden dolayı, listelerin bir listesidir.

Java 10, 213 bayt

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

Çevrimiçi deneyin.

Başladığımda iyi bir fikir gibiydi, ama bu yerleşikler sadece daha uzun sürüyor ... Kesinlikle daha manuel bir yaklaşımla golf oynayabilir ..

Esinlenerek @EriktheOutgolfer 'ın 4 baytlık 05AB1E cevap . 4 vs 213 bayt, küme ..>.>

Açıklama:

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]