Функции, которые принимают массив в качестве аргумента и генерируют случайные числа

Question

Прежде всего, нельзя использовать любой из встроенных методов . ех. pop(), shift(). Я могу использовать только циклы, массив и т. Д.

Я хотел бы создать функцию, которая принимает массив в качестве аргумента и генерирует случайные строки чисел, которые не содержат этих чисел, указанных в массиве.

Например, func([6, 2]) //=> "20353" (2 и 6 там не будет). Длина массива может измениться ([6, 2, 9], [7, 2, 1, 9]). Таким образом, функция должна иметь возможность размещения любой длины массива.

Для решения этого практического вопроса я использовал петли for и while. Однако я столкнулся с проблемой, заключающейся в том, что, когда проверяется второй индекс (независимо от того, содержат ли числа, сгенерированные случайным образом, 2, или нет, в примере), если он содержит, я регенерирую случайное число, и оно может произвести первое индексное число (в этом дело, 6) которого я не хочу.

Пожалуйста, посмотрите код, который я разместил ниже, и помогите мне решить эту проблему. Кроме того, если есть другой способ получить тот же результат, который является лучшим способом, пожалуйста, дайте мне знать.

let str = "";
let arr = [];
let tem

const func = arg2 => {
  for (let i = 0; i < 5; i++) {
    arr[i] = Math.floor(Math.random() * 10);
  }

  for (let i = 0; i < arr.length; i++) {
    for (let v = 0; v < arg2.length; v++) {
      if (arg2[v] == arr[i]) {
        do {
          tem = Math.floor(Math.random() * 10);
        } while (tem == arr[i])
        arr[i] = tem;
      }
    }
  }

  for (let i = 0; i < arr.length; i++) str += arr[i]
  return str
}

console.log(func([6, 2]))

// the output will not contain 2, which is the last index element
// however, when the second index number is removed, the output might replace it with 6, which is the first index element

Ожидаемый результат:

func([6, 3, 8]) //=> "45102"
func([4, 9]) //=> "55108"

Answer 1

Во-первых, вы уже используете два нативных метода (floor и random), но я предполагаю, что вы в порядке с этим.

Во-вторых, в вашем вопросе термин цифра было бы более подходящим в некоторых случаях, чем число .Есть разница ...

Чтобы избежать выбора недопустимой цифры, вы можете сначала создать массив с разрешенными цифрами, а затем случайным образом выбрать значения из , которые массив.Таким образом, вы никогда не выберете неправильный вариант.

Вот как это будет выглядеть:

const func = arg2 => {
    const digits = [0,1,2,3,4,5,6,7,8,9];
    // Mark digits that are not allowed with -1
    for (let i=0; i<arg2.length; i++) {
        digits[arg2[i]] = -1;
    }
    // Collect digits that are still allowed
    const allowed = [];
    for (let i=0; i<digits.length; i++) {
        if (digits[i] > -1) allowed[allowed.length] = digits[i];
    }
    // Pick random digits from the allowed digits
    let str = "";
    for(let i=0; i<5; i++) {
        str += allowed[Math.floor(Math.random() * allowed.length)];
    }
    return str;
}

console.log(func([6, 2]));

Просто для удовольствия, если вы снимите ограничения на то, какие языковые аспекты использовать нельзя, вы можете сделать это следующим образом:

const func = arg2 => {
    const digits = new Set(Array(10).keys());
    for (let digit of arg2) digits.delete(digit);
    const allowed = [...digits];
    return Array.from({length:5}, () => 
        allowed[Math.floor(Math.random() * allowed.length)]
    ).join``;
}

console.log(func([6, 2]));

Answer 2

Помимо того факта (о чем говорили и другие), что вы сами используете нативные методы для работы с массивами, я бы, вероятно, пошел на это примерно так (используя только то, что вы использовали):

const func = without => {
    let result = '';

    while (result.length < 5) {
        let rand = Math.floor(Math.random() * 10);
        let add = true;

        for (i=0; i<without.length; i++) {
            if (rand === without[i]) {
                add = false;
            }
        }

        if (add) {
            result += rand;
        }
    }

    return result;
}

console.log(func([6, 2]))

более краткая версия с использованием встроенных методов массива может выглядеть следующим образом:

const func = without => {
    let result = '';

    while (result.length < 5) {
        let rand = Math.floor(Math.random() * 10);

        if (!without.includes(rand)) {
            result += rand;
        }
    }

    return result;
}

console.log(func([6, 2]))

Answer 3

Я подозреваю, что вы думаете об этом. Основной алгоритм:

• В цикле:
  • Если вывод имеет 5 цифр, вернуть его.
  • В противном случае
    • Выберите случайную цифру n от 0 до 9.
    • Если n равно , а не в списке исключенных номеров, то оно выводит .

Это довольно точно отображает следующую функцию:

function fn(exclude, length = 5) {
  let output = '';
  while (output.length < length) {
    const n = Math.floor(Math.random() * 10)
    if (!exclude.includes(n)) {
      output += n;
    }
  }
  return output;
}

console.log(fn([6,3,8]));

Конечно, есть и другие способы для достижения этой цели, такие как инициализация массива с пятью элементами и затем join добавление элементов:

function fn(exclude, length = 5) {
  return Array.from({ length }, () => {
    let n;
    while (n = Math.floor(Math.random() * 10), exclude.includes(n)) {}
    return n;
  }).join('');
}

console.log(fn([6,3,8]));

Answer 4

Вам нужно перебирать весь массив arg2 каждый раз, когда вы выбираете случайную цифру. Вы не можете заменить значение в цикле arg2, потому что тогда вы не будете проверять более ранние элементы.

Вам не нужен массив arr, вы можете добавить к str в цикле.

const func = arg2 => {
  let str = "";
  let arr = [];
  for (let i = 0; i < 5; i++) {
    let random;
    while (true) {
      let ok = true;
      random = Math.floor(Math.random() * 10);
      for (let j = 0; j < arg2.length; j++) {
        if (random == arg2[j]) {
          ok = false;
          break;
        }
      }
      if (ok) {
        break;
      }
    }
    str += random
  }

  return str
}

console.log(func([6, 2]))