Mi pequeño niño tiene un juguete como este:

Este juguete consta de 10 pequeños cubos apilables, que vamos a numerar de 1 (el más pequeño) a 10 (el más grande). A veces hace pequeños montones y el juguete termina así:

Podemos representar esquemáticamente las pilas como esta:

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

O, dicho de otra manera:

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

Este conjunto de pilas de cubos se puede volver a apilar fácilmente para reconstruir el conjunto original (la primera imagen) simplemente colocando pilas consecutivas de cubos más pequeños dentro de pilas de cubos más grandes:

                             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

Sin embargo, a veces mi hijo intenta construir torres o tira cubos, y las pilas terminan siendo inconsistentes y el conjunto original no se puede reconstruir simplemente colocando una pila dentro de otra. Ejemplos de esto:

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

Reto

Dada una lista de listas de enteros que representan un conjunto de pilas de cubetas, devuelve un valor verdadero si las listas representan un conjunto de pilas fácilmente re-apilables, o falsey en cualquier otro caso.

• La entrada se dará como una lista de listas de enteros, que representan los cubos de arriba a abajo para cada pila.
• No habrá pilas de inicio vacías (no obtendrá [[1,2,3],[],[4,5]]como entrada).
• El número total de cubos puede ser cualquiera dentro de un rango entero razonable.
• Mi hijo solo tiene un conjunto de cubos, por lo que no habrá elementos duplicados.
• Puede seleccionar dos valores consistentes (y coherentes) para verdadero o falso.
• Los cubos se etiquetarán del # 1 al #N, siendo Nel número entero más grande en las listas de enteros. Mi hijo todavía no conoce el concepto de cero.
• Puede recibir la entrada en cualquier formato razonable siempre que represente un conjunto de pilas de cubos. Solo especifíquelo en su respuesta si cambia la forma en que recibe la entrada.
• Este es el código de golf , ¡así que puede ganar el programa / función más corto para cada idioma!

Ejemplos

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)

Jalea , 6 5 bytes

Gracias a @Lynn por guardar 1 byte.

ṢFµJ⁼

Pruébalo en línea! (viene con el pie de página de la suite de pruebas)

Explicación

Ṣ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

Gracias por el byte xnor

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

Pruébalo en línea!

JavaScript (ES6), 59 58 bytes

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

Explicación

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

Casos de prueba

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

Pruébalo en línea!

Haskell , 54 bytes

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

Pruébalo en línea!

Haskell , 37 bytes

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

Pruébalo en línea!

Comprueba si la lista ordenada concatenada es lexicográficamente más pequeña que la lista infinita [1,2,3,...]. Debido a que no hay duplicados, cualquier segmento faltante o fuera de servicio causaría un valor mayor que ken el k'th lugar, haciendo que la lista resultante sea más grande ...

Pyth, 6 bytes

UItMsS

Pruébalo aquí.

Explicación:

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

Ahora eso está mejor. Todavía bastante detallado, por desgracia.

Pruébalo en línea!

El s/1predicado toma una lista como argumento y es verdadero si la lista es una lista de cubos fácilmente apilables.

Mejora en el algoritmo: si clasifico la lista antes de aplanarla, esto obliga a ordenar todas las sublistas para que el predicado sea verdadero. Ligeramente "prestado" de la respuesta de Jelly de Pietu1998 . Gracias a eso puedo volcar lo forallque es más de la mitad del programa (ver más abajo la respuesta original).

¿Como funciona?

El predicado es verdadero si todas sus cláusulas son verdaderas:

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

Respuesta anterior, 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))).

Pruébalo en línea!

Pyth , 9 16 11 bytes (fijo)

Utiliza un método completamente diferente de la otra respuesta. Un enfoque más corto de 7 bytes se puede encontrar a continuación.

!.EtM.++0sS

Banco de pruebas.

Explicación

! .EtM. ++ 0sSQ -> Programa completo, con entrada implícita al final.

          SQ -> Ordenar la entrada por el elemento más alto en cada sublista.
         s -> Acoplar.
       +0 -> Anteponer un 0.
     . + -> Obtener los deltas de la lista (es decir, diferencias entre elementos consecutivos)
   tM -> Disminuye cada elemento.
 .E -> Cualquier elemento verdadero (1 son verdaderos, 0 son falsos)
! -> Negar (tener valores de verdad / falsedad coherentes)

¿Como funciona esto?

Tomemos un par de ejemplos, que hacen que sea más fácil de entender. Supongamos que la entrada es [[1,3,4],[5,7],[2,6]]. El núcleo de este algoritmo es que cada delta en la lista no aplanada debe ser 1 para que los depósitos sean apilables.

• Primero apagado, lo Sconvierte en [[1, 3, 4], [2, 6], [5, 7]].

• Entonces, sla aplana: [1, 3, 4, 2, 6, 5, 7].

• Anteponer un 0delante:[0, 1, 3, 4, 2, 6, 5, 7]

• .+obtiene los deltas de la lista, [1, 2, 1, -2, 4, -1, 2].

• tMdecrementa cada elemento, [0, 1, 0, -3, 3, -2, 1].

• Cualquier no 0entero es verdadero en Pyth, por lo que verificamos si hay algún elemento verdadero .E(lo que significa que la pila no se puede formar correctamente). Nosotros conseguimos True.

• !niega el resultado, que se convierte Trueen False.

Si la entrada fuera, por ejemplo [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]], el algoritmo funcionaría de esta manera:

• Ordenado por el elemento más alto: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]y aplanado, con un 0antepone: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

• Deltas: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Todo get decrementa: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

• No hay un elemento de verdad, así que lo entendemos False. Por negación lógica, el resultado es True.

Pyth , 7 bytes

qSlsQsS

Banco de pruebas.

Respuesta del puerto de Python y una variación de la solución de @ Erik .

Brachylog , 5 bytes

oc~⟦₁

Pruébalo en línea!

Unificaciones explicadas:

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

Explicación analítica:

En primer lugar, ordenamos la lista de listas, y luego concatenamos (es decir, aplanamos 1 profundidad) ( oc) para que los cubos se apilen de derecha a izquierda si es posible. Luego, para verificar si los cubos se han apilado correctamente (es decir, no faltan cubos o torres), verificamos que la lista resultante sea un rango inclusivo de 1 a su longitud. Ahora, en lugar de verificar la lista con el rango [1..n] de su longitud ( {l⟦₁?}), tratamos de encontrar una entrada a una función que genere dicho rango ( ~⟦₁), si existe. Si se encuentra una entrada, el programa finaliza sin problemas, por lo que activa un true.estado. Si no se encuentra ninguna entrada, el programa falla y activa un false.estado.

Python 2 , 43 bytes

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

Pruébalo en línea!

Comprueba si la lista ordenada concatenada es lexicográficamente más pequeña que [1,2,3,...N]grande N. Dado que no hay duplicados, cualquier depósito faltante o fuera de servicio causaría un valor mayor que ken el klugar 'th, haciendo que la lista resultante sea más grande. La longitud de cadena de la entrada es suficiente como límite superior ya que cada número toma más de 1 carácter.

MATL , 5 bytes

Sgtf=

Pruébalo en línea!

(Entrada implícita, por ejemplo {[4,5],[9,10],[1,2,3],[6,7,8]})

S- ordenar matrices de entrada en orden lexicográfico ( {[1,2,3],[4,5],[6,7,8],[9,10]})

g- convertir en una sola matriz ( cell2mat)

t - duplicar eso

f- Encuentra índices de valores distintos de cero. Dado que la entrada aquí no son todos ceros, devuelve la lista de índices de 1 a longitud (matriz) ( [1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10])

= - compruebe que la matriz es igual al rango 1 a la longitud (matriz)

Japt , 13 12 11 bytes

Esto probablemente podría ser más corto.

ñÎc äaT e¥1

• 1 byte guardado gracias a ETH

Pruébalo o ejecuta todos los casos de prueba

Explicación

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

Sin golf:

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Ìõ

Pruébalo en línea!

R , 58 bytes

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

Pruébalo en línea!

NB: FALSO es el resultado verdadero, VERDADERO es el falso

• -3 bytes gracias a @JayCe

Explicacion:

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

El recuento de bytes también incluye

using System.Linq;

Pruébalo en línea!

Sin golf:

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

{$:+:(_,,=}

Pruébalo en línea!

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

Carbón de leña , 19 bytes (¿no compite?)

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

Pruébalo en línea!

-10 bytes gracias a ASCII-only .

-3 bytes gracias a ASCII-only para una implementación posterior (ver el historial de revisiones para la versión posiblemente competidora).

-por la verdad, por la falsedad.

La entrada es una lista singleton de una lista de listas, debido a la forma en que Charcoal toma la entrada.

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

Pruébalo en línea.

Parecía una buena idea cuando comencé, pero estas incorporaciones solo lo hacen más largo ... Definitivamente se puede jugar al golf usando un enfoque más manual ...

Inspirado por la respuesta 05AB1E de 4 bytes de @EriktheOutgolfer . 4 contra 213 bytes, rofl ..>.>

Explicación:

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]