Considere uma matriz de números inteiros:

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

Existem várias maneiras de particionar esta lista em sublistas consecutivas. Aqui estão três:

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

Chamaremos uma partição Y e o refinamento de outra partição X se X puder ser obtido de Y juntando algumas de suas sublistas novamente.

O mesmo Bvale para um refinamento de A: se juntarmos os dois primeiros e os dois últimos sublistas juntos, obteremos A. Mas Cé não um refinamento A: teríamos que dividir o 9e 1a fim de recuperar Aa partir dele. Além disso, qualquer partição é trivialmente um refinamento de si mesma.

Observe que não temos permissão para reorganizar sublistas ou elementos a qualquer momento.

O desafio

Dadas duas partições (listas de listas de números inteiros) Xe Y, determine se Yé um refinamento de X.

Você pode assumir que as partições conterão apenas números inteiros de 0até 9, inclusive. Você não deve assumir isso Xe Yé partição da mesma lista (se não for, também não será um refinamento um do outro). Xe / ou Ypode estar vazio, mas nunca conterá sublistas vazias.

Você pode escrever um programa ou função, recebendo entrada via STDIN (ou alternativa mais próxima), argumento da linha de comando ou argumento da função e emitindo o resultado via STDOUT (ou alternativa mais próxima), valor de retorno da função ou parâmetro da função (saída).

A entrada pode ser obtida em qualquer formato conveniente de sequência ou lista. Como os elementos serão apenas números inteiros de um dígito, você pode optar por omitir um delimitador nas sublistas, mas certifique-se de que 0s iniciais sejam possíveis. Você pode optar por tomar Xe Yem ordem oposta.

A saída deve ser verdadeira se Yfor um refinamento Xe uma falsificação de outra forma.

Seu código deve ser capaz de resolver cada um dos casos de teste abaixo em 1 segundo em uma máquina de desktop razoável. (Esta é apenas uma verificação de sanidade para evitar soluções simples de força bruta.)

Isso é código de golfe, então a resposta mais curta (em bytes) vence.

Casos de teste

Cada caso de teste está em sua própria linha, escrita como X Y. Estou usando a notação de matriz no estilo GolfScript / CJam para economizar espaço horizontal:

Verdade:

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

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# 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>

Desafios relacionados

• Calcular a junção e reunião de partições

CJam, 13 10 9 bytes

lr.-F-U-!

Experimente on-line no intérprete CJam .

Obrigado a @ MartinBüttner por sugerir o engenhoso formato de entrada de @ edc65 .

Obrigado a @ jimmy23013 por melhorar o formato de entrada e obter 3 bytes adicionais.

I / O

Entrada

As sublistas são separadas por ;e umas das outras por ,:

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

Resultado

1

Como funciona

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.

Para cadeias de comprimento diferente, .-deixará caracteres na matriz, que não podem ser iguais aos números inteiros 0 ou 15.

Pitão, 19 bytes

&gF_m{.u+NYdYQqFsMQ

Experimente on-line: demonstração ou equipamento de teste

Estou usando o formato de tupla / lista de Pyth como entrada. Simplesmente substitua os espaços dos casos de teste por vírgulas.

Explicação:

                     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

Como o pseudo-código ainda é um pouco confuso, demonstrarei o algoritmo usando uma entrada de exemplo.

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

A .u+NYdYpeça calcula todas as sublistas contínuas que contêm o primeiro 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é um refinamento do Aiff de cada sub-lista contínua Atambém é uma sub-lista contínua de B(há apenas uma exceção).

Portanto, simplesmente verifico se o conjunto de sublistas contínuas de Aé um subconjunto do conjunto de sublistas contínuas de B( gF_m.u+NYdYQ).

A única exceção é se a primeira lista de entrada contiver menos elementos que a segunda lista de entrada. Por exemplo <Fm.u+YdYQ, retornaria Truepara a entrada [[1]],[[1],[2]].

Portanto, também verifico se as listas unidas também são iguais &...qFsMQ.

JavaScript ( ES6 ), 67 70

Editar 3 bytes salvos thx @apsillers

Execute o trecho abaixo no Firefox para testar

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

Uma função com 2 parâmetros de string, retornando 0 ou 1.

Formato do parâmetro: sub-lista separada por espaços (''), elementos da lista separados por vírgulas.

Exemplo: "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);}

Menos golfe

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
}

Ideona de teste (desatualizada)

Haskell, 76 bytes

[]#[]=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

Devoluções TrueouFalse . Exemplo de uso: [[1,0,9],[1,3,8]] # [[1,0],[9]]-> False.

Abordagem recursiva simples: se os primeiros elementos corresponderem, continue com as caudas, ou então comece de novo, mas concatene os dois elementos na frente da segunda lista. Os casos base são: ambas as listas vazias -> True; ambas as listas com um único elemento -> compare-as; apenas uma lista vazia -> False.

CJam, 19 bytes

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

Experimente online.

I / O

Entrada

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

Resultado

1

Idéia

Cada partição pode ser identificada exclusivamente observando as duas propriedades a seguir:

• A lista formada concatenando todas as sublistas.

• Os "pontos de corte", incluindo os extremos da lista.

Podemos combinar os dois critérios em um, substituindo cada ponto de corte pela sub-lista de elementos do ponto de corte até o final da lista.

Para verificar se uma determinada partição é mais fina que a outra, precisamos apenas verificar se a partição mais grossa, representada como acima, é um subconjunto da mais fina e se as maiores listas de ambas as partições correspondem.

Código

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.

Para o formulário de entrada do exemplo de E / S, a pilha mantém

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

antes de executar -! .

Observe que o primeiro elemento de cada matriz possui um espaço à direita. Isso garante que comparemos a lista completa da primeira entrada com a lista completa da segunda.

CJam, 24 bytes

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

Algoritmo

Aqui, simplesmente usamos um algoritmo ganancioso para ver se as primeiras Nsub-listas da segunda lista podem ser mescladas para formar a primeira sub-lista da primeira lista. Uma vez Nencontrado, removemos as primeiras Nsub-listas da segunda lista e a primeira sub-lista da primeira lista e repetimos o processo.

Idealmente, se a segunda lista era um refinamento da primeira, deveríamos ficar com 2 listas vazias na pilha. Apenas verificamos e imprimimos 1se for esse o caso. Em qualquer outra combinação, depois de iterar completamente as sub-listas da segunda lista, não terminaremos com duas listas vazias. Assim, a 0será impresso para esses casos.

Expansão de código

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

Experimente on-line aqui ou execute o conjunto de testes completo aqui

C, 120 114 bytes

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

Não joguei muito recentemente, então pensei em experimentar isso.

Definimos uma função R(char* s, char* t)que retorna 1se té uma partição refinada de s, e 0caso contrário. se tdeve estar no formato [DDDD...][DDDD...]...Onde cada um Dé outro elemento de um dígito.

Código de teste:

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

O texto acima imprime o seguinte:

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

Parece funcionar, pelo menos.

Haskell, 52 50 53 bytes

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

Completamente diferente do meu outra solução . Usa o mesmo formato de entrada inteligente que a resposta do @ edc65 , ou seja, os elementos são separados por ,e listados com .

Exemplo de uso: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True.

O segundo parâmetro é um refinamento do primeiro, se eles tiverem elementos iguais em todas as posições ou se o primeiro for ,. Eu tenho que acrescentar um token final exclusivo (-> ..) aos dois parâmetros, porque zipWithtrunca o parâmetro mais longo e, por exemplo "1,2,3" # "1,2", também seriaTrue .

Mathematica, 65 bytes

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

Matemática com expressões regulares é divertida!

ES6 Javascript, 53 caracteres

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

Javascript vintage, 70 caracteres

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

Usa o mesmo formato de entrada que a resposta do edc65 .

Demonstração completa, incluindo todos os casos de teste aqui.

Mathematica, 55 bytes

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

Isso define uma função sem nome, levando as duas partições em uma única lista , em ordem inversa (isto é Y, primeiro, Xsegundo).

Explicação

Equal@@Join@@@#

Isso verifica se as duas partições são realmente da mesma lista.

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

Esta é uma forma golfe da minha abordagem nesta questão sobre o Mathematica.SE , que inspirou esse desafio. Basicamente, uma partição é definida como um número de índices onde as divisões são inseridas, e isso verifica se todas as posições de divisão Xtambém aparecem Y, acumulando os comprimentos das sublistas.

Python 2, 68 51 bytes

Obrigado ao xnor por uma economia considerável de bytes!

Função anônima que pega duas cadeias de caracteres do formulário "1,0,9 1,3,8"(extraídas da resposta C de edc65 ) e retorna Trueor False. A nova versão map(None)não funciona mais no Python 3.

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

Suíte de teste:

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

Solução anterior de 92 bytes que recebe entradas como "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