Pregunta Compruebe si una matriz es un subconjunto de otra matriz


Digamos que tengo dos matrices,

var PlayerOne = ['B', 'C', 'A', 'D'];
var PlayerTwo = ['D', 'C'];

¿Cuál es la mejor forma de comprobar si arrayTwo es un subconjunto de arrayOne con javascript?

La razón: estaba tratando de resolver la lógica básica para un juego Tic tac toe, y me quedé atrapado en el medio. Aquí está mi código de todos modos ... ¡Muchísimas gracias!

var TicTacToe = {


  PlayerOne: ['D','A', 'B', 'C'],
  PlayerTwo: [],

  WinOptions: {
      WinOne: ['A', 'B', 'C'],
      WinTwo: ['A', 'D', 'G'],
      WinThree: ['G', 'H', 'I'],
      WinFour: ['C', 'F', 'I'],
      WinFive: ['B', 'E', 'H'],
      WinSix: ['D', 'E', 'F'],
      WinSeven: ['A', 'E', 'I'],
      WinEight: ['C', 'E', 'G']
  },

  WinTicTacToe: function(){

    var WinOptions = this.WinOptions;
    var PlayerOne = this.PlayerOne;
    var PlayerTwo = this.PlayerTwo;
    var Win = [];

    for (var key in WinOptions) {
      var EachWinOptions = WinOptions[key];

        for (var i = 0; i < EachWinOptions.length; i++) {
          if (PlayerOne.includes(EachWinOptions[i])) {
            (got stuck here...)
          }

        }
        // if (PlayerOne.length < WinOptions[key]) {
        //   return false;
        // }
        // if (PlayerTwo.length < WinOptions[key]) {
        //   return false;
        // }
        // 
        // if (PlayerOne === WinOptions[key].sort().join()) {
        //   console.log("PlayerOne has Won!");
        // }
        // if (PlayerTwo === WinOptions[key].sort().join()) {
        //   console.log("PlayerTwo has Won!");
        // } (tried this method but it turned out to be the wrong logic.)
    }
  },


};
TicTacToe.WinTicTacToe();

9
2017-08-07 06:08


origen


Respuestas:


La solución correcta es esta:

En ES6 sintaxis:

PlayerTwo.every(val => PlayerOne.includes(val))

o en ES5 sintaxis:

PlayerTwo.every(function(val) { return PlayerOne.indexOf(val) >= 0; });

19
2018-01-11 16:01



Si está utilizando ES6:

!PlayerTwo.some(val => PlayerOne.indexOf(val) === -1);

Si tiene que usar ES5, use un relleno para el some funcionar el Documentación de Mozilla, luego usa la sintaxis de la función regular:

!PlayerTwo.some(function(val) { return PlayerOne.indexOf(val) === -1 });

13
2017-08-07 07:44



Puedes usar esta simple pieza de código.

PlayerOne.every(function(val) { return PlayerTwo.indexOf(val) >= 0; })

6
2018-05-30 09:08



Si PlayerTwo es un subconjunto de PlayerOne, la duración del conjunto (PlayerOne + PlayerTwo) debe ser igual a la duración del set (PlayerOne).

var PlayerOne = ['B', 'C', 'A', 'D'];
var PlayerTwo = ['D', 'C'];

// Length of set(PlayerOne + PlayerTwo) == Length of set(PlayerTwo)

Array.from(new Set(PlayerOne) ).length == Array.from(new Set(PlayerOne.concat(PlayerTwo)) ).length

0
2017-12-12 05:11



Esto me parece más claro:

function isSubsetOf(set, subset) {
    for (let i = 0; i < set.length; i++) {
        if (subset.indexOf(set[i]) == -1) {
            return false;
        }
    }
    return true;
}

También tiene la ventaja de irrumpir tan pronto como se encuentre un no miembro.


0
2018-01-12 05:54



Aquí hay una solución que explota el tipo de datos establecido y su has función.

let PlayerOne = ['B', 'C', 'A', 'D', ],
    PlayerTwo = ['D', 'C', ],
    [one, two] = [PlayerOne, PlayerTwo, ]
        .map( e => new Set(e) ),
    matches = Array.from(two)
        .filter( e => one.has(e) ),
    isOrisNot = matches.length ? '' : ' not',
    message = `${PlayerTwo} is${isOrisNot} a subset of ${PlayerOne}`;
console.log(message)

Out: D,C is a subset of B,C,A,D

0
2018-06-09 19:17