Розглянемо масив цілих чисел:

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

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

Вихід повинен бути правдивим, якщо Yце вдосконалення Xта хибне в іншому випадку.

Ваш код повинен мати можливість вирішити кожен із наведених нижче тестових випадків на розумній настільній машині. (Це лише перевірка добросовісності, щоб уникнути простих рішучих рішень.)

Це кодовий гольф, тому найкоротша відповідь (у байтах) виграє.

Випробування

Кожен тестовий випадок знаходиться у власному рядку, записаному як 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]]

Фальсі:

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

Табло лідерів

Ось фрагмент стека для створення як звичайного табло, так і огляду переможців за мовою.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# 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

Спробуйте в Інтернеті: Демонстрація або Тест-джгут

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

Пояснення:

                     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
}

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

Математика, 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 .

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

Математика, 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