Рассмотрим массив целых чисел:

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

Есть много способов разделить этот список на последовательные списки. Вот три:

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

Мы будем называть разбиение Y и утонченность другого раздела X , если X может быть получено из Y , соединив несколько его подсписков вместе.

Так Bесть уточнение A: если мы объединим две первые и две последние подсписки вместе, мы получаем A. Но Cэто не уточнение A: мы должны были бы разделить 9и 1, чтобы оправиться Aот этого. Кроме того, любой раздел является тривиальным уточнением самого себя.

Обратите внимание, что мы не можем переставлять любые списки или элементы в любой точке.

Соревнование

Учитывая два раздела (списки списков целых чисел) Xи Y, определить, Yявляется ли уточнениеX .

Вы можете предположить, что разделы будут содержать только целые числа от 0до 9, включительно. Вы не должны предполагать, что Xи Yявляются разделами одного и того же списка (если они не являются, они также не являются уточнениями друг друга). Xи / или Yможет быть пустым, но никогда не будет содержать пустых списков.

Вы можете написать программу или функцию, принимая ввод через STDIN (или ближайшую альтернативу), аргумент командной строки или аргумент функции и выводя результат через STDOUT (или ближайшую альтернативу), возвращаемое значение функции или параметр функции (out).

Ввод может быть сделан в любой удобной строке или формате списка. Поскольку элементы будут состоять только из однозначных целых чисел, вы можете опустить разделитель в подсписках, но убедитесь, что 0возможны начальные s. Вы можете взять Xи Yв обратном порядке.

Вывод должен быть правдивым, если Yуточнение, Xи ложным в противном случае.

Ваш код должен быть в состоянии решить каждый из приведенных ниже тестовых примеров за 1 секунду на подходящем настольном компьютере. (Это всего лишь проверка работоспособности, чтобы избежать простых переборов.)

Это код для гольфа, так что самый короткий ответ (в байтах) выигрывает.

Тестовые случаи

Каждый тестовый пример находится в отдельной строке, записанной как X Y. Я использую обозначение массива в стиле GolfScript / CJam, чтобы сэкономить пространство по горизонтали:

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

Leaderboards

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Связанные проблемы

• Вычислить объединение и встречу разделов

CJam, 13 10 9 байт

lr.-F-U-!

Попробуйте онлайн в интерпретаторе CJam .

Спасибо @ MartinBüttner за предложение оригинального формата ввода @ edc65 .

Спасибо @ jimmy23013 за улучшение формата ввода и добавление 3 дополнительных байтов.

I / O

вход

Сублисты отделены ;друг от друга ,:

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

Выход

1

Как это устроено

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.

Для строк разной длины .-в массиве останутся символы, которые не могут быть равны целым числам 0 или 15.

Pyth, 19 байт

&gF_m{.u+NYdYQqFsMQ

Попробуйте онлайн: демонстрация или тестовая привязь

Я использую формат кортежа / списка Пита в качестве входных данных. Просто замените пробелы на запятые.

Объяснение:

                     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

Поскольку псевдокод все еще немного сбивает с толку, я продемонстрирую алгоритм на примере ввода.

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

.u+NYdYЧасть вычисляет все непрерывные подсписки, которые содержат первый элемент.

[[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является уточнением A, если каждый непрерывный подсписок Aтакже является непрерывным подспискомB (есть только одно исключение).

Поэтому я просто проверяю, является ли множество непрерывных подсписков из Aмножества подмножеством непрерывных подсписков из B(gF_m.u+NYdYQ ).

Единственное исключение - если первый список ввода содержит меньше элементов, чем второй список ввода. Например <Fm.u+YdYQ, вернется Trueдля ввода[[1]],[[1],[2]] .

Поэтому я также проверяю, равны ли объединенные списки &...qFsMQ.

JavaScript ( ES6 ), 67 70

редактировать 3 байта, сохраненные thx @apsillers

Запустите фрагмент ниже в Firefox, чтобы проверить

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>

С 69 75

Функция с 2 строковыми параметрами, возвращающая 0 или 1.

Формат параметра: подсписок, разделенный пробелами (''), элементы списка, разделенные запятыми.

Пример: "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);}

Меньше гольфа

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
}

Тест Ideone (устаревший)

Haskell, 76 байт

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

Возвращает Trueили False. Пример использования: [[1,0,9],[1,3,8]] # [[1,0],[9]]->False .

Простой рекурсивный подход: если первые элементы совпадают, продолжайте с хвостами, иначе начните сначала, но объедините два элемента в начале второго списка. Базовые случаи: оба списка пустые -> True; оба списка с одним элементом -> сравнить их; только один список пуст -> False.

CJam, 19 байтов

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

Попробуйте онлайн.

I / O

вход

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

Выход

1

идея

Каждый раздел может быть однозначно идентифицирован, соблюдая следующие два свойства:

• Список формируется путем объединения всех подсписков.

• «Точки разреза», включая крайности списка.

Мы можем объединить оба критерия в один, заменив каждую точку вырезания подсписком элементов от точки вырезания до конца списка.

Чтобы убедиться, что данный раздел более тонкий, чем другой, нам нужно только проверить, является ли более грубый раздел, представленный, как указано выше, подмножеством более тонкого и совпадают ли самые большие списки обоих разделов.

Код

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.

Для ввода из примера ввода / вывода стек содержит

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

перед выполнением -!.

Обратите внимание, что первый элемент каждого массива имеет завершающий пробел. Это гарантирует, что мы сравниваем полный список первого ввода с полным списком второго.

CJam, 24 байта

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

Алгоритм

Здесь мы просто используем жадный алгоритм, чтобы увидеть, Nможно ли объединить первые подсписки второго списка, чтобы сформировать первый подсписок первого списка. Как только такой Nнайден, мы удаляем первыйN подсписки из второго списка и первый подсписок из первого списка и повторяем процесс.

В идеале, если второй список является уточнением первого, нам следует оставить 2 пустых списка в стеке. Мы просто проверяем это и печатаем, 1если это так. В любой другой комбинации, после полной итерации по подспискам второго списка, мы не получим 2 пустых списка. Таким образом, 0будет напечатан для таких случаев.

Расширение кода

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

Попробуйте онлайн здесь или запустите полный набор тестов здесь

C 120 114 байтов

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

Я не так много играл в гольф в последнее время, поэтому я решил попробовать это.

Мы определяем функцию, R(char* s, char* t)которая возвращает, 1если tявляется уточненным разделом s, и в 0противном случае. sи, tкак ожидается, будут в формате, [DDDD...][DDDD...]...где каждыйD является другим однозначным элементом.

Тестовый код:

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

Выше напечатано следующее:

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

Кажется, работает, по крайней мере.

Haskell, 52 50 53 байта

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

Полностью отличается от моего другого решения . Использует тот же умный формат ввода, что и в ответе @ edc65 , т.е. элементы разделяются, и списки с .

Пример использования: "1,0,9,1,3,8" # "1,0,9 1,3,8" -> True.

Второй параметр - это уточнение первого, если они имеют одинаковые элементы в каждой позиции или первый ,. Я должен добавить уникальный маркер конца (-> ..) к обоим параметрам, потому что zipWithусекает более длинный параметр и, например "1,2,3" # "1,2", также будет True.

Mathematica, 65 байт

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

Математика с регулярными выражениями это весело!

ES6 Javascript, 53 символа

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

Винтажный Javascript, 70 символов

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

Использует тот же формат ввода, что и в ответе edc65 .

Полное демо, включая все тестовые примеры здесь.

Mathematica, 55 байт

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

Это определяет безымянную функцию, беря два раздела в одном списке , в обратном порядке (т.е. Yпервый, Xвторой).

объяснение

Equal@@Join@@@#

Это проверяет, что оба раздела фактически являются разделами одного и того же списка.

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

Это форма моего подхода к Mathematica.SE , которая вдохновила меня на этот вопрос . По сути, раздел определяется как ряд индексов, в которые вставляются разделители, и это проверяет, что все позиции разделения Xтакже появляются Y, накапливая длины подсписков.

Python 2, 68 51 байт

Спасибо xnor за значительную экономию байтов!

Анонимная функция, которая принимает две строки формы "1,0,9 1,3,8"(взяты из ответа C edc65 ) и возвращает Trueили False. Новая версия map(None)больше не работает в Python 3.

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

Тестирование:

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

Предыдущее 92-байтовое решение, которое принимает входные данные как "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