Posso reimballare i secchi?


30

Il mio bambino ha un giocattolo come questo:

Stacked

Questo giocattolo è composto da 10 secchielli impilabili, che numereremo da 1 (il più piccolo) a 10 (il più grande). A volte fa piccole pile e il giocattolo finisce così:

Sparpagliato

Possiamo rappresentare schematicamente le pile in questo modo:

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

Oppure, in altre parole:

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

Questo set di pile a secchiello è facilmente ripristinabile per ricostruire il set originale (la prima immagine) semplicemente posizionando consecutivamente pile di secchi più piccoli all'interno di pile di secchi più grandi:

                             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

Tuttavia, a volte mio figlio cerca di costruire torri o getta secchi, e le pile finiscono per essere incoerenti e il set originale non può essere ricostruito semplicemente posizionando una pila all'interno di un'altra. Esempi di questo:

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

Sfida

Dato un elenco di elenchi di numeri interi che rappresentano un set di pile bucket, restituisce un valore di verità se gli elenchi rappresentano un set di pile facilmente ripristinabili o false in ogni altro caso.

  • L'input verrà fornito come un elenco di elenchi di numeri interi, che rappresentano i bucket dall'alto verso il basso per ogni stack.
  • Non ci saranno pile iniziali vuote (non otterrai [[1,2,3],[],[4,5]]come input).
  • Il numero totale di bucket può essere qualsiasi all'interno di un intervallo intero ragionevole.
  • Mio figlio ha solo un set di secchi, quindi non ci saranno elementi duplicati.
  • È possibile selezionare due valori coerenti (e coerenti) per verità o falsità.
  • I bucket verranno etichettati da # 1 a #N, essendo Nil numero intero più grande negli elenchi di numeri interi. Mio figlio non conosce ancora il concetto di zero.
  • È possibile ricevere l'input in qualsiasi formato ragionevole purché rappresenti una serie di pile di secchi. Basta specificarlo nella risposta se si cambia il modo in cui si riceve l'input.
  • Questo è , così possa il programma / funzione di breve per ogni vittoria la lingua!

Esempi

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)

Questo viene dalla sandbox .
Charlie,

2
@ Mr.Xcoder no, non ci saranno elementi duplicati (mio figlio ha solo un set di secchi e sono tutti diversi.
Charlie

1
Possiamo supporre che il bucket 1 non manchi mai?
PurkkaKoodari,

2
@ Pietu1998 può mancare il secchio n. 1, ho appena aggiunto un caso di prova (in effetti, il secchio più piccolo è il più facile da perdere).
Charlie,

1
Le varie sfide della Torre di Hanoi sono correlate (non duplicati).
AdmBorkBork,

Risposte:


12

Gelatina , 6 5 byte

Grazie a @Lynn per aver salvato 1 byte.

ṢFµJ⁼

Provalo online! (viene fornito con il piè di pagina della suite di test)

Spiegazione

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

Penso che ṢFµJ⁼funzioni, ma non ho pensato a tutti i casi limite.
Lynn,

@Lynn Funziona supponendo che 1non manchi il bucket . Non sono sicuro che ciò sia garantito dall'OP.
PurkkaKoodari il

@Lynn bucket # 1 potrebbe mancare, sì. Ho appena aggiunto un nuovo caso di prova.
Charlie,

Se mancano dei bucket, l'elenco ordinato conterrà sempre numeri più grandi di quelli che Jpossono restituire, garantendo un output falso. mi sto perdendo qualcosa?
Lynn,

Penso che puoi ancora utilizzare la versione a 5 byte con il bucket n. 1 mancante?
Erik the Outgolfer

8

Python 2 , 53 52 byte

Grazie per il byte xnor

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

Provalo online!


Mi piace che inizi la somma a []. Abbastanza difficile
bioweasel

2
È possibile salvare un byte avviando la somma in [0]modo che l'intervallo possa iniziare da 0.
xnor

5

JavaScript (ES6), 59 58 byte

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

Spiegazione

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

Casi test




5

Haskell , 37 byte

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

Provalo online!

Verifica se l'elenco ordinato concatenato è lessicograficamente più piccolo dell'elenco infinito [1,2,3,...]. Dal momento che non ci sono duplicati, qualsiasi bucket mancante o fuori servizio causerebbe un valore maggiore rispetto kal k'terzo posto, rendendo l'elenco risultante più grande.


4

Pyth, 6 byte

UItMsS

Provalo qui.

Spiegazione:

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)

Wat ?! Aggiungi una spiegazione alla UIparte, per favore
Mr. Xcoder

@ Mr.Xcoder U <col>è range(len(A)), I <pfn> <any> <n-1:any>è A(B, ...) == B.
Erik the Outgolfer

Poi mi sono terribilmente superato>. <. Potrei giocare a golf, però. Genio, soluzione geniale, ora che vedo come funziona ... Complimenti!
Mr. Xcoder,

@ Mr.Xcoder È davvero solo alla ricerca di documenti ...
Erik the Outgolfer

No non lo è. Sapevo che U <col>è range(len(A)), ma non mi rendevo conto che il porting di Python la soluzione sarebbe più breve ...
Mr. Xcoder

4

PROLOG (SWI), 54 byte

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

Adesso va meglio. Purtroppo ancora prolisso, ahimè.

Provalo online!

Il s/1predicato accetta un elenco come argomento ed è vero se l'elenco è un elenco di bucket facilmente impilabili.

Miglioramento dell'algoritmo: se ordino l'elenco prima di appiattirlo, questo costringe tutti gli elenchi secondari a essere ordinati affinché il predicato sia vero. Leggermente "preso in prestito" dalla risposta di Jelly di Pietu1998 . Grazie a ciò posso scaricare il forallche è più della metà del programma (vedi sotto per la risposta originale).

Come funziona?

Il predicato è vero se tutte le sue clausole sono vere:

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

Risposta precedente, PROLOG (SWI), 109 byte

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

Provalo online!


3

Pyth , 9 16 11 byte (fisso)

Utilizza un metodo completamente diverso dall'altra risposta. Di seguito è riportato un approccio più breve, a 7 byte.

!.EtM.++0sS

Test Suite.


Spiegazione

! .EtM. ++ 0sSQ -> Programma completo, con input implicito alla fine.

          SQ -> Ordina l'input in base all'elemento più alto in ciascun elenco secondario.
         s -> Appiattisci.
       +0 -> Prepara uno 0.
     . + -> Ottieni i delta dell'elenco (ovvero le differenze tra elementi consecutivi)
   tM -> Decrementa ogni elemento.
 .E -> Qualsiasi elemento di verità (1s è verità, 0s è falsa)
! -> Nega (per avere valori coerenti / falsi coerenti)

Come funziona?

Facciamo un paio di esempi, che facilitano la comprensione. Supponiamo che sia l'input [[1,3,4],[5,7],[2,6]]. Il nucleo di questo algoritmo è che ogni delta nell'elenco non appiattito deve essere 1 affinché i bucket siano impilabili.

  • Prima di tutto, lo Strasforma in [[1, 3, 4], [2, 6], [5, 7]].

  • Poi, sappiattisce esso: [1, 3, 4, 2, 6, 5, 7].

  • Prepara un 0davanti:[0, 1, 3, 4, 2, 6, 5, 7]

  • .+ottiene i delta della lista, [1, 2, 1, -2, 4, -1, 2].

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

  • Qualsiasi non 0intero è veritiero in Pyth, quindi controlliamo se c'è qualche elemento di verità con .E(il che significa che lo stack non può essere formato correttamente). Abbiamo capito True.

  • !annulla il risultato, che si trasforma Truein False.

Se l'input fosse, ad esempio [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]], l'algoritmo funzionerebbe in questo modo:

  • Ordinati per l'elemento più alto: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]e appiattito, con un 0anteposto: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].

  • Delta: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]. Tutti otteniamo decrementato: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].

  • Non esiste alcun elemento di verità, quindi otteniamo False. Per negazione logica, il risultato è True.


Pyth , 7 byte

qSlsQsS

Test Suite.

Risposta di Port of the Python e una variante della soluzione di @ Erik .


Grazie mille per aver dedicato del tempo a spiegare come funziona!
Charlie,


@ Mr.Xcoder Cosa intendi per tMdecrementi di ogni elemento? Penserei che il decremento di ogni elemento di [1, 2, 1, -2, 4, -1, 2]cederebbe [0, 1, 0, -3, 3, -2, 1]. Ma ciò non aiuterebbe a risolvere il problema, quindi devo fraintendere cosa significhi decrementare ogni elemento.
Brian J

@BrianJ tMriduce di ciascun elemento nell'elenco di 1. C'è un errore nella mia spiegazione. Risolverà.
Mr. Xcoder,

@BrianJ Risolto. Grazie per
averlo

3

Brachylog , 5 byte

oc~⟦₁

Provalo online!

Unificazioni spiegate:

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

Spiegazione analitica:

Prima di tutto ordiniamo l'elenco degli elenchi, quindi concateniamo (cioè appiattiamo 1 in profondità) ( oc) in modo che i bucket vengano impilati da destra a sinistra, se possibile. Quindi, per verificare se i bucket sono stati impilati correttamente (ovvero non ci sono bucket o tower mancanti), controlliamo che l'elenco risultante sia un intervallo compreso tra 1 e la sua lunghezza. Ora, invece di controllare ugualmente l'elenco con l'intervallo [1..n] della sua lunghezza ( {l⟦₁?}), proviamo a trovare un input per una funzione che genera tale intervallo ( ~⟦₁), se ce n'è uno. Se viene trovato un input, il programma termina senza problemi, quindi attiva uno true.stato. Se non viene trovato alcun input, il programma non riesce, attivando uno false.stato.


3

Python 2 , 43 byte

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

Provalo online!

Verifica se l'elenco ordinato concatenato è lessicograficamente più piccolo rispetto [1,2,3,...N]a quello di grandi dimensioni N. Dal momento che non ci sono duplicati, qualsiasi bucket mancante o fuori servizio causerebbe un valore maggiore rispetto kal k'terzo posto, rendendo l'elenco risultante più grande. La lunghezza della stringa dell'input è sufficiente come limite superiore poiché ogni numero accetta più di 1 carattere.


Bene, ho pensato che ci dovrebbe essere un modo per migliorare sostanzialmente la mia soluzione, e questo è tutto!
Chris_Rands il

3

MATL , 5 byte

Sgtf=

Provalo online!

(Input implicito, diciamo {[4,5],[9,10],[1,2,3],[6,7,8]})

S- ordina le matrici di input in ordine lessicografico ( {[1,2,3],[4,5],[6,7,8],[9,10]})

g- converti in un singolo array ( cell2mat)

t - duplicalo

f- trova indici con valori diversi da zero. Poiché l'input qui è tutto diverso da zero, restituisce l'elenco di indici da 1 a lunghezza (array) ( [1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10])

= - verifica che l'array sia uguale all'intervallo da 1 a lunghezza (array)


3

Japt , 13 12 11 byte

Questo potrebbe probabilmente essere più breve.

ñÎc äaT e¥1
  • 1 byte salvato grazie a ETH

Provalo o esegui tutti i casi di test


Spiegazione

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

Sì, hai ragione, penso. Ne è valsa la pena però
ETHproductions

Penso che puoi salvare un byte sull'ultima riga con ä-0 e¥Joän0 e¥1
ETHproductions

Un'altra soluzione simile a 13 byte: ethproductions.github.io/japt/…
Oliver

@ETHproductions, non ho idea di cosa stia succedendo lì! : D Non credo di aver ancora avuto occasione di toccare äper gli array. Grazie per il risparmio
Shaggy

1
@LuisfelipeDejesusMunoz Funziona quando si utilizza la prima riga di questa soluzione e la seconda riga della soluzione collegata, proprio come ho detto, nove byte: codegolf.stackexchange.com/a/168967/16484
Nit

2

Scala, 49 byte

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
}


2

R , 58 byte

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

Provalo online!

NB: FALSO è il risultato veritiero, VERO è il risultato falso

  • -3 byte grazie a @JayCe

Spiegazione :

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

1
Semplicemente seq(a)per 2 byte ?. Inoltre, è consentito utilizzare TRUEcome valore falsy e viceversa (basta specificare nella risposta), quindi è possibile farlo any(a-seq(a))per un altro byte.
JayCe,

@JayCe: Sono un pazzo ... Ero così preoccupato di seq(a)comportarmi diversamente quando aè di lunghezza 1 e mi sono perso che in questo caso avremo gli stessi risultati: D Grazie!
digEmAll

1

C # (.NET Core) , 157 145 132 byte

-13 byte grazie 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);}

Il conteggio dei byte include anche

using System.Linq;

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

1
x.First()-> x[0]? Enumerable.Range-> new int[]e Zipcon indice se possibile ..? Rimuovere Wheree posizionare la condizione in Any.
TheLethalCoder il

@TheLethalCoder Grazie per i suggerimenti! E l' new int[]approccio richiederebbe l'aggiunta di a Select()per ottenere l'indice e, alla fine, aumenterebbe il conteggio dei byte.
Grzegorz Puławski,


1

Carbone , 19 byte (non in competizione?)

A▷m⟦▷s▷vθυ⟧θ⁼θ…·¹Lθ

Provalo online!

-10 byte grazie a ASCII .

-3 byte grazie solo a ASCII per un'implementazione successiva (vedere la cronologia delle revisioni per versioni eventualmente concorrenti).

- per la verità, per la falsità.

L'input è un elenco singleton di un elenco di elenchi, a causa del modo in cui Charcoal accetta l'input.


È la prima risposta in Carbone che vedo che usa UP.
Charlie,

@CarlosAlejo Ho dovuto trovare un modo per ordinare, e il modo più semplice era giusto UPsorted.
Erik the Outgolfer,


l' uso lì rende le cose dell'ambito la priorità comunque in modo che; s perché UPè ancora lì ma immagino che tu possa semplicemente evitare di usare i nomi delle funzioni python come nomi di nomi?
ASCII il

yay ha aggiunto eval come v, anche O_O questa non è nemmeno una sfida di arte ascii (non c'è da stupirsi che sia così ungolfy: P
ASCII

0

Java 10, 213 byte

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

Provalo online.

Mi è sembrata una buona idea quando ho iniziato, ma questi builtin lo rendono solo più lungo .. Può sicuramente essere giocato a golf usando un approccio più manuale ..

Ispirato dalla risposta 05AB1E a 4 byte di @EriktheOutgolfer . 4 vs 213 byte, rofl ..>.>

Spiegazione:

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]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.