Registrierung Kalender Mitgliederliste Teammitglieder Suche Häufig gestellte Fragen Zur Startseite

Informatiker Board » Suche » Suchergebnis » Hallo Gast [Anmelden|Registrieren]
Zeige Beiträge 1 bis 15 von 220 Treffern Seiten (15): [1] 2 3 nächste » ... letzte »
Autor Beitrag
Thema: Neuer Ansatz zum Neunerpuzzle
Haevelin

Antworten: 2
Hits: 246
RE: Neuer Ansatz zum Neunerpuzzle 13.10.2019 18:55 Forum: Algorithmen


Also die Nullpointerausnahmen kommen daher, dass ein Knoten erst erzeugt werden muss, ehe ihm null zugewiesen wird! Das habe ich jetzt behoben, und mein Programm läuft. Allerdings kommt er immer wieder auf die Ausgangslage zurück und bricht dann ab. In der Rekursion muss also noch etwas geändert werden! Kann mir jemand weiterhelfen? Hier der neue Code:
code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package FU_2;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class L_E2_3 {

    int[][] ziel = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
    int[][] ausgang = {{1, 2, 3}, {8, 0, 5}, {4, 7, 6}};
    Node root = new Node();

    public Node g_erster(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 1; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i - 1][j];
                    matrix[i - 1][j] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;
                    System.out.println("Neue Matrix errechnet");
                    ausgabe(matrix);

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.content == matrix) {
                    doppelt = true;
                    Node neu = new Node();
                    neu = null;
                    return neu;
                } else {
                    n = n.parent;
                }
            }
            System.out.println("Ein neuer Knoten wird generiert " + matrix);
            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        Node neu = new Node();
        neu = null;
        return neu;
    }

    public Node g_zweiter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i + 1][j];
                    matrix[i + 1][j] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;
                    System.out.println("Neue Matrix errechnet");
                    ausgabe(matrix);

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.content == matrix) {
                    doppelt = true;
                    Node neu = new Node();
                    neu = null;
                    return neu;
                } else {
                    n = n.parent;
                }
            }
            System.out.println("Ein neuer Knoten wird generiert " + matrix);

            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        Node neu = new Node();
        neu = null;
        return neu;
    }

    public Node g_dritter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 1; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i][j - 1];
                    matrix[i][j - 1] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;
                    System.out.println("Neue Matrix errechnet");
                    ausgabe(matrix);

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.content == matrix) {
                    doppelt = true;
                    Node neu = new Node();
                    neu = null;
                    return neu;
                } else {
                    n = n.parent;
                }
            }
            System.out.println("Ein neuer Knoten wird generiert " + matrix);

            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        Node neu = new Node();
        neu = null;
        return neu;
    }

    public Node g_vierter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 1; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i][j + 1];
                    matrix[i][j + 1] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;
                    System.out.println("Neue Matrix errechnet");
                    ausgabe(matrix);
                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.content == matrix) {
                    doppelt = true;
                    Node neu = new Node();
                    neu = null;
                    return neu;
                } else {
                    n = n.parent;
                }
            }
            System.out.println("Ein neuer Knoten wird generiert " + matrix);

            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        Node neu = new Node();
        neu = null;
        return neu;
    }

    public Node insert(Node n) {
        if (n != null) {
            Node v = new Node();
            n.eins = v;
            n.eins = g_erster(n.content, n);
            if (n.eins != null && !abbruch(n.eins)) {
                insert(n.eins);
            }
            if (abbruch(n.eins)) {
                return n.eins;
            }
            Node w = new Node();
            n.zwei = w;
            n.zwei = g_zweiter(n.content, n);
            if (n.zwei != null && !abbruch(n.zwei)) {
                insert(n.zwei);
            }
            if (abbruch(n.zwei)) {
                return n.zwei;
            }
            Node x = new Node();
            n.drei = x;
            n.drei = g_dritter(n.content, n);
            if (n.drei != null && !abbruch(n.drei)) {
                insert(n.drei);
            }
            if (abbruch(n.drei)) {
                return n.drei;
            }
            Node y = new Node();
            n.vier = y;
            n.vier = g_vierter(n.content, n);
            if (n.vier != null && !abbruch(n.vier)) {
                insert(n.vier);
            }
            if (abbruch(n.vier)) {
                return n.vier;
            }
        }
        return null;
    }

    public boolean abbruch(Node n) {
        if (n != null && n.content == ziel) {
            return true;
        } else {
            return false;
        }
    }
    
    public void ausgabe(int[][] matrix){
        for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(matrix[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("____________________");
            System.out.println();
        }
    

    public static void main(String[] args) {
        // TODO code application logic here
        L_E2_3 p = new L_E2_3();
        p.root.content = p.ausgang;
        p.root.parent = new Node();
        p.root.parent = null;
        Node v = new Node();
        v = p.root;
        Node resultat = new Node();
        resultat = p.insert(p.root);
        while (resultat != null) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(resultat.content[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("____________________");
            System.out.println();
            resultat = resultat.parent;
        }
    }
}

Thema: Neuer Ansatz zum Neunerpuzzle
Haevelin

Antworten: 2
Hits: 246
Neuer Ansatz zum Neunerpuzzle 13.10.2019 17:08 Forum: Algorithmen


Hallo, jetzt habe ich es mit Bäumen versucht. Die Idee ist die Ausgangsstellung in root einzustellen, und dann nach up, down, Right und left zu verzweigen! So entsteht ein Baum mit einer maximalen Verzweigung von vier. Aber im Programm wird eine nullpointerexception geworfen! Das muss wohl irgendwie damit zusammenhängen, dass ich null da ansetze, wo keine Verzweigung mehr erfolgt! Hier der Code:

code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package FU_2;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class L_E2_3 {

    int[][] ziel = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
    int[][] ausgang = {{1, 2, 3}, {8, 0, 5}, {4, 7, 6}};
    Node root = new Node();

    public Node g_erster(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 1; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i - 1][j];
                    matrix[i - 1][j] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.parent.content == matrix) {
                    doppelt = true;
                    return null;
                } else {
                    n = n.parent;
                }
            }
            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        return null;
    }
    
    
    
    public Node g_zweiter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i + 1][j];
                    matrix[i + 1][j] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.parent.content == matrix) {
                    doppelt = true;
                    return null;
                } else {
                    n = n.parent;
                }
            }
            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        return null;
    }
    
    
    public Node g_dritter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 1; j < 3; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i][j-1];
                    matrix[i][j-1] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.parent.content == matrix) {
                    doppelt = true;
                    return null;
                } else {
                    n = n.parent;
                }
            }
            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        return null;
    }
    
    public Node g_vierter(int[][] matrix, Node n) {
        int generiert = 0;
        for (int i = 1; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                if (matrix[i][j] == 0) {
                    int zwischen = matrix[i ][j+1];
                    matrix[i][j+1] = 0;
                    matrix[i][j] = zwischen;
                    i = 3;
                    j = 3;
                    generiert = 1;

                }
            }

        }

        if (generiert == 1) {
            boolean doppelt = false;
            while (n != null) {
                if (n.parent.content == matrix) {
                    doppelt = true;
                    return null;
                } else {
                    n = n.parent;
                }
            }
            Node neu = new Node();
            neu.parent = n;
            neu.content = matrix;
            return neu;
        }
        return null;
    }

    public Node insert(Node n) {
        if (n != null) {
            n.eins = g_erster(n.content, n);
            if (n.eins != null && !abbruch(n.eins)){
                insert (n.eins);
            }
            if (abbruch(n.eins)) return n.eins;
            n.zwei = g_zweiter(n.content, n);
            if (n.zwei != null && !abbruch(n.zwei)){
                insert (n.zwei);
            }
            if (abbruch(n.zwei)) return n.zwei;
            n.drei = g_dritter(n.content, n);
            if (n.drei != null && !abbruch(n.drei)){
                insert (n.drei);
            }
            if (abbruch(n.drei)) return n.drei;
            n.vier = g_vierter(n.content, n);
            if (n.vier != null && !abbruch(n.vier)){
                insert (n.vier);
            }
            if (abbruch(n.vier)) return n.vier;
        }
        return null;
    }
    
    public boolean abbruch(Node n){
        if (n.content==ziel) { return true;} else {return false;}
    }
    

    public static void main(String[] args) {
        // TODO code application logic here
        L_E2_3 p = new L_E2_3();
        p.root.content=p.ausgang; 
        p.root.parent=null;
        Node v = new Node();
        v = p.root;
        Node resultat = new Node(); 
        resultat= p.insert(v);
        while (resultat.parent!=null){
            for (int i=0; i<3; i++){
                for (int j=0; j<3; j++){
                    System.out.print(resultat.content[i][j]+ " ");
                }
                System.out.println();
            }
            System.out.println("____________________");
            System.out.println();
        }
        resultat=resultat.parent;

    }
}





Es fehlt noch die Nodeklasse:

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package FU_2;

/**
 *
 * @author Richard Kunstwadl
 */
public class Node {
    Node eins; 
    Node zwei;
    Node drei;
    Node vier;
    Node parent;
    int[][] content; 
    
}

Thema: Neunerpuzzle
Haevelin

Antworten: 2
Hits: 245
RE: Neunerpuzzle 12.10.2019 17:09 Forum: Algorithmen


Meine erste Fehlersuche ergab, dass ein Stein zuerst verschoben wird, und dann in einer anderen Rekursion wieder zurückgeschoben wird, wodurch keine weitere Rekursion mehr erfolgt. Wie kann ich das vermeiden?
code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package fu_hagen;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class FU_Hagen {

    int[][] ziel = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
    int[][] ausgang = {{1, 2, 3}, {8, 0, 5}, {4, 7, 6}};
    ArrayList<int[][]> resultat = new ArrayList<int[][]>();
    ArrayList<int[][]> korb = new ArrayList<int[][]>();

    public boolean up(int[][] k) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i > 0 && k[i - 1][j] == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean down(int[][] k) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i < 2 && k[i + 1][j] == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean left(int[][] k) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j < 2 && k[i][j] == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean right(int[][] k) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j > 0 && k[i][j] == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    public void starter(int[][] z, int[][] a) {
        ArrayList<int[][]> korb_s = new ArrayList<int[][]>();
        rekursion(z, a, korb_s);
    }

    public void rekursion(int[][] z, int[][] a, ArrayList<int[][]> korb) {
        boolean ende = true;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (z[i][j] != a[i][j]) {
                    ende = false;
                    i = 3;
                    j = 3;
                    System.out.println("Falsches Ende");
                }
            }
        }
        if (ende == true) {
            resultat = korb;
            System.out.println("jetzt wird abgebrochen " + a[2][2]);
            return;
        };

        int[][] bi = a;
        System.out.println("a an der Stelle 0,1 ist " + a[0][1]);
        if (up(a)) {
            for (int i = 1; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (i > 0 && a[i - 1][j] == 0) {
                        int zwischen = a[i][j];
                        a[i][j] = 0;
                        a[i - 1][j] = zwischen;
                        System.out.println("Jetzt in up");
                        if (korb.indexOf(a) == -1) {
                            System.out.println("Wird hinzugefügt?");
                            System.out.println("a an der Stelle 1,1 ist " + a[1][1]);

                            korb.add(a);
                            rekursion(z, a, korb);
                        } 
                    }
                }
            }
        }

        bi = a;
        if (down(a)) {
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    if (i > 0 && a[i + 1][j] == 0) {
                        int zwischen = a[i][j];
                        a[i][j] = 0;
                        a[i + 1][j] = zwischen;
                        System.out.println("a an der Stelle 1,1 ist " + a[1][1]);

                        if (korb.indexOf(a) == -1) {
                            System.out.println("Wird hinzugefügt? down");

                            korb.add(a);
                            rekursion(z, a, korb);
                        } 
                    }
                }
            }

        }

        bi = a;
        if (left(a)) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 2; j++) {
                    if (j < 2 && a[i][j] == 0) {
                        int zwischen = a[i][j + 1];
                        a[i][j] = zwischen;
                        a[i][j + 1] = 0;
                        System.out.println("a an der Stelle 1,1 ist " + a[1][1]);

                        if (korb.indexOf(a) == -1) {
                            System.out.println("Wird hinzugefügt? left");

                            korb.add(a);
                            rekursion(z, a, korb);
                        } 
                    }
                }
            }

        }

        
        if (right(a)) {
            for (int i = 0; i < 3; i++) {
                for (int j = 1; j < 3; j++) {
                    if (j > 0 && a[i][j] == 0) {
                        int zwischen = a[i][j - 1];
                        a[i][j] = zwischen;
                        a[i][j - 1] = 0;
                        System.out.println("a an der Stelle 1,1 ist " + a[1][1]);

                        if (korb.indexOf(a) == -1) {
                            System.out.println("Wird hinzugefügt? right");

                            korb.add(a);
                            rekursion(z, a, korb);
                        } 
                    }
                }
            }

        }

    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        FU_Hagen p = new FU_Hagen();
        ArrayList<int[][]> a_korb = new ArrayList<int[][]>();
        p.starter(p.ziel, p.ausgang);
        for (int[][] ausgabe : p.resultat) {
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(ausgabe[i][j] + " ");
                }
                System.out.println("");
            }
            System.out.println("___________________");
        }
    }

}

Thema: Neunerpuzzle
Haevelin

Antworten: 2
Hits: 245
RE: Neunerpuzzle 12.10.2019 16:26 Forum: Algorithmen


Der Code beinhaltet, dass unendliche Schleifen eingezogen werden. Ich habe versucht das zu verbessern, aber das Problem ist, dass immer die Anfangskonstellation ausgegeben wird!

code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package fu_hagen;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class FU_Hagen {
int[][] ziel ={{1,2,3},{4,5,6},{7,8,0}};
int[][] ausgang = {{1,2,3},{8,0,5},{4,7,6}};


public boolean up (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && k[i-1][j] == 0){
            return true;
        }
        }
    }
    return false;
}


public boolean down (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i<2 && k[i+1][j] == 0){
            return true;
        }
        }
    }
    return false;
}

public boolean left (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j < 2 && k[i][j] == 0){
            return true;
        }
        }
    }
    return false;
}

public boolean right (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j > 0 && k[i][j] == 0){
            return true;
        }
        }
    }
    return false;
}



public ArrayList<int[][]> starter (int[][] z, int[][] a){
    ArrayList<int[][]> korb_s = new ArrayList<int[][]>();
    return rekursion(z,a,korb_s);
}

public ArrayList<int[][]> rekursion(int[][] z, int[][] a, ArrayList<int[][]> korb){
    boolean ende = true; 
    for (int i=0; i<3; i++){
        for (int j= 0; j< 3; j++){
            if ( z[i][j] != a[i][j] )
            { ende = false;
            i = 3; j = 3;
            } 
        }
    }
    if (ende == true) return korb; 
    
    int[][] bi= a;
    if (up(bi)){
        for (int i= 1; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && bi[i-1][j] == 0){
            int zwischen = bi[i][j];
            bi[i][j]=0;
            bi[i-1][j]=zwischen; 
            System.out.println("Jetzt in up");
            if (korb.indexOf(bi)== -1){
            System.out.println("Wird hinzugefügt?");
            korb.add(bi);
            return rekursion(z,bi,korb);
            }
        }
        }
    }
    }
       
        
        if (down(bi)){
        for (int i= 0; i< 2; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && bi[i+1][j] == 0){
            int zwischen = bi[i][j];
            bi[i][j]=0;
            bi[i+1][j]=zwischen; 
            if (korb.indexOf(bi)== -1){
            korb.add(bi);
            return rekursion(z,bi,korb);
            }
        }
        }
    }
        
    }
        
        
        if (left(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 0; j< 2; j++){
            if (j < 2 && bi[i][j] == 0){
            int zwischen = bi[i][j+1];
            bi[i][j]=zwischen;
            bi[i][j+1]=0; 
            if (korb.indexOf(bi)== -1){
            korb.add(bi);
            return rekursion(z,bi,korb);
            }
        }
        }
    }
        
    }
        
         
        if (right(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 1; j< 3; j++){
            if (j > 0 && bi[i][j] == 0){
            int zwischen = bi[i][j-1];
            bi[i][j]=zwischen;
            bi[i][j-1]=0; 
            if (korb.indexOf(bi)== -1){
            korb.add(bi);
            return rekursion(z,bi,korb);
            }
        }
        }
    }
        
    }
    
        
        
    
    return korb; 
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        FU_Hagen p = new FU_Hagen();
        ArrayList<int[][]> a_korb= new ArrayList<int[][]>();
        a_korb= p.starter(p.ziel, p.ausgang);
        for (int[][] ausgabe : a_korb){
            for (int i=0; i<3; i++){
                for (int j=0; j<3; j++){
                    System.out.print(ausgabe[i][j] + " ");
                }
                System.out.println("");
            }
            System.out.println("___________________");
        }
    }
    
}

Thema: Neunerpuzzle
Haevelin

Antworten: 2
Hits: 245
Neunerpuzzle 12.10.2019 14:18 Forum: Algorithmen


Hallo, es gilt ein 3 mal 3 Feld mit 8 Zahlen und der 0 in eine richtige Reihenfolge zu bringen. Das Feld am Anfang ist anfang, dass Zielfeld ist ziel. Wie kann ich eine Folge vom anfang bis zum ziel erzeugen? Hier mein Vorschlag:

code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package fu_hagen;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class FU_Hagen {
int[][] ziel ={{1,2,3},{4,5,6},{7,8,0}};
int[][] ausgang = {{1,2,3},{8,0,5},{4,7,6}};


public boolean up (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && k[i-1][j] == 0){
            return true;
        }
        }
    }
    return false;
}


public boolean down (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i<2 && k[i+1][j] == 0){
            return true;
        }
        }
    }
    return false;
}

public boolean left (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j < 2 && k[i][j] == 0){
            return true;
        }
        }
    }
    return false;
}

public boolean right (int[][] k) {
    for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j > 0 && k[i][j] == 0){
            return true;
        }
        }
    }
    return false;
}



public ArrayList<int[][]> starter (int[][] z, int[][] a){
    ArrayList<int[][]> korb_s = new ArrayList<int[][]>();
    return rekursion(z,a,korb_s);
}

public ArrayList<int[][]> rekursion(int[][] z, int[][] a, ArrayList<int[][]> korb){
    if (korb.size()==0){
        korb = new ArrayList<int[][]>();
    }
    boolean ende = true; 
    for (int i=0; i<3; i++){
        for (int j= 0; j< 3; j++){
            if ( z[i][j] != a[i][j] )
            { ende = false;
            i = 3; j = 3;
            } 
        }
    }
    if (ende == true) return korb; 
    
    int[][] bi=a;
    if (up(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && bi[i-1][j] == 0){
            int zwischen = bi[i][j];
            bi[i][j]=0;
            bi[i-1][j]=zwischen; 
            korb.add(bi);
            rekursion(z,bi,korb);
        }
        }
    }
    }
       
        bi = a;
        if (down(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (i>0 && bi[i+1][j] == 0){
            int zwischen = bi[i][j];
            bi[i][j]=0;
            bi[i+1][j]=zwischen; 
            korb.add(bi);
            rekursion(z,bi,korb);
        }
        }
    }
        
    }
        
        bi = a;
        if (left(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j <2 && bi[i][j] == 0){
            int zwischen = bi[i][j+1];
            bi[i][j]=zwischen;
            bi[i][j+1]=0; 
            korb.add(bi);
            rekursion(z,bi,korb);
        }
        }
    }
        
    }
        
         bi = a;
        if (right(bi)){
        for (int i= 0; i< 3; i++){
        for (int j = 0; j< 3; j++){
            if (j > 0 && bi[i][j] == 0){
            int zwischen = bi[i][j-1];
            bi[i][j]=zwischen;
            bi[i][j-1]=0; 
            korb.add(bi);
            rekursion(z,bi,korb);
        }
        }
    }
        
    }
    
        
        
    
    return korb; 
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        FU_Hagen p = new FU_Hagen();
        ArrayList<int[][]> a_korb= new ArrayList<int[][]>();
        a_korb= p.starter(p.ziel, p.ausgang);
        for (int[][] ausgabe : a_korb){
            for (int i=0; i<3; i++){
                for (int j=0; j<3; j++){
                    System.out.print(ausgabe[i][j] + " ");
                }
            }
            System.out.println("___________________");
        }
    }
    
}


Thema: Einfacher Javacode funktioniert niccht
Haevelin

Antworten: 1
Hits: 185
RE: Einfacher Javacode funktioniert niccht 12.10.2019 11:29 Forum: Algorithmen


Habe den Fehler schon gefunden; nicht == bei der Zuweisung und Felder werden a[i][j] angesprochen! Schon lange nicht mehr programmiert, daher der Fehler!
Thema: Einfacher Javacode funktioniert niccht
Haevelin

Antworten: 1
Hits: 185
Einfacher Javacode funktioniert niccht 12.10.2019 11:26 Forum: Algorithmen


Die Vergleichung zweier Werte ist schwieriger als ich dachte: Was ist falsch an folgendem Code, den mein Compiler nicht akzeptiert?!
code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package fu_hagen;

import java.util.ArrayList;

/**
 *
 * @author Richard Kunstwadl
 */
public class FU_Hagen {
int[][] ziel ={{1,2,3},{4,5,6},{7,8,0}};
int[][] ausgang = {{1,2,3},{8,0,5},{4,7,6}};


public void rekursion(int[][] z, int[][] a, ArrayList<int[][]> korb){
    if (korb.size()==0){
        korb = new ArrayList<int[][]>();
    }
    boolean ende = true; 
    for (int i=0; i<3; i++){
        for (int j= 0; j< 3; j++){
            if ( z[i,j] != a[i,j] )
            { ende == false;
            }
            } 
        }
    }
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    }
    
}


Thema: Figur in x3d
Haevelin

Antworten: 1
Hits: 611
RE: Figur in x3d 08.06.2018 11:18 Forum: Algorithmen


Ein erster Ansatz:

code:
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:
30:
31:
32:
33:
34:
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE X3D PUBLIC "ISO//Web3D//DTD X3D 3.3//EN" "http://www.web3d.org/specifications/x3d-3.3.dtd"> 
<X3D profile='Immersive' version='3.3' xmlns:xsd='http://www.w3.org/2001/XMLSchema-instance' xsd:noNamespaceSchemaLocation='http://www.web3d.org/specification s/x3d-3.3.xsd'>          
<Scene>  

<group>
<shape>
<Appearance>
                          <Material DEF="BarColor" diffuseColor="0 0 1"
                            specularColor="0.5 0.5 0.5" transparency="0.2">
                            <IS>
                              <connect nodeField="diffuseColor" protoField="barColor"/>
                            </IS>
                          </Material>
                        </Appearance>
                        <Box DEF="bar" size="2 2 2"/>
</shape>
<shape>
<Appearance>
                          <Material DEF="PointerColor"
                            diffuseColor="1 1 1" specularColor="0.5 0.5 0.5">
                         </Material>
                        </Appearance>
                        <Box DEF="bar" size="2 2 0.1"/>
</shape>
</group>


 

 </Scene> 
 </X3D>

Thema: Figur in x3d
Haevelin

Antworten: 1
Hits: 611
Figur in x3d 07.06.2018 15:36 Forum: Algorithmen


Die Aufgabe lautet, dass man eine Box aufrecht stehend, wobei nur die Kanten zu sehen sind, zu programmieren in der eine Ebene eingezogen ist, die die Höhe in der Box zeigt, und diese Ebene soll in der Box nach oben und unten verschoben werden können. Finde keine Beispiele im Netz!
Thema: Zerlegung einer Zahl in Primfaktoren
Haevelin

Antworten: 1
Hits: 927
Zerlegung einer Zahl in Primfaktoren 26.12.2017 12:24 Forum: Algorithmen


Ich möchte eine Zahl in Primfaktoren zerlegen. Allerdings funktioniert folgendes nicht:
code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
 /*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication2;

import java.util.ArrayList;

/**
 *
 * @author
 */
public class EA6_Aufgabe_2_1 {
    
    
    public static boolean isPrim(double value) { 
        if (value <= 2) { 
            return (value == 2); 
        } 
        for (double i = 2.0; i * i <= value; i++) { 
            if ((value % i == 0) && ((int)value == value)) { 
                return false; 
            } 
        } 
        return true; 
    }
    
    
        
    public ArrayList<Double> zerlege(int n){
        ArrayList<Double> z = new ArrayList();
       for (int i= 3; i< (int) Math.sqrt(n); i++){
           if (isPrim(i)){
               
                   if (isPrim((n*1.0)/(i*1.0))){
                       z.add(i*1.0);
                       z.add(n*1.0/i);
                   }
               }
           }
       
       return z;
    }
    
    
    
    public static void main(String[] args) {
        
        EA6_Aufgabe_2_1 ea6 = new EA6_Aufgabe_2_1();
        ArrayList<Double> ergebnis = new ArrayList();
        ergebnis = ea6.zerlege(3599);
        for (double i: ergebnis) System.out.println("Ich habe gefunden " + i);
    }
}
Thema: Erzeugung eines Sockets und Schichtenmodell
Haevelin

Antworten: 0
Hits: 671
Erzeugung eines Sockets und Schichtenmodell 19.10.2017 17:10 Forum: Softwaretechnik


Frage: Bei der Erzeugung eines Sockets müssen eine IP-Adresse und eine Portnummer übergeben werden. Ist die Verwendung der Portnummer und der IP-Adresse hier problematisch, angesichts des Prinzips des Schichtenmodells?

Mögliche Antwort: Probleme können bspw. bei der Textkodierung auftreten. Wird nur ein Bytestrom übertragen gibt es keine Probleme. Bei der Kommunikation mit Sockets sind viele Fehlerquellen möglich, z.B. ein nicht antwortender Server oder eine nicht vorhandene Verbindung mit dem Internet.

Frage: Wie viele Sockets benötigt der Server-Prozess bei der verbindungsorientierten Kommunikation, wenn er n Verbindungen gleichzeitig unterstützt und jede Verbindung einen eigenen Socket verwendet?
Mögliche Antwort: keine Idee
Thema: Steine aufklauben
Haevelin

Antworten: 9
Hits: 1.852
12.10.2017 12:33 Forum: Algorithmen


Vielleicht kann ich mein Anliegen durch einen regelbasierten Ansatz klar machen:
Ein Stein ist gefunden wenn:
not(Feld.h) und not(Feld.Ö) und not(Feld.B) und not(Feld.N) ==> klaube Stein auf.

Da aber nach Feld.B nicht traversiert wird, reduziert sich diese Regel auf:
not(Feld.h) und not(Feld.Ö) und not(Feld.N) ==> klaube Stein auf.

Die Logik des Sachverhaltes wirkt sich so auf den Code aus. Da der Code den Regelbestandteil nur indirekt repräsentiert, spreche ich davon, dass es sich um ein Unbewußtes des Codes handelt.

Nochmals danke für deine Programmierungshinweise.
Thema: Steine aufklauben
Haevelin

Antworten: 9
Hits: 1.852
11.10.2017 16:11 Forum: Algorithmen


Ich beschäftige mich mit der Psychoanalyse des Programmierens. Da ist es von Interesse, was als eine Form des Unbewußten in Programmen aufgefaßt werden kann. Das ist also keine Frage, sondern nur ein Anstoß für Interessierte.
Thema: Steine aufklauben
Haevelin

Antworten: 9
Hits: 1.852
09.10.2017 13:47 Forum: Algorithmen


Mal eine Perspektive auf den Code:
code:
1:
2:
3:
if (feld[x][y]!="H" && feld[x][y]!="Ö" && feld[x][y]!="N"){
            gefunden.add(feld[x][y]);
    } 


reagiert auf die Redundanz:

code:
1:
2:
3:
 if (feld[x][y]!="H" && feld[x][y]!="Ö" && feld[x][y]!="N" && feld[x][y] !="B"){
            gefunden.add(feld[x][y]);
    }


In diesem Sinne hat der Code ein Unbewußtes.
Thema: Steine aufklauben
Haevelin

Antworten: 9
Hits: 1.852
05.10.2017 16:29 Forum: Algorithmen


Habe den Fehler behoben. Der richtige Code muss lauten:

code:
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:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
    /*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

import java.util.ArrayList;

/**
 *
 * @author rkunstwadl
 */
public class JavaApplication1 {
    
    String[][] feld = new String[7][7];
    ArrayList<String> gefunden = new ArrayList();
    public JavaApplication1(){
        for (int i=0; i<7; i++){
            for (int j= 0; j<7; j++){
                feld[i][j]="N";
            }
        }
        feld[0][2]="Ö";
        feld[6][6]= "L";
        feld[0][1]= "A";
        feld[5][3]= "I";
        feld[0][4]= "O";
        feld[0][6]= "S";
        feld[0][0]= "H";
        feld[1][2]= "H";
        feld[2][5]= "H";
        feld[4][1]= "H";
        feld[5][1]= "H";
        feld[6][4]= "H";
        
        
        
    }

    
    
    public void traversiere(String[][] feld, int x, int y, ArrayList<String> gefunden){
        if (feld[x][y]!="H" && feld[x][y]!="Ö" && feld[x][y]!="N"){
            gefunden.add(feld[x][y]);
    }
        if (feld[x][y]=="H") return;
        if (feld[x][y]!="H") feld[x][y]="B"; 
        if (x+1<7 && y>=0 && y<7 && feld[x+1][y]!="B") traversiere(feld, x+1,y,gefunden);
        if (y+1 <7 && x>=0 && x<7 && feld[x][y+1]!="B") traversiere(feld, x, y+1,gefunden);
        if (x-1>=0 && y>=0 && y<7 && feld[x-1][y]!="B") traversiere(feld,x-1,y, gefunden);
        if (y-1>=0 && x>=0 && x<7 && feld[x][y-1]!="B") traversiere(feld,x,y-1,gefunden);
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        JavaApplication1 japp= new JavaApplication1(); 
        japp.traversiere(japp.feld, 0, 2, japp.gefunden);
        System.out.println(japp.gefunden);
    }
    
}
Zeige Beiträge 1 bis 15 von 220 Treffern Seiten (15): [1] 2 3 nächste » ... letzte »