Considera una matrice di numeri interi:

[1, 0, 9, 1, 3, 8]

Esistono molti modi per suddividere questo elenco in elenchi consecutivi. Eccone tre:

A: [[1, 0, 9], [1, 3, 8]]
B: [[1], [0, 9], [1, 3], [8]]
C: [[1, 0], [9, 1], [3, 8]]

Chiameremo una partizione Y e perfezioneremo un'altra partizione X se X può essere ottenuto da Y unendo nuovamente alcuni dei suoi elenchi.

Così Bè un perfezionamento di A: se uniamo i primi due e gli ultimi due elenchi di nuovo insieme, otteniamo A. Ma nonC è un perfezionamento di : dovremmo dividere il e il per recuperare da esso. Inoltre, qualsiasi partizione è banalmente un raffinamento di se stessa.A91A

Si noti che non ci è permesso di riorganizzare alcuna lista o elemento in qualsiasi momento.

La sfida

Date due partizioni (elenchi di elenchi di numeri interi) Xe Y, determinare se si Ytratta di un perfezionamento di X.

Si può presumere che le partizioni conterranno solo numeri interi da 0a 9, inclusi. Non devi supporre che Xe Ysiano partizioni dello stesso elenco (se non lo sono, anche loro non sono perfezionamenti l'uno dell'altro). Xe / o Ypuò essere vuoto ma non conterrà mai elenchi vuoti.

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

L'input può essere preso in qualsiasi formato stringa o elenco conveniente. Dato che gli elementi saranno solo numeri interi a una cifra, puoi scegliere di omettere un delimitatore all'interno delle liste secondarie, ma assicurati che 0siano possibili le iniziali . Puoi scegliere di prendere Xe Ynell'ordine opposto.

L'output dovrebbe essere veritiero se Yè un raffinamento Xe falsa in caso contrario.

Il tuo codice deve essere in grado di risolvere ciascuno dei casi di test di seguito in 1 secondo su una macchina desktop ragionevole. (Questo è solo un controllo di sanità mentale per evitare semplici soluzioni di forza bruta.)

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

Casi test

Ogni caso di test è sulla sua riga, scritto come X Y. Sto usando la notazione di array in stile GolfScript / CJam per risparmiare spazio orizzontale:

Truthy:

[] []
[[0]] [[0]]
[[1 0 9 1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9 1 3 8]] [[1 0 9 1 3] [8]]
[[1 0 9 1 3 8]] [[1] [0] [9] [1] [3] [8]]
[[1 0 9] [1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5] [1 4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

Falsy:

[[0]] []
[[0]] [[1]]
[[1 0 9]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9 1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9]]
[[1 0 9] [1 3 8]] [[1 0] [9]]
[[1 0 9] [1 3 8]] [[1 0] [9 1] [3 8]]
[[1] [0 9] [1 3] [8]] [[1 0 9] [1 3 8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5 1] [4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script>site = 'meta.codegolf'; postID = 5314; isAnswer = true; QUESTION_ID = 51719</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Sfide correlate

• Calcola il Join and Meet of Partitions

CJam, 13 10 9 byte

lr.-F-U-!

Provalo online nell'interprete CJam .

Grazie a @ MartinBüttner per aver suggerito il geniale formato di input di @ edc65 .

Grazie a @ jimmy23013 per migliorare il formato di input e giocare a golf da 3 byte addizionali.

I / O

Ingresso

I sublisti sono separati l' ;uno dall'altro da ,:

1;0;9,1;3;8
1,0;9,1;3,8

Produzione

1

Come funziona

lr e# Read line and a whitespace-separated token from STDIN.
.- e# Vectorized difference. Pushes the differences of corresponding code points.
F- e# Remove all occurrences of 15 (';' - ',') from the array.
U- e# Remove all occurrences of 0 from the array.
!  e# Push 1 if the resulting array is empty and 0 if not.

Per stringhe di diversa lunghezza, .-lasceranno caratteri nell'array, che non può essere uguale agli interi 0 o 15.

Pyth, 19 byte

&gF_m{.u+NYdYQqFsMQ

Provalo online: cablaggio dimostrativo o di prova

Sto usando il formato tuple / list di Pyth come input. Sostituisci semplicemente gli spazi dei casi di test con virgole.

Spiegazione:

                     implicit: Q is the evaluated input
    m        Q       map each input list d to:
      .u   dY          reduce with intermediate states over d, initial value = []
        +NY              update initial value N with sum of N and Y (current element of d)
     {                 generate a set
   _                 invert
 gF                  check, if the first element is >= (superset) than the second
&                    and
                sMQ  check, if the joined lists of the input
              qF     are equal

Poiché lo pseudo-codice è ancora un po 'confuso, mostrerò l'algoritmo usando un input di esempio.

Input: [[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]

La .u+NYdYparte calcola tutte le liste secondarie continue, che contengono il primo elemento.

[[1,0,9],[1,3,8]]     => [[], [1,0,9], [1,0,9,1,3,8]]
[[1],[0,9],[1,3],[8]] => [[], [1], [1,0,9], [1,0,9,1,3], [1,0,9,1,3,8]]

Bè un perfezionamento di A, iff ogni sottoelenco continuo di Aè anche un sottoelenco continuo di B(c'è solo un'eccezione).

Quindi controllo semplicemente se l'insieme di elenchi continui di Aè un sottoinsieme dell'insieme di elenchi continui di B( gF_m.u+NYdYQ).

L'unica eccezione è se il primo elenco di input contiene meno elementi rispetto al secondo elenco di input. Ad esempio <Fm.u+YdYQ, ritornerebbe Trueper l'input [[1]],[[1],[2]].

Pertanto, controllo anche se le liste unite sono uguali &...qFsMQ.

JavaScript ( ES6 ), 67 70

Modifica 3 byte salvati grazie a @apsillers

Esegui il frammento di seguito in Firefox per testare

f=(a,b)=>a+''==b // same values in the lists ?
&![...a.join(' ')].some((c,p)=>c<','&b.join(c)[p]>c) // splits in a are present in b?

// TEST

out=x=>O.innerHTML += x+'\n';

OK=[
[[],[]],
[[[0]],[[0]]],
[[[1,0,9,1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9,1,3,8]],[[1,0,9,1,3],[8]]],
[[[1,0,9,1,3,8]],[[1],[0],[9],[1],[3],[8]]],
[[[1,0,9],[1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5],[1,4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

KO=[
[[[0]],[]],
[[[0]],[[1]]],
[[[1,0,9]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9,1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9,1],[3,8]]],
[[[1],[0,9],[1,3],[8]],[[1,0,9],[1,3,8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5,1],[4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

dump=l=>l.map(x=>'['+x+']').join(',');

out('YES');
OK.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));
out('NO');
KO.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));

<pre id=O></pre>

C, 69 75

Una funzione con 2 parametri stringa, che restituisce 0 o 1.

Formato dei parametri: elenco secondario separato da spazi (''), elementi elenco separati da virgole.

Esempio: "1,0,9 1,3,8" "1,0 9,1,3,8"

f(char*a,char*b){for(;*a-44?*a&&*b==*a:*b<48;a++)b++;return!(*b|*a);}

Meno golf

int f(char *a, char *b)
{
    // expected in a,b: digit,separator,digit... with separator being ' ' or ','
    for(; *a; a++,b++)
       // ' ' or digit in a must be the same in b
       // comma in a must be comma or space in b
       if (*a != ',' ? *b != *a : *b > *a) return 0;
    return !*b; // must have a null in *b too
}

Test Ideone (obsoleto)

Haskell, 76 byte

[]#[]=1<2
[x]#[y]=x==y
x@(a:b)#(c:d:e)|a==c=b#(d:e)|1<2=x#((c++d):e)
_#_=2<1

Restituisce Trueo False. Esempio di utilizzo: [[1,0,9],[1,3,8]] # [[1,0],[9]]->False .

Approccio ricorsivo semplice: se i primi elementi corrispondono, continua con le code, altrimenti ricomincia da capo ma concatena i due elementi all'inizio della seconda lista. I casi base sono: entrambi gli elenchi sono vuoti -> True; entrambe le liste con un singolo elemento -> confrontale; solo un elenco vuoto -> False.

CJam, 19 byte

q~]{_,,\f>:sS.+}/-!

Provalo online.

I / O

Ingresso

[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]

Produzione

1

Idea

Ogni partizione può essere identificata in modo univoco osservando le seguenti due proprietà:

• La lista formata concatenando tutte le liste.

• I "punti di taglio", compresi gli estremi della lista.

È possibile combinare entrambi i criteri in uno sostituendo ciascun punto di taglio con il sottoelenco di elementi dal punto di taglio fino alla fine dell'elenco.

Per verificare che una determinata partizione sia più fine di un'altra, dobbiamo solo verificare se la partizione più grossolana, rappresentata come sopra, è un sottoinsieme di quella più fine e che gli elenchi più grandi di entrambe le partizioni corrispondono.

Codice

q~]   e# Read from STDIN and evaluate.
{     e# For each array P from the input:
  _,, e#   Push [0 ... L], where L == length(P) - 1.
  \f> e#   Push [P[0:] ... P[L]].
  :s  e#   Stringify each P[k:] (flattens).
  S.+ e#   Vectorized concatenation. This appends a space to the first element.
}/    e#
-!    e# Push the logical NOT of the difference A-B to check if A is a subset of B.

Per l'input dall'esempio I / O, lo stack è valido

["109138 " "138"] ["109138 " "09138" "138" "8"]

prima di eseguire -!.

Si noti che il primo elemento di ciascun array ha uno spazio finale. Questo assicura che confrontiamo l'elenco completo del primo input con l'elenco completo del secondo.

CJam, 24 byte

l~L\{+_a2$1<={;1>L}&}/+!

Algoritmo

Qui usiamo semplicemente un algoritmo avido per vedere se i primi Nsotto-elenchi del secondo elenco possono essere uniti per formare il primo sotto-elenco del primo elenco. Una volta Ntrovato tale , rimuoviamo i primi Nsotto-elenchi dal secondo elenco e il primo sotto-elenco dal primo elenco e ripetiamo il processo.

Idealmente, se la seconda lista fosse un perfezionamento della prima, dovremmo rimanere con 2 liste vuote in pila. Lo controlliamo e stampiamo 1se è così. In qualsiasi altra combinazione, dopo aver ripetutamente ripetuto gli elenchi secondari del secondo elenco, non finiremo con 2 elenchi vuoti. Quindi 0verrà stampato un testamento per tali casi.

Espansione del codice

l~L\{+_a2$1<={;1>L}&}/+!
l~L\                       e# Read the line, evaluate the two lists and put an empty list
                           e# between them
    {               }/     e# Iterate over all sub-lists of the second list
     +                     e# Append the current sub-list to whatever is on stack. Originally
                           e# an empty array, but eventually the sum of first N sub-lists
      _a                   e# Copy this and wrap it in an array
        2$                 e# Copy the first list on top of stack
          1<               e# Get only its first element wrapped in an array. This approach
                           e# is exception safe in case the array was already 0 length
            ={    }&       e# If we have a match, remove both first sub-lists
              ;            e# Remove the first N sub-lists array
               1>          e# Remove the first element from the first array
                 L         e# Put an empty array on stack to repeat the process
                      +!   e# If we are left with two empty arrays, sum them and do logical
                           e# not to get 1. If any of the arrays is non-empty, logical not
                           e# gives 0

Provalo online qui o esegui la suite di test completa qui

C, 120 114 byte

#define C(x),x+=(*x/93)*(1+!!x[1])|1
o;R(char*s,char*t){for(o=1;*s;o&=*s==t[2*(*t==93&&93>*s)]C(s)C(t));return o;}

Di recente non ho giocato a golf, quindi ho pensato di provarlo.

Definiamo una funzione R(char* s, char* t)che restituisce 1if se tè una partizione raffinata di s, e 0altrimenti. se tdovrebbero essere nel formato [DDDD...][DDDD...]...Where eachD è un altro elemento a una cifra.

Codice di prova:

#include "stdio.h"

int main(int argc, char** argv) {
    char* str1, *str2;
    str1 = "[109][138]";
    str2 = "[1][09][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[1][19][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[10][91][3][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));
}

Quanto sopra stampa quanto segue:

Input: [109][138], [1][09][13][8] --> 1
Input: [109][138], [1][19][13][8] --> 0
Input: [109][138], [10][91][3][8] --> 0

Sembra funzionare, almeno.

Haskell, 52 50 53 byte

x#y=and$zipWith(\a b->a==b||a==',')(x++"..")(y++"..")

Completamente diverso dall'altra mia soluzione . Utilizza lo stesso formato di input intelligente della risposta di @ edc65 , ovvero gli elementi sono separati da ,e gli elenchi con .

Esempio di utilizzo: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True.

Il secondo parametro è un perfezionamento del primo, se hanno elementi uguali in ogni posizione o il primo è ,. Devo aggiungere un token di fine univoco (-> ..) a entrambi i parametri, perché zipWithtronca il parametro più lungo e, ad esempio, lo "1,2,3" # "1,2"sarebbe anche True.

Mathematica, 65 byte

f@__=1<0;{}~f~{}=1>0;{a_,b___}~f~{c__,d___}/;a==Join@c:={b}~f~{d}

La matematica con espressioni regolari è divertente!

Javascript ES6, 53 caratteri

(a,b)=>RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

Javascript vintage, 70 caratteri

function f(a,b){return RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

Utilizza lo stesso formato di input di della risposta di edc65 .

Demo completa che include tutti i casi di test qui.

Mathematica, 55 byte

Equal@@Join@@@#&&SubsetQ@@(Accumulate[Length/@#]&)/@##&

Questo definisce una funzione senza nome, prendendo le due partizioni in un unico elenco , in ordine inverso (cioè Yprimo, Xsecondo).

Spiegazione

Equal@@Join@@@#

Ciò verifica che entrambe le partizioni siano effettivamente partizioni dello stesso elenco.

SubsetQ@@(Accumulate[Length/@#]&)/@##

Questa è una forma di golf del mio approccio in questa domanda su Mathematica.SE , che ha ispirato questa sfida. Fondamentalmente, una partizione è definita come un numero di indici in cui sono inserite le divisioni e questo controlla che tutte le posizioni di divisione Xcompaiano anche inY accumulando le lunghezze delle liste secondarie.

Python 2, 68 51 byte

Grazie a xnor per un notevole risparmio di byte!

Funzione anonima che accetta due stringhe del modulo "1,0,9 1,3,8"(preso dalla risposta C di edc65 ) e restituisce Trueo False. Nuova versione con map(None)non funziona più in Python 3.

lambda a,b:all(i in[j,","]for i,j in map(None,a,b))

Suite di test:

>>> def runTests(f):
    assert f("1,0,9 1,3,8","1 0,9 1,3 8")
    assert not f("1,0,9 1,3,8","1,0 9,1 3,8")
    assert f("1 0,9 1,3 8","1 0,9 1,3 8")
    assert not f("1 0,9 1,3 8","1,0,9 1,3,8")
    assert not f("1 0,9 1,3 8","1 0,9 1,3")
    assert not f("1 0,9 1,3,8","1 0,9 1,3")
    print("All tests pass.")


>>> runTests(lambda a,b:all(i in[j,","]for i,j in map(None,a,b)))
All tests pass.

Precedente soluzione a 92 byte che accetta input come "109 138":

def R(a,b):
 r=1
 for i in b.split():r&=a.find(i)==0;a=a[len(i):].strip()
 return r and""==a