Java-Code

package TrainYourProgrammer;

import java.util.Scanner;

public class Aufgabe191
{		
	private static int[][] create()
	{
		int [][] array = new int[10][10];
		int start=1;
		int field=1;
		int counter_1 = 1;
		int counter_2 = 2;
		int t_counter = 1;
		for(int y=0; y<10; y++)
		{
			for(int x=0; x<10; x++)
			{
				array[y][x] = field;
				field += counter_1;
				counter_1++;
			}
			start += counter_2;
			field = start;
			t_counter++;
			counter_2++;
			counter_1 = t_counter;
		}
		return array;
	}
	
	private static int checker(int[][] array)
	{
		Scanner sc = new Scanner(System.in);
		System.out.println("Zeile");
		int zeile = sc.nextInt();
		System.out.println("Spalte");
		int spalte = sc.nextInt();
		sc.close();
		int ausgabe = array[zeile][spalte];
		return ausgabe;
	}
	
	public static void main(String[] args)
	{
		int[][] array = create();
		int ausgabe = checker(array);
		System.out.println("Zahl lautet: " + ausgabe);
	}
}

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;
	}
}

Java-Code

package übung191;

import java.util.Scanner;

public class Program {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int z = 0;
		int Zeile = 0; 
		int Spalte = 0;
		boolean ergebnis = false;
		
		//Frage mit eingabe in der Console
		System.out.println("Wie groß soll das 2D-Array sein?");
		System.out.println("wv Zeilen:");
		int y = sc.nextInt();
		System.out.println("wv Spalten:");
		int x = sc.nextInt();
		int[][] array = new int[y][x];
		
		
		//Array mit Zahlen wird erstellt
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				//(0/0)
				if (i == 0 && j == 0) {
					array[i][j] = j + 1;
				}
				//Erste Reihe
				if (i == 0 && j != 0) {
					array[i][j] = ++z + array[i][(j - 1)];
					z = array[i][j] - array[i][(j - 1)];
				}
				//letzte Spalte
				if (i != 0 && j == (x - 1)) {
					array[i][j] = (array[i][(j - 1)] - array[i][(j - 2)]) + array[i][(j - 1)];
				}
				//Rest
				if (i != 0 && j != (x - 1)) {
					array[i][j] = array[(i - 1)][(j + 1)] + 1;
				}		
			}	
		}
		
		
		//Eingabe welche Zahl der User wissen möchte
		System.out.println("Welche Zahl suchst du?");
		int eingabe = sc.nextInt();
		
		
		//Suche der Zahl und ob sie überhaupt im Array ist
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				if (eingabe == array[i][j]) {
					ergebnis = true;
					Zeile = i;
					Spalte = j;
				}
			}
		}
		
		
		//Ausgabe des Ergebnis
		if (ergebnis == true) {
			System.out.println("*********************");
			System.out.println("Deine Zahl " + eingabe + " ist in:");
			System.out.println("Zeile: " + Zeile + " - Spalte: " + Spalte);
		} else {
			System.out.println("Deine Zahl ist leider nicht im array");
		}
		
		
		//Für manuelle überprüfung - Tabelle wird ausgegeben falls gewünscht
		System.out.println("*********************");
		System.out.println("Möchtest du die Tabelle manuel überprüfen? ja(j) - nein(n)");
		String manuell = sc.next();
		if (manuell.equals("j")) {
			for (int i = 0; i < array.length; i++) {
				for (int j = 0; j < array[i].length; j++) {
					System.out.print(array[i][j] + " ");
				}
				System.out.println();
			}
		} else {
			System.out.println("(n) oder Falsche eingabe - terminate");
		}
		
		
	}

}