You are given an array A consisting of N integers.
For each number A[i] such that 0 ≤ i < N, we want to count the number of elements of the array that are not the divisors of A[i]. We say that these elements are non-divisors.
For example, consider integer N = 5 and array A such that:
A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 3 A[4] = 6For the following elements:
- A[0] = 3, the non-divisors are: 2, 6,
- A[1] = 1, the non-divisors are: 3, 2, 3, 6,
- A[2] = 2, the non-divisors are: 3, 3, 6,
- A[3] = 3, the non-divisors are: 2, 6,
- A[4] = 6, there aren't any non-divisors.
Assume that the following declarations are given:
struct Results { int * C; int L; // Length of the array };
Write a function:
struct Results solution(int A[], int N);
that, given an array A consisting of N integers, returns a sequence of integers representing the amount of non-divisors.
Result array should be returned as a structure Results.
For example, given:
A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 3 A[4] = 6the function should return [2, 4, 3, 2, 0], as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..50,000];
- each element of array A is an integer within the range [1..2 * N].
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
}
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
free(counts);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
}
for (i = 0; i < N; ++i) {
counts[A[i]] =
}
free(counts);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
free(counts);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
free(counts);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
free(counts);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
free(counts);
fre
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
// write your code in C99 (gcc 6.2.0)
result.C = ...
result.L = ...
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if ()
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
in
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
int j;
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i,
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
int j;
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
if ()
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
if (A[i])
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
for (j = 1; j <)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
for (j = 1; j)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
for (j = 1; j)
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0)
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0) {
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0) {
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[]
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if ()
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i])
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxN; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
free(counts);
free(cache);
return result;
}
func.c: In function 'solution': func.c:19:21: error: 'maxN' undeclared (first use in this function) for (i = 0; i < maxN; ++i) { ^~~~ func.c:19:21: note: each undeclared identifier is reported only once for each function it appears in func.c:6:25: warning: unused variable 'divA' [-Wunused-variable] int maxA = 0, i, j, divA, sqrtA; ^~~~
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, divA, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
free(counts);
free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
free(counts);
free(cache);
return result;
}
[MONITOR] syscall open was blocked! *** Error in `./exec.e.binary': munmap_chunk(): invalid pointer: 0x00000000023b2050 *** ======= Backtrace: ========= /lib/x86_64-linux-gnu/libc.so.6(+0x77725)[0x2b9b74a4f725] /lib/x86_64-linux-gnu/libc.so.6(cfree+0x1a8)[0x2b9b74a5bc18] ./exec.e.binary[0x40105e] ./exec.e.binary[0x4009fe] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x2b9b749f8830] ./exec.e.binary[0x400a89] ======= Memory map: ========
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (counts[j] > 0 && A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < maxA; ++i)
printf("%d ", counts[i]);
printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
0 1 1 2 0 0
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
counts = (int *) malloc((maxA)*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < maxA; ++i)
printf("%d ", counts[i]);
printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc((maxA)*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < maxA; ++i)
printf("%d ", counts[i]);
printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
0 1 1 2 0 0 1
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < maxA; ++i)
printf("%d ", counts[i]);
printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
result.C[i] = 0;
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
// if (cache[A[i]] >= 0) {
// result.C[i] = cache[A[i]];
// continue;
// }
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
// if (cache[A[i]] >= 0) {
// result.C[i] = cache[A[i]];
// continue;
// }
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j < sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j <= sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
// for (i = 0; i < maxA; ++i)
// printf("%d ", counts[i]);
// printf("\n");
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j <= sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j <= sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j <= sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
// you can write to stdout for debugging purposes, e.g.
// printf("this is a debug message\n");
#include <math.h>
struct Results solution(int A[], int N) {
int maxA = 0, i, j, sqrtA;
int *counts, *cache;
struct Results result;
result.C = (int *) malloc(N*sizeof(int));
result.L = N;
for (i = 0; i < N; ++i) {
if (A[i] > maxA)
maxA = A[i];
}
++maxA;
counts = (int *) malloc(maxA*sizeof(int));
cache = (int *) malloc(maxA*sizeof(int));
for (i = 0; i < maxA; ++i) {
counts[i] = 0;
cache[i] = -1;
}
for (i = 0; i < N; ++i) {
counts[A[i]] += 1;
}
for (i = 0; i < N; ++i) {
if (cache[A[i]] >= 0) {
result.C[i] = cache[A[i]];
continue;
}
cache[A[i]] = N;
sqrtA = (int) sqrt(A[i]);
for (j = 1; j <= sqrtA; ++j) {
if (A[i]%j == 0) {
cache[A[i]] -= counts[j];
if (j*j != A[i]) {
cache[A[i]] -= counts[A[i]/j];
}
}
}
result.C[i] = cache[A[i]];
}
// free(counts);
// free(cache);
return result;
}
The solution obtained perfect score.