1.

´import java.util.Scanner;

/**
* Angewandte Mathematik, SS11
* Problem: 311 Packets
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=5&page=show_problem&problem=247
*
* @author Benedikt Z¨nnchen
* @author Erik Wenzel
* @version 1.0, 12/04/2011
*
* Method : Fallunterscheidung
* Status : Accepted
* Runtime: 0.568
*
* Herangehensweise
* 1. Es erscheint einleuchtend das man f¾r jedes 4x4, 5x5, 6x6 ein neues Paket braucht
* 2. Es erscheint auch einleuchtend, dass man danach zun¦chst versucht m¨glichst viele 2x2er
* in die freien Pl¦tze zu bringen da die 1x1er ja die flexibelsten sind und ¾berall reinpassen
* 3. In ein 4x4 gehen genau 5*2x2
* 4. In ein 5x5 gehen nur 11*1x1
* 5. Die 3x3 stellen das eigentliche Problem dar, doch es l¦sst sich beweisen, dass es immer am
* sinnvollsten ist alle 3x3 in m¨glichst ein Paket zu bringen und nicht zu mischen.
*
* => Beweis:
* 1. 4*3x3 passen genau in ein 6x6! D.h. es bleibt kein Platzt ¾brig und es ist der Idealfall!
* 2. bleiben die F¦lle es ist 1*3x3, 2*3x3 und 3*3x3 ¾ber
* 2.1 1*3x3: packen wir einfach in ein 6x6 => fertig
* 2.2 2*3x3: teilen wir es in 2 Pakete => es ist Platzt f¾r 10*2x2
* teilen wir es nicht sondern legen beide in ein Paket => es ist Platzt f¾r 5*2x2+9*2x2 = 14*2x2
* 2.3 3*3x3: packen wir alle in eins => platzt f¾r 1*2x2+9*2x2+9*2x2 = 19*2x2
* teilen wir es in 2 auf => platzt f¾r 3*2x2+5*2x2+9*2x2 = 17*2x2
* teilen wir es in 3 auf => plarzt f¾r 5*2x2+5*2x2+5*2x2 = 15*2x2
* => Es ist in jedem Fall am besten alle 3x3 in ein Paket zu packen. Das vereinfacht den Algo enorm.
*
*/

public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);

while(true)
{
int packets[] = new int[6];
int result = 0;
int freeOnes = 0; // freie Plätze f¾r 1er
int freeTwos = 0; // freie Plätze f¾r 2er

for(int i = 0; i < 6; i++)
{
packets[i] = sc.nextInt();
result += packets[i];
}

// Abbruchbedingugn
if(result==0)
{
break;
}

/*
* Da keine 2 6x6er, 2 5x5er oder 2 4x4er in ein Packet passen und
* nach dem oben angeführten Beweis es immer am besten ist alle
* 3x3 zusammen zu packen folgt eine mindesanzahl an Paketen von:
*/
result = packets[5] + packets[4] + packets[3] + (packets[2] + 3) / 4; //+3 da man f¾r 1 3er 1packet aber auch f¾r 4 1packet braucht

// in jedes 5er Paket gehen 11 1x1 somit hat man 11*5x5er frei 1x1
freeOnes = packets[4]*11;

// in jedes 4er Paket gehen 5 2x2 somit hat man 5*4x4er frei 2x2
freeTwos = packets[3]*5;

// Nun muss man noch beachten wie viele 2x2 und 1x1 in den platzt des Pakets mit den 3x3 ern geht.
// Dies ist abh¦ngig von der Anzhal der 3x3er in diesem Paket
if(packets[2]%4 == 1)
{
freeTwos += 5;
freeOnes += 7;
}
else if(packets[2]%4 ==2)
{
freeTwos += 3;
freeOnes += 6;
}
else if(packets[2]%4 == 3)
{
freeTwos += 1;
freeOnes += 5;
}

/*
* Gibt es mehr 2x2er als freie Plätze f¾r 2x2er so m¾ssen f¾r den
* rest neue Pakete angelegt werden. Es passen 9 2x2 in ein 6x6!
*/
if(freeTwos <= packets[1])
{
int rest = packets[1] - freeTwos;
int tmp = (rest + 8) / 9; // +8 da man f¾r 1 2x2, 1 6x6 braucht und f¾r 9 2x2er ebenfalls
result += tmp;
// hat man neue Pakete f¾r die 2x2er so bleibt platzt f¾r neue 1x1er
// 9 2x2 sind immer ein volles 6x6 und in 1 2x2 gehen 4 1x1!
freeOnes += 4 *(9 * tmp - rest);
}
// andernfalls gehen alle 2x2 in die freien pl¦tze und es gibt vielleicht noch platzt f¾r 1x1 er
else
{
freeOnes += 4 * (freeTwos - packets[1]);
}

// falls es mehr 1x1 gibt als platzt da ist m¾ssen weitere pakete genutzt werdenn
if(freeOnes <= packets[1])
{
result += (packets[0] - freeOnes + 35) / 36; // +35 da man f¾r 1 1x1, 1 6x6 braucht und f¾r 36 1x1er ebenfalls
}


System.out.println(result);
}
}
}