Füllung von 2.Dim Arrays in Intervallen ?

[Raziel]

Hallo!
ich bin seit längerem an einer Aufgaben dran(uni) bei der ich eine Wahrheitstabelle (Aussagenlogik) erstellen soll.
Form:
Anzahl Variablen: z.b 4
A B C D
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1

Das Initialisieren des Arrays ist kein Problem auch das Befüllen geht spaltenweise von oben nach unten (links angefangen)
mir fällt nur nicht ein wie ich das ganze sinnvoll (abwechselnd) mit 1 und 0 füllen kann.
Ich wüste wie ich alle Spalten bis auf die Letzten 3 bei n beliebigen Variablen richtig füllen könnte z.b Variable A (bis zur hälfte 0 dann 1) jedoch funktioniert das ganze nicht bei Spalte 2 Variable B (C, D)
Bei den Spalten B C D müsste ich im wechsel 0 und 1 in die Schubladen des Arrays packen natürlich in unterschiedlichen Intervallen
B= 4er C=2er D=1er.
Nun zu meiner Frage gibt es eine Methode die bei übergebenem Parameter z.b 4 genau 4 mal 0 dann 4 mal 1( bis zum ende der spalte auch übergeben ) ausführt ?
Ich hoffe das ist hier richtig und ihr könnt mir Tipps geben das ganze zu realisieren auch wenn es keine Methode dafür gibt.
Vielen dank im Voraus.

 

[Marco13]

So direkt erstmal nicht. Natürlich könnte man sich da irgendwas basteln, aber ... ich finde es schon fragwürdig, ob man so einen Array wirklich spaltenweise füllen sollte (sofern das nicht explizit die Aufgabe war, um ein bißchen Array- und ggf. BitShift-Hantiererei zu lernen...)

 

[Raziel]

Ich habe mich wohl etwas schlecht ausgedruckt sry!
Nein, es ist nicht zwingend notwendig das Array Spaltenweise zu füllen würde natürlich auch Zeilenweise gehen. Jedoch dachte ich Spaltenweise wäre es leichter da ich dort direkt eine art Intervall zwischen
den auftauchenden 1 und 0 gesehen haben.
Zeilenweise wüste ich nicht nach welchem Muster 1 und 0 in die jeweiligen Schubladen kommen sollen.
Danke für die flotte Antwort!

 

[Crian]

Und mit vier Schleifen geht's nicht?

 

[Marco13]

Geht vielleicht auch mit 4 Schleifen... würde aber keinen Sinn machen.

Schau' dir vielleicht mal an, was Integer#toBinaryString(int) so ausgibt, wenn man ihm bestimmte Zahlen gibt. Und mit

if ((value & (1<<n)) != 0) { ... }

kann man prüfen, ob in 'value' ein bit an Stelle 'n' gesetzt ist.

 

[T7V]

Für dein Beispiel mit 4 Variablen müsste es so gehen (hab es jetzt aber nichtgetestet). Ist aber umständlich, da du die Intervale angeben musst.

int[][]t = new int[16][4];

for(int i; i <= 15; ++i){
  if (i <= 7) t[i][0] = 0;
  else t[i][0] = 1;
}
for(int i; i <= 15; ++i){
  if (i <= 3 || (i>=8 && i<=11)) t[i][1] = 0;
  else t[i][1] = 1
}
for(int i; i <= 15; ++i){
  if (i <= 3 || (i>=8 && i<=11)) t[i][1] = 0;
  else t[i][1] = 1
}
for(int i; i <= 15; ++i){
  if (i <= 1 || (i>=4 && i<=5) || (i>=8 && i<=9)|| (i>=12 && i<=13)) t[i][2] = 0;
  else t[i][2] = 1;
}
for(int i; i <= 15; ++i){
  if (i % 2 ==0) t[i][3] = 0;
  else t[i][3] = 1;
}

Du könntest es auch nur mit modulo machen:

for(int i; i <= 15; ++i){
  if (i % 4 ==0||i % 4 == 1) t[i][2] = 0;  //3.Spalte
  else t[i][2] = 1;
}

 

[Marco13]

import java.util.*;

class BinaryTest
{
    public static void main(String args[])
    {
        int array[][] = new int[16][4];
        fill(array);
        for (int r=0; r<array.length; r++)
        {
            System.out.println(Arrays.toString(array[r]));
        }
    }

    private static void fill(int array[][])
    {
        int cols = array[0].length;
        for (int c=0; c<cols; c++)
        {
            fillCol(array, c);
        }
    }

    private static void fillCol(int array[][], int col)
    {
        int rows = array.length;
        int cols = array[0].length;
        int index = cols-col-1;
        int div = (1<<index);
        for (int r=0; r<rows; r++)
        {
            array[r][col] = (r / div) % 2;
        }
    }


}

@T7V: Wenn du dein Programm auf [32][5] oder [64][6] erweiterst, mach' ich das mit meinem auch 😀

@Raziel: Der gepostete Code ist für den Fall, dass man das Spaltenweise machen will. Zeilenweise fände ich intuitiver: Man schreibt in jede Zeile die Binärrepräsentation der Zahl...

 

[Raziel]

Vielen Danke für die schnellen Antworten.
Die Modulolösung gefällt mir sehr gut. Danke T7V
Ihr habt mir sehr viel verraten danke!
Ich werde das ganze nicht Spaltenweise füllen.
@ Marco danke für die Idee mit dem Integer.toBinaryString(int)
du hast definitiv recht das Zeilenweise wohl intuitiver ist nur kam mir die Idee mit der
Binärpressentation nicht. Ich probier das ganze morgen Zeilenweise. Zeit fürs Bett.
Ich bedank mich noch mal bei allen ! Danke.

 

[Marco13]

Nun, ich meinte nicht, dass man Integer#toBinaryString direkt dafür verwenden sollte (obwohl das gehen würde), sondern dass das intern praktisch das gleiche macht: Schauen, an welcher stelle der Binaärrepräsentation eine 1 oder eine 0 steht.

 

[T7V]

Ich habe jetzt eine Methode für dein Problem entwickelt.
Also eine die für n Variablen eine Wahrheitstabelle liefert. Ich kann sie, falls du noch Interesse hast, frühestens um halb drei Posten, weil ich jetzt nicht an meinem PC sitze

 

[T7V]

@T7V: Wenn du dein Programm auf [32][5] oder [64][6] erweiterst, mach' ich das mit meinem auch 😀

Jetzt musst du auch auf n Variablen erweitern.

Edit: Mist, zu viel gelöscht. Verdammtes Handy-Touchscreen... // Korrigiert

 

[T7V]

Ging doch schon früher. 😉

public int hochN(int x) {       // Methode berechnet 2^x ; x = Anzahl der Variablen
    int counter = 0;
    int result = 1;

    while (counter < x) {
      result = result * 2;
      counter++;
    }
    return result;

  }

  public int[][] fill(int x){                       //erstellt und füllt ein Array a ; x = Anzahl der Variablen
    int[][]a=new int [hochN(x)][x];
    int g= hochN(x);
    int y = g;
    int h = 0;  //SpaltenIndex

    while(h < x){
      for(int b=0; b < g; b++){
        if ((b % y) < (g/hochN(h+1)) ) a[b][h] =1;
        else a[b][h] =0;
      }
      y = hochN(x-(h+1));
      ++h;
    }
    return a;
  }

Ich hab es getestet, sollte also eigentlich gut funktionieren. Sagt Bescheid falls ihr noch einen Fehler findet.

@Marco13 Ich glaube dein System auf n Variablen erweitert wird, falls es überhaupt geht, länger werden.😉

 

[Marco13]

Wenn das ein Wettbewerb sein soll, müßte man erstmal wissen, worum es geht? ???:L :bahnhof: 😉

import java.util.*;

class BinaryTest2
{
    public static void main(String args[])
    {
        int array[][] = fill(4);
        for (int r=0; r<array.length; r++)
        {
            System.out.println(Arrays.toString(array[r]));
        }
    }

    private static int[][] fill(int n)
    {
        int m = 1<<n;
        int a[][] = new int[m][n];
        for (int r=0; r<m; r++)
            for (int c=0; c<n; c++)
                a[r][c] = ((r & (1<<(n-1-c))) == 0) ? 0 : 1;
        return a;
    }

}

Wenn es um Effizienz geht (oder genauer: Wenn es um irgendwas anderes geht, als darum, das Programm komplizierter zu schreiben, als es sein müßte) :
int a = hochN(n);
<=>
int a = (1<<n);
(für den allgemeinen Fall: Binäre Exponentiation ? Wikipedia )

EDIT: Vereinfachung - und wieder zurück 🙂 Man könnte es noch einfacher schreiben, aber... soo wichtig ist das jetzt ja auch nicht ... 😉

 

[T7V]

Natürlich kein Wettbewerb,meinte das nur deswegen:

@T7V: Wenn du dein Programm auf [32][5] oder [64][6] erweiterst, mach' ich das mit meinem auch

 

[Raziel]

Hallo,
danke für die Hilfe noch mal.
Das Programm funktioniert nun wunderbar bis 21 Variablen.
Ich setze es am Montag mal rein (nach dem Testat)
Wir sollten laut Aufgabenstellung auch die Zeit für das Initialisieren des Arrays messen.
Bei 21 Variablen dauert die Initialisierung 2,3 Sekunden.

LG
Razi🙂

 

[Marco13]

Also DOCH ein Wettbewerb :hihi: 😉