Rsa97

Просмотрев все значения. Ваш К.О.

Для начала научитесь выражать всё словами.
Что такое "эквивалентность"? Это значит, что оба операнда (A и B) равны, то есть либо оба они равны единице, либо оба равны нулю.
Оба операнда равны единице: A∧B
Оба операнда равны нулю: ¬A∧¬B
Общее выражение: A∧B ∨ ¬A∧¬B
Избавляемся от дизъюнкции: ¬(¬(A∧B) ∧ ¬(¬A∧¬B))
Остаётся составить таблицу истинности и проверить

A | B | ¬(¬(A∧B) ∧ ¬(¬A∧¬B))
0 | 0 |           1
0 | 1 |           0
1 | 0 |           0
1 | 1 |           1

Во втором случае утверждение будет "из A следует B и из B следует A".
(A→B) ∧ (B→A)
Остаётся избавиться от конъюнкции
¬((A→B) → ¬(B→A))

Фантастический способ:
Изучить O-нотацию.
Изучить различные алгоритмы с их оценкой сложности в O-нотации.
Подобрать необходимые алгоритмы и провести их композицию в свой алгоритм, решающий задачу.

Реальный способ:
Бегать по всем форумам с просьбой помочь, авось кто и откликнется.

P.S. Задача, кстати, примитивная, в два действия, первое O(n log n), второе O(n).

А в чём проблема то?

$nullPercents = [10, 20, 50];
$totalRows = 11;
$result = [];
for ($i = 1; $i <= $totalRows; $i++) {
  $row = [];
  foreach ($nullPercents as $percent) {
    if ($i <= $totalRows*$percent/100) {
      $row[] = null;
    } else {
      $row[] = $i;
    }
  }
  $result[] = $row;
}

Несколько обобщив задачу получаем следующее:
- на входе есть список имеющихся подсетей (возможно из одного элемента) и список размеров подсетей, которые надо выделить;
- на выходе надо получить выделенные подсети и список оставшихся нераспределёнными подсетей.
1. Находим маску необходимой подсети mask := 32 - ⌈log₂(size + 2)⌉. 2. Ищем в списке свободных подсеть subNet с максимальной маской меньшей либо равной mask.
3. Если не нашли, то выделить подсеть невозможно, возвращаем ошибку.
4. Пока маска subNet меньше mask, удаляем subNet из списка свободных, разбиваем её на две подсети, добавляем полученные подсети в список свободных, в качестве subNet берём одну из них.
5. Если маска subNet равна mask, то выделяем подсеть, удаляем её из списка свободных, возвращаем результат.

Пример:

Вход: список подсетей = [192.168.0.0/24], размер = 30
mask = 32-ceil(log2(32)) = 27
после поиска subNet = 192.168.0.0/24
24 < 27 => список подсетей = [192.168.0.0/25, 192.168.0.128/25], subNet = 192.168.0.0/25
25 < 27 => список подсетей = [192.168.0.0/26, 192.168.0.64/26, 192.168.0.128/25], subNet = 192.168.0.0/26
26 < 27 => список подсетей = [192.168.0.0/27, 192.168.0.32/27, 192.168.0.64/26, 192.168.0.128/25], subNet = 192.168.0.0/27
27 == 27 => список подсетей = [192.168.0.32/27, 192.168.0.64/26, 192.168.0.128/25], выделенная подсеть = 192.168.0.0/27

Если у вас только два знака и ставиться они могут только между числами, то просто генерируете все числа от 0 до 2^N-1 и принимаете, например, бит 0 за минус, а бит 1 за плюс.

{
  "parameters": {
    "speed": ...,
    "visionArea": ...,
    ...
  },
  "events": {
    "getSight": [
      {
        "objects": ["fox", "wolf"],
        "actions": [
          {
            "probability": 0.5,
            "action": "run"
          }, {
            "probability": 0.5,
            "action": "wait"
          }
        ]
      }, {
        "objects": ["carrot"],
        "actions": [
          {
            "probability": 1,
            "action": "eat"
          }
        ]
      }
    },
    "hungry": [ ... ],
    "thirsty": [ ... ].
    ...
  }
}

Вообще, в таком виде задача может не иметь однозначного решения.
Первый же пример X=8, Y=1 даёт два решения - (3,4) и (4,3).

Эвристическая оптимизация - по столбикам с положительными значениями надо прыгать подряд, как только впереди отрицательные значения - надо искать способ попасть на следующее положительное с минимальными потерями.
Таким образом задача разбивается на эквивалентные подзадачи меньшего объёма.
Решается поиском оптимального пути в ориентированном графе.

Что я делаю не так?

Не занимаетесь отладкой своей программы. Если не умеете пользоваться отладчиком, то возьмите лист бумаги, карандаш, и пошагово пройдите всю свою программу.

Для общего случая - отсортировать массив и одним проходом посчитать количество и занести в новый массив.
Для частных случаев может быть и более оптимальное решение.

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

function rand80() {
  let result = ''+Math.floor(Math.random()*10000000000);
  for (let i = 0; i < 7; i++) {
    result += ('0000000000'+Math.floor(Math.random()*10000000000)).substr(-10);
  }
  return result;
}
console.log(rand80());

78687700753019149846288536942965286843811762227419373094448469993291737449820343