Java-Code

package zweiDArray;

public class twoDimArray {		
	private int size;	
	private int[][] container;	
	private int[] beginings;	
	private int[] initOffset;
	
	/**
	 * Die Strategie:
	 * Als erstes werden die Anfangselemente jeder Spalte bestimmt und eingetragen.
	 * Von einer Spalte zur nächsten gibt es einen Offset der sich von Spalte zu Spalte um 1 erhöht.
	 * Der Initiale Spalten-Offset ist immer so hoch wie Spaltennummer +1.
	 * Mit den gesammelten Werten kann nun das Array befüllt werden.
	 * Für die Suche kann einfach über das Array iteriert werden.
	 */


	public twoDimArray(int maxNodes){
		this.size = getSize(maxNodes);
		
		this.container  = new int[this.size][];
		for(int i = 0; i < this.size; i++){
			this.container[i] = new int[this.size-i];
		}
		
		 this.beginings= new int[size];
		 beginings = getBeginings(size);
		 
		  this.initOffset = getInitOffset(size);
		  
		  fullFillContainer();
	}
	
	public void getPos(int value){
		// Die äußere Schleife iteriert über die Zeilen ...
		for(int row = 0; row < this.container.length; row++){
			//... und die innere über die Spalten.
			for(int collum = 0; collum < this.container[row].length; collum++){
				if(container[row][collum] == value){
					// Wurde der richtige Wert gefunden, brauchen die Zähler der Schleifen nur noch ausgegeben zu werden.
					System.out.println("Position von " + value + " = (" + row + ":" + collum + ")");
				}
			}
		}			
	}

	public void print(){
		for(int[] row : this.container){
			for(int element : row){
				System.out.print(element + ", ");
			}
			System.out.print("\n");
		}
	}
	
	private void fullFillContainer(){
		int offset = 0;
		// Die Anfangswerte werden in die Zeilen-Arrays geschrieben.
		for(int i = 0; i < size; i++){
			 this.container[i][0] = this.beginings[i];
		}
		
		for(int row = 0; row < this.container.length; row++){
			// Der initiale Zeilen-Offset der atuellen Zeilen wird geholt.
			offset = this.initOffset[row];
			// Dann wird über die aktuelle Zeile Iteriert ...
			for(int element = 1; element < this.container[row].length; element++){
				//... und das aktuelle Feld aus vorherigem Feld und Offset berechnet.
				this.container[row][element] = this.container[row][element - 1] + offset;
				// Hat man ein Feld berechnet muss der Offset für das nächste Feld erhöt werden.
				offset++;
			}
		}
	}
	
	private int[] getInitOffset(int size){
		int[] initOffset = new int[size];
		// Der Initiale Spalten-Offset ist immer so hoch wie Spaltennummer +1.
		for(int k = 0; k < size; k++){
			initOffset[k] = k + 1;
		}
		return initOffset;
	}
	
	private int[] getBeginings(int size){
		int offset = 2;	// Das zweite element ist immer die 3.
		// Der Offset beginnt also bei 2.
		int zahl = 1;	// Das erste Element ist immer die 1.
		int[] beginings = new int[size];
		// Von einer Spalte zur nächsten gibt es einen Offset der sich von Spalte zu Spalte um 1 erhöht.
		for(int k = 0; k < beginings.length; k++){
			beginings[k] = zahl;
			zahl = zahl + offset;
			offset++;
		}
		return beginings;
	}
	
	private int getSize(int border){
		// Berechnet die Kantenlänge des Dreiecks.
		int size = 0;
		int sum = 0;
		// Jetzt wird die Gaußsche Summenformel bemüht, bis die Summe größer ist
		// als der Grenzwert für das Zahlendreieck.
		for(;sum < border;size++){
			sum += size;
		}
		// Die Anzahl der Iterationen -1 ist gleich der Kantenlänge.
		return size-1;
	}
}