Bir tamsayı dizisi düşünün:

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

Bu listeyi ardışık alt listelere bölmenin birçok yolu vardır. İşte üç:

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

Bir bölümü arayacak Y başka bölüm ve arıtmayı X eğer X alınabilir Y tekrar bir araya onun sublists bazı katılarak.

Bu Bda bir ayrıntılandırmadır A: ilk iki ve son iki alt listeyi tekrar birleştirirsek, elde ederiz A. Ama Cbir değil bir arıtma A: ayrılalım olurdu 9ve 1kurtarmak amacıyla Aondan. Ayrıca, herhangi bir bölüm önemsiz bir şekilde kendi geliştirmesidir.

Herhangi bir noktada alt listeleri veya öğeleri yeniden düzenlememize izin verilmediğini unutmayın.

Meydan okuma

Verilen iki bölüm (tamsayıların listesi listeleri) Xve Y, Ybir ayrıntılandırma olup olmadığını belirlemek X.

Sen bölümleri sadece gelen tamsayılar içerecektir varsayabiliriz 0için 9kapsayıcı. Bunu varsaymamalısınız Xve Yaynı listenin bölümleridirler (eğer değilse, onlar da birbirlerinin ayrıntılandırması değildir). Xve / veya Yboş olabilir, ancak asla boş alt listeler içermez.

STDIN (veya en yakın alternatif), komut satırı bağımsız değişkeni veya işlev bağımsız değişkeni ile girdi alarak ve sonucu STDOUT (veya en yakın alternatif), işlev dönüş değeri veya işlev (çıkış) parametresi aracılığıyla çıktı alarak bir program veya işlev yazabilirsiniz.

Giriş herhangi bir uygun dize veya liste formatında alınabilir. Öğeler yalnızca tek basamaklı tamsayılar olacağından, alt listeler içinde bir sınırlayıcıyı atlamayı seçebilirsiniz, ancak baştaki satırların mümkün olduğundan emin olun 0. Almayı Xve Ytersi sırada almayı seçebilirsiniz .

Çıktı olmalıdır truthy eğer Ybir arıtma olduğunu Xve falsy aksi.

Kodunuz, aşağıdaki test senaryolarının her birini makul bir masaüstü bilgisayarda 1 saniye içinde çözebilmelidir. (Bu basit kaba kuvvet çözümlerinden kaçınmak için sadece bir sağlık kontrolüdür.)

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Test Durumları

Her test senaryosu kendi satırında, olarak yazılmıştır X Y. Bazı yatay alan kazanmak için GolfScript / CJam tarzı dizi gösterimi kullanıyorum:

Doğru:

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

Liderler

İşte hem düzenli bir skor tablosu hem de kazananları dile göre gözden geçirmek için bir Yığın Parçacığı.

Yanıtınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak yanıtınızı bir başlıkla başlatın:

# Language Name, N bytes

Ngönderiminizin büyüklüğü nerede . Skorunuzu yükseltirseniz, eski skorları başlığa vurarak tutabilirsiniz. Örneğin:

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

İlgili Zorluklar

• Bölümlerin Birleşmesini ve Buluşmasını Karşılayın

CJam, 13 10 9 bayt

lr.-F-U-!

CJam yorumlayıcısında çevrimiçi deneyin .

@ Edc65'in ustaca giriş formatını önerdiği için @ MartinBüttner'a teşekkürler .

Giriş formatını iyileştirmek ve 3 ek bayt golf oynamak için @ jimmy23013 sayesinde.

I / O

Giriş

Alt listeler birbirlerinden ;ve birbirlerinden ayrılır ,:

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

Çıktı

1

Nasıl çalışır

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.

Farklı uzunluktaki dizeler için .-, dizide 0 veya 15 tamsayılarına eşit olmayan karakterler bırakılır.

Pyth, 19 bayt

&gF_m{.u+NYdYQqFsMQ

Çevrimiçi deneyin: Gösteri veya Test koşum takımı

Pyth'in tuple / list formatını girdi olarak kullanıyorum. Test senaryolarının boşluklarını virgülle değiştirmeniz yeterlidir.

Açıklama:

                     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

Sahte kod hala biraz kafa karıştırıcı olduğundan, örnek bir giriş kullanarak algoritmayı göstereceğim.

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

.u+NYdYBölüm birinci eleman içeren tüm sürekli sublists, hesaplar.

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

Bbir arıtma olduğunu Aher kesintisiz alt liste IFF, Aaynı zamanda sürekli bir alt liste olduğunu B(sadece bir istisna var).

Yani, sürekli Aalt listeleri kümesinin B( gF_m.u+NYdYQ) sürekli alt listeleri kümesinin bir alt kümesi olup olmadığını kontrol ediyorum .

Tek istisna, eğer birinci girdi listesi ikinci girdi listesinden daha az eleman içeriyorsa. Örneğin , girdi için <Fm.u+YdYQdönecekti .True[[1]],[[1],[2]]

Bu nedenle, birleştirilmiş listelerin de eşit olup olmadığını da kontrol ediyorum &...qFsMQ.

JavaScript ( ES6) ), 67 70

Düzenleme 3 kaydedilmiş thx @apsillers bayt

Test etmek için aşağıdaki snippet'i Firefox'ta çalıştırın

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

0 veya 1 döndüren 2 dize parametresine sahip bir işlev.

Parametre biçimi: boşluklarla ayrılmış alt liste (''), virgüllerle ayrılmış liste öğeleri.

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

Daha az 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 (modası geçmiş)

Haskell, 76 bayt

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

TrueVeya döndürür False. Örnek kullanım: [[1,0,9],[1,3,8]] # [[1,0],[9]]->False .

Basit özyinelemeli yaklaşım: İlk öğeler eşleşirse, kuyruklarla devam edin, başka baştan başlayın ancak ikinci listenin önündeki iki öğeyi birleştirin. Temel durumlar: her iki liste de boş -> True; her iki liste tek bir öğeyle -> karşılaştır; yalnızca bir liste boş -> False.

CJam, 19 bayt

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

Çevrimiçi deneyin.

I / O

Giriş

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

Çıktı

1

Fikir

Her bölüm aşağıdaki iki özellik gözlenerek benzersiz şekilde tanımlanabilir:

• Tüm alt listelerin birleştirilmesiyle oluşturulan liste.

• Listenin uç noktaları dahil "kesme noktaları".

Her bir kesme noktasını, kesme noktasından listenin sonuna kadar öğelerin alt listesiyle değiştirerek her iki kriteri de birleştirebiliriz.

Belirli bir bölümün diğerinden daha iyi olduğunu doğrulamak için, yalnızca yukarıda gösterildiği gibi daha kaba bölümün daha ince olanın bir alt kümesi olup olmadığını ve her iki bölümün en büyük listelerinin eşleştiğini doğrulamamız gerekir.

kod

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.

Giriş formunda G / Ç örneği için, yığın

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

çalıştırmadan önce -! .

Her dizinin ilk öğesinin sonunda bir boşluk olduğunu unutmayın. Bu, ilk girişin tam listesini ikincinin tam listesiyle karşılaştırmamızı sağlar.

CJam, 24 bayt

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

Algoritma

Burada, ilk Nlistenin ilk alt listesini oluşturmak için ikinci listenin ilk alt listelerinin birleştirilip birleştirilemeyeceğini görmek için açgözlü bir algoritma kullanıyoruz . Böyle bir Nşey bulunduğunda, ilkiniN alt listeleri ikinci listeden ve ilk alt listeyi ilk listeden ve işlemi tekrarlarız.

İdeal olarak, ikinci liste birincinin inceliğiyse, yığınta 2 boş liste bırakılmalıdır. Sadece bunu kontrol ediyoruz 1ve durum buysa yazdırıyoruz . Başka herhangi bir kombinasyonda, ikinci listenin alt listeleri üzerinde tam olarak yineledikten sonra, 2 boş liste ile sonuçlanmayacağız. Böylece 0bu gibi durumlar için bir baskı yapılacaktır.

Kod genişletme

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

Buradan çevrimiçi deneyin veya tüm test paketini burada çalıştırın

Cı, 120 114 bayt

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

Ben son zamanlarda golf değil, bu yüzden bunu denemek düşündüm.

Eğer rafine edilmiş bir bölüm ise , aksi takdirde R(char* s, char* t)geri dönen bir fonksiyon tanımlarız . ve her birinin başka bir tek haneli öğe olduğu biçiminde olması beklenir .1ts0st[DDDD...][DDDD...]...D

Test kodu:

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

Yukarıdakiler aşağıdakileri yazdırır:

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

En azından işe yarıyor gibi görünüyor.

Haskell, 52 50 53 bayt

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

Benim tamamen farklı başka çözümü . @ Edc65 yanıtıyla aynı akıllı giriş biçimini kullanır , yani öğeler ile ayrılır ,ve ile listeler .

Kullanım örneği: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True.

İkinci parametre, her pozisyonda eşit elemanlara sahipse veya birincisi varsa, birincinin inceliğidir ,. Her ..iki parametreye benzersiz bir bitiş belirteci (-> ) eklemek zorundayım , çünkü zipWithdaha uzun parametreyi keser ve örneğin "1,2,3" # "1,2"de olur True.

Mathematica, 65 bayt

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

Düzenli ifadelerle matematik eğlencelidir!

ES6 Javascript, 53 karakter

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

Vintage Javascript, 70 karakter

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

Edc65'in cevabı ile aynı giriş formatını kullanır .

Tüm test senaryolarını içeren tam demo.

Mathematica, 55 bayt

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

Bu , iki bölümü tek bir listede ters sırada (yani Yönce,X ikinci) .

açıklama

Equal@@Join@@@#

Bu, her iki bölümün aslında aynı listenin bölümleri olup olmadığını denetler.

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

Bu, Mathematica.SE ile ilgili bu sorudaki yaklaşımımın bu zorluğa ilham veren golfçü bir biçimidir . Temel olarak, bir bölüm, bölünmelerin eklendiği bir dizi indeks olarak tanımlanır ve bu, tüm bölme konumlarının , alt listelerin uzunluklarını biriktirerek Xde göründüğünü kontrol eder Y.

Python 2, 68 51 bayt

Bazı önemli bayt tasarrufları için xnor'a teşekkürler!

Formun iki dizesini alan "1,0,9 1,3,8"( edc65'in C yanıtından alınmıştır ) ve Trueveya döndüren anonim işlev False. Yeni sürüm map(None)artık Python 3'te çalışmıyor.

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

Test odası:

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

Önceki 92 baytlık çözüm girişi alır "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