Hãy xem xét một loạt các số nguyên:

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

Có rất nhiều cách để phân vùng danh sách này thành các danh sách con liên tiếp. Đây là ba:

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

Chúng tôi sẽ gọi một phân vùng Y và sàng lọc một phân vùng X khác nếu X có thể được lấy từ Y bằng cách nối một số danh sách con của nó lại với nhau.

Vì vậy, Bmột sàng lọc của A: nếu chúng ta tham gia hai danh sách đầu tiên và hai danh sách con cuối cùng trở lại với nhau, chúng ta có được A. Nhưng Clà không một sự tinh tế của A: chúng ta sẽ phải chia tay sự 9và 1để thu hồi Atừ nó. Ngoài ra, bất kỳ phân vùng là tầm thường của chính nó.

Lưu ý rằng chúng tôi không được phép sắp xếp lại bất kỳ danh sách con hoặc thành phần nào tại bất kỳ thời điểm nào.

Các thách thức

Đưa ra hai phân vùng (danh sách danh sách các số nguyên) Xvà Y, xác định xem có phải Ylà sàng lọc hay không X.

Bạn có thể giả định rằng các phân vùng sẽ chỉ chứa các số nguyên từ 0đến 9, bao gồm. Bạn không được cho rằng Xvà Ylà các phân vùng của cùng một danh sách (nếu chúng không có, chúng cũng không phải là các sàng lọc của nhau). Xvà / hoặc Ycó thể trống nhưng sẽ không bao giờ chứa danh sách con trống.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đầu vào có thể được thực hiện trong bất kỳ định dạng chuỗi hoặc danh sách thuận tiện. Vì các phần tử sẽ chỉ là số nguyên một chữ số, bạn có thể chọn bỏ qua một dấu phân cách trong danh sách phụ, nhưng hãy đảm bảo rằng các số đứng đầu 0là có thể. Bạn có thể chọn lấy Xvà Ytheo thứ tự ngược lại.

Đầu ra phải là sự thật nếu Ylà một sàng lọc Xvà giả mạo khác.

Mã của bạn phải có khả năng giải quyết từng trường hợp thử nghiệm bên dưới trong 1 giây trên máy tính để bàn hợp lý. (Đây chỉ là một kiểm tra vệ sinh để tránh các giải pháp vũ phu đơn giản.)

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

Mỗi trường hợp thử nghiệm là trên dòng riêng của nó, được viết là X Y. Tôi đang sử dụng ký hiệu mảng theo kiểu GolfScript / CJam để tiết kiệm một số không gian ngang:

Sự thật:

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

Giả mạo:

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

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Những thách thức liên quan

• Tính toán tham gia và gặp gỡ phân vùng

CJam, 13 10 9 byte

lr.-F-U-!

Hãy thử trực tuyến trong trình thông dịch CJam .

Cảm ơn @ MartinBüttner đã gợi ý định dạng đầu vào khéo léo của @ edc65 .

Cảm ơn @ jimmy23013 vì đã cải thiện định dạng đầu vào và loại bỏ 3 byte bổ sung.

Tôi / O

Đầu vào

Danh sách con được phân tách bằng ;và cách nhau bởi ,:

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

Đầu ra

1

Làm thế nào nó hoạt động

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.

Đối với các chuỗi có độ dài khác nhau, .-sẽ để lại các ký tự trong mảng, không thể bằng các số nguyên 0 hoặc 15.

Bình thường, 19 byte

&gF_m{.u+NYdYQqFsMQ

Dùng thử trực tuyến: Trình diễn hoặc thử nghiệm khai thác

Tôi đang sử dụng định dạng tuple / list của Pyth làm đầu vào. Đơn giản chỉ cần thay thế không gian của các trường hợp thử nghiệm bằng dấu phẩy.

Giải trình:

                     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

Vì mã giả vẫn còn một chút khó hiểu, tôi sẽ trình bày thuật toán bằng cách sử dụng một ví dụ đầu vào.

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

Phần này .u+NYdYtính toán tất cả các danh sách con liên tục, có chứa phần tử đầu tiên.

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

Blà một sàng lọc của A, mỗi danh sách con liên tục Acũng là một danh sách con liên tục của B(chỉ có một ngoại lệ).

Vì vậy, tôi chỉ cần kiểm tra, nếu tập hợp các danh sách con liên tục của Alà một tập hợp con của tập hợp danh sách con liên tục của B( gF_m.u+NYdYQ).

Ngoại lệ duy nhất là, nếu danh sách đầu vào đầu tiên chứa ít thành phần hơn danh sách đầu vào thứ hai. Ví dụ <Fm.u+YdYQsẽ trả lại Truecho đầu vào [[1]],[[1],[2]].

Do đó tôi cũng kiểm tra xem danh sách tham gia có bằng nhau không &...qFsMQ.

JavaScript ( ES6 ), 67 70

Chỉnh sửa 3 byte lưu thx @apsillers

Chạy đoạn trích dưới đây trong Firefox để kiểm tra

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

Một hàm có 2 tham số chuỗi, trả về 0 hoặc 1.

Định dạng tham số: danh sách con được phân tách bằng dấu cách (''), liệt kê các phần tử được phân tách bằng dấu phẩy.

Thí dụ: "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);}

Ít chơi gôn

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
}

Kiểm tra Ideone (lỗi thời)

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

Trả về Truehoặc False. Ví dụ sử dụng: [[1,0,9],[1,3,8]] # [[1,0],[9]]-> False.

Cách tiếp cận đệ quy đơn giản: nếu các phần tử đầu tiên khớp, tiếp tục với các đuôi, phần khác bắt đầu lại nhưng nối hai phần tử ở phía trước danh sách thứ hai. Các trường hợp cơ bản là: cả hai danh sách trống -> True; cả hai danh sách với một yếu tố duy nhất -> so sánh chúng; chỉ có một danh sách trống -> False.

CJam, 19 byte

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

Hãy thử trực tuyến.

Tôi / O

Đầu vào

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

Đầu ra

1

Ý kiến

Mỗi phân vùng có thể được xác định duy nhất bằng cách quan sát hai thuộc tính sau:

• Danh sách được hình thành bằng cách ghép tất cả các danh sách phụ.

• Các "điểm cắt", bao gồm các cực trị của danh sách.

Chúng ta có thể kết hợp cả hai tiêu chí thành một bằng cách thay thế từng điểm cắt bằng danh sách con của các phần tử từ điểm cắt đến cuối danh sách.

Để xác minh rằng một phân vùng đã cho là tốt hơn phân vùng khác, chúng ta chỉ phải xác minh xem phân vùng thô hơn, được trình bày như trên, có phải là một tập hợp con của phân vùng mịn hơn và danh sách lớn nhất của cả hai phân vùng khớp với nhau không.

Mã

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.

Đối với mẫu đầu vào, ví dụ I / O, ngăn xếp giữ

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

trước khi thi hành -!.

Lưu ý rằng phần tử đầu tiên của mỗi mảng có một khoảng trắng ở cuối. Điều này đảm bảo chúng tôi so sánh danh sách đầy đủ của đầu vào đầu tiên với danh sách đầy đủ của đầu vào thứ hai.

CJam, 24 byte

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

Thuật toán

Ở đây chúng ta chỉ cần sử dụng một thuật toán tham lam để xem liệu Ndanh sách phụ đầu tiên của danh sách thứ hai có thể được hợp nhất với nhau để tạo thành danh sách phụ đầu tiên của danh sách đầu tiên hay không. Khi Ntìm thấy như vậy , chúng tôi xóa Ndanh sách phụ đầu tiên khỏi danh sách thứ hai và danh sách phụ đầu tiên khỏi danh sách đầu tiên và lặp lại quy trình.

Lý tưởng nhất, nếu danh sách thứ hai là một sàng lọc của danh sách đầu tiên, chúng ta nên để lại 2 danh sách trống trên ngăn xếp. Chúng tôi chỉ kiểm tra và in 1nếu đó là trường hợp. Trong bất kỳ kết hợp nào khác, sau khi lặp lại đầy đủ các danh sách phụ của danh sách thứ hai, chúng tôi sẽ không kết thúc với 2 danh sách trống. Do đó, một 0sẽ được in cho các trường hợp như vậy.

Mở rộng mã

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

Dùng thử trực tuyến tại đây hoặc chạy bộ thử nghiệm hoàn chỉnh tại đây

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

Gần đây tôi không chơi gôn, vì vậy tôi nghĩ tôi sẽ thử cái này.

Chúng tôi định nghĩa một hàm R(char* s, char* t)trả về 1nếu tlà một phân vùng được tinh chỉnh s, và 0nếu không. svà tdự kiến ​​sẽ ở định dạng [DDDD...][DDDD...]...Trong đó mỗi Dphần tử là một phần tử một chữ số khác.

Mã kiểm tra:

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

Trên đây in như sau:

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

Nó dường như làm việc, ít nhất.

Haskell, 52 50 53 byte

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

Hoàn toàn khác với giải pháp khác của tôi . Sử dụng định dạng đầu vào thông minh giống như câu trả lời của @ edc65 , tức là các phần tử được phân tách bằng ,và liệt kê với .

Ví dụ sử dụng: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True.

Tham số thứ hai là một sàng lọc của đầu tiên, nếu chúng có các phần tử bằng nhau ở mọi vị trí hoặc đầu tiên là ,. Tôi phải nối thêm mã thông báo kết thúc duy nhất (-> ..) cho cả hai tham số, vì zipWithcắt bớt tham số dài hơn và ví dụ "1,2,3" # "1,2"cũng sẽ như vậy True.

Toán học, 65 byte

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

Toán học với các biểu thức thông thường là niềm vui!

Javascript ES6, 53 ký tự

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

Javascript cổ điển, 70 ký tự

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

Sử dụng định dạng đầu vào giống như câu trả lời của edc65 .

Bản demo đầy đủ bao gồm tất cả các trường hợp thử nghiệm ở đây.

Toán học, 55 byte

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

Điều này xác định một hàm không tên, lấy hai phân vùng trong một danh sách , theo thứ tự ngược lại (tức là Ythứ nhất, Xthứ hai).

Giải trình

Equal@@Join@@@#

Điều này kiểm tra rằng cả hai phân vùng thực sự là phân vùng của cùng một danh sách.

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

Đây là một hình thức đánh gôn của cách tiếp cận của tôi trong câu hỏi này trên Mathematica.SE , đã truyền cảm hứng cho thử thách này. Về cơ bản, một phân vùng được định nghĩa là một số chỉ mục nơi chia tách được chèn và điều này kiểm tra xem tất cả các vị trí chia Xcũng xuất hiện Ybằng cách tích lũy độ dài của danh sách con.

Python 2, 68 51 byte

Cảm ơn xnor cho một số tiết kiệm byte đáng kể!

Hàm ẩn danh có hai chuỗi biểu mẫu "1,0,9 1,3,8"(lấy từ câu trả lời C của edc65 ) và trả về Truehoặc False. Phiên bản mới map(None)không còn hoạt động trong Python 3.

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

Bộ kiểm tra:

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

Giải pháp 92 byte trước đó có đầu vào là "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