Initialen mit Array wiedergeben

[millyrockk]

Hey Leute, ich weiß leider nicht wie ich das '+' wie hier in der im Bild ausgeben kann, bzw. mit meinen Initialen "MK" ausgeben lasse. Ich bin echt am verzweifeln. Hier ist mein bisheriger Code .

Vielen Dank euch schon mal im Voraus

import java.util.Scanner;
public class Initialen {
static Scanner sc = new Scanner (System.in);
  
public static void main(String[] args){
    char [][] feld = erstelleFeld ('m','k');
    for (int i = 0; i< feld.length;i++) {
        for (int j =0; j<feld[i].length;j++) {
            System.out.println (feld[i][j]);
          
        } System.out.println();// Platz machen
    }
  
    }
    public static char[][] erstelleFeld(char vorname, char nachname ) {
      
        System.out.println ("Bitte geben Sie n ein ");
        int n = sc.nextInt();
        char[][] buchstabe = new char [n][n];
      
        int höhe = n/2 ;
        int breite = n/4 ;
      
        for (int i=0;i< buchstabe.length;i++) {
            for (int j =0;j<buchstabe[i].length;j++) {
              
                buchstabe [i][j] = ' ';
                  
            }
          
        }    for (int i=0;i <höhe;i++) { 
              for (int j = 0;j<breite;j++) {
                 buchstabe [2+i][1] = '+'; // Für Buchstaben
                
              
              
              }
          
        } return buchstabe;
    } 
}

 

[mihe7]

Naja, Du brauchst halt einen Bereich, in dem Du die "Bildpunkte" der Buchstaben definierst und von wo aus Du die Bildpunkte dann kopieren kannst.

Nehmen wir mal an, Du möchtest Zeichen der Größe 5x6 haben. Dann kannst Du jede Zeile mit 5 Bits darstellen und brauchst 6 davon. Damit würde ein 32-Bit-int je Zeichen locker reichen. Einfacher dürfte es für Dich sein, wenn Du jeden Bildpunkt durch ein boolean in einem 2D-Array darstellst.

Aber, weils gerade Spaß macht, kann man das Bit-Gedöns ja mal zeigen. Das wären die Bit-Indizes:

0​	1​	2​	3​	4​
5​	6​	7​	8​	9​
10​	11​	12​	13​	14​
15​	16​	17​	18​	19​
20​	21​	22​	23​	24​
25​	26​	27​	28​	29​

Ein M "gezeichnet":

1​	0​	0​	0​	1​
1​	1​	0​	1​	1​
1​	0​	1​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​

ergibt dann, wenn man Bit 29 bis Bit 0 der Reihe nach (also von unten rechts nach oben links) runterschreibt: 10 0011 0001 1000 1101 0111 0111 0001 (binär) oder 0x2318D771 (hex)

Jetzt brauchen wir noch ein K (in der Darstellung nur mal die gesetzten Bits)

	*​	​	​	*​
​	*​	​	*​	​
​	*​	*​	​	​
​	*​	*​	​	​
​	*​	​	*​	​
​	*​	​	​	*​

10 0100 1010 0011 0001 1001 0101 0010 = 0x24A31952

Test:

public class Test {
    static final int CHAR_HEIGHT = 6;
    static final int CHAR_WIDTH = 5;

    static int[] alphabet = { // A-Z
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0x24a31952, 0, 0x2318d771, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

    public static void main(String[] args) {
        printChars("MK".toCharArray());
    }

    private static void printChars(char[] chars) {
        StringBuilder b = new StringBuilder();
        for (int row = 0; row < CHAR_HEIGHT; row++) {
            for (char ch : chars) {
                int symbol = alphabet[ch - 'A'];
                for (int col = 0; col < CHAR_WIDTH; col++) {
                    int mask = 1 << (CHAR_WIDTH*row + col);
                    b.append((symbol & mask) == 0 ? ' ' : '+');
                }
                b.append("  ");
            }
            b.append("\n");
        }
        System.out.println(b.toString());
    }
}

Das Programm liefert dann

+   +   +  +  
++ ++   + +   
+ + +   ++    
+   +   ++    
+   +   + +   
+   +   +  +

Die Lösung mit dem 2D-Array überlasse ich Dir

 

[millyrockk]

Naja, Du brauchst halt einen Bereich, in dem Du die "Bildpunkte" der Buchstaben definierst und von wo aus Du die Bildpunkte dann kopieren kannst.

Nehmen wir mal an, Du möchtest Zeichen der Größe 5x6 haben. Dann kannst Du jede Zeile mit 5 Bits darstellen und brauchst 6 davon. Damit würde ein 32-Bit-int je Zeichen locker reichen. Einfacher dürfte es für Dich sein, wenn Du jeden Bildpunkt durch ein boolean in einem 2D-Array darstellst.

Aber, weils gerade Spaß macht, kann man das Bit-Gedöns ja mal zeigen. Das wären die Bit-Indizes:

0​	1​	2​	3​	4​
5​	6​	7​	8​	9​
10​	11​	12​	13​	14​
15​	16​	17​	18​	19​
20​	21​	22​	23​	24​
25​	26​	27​	28​	29​

Ein M "gezeichnet":

1​	0​	0​	0​	1​
1​	1​	0​	1​	1​
1​	0​	1​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​

ergibt dann, wenn man Bit 29 bis Bit 0 der Reihe nach (also von unten rechts nach oben links) runterschreibt: 10 0011 0001 1000 1101 0111 0111 0001 (binär) oder 0x2318D771 (hex)

Jetzt brauchen wir noch ein K (in der Darstellung nur mal die gesetzten Bits)

	*​	​	​	*​
​	*​	​	*​	​
​	*​	*​	​	​
​	*​	*​	​	​
​	*​	​	*​	​
​	*​	​	​	*​

10 0100 1010 0011 0001 1001 0101 0010 = 0x24A31952

Test:

public class Test {
    static final int CHAR_HEIGHT = 6;
    static final int CHAR_WIDTH = 5;

    static int[] alphabet = { // A-Z
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0x24a31952, 0, 0x2318d771, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

    public static void main(String[] args) {
        printChars("MK".toCharArray());
    }

    private static void printChars(char[] chars) {
        StringBuilder b = new StringBuilder();
        for (int row = 0; row < CHAR_HEIGHT; row++) {
            for (char ch : chars) {
                int symbol = alphabet[ch - 'A'];
                for (int col = 0; col < CHAR_WIDTH; col++) {
                    int mask = 1 << (CHAR_WIDTH*row + col);
                    b.append((symbol & mask) == 0 ? ' ' : '+');
                }
                b.append("  ");
            }
            b.append("\n");
        }
        System.out.println(b.toString());
    }
}

Das Programm liefert dann

+   +   +  + 
++ ++   + +  
+ + +   ++   
+   +   ++   
+   +   + +  
+   +   +  +

Die Lösung mit dem 2D-Array überlasse ich Dir

Vielen Dank!

 

[millyrockk]

Naja, Du brauchst halt einen Bereich, in dem Du die "Bildpunkte" der Buchstaben definierst und von wo aus Du die Bildpunkte dann kopieren kannst.

Nehmen wir mal an, Du möchtest Zeichen der Größe 5x6 haben. Dann kannst Du jede Zeile mit 5 Bits darstellen und brauchst 6 davon. Damit würde ein 32-Bit-int je Zeichen locker reichen. Einfacher dürfte es für Dich sein, wenn Du jeden Bildpunkt durch ein boolean in einem 2D-Array darstellst.

Aber, weils gerade Spaß macht, kann man das Bit-Gedöns ja mal zeigen. Das wären die Bit-Indizes:

0​	1​	2​	3​	4​
5​	6​	7​	8​	9​
10​	11​	12​	13​	14​
15​	16​	17​	18​	19​
20​	21​	22​	23​	24​
25​	26​	27​	28​	29​

Ein M "gezeichnet":

1​	0​	0​	0​	1​
1​	1​	0​	1​	1​
1​	0​	1​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​
1​	0​	0​	0​	1​

ergibt dann, wenn man Bit 29 bis Bit 0 der Reihe nach (also von unten rechts nach oben links) runterschreibt: 10 0011 0001 1000 1101 0111 0111 0001 (binär) oder 0x2318D771 (hex)

Jetzt brauchen wir noch ein K (in der Darstellung nur mal die gesetzten Bits)

	*​	​	​	*​
​	*​	​	*​	​
​	*​	*​	​	​
​	*​	*​	​	​
​	*​	​	*​	​
​	*​	​	​	*​

10 0100 1010 0011 0001 1001 0101 0010 = 0x24A31952

Test:

public class Test {
    static final int CHAR_HEIGHT = 6;
    static final int CHAR_WIDTH = 5;

    static int[] alphabet = { // A-Z
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0x24a31952, 0, 0x2318d771, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

    public static void main(String[] args) {
        printChars("MK".toCharArray());
    }

    private static void printChars(char[] chars) {
        StringBuilder b = new StringBuilder();
        for (int row = 0; row < CHAR_HEIGHT; row++) {
            for (char ch : chars) {
                int symbol = alphabet[ch - 'A'];
                for (int col = 0; col < CHAR_WIDTH; col++) {
                    int mask = 1 << (CHAR_WIDTH*row + col);
                    b.append((symbol & mask) == 0 ? ' ' : '+');
                }
                b.append("  ");
            }
            b.append("\n");
        }
        System.out.println(b.toString());
    }
}

Das Programm liefert dann

+   +   +  + 
++ ++   + +  
+ + +   ++   
+   +   ++   
+   +   + +  
+   +   +  +

Die Lösung mit dem 2D-Array überlasse ich Dir

Vielen Dank!