import java.io.*;
class Zettel9 {

    public static void main(String[] args) throws Exception {
		aufgabe1();
		aufgabe2();
	}

	public static void aufgabe1 () throws Exception {

	// EINLESEN
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("Wieviele Sitze wird es geben? ");
		int sitze_sum = Integer.parseInt(br.readLine());

		System.out.print("Wieviele Parteien sollen eingelesen werden? ");
		int n = Integer.parseInt(br.readLine());

		int[] partei = new int[n];	// Sitze-für-jede-Partei-Array anlegen
		int[] stimmen = new int[n];	// Stimmen-für-jede-Partei-Array anlegen
		for (int i=0; i<n; i++) {
			partei[i]=0;			// Sitze-Array nebenbei initialisieren
			System.out.print("Wieviele Stimmen fuer die "+(i+1)+". Partei? ");
			stimmen[i] = Integer.parseInt(br.readLine());
		}

	// BERECHNUNG
		float max=0.0f; // Maximalwert der x zu vergleichenden Stimmen
		float hoechstzahl=0.0f; // temporäre Höchstzahl initialisieren
		int welchepartei=0;	// Zeiger auf die Nr. der Partei welche diesen Sitz erhält

		for (int sitze=sitze_sum; sitze!=0; sitze--) {	// für alle zu vergebenden Sitze
			System.out.println();
			for (int i=0; i<n; i++) {	// Alle obersten Werte der Parteien-Tabelle vergleichen

				hoechstzahl=((float)stimmen[i])/((float)partei[i]+1);
					// =(Stimmenanzahl/an diese Partei vergebene Sitze)
				System.out.println("Die Hoechstzahl der "+(i+1)+". Partei ist "+hoechstzahl+" (="+stimmen[i]+":"+(partei[i]+1)+") ");

				if (max<hoechstzahl) {	// Wenn der max-wert < als hoechstzahl
					welchepartei=i;	// Zeiger auf die Partei setzen, welche anscheinend den Sitz erhält
					max=hoechstzahl; // neuer Maxwert für diese Zeile
				}
			}
			partei[welchepartei]++;	// Der Partei den Sitz geben
			System.out.println("Dieser Sitz geht an die Partei "+(welchepartei+1)+", welche somit "+partei[welchepartei]+" Sitze hat.");
			max=0;	// Max-Wert resetten
		}

	// AUSGABE
		System.out.println();
		for (int i=0; i<n; i++) {
			System.out.println("Die "+(i+1)+". Partei mit "+stimmen[i]+" Stimmen bekommt "+partei[i]+" von "+sitze_sum+" Sitzen.");
		}
	/*
	Zuerst war die Überlegung die Matrix nur teilweise vorzuberechnen.
	Ganz simpel anhand der ungefähren Sitzverteilung berechnet über Prozente.
	Wenn man diese Matrix erstellt hat und auf den Kopf dreht,
	so erkennt man in der untersten Zeile, welche Partei die meisten Stimmen bekommen hat.

	Dieser Partei schreibt man einen Sitz gut.

	Dann streicht man diesen Wert aus der Matrix und lässt die anderen (darüberliegenden) nachrutschen.
	Deswegen das Umdrehen. Wert gestrichen, die restlichen Werte sacken nach.
	Dann braucht man nur weiter in der untersten Zeile zu vergleichen, welcher Wert am größten ist.
	Stimme vergeben, nachrutschen lassen.

	Optimierung:
	Das vorrausberechnen der Matrix ist nicht notwendig.
	Man kann den "nachrutschenden" Wert (Höchstzahl) einfach ermitteln in dem man die Stimmenanzahl der Partei
	durch die schon an diese Partei vergebenen Sitze dividiert (aufpassen, immer +1 damit nicht x/0 auftaucht!)

	Das Konzept ganz zu Anfang (ohne Algorithmus) sah ca. so aus:


			// EINLESEN

			int sitze_sum = 365;		// z.B. sind 365 Sitze verfügbar
			int n = 5;					// 5 Parteien, beispielsweise
			int[] stimmen = new int[n];	// Stimmen-Array anlegen
			int[] sitze = new int[n];	// Sitze-Array anlegen
			int stimmen_sum = 0;		// Stimmen-Max initialisieren
			for (int i=0; i<n; i++) {
				stimmen[i]=27;	// erstmal Beispielwerte eintragen
				stimmen_sum+=stimmen[i];
			}

			// BERECHNUNG

			// Algorithmus für die Sitzverteilung



			// AUSGABE

			for (int i=0; i<n; i++) {
				System.out.println("Die "+(i+1)+". Partei mit "+stimmen[i]+" Stimmen bekommt "+sitze[i]+" von "+sitze_sum+" Sitzen.");
			}

	Der Algorithmus wurde solange theoretisch optimiert und erst dann implementiert, das es hier zu keine wirkliche
	History-Datei gibt (ausser evtl. Syntax-Fehlern, kleinere Implementationsprobleme).

	TESTLAUF:
	Wieviele Sitze wird es geben? 10
	Wieviele Parteien sollen eingelesen werden? 3
	Wieviele Stimmen fuer die 1. Partei? 22
	Wieviele Stimmen fuer die 2. Partei? 48
	Wieviele Stimmen fuer die 3. Partei? 67

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 48.0 (=48:1)
	Die Hoechstzahl der 3. Partei ist 67.0 (=67:1)
	Dieser Sitz geht an die Partei 3, welche somit 1 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 48.0 (=48:1)
	Die Hoechstzahl der 3. Partei ist 33.5 (=67:2)
	Dieser Sitz geht an die Partei 2, welche somit 1 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 24.0 (=48:2)
	Die Hoechstzahl der 3. Partei ist 33.5 (=67:2)
	Dieser Sitz geht an die Partei 3, welche somit 2 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 24.0 (=48:2)
	Die Hoechstzahl der 3. Partei ist 22.333334 (=67:3)
	Dieser Sitz geht an die Partei 2, welche somit 2 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 16.0 (=48:3)
	Die Hoechstzahl der 3. Partei ist 22.333334 (=67:3)
	Dieser Sitz geht an die Partei 3, welche somit 3 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 22.0 (=22:1)
	Die Hoechstzahl der 2. Partei ist 16.0 (=48:3)
	Die Hoechstzahl der 3. Partei ist 16.75 (=67:4)
	Dieser Sitz geht an die Partei 1, welche somit 1 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 11.0 (=22:2)
	Die Hoechstzahl der 2. Partei ist 16.0 (=48:3)
	Die Hoechstzahl der 3. Partei ist 16.75 (=67:4)
	Dieser Sitz geht an die Partei 3, welche somit 4 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 11.0 (=22:2)
	Die Hoechstzahl der 2. Partei ist 16.0 (=48:3)
	Die Hoechstzahl der 3. Partei ist 13.4 (=67:5)
	Dieser Sitz geht an die Partei 2, welche somit 3 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 11.0 (=22:2)
	Die Hoechstzahl der 2. Partei ist 12.0 (=48:4)
	Die Hoechstzahl der 3. Partei ist 13.4 (=67:5)
	Dieser Sitz geht an die Partei 3, welche somit 5 Sitze hat.

	Die Hoechstzahl der 1. Partei ist 11.0 (=22:2)
	Die Hoechstzahl der 2. Partei ist 12.0 (=48:4)
	Die Hoechstzahl der 3. Partei ist 11.166667 (=67:6)
	Dieser Sitz geht an die Partei 2, welche somit 4 Sitze hat.

	Die 1. Partei mit 22 Stimmen bekommt 1 von 10 Sitzen.
	Die 2. Partei mit 48 Stimmen bekommt 4 von 10 Sitzen.
	Die 3. Partei mit 67 Stimmen bekommt 5 von 10 Sitzen.
	*/
	}

	public static void aufgabe2 () throws Exception {
/*
	Konzept:
		Teilnehmer-Daten einlesen
		loop-mark
		Teilnehmer-Zeiten Array resetten
		für jeden Teilnehmer
			Zeit einlesen
			Zeit in Array einsortieren
			Arrray als Tabelle ausgeben
		Fragen ob nochmal, ja gehe zum loop, sonst ende.
*/


	// Teilnehmer-Daten einlesen
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("Wieviele Teilnehmer? ");	// Teilnehmeranzahl einlesen
		int n = Integer.parseInt(br.readLine());

		int temp=0;		// nur eine Temp-Variable :)
		int [][] zeiten = new int [n+1][2];	// Arrays bereitstellen
		// Das Zeitenarray ist 2dimensional, es enthält in der
		// 1. Zeile: die gemessene Zeit
		// 2. Zeile: die Index-Nr des zugehörigen Sportlers

		String[] teilnehmer = new String [n+1];	// Arrays bereitstellen

		for (int i=1; i<=n; i++) {	// Teilnehmernamen einlesen
			System.out.print("Name des "+i+". Teilnehmers: ");
			teilnehmer[i] = br.readLine();
		}

	// loop-mark
		int redo, counter=0; // benötigte Variablen vorinitialisieren...
		for (;;) {

			// Teilnehmer-Array resetten
			for (int i=1; i<=n; i++) zeiten[i][0]=0;

			for (int i=1; i<=n; i++) {			// für jeden Teilnehmer
				System.out.print("Wie lange hat '"+teilnehmer[i]+"' gebraucht? ");
				temp = Integer.parseInt(br.readLine());
				zeiten[0][0]=temp;				// Zeit einlesen

				mark1:for (int j=n; j>0; j--) {			// Zeit in array einsortieren
					if (zeiten[j-1][0]<=temp) {			// Sentinel-Technik nutzen
						if (zeiten[j-1][0]!=0) {		// abchecken weil mit 0 gefüllt
							zeiten[j][0]=temp;			// Zeit eintragen
							zeiten[j][1]=i;				// Namens-pointer mitschleifen!
							break mark1;				// fertig, schnell raus hier.
						}
					} else {
						zeiten[j][0]=zeiten[j-1][0];	// alles 1 Feld weiterschieben
						zeiten[j][1]=zeiten[j-1][1];	// Namens-pointer nicht vergessen!
					}
				}
				counter=0;
				for (int k=1; k<=n; k++) {	// Jedes Feld des Arrays von 1 bis n ausgeben
					if (zeiten[k][0]!=0) {	// Aber nur die Spalten, mit Zeiten != 0
						counter++;
						System.out.println(counter+". '"+teilnehmer[(zeiten[k][1])]+"' : "+zeiten[k][0]+"s");
					}
				}
			}
			System.out.print("Noch ein Durchgang? 1=Ja, Rest=Nein)");
			redo = Integer.parseInt(br.readLine());
			if (redo==1) System.out.println("*** Neuer Durchgang ***");
			else break;
		}
	}
}
/*

TESTLAUF:

Wieviele Teilnehmer? 7
Name des 1. Teilnehmers: Hannes
Name des 2. Teilnehmers: Berta
Name des 3. Teilnehmers: Ines
Name des 4. Teilnehmers: Klaus
Name des 5. Teilnehmers: Herrmann
Name des 6. Teilnehmers: Lambert
Name des 7. Teilnehmers: Rudolph
Wie lange hat 'Hannes' gebraucht? 22
1. 'Hannes' : 22s
Wie lange hat 'Berta' gebraucht? 10
1. 'Berta' : 10s
2. 'Hannes' : 22s
Wie lange hat 'Ines' gebraucht? 9
1. 'Ines' : 9s
2. 'Berta' : 10s
3. 'Hannes' : 22s
Wie lange hat 'Klaus' gebraucht? 77
1. 'Ines' : 9s
2. 'Berta' : 10s
3. 'Hannes' : 22s
4. 'Klaus' : 77s
Wie lange hat 'Herrmann' gebraucht? 13
1. 'Ines' : 9s
2. 'Berta' : 10s
3. 'Herrmann' : 13s
4. 'Hannes' : 22s
5. 'Klaus' : 77s
Wie lange hat 'Lambert' gebraucht? 43
1. 'Ines' : 9s
2. 'Berta' : 10s
3. 'Herrmann' : 13s
4. 'Hannes' : 22s
5. 'Lambert' : 43s
6. 'Klaus' : 77s
Wie lange hat 'Rudolph' gebraucht? 4711
1. 'Ines' : 9s
2. 'Berta' : 10s
3. 'Herrmann' : 13s
4. 'Hannes' : 22s
5. 'Lambert' : 43s
6. 'Klaus' : 77s
7. 'Rudolph' : 4711s
Noch ein Durchgang? 1=Ja, Rest=Nein)1
*** Neuer Durchgang ***
Wie lange hat 'Hannes' gebraucht? 55
1. 'Hannes' : 55s
Wie lange hat 'Berta' gebraucht? 33
1. 'Berta' : 33s
2. 'Hannes' : 55s
Wie lange hat 'Ines' gebraucht? 22
1. 'Ines' : 22s
2. 'Berta' : 33s
3. 'Hannes' : 55s
Wie lange hat 'Klaus' gebraucht? 91
1. 'Ines' : 22s
2. 'Berta' : 33s
3. 'Hannes' : 55s
4. 'Klaus' : 91s
Wie lange hat 'Herrmann' gebraucht? 53
1. 'Ines' : 22s
2. 'Berta' : 33s
3. 'Herrmann' : 53s
4. 'Hannes' : 55s
5. 'Klaus' : 91s
Wie lange hat 'Lambert' gebraucht? 22
1. 'Ines' : 22s
2. 'Lambert' : 22s
3. 'Berta' : 33s
4. 'Herrmann' : 53s
5. 'Hannes' : 55s
6. 'Klaus' : 91s
Wie lange hat 'Rudolph' gebraucht? 1
1. 'Rudolph' : 1s
2. 'Ines' : 22s
3. 'Lambert' : 22s
4. 'Berta' : 33s
5. 'Herrmann' : 53s
6. 'Hannes' : 55s
7. 'Klaus' : 91s
Noch ein Durchgang? 1=Ja, Rest=Nein)0

*/