Considérez un tableau d'entiers:

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

Il existe de nombreuses façons de partitionner cette liste en sous-listes consécutives. En voici trois:

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

Nous appellerons une partition Y et affinerons une autre partition X si X peut être obtenu à partir de Y en réunissant certaines de ses sous-listes.

Il en Best de même pour le raffinement A: si nous joignons les deux premières et les deux dernières sous-listes, nous obtenons A. Mais ce Cn'est pas un raffinement de A: il faudrait diviser le 9et le 1pour s'en remettre A. De plus, toute partition est trivialement un raffinement d'elle-même.

Notez que nous ne sommes pas autorisés à réorganiser les sous-listes ou les éléments à tout moment.

Le défi

Étant donné deux partitions (listes de listes d'entiers) Xet Y, déterminer s'il Ys'agit d'un raffinement de X.

Vous pouvez supposer que les partitions ne contiendront que des entiers de 0à 9, inclus. Vous ne devez pas supposer cela Xet ce Ysont des partitions de la même liste (si elles ne le sont pas, elles ne sont pas non plus des raffinements les unes des autres). Xet / ou Ypeut être vide mais ne contiendra jamais de sous-listes vides.

Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction et en sortant le résultat via STDOUT (ou l'alternative la plus proche), la valeur de retour de la fonction ou le paramètre de la fonction (out).

L'entrée peut être prise dans n'importe quel format de chaîne ou de liste. Étant donné que les éléments ne seront que des entiers à un chiffre, vous pouvez choisir d'omettre un délimiteur dans les sous-listes, mais assurez-vous que les 0s de tête sont possibles. Vous pouvez choisir de prendre Xet Ydans l'ordre inverse.

La sortie doit être vraie si Yc'est un raffinement Xet fausse sinon.

Votre code doit être capable de résoudre chacun des cas de test ci-dessous en 1 seconde sur une machine de bureau raisonnable. (Il s'agit simplement d'une vérification d'esprit pour éviter de simples solutions de force brute.)

Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte.

Cas de test

Chaque cas de test est sur sa propre ligne, écrit comme X Y. J'utilise la notation de tableau de style GolfScript / CJam pour économiser de l'espace horizontal:

Vérité:

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

Faux:

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

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

Défis liés

• Calculer la jointure et la rencontre des partitions

CJam, 13 10 9 octets

lr.-F-U-!

Essayez-le en ligne dans l' interpréteur CJam .

Merci à @ MartinBüttner d'avoir suggéré le format d'entrée ingénieux de @ edc65 .

Merci à @ jimmy23013 pour l'amélioration du format d'entrée et le démarrage de 3 octets supplémentaires.

E / S

Contribution

Les sous-listes sont séparées les ;unes des autres par ,:

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

Production

1

Comment ça fonctionne

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.

Pour les chaînes de longueur différente, .-laissera des caractères dans le tableau, qui ne peuvent pas être égaux aux entiers 0 ou 15.

Pyth, 19 octets

&gF_m{.u+NYdYQqFsMQ

Essayez-le en ligne: démonstration ou test de harnais

J'utilise le format de liste / tuple de Pyth comme entrée. Remplacez simplement les espaces des cas de test par des virgules.

Explication:

                     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

Étant donné que le pseudo-code est toujours un peu déroutant, je vais démontrer l'algorithme en utilisant un exemple d'entrée.

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

La .u+NYdYpièce calcule toutes les sous-listes continues, qui contiennent le premier élément.

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

Best un raffinement de A, si chaque sous-liste continue de Aest également une sous-liste continue deB (il n'y a qu'une seule exception).

Je vérifie donc simplement si l'ensemble des sous-listes continues de Aest un sous-ensemble de l'ensemble des sous-listes continues de B(gF_m.u+NYdYQ ).

La seule exception est, si la première liste d'entrée contient moins d'éléments que la deuxième liste d'entrée. Par exemple <Fm.u+YdYQ, reviendrait Truepour l'entrée[[1]],[[1],[2]] .

Par conséquent, je vérifie également si les listes jointes sont également égales &...qFsMQ.

JavaScript ( ES6 ), 67 70

Modifier 3 octets enregistrés thx @apsillers

Exécutez l'extrait ci-dessous dans Firefox pour tester

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

Une fonction avec 2 paramètres de chaîne, retournant 0 ou 1.

Format des paramètres: sous-liste séparée par des espaces (''), liste des éléments séparés par des virgules.

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

Moins 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 (obsolète)

Haskell, 76 octets

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

Renvoie Trueou False. Exemple d'utilisation: [[1,0,9],[1,3,8]] # [[1,0],[9]]->False .

Approche récursive simple: si les premiers éléments correspondent, continuez avec les queues, sinon recommencez mais concaténez les deux éléments en tête de la deuxième liste. Les cas de base sont: les deux listes vides -> True; les deux listes avec un seul élément -> les comparer; une seule liste vide -> False.

CJam, 19 octets

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

Essayez-le en ligne.

E / S

Contribution

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

Production

1

Idée

Chaque partition peut être identifiée de manière unique en observant les deux propriétés suivantes:

• La liste s'est formée en concaténant toutes les sous-listes.

• Les "points de coupure", y compris les extrêmes de la liste.

Nous pouvons combiner les deux critères en un seul en remplaçant chaque point de coupe par la sous-liste des éléments du point de coupe à la fin de la liste.

Pour vérifier qu'une partition donnée est plus fine qu'une autre, il suffit de vérifier si la partition la plus grossière, représentée comme ci-dessus, est un sous-ensemble de la plus fine et que les plus grandes listes des deux partitions correspondent.

Code

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.

Pour la forme d'entrée de l'exemple d'E / S, la pile contient

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

avant d'exécuter -! .

Notez que le premier élément de chaque tableau a un espace de fin. Cela garantit que nous comparons la liste complète de la première entrée avec la liste complète de la seconde.

CJam, 24 octets

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

Algorithme

Ici, nous utilisons simplement un algorithme gourmand pour voir si les premières Nsous-listes de la deuxième liste peuvent être fusionnées pour former la première sous-liste de la première liste. Une fois Ntrouvé, nous supprimons le premierN sous-listes de la deuxième liste et la première sous-liste de la première liste et répétons le processus.

Idéalement, si la deuxième liste était un raffinement de la première, nous devrions nous retrouver avec 2 listes vides sur la pile. Nous vérifions simplement cela et imprimons 1si tel est le cas. Dans toute autre combinaison, après avoir entièrement itéré les sous-listes de la deuxième liste, nous ne nous retrouverons pas avec 2 listes vides. Ainsi, un 0sera imprimé pour de tels cas.

Expansion du code

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

Essayez-le en ligne ici ou exécutez la suite de tests complète ici

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

Je n'ai pas beaucoup joué au golf récemment, alors j'ai pensé essayer celui-ci.

Nous définissons une fonction R(char* s, char* t)qui retourne 1si test une partition raffinée de s, et 0sinon. set tdevraient être dans le format [DDDD...][DDDD...]...où chaqueD est un autre élément à un chiffre.

Code de test:

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

Ce qui précède imprime les éléments suivants:

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

Cela semble fonctionner, au moins.

Haskell, 52 50 53 octets

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

Complètement différent de mon autre solution . Utilise le même format d'entrée intelligent que la réponse de @ edc65 , c'est-à-dire que les éléments sont séparés par ,et les listes avec .

Exemple d'utilisation: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True.

Le second paramètre est un raffinement du premier, s'ils ont des éléments égaux à chaque position ou si le premier l'est ,. Je dois ajouter un jeton de fin unique (-> ..) aux deux paramètres, car zipWithtronque le paramètre le plus long et, par exemple, le "1,2,3" # "1,2"serait également True.

Mathematica, 65 octets

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

Les mathématiques avec des expressions régulières sont amusantes!

ES6 Javascript, 53 caractères

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

Javascript vintage, 70 caractères

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

Utilise le même format d'entrée que la réponse d'edc65 .

Démo complète comprenant tous les cas de test ici.

Mathematica, 55 octets

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

Cela définit une fonction sans nom, prenant les deux partitions dans une seule liste , dans l'ordre inverse (c'est-à-dire Ypremière, Xseconde).

Explication

Equal@@Join@@@#

Cela vérifie que les deux partitions sont bien des partitions de la même liste.

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

C'est une forme golfique de mon approche dans cette question sur Mathematica.SE , qui a inspiré ce défi. Fondamentalement, une partition est définie comme un certain nombre d'indices dans lesquels des séparations sont insérées, ce qui vérifie que toutes les positions de fractionnement dansX apparaissent également dansY accumulant les longueurs des sous-listes.

Python 2, 68 51 octets

Merci à xnor pour des économies d'octets considérables!

Fonction anonyme qui prend deux chaînes de la forme "1,0,9 1,3,8"(tirée de la réponse C d' edc65 ) et retourne Trueou False. Nouvelle version avec map(None)ne fonctionne plus dans Python 3.

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

Suite de tests:

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

Solution précédente de 92 octets qui prend en entrée "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