Aufgabe Arrays in ArrayList

[f4814n]

Hallo,

ich bin neu hier und freu mich über jeden der mir helfen kann/möchte. Danke schonmal. Das bringt mir sicher ne Menge!

Bereite mich grade auf ein Java Testat vor und brauche Hilfe bei folgender Aufgabe:

Es gibt ein ReferenzArray mit 3 Werten {2,3,1} und eine ArrayList in der int Arrays gespeichert sind zB so:

{1,1,2}
{3,1,2}
{2,3,0}
{2,2,2}

Diese stellen Prozesse dar, die jeweils entsprechende Ressourcen benötigen. Der Ressourcenspeicher ist das Referenzarray {2,3,1}

Jetzt soll ich mittels einer Methode Überprüfen welcher Prozess der erste ist, der ausgeführt werden kann (heißt, dessen Werte alle kleiner oder gleich den Werten im Referenzarray sind. Natürlich auf den entsprechenden Positionen).

Theoretisch würde ich es so machen:

ArrayList durchlaufen mittels forSchleife, dann das dreierarray durchlaufen und jedes element mit dem entsprechenden element des Referenzarrays vergleichen. Mir ist nicht klar was er dann tun soll... Vermutlich ne dumme Frage. Vielleicht ein boolean einführen und ihn so lange vergleichen lasen bis dieser false wird und dann zum nächsten springen? ich hab eine idee kann sie aber mangels programmiererfahrung nicht umsetzen. Vielleicht schafft es jemand mir einen tipp zu geben ohne alles zu verraten. Wäre echt dankebar!!!!

public class ProcessCheckerImpl implements ProcessChecker {
	
	int[] currentlyAvailableResources;
	
	public ProcessCheckerImpl(int[] currentlyAvailableResources) {
		this.currentlyAvailableResources = currentlyAvailableResources;
	}
	
	public int getExecutableIndex(ArrayList<int[]> processList) {
			
			for (int[] a : processList) {
				for (int i = 0; i < a.length; i++) {
					
					while(a[i]<=currentlyAvailableResources[i]){
						
						//mach so lange weiter bis es nicht mehr erfüllt ist und springe dann zu processList[i+1]
					
						
					}
					
				}
			
		}
		
		
		return -1;
	}

VIELEN DANK: freu mich auf Feedback!

 

[Timothy Truckle]

Mir ist nicht klar was er dann tun soll... Vermutlich ne dumme Frage.

Da es keine Dummen Fragen gibt frage ich mal zurück:
Was erwartest Du von einer Methode mit diesem Namen:

int getExecutableIndex()

?

bye
TT

 

[f4814n]

Sie gibt den Index des Arrays zurück, das "mit den gegebenen Kapazitäten klarkommt".

Was mir nicht klar ist, ist wie man dieses problem löst:

"vergleiche das dreierarray so lange bis es false wird und geh dann weiter" - das kann ich nicht in java übersetzten.

while(a<=currentlyAvailableResources){

was sol er denn machen solange? return true?
}

oder ne dritte for schleife?


VIELEN DANK für die schnelle Antwort!! Ist ja großartiog wie das hier funktioniert

 

[Timothy Truckle]

was sol er denn machen solange? return true?

Bitte nachdenken, return (egal was danach kommt) verlässt die Methode. kann das hier gewünscht sein?

oder ne dritte for schleife?

nein, Du iterierst ja schon über die 3-erArrays und zwar schon im 2.

for

...
wer hat denn das

while

dort eingefügt? Da müsste IMHO eine andere Anweisung stehen.

Also ich würde den Ausdruck im

while

negieren (ind die andere Anweisung verwenden).
Ich hätte eine Variable vom Typ boolean, die vor dem innern

for

auf

true

und an der Stelle des Kommentars (nach den Änderungen am

while

) auf

false

gesetzt wird. Wenn diese Variable nach den inneren

for

immer noch true ist kannst Du die Methode mit dem aktuellen Index des 3-er Arrays verlassen.

Anstelle der Boolenvariable könnte man auch mit einem Label und

break

arbeiten, dass hat aber ein "Geschmäckle"... Ich rate davon ab, schon deshalb, weil sich dann die innere Schleife nicht mehr in eine eigene Methode auslagern ließe (was man aber tun sollte...)

bye
TT

 

[f4814n]

public class ProcessCheckerImpl implements ProcessChecker {

	int[] currentlyAvailableResources;

	public ProcessCheckerImpl(int[] currentlyAvailableResources) {
		this.currentlyAvailableResources = currentlyAvailableResources;
	}

	public int getExecutableIndex(ArrayList<int[]> processList) {
		int zaehler = 0;
		
		for (int[] a : processList) {
			zaehler++;
                        boolean gleich = true;
			for (int j = 0; j < a.length; j++) {

				if (a[j] > currentlyAvailableResources[j]) {

					gleich = false;

				} else

					return zaehler;
			}
		}

		return -1;
	}

die Deklaration der "gleich" Variable ist gelb unterstrichen was ich nicht ganz verstehe.ich glaube es fehlt ein befehl, der ihn weiterschickt zum nächsten processList nachdem gleich auf false gesetzt wurde... Ich hoffe Du/Ihr könnt nachvollziehen was ich mir gedacht habe und vor allem was ich so falsches gedacht habe ;-) Der erste Testfall wird jetzt grün allerdings nur weil da das erste Array direkt passt. Was mich noch interessieren würde: kann man die for each schleife auch in einer "normalen" for-schleife umsetzten? nur für mien Verständnis... DANKE

 

[f4814n]

public class ProcessCheckerImpl implements ProcessChecker {

	int[] currentlyAvailableResources;

	public ProcessCheckerImpl(int[] currentlyAvailableResources) {
		this.currentlyAvailableResources = currentlyAvailableResources;
	}

	public int getExecutableIndex(ArrayList<int[]> processList) {
		int zaehler = 0;
		
		for (int[] a : processList) {
			zaehler++;
			boolean gleich = true;
			for (int j = 0; j < a.length; j++) {

				if (a[j] > currentlyAvailableResources[j]) {

					gleich = false;

				} 
			}

				return zaehler;
		}

		return -1;
	}

Was ich aber noch nicht ganz verstehe ist warum

 boolean gleich = true;

"dead code" sein soll...!?
Werde gleich den nächsten Thread mit einer neuen Aufgabe veröffentlichen. gibt noch viele Fragen. Super Hilfe hier!!!

 

[pro2]

Alle Tests wurden grün!!! Super, vielen Dank für deine Denkanstöße, das war mein Durchbruch ;-)
Was ich aber noch nicht ganz verstehe ist warum

 boolean gleich = true;

"dead code" sein soll...!?

Na, was machst du denn mit der Variable? Verwendest du sie irgendwo für? Gibst du sie irgendwo aus? Hilft sie einer deiner Schleifen?

 

[f4814n]

	public int getExecutableIndex(ArrayList<int[]> processList) {
		int zaehler = 0;

		for (int[] a : processList) {
			zaehler++;

			for (int j = 0; j < a.length; j++) {

				if (a[j] > currentlyAvailableResources[j]) {

				}
			}

			return zaehler;
		}

		return -1;
	}

Es funktioniert tatsächlich auch mit einer leeren if Anweisung... alle tests werden grün. Ist das sauber programmiert?! Auf die Idee, die {}-Klammern leer zu lassen wär ich niemals gekommen...


ES WERDEN NATÜRLICH NICHT ALLE TESTS GRÜN. NACH WIE VOR NUR DER ERSTE!!

 

[f4814n]

Halt!! Falscher Alarm. Ich Idiot. Sorry. Ich hab nur auf den ersten Test getestet deshalb wurde es grün. Aber es funktioniert natürlich nicht. Sorry!!!!

Also, oben ist mein letzter Stand! Und das sind die Testfälle von denen nur der erste durchläuft. Sorry für die Verwirrung ich bin echt unerfahren...

Testfälle

public class ProcessCheckerTest {
		
	@Test
	public void testExecutable1() {
		int[] curAvailRes = {3,3,2};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{1,2,3});
		processList.add(new int[]{1,2,0}); // executable
		processList.add(new int[]{3,4,2});
		processList.add(new int[]{1,1,1}); // executable
		int index = pc.getExecutableIndex(processList);
		assertEquals(1, index);
	}
	
	@Test
	public void testExecutable2() {
		int[] curAvailRes = {5};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{7});
		processList.add(new int[]{6});
		processList.add(new int[]{4}); // executable
		processList.add(new int[]{4}); // executable
		processList.add(new int[]{4}); // executable
		processList.add(new int[]{4}); // executable
		processList.add(new int[]{4}); // executable		
		int index = pc.getExecutableIndex(processList);
		assertEquals(2, index);
	}
	
	@Test
	public void testExecutable3() {
		int[] curAvailRes = {1,1,1,1,1,1,1,1,1,1,1};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{1,2,1,1,1,1,1,1,1,1,1});
		processList.add(new int[]{1,1,1,1,4,1,1,1,1,1,1});
		processList.add(new int[]{1,1,1,1,1,1,1,1,1,5,1});
		processList.add(new int[]{1,1,1,1,1,1,1,1,1,1,1}); // executable
		int index = pc.getExecutableIndex(processList);
		assertEquals(3, index);
	}
	
	
	@Test
	public void testExecutable4() {
		int[] curAvailRes = {3,3,2,4};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{3,2,1,0});  // executable
		processList.add(new int[]{3,2,1,0});  // executable
		processList.add(new int[]{3,2,1,0});  // executable
		processList.add(new int[]{3,2,1,0});  // executable
		processList.add(new int[]{3,2,1,0});  // executable
		int index = pc.getExecutableIndex(processList);
		assertEquals(0, index);
	}
	
	@Test
	public void testNotExecutable1() {
		int[] curAvailRes = {7,6,7,6};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{8,1,1,1}); 
		processList.add(new int[]{1,8,8,8});
		processList.add(new int[]{1,1,1,8}); 
		processList.add(new int[]{6,7,6,7}); 
		processList.add(new int[]{10000,10000,1000,1000}); 
		int index = pc.getExecutableIndex(processList);
		assertEquals(-1, index);
	}	
	
	@Test
	public void testNotExecutable2() {
		int[] curAvailRes = {3,3,2,4};
		ProcessCheckerImpl pc = new ProcessCheckerImpl(curAvailRes);
		ArrayList<int[]> processList = new ArrayList<int[]>();
		processList.add(new int[]{100,2,1,0}); 
		processList.add(new int[]{100,1,1,1}); 
		processList.add(new int[]{100,2,1,0});  
		processList.add(new int[]{3,2,1,100}); 
		processList.add(new int[]{3,2,1,100});  
		int index = pc.getExecutableIndex(processList);
		assertEquals(-1, index);
	}	
	

}