Notes

Lisp Count Non Divisible

(defun count-non-divisible (a)
  (let* ((vec (coerce a 'vector))
         (size (length vec))
         (occurrences (make-array (1+ (reduce #'max vec)) :initial-element 0)))
    (loop for v across vec do (incf (aref occurrences v)))
    (loop for v across vec
          collect (let ((count 0) (i 1))
                    (loop while (<= (* i i) v)
                          do (progn
                               (when (zerop (mod v i))
                                 (incf count (aref occurrences i))
                                 (unless (= (/ v i) i)
                                   (incf count (aref occurrences (/ v i)))))
                               (incf i)))
                    (- size count)))))

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

PHP Count Non Divisible

function countNonDivisible(array $a): array
{
    $size       = count($a);
    $nondivisor = array_fill(0, $size, 0);
    $occurences = array_fill(0, max($a) + 1, 0);

    foreach ($a as $v) {
        $occurences[$v]++;
    }

    foreach ($a as $k => $v) {
        $count = 0;
        $i     = 1;
        while ($i * $i <= $v) {
            if ($v % $i === 0) {
                $count += $occurences[$i];
                if ($v / $i !== $i) {
                    $count += $occurences[$v / $i];
                }
            }
            $i++;
        }
        $nondivisor[$k] = $size - $count;
    }

    return $nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Python Count Non Divisible

def count_non_divisible(a: list[int]) -> list[int]:
    size = len(a)
    occurrences = [0] * (max(a) + 1)
    for v in a:
        occurrences[v] += 1

    nondivisor = [0] * size
    for k, v in enumerate(a):
        count = 0
        i = 1
        while i * i <= v:
            if v % i == 0:
                count += occurrences[i]
                if v // i != i:
                    count += occurrences[v // i]
            i += 1
        nondivisor[k] = size - count

    return nondivisor

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Rust Count Non Divisible

fn count_non_divisible(a: &[i64]) -> Vec<i64> {
    let size = a.len();
    let max_val = *a.iter().max().unwrap() as usize;
    let mut occurrences = vec![0i64; max_val + 1];

    for &v in a {
        occurrences[v as usize] += 1;
    }

    let mut nondivisor = vec![0i64; size];
    for (k, &v) in a.iter().enumerate() {
        let mut count = 0;
        let mut i = 1i64;
        while i * i <= v {
            if v % i == 0 {
                count += occurrences[i as usize];
                if v / i != i {
                    count += occurrences[(v / i) as usize];
                }
            }
            i += 1;
        }
        nondivisor[k] = size as i64 - count;
    }

    nondivisor
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

TypeScript Count Non Divisible

function countNonDivisible(a: number[]): number[] {
  const size = a.length;
  const nondivisor: number[] = new Array(size).fill(0);
  const occurences: number[] = new Array(Math.max(...a) + 1).fill(0);

  for (const v of a) {
    occurences[v]++;
  }

  for (let k = 0; k < size; k++) {
    const v = a[k];
    let count = 0;
    let i = 1;
    while (i * i <= v) {
      if (v % i === 0) {
        count += occurences[i];
        if (v / i !== i) {
          count += occurences[v / i];
        }
      }
      i++;
    }
    nondivisor[k] = size - count;
  }

  return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.