Test for an array being subset of another master array












1












$begingroup$


I was trying to build a small utility function to check if an array is part of other array. It's testing if an array is a subset of another master array.



const masterArray = [1,2,3,4,5,6];
const candidateArray = [2,5,6];

//Test for subset.

//create a set from the two.
const s1 = new Set(masterArray.concat(candidateArray));

//Compare the sizes of the master array and the created set
//If the sizes are same, no new elements are added that means
//the candidate is complete subset.
s1.size === masterArray.length;


Can this be handled in a better way?










share|improve this question











$endgroup$




bumped to the homepage by Community 18 mins ago


This question has answers that may be good or bad; the system has marked it active so that they can be reviewed.











  • 2




    $begingroup$
    Wouldn't that fail if masterArray has duplicate elements?
    $endgroup$
    – Martin R
    Jul 16 '18 at 7:15










  • $begingroup$
    Good point. In my case the master array is always unique.
    $endgroup$
    – Harshal
    Jul 16 '18 at 7:22










  • $begingroup$
    I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
    $endgroup$
    – Harshal
    Jul 16 '18 at 8:46
















1












$begingroup$


I was trying to build a small utility function to check if an array is part of other array. It's testing if an array is a subset of another master array.



const masterArray = [1,2,3,4,5,6];
const candidateArray = [2,5,6];

//Test for subset.

//create a set from the two.
const s1 = new Set(masterArray.concat(candidateArray));

//Compare the sizes of the master array and the created set
//If the sizes are same, no new elements are added that means
//the candidate is complete subset.
s1.size === masterArray.length;


Can this be handled in a better way?










share|improve this question











$endgroup$




bumped to the homepage by Community 18 mins ago


This question has answers that may be good or bad; the system has marked it active so that they can be reviewed.











  • 2




    $begingroup$
    Wouldn't that fail if masterArray has duplicate elements?
    $endgroup$
    – Martin R
    Jul 16 '18 at 7:15










  • $begingroup$
    Good point. In my case the master array is always unique.
    $endgroup$
    – Harshal
    Jul 16 '18 at 7:22










  • $begingroup$
    I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
    $endgroup$
    – Harshal
    Jul 16 '18 at 8:46














1












1








1





$begingroup$


I was trying to build a small utility function to check if an array is part of other array. It's testing if an array is a subset of another master array.



const masterArray = [1,2,3,4,5,6];
const candidateArray = [2,5,6];

//Test for subset.

//create a set from the two.
const s1 = new Set(masterArray.concat(candidateArray));

//Compare the sizes of the master array and the created set
//If the sizes are same, no new elements are added that means
//the candidate is complete subset.
s1.size === masterArray.length;


Can this be handled in a better way?










share|improve this question











$endgroup$




I was trying to build a small utility function to check if an array is part of other array. It's testing if an array is a subset of another master array.



const masterArray = [1,2,3,4,5,6];
const candidateArray = [2,5,6];

//Test for subset.

//create a set from the two.
const s1 = new Set(masterArray.concat(candidateArray));

//Compare the sizes of the master array and the created set
//If the sizes are same, no new elements are added that means
//the candidate is complete subset.
s1.size === masterArray.length;


Can this be handled in a better way?







typescript






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited Dec 25 '18 at 20:42









Jamal

30.3k11116226




30.3k11116226










asked Jul 16 '18 at 6:50









HarshalHarshal

1064




1064





bumped to the homepage by Community 18 mins ago


This question has answers that may be good or bad; the system has marked it active so that they can be reviewed.







bumped to the homepage by Community 18 mins ago


This question has answers that may be good or bad; the system has marked it active so that they can be reviewed.










  • 2




    $begingroup$
    Wouldn't that fail if masterArray has duplicate elements?
    $endgroup$
    – Martin R
    Jul 16 '18 at 7:15










  • $begingroup$
    Good point. In my case the master array is always unique.
    $endgroup$
    – Harshal
    Jul 16 '18 at 7:22










  • $begingroup$
    I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
    $endgroup$
    – Harshal
    Jul 16 '18 at 8:46














  • 2




    $begingroup$
    Wouldn't that fail if masterArray has duplicate elements?
    $endgroup$
    – Martin R
    Jul 16 '18 at 7:15










  • $begingroup$
    Good point. In my case the master array is always unique.
    $endgroup$
    – Harshal
    Jul 16 '18 at 7:22










  • $begingroup$
    I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
    $endgroup$
    – Harshal
    Jul 16 '18 at 8:46








2




2




$begingroup$
Wouldn't that fail if masterArray has duplicate elements?
$endgroup$
– Martin R
Jul 16 '18 at 7:15




$begingroup$
Wouldn't that fail if masterArray has duplicate elements?
$endgroup$
– Martin R
Jul 16 '18 at 7:15












$begingroup$
Good point. In my case the master array is always unique.
$endgroup$
– Harshal
Jul 16 '18 at 7:22




$begingroup$
Good point. In my case the master array is always unique.
$endgroup$
– Harshal
Jul 16 '18 at 7:22












$begingroup$
I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
$endgroup$
– Harshal
Jul 16 '18 at 8:46




$begingroup$
I can enhance it by comparing with a new set created from master array (new Set(masterArray)).size
$endgroup$
– Harshal
Jul 16 '18 at 8:46










1 Answer
1






active

oldest

votes


















0












$begingroup$

So the key here is that I value code that's obvious to others.



Someone else is likely to try to stuff duplicate elements in unless it requires a type refactor; making const masterSet: Set<number> and using that throughout the code is a Good Idea. That "someone else" can often be you two months down the line, too.



In this case I would not say that the point of this length comparison is obvious; it will work but it takes some thinking -- that is why it has bugs with duplicate elements. In this case I would write something which I find more straightforward like,





function isSubsetOf<x>(sub: Iterable<x>, sup: Set<x>): boolean {
for (const x of sub) {
if (!sup.has(x)) {
return false;
}
}
return true;
}


I am also hinting through the type system how this function works by insisting that the subset is any iterable -- so I must be iterating through it.



With a restriction to an array and a set, one can get a little swankier by using the reduce function,



function isSubsetOf<x>(sub: Array<x>, sup: Set<x>): boolean {
return sub.reduce((acc, x) => acc && sup.has(x), true);
}


but probably not all other readers will find that as intuitive as I do, and the former has slightly better runtime characteristics on very large lists that are obviously not subsets.






share|improve this answer









$endgroup$













    Your Answer





    StackExchange.ifUsing("editor", function () {
    return StackExchange.using("mathjaxEditing", function () {
    StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
    StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
    });
    });
    }, "mathjax-editing");

    StackExchange.ifUsing("editor", function () {
    StackExchange.using("externalEditor", function () {
    StackExchange.using("snippets", function () {
    StackExchange.snippets.init();
    });
    });
    }, "code-snippets");

    StackExchange.ready(function() {
    var channelOptions = {
    tags: "".split(" "),
    id: "196"
    };
    initTagRenderer("".split(" "), "".split(" "), channelOptions);

    StackExchange.using("externalEditor", function() {
    // Have to fire editor after snippets, if snippets enabled
    if (StackExchange.settings.snippets.snippetsEnabled) {
    StackExchange.using("snippets", function() {
    createEditor();
    });
    }
    else {
    createEditor();
    }
    });

    function createEditor() {
    StackExchange.prepareEditor({
    heartbeatType: 'answer',
    autoActivateHeartbeat: false,
    convertImagesToLinks: false,
    noModals: true,
    showLowRepImageUploadWarning: true,
    reputationToPostImages: null,
    bindNavPrevention: true,
    postfix: "",
    imageUploader: {
    brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
    contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
    allowUrls: true
    },
    onDemand: true,
    discardSelector: ".discard-answer"
    ,immediatelyShowMarkdownHelp:true
    });


    }
    });














    draft saved

    draft discarded


















    StackExchange.ready(
    function () {
    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f199570%2ftest-for-an-array-being-subset-of-another-master-array%23new-answer', 'question_page');
    }
    );

    Post as a guest















    Required, but never shown

























    1 Answer
    1






    active

    oldest

    votes








    1 Answer
    1






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes









    0












    $begingroup$

    So the key here is that I value code that's obvious to others.



    Someone else is likely to try to stuff duplicate elements in unless it requires a type refactor; making const masterSet: Set<number> and using that throughout the code is a Good Idea. That "someone else" can often be you two months down the line, too.



    In this case I would not say that the point of this length comparison is obvious; it will work but it takes some thinking -- that is why it has bugs with duplicate elements. In this case I would write something which I find more straightforward like,





    function isSubsetOf<x>(sub: Iterable<x>, sup: Set<x>): boolean {
    for (const x of sub) {
    if (!sup.has(x)) {
    return false;
    }
    }
    return true;
    }


    I am also hinting through the type system how this function works by insisting that the subset is any iterable -- so I must be iterating through it.



    With a restriction to an array and a set, one can get a little swankier by using the reduce function,



    function isSubsetOf<x>(sub: Array<x>, sup: Set<x>): boolean {
    return sub.reduce((acc, x) => acc && sup.has(x), true);
    }


    but probably not all other readers will find that as intuitive as I do, and the former has slightly better runtime characteristics on very large lists that are obviously not subsets.






    share|improve this answer









    $endgroup$


















      0












      $begingroup$

      So the key here is that I value code that's obvious to others.



      Someone else is likely to try to stuff duplicate elements in unless it requires a type refactor; making const masterSet: Set<number> and using that throughout the code is a Good Idea. That "someone else" can often be you two months down the line, too.



      In this case I would not say that the point of this length comparison is obvious; it will work but it takes some thinking -- that is why it has bugs with duplicate elements. In this case I would write something which I find more straightforward like,





      function isSubsetOf<x>(sub: Iterable<x>, sup: Set<x>): boolean {
      for (const x of sub) {
      if (!sup.has(x)) {
      return false;
      }
      }
      return true;
      }


      I am also hinting through the type system how this function works by insisting that the subset is any iterable -- so I must be iterating through it.



      With a restriction to an array and a set, one can get a little swankier by using the reduce function,



      function isSubsetOf<x>(sub: Array<x>, sup: Set<x>): boolean {
      return sub.reduce((acc, x) => acc && sup.has(x), true);
      }


      but probably not all other readers will find that as intuitive as I do, and the former has slightly better runtime characteristics on very large lists that are obviously not subsets.






      share|improve this answer









      $endgroup$
















        0












        0








        0





        $begingroup$

        So the key here is that I value code that's obvious to others.



        Someone else is likely to try to stuff duplicate elements in unless it requires a type refactor; making const masterSet: Set<number> and using that throughout the code is a Good Idea. That "someone else" can often be you two months down the line, too.



        In this case I would not say that the point of this length comparison is obvious; it will work but it takes some thinking -- that is why it has bugs with duplicate elements. In this case I would write something which I find more straightforward like,





        function isSubsetOf<x>(sub: Iterable<x>, sup: Set<x>): boolean {
        for (const x of sub) {
        if (!sup.has(x)) {
        return false;
        }
        }
        return true;
        }


        I am also hinting through the type system how this function works by insisting that the subset is any iterable -- so I must be iterating through it.



        With a restriction to an array and a set, one can get a little swankier by using the reduce function,



        function isSubsetOf<x>(sub: Array<x>, sup: Set<x>): boolean {
        return sub.reduce((acc, x) => acc && sup.has(x), true);
        }


        but probably not all other readers will find that as intuitive as I do, and the former has slightly better runtime characteristics on very large lists that are obviously not subsets.






        share|improve this answer









        $endgroup$



        So the key here is that I value code that's obvious to others.



        Someone else is likely to try to stuff duplicate elements in unless it requires a type refactor; making const masterSet: Set<number> and using that throughout the code is a Good Idea. That "someone else" can often be you two months down the line, too.



        In this case I would not say that the point of this length comparison is obvious; it will work but it takes some thinking -- that is why it has bugs with duplicate elements. In this case I would write something which I find more straightforward like,





        function isSubsetOf<x>(sub: Iterable<x>, sup: Set<x>): boolean {
        for (const x of sub) {
        if (!sup.has(x)) {
        return false;
        }
        }
        return true;
        }


        I am also hinting through the type system how this function works by insisting that the subset is any iterable -- so I must be iterating through it.



        With a restriction to an array and a set, one can get a little swankier by using the reduce function,



        function isSubsetOf<x>(sub: Array<x>, sup: Set<x>): boolean {
        return sub.reduce((acc, x) => acc && sup.has(x), true);
        }


        but probably not all other readers will find that as intuitive as I do, and the former has slightly better runtime characteristics on very large lists that are obviously not subsets.







        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered Dec 26 '18 at 3:44









        CR DrostCR Drost

        22113




        22113






























            draft saved

            draft discarded




















































            Thanks for contributing an answer to Code Review Stack Exchange!


            • Please be sure to answer the question. Provide details and share your research!

            But avoid



            • Asking for help, clarification, or responding to other answers.

            • Making statements based on opinion; back them up with references or personal experience.


            Use MathJax to format equations. MathJax reference.


            To learn more, see our tips on writing great answers.




            draft saved


            draft discarded














            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f199570%2ftest-for-an-array-being-subset-of-another-master-array%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown





















































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown

































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown







            Popular posts from this blog

            How to make a Squid Proxy server?

            Is this a new Fibonacci Identity?

            19世紀