A continuación, trato de dar matrices de cadenas a una función que agrega palabras únicas a una matriz de palabras, y si la palabra ya está en la matriz para aumentar el recuento del elemento correspondiente en la matriz de conteo:

var words = [];
var counts = [];

calculate([a, b]);
calculate([a, c]);

function calculate(result) {
    for (var i = 0; i < result.length; i++) {
        var check = 0;
        for (var j = 0; i < tags.length; i++) {
            if (result[i] == tags[j]) {
                check = 1;
                counts[i] = counts[i] + 20;
            }
        }
        if (check == 0) {
            tags.push(result[i]);
            counts.push(20);
        }
        check = 0;
    }
}

Sin embargo, la salida resulta así:

Palabras = a, b cuenta = 2, 1

Cuando espero que sea: palabras = a, b, c cuenta = 2,1,1

Gracias por cualquier ayuda de antemano

3
Grace O'Brien 1 sep. 2014 a las 13:06

4 respuestas

La mejor respuesta

Por favor, chequee esto : puede probarlo en: http://jsfiddle.net/knqz6ftw/

var words = [];
var counts = [];

calculate(['a', 'b']);
calculate(['a', 'c']);
calculate(['a', 'b', 'c']);

function calculate(inputs) {
    for (var i = 0; i < inputs.length; i++) {
    var isExist = false;
    for (var j = 0; j < words.length; j++) {
        if (inputs[i] == words[j]) {
            isExist = true
            counts[i] = counts[i] + 1;
        }
    }
    if (!isExist) {
        words.push(inputs[i]);
        counts.push(1);
    }
    isExist = false;
}
}

console.log(words);
console.log(counts);

Salida es:

["a", "b", "c"] (index):46
[3, 2, 2] 
1
krishna Prasad 1 sep. 2014 a las 09:24

Algunas cosas estaban mal, aquí está el código de trabajo:

var words = [];
var counts = [];

calculate(["a", "b"]);
calculate(["a", "c"]);

function calculate(result) {
    for (var i = 0; i < result.length; i++) {
        var check = 0;
        for (var j = 0; j < words.length; j++) {
            if (result[i] == words[j]) {
                check = 1;
                ++counts[j];
            }
        }
        if (check == 0) {
            words.push(result[i]);
            counts.push(1);
        }
        check = 0;
    }
}

Jsbin: http://jsbin.com/hawaco/2/edit?js,console

Cosas que he cambiado:

  • Se cambió el literal de la matriz para proporcionar cadenas en lugar de nombres de variables: [a,b] a ["a","b"]
  • Instancias reemplazadas de tags (presumiblemente un nombre antiguo) con words
  • Cambió los años 20 a 1
  • Se hizo más claro el incremento de counts[j]
  • Uso fijo de los índices i / j

Cosas para considerar:

  • Quizás haga de este un diccionario en lugar de un par de matrices: {"a":1, "b":2}, lo que haría que el código sea más simple
  • Pase los nombres de las matrices para permitir otros acumuladores, o combine el método y las matrices en un solo objeto

Simplificada:

var seen = {};

count(["a", "b"], seen);
count(["a", "c"], seen);

function count(words, accumulator) {
    for (var i = 0; i < words.length; ++i) {
        if(!accumulator.hasOwnProperty(words[i])) {
          accumulator[words[i]] = 1;
        } else {
          ++accumulator[words[i]];
        }
    }
}

Resultado:

>> seen
[object Object] {
  a: 2,
  b: 1,
  c: 1
}

JSBin: http://jsbin.com/halak/1/edit?js,console

1
Phil H 1 sep. 2014 a las 09:27

Aquí está mi solución (usando un objeto):

  const checkWord = (str) => {
    let collection = {};
    // split the string into an array
    let words = str.split(' ');
    words.forEach((word) => {
     collection[word] = word;
   });
   // loop again to check against the array and assign a count
   for (let j = 0; j < words.length; j++) {
     if (words[j] === collection[words[j]]) {
       collection[words[j]] = 0;
     }
     collection[words[j]]++
   }
   console.log(collection);
 };

También puedes usar reduce:

  const checkWord = (str) => {
  let collection = {};
  let words = str.split(' ');
  words.forEach((word) => {
     collection[word] = word;
   });
  for (var i = 0; i < words.length; i++) {
    if (words[i] === collection[words[i]]) {
      collection[words[i]] = 0;
    }
  }
  let total = words.reduce((occurrences, word) => {
    collection[word]++
    return collection;
}, 0);
    console.log(total);
  };
1
Ryan Casalino 20 may. 2017 a las 21:11

Desglosar el problema en métodos con buenos nombres te ayuda a resolver tu lógica.

Prueba esto:

<script type="text/javascript">
var words = [];
var counts = [];
calculate(["a", "b"]);
calculate(["a", "c"]);
console.log(words);
console.log(counts);

function calculate(result) {
    for (var i=0; i<result.length; i++) {
        if (array_contains(words, result[i])) {
            counts[result[i]]++;
        } else {
            words.push(result[i]);
            counts[result[i]] = 1;
        }
    }
}

function array_contains(array, value) {
    for (var i=0; i<array.length; i++)
        if (array[i] == value)
            return true;
    return false;
}

</script>

Salida:

["a", "b", "c"]
[]
un 2
b 1
c 1

2
Ozzy 1 sep. 2014 a las 09:17