1.

/**
> > * Angewandte Mathematik, SS11
> > * Problem: 12004 Bubble Sort
> > * Link: http://uva.onlinejudge.org/external/120/12004.pdf
> > * @author Brielbeck, Daniel
> > * @author Weber, Georg
> > * @version 1.0, 06/21/2011
> > * Method : Ad-Hoc
> > * Status : Accepted
> > * Runtime: 0.344
> > */
> > import java.util.Scanner;
> >
> > public class Main {
> >
> > public static void main(String[] args) {
> > Scanner in = new Scanner(System.in);
> > long n = in.nextInt();
> >
> > for (long i = 0; i < n; i++) {
> > long r = in.nextInt();
> > long f[] = fkt((r * (r - 1)), 4);
> > if (f[0] == 0)
> > System.out.println("Case " + (i + 1) + ": 0");
> > else {
> > if (f[0] == f[1])
> > System.out.println("Case " + (i + 1) + ": 1");
> > else {
> > if (f[1] == 1)
> > System.out.println("Case " + (i + 1) + ": " + f[0]);
> > else
> > System.out.println("Case " + (i + 1) + ": " + f[0] + "/" + f[1]);
> > }
> > }
> > }
> > }
> >
> > private static long[] fkt(long z, long n) {
> > long[] temp = new long[2];
> > long ggt = ggt(z, n);
> > z /= ggt;
> > n /= ggt;
> > temp[0] = z;
> > temp[1] = n;
> > return temp;
> > }
> >
> > public static long ggt(long x, long y) {
> > if (y != 0)
> > return ggt(y, x % y);
> > else
> > return x;
> > }
> > }


2.

package am.bubblesort;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
* Angewandte Mathematik, SS11
* Problem: 12004 - Bubble Sort
* Link:
*
* @author Florian Stein
* @author Franz Sommer
* @version 1.0, 06/27/2011
*
* Method : Ad-Hoc
* Status : TLE
* Runtime: x.xxx
*/

public class Main {

public static void main(String... args) throws IOException {

// start der eingabe
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));

String inputLine = reader.readLine();
StringTokenizer token = new StringTokenizer(inputLine);
int tests = new Integer(token.nextToken());
for (int c = 1; c <= tests; c++) {
inputLine = reader.readLine();
token = new StringTokenizer(inputLine);
int n = new Integer(token.nextToken());
double pow = Math.pow(n, 2) - n;
pow = pow * 0.25;
if ((pow % 1) == 0) {
System.out.println("Case " + c + ": " + (int) pow);
} else {
Bruch test = new Bruch(pow, c);
// bruch(pow);
}
}
}

static class Bruch {
final double Ungenauigkeit = 0.0000000002;
int Nenner, Zaehler;
int c;

int GetNenner() {
return (Nenner);
}

int GetZaehler() {
return (Zaehler);
}

boolean IstGanz(double Zahl) {
if ((Zahl - (int) (Zahl) - Ungenauigkeit < 0)
&& (Zahl - (int) (Zahl) + Ungenauigkeit > 0)) {
return (true);
} else {
return (false);
}
}

// Konstruktor fuer Bruch, der einen double in einen Bruch umwandelt
// (Erst die Komma-Zahl in einen Bruch umwandeln und dann kuerzen)
Bruch(double Zahl, int c) {
boolean Negativ = false;
if (Zahl < 0) {
Zahl = -1 * Zahl;
Negativ = true;
}
this.c = c;
int i = 1;
while (!(IstGanz(Zahl * Math.pow((double) 10, (double) i)))) {
++i;
}
Zaehler = (int) (Zahl * Math.pow((double) 10, (double) i) + Ungenauigkeit);
Nenner = (int) Math.pow((double) 10, (double) i);
Kuerzen();
if (Negativ) {
Zaehler = -1 * Zaehler;
}
System.out.println("Case " + c + ": " + Zaehler + "/" + Nenner);
}

// Kuerzt den Bruch, indem ein gemeinsamer Teiler gesucht wird,
// durch den dann geteilt und wieder gekuerzt wird
void Kuerzen() {
for (int i = 2; ((i <= Nenner) && (i <= Zaehler)); ++i) {
if ((Nenner % i == 0) && (Zaehler % i == 0)) {
Nenner /= i;
Zaehler /= i;
Kuerzen();
}
}
return;
}

}
}