1.

/**
* Angewandte Mathematik, SS11
* Problem: 11875 Brick Game
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=226&page=show_problem&problem=2986
*
* @author Gent Selmanaj
* @author Marco Schuster
* @version 1.0, 2011-03-29
*
* Method :
* Status : Accepted (ID 8690604)
* Runtime: 0.140
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

/**
* @param args
*/
public static void main(String[] args) {
try {
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
int numTeams;
numTeams=Integer.parseInt(input.readLine());

for(int i=1;i<=numTeams;i++) {
String line=input.readLine();
String[] tmp=line.split(" ",2);
String[] players=tmp[1].split(" ");
int[] playersAge=new int[players.length];
for(int j=0;j<players.length;j++)
playersAge[j]=Integer.parseInt(players[j]);
java.util.Arrays.sort(playersAge);
System.out.println("Case "+i+": "+playersAge[playersAge.length/2]);
}
} catch(Exception e) {
e.printStackTrace();
}
}
}




------------------------------------------------------


1.


/**
 * FWP, Ausgewählte Probleme aus dem ACM Programming Contest, WS10/11 Problem:
 * 11875 - Brick Game
 * Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=226&page=show_problem&problem=2986

 *
 * @author Felix Dietrich
 * @version 1.0, 24.10.2010
 *
 * Method : Ad-Hoc
 * Status : Accepted
 * Runtime:
 */
import java.util.*;
import java.util.Scanner;


public class Main
{
    public static final int MAX = (int) 1000;
    public static final boolean[] isPrime = new boolean[MAX + 1];
    public static final int prime[] = new int[MAX];
    public static int maxPrime = 0;
    private static int a, b, c, d;
//    private static Map<Integer,Set<Integer>> divisors = new HashMap<Integer,Set<Integer>>();
//    private static int[] divs = new int[MAX*MAX];

    private static void sievePrimes()
    {
//        Set<Integer> s = new HashSet<Integer>();
       
        for (int i = 2; i <= MAX; i++)
        {
            isPrime[i] = true;
        }
        // sieve the multiples of 2
        for (int i = 4; i <= MAX; i += 2)
        {
            isPrime[i] = false;
            /*if(!divisors.containsKey(i))
                divisors.put(i, new HashSet<Integer>());
            s = divisors.get(i);
            s.add(1);
            s.add(i);
            s.add(2);
            s.add(i/2);*/
//            if (i == 4)
//                divs[i] = 3;
//            else
//                divs[i] = 2;
        }

//        divs[1] = 1;
//        divs[2] = 2;
//        divs[3] = 2;

        prime[maxPrime++] = 2;
/*
        s = new HashSet<Integer>();
        s.add(1);
        divisors.put(0, s);
        divisors.put(1, s);
        s = new HashSet<Integer>();
        s.add(1);
        s.add(2);
        divisors.put(2, s);*/

        // sieve other numbers
        int squareRoot = (int) Math.sqrt(MAX);
        for (int i = 3; i <= MAX; i += 2)
            if (isPrime[i])
            {
                prime[maxPrime++] = i;
//                s = new HashSet<Integer>();
//                s.add(1);
//                s.add(i);
//                divisors.put(i, s);
                for (int j = i + i; j <= MAX; j += i)
                {
                    isPrime[j] = false;
                    //if(!divisors.containsKey(j))
                    //    divisors.put(j, new HashSet<Integer>());
                    //s = divisors.get(j);
                    //s.add(1);
                    //s.add(j);
                    //s.add(i);
                    //s.add(j/i);
                }
            }

    }

    private static int calc(int n)
    {
        if(n == 0)
            return 1;
        //if(n < 1000000)
        //    return divs[n] == 0 ? 2 : divs[n];
       
        //if(divisors.containsKey(n))
        //    return divisors.get(n).size();
       
        //System.out.println("sss");
       
        int d = 1, power;
        for (int i = 0; i < maxPrime; i++)
            if (n % prime[i] == 0)
            {
                // System.out.println(n + " ==> " + prime[i]);
                power = 1;
                while (n % prime[i] == 0)
                {
                    n /= prime[i];
                    power++;
                    // System.out.println("    " + prime[i]);
                }
                d *= power;
            }

        if (n != 1)
            return d * 2;

        return d;
    }

    public static void main(String... s)
    {
        // calculate divisors and NOD series
        sievePrimes();

        long dist = System.currentTimeMillis();
        int[] abs = new int[1000600];
        int cab = 1;

        int newnod = 1;
        abs[0] = 0;
        abs[1] = 1;
        abs[2] = 1;
        for (int i = 1; i < 64750; i++)
        {
            newnod = newnod + calc(newnod);
            for(int c2=cab+1;c2<=newnod;c2++)
                abs[c2] = abs[cab];
            abs[newnod] = abs[cab]+1;
            cab = newnod;
        }

        Scanner sc = new Scanner(System.in);
        dist = System.currentTimeMillis() - dist;
        System.out.println(dist);

        int tcs = sc.nextInt();
        int A,B,count;
        for (int c = 0; c < tcs; c++)
        {
            A = sc.nextInt();
            B = sc.nextInt();
            count = abs[B]-abs[A-1];
           
            System.out.println("Case " + (c+1) + ": " + count);
        }
    }
}

2.

/*
 * ACM Contest training
 * Problem: 11875 - Brick Game
 * Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&category=226&problem=2986
 *
 * @author Christoph Goettschkes
 * @version 1.0, 10/27/2010
 *
 * Method : Ad-Hoc
 * Status : Accepted
 * Runtime: 0.088
 */

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

class Main
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String line = reader.readLine().trim();
        int testCases = Integer.parseInt(line);
       

        for (int i = 1; i <= testCases; i++)
        {
            line = reader.readLine();
            StringTokenizer tokenizer = new StringTokenizer(line);
            int players = Integer.parseInt(tokenizer.nextToken());

            int[] playerArr = new int[players];

            for (int j = 0; j < players; j++) {
                playerArr[j] = Integer.parseInt(tokenizer.nextToken());
            }

            Arrays.sort(playerArr);

            System.out.println("Case " + i + ": " + playerArr[players/2]);
           
        }
       

    }


   
}

3.

/**
 * FWP, Ausgewählte Probleme aus dem ACM Programming Contest
 * Problem:     11875 - Brick Game
 * Link:        http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=226&page=show_problem&problem=2986
 *
 * Method :     ad hoc
 * Status :     Accepted
 * Runtime:     0.128
 *
 * @author      Evgeni Pavlidis
 * @version     1.0, 10/24/2010
 */

import java.io.*;
import java.util.*;

class Main
{

    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    static int nextInt() throws IOException
    {
    st.nextToken();
    return (int)st.nval;
    }

    public static void main(String...args) throws Exception
    {
    int testCases = nextInt();
    List<Integer> list = new ArrayList<Integer>();
    int n;
   
    for(int tc = 1; tc <= testCases; tc++)
    {
        list.clear();
        n = nextInt();
        for(int i = 0; i < n; i++)
        list.add(nextInt());

        Collections.sort(list);
        System.out.printf("Case %d: %d\n", tc, list.get(n/2));
    }
    }
}