python solution

def solve(V): n = len(V) # instead of turning, the ants can be seen to pass each other # so they simply go around and around. # in each direction go about half of them, # meeting the other half 2 times a round, 2x hello in a meeting # 1 round is 10_000 sec, 10**9 sec is 10**5 rounds meets = (n//2) * (n-n//2) * 2 * 2 * 10**5 # now what about the last 6 sec? => must maximize meetings here # 6 sec is 0.6 m per ant, that is ants can only meet if adjacent V.sort() for pos in range(n): if (V[pos]-V[pos-1])%1000 > 1: break run = 0 for i in range(pos, pos+n): if (V[i%n]-V[(i-1)%n])%1000 == 1: run += 1 else: meets += (run+1)//2 * 2 run = 0 else: if run: meets += (run+1)//2 * 2 return meets

Most solutions (and even the editorial) are not fully correct, because they ignore this case:
If there are ants on positions 999 and 0 (distance 1 over ends of intervall) the algorithms may give wrong results, e.g : the algos find one pair (0,1), not two pairs (1,2), (999,0) .
(see also post of ygrinev below).

Clumsy but correct solution:

def solve(V):
    n = len(V)
    # instead of turning, the ants can be seen to pass each other
    # so they simply go around and around. 
    # in each direction go about half of them,
    #   meeting the other half 2 times a round, 2x hello in a meeting
    # 1 round is 10_000 sec, 10**9 sec is 10**5 rounds
    meets = (n//2) * (n-n//2) * 2 * 2 * 10**5
    # now what about the last 6 sec? => must maximize meetings here
    # 6 sec is 0.6 m per ant, that is ants can only meet if adjacent
    V.sort()
    for pos in range(n): 
        if (V[pos]-V[pos-1])%1000 > 1: break
    run = 0
    for i in range(pos, pos+n):
        if (V[i%n]-V[(i-1)%n])%1000 == 1:
            run += 1
        else:
            meets += (run+1)//2 * 2
            run = 0
    else:
        if run: meets += (run+1)//2 * 2
    return meets

public static int solve(List V) { int n=V.size(),c=0; int x = 2*n/2*(n-n/2)*100000; Collections.sort(V);

for(int i=0;i<n-1;i++)
{
    if(V.get(i+1)-V.get(i) == 1)
    {
        c++;
        i++;
    }
}
if(V.get(n-1) - V.get(0) == 1)
    c++;
x+=c;
return x*2; 

}

}

Not clear: if V[n-1] is 999 and V[0] is 0 would the following be wrong:

if(V[n-1]-V[0]==1) c++;

Simple case {0, 999}, the answer should be 40000002, but it is 40000000 !

Explanation goes:

let we have n ants. We have to maximize the Hi among them so We have to divide them equally into two groups n*(n-n/2). Now Comes the main part We have Time= (10^9 + 6), so we will find the Encounter of ants only for 10^9 initially afterwords we count for 6. so
Speed = 0.1 m/s ,
Length of Track = 1000,
so Time taken by ants to complete
one cycle = 1000/0.1 = 10000.
Total Time = 10^9
Number of Cycles = 10^9/10^4 = 10^5
Total Encounters = Number of Cycle * n*(n-n/2);

Now Came The Second Part:

The rest 6 sec. if the distance between 2 ants is <6*0.1*2 then Only there will be Encounter. so we Wil iterate through the initial Position of ants and check that whether Two ants are standing <1.2m distance or not, it they increase the Encounter +1;

PS. Sort the Array and Check the last index and the first index are also at the distance less than 1.2 , then increase the Counter;

Finally Return the total Encounter * 2 as in One Encounter there will be Two Hi

Implementation in Cpp:

nt solve(vector<int> V) {
    int n=V.size(),c=0;
    int x = 2*n/2*(n-n/2)*100000;
    sort(V.begin(),V.end());
    
    for(int i=0;i<n-1;i++)
    {
        if(V[i+1]-V[i]==1)
        {
            c++;
            i++;
        }
    }
    if(V[n-1]-V[0]==1)
        c++;
    x+=c;
    return x*2; 
}