Zählen gleiche Werte in Array

[Ganzir]

Hallo,

wie kann ich in einem Array die Elemente zählen die identisch sind.

Mal angenommen ich habe folgenden Array:

		 int[][] zahlen = 
		 {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};

Was muss ich nun tun, damit ich die folgende Ausgabe erhalte:

11 = 1 mal
17= 1 mal
34 = 5 mal

usw.

Mit ist die enum-funktion bekannt, jedoch musste ich feststellen, dass ich in enum keine Zahlen verwenden kann.


Greetz
Ganzir

 

[hdi]

Kann man sicher schöner machen, ich habs jetzt runtergeschrieben, aber es müsste korrekt sein.
Beachte aber bitte unbedingt folgendes: Das ganze funktioniert jetzt nur, wenn dein gegebenes Array
keine Nullen enthält. Denn Standardmässig ist unser Hilfs-Array mit nullen befüllt. Wenn du Nullen hast,
initialisier das count-Array mit -1 oder sowas. Wenn du auch negative Zahlen hast, und den Wertebereich
nicht kennst, kannst du das so leider nicht mehr lösen...

public class ArrayZaehler {

	public static void main(String[] args) {

		int[][] zahlen = { { 34, 255, 255 }, { 127, 204, 11, 34 },
				{ 123, 98, 127, 34 }, { 34, 34, 127, 17 } };
		zaehle(zahlen);
	}

	private static void zaehle(int[][] array) {

       // Wir erstellen uns ein 2d-Hifsarray, dass paarweise die Zahl und die Anzahl ihrer Vorkommen enthält.
       // Es kann nicht länger sein als die Anzahl der Elemente im gegebenen Array (dann würde jedes Element
       // genau 1x vorkommen.)

		int maxLen = 0;
		for (int i = 0; i < array.length; i++) {
			maxLen += array[i].length;
		}
		int[][] count = new int[maxLen][2]; // paarweise Zahl<->ihre Anzahl
		int numFilled = 0;

		// diese schleife geht die blöcke durch, also {..}, {..}
		for (int i = 0; i < array.length; i++) {
			// diese schleife durchsucht die einzelnen blöcke
			for (int j = 0; j < array[i].length; j++) {
				// momentanes element speichern:
				int current = array[i][j];
				// nachsehen, ob es das schon im hilfsarray gibt:
				boolean found = false;
				for (int k = 0; k < count.length; k++) {

					if (current == count[k][0]) {
						// Zahl schon gefunden, ihren counter erhöhen:
						count[k][1] = count[k][1] + 1;
						// und aufhören, weiter zu suchen:
						found = true;
						break;
					}

				}
				// schleife wurde komplett durchsucht, und nix gefunden:
				if (!found) {
					// Zahl gibt es noch nicht, einfügen:
					count[numFilled][0] = current;
					count[numFilled][1] = 1;
					numFilled++;
				}
			}
		}

		// Fertig, das kann man jetz formatiert ausgeben:
		for (int i = 0; i < count.length; i++) {
			if (count[i][0] != 0) { // bzw. != dein Initial-Wert
				System.out.println("Zahl " + count[i][0] + " kommt "
						+ count[i][1] + " mal vor.");
			}
		}
	}
}

 

[Ganzir]

Hallo hdi,

das ist sehr nett was du da geschrieben hast, es funktioniert auch, jedoch bin ich absoluter Anfänger und hatte mir eine etwas plumpere Methode ausgedaucht:

public static void main (String args[])
	 {   

		 int z_11 = 0;
		 
		 int[][] zahl = 
		 {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};
	 
		 
		 for (int i = 0; i < zahl.length; i++)
		 {
			 for (int j = 0; j < zahl[0].length; j++)

				 System.out.print(zahl[i][j] + "\t");
			 System.out.println();
			 int current = zahl[i][j]; //<-  An dieser Stelle sagt er mit er kann j nicht resolven - kannst du mir sagen wieso? bei dir klappt da doch auch int current = array[i][j]; 
			
			 }

		 }
	
	 }

 

[Marco13]

Es fehlt noch die { für die innere for-Schleife.

Nochmal eine Lösugn, die man verwenden kann, wenn das ganze nicht ausführungs- sondern Entwicklungszeitritisch ist:

import java.util.*;

class ArrayCount
{
    public static void main(String args[])
    {
        int[][] a = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};
        count(a);
    }

    private static void count(int a[][])
    {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i=0; i<a.length; i++)
        {
            for (int j=0; j<a[i].length; j++)
            {
                map.put(a[i][j], map.containsKey(a[i][j])?map.get(a[i][j])+1:1);
            }
        }
        for (Integer k : map.keySet())
        {
            System.out.println(k+": "+map.get(k)+" times");
        }
    }


}

 

[hdi]

Jo, und so macht man es schön Ich hatte mir auch erst gedacht ich sollte ne Map nehmen, aber dachte dann das is genauso kompliziert. Diese Zeile:

map.put(a[i][j], map.containsKey(a[i][j])?map.get(a[i][j])+1:1);

hat es in sich^^ Das so zu machen kommt einem auch nur, wenn man die Map-Methoden im Kopf hat alle xD

 

[Marco13]

Naja - erst hatte ich sie als

if (!map.containsKey(a[i][j]))
{
    map.put(a[i][j], 0);
}
map.put(a[i][j], map.get(a[i][j])+1);

was etwas übersichtlicher ist - optional dann auch

if (!map.containsKey(a[i][j]))
{
    map.put(a[i][j], 1);
}
else
{
    map.put(a[i][j], map.get(a[i][j])+1);
}

aber ... ich glaube, sie wirkt nur durch die arrayzugriffe so kompliziert:

map.put(n, map.containsKey(n)?map.get(n)+1:1);

ist doch auch hübsch....