WA in IITKWPCO SPOJ - c

Question

This is a question from SPOJ
Little Feluda likes to play very much. As you know he only plays with numbers. So he is given n numbers. Now tries to group the numbers into disjoint collections each containing two numbers. He can form the collection containing two numbers iff small number in the collection is exactly half of large number.
Given n numbers, Find out how many maximum number of collections he can form ?
Input
T: number of test cases. (1 <= T <= 100).
For each test case:
First line will contain n : (1 <= n <= 100)
Then next line will contain n numbers single space seperated. Range of each number will be between 1 and 10^6.
Output
For each test case, output maximum number of collections that can be formed.
Example
Input:
2
2
1 2
3
1 2 4
Output:
1
1
my code::
#include <stdio.h>
#include <math.h>
#include <string.h>
int main()
{
int t;
scanf("%d", &t);
while (t--) {
int n, i, j;
scanf("%d", &n);
long int arr[n], mini, maxi;
char str[105];
for (i = 0;i < n;i++) {
str[i] = '0';
scanf("%ld", &arr[i]);
}
for (i = 0;i < n;i++) {
for (j = 0;j < n;j++) {
mini = fmin(arr[i], arr[j]);
maxi = fmax(arr[i], arr[j]);
if ((maxi == 2 * mini) && (str[i] == '0' && str[j] == '0')) {
str[i] = str[j] = '1';
break;
}
}
}
long int cnt = 0;
for (i = 0;i < n;i++) {
if (str[i] == '1') {
cnt++;
}
}
printf("%ld\n", cnt / 2);
}
return 0;
}
can someone plz point out where i am going wrong or any corner test case that i am missing??

Answer 1

There is a flaw in your logic.
Consider the case where the input array is {2,4,1,8}
The answer for this should be 2, since the collections {1,2} and {4,8} can be formed. However, your code will output 1 for this case (it will pair 2 with 4, and be able to create only one collection).
I have solved this problem by sorting the array, then for each element, check whether two times that element exists or not. If yes, mark it as used and increment the count of collections.
(pseudo-code):
sort(array)
count = 0;
for(i=0;i<size;i++){
if(used[i]) continue; //used elements should not be re-considered
for(j=i+1;j<size;j++){
if(array[j]==2*array[i] && !used[j]){
used[j] = true;.
count++;
}
}
}
The variable count will now have the maximum possible number of collections.
Note that searching for 2*array[i] in the array can also be implemented by binary search, but that would be unnecessary since the array is really small (size <=100)
Here's my C++ code for the problem. ( I have used the c++ standard library for sorting, you may use any sorting algorithm of your choice ).
Hope this helps.
Cheers.

Answer 2

Check out this easy solution:
#include<iostream>
#include<algorithm>
#include<stdio.h>
using namespace std;
int main()
{
int t=0;
scanf("%d",&t);
while(t>0)
{
t=t-1;
int num=0;
long long int n[10001];
int count=0;
scanf("%d",&num);
for(int k=0;k<num;k++)
scanf("%lld",&n[k]);
sort(n,n+num);
for(int i=0;i<num;i++)
{
if(n[i]==-1)continue;
for(int j=i+1;j<num;j++)
{
if(n[j]==n[i]*2 &&n[i]!=-1 &&n[j]!=-1 )
{
count=count+1;
n[i]=-1;
n[j]=-1;
break;
}
}
}
printf("%d\n",count);
}
// getchar();
return 0;
}