Map anlegen und verwalten

A

andreas2505

Bekanntes Mitglied
Hallo,

ich möchte gerne eine Map anlegen, in der verschiedenen String Werten eine Bitfolge zugeordnet wird, also z.B. "A" --> 0000,
"a" --> 1111, usw.
Weiterhin will ich dann von verschiedenen String Werten den richtigen Wert aus der Map auslesen.
Was für eine Map soll ich dafür nehmen. Wie erstelle ich so eine Map, also welchen Befehl und wie tue ich die Elemente alle da rein und wie kann ich sie dann wieder auslesen?
 
A

andreas2505

Bekanntes Mitglied
ok, aber so richtig findet man da trotzdem nix.

Ich möchte eine Map erstellen, in der ich einem String einen int[] zuweise. Ist das möglich?

Hab mal das geschrieben, aber das funzt nicht.

Java: 
Map<String, int[]> alphabet = new HashMap<String, int[]>();

kommt die Fehlermeldung: type HashMap does not take parameters

Warum?

Das hinzufügen von Elementen geht dann mit dem put Befehl oder.
 
S

SlaterB

Gast
die Fehlermeldung klingt entweder danach dass Generics generell nicht geht,
schon mit irgendwas anderen wie ArrayList<String> probiert?

oder dass du zufällig eine eigene Klasse HashMap ohne generischen Parameter definiert hast

type Map does not take parameters ?

--------

notfalls geht es erstmal auch ohne Generics, put ist dann ein guter Befehl, richtig,

wie das Lehrbuch verwirren kann kann ich wiederum nicht nachvollziehen,
im aller ersten Code-Beispiel Listing 13.19 nach kaum 10 Zeilen verständlichen Text wird schon auf die put-Methode hingewiesen
 
Dit_

Dit_

Bekanntes Mitglied
Vielleicht mal mit einer hübschen HüllKlasse?

Java: 
public class BitString {
    
    private static final int BITS = 4;
    private int[]            _bitString;
    
    public BitString() {
        setBitString(new int[BITS]);
    }
    
    /**
     * Vorsicht.
     * @param bits
     */
    public BitString(int...bits){
        setBitString(bits);
    }
    
    /**
     * @param bitString
     *            the bitString to set
     */
    public void setBitString(int... bitString) {
        if (bitString.length == BITS) {
            this._bitString = bitString;
        } else {
            // TODO
        }
    }
    
    /**
     * @return the bitString
     */
    public int[] getBitString() {
        return _bitString;
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(int i : _bitString){
            sb.append(i);
        }
        
        return sb.toString();
    }
}

Main
Java: 
  public static void main(String[] args) {
        Map<String, BitString> map = new HashMap<String, BitString>();
        
        map.put("A", new BitString(0,0,0,0));
        
        System.out.println(map.get("A")); // out: 0000
       
    }
 
Zuletzt bearbeitet:
A

andreas2505

Bekanntes Mitglied
das sieht eigentlich ganz gut aus.

Schöne Idee. Das sind dann aber in dem Sinne schon int[] wenn ich die auslese, weil ich muss mit den BitStrings dann als int[] abeiten. Oder wie kann ich das dann wieder in so eins umwandeln.

Wäre auch schön wenn du nochmal erklären könntest, was genau die ganze Hüllklasse jetzt macht.
Warum sind da manchmal ... hinter int und so weiter. Kann ich das so komplett übernehmen oder muss ich da was ändern.

Und irgendwie verstehe ich auch die setBitString Methode nicht, warum steht da nix in der else anweisung?
 
Zuletzt bearbeitet:
Dit_

Dit_

Bekanntes Mitglied
ok

int... ist das gleiche wie int[] mit unterschied das du beim Aufruf der Methode die Werte einfach mit komma übergeben kannst.

Beispiel:

Variante: int...
Java: 
setBitString(0,1,1,1);
Variante: int[]

Java: 
setBitString(new int{0,1,1,1});

ich benutze öfters mal int... kannst alle int... durch int[] ersetzen.


Dies ist eine Hüllklasse, d.h. dein int Array hast du immer noch, du Speicherst Array in einer s.g. Verpackung.

du kannst zu jeder Zeit die Verpackung aus der HashMap hollen. mit
Code: 
getBitString()
bekommst du dann deine BitFolge als int[]

Code: 
getBitString()
liefert also keinen String, der Name ist bisschen ungünstig gewählt, aber BitString ist nun mal "BitFolge" auf English :), du kannst auch gerne die Klasse in
Code: 
BitSet
und die methoden in
Code: 
setBitSet(int[] nSet) und getBitSet()
umbenennen.

zu else:

Es bleibt dir überlassen, was du machst, wenn jemand ein Array mit der Länge größer oder kleiner 4 übergibt.

Du könntest:
  1. Nichts machen, ignorieren
  2. Exception werfen
  3. Array einfach setzen, brauchst dann keine if-else abfrage.


Java: 
        Map<String, BitString> map = new HashMap<String, BitString>();
    	
        map.put("A", new BitString(0,0,0,0));
        BitString myBitString = map.get("A");
        int[] arrayAusDerHuellKlasse = myBitString.getBitString();
 
Zuletzt bearbeitet:
A

andreas2505

Bekanntes Mitglied
Hallo,

nach längerer Pause, habe ich mal weiter gemacht.

Ich habe jetzt die BitString Hüllklasse genommen, habe allerdings ein Problem:

Hier ein Ausschnitt aus meinem Programm:

Java: 
public static encryptedPair encrypt(String m, Polynom pubKey, NTRUparameter params) {
        int N = params.N;
        int q = params.q;
        int dr = params.dr;
        int p = params.p;
        
        encryptedPair ep = new encryptedPair();
        
        int l = m.length();
        char[] message = new char[l];
        BitString[] num = new BitString[l];
        int[][] numInt = new int[l][5];
        
        message = m.toCharArray();
       
        
        for (int i=0; i<l; i++) {
            int[] help = new int[5];
            num[i] = (BitString) alphabet.get(message[i]);
            help = num[i].getBitString();
        }

Das Problem lieget bei der for Schleife.

Wenn ich die Methode (ist hier nicht ganz vollständig dargestellt) aufrufe, kommt es in der Zeile mit help = .. zu einer NullpointerException. Das Problem muss aber in der BitString Klasse liegen. Zur weiteren Erläuterung: alphabet ist ein map, wie folgt:

static Map alphabet = BitString.createMap();

Java: 
public static Map createMap() {
        Map<String, BitString> map = new HashMap<String, BitString>();
        
        
        map.put(" ", new BitString(-1,-1,-1,-1,-1));
        map.put("0", new BitString(-1,-1,-1,-1,0));
        map.put("1", new BitString(-1,-1,-1,-1,1));
        map.put("2", new BitString(-1,-1,-1,0,-1));
        map.put("3", new BitString(-1,-1,-1,0,0));
        map.put("4", new BitString(-1,-1,-1,0,1));
        map.put("5", new BitString(-1,-1,-1,1,-1));
        map.put("6", new BitString(-1,-1,-1,1,0));
        map.put("7", new BitString(-1,-1,-1,1,1));
        map.put("8", new BitString(-1,-1,0,-1,-1));
        map.put("9", new BitString(-1,-1,0,-1,0));
        map.put("a", new BitString(-1,-1,0,-1,1));
        map.put("b", new BitString(-1,-1,0,0,-1));
        map.put("c", new BitString(-1,-1,0,0,0));
        map.put("d", new BitString(-1,-1,0,0,1));
        map.put("e", new BitString(-1,-1,0,1,-1));
        map.put("f", new BitString(-1,-1,0,1,0));
        map.put("g", new BitString(-1,-1,0,1,1));
        map.put("h", new BitString(-1,-1,1,-1,-1));
        map.put("i", new BitString(-1,-1,1,-1,0));
        map.put("j", new BitString(-1,-1,1,-1,1));
        map.put("k", new BitString(-1,-1,1,0,-1));
        map.put("l", new BitString(-1,-1,1,0,0));
        map.put("m", new BitString(-1,-1,1,0,1));
        map.put("n", new BitString(-1,-1,1,1,-1));
        map.put("o", new BitString(-1,-1,1,1,0));
        map.put("p", new BitString(-1,-1,1,1,1));
        map.put("q", new BitString(-1,0,-1,-1,-1));
        map.put("r", new BitString(-1,0,-1,-1,0));
        map.put("s", new BitString(-1,0,-1,-1,1));
        map.put("t", new BitString(-1,0,-1,0,-1));
        map.put("u", new BitString(-1,0,-1,0,0));
        map.put("v", new BitString(-1,0,-1,0,1));
        map.put("w", new BitString(-1,0,-1,1,-1));
        map.put("x", new BitString(-1,0,-1,1,0));
        map.put("y", new BitString(-1,0,-1,1,1));
        map.put("z", new BitString(-1,0,0,-1,-1));
        map.put("A", new BitString(-1,0,0,-1,0));
        map.put("B", new BitString(-1,0,0,-1,1));
        map.put("C", new BitString(-1,0,0,0,-1));
        map.put("D", new BitString(-1,0,0,0,0));
        map.put("E", new BitString(-1,0,0,0,1));
        map.put("F", new BitString(-1,0,0,1,-1));
        map.put("G", new BitString(-1,0,0,1,0));
        map.put("H", new BitString(-1,0,0,1,1));
        map.put("I", new BitString(-1,0,1,-1,-1));
        map.put("J", new BitString(-1,0,1,-1,0));
        map.put("K", new BitString(-1,0,1,-1,1));
        map.put("L", new BitString(-1,0,1,0,-1));
        map.put("M", new BitString(-1,0,1,0,0));
        map.put("N", new BitString(-1,0,1,0,1));
        map.put("O", new BitString(-1,0,1,1,-1));
        map.put("P", new BitString(-1,0,1,1,0));
        map.put("Q", new BitString(-1,0,1,1,1));
        map.put("R", new BitString(-1,1,-1,-1,-1));
        map.put("S", new BitString(-1,1,-1,-1,0));
        map.put("T", new BitString(-1,1,-1,-1,1));
        map.put("U", new BitString(-1,1,-1,0,-1));
        map.put("V", new BitString(-1,1,-1,0,0));
        map.put("W", new BitString(-1,1,-1,0,1));
        map.put("X", new BitString(-1,1,-1,1,-1));
        map.put("Y", new BitString(-1,1,-1,1,0));
        map.put("Z", new BitString(-1,1,-1,1,1));
        map.put("^", new BitString(-1,1,0,-1,-1));
        map.put("°", new BitString(-1,1,0,-1,0));
        map.put("!", new BitString(-1,1,0,-1,1));
        map.put("²", new BitString(-1,1,0,0,-1));
        map.put("§", new BitString(-1,1,0,0,0));
        map.put("³", new BitString(-1,1,0,0,1));
        map.put("$", new BitString(-1,1,0,1,-1));
        map.put("%", new BitString(-1,1,0,1,0));
        map.put("&", new BitString(-1,1,0,1,1));
        map.put("/", new BitString(-1,1,1,-1,-1));
        map.put("{", new BitString(-1,1,1,-1,0));
        map.put("(", new BitString(-1,1,1,-1,1));
        map.put("[", new BitString(-1,1,1,0,-1));
        map.put(")", new BitString(-1,1,1,0,0));
        map.put("]", new BitString(-1,1,1,0,1));
        map.put("=", new BitString(-1,1,1,1,-1));
        map.put("}", new BitString(-1,1,1,1,0));
        map.put("ß", new BitString(-1,1,1,1,1));
        map.put("?", new BitString(0,-1,-1,-1,-1));
        map.put("´", new BitString(0,-1,-1,-1,0));
        map.put("`", new BitString(0,-1,-1,-1,1));
        map.put("+", new BitString(0,-1,-1,0,-1));
        map.put("*", new BitString(0,-1,-1,0,0));
        map.put("~", new BitString(0,-1,-1,0,1));
        map.put("#", new BitString(0,-1,-1,1,-1));
        map.put("'", new BitString(0,-1,-1,1,0));
        map.put("-", new BitString(0,-1,-1,1,1));
        map.put("_", new BitString(0,-1,0,-1,-1));
        map.put(".", new BitString(0,-1,0,-1,0));
        map.put(":", new BitString(0,-1,0,-1,1));
        map.put(",", new BitString(0,-1,0,0,-1));
        map.put(";", new BitString(0,-1,0,0,0));
        map.put("µ", new BitString(0,-1,0,0,1));
        map.put("<", new BitString(0,-1,0,1,-1));
        map.put(">", new BitString(0,-1,0,1,0));
        map.put("|", new BitString(0,-1,0,1,1));

        return map;
        
       }

Kann mir wer sagen, warum die Exception kommt?
 
S

SlaterB

Gast
das ist doch leicht, message ist ein char, wird durch AutoBoxing zu einem Character-Objekt gecastet,
in der Map ist aber nichts zu Charakter gespeichert, sondern nur zu String-Keys
 
S

SlaterB

Gast
verschiedene Möglichkeiten,
Java: 
Map<Character, BitString> statt Map<String, BitString>
+
map.put(' ', new BitString(-1,-1,-1,-1,-1));
map.put('0', new BitString(-1,-1,-1,-1,0));
statt
map.put(" ", new BitString(-1,-1,-1,-1,-1));
map.put("0", new BitString(-1,-1,-1,-1,0));


oder beim Abfragen einen String zu einem Char erstellen, z.B. 
alphabet.get(""+message[i]);
 
A

andreas2505

Bekanntes Mitglied
hab mal die erste Methode probiert:

Java: 
public static Map createMap() {
        Map<char, BitString> map = new HashMap<char, BitString>();
        
        
        map.put(' ', new BitString(-1,-1,-1,-1,-1));
        map.put('0', new BitString(-1,-1,-1,-1,0));

funktioniert aber nicht:

unexcepted type
found: char required: reference
 
A

AmunRa

Gesperrter Benutzer
nimm mal lieber dass hier

Java: 
  Map<char, BitString> map = new HashMap<Character, BitString>();

Character ist die Wrapperklasse von char. und in die Map musst du ein Object einer Klasse stecken und kannst keinen primitiven typ verwenden.
 
S

SlaterB

Gast
AmunRa hat es halb korrigiert, in meinem Posting habe ich doch Character statt char geschrieben,
ist da so schwer eine mögliche Fehlerursache zu raten?
(nicht dass ich garantiert richtig liege, aber das kann man doch zumindest mal ausprobieren)
 
A

andreas2505

Bekanntes Mitglied
so jetzt habe ich das nächste Problem.

Wenn ich mal probiere obs funzt und in die for Schleife

Java: 
num[i].toString();

einbaue, dann kommen nur lauter Nullen raus. Woran kann das liegen?
 
S

SlaterB

Gast
vielleicht zufällig, weil du in deine BitString eingebaut hast, dass die Parameter ohne Hinweis in den Müll zu schmeißen sind,
wenn es nicht genau 4 Stück sind, siehe deinen Code, zumindest Stand 10.03.2011?! ;)

aktuellen Code zu posten wäre auch nicht verkehrt wenn du eine Frage zu DEINER unbekannten Klasse stellst

ok, ich sehe gerade, der Code wurde von _Dit vorgeschlagen, hast du den oder einen anderen?
 
A

andreas2505

Bekanntes Mitglied
ok hier die Klasse BitString:

Java: 
public class BitString {
    
    private static final int BITS = 5;
    private int[] _bitString;
    
    public BitString() {
        setBitString(new int[BITS]);
    }
    
    /**
     * Vorsicht.
     * @param bits
     */
    public BitString(int... bits){
        setBitString(bits);
    }
    
    /**
     * @param bitString
     *            the bitString to set
     */
    public void setBitString(int... bitString) {
        if (bitString.length == BITS) {
            this._bitString = bitString;
        } else {
            // TODO
        }
    }
    
    /**
     * @return the bitString
     */
    public int[] getBitString() {
        return _bitString;
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(int i : _bitString){
            sb.append(i);
        }
        
        return sb.toString();
    }


    public static Map createMap() {
        Map<Character, BitString> map = new HashMap<Character, BitString>();
        
        
        map.put(' ', new BitString(-1,-1,-1,-1,-1));
        map.put('0', new BitString(-1,-1,-1,-1,0));
        map.put('1', new BitString(-1,-1,-1,-1,1));
        map.put('2', new BitString(-1,-1,-1,0,-1));
        map.put('3', new BitString(-1,-1,-1,0,0));
        map.put('4', new BitString(-1,-1,-1,0,1));
        map.put('5', new BitString(-1,-1,-1,1,-1));
        map.put('6', new BitString(-1,-1,-1,1,0));
        map.put('7', new BitString(-1,-1,-1,1,1));
        map.put('8', new BitString(-1,-1,0,-1,-1));
        map.put('9', new BitString(-1,-1,0,-1,0));
        map.put('a', new BitString(-1,-1,0,-1,1));
        map.put('b', new BitString(-1,-1,0,0,-1));
        map.put('c', new BitString(-1,-1,0,0,0));
        map.put('d', new BitString(-1,-1,0,0,1));
        map.put('e', new BitString(-1,-1,0,1,-1));
        map.put('f', new BitString(-1,-1,0,1,0));
        map.put('g', new BitString(-1,-1,0,1,1));
        map.put('h', new BitString(-1,-1,1,-1,-1));
        map.put('i', new BitString(-1,-1,1,-1,0));
        map.put('j', new BitString(-1,-1,1,-1,1));
        map.put('k', new BitString(-1,-1,1,0,-1));
        map.put('l', new BitString(-1,-1,1,0,0));
        map.put('m', new BitString(-1,-1,1,0,1));
        map.put('n', new BitString(-1,-1,1,1,-1));
        map.put('o', new BitString(-1,-1,1,1,0));
        map.put('p', new BitString(-1,-1,1,1,1));
        map.put('q', new BitString(-1,0,-1,-1,-1));
        map.put('r', new BitString(-1,0,-1,-1,0));
        map.put('s', new BitString(-1,0,-1,-1,1));
        map.put('t', new BitString(-1,0,-1,0,-1));
        map.put('u', new BitString(-1,0,-1,0,0));
        map.put('v', new BitString(-1,0,-1,0,1));
        map.put('w', new BitString(-1,0,-1,1,-1));
        map.put('x', new BitString(-1,0,-1,1,0));
        map.put('y', new BitString(-1,0,-1,1,1));
        map.put('z', new BitString(-1,0,0,-1,-1));
        map.put('A', new BitString(-1,0,0,-1,0));
        map.put('B', new BitString(-1,0,0,-1,1));
        map.put('C', new BitString(-1,0,0,0,-1));
        map.put('D', new BitString(-1,0,0,0,0));
        map.put('E', new BitString(-1,0,0,0,1));
        map.put('F', new BitString(-1,0,0,1,-1));
        map.put('G', new BitString(-1,0,0,1,0));
        map.put('H', new BitString(-1,0,0,1,1));
        map.put('I', new BitString(-1,0,1,-1,-1));
        map.put('J', new BitString(-1,0,1,-1,0));
        map.put('K', new BitString(-1,0,1,-1,1));
        map.put('L', new BitString(-1,0,1,0,-1));
        map.put('M', new BitString(-1,0,1,0,0));
        map.put('N', new BitString(-1,0,1,0,1));
        map.put('O', new BitString(-1,0,1,1,-1));
        map.put('P', new BitString(-1,0,1,1,0));
        map.put('Q', new BitString(-1,0,1,1,1));
        map.put('R', new BitString(-1,1,-1,-1,-1));
        map.put('S', new BitString(-1,1,-1,-1,0));
        map.put('T', new BitString(-1,1,-1,-1,1));
        map.put('U', new BitString(-1,1,-1,0,-1));
        map.put('V', new BitString(-1,1,-1,0,0));
        map.put('W', new BitString(-1,1,-1,0,1));
        map.put('X', new BitString(-1,1,-1,1,-1));
        map.put('Y', new BitString(-1,1,-1,1,0));
        map.put('Z', new BitString(-1,1,-1,1,1));
        map.put('^', new BitString(-1,1,0,-1,-1));
        map.put('°', new BitString(-1,1,0,-1,0));
        map.put('!', new BitString(-1,1,0,-1,1));
        map.put('²', new BitString(-1,1,0,0,-1));
        map.put('§', new BitString(-1,1,0,0,0));
        map.put('³', new BitString(-1,1,0,0,1));
        map.put('$', new BitString(-1,1,0,1,-1));
        map.put('%', new BitString(-1,1,0,1,0));
        map.put('&', new BitString(-1,1,0,1,1));
        map.put('/', new BitString(-1,1,1,-1,-1));
        map.put('{', new BitString(-1,1,1,-1,0));
        map.put('(', new BitString(-1,1,1,-1,1));
        map.put('[', new BitString(-1,1,1,0,-1));
        map.put(')', new BitString(-1,1,1,0,0));
        map.put(']', new BitString(-1,1,1,0,1));
        map.put('=', new BitString(-1,1,1,1,-1));
        map.put('}', new BitString(-1,1,1,1,0));
        map.put('ß', new BitString(-1,1,1,1,1));
        map.put('?', new BitString(0,-1,-1,-1,-1));
        map.put('´', new BitString(0,-1,-1,-1,0));
        map.put('`', new BitString(0,-1,-1,-1,1));
        map.put('+', new BitString(0,-1,-1,0,-1));
        map.put('*', new BitString(0,-1,-1,0,0));
        map.put('~', new BitString(0,-1,-1,0,1));
        map.put('#', new BitString(0,-1,-1,1,-1));
        map.put('-', new BitString(0,-1,-1,1,1));
        map.put('_', new BitString(0,-1,0,-1,-1));
        map.put('.', new BitString(0,-1,0,-1,0));
        map.put(':', new BitString(0,-1,0,-1,1));
        map.put(',', new BitString(0,-1,0,0,-1));
        map.put(';', new BitString(0,-1,0,0,0));
        map.put('µ', new BitString(0,-1,0,0,1));
        map.put('<', new BitString(0,-1,0,1,-1));
        map.put('>', new BitString(0,-1,0,1,0));
        map.put('|', new BitString(0,-1,0,1,1));
       
        return map;
        
       }
}
 
S

SlaterB

Gast
das sollte dann im Moment funktionieren, wenn ich BitString für
Java: 
public class Test {
    public static void main(String[] args) {
        encrypt("hallo");
    }

    static void encrypt(String m)  {
        int l = m.length();
        char[] message = new char[l];
        BitString[] num = new BitString[l];
        int[][] numInt = new int[l][5];

        message = m.toCharArray();

        Map alphabet = BitString.createMap();
        for (int i = 0; i < l; i++)   {
            int[] help = new int[5];
            num[i] = (BitString)alphabet.get(message[i]);
            help = num[i].getBitString();
            System.out.println("i: " + i + ", " + Arrays.toString(help) + " ### " + num[i].toString());
        }
    }
}
benutze, dann erhalte ich als Ausgabe
Code: 
i: 0, [-1, -1, 1, -1, -1] ### -1-11-1-1
i: 1, [-1, -1, 0, -1, 1] ### -1-10-11
i: 2, [-1, -1, 1, 0, 0] ### -1-1100
i: 3, [-1, -1, 1, 0, 0] ### -1-1100
i: 4, [-1, -1, 1, 1, 0] ### -1-1110

ist also noch das 0er-Problem bei dir aktuell?
 
A

andreas2505

Bekanntes Mitglied
teilweise schon:

ich habe als text

Java: 
String s = new String("hallo hallo");

und als Ausgabe erhalte ich:

[XML]i: 0, [-1, -1, 1, -1, -1] ### -1-11-1-1
i: 1, [-1, -1, 0, -1, 1] ### -1-10-11
i: 2, [-1, -1, 1, 0, 0] ### -1-1100
i: 3, [-1, -1, 1, 0, 0] ### -1-1100
i: 4, [-1, -1, 1, 1, 0] ### -1-1110
i: 5, [-1, -1, -1, -1, -1] ### -1-1-1-1-1
i: 6, [-1, -1, 1, -1, -1] ### -1-11-1-1
i: 7, [-1, -1, 0, -1, 1] ### -1-10-11
i: 8, [-1, -1, 1, 0, 0] ### -1-1100
i: 9, [-1, -1, 1, 0, 0] ### -1-1100
i: 10, [-1, -1, 1, 1, 0] ### -1-1110
[/XML]

Das mit den Nullen ist geklärt aber die Leerzeichen werden nicht verarbeitet

Was du da geschrieben hast, verändert ja nur die Ausgabe. Aber der Inhalt von num hat die ganze Zeit schon gestimmt oder?
 
Zuletzt bearbeitet:
S

SlaterB

Gast
> und außerdem werden die Leerzeichen nicht genommen
inwiefern?
-1-1-1-1-1 für Leerzeichen ist doch dabei, Index 0 bis 10 sind 11 verschiedene Einträge, 11 Zeichen hat der String?


----

was Zeile 12 bedeutet erklärst du wenig schlauerweise mal wieder nicht,
ich vermute selber, dass es etwas mit [c]int[][] numInt[/c] zu tun hat und du dieses Array in der Schleife auf keine Weise veränderst,
daher ist es am Ende wie am Anfang: voller 0en

edit: ok, das ist weg

-----

> Was du da geschrieben hast, verändert ja nur die Ausgabe. Aber der Inhalt von num hat die ganze Zeit schon gestimmt oder?

worum gehts?
 
A

andreas2505

Bekanntes Mitglied
ich meine damit, dass der Fehler, dass am Anfang die Nullen ausgegeben wurden, daran lag, dass die Ausgabemethode falsch war, oder?

Es lag also nicht an der Unwandlung von BitString, richtig?
 
S

SlaterB

Gast
puh, ich weiß jetzt wirklich nicht, welche von verschiedenen Code-Versionen du meinst (von denen du gewiss nicht alle gepostet hast),
wo wann warum eine Ausgabemethode beteiligt war, was eine Umwandlung von BitString ist und wo diese dann wieder beteiligt war, ist oder sein wird,

da sind ja hunderte Variablen in dieser Frage,
stelle bitte immer nur aktuelle:
'ich habe folgenden Code, folgende Ausgabe und Problem + Vermutung xy'
 
A

andreas2505

Bekanntes Mitglied
ok , ich denke das passt schon, dankeschön


kannst du mir vielleicht auch weiterhelfen.

Ich möchte nun die einzelnen Arrays (also num) in das int[][] numInt einfügen, und zwar so dass die variable N die neue Länge bestimmt und soviele einzelne int[] erstellt werden, wie bis alle Zeichen verarbeitet sind.

Als Beispiel:

Hallo Hallo

-1-11-1-1-1-10-11-1-1100-1-1100.....

wenn n jetzt 8 ist, möchte ich halt

-1-11-1-1-1-10
-11-1-1100-1
-1100.....

und wenn dann keine vollen 8 mehr zusammen kommen soll der rest mit Nullen aufgefüllt werden!
 
S

SlaterB

Gast
0en sind im Array schon drin, du musst nur auf das Array auch zugreifen,
z.B. die Werte des help-Arrays mit einer Schleife nach numInt[...] übertragen
 
A

andreas2505

Bekanntes Mitglied
ich habe schon sowas

Java: 
double t = (double) l/N;
        int anz = (int) Math.ceil(t);
        int diff = anz*N - l;
        
        Polynom[] e = new Polynom[anz]; 
        Polynom poly;

for (int i = 0; i < l && i < anz; i++) {
            int[] koeffs = new int[N];
            for (int j = 0; j < 5 && j < N; j++) {
                koeffs[i] = numInt[i][j];
            }
            poly = new Polynom(koeffs);
            //poly.print();
        }

aber irgendwie funzt das nicht richtig

hab die Klasse Polynom noch vergessen:

Java: 
public class Polynom
{
    int[] koeffs;

    
    private Polynom(int N) {
        koeffs = new int[N];
    }
    
    Polynom(int[] koeffs) {
        this.koeffs = koeffs;
    }

    // Erzeugt ein zufälliges Polynom mit numOnes Koeffizienten gleich 1,
    // numNegOnes Koeffizienten gleich -1, und dem Rest gleich 0.
    static Polynom generatePolynom(int N, int numOnes, int numNegOnes) {
        List<Integer> koeffs = new ArrayList<Integer>();
        for (int i=0; i<numOnes; i++)
            koeffs.add(1);
        for (int i=0; i<numNegOnes; i++)
            koeffs.add(-1);
        while (koeffs.size() < N)
            koeffs.add(0);
        Collections.shuffle(koeffs, new SecureRandom());
        
        Polynom poly = new Polynom(N);
        for (int i=0; i<koeffs.size(); i++)
            poly.koeffs[i] = koeffs.get(i);
        return poly;
    }
    
    
     // Computes the inverse mod q; q must be a power of 2.
    // Returns null if the polynomial is not invertible.
    Polynom invertPolynomFq(int q) {
        int N = koeffs.length;
        int k = 0;
        Polynom b = new Polynom(N+1);
        b.koeffs[0] = 1;
        Polynom c = new Polynom(N+1);
        Polynom f = new Polynom(N+1);
        f.koeffs = Arrays.copyOf(koeffs, N+1);
        // setze g(x) = x^N - 1
        Polynom g = new Polynom(N+1);
        g.koeffs[0] = -1;
        g.koeffs[N] = 1;
        while (true) {
            while (f.koeffs[0] == 0) {
                for (int i=1; i<=N; i++) {
                    f.koeffs[i-1] = f.koeffs[i];   // f(x) = f(x) / x
                    c.koeffs[N+1-i] = c.koeffs[N-i];   // c(x) = c(x) * x
                }
                f.koeffs[N] = 0;
                c.koeffs[0] = 0;
                k++;
                if (f.equalsZero())
                    return null;   // nicht invertierbar
            }
            if (f.equalsOne())
                break;
            if (f.degree() < g.degree()) {
                // vertausche f und g
                Polynom temp = f;
                f = g;
                g = temp;
                // vertausche b und c
                temp = b;
                b = c;
                c = temp;
            }
            f.add(g, 2);
            b.add(c, 2);
        }
        
        if (b.koeffs[N] != 0)
            return null;
        // Fq(x) = x^(N-k) * b(x)
        Polynom Fq = new Polynom(N);
        int j = 0;
        k %= N;
        for (int i=N-1; i>=0; i--) {
            j = i - k;
            if (j < 0)
                j += N;
            Fq.koeffs[j] = b.koeffs[i];
        }
        
        // inverse mod 2 --> inverse mod q
        int v = 2;
        while (v < q) {
            v *= 2;
            Polynom temp = new Polynom(Arrays.copyOf(Fq.koeffs, Fq.koeffs.length));
            temp.multiply2(v);
            Fq = starMultiply(Fq, v).starMultiply(Fq, v);
            temp.sub(Fq, v);
            Fq = temp;
        }
        
        Fq.modPositive(q);
        return Fq;
    }
    
    
    
    Polynom invertPolynomFp(int p) {
        int N = koeffs.length;
        int k = 0;
        Polynom b = new Polynom(N+1);
        b.koeffs[0] = 1;
        Polynom c = new Polynom(N+1);
        Polynom f = new Polynom(N+1);
        f.koeffs = Arrays.copyOf(koeffs, N+1);
        // setze g(x) = x^N - 1
        Polynom g = new Polynom(N+1);
        g.koeffs[0] = -1;
        g.koeffs[N] = 1;
        while (true) {
            while (f.koeffs[0] == 0) {
                for (int i=1; i<=N; i++) {
                    f.koeffs[i-1] = f.koeffs[i];   // f(x) = f(x) / x
                    c.koeffs[N+1-i] = c.koeffs[N-i];   // c(x) = c(x) * x
                }
                f.koeffs[N] = 0;
                c.koeffs[0] = 0;
                k++;
                if (f.equalsZero())
                    return null;   // not invertible
            }
            if (f.equalsAbsOne())
                break;
            if (f.degree() < g.degree()) {
                // vertausche f und g
                Polynom temp = f;
                f = g;
                g = temp;
                // vertausche b und c
                temp = b;
                b = c;
                c = temp;
            }
            if (f.koeffs[0] == g.koeffs[0]) {
                f.sub(g, p);
                b.sub(c, p);
            }
            else {
                f.add(g, p);
                b.add(c, p);
            }
        }
        
        if (b.koeffs[N] != 0)
            return null;
        // Fp(x) = [+-] x^(N-k) * b(x)
        Polynom Fp = new Polynom(N);
        int j = 0;
        k %= N;
        for (int i=N-1; i>=0; i--) {
            j = i - k;
            if (j < 0)
                j += N;
            Fp.koeffs[j] = f.koeffs[0] * b.koeffs[i];
        }
        
        Fp.modPositive(p);
        return Fp;
    }
    
    
    
    Polynom starMultiply(Polynom poly2, int q) {
        int[] a = koeffs;
        int[] b = poly2.koeffs;
        if (b.length != a.length)
            throw new RuntimeException("Anzahl der Koeffizienten muss gleich sein!");
        int N = a.length;
        int[] c = new int[N];
        
        for (int k=N-1; k>=0; k--) {
            c[k] = 0;
            int j = k + 1;
            
            for (int i=N-1; i>=0; i--) {
                if (j == N) 
                    j = 0;
                if (a[i] != 0 && b[j] != 0) {
                    c[k] += a[i] * b[j];
                    c[k] %= q;
                }
                j++;
            }
        }
        
        Polynom result = new Polynom(N);
        result.koeffs = c;
        return result;
                    
    }
    
    
    void sub(Polynom b, int mod) {
        int N = koeffs.length;
        if (b.koeffs.length != N)
            throw new RuntimeException("Anzahl der Koeffizienten muss gleich sein!");
        for (int i=0; i<N; i++) {
            koeffs[i] -= b.koeffs[i];
            koeffs[i] %= mod;
        }
    }
    
    
    
    // tests if |p(x)| = 1
    private boolean equalsAbsOne() {
        for (int i=1; i<koeffs.length; i++)
            if (koeffs[i] != 0)
                return false;
        return Math.abs(koeffs[0]) == 1;
    }
    

    
    void modPositive(int mod) {
        for (int i=0; i<koeffs.length; i++)
            while (koeffs[i] < 0)
                koeffs[i] += mod;
    }
    
    
    
    private void multiply2(int mod) {
        for (int i=0; i<koeffs.length; i++) {
            koeffs[i] *= 2;
            koeffs[i] %= mod;
        }
    }
        
            
    
    
    // testet ob p(x) = 0
    private boolean equalsZero() {
        for (int i=0; i<koeffs.length; i++)
            if (koeffs[i] != 0)
                return false;
        return true;
    }
    
    
    // testet ob p(x) = 1
    boolean equalsOne() {
        for (int i=1; i<koeffs.length; i++)
            if (koeffs[i] != 0)
                return false;
        return koeffs[0] == 1;
    }
    
    
    /**testet ob |p(x)| = 1
    private boolean equalsAbsOne() {
        for (int i=1; i<koeffs.length; i++)
            if (koeffs[i] != 0)
                return false;
        return Math.abs(koeffs[0]) == 1;
    }*/
    
    
    void add(Polynom b, int modulus) {
        int N = koeffs.length;
        if (b.koeffs.length != N)
            throw new RuntimeException("number of coefficients must be the same");
        for (int i=0; i<N; i++) {
            koeffs[i] += b.koeffs[i];
            koeffs[i] %= modulus;
        }
    }
    
    
    void multp(int p, int mod) {
        for (int i=0; i<koeffs.length; i++) {
            koeffs[i] *= p;
            koeffs[i] %= mod;
        }
    }
    
    
    private int degree() {
        int deg = koeffs.length - 1;
        while (deg>0 && koeffs[deg]==0)
            deg--;
        return deg;
    }
    
    
    // shiftet alle Koeffizienten in das Interval [-p/2, p/2]
    void centerShift(int p) {
        for (int i=0; i<koeffs.length; i++) {
            while (koeffs[i] < -p/2)
                koeffs[i] += p;
            while (koeffs[i] > p/2)
                koeffs[i] -= p;
        }
    }
    
    
    void mod(int mod) {
        for (int i=0; i<koeffs.length; i++)
            koeffs[i] %= mod;
        modPositive(mod);
    }
    
    
    void print() {
        for (int i=0; i<koeffs.length; i++) {
            System.out.print(koeffs[i]);
            System.out.print(" ");
        }
        System.out.println();
    }
    
    
    char[] toCharArray() {
        char[] a = new char[koeffs.length];
        for (int i=0; i<koeffs.length; i++) {
            a[i] = (char) koeffs[i];
        }
        return a;
    }
    
}
 
Zuletzt bearbeitet:
S

SlaterB

Gast
was soll mir das sagen?
ich rate mal wieder in langen ausführlichen Sätzen selber:
das ist die Auswertung nach der Schleife mit den BitString-Map-Zugriff um den es bisher ging,
da du dort bisher nichts verändert hast, ist an dieser Stelle das numInt-Array immer noch mit 0en befüllt,
dieser Code mag so gut sein wie möglich, kann aber nichts sinnvolles zaubern sofern numInt nur 0en enthält,

rate ich richtig?

(edit: meine Güte wird das viel Code inzwischen, wofür soll der nur (ohne Erklärungen wie üblich!) interessant sein?)
------

ich habe dir gesagt dass du den vorherigen Code ändern musst, da wo das help-Array, anhand der System.out.println()-Ausgabe sichtbar, interessante Zahlen enthält,
diese Zahlen musst du in das numInt-Array übertragen!..
 
Zuletzt bearbeitet von einem Moderator:
A

andreas2505

Bekanntes Mitglied
irgendwie reden wir aneinander vorbei.

Also 1. der Code dient dazu das NTRU Kryptosystem zu implementieren.

Ich möchte eigentlich nur wissen, wie ich die help Arrays alle in das numInt[][] packe.

Kannste mir vielleicht mit Code weiterhelten, sonst reden wir noch ewig aneinander vorbei
 
S

SlaterB

Gast
nein ich kann dir keinen Code schreiben der so simpel ist, dass es kaum simpler geht,
mir egal wieviele Stunden du dafür brauchst, Java lernen musst du,

es gibt Index-Schleifen, es gibt die Möglichkeit per Index etwas aus einem Array heraus zu holen und es gibt die Möglichkeit etwas per Index woanders hineinzuspeichern,
wenn du das nicht lernst, dann geht ja gar nix

---------

wenn es ein Vorbeireden gibt, dann doch sicherlich von deiner Seite, oder? ;)
ich habe in meinen letzten beiden Postings das help-Array explizit erwähnt,
du dagegen 300 Zeilen einer neuen komplett anderen Polygon-Klasse gepostet
 
A

andreas2505

Bekanntes Mitglied
ich hatte doch schon gepostet, was ich bisher dazu habe, aber irgendwie stimmt das nicht.

Java: 
int N = params.N;
        int q = params.q;
        int dr = params.dr;
        int p = params.p;
        
        encryptedPair ep = new encryptedPair();
        
        int l = m.length();
        char[] message = new char[l];
        BitString[] num = new BitString[l];
        int[][] numInt = new int[l][5];
        
        message = m.toCharArray();
       
        
        for (int i=0; i<l; i++) {
            int[] help = new int[5];
            num[i] = (BitString) alphabet.get(message[i]);
            help = num[i].getBitString();
            //System.out.println("i: " + i + ", " + Arrays.toString(help) + " ### " + num[i].toString());

        }
            
        
        double t = (double) l/N;
        int anz = (int) Math.ceil(t);
        int diff = anz*N - l;
        
        Polynom[] e = new Polynom[anz]; 
        Polynom poly;
        
        for (int i = 0; i < l && i < anz; i++) {
            int[] koeffs = new int[N];
            for (int j = 0; j < 5 && j < N; j++) {
                koeffs[i] = numInt[i][j];
            }
            poly = new Polynom(koeffs);
            //poly.print();
        }

unten die Schleife soll die Umwandlung vornehmen
 
S

SlaterB

Gast
nein, nicht unten, in Zeile 19 setzt du help aus dem BitString, nur bis zum nächsten Schleifendurchlauf hat help die passenden Daten,
genau nach Zeile 19 musst du jetzt eine Schleife programmieren, die die Werte überträgt,
oder schreibe einzelne Befehle, einen kann dir ja vorgeben:
[c]numInt[0] = help[0];[/c]
schon ist endlich im längerfristigen numInt-Array ein Teil der in help kurzfristig erlangten Information gespeichert
 
A

andreas2505

Bekanntes Mitglied
aber wie kann ich so die unterschiedlichen Längen berücksichtigen.
help ja ja jeweils nur 5 Elemente, aber numInt hat ja N Elemente.

ganz ehrlich, ich habe keine Idee wie das in der Schleife funktionieren soll, mit den Indizes.
Ich überleg ja schon, aber ich komme nicht drauf
 
S

SlaterB

Gast
numInt hat N Elemente, als erste von zwei Dimensionen, und jedes dieser N Elemente ist nur ein normales Array der Länge 5,
das gesamte numInt interessiert dich gar nicht, sondern numInt,
da gibt es allein 5 Positionen, numInt[0] bis numInt[4],
also schreibe 5 Kopierbefehle untereinander oder überlege dir eine Schleife die von 0 bis 4 läuft bzw. bis zur Länge von help

[c]BitString[] num [/c] ist doch auch ein Array, welches du mit der Schleife von Zeile 16 durchläufst,
was ist daran schwer?

oder denke von deinem Programm weg wenn dich das blockiert und denke dir folgendes einfache:
Java: 
public class Test
{
    public static void main(String[] args)
    {
        int[] help = new int[5];
    }
}
was ist so schwer daran, ein Array mit einer Schleife durchzulaufen und jeden Wert auszugeben?
wie du jeden Wert in ein zweidimensionales Array irgendwo plazierst musst du dabei ja noch gar nicht sofort lösen,
erstmal wäre nur eine Schleife zum Durchlauf das einfachen Arrays help schon ein erster guter Schritt,

wie man ganz elementar ein einfachst-denkbares normales eindimensionales Array mit einer Schleife durchläuft findet sich ansonsten auch in Lehrbüchern im Array-Kapitel
 
A

andreas2505

Bekanntes Mitglied
ok du hast es etwas falsch verstanden.

numInt hat anz Arrays, die jeweils N Elemente haben sollen.
num hat nur 5 Elemente. Allerdings sollen ja jetzt der Reihe nach die Elemente in numInt gepackt werden.

Habe doch das Beispiel geschickt:

Als Beispiel:

Hallo Hallo

-1-11-1-1-1-10-11-1-1100-1-1100.....,

also num[0] = -111-1-1
num[1] = -1-10-11
...

wenn N jetzt 8 ist, möchte ich halt

numInt[0] = [-1-11-1-1-1-10]
numInt[1] = [-11-1-1100-1]
....

und wenn dann keine vollen 8 mehr zusammen kommen soll der rest mit Nullen aufgefüllt werden!

deshalb denkst du auch, dass es so einfach ist.

Es ist nämlich jetzt nicht mehr so einfach, oder?
 
S

SlaterB

Gast
nach [c]int[][] numInt = new int[l][5];[/c]
hat numInt hat anz Arrays, die jeweils 5 Elemente haben, nicht N,

wie auch immer, bei N ist dann die Schleife kaum zu umgehen, ja, ist [c]for(x=0; x<help.length; x++)[/c] wirklich schwer?
 
A

andreas2505

Bekanntes Mitglied
numInt hat die Dimension numInt[anz][N]

und anz ist halt abhängig davon wieviele Arrays der Größe N aus den num[5] Arrays gebildet werden können.

und ich wüsste nicht, wie das in derselben Schleife gehen soll
 
S

SlaterB

Gast
anz kann dir wie gesagt egal sein, du bist ja schon in einer Schleife i wo es um numInt geht,
numInt ist ein eindimensionales Array der Länge N, ansprechbar numInt[0], numInt[1] usw.
help ist ein eindimensionales Array der Länge N, 5, oder was auch immer, ansprechbar help[0], help[1] usw.,

du musst fast nur von einem eindimensionalen Array in ein anderes eindimensionales kopieren
 
A

andreas2505

Bekanntes Mitglied
nein, du verstehst mich komplett falsch. numInt hat nix mit i zu tun. numInt hat als ersten Index die Anzahl der Arrays mit jeweils N einträgen, welche mit anz ausgedrückt werden.

num soll nur die einzelnen Buchstaben als int[] abspeichern. Aber die Länge der int[] soll nun auf N vergrößert werden, in dem die num aneinander gereiht werden.
Dadurch ergibt sich dann die Anzahl anz der Arrays mit N Elementen.
 
S

SlaterB

Gast
das widerspricht meiner Ansicht nach komplett dem Code bzw. im Grunde sagst du kaum etwas für mich exakt interpretierbares,
insofern kann ich auch einfach von weiterem Missverständnis ausgehen,

unter diesen Umständen bin ich dann bereit, direkt dazu Code posten, so wie ich mir das vorstelle:
beachte wie der Schleife, die help ins numInt-Array überträgt, anz ganz egal ist, das aktuelle i ist wichtig

Java: 
public class Test
{
    public static void main(String[] args)
    {
        encrypt("hallo hallo hallo hallo hallo hallo hallo hallo hallo hallo hallo hallo ");
    }

    static void encrypt(String m)
    {
        int l = m.length();
        int N = 8;
        char[] message = new char[l];
        BitString[] num = new BitString[l];
        int[][] numInt = new int[l][N];

        message = m.toCharArray();

        Map alphabet = BitString.createMap();
        for (int i = 0; i < l; i++)
        {
            num[i] = (BitString)alphabet.get(message[i]);
            int[] help = num[i].getBitString();
            for (int j = 0; j < help.length; j++)
            {
                numInt[i][j] = help[j];
            }
        }

        for (int i = 0; i < l; i++)
        {
            for (int j = 0; j < N; j++)
            {
                System.out.print(numInt[i][j] + ", ");
            }
            System.out.println();
        }

    }

}
Ausgabe:
Code: 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0, 
-1, -1, 1, -1, -1, 0, 0, 0, 
-1, -1, 0, -1, 1, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 0, 0, 0, 0, 0, 
-1, -1, 1, 1, 0, 0, 0, 0, 
-1, -1, -1, -1, -1, 0, 0, 0,
 
A

andreas2505

Bekanntes Mitglied
Hallo,

ich bins mal wieder.

Also hab mir den Code mal angegeguckt. Die Ausgabe ist zwar richtig, aber ich will nicht nur, dass es so ausgegeben wird, sondern auch genauso in numInt abgespeichert wird.

In der oberen Schleife hat ja numInt die Dimensionen l und 5 (help.length), also numInt[l][5], aber ich will doch, dass numInt die Dimension numInt[anz][N] hat, wobei sich anz nach der Anzahl der Arrays richtet, die mit N Elementen gefüllt sind.

Unten wird es ja nur ausgegeben, aber es soll auch so abgespeichert sein.

Außerdem sehe ich grad, dass bei den Arrays die bei dir ausgegeben werden auch immer Nullen am Ende stehen. Ich glaube du hast das mit den Nullen auffüllen missverstanden.

Es soll nur dass allerletzte Array von numInt mit Nullen aufgefüllt werden, falls nicht mehr genügend Elemente von den help Arrays vorhanden sind.

Hier nochmal ein Beispiel: (Umwandlung ist jetzt erfunden, also von der Map)

Test : '123'

help Arrays:

-11011
-1-1-100
11-11-1

numIntArrays: (für N=8)

-11011-1-1-1
0011-11-10 (die letzte Null wurde aufgefüllt, weil nur 15 Elemente von den help Arrays da waren, aber N=8 ist, und damit ein Element fehlt)
 
Zuletzt bearbeitet:
S

SlaterB

Gast
in meinem Code verwende ich doch N statt 5, kannst du bei dir auch machen, was ist dazu die Frage?

und die Ausgabe ist nicht direkt berechnet sondern genau die Ausgabe der Werte die vorher in numInt gespeichert wurden!,
also auch in diesem Punkt verstehe ich deine Rückfrage nicht, um mehr als Speicherung in diesem 2D-Array ging es doch bisher nicht,
das war vorher 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, jetzt sind stattdessen Zahlen drin?
ob du danach noch irgendwas mit Polygon machen musst, kann ich nicht absehen

edit:
ich schaue deinen edit an, schreibe auch zu schnell Anfworten ;)
 
S

SlaterB

Gast
ok, ich sehe nun einen neuen Punkt,
das ist in der Tat eine kompliziertere Art, das Array zu befüllen, schaue dir dazu folgendes Testprogramm an
Java: 
public class Test {
    public static void main(String[] args) {
        int[][] k = new int[10][4];

        int indexK = 0;
        for (int i = 0; i < 6; i++) {
            int[] help =  {33, 44, 55};
            for (int h = 0; h < help.length; h++)  {
                k[indexK / k[0].length][indexK % k[0].length] = help[h];
                indexK++;
            }
        }
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.print(k[i][j] + ", ");
            }
            System.out.println();
        }
    }
}
Ausgabe:
Code: 
33, 44, 55, 33, 
44, 55, 33, 44, 
55, 33, 44, 55, 
33, 44, 55, 33, 
44, 55, 0, 0, 
0, 0, 0, 0, 
0, 0, 0, 0, 
0, 0, 0, 0, 
0, 0, 0, 0, 
0, 0, 0, 0,
die 6x drei Zahlen 33, 44, 55 passen hier in die ersten 5 Zeilen des größeren Arrays


edit:
eine Variante für indexK ohne allgemeines Hochzählen:
Java: 
            for (int h = 0; h < help.length; h++)
            {
                int indexK = i * help.length + h;
                k[indexK / k[0].length][indexK % k[0].length] = help[h];
            }
 
Zuletzt bearbeitet von einem Moderator:
A

andreas2505

Bekanntes Mitglied
das Problem ist, dass du das help Array einfach direkt in das numInt Array übergibst, aber das will ich doch gar nicht.

du machst:

help = 1,-1,0,0,1
numInt = 1,-1,0,0,1

aber das will ich doch gar nicht.

Ich will doch dass du immer mehrere help Arrays zusammenfügen musst, um es dann in dem numInt abzuspeichern.
Du weißt ja vorher nicht, wiegroß N ist. Wenn N immer 5 wäre, wäre ja deine Methode richtig, aber wenn es größer als 5 ist, müssen von dem nächsten help Arrays noch Elemente in numInt hinzugefügt werden.

Das haut einfach nicht hin in der Schleife, weil der Index i viel zu weit läuft und nicht auch als Index für numInt dienen kann, da dort je nach Größe von N, weniger Arrays vorhanden sind.

Nochmal zum Verständnis.

Mann kann ja die ganzen help Arrays hintereinander schreiben:

z.B.
1,-1,-1,0,0,1,1,1,0,-1,1,0,1,1,-1,1,0

und nun sei N = 8

Dann ist numInt[0] = 1,-1,-1,0,0,1,1,1
numInt[1] = 0,-1,1,0,1,1,-,1,0
jetzt ist noch die 0 übrig und der Rest muss mit Nullen aufgefüllt werden.
Also numInt[2] = 0,0,0,0,0,0,0,0

Ich hoffe du weißt jetzt wie ichs meine, damit du mir auch helfen kannst
 
S

SlaterB

Gast
seit du in deinem edit um 11:30 das in deinem Posting von 11:25 ERSTMALS erwähnst, weiß ich Bescheid,
vorher wäre das nur mit Hellsehen gegangen, wenn mir dieser Wertung erlaubt ist ;)

Beispiele sind schon was tolles, man muss sie auch posten

siehe meine Antwort um 11:43 zu diesem neuen Stand, falls zwischenzeitlich übersehen


> der Rest muss mit Nullen aufgefüllt werden.

ein int-Array ist standardmäßig sowieso immer mit Nullen gefüllt, auf diese Redewendung könntest du langsam verzichten,
falls du nicht gerade ein altes benutztes Array mit potentiellen Inhalt wieder leeren willst
 
Zuletzt bearbeitet von einem Moderator:
A

andreas2505

Bekanntes Mitglied
ja sorry, hatte dein Posting erst nach meinem gelesen!

Also irgendwie verstehe ich die Funktion des Besipielcodes nicht, könntest du mir das mal auf mein Besipiel anpassen, damit ich dass besser nachvollziehen kann.
 
S

SlaterB

Gast
der Vorteil ist, dass jetzt nicht mehr das help-Array, 33, 44, 55 zu Beginn jeder Zeile des 2D-Arrays steht (+ am Ende 0),
sondern dass die Zeilen komplett aufgefüllt werden,

für dein Programm musst du eigentlich nur die Variablen der beteiligten Arrays austauschen,
das ist so wenig Arbeit, da solltest du dann doch wieder bisschen selber dran sitzen

was das / und % bedeutet besser im Detail anschauen und verstehen, grundsätzlich aber gar nicht nötig
 
A

andreas2505

Bekanntes Mitglied
das Problem ist, dass ich immer noch nicht glaube, dass ich die Umwandlung der Arrays in dieselber Schleife, wie beim help Array reinpacken kann, weil die Laufvariable i ja nicht auch Laufvariable für numInt sein kann, weil ja viel weniger Arrays entstehen!!!

Wie soll das gehen?
 
S

SlaterB

Gast
wenn du dir mein Programm von 11:43 anschaust, dann ist das i dort unabhängig vom zweidimensionalen Array k,
falls das i sehr groß wird ist sogar kein Überlauf möglich, dann passen nicht mehr alle Zahlen in k,

wie du da grundsätzlich vorgehst musst du selber wissen, das 2D-Array vorher groß genug wählen,
ich schätze im Moment kommt bei dir alles hin, du musst nur noch help übertragen, mein Code zeigt wie
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Rest mit Spring boot oder selbst anlegen Java Basics - Anfänger-Themen 14
M 2d array ohne längen anlegen Java Basics - Anfänger-Themen 4
I Logik Zahlungsprozess - Wann Bestellobjekt anlegen? Java Basics - Anfänger-Themen 2
S Datei anlegen Problem! Groß- und Kleinschreibung wird nicht unterschieden Java Basics - Anfänger-Themen 4
B Inventar als einzelne Klassen anlegen? Java Basics - Anfänger-Themen 12
J Methode als Class anlegen Java Basics - Anfänger-Themen 7
J Datenbankstruktur als Objekt anlegen Java Basics - Anfänger-Themen 4
E OOP Array anlegen mit unterschiedlichen Werten Java Basics - Anfänger-Themen 8
M Fragen zum Anlegen und Benutzen von Listen Java Basics - Anfänger-Themen 9
B Datei auslesen und 2D-Array anlegen Java Basics - Anfänger-Themen 1
Z char Array unbekanntes Zeichen selbstständig anlegen Java Basics - Anfänger-Themen 6
P zweidimensionales Array anlegen und mit DB-Daten füllen Java Basics - Anfänger-Themen 14
K Mehrere Objekte anlegen Java Basics - Anfänger-Themen 23
P Anlegen und Abfragen von Array List Java Basics - Anfänger-Themen 4
Q Methoden Konstruktoren anlegen Java Basics - Anfänger-Themen 5
S Direkt Instanzen anlegen Java Basics - Anfänger-Themen 1
V Anlegen eines 2 dim Array mit Point Elementen Java Basics - Anfänger-Themen 3
H Programmiertechnik: Methode einer Klasse beim Anlegen überschreibt Java Basics - Anfänger-Themen 3
D Array auslesen und und Werte in ein anderes array anlegen Java Basics - Anfänger-Themen 5
L Classpath anlegen Java Basics - Anfänger-Themen 6
K Bibliothek per "Struktur" anlegen Java Basics - Anfänger-Themen 5
P Mindestangaben beim anlegen von Objekten Java Basics - Anfänger-Themen 4
F Klassenorganisation: Datentyp in Datentyp anlegen Java Basics - Anfänger-Themen 3
E Liste mit Wertepaaren anlegen Java Basics - Anfänger-Themen 4
P Variablen Variable in if Bedingung anlegen, Wert zuweisen und diesen als Bedingung nutzen Java Basics - Anfänger-Themen 4
B Klassen Objekte während der Laufzeit dynamisch anlegen Java Basics - Anfänger-Themen 8
A Konto anlegen Java Basics - Anfänger-Themen 3
3 Array eines Objektes anlegen Java Basics - Anfänger-Themen 4
H Wann ein Objekt der Programmklasse in main anlegen Java Basics - Anfänger-Themen 2
A Variablen für einen Thread anlegen Java Basics - Anfänger-Themen 5
B Dateien anlegen Java Basics - Anfänger-Themen 3
W neue Variablen in Schleife anlegen Java Basics - Anfänger-Themen 13
D Array anlegen ohne bekannte Länge? Java Basics - Anfänger-Themen 6
Houly JUnit Test Suite anlegen Java Basics - Anfänger-Themen 6
B jar Archiv anlegen Java Basics - Anfänger-Themen 2
D Objekte anlegen und Singleton Pattern Java Basics - Anfänger-Themen 21
B logfile anlegen Java Basics - Anfänger-Themen 5
B Datentyp anlegen Java Basics - Anfänger-Themen 6
G Unterverzeichnisse anlegen klappt nicht Java Basics - Anfänger-Themen 4
G Prüfen ob Ordner vorhanden, wenn nicht anlegen? Java Basics - Anfänger-Themen 2
G bin-Datei anlegen und schreiben Java Basics - Anfänger-Themen 5
G Datei mit Java anlegen Java Basics - Anfänger-Themen 9
X Ordner mit Tageszeit als Name anlegen Java Basics - Anfänger-Themen 5
J Datei anlegen Java Basics - Anfänger-Themen 2
J variable Variable anlegen Java Basics - Anfänger-Themen 7
loadbrain dateirechte unter linux, verzeichniss anlegen lassen Java Basics - Anfänger-Themen 10
M Mit Java eine neue DB anlegen über XAMPP? Ist das möglich ? Java Basics - Anfänger-Themen 4
O Variablen über Schleife anlegen Java Basics - Anfänger-Themen 7
H Integerliste anlegen. aber wie Java Basics - Anfänger-Themen 4
Q sun.net.ftp.FtpClient; Ordner anlegen Java Basics - Anfänger-Themen 4
R mehrere Objekte in Schleife anlegen? Java Basics - Anfänger-Themen 4
M Dateien/Verzeichnisse anlegen Java Basics - Anfänger-Themen 10
G JTextArea: Anlegen, Text löschen, überschreiben Java Basics - Anfänger-Themen 4
K Ordner anlegen! Java Basics - Anfänger-Themen 3
E Zweiten Container anlegen Java Basics - Anfänger-Themen 5
S Ein Dokument durchparsen und Dokumente Anlegen Java Basics - Anfänger-Themen 5
S Schöne Tabelle mit println() anlegen Java Basics - Anfänger-Themen 3
I User anlegen und Sytempfade zuordnen Java Basics - Anfänger-Themen 4
G Wie anlegen? Java Basics - Anfänger-Themen 5
H Datein und Ordner kopieren bzw neu anlegen Java Basics - Anfänger-Themen 2
G Path anlegen Java Basics - Anfänger-Themen 2
G Objekte mittels Schleife anlegen und ansprechen Java Basics - Anfänger-Themen 8
F Area anlegen Java Basics - Anfänger-Themen 9
S Datei anlegen Java Basics - Anfänger-Themen 6
S Objekte dynamisch anlegen Java Basics - Anfänger-Themen 3
F Neuen Pfad anlegen Java Basics - Anfänger-Themen 3
B Reihung anlegen, Werte einlesen Java Basics - Anfänger-Themen 9
M Arrays neu anlegen Java Basics - Anfänger-Themen 4
G Dateien anlegen, kopieren bzw. speichern Java Basics - Anfänger-Themen 5
G Ordner anlegen Java Basics - Anfänger-Themen 2
P x-viele Variablen anlegen Java Basics - Anfänger-Themen 2
B Objete von Polygon mit TreeSet verwalten Java Basics - Anfänger-Themen 1
frager2345 Java Klasse Buch verwalten Java Basics - Anfänger-Themen 0
frager2345 Java eigen Klasse zum verwalten von Büchern Java Basics - Anfänger-Themen 3
Kotelettklopfer Mehrere Projekte in einem Git verwalten Java Basics - Anfänger-Themen 10
EisKaffee Klassen Objekte verwalten Java Basics - Anfänger-Themen 13
A Sportligen verwalten Java Basics - Anfänger-Themen 2
F Objekte einer Klasse verwalten Java Basics - Anfänger-Themen 10
T Objekte in Array verwalten Java Basics - Anfänger-Themen 4
JCODA Polymorphie Wie soll man Daten verwalten? Java Basics - Anfänger-Themen 4
M Eine Resource die veraltet verwalten Java Basics - Anfänger-Themen 3
D Erste Schritte Viele Objekte einer Klasse "verwalten" Java Basics - Anfänger-Themen 17
D Fenster in LinkedList verwalten Java Basics - Anfänger-Themen 2
sqsh statische jlabels dynamisch verwalten Java Basics - Anfänger-Themen 2
B EreignisListener verschiedener Klassen aus einer Ereignisklasse verwalten Java Basics - Anfänger-Themen 9
sqsh mehrere JLabels mit einer Funktion verwalten Java Basics - Anfänger-Themen 5
U Programm zum verwalten von Objekten Java Basics - Anfänger-Themen 17
G Collection<Strings> - Liste von Strings verwalten Java Basics - Anfänger-Themen 9
P JPanel dynamisch mit ActionListener verwalten Java Basics - Anfänger-Themen 3
W Verwalten von Objekten - Listen, Vektoren usw. Java Basics - Anfänger-Themen 6
J Objekte verwalten? Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen


Oben