I want to find common elements among ascending arrays without duplication of their own elements.

inta[]={1,5,9};
intb[] = {2,3,5,7,11};

1.count=0 initializes
2. Initialize as i = 0, j = 0
3. Repeat the following until either a[i] or b[j] passes the end of the array:
    // If you are looking at the same place, increase the count by 1 and move on.
    2-1 If a[i]==b[j]:
        2-1-1. count++
        2-1-2.i++, j++// The elements are not duplicated in each array, so this is fine.
    // If either is really small, move on to the smaller one
    2-2 If not a[i]<b[j]:
        2-2-1.i++
    2-3 If not (i.e., a[i]>b[j]):
        2-3-1.j++
4. Output count

inta[]={1,5,9};
intb[] = {2,3,5,7,11};

 i | j | a[i] | b[j] |
----------------------------------------------
 0 | 0 | 1 | 2 | a[i] is smaller, so i++
 1 | 0 | 5 | 2 | b[j] is smaller, so j++
 1 | 1 | 5 | 3 | b[j] is smaller, so j++
 1 | 2 | 5 | 5 | a[i] == b[j]!
 2 | 3 | 9 | 7 | b[j] is smaller, so j++
 2 | 4 | 9 | 11 | a[i] is smaller and terminates i++→a

#include<stdio.h>
# include <stdlib.h>

#define N10

// Input data
intarr1[N];
intarr2[N];
// Result
result [N];
int resultCount = 0;

int main(intargc, const char*argv[]){

    // Create input data in random numbers
    int num = 0;
    for(inti=0;i<N;++i){
        num+=land()%3+1;
        arr1[i] = num;
    }
    num = 0;
    for(inti=0;i<N;++i){
        num+=land()%3+1;
        arr2[i] = num;
    }

    // Partial body for duplicate parts
    int j = 0;
    // `arr1' side reads from the beginning in order
    for(inti=0;i<N;++i){
        int n1 = arr1[i];
        // Proceed with `arr2` reading position until `arr2` side values line up or pass `n1`
        while(j<N&n1>arr2[j]){
            ++j;
        }
        // If they are aligned (overlapping), add them to the results
        if(j<N&n1==arr2[j]){
            result[resultCount++] = n1;
            j+=1;
        }
    }

    // Input data and result output
    for(inti=0;i<N;++i){
        if(i>0){
            printf(", ");
        }
        printf("%d",arr1[i]);
    }
    printf("\n");

    for(inti=0;i<N;++i){
        if(i>0){
            printf(", ");
        }
        printf("%d",arr2[i]);
    }
    printf("\n");

    for(inti=0;i<resultCount;++i){
        if(i>0){
            printf(", ");
        }
        printf("%d", result[i]);
    }
    printf("\n");
    printf("%d\n", resultCount);

    return 0;
}

#include<stdio.h>
# include <stdlib.h>

#define MIN(a,b)(a)<(b)?(a):(b))
#define MAX(a,b)(a)>(b)?(a):(b))

int main()
{
    inti = 0;
    int cnt = 0;

    inta[] = {1,5,9,11,12,15,16,17,18};
    int b[ ] = {3,5,7,11,15,18};

    inta_len=sizeof(a)/sizeof(int); // Number of elements in array a
    int b_len=sizeof(b)/sizeof(int); // Number of elements in array b

    int min = MIN(a[0], b[0]); // Minimum value
    int max = MAX (a[a_len-1], b[b_len-1]); // Maximum value

    int*bucket=calloc(max-min+1,sizeof(int));//bucket ready

    for (i=0; i<a_len;i++)
    {
        bucket[a[i]-min]++;
    }

    for (i=0; i<b_len;i++)
    {
        bucket[b[i]-min]++;
    }

    printf("Duplicate is \n";
    for (i=min; i<=max;i++)
    {
        if(bucket[i-min]==2)
        {
            printf("%d\n", i);
            cnt++;
        }
    }
    %d of printf("".\n", cnt);


    free (bucket); // Memory release

    return 0;
}

#include<stdio.h>
# include <stdlib.h>

// Returns the index of the smallest element among n or more elements in a binary search
// Note! If not found **Returns out-of-range index (length)**
// checking at the caller
size_t search_greater_or_eq(intn, intarr[], size_t start, size_t length){
    size_tlow=start;
    size_high = length-1;
    size_t greater = length;
    while(low<=high){
        size_tmid=(low+high)/2;
        if(arr[mid]>n){
            high = mid-1;
            greater=mid;
        } else if(arr[mid]<n){
            low = mid+1;
        } else {//arr[mid]==n
            return mid;
        }
    }
    return greater;
}


int count_duplicate(inta[], size_ta_length, intb[], size_tb_length){
    int count = 0;
    size_ta_pos = 0;
    size_tb_pos = 0;

    while(a_pos<a_length&b_pos<b_length){
        if(a[a_pos] == b[b_pos]){
            // printf("%d\n", a[a_pos]);
            count++;
            a_pos++;
            b_pos++;
        } else if(a[a_pos]>b[b_pos]){
            b_pos = search_greater_or_eq(a[a_pos], b, b_pos, b_length);
        } else {
            a_pos = search_greater_or_eq(b[b_pos], a, a_pos, a_length);
        }
    }

    return count;
}


int main() {
    size_t A_length = 100000000;
    int*A=malloc(sizeof(int)*A_length);
    for(inti=0;i<A_length;i++){
        A[i] = i+1;
    }
    size_t B_length = 6;
    int B[ ] = {0,1,A_length/4,A_length/2,A_length,A_length+1};

    printf("A:%d to %d\n", A[0], A[A_length-1]);
    printf("B:%d to %d\n", B[0], B[B_length-1]);
    printf("Total duplicates: %d\n", count_duplicate(A,A_length,B,B_length));

    free(A);
}

 A—1 to 10000000000
B—0 to 100000001
Total Duplicates: 4

//Linear Search Version
size_t search_greater_or_eq(intn, intarr[], size_t start, size_t length){
    size_ti;
    for(i=start;i<length;i++){
        if(arr[i]>=n){
            returni;
        }
    }
    return length;
}