# very hard algorithm implementation

• April 25th, 2012, 03:26 PM
TheByt3
very hard algorithm implementation
So I wanted to solve this problem:

After a tennis tournament each player was asked how many matches he had.
An athlete can't play more than one match with another athlete.
As an input the only thing you have is the number of athletes and the matches each athlete had. As an output you will have 1 if the tournament was possible to be done according to the athletes answers or 0 if not. For example:

Input: 4 3 3 3 3 Output: 1
Input: 6 2 4 5 5 2 1 Output: 0
Input: 2 1 1 Output: 1
Input: 1 0 Output: 0
Input: 3 1 1 1 Output: 0
Input: 3 2 2 0 Output: 0
Input: 3 4 3 2 Output: 0

the first number of the input is not part of the athletes answer it's the number of athletes that took part in the tournament for example in 6 2 4 5 5 2 1 we have 6 athletes that took part and their answers were 2 4 5 5 2 1

This is what I have wrote so far and it is not working completely:

Code :

```import java.util.Scanner; import java.util.Arrays;   public class Tennis {   public static void main(String[] args) { Scanner input = new Scanner(System.in);   String N; int count; int sum = 0; int max; int activeAthletes; int flag;   System.out.printf("Give: "); N = input.nextLine();   String[] arr = N.split(" "); int[] array = new int[arr.length];   for (count = 0; count < arr.length; count++) { array[count] = Integer.parseInt(arr[count]); //System.out.print(arr[count] + " "); }   for (count = 1; count < arr.length; count++) { sum += array[count]; } //System.out.println("\n" + sum);   activeAthletes = array[0];   for (count = 1; count < array.length; count++) { if (array[count] == 0) { activeAthletes--; } }   max = array[1]; for (count = 2; count < array.length; count++) { if (array[count] > max) { max = array[count]; } } // System.out.println(max);   if ((sum % 2 == 0) && (max < activeAthletes)) { flag = 1; } else{ flag = 0; }   System.out.println(flag); } }```
• July 26th, 2012, 09:39 AM
Aivaz
Re: very hard algorithm implementation
Hi TheByt3, I know I am replying a bit late, but I just saw your question, and think maybe I'd help you a bit. Here algorithm would work so:
You should initially determine the maximum of the series you indicate, and decrease the other ones in the series by one, then we'd make the maximum number 0, and keep processing the same algorithm for the next maximum numbers remaine. For instance, say the series is as follows: 6 4 1 1 1 2 1. Here 6 indicates the number of players, we can start processing by the maximum number of the series, being 4. Decrease 1, 1, 1, and 2 by one so the result is 0 0 0 0 1 1. The maximum is, now, 1, afterwards the series get converted to 0 0 0 0 0 0, so the function should return the result true. The code is as follows (I hope it helps):

Attachment 1342
• July 26th, 2012, 09:45 AM
Aivaz
Re: very hard algorithm implementation
I'd better show the java code here to make it clearer. Regards.
Code :

`...edited by moderator`
• July 26th, 2012, 11:10 AM
copeg
Re: very hard algorithm implementation