Algortihmus: Kürzeste Folge zu einer Zahl

T

tekevic

Mitglied
Hallo und zwar soll ich ein Algorithmus erstellen bei dem eine Zahl durch folgende Operationen verändert werden kann:
1. Multiplikation mit drei
2. Multiplikation mit zwei und anschließendes Abziehen von 323.
3. Addition von 27
4. Subtraktion 13

Dabei soll ich eine kürzest mögliche Folge von Operationen finden, die die Zahl 1 in die Zahl 100 verwandelt. Die Zahl darf dabei zwischendurch nicht negativ werden.

Da ich leider nicht soviel Ahnung vom Programmieren habe , weiß ich leider nicht wie ich diesen Algorithmus implementieren soll.
Ich muss ja aufjedenfall für jede Zahl, 4 (für jede neue Zahl eine o.g Operation) neue Zahlen erstellen und das rekursiv bis ich die 1000 geknackt habe.
Wie genau implementiere ich das?
Vielen Dank für eure Hilfe :)
 
Viktim

Viktim

Bekanntes Mitglied
Ich hab erstmal eine Verständnsfrage:
Dein Programm soll bei einer Eins starten, und dann solange einen der vier Operatoren ausführen, bis die 1 eine 100 ist oder?
Und das in so wenig Schritten wie möglich, richtig?
 
X

Xyz1

Gast
Hatte mich nämlich schon gewundert, für N=100 ergibt sich:
Code: 
list = [3, 3, 4, 1, 4, 4]
ausgabe = ((((((1 + 27) + 27) - 13) * 3) - 13) - 13)
list = [3, 4, 3, 1, 4, 4]
ausgabe = ((((((1 + 27) - 13) + 27) * 3) - 13) - 13)
list = [4, 3, 3, 1, 4, 4]
ausgabe = ((((((1 - 13) + 27) + 27) * 3) - 13) - 13)

Hingegen für N=1000 ergibt sich:
Code: 
list = [3, 1, 3, 1, 1, 3, 4, 4]
ausgabe = ((((((((1 + 27) * 3) + 27) * 3) * 3) + 27) - 13) - 13)
list = [3, 1, 3, 1, 1, 4, 3, 4]
ausgabe = ((((((((1 + 27) * 3) + 27) * 3) * 3) - 13) + 27) - 13)
list = [3, 1, 3, 1, 1, 4, 4, 3]
ausgabe = ((((((((1 + 27) * 3) + 27) * 3) * 3) - 13) - 13) + 27)
list = [3, 4, 1, 3, 1, 1, 2, 3]
ausgabe = ((((((((1 + 27) - 13) * 3) + 27) * 3) * 3) * 2 - 323) + 27)
list = [4, 3, 1, 3, 1, 1, 2, 3]
ausgabe = ((((((((1 - 13) + 27) * 3) + 27) * 3) * 3) * 2 - 323) + 27)

Bei N=100 taucht 323 ja gar nicht auf...

Wie erklärt man das jetzt? Alle Operatoren haben kein Präzedenz. Das ist aber Wurscht, da alles eh in volls. geklammerter Infinxnotation steht. Da Addition und Subtraktion vertauscht werden kann, ist auch Wurscht, ob ich erst + 27 oder - 13 rechne.
 
X

Xyz1

Gast
Sorry, hatte glatt an eine wichtige Eigenschaft nicht gedacht...
tekevic hat gesagt.:
Die Zahl darf dabei zwischendurch nicht negativ werden. [...]
Zum Vergrößern anklicken....

Aber auch niemand dran erinnert... :
Code: 
Start: 1
Stop : 100
1 + 27 + 27 - 13 * 3 - 13 - 13
1 + 27 - 13 + 27 * 3 - 13 - 13
Fertig?

Start: 1
Stop : 1000
1 + 27 * 3 + 27 * 3 * 3 + 27 - 13 - 13
1 + 27 * 3 + 27 * 3 * 3 - 13 + 27 - 13
1 + 27 * 3 + 27 * 3 * 3 - 13 - 13 + 27
1 + 27 - 13 * 3 + 27 * 3 * 3 * 2 - 323 + 27
Fertig?

Also mea culpa - alles meine Schuld. :(

(Edit: Ja, Latein kann ich auch ;) . )
 
X

Xyz1

Gast
Wollte ich erst, aber ich hab's mir anders überlegt...
Warum?
1.) die .Exe ist 4,93 MB groß,
2.) ich müsste sie zuvor in ein .Zip packen,
3.) es sind halt viele Libs,
4.) betrachtet man das Binary, steht in Zeile 23300 und ff. mein BENUTZERNAME ......
5.) ich wollte schon anonym bleiben.

Der Algo macht das, was Flown oben beschrieben hat.
Setze die nächste der 4 Möglichkeiten ein, gehe einen Schritt weiter usw. usf.
 
X

Xyz1

Gast
Flown hat gesagt.:
@DerWissende Warum 4,93 MB? Welche Libs? Der Algorithmus hat ~30 Zeilen.
Zum Vergrößern anklicken....

Ich übersetze ein Java-Quelltext mit GCJ unter WINDOWS in nativen Code... Da System.in, IO(Exception s) und so etwas dabei ist, linkt der ziemlich viel dazu... u. a. auch den Pfad zu meinem Desktop, dort steht mein Benutzername, mein Benutzername ist mein bürgerlicher Name, der sollte nicht in 's Www...
 
Flown

Flown

Administrator
Mitarbeiter
Ohne Eigeninitiative werde ich auch nichts posten. Hab schon einen Hinweis mit BFS geliefert und das muss jetzt auch schon reichen.
 
Flown

Flown

Administrator
Mitarbeiter
Wow ich wollte keine: Wer schreibts kürzer? Challenge heraufbeschwören. Sondern war neugierig wie ein paar Zeichen ~5 MB erzeugen.

Wenn schon eine Challenge: Welcher Algorithmus ist schneller?
 
X

Xyz1

Gast
Meiner ist der schnellste. :D

Nein, Blödelei, ich schreibe das jetzt nochmal in Uralt-C, dann kommen da auch nicht 5 MB (~) bei raus. Und meine Identität wird auch geschützt.
 
Flown

Flown

Administrator
Mitarbeiter
OT: GCJ ist ja mal ein unnützes, aber witziges Tool. Schade das seit 7 Jahren daran nichts mehr gemacht wurde.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Flown hat gesagt.:
OT: GCJ ist ja mal ein unnützes, aber witziges Tool. Schade das seit 7 Jahren daran nichts mehr gemacht wurde.
Zum Vergrößern anklicken....

Gibt aber zB Excelsior Jet, ist das gleiche in Closed Source ;)

JStein52 hat gesagt.:
Warum denn das ? Soweit ich mich erinnere hat der TE schon nach Java-Code gefragt
Zum Vergrößern anklicken....
Na er gibt doch keinen Java-Code mehr raus, und dann kann er wenigstens irgendwas zeigen :p (also wenn er es schafft, seinen Nutzernamen nicht wieder in der Exe unterzubringen...)
 
X

Xyz1

Gast
So sollte das bei euch schauen:

se.PNG

Viel Spaß damit :) .
Anbei: Diesmal steht mein Benutzername nicht drin...
Anbei 2: C-Code kann jetzt von der Schnelligkeit aber nicht eingeholt werden...
Anbei 3: Jow, leider wurde an GCJ seid Jahren nix mehr gemacht, Generics, Autoboxing usw. - das gibt's dort alles nicht.
Anbei 4:
C: 
//
// This file was generated by the Retargetable Decompiler
// Website: https://retdec.com
// Copyright (c) 2016 Retargetable Decompiler <info@retdec.com>
//

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

// ------------------- Function Prototypes --------------------

int32_t _rek(char * a1, char * a2, int32_t a3);

// --------------------- Global Variables ---------------------

int32_t * g1; // 0x40da40

// ------------------------ Functions -------------------------

// Address range: 0x401439 - 0x401589
int32_t _rek(char * a1, char * a2, int32_t a3) {
    // 0x401439
    if (a3 != 8) {
        // branch -> 0x40154f
        int32_t v1; // 0x401573
        for (int32_t i = 0; i < 5; i++) {
            // 0x40154f
            g1[a3] = i;
            v1 = _rek(a1, a2, a3 + 1);
            // continue -> 0x40154f
        }
        // branch -> 0x401588
        // 0x401588
        return (int32_t)(char *)v1;
    }
    int32_t v2 = 0;
    char * v3 = a1; // 0x01329
    char * chars_printed; // 0x401589_14
    int32_t v4;
    int32_t v5;
    char * v6; // bp+012
    while (true) {
        // 0x401452
        chars_printed = "\x90\x83\x7d\x08";
        char * v7; // 0x401589_13
        switch (g1[v2]) {
            case 0: {
                v6 = v3;
                v7 = "\x90\x83\x7d\x08";
              lab_0x401495_4:
                // 0x401495
                if (v6 > NULL) {
                    int32_t v8 = v2 + 1; // 0x4014a0
                    if (v8 >= 8) {
                        // break (via goto) -> 0x4014ac
                        goto lab_0x4014ac;
                    }
                    v2 = v8;
                    v3 = v6;
                    // continue -> 0x401452
                    continue;
                } else {
                    chars_printed = v7;
                }
                break;
            }
            case 1: {
                char * v9 = (char *)(3 * (int32_t)v3); // 0x401475_4
                v6 = v9;
                v7 = v9;
                // branch -> 0x401495
                goto lab_0x401495_4;
            }
            case 2: {
                // 0x40147c
                v6 = (char *)(2 * (int32_t)v3 - 323);
                v7 = "\x90\x83\x7d\x08";
                // branch -> 0x401495
                goto lab_0x401495_4;
            }
            case 3: {
                // 0x401488
                v6 = (char *)((int32_t)v3 + 27);
                v7 = "\x90\x83\x7d\x08";
                // branch -> 0x401495
                goto lab_0x401495_4;
            }
            case 4: {
                // 0x40148e
                v6 = (char *)((int32_t)v3 - 13);
                v7 = "\x90\x83\x7d\x08";
                // branch -> 0x401495
                goto lab_0x401495_4;
            }
            case 5: {
                // 0x4014e9
                printf(" + 0)");
                // branch -> 0x4014f5
            }
            case 6: {
                // 0x4014f5
                printf(" * 3)");
                v5 = v2;
                // branch -> 0x401530
              lab_0x401530_11:;
                int32_t v10 = v5 + 1; // 0x40152c
                if (v10 < 8) {
                    v4 = v10;
                    // 0x4014cd
                    chars_printed = "\xc7\x04\x24\xca\xa0\x40";
                    switch (g1[v4]) {
                        case 0: {
                            // 0x4014e9
                            printf(" + 0)");
                            // branch -> 0x4014f5
                        }
                        case 1: {
                            // 0x4014f5
                            printf(" * 3)");
                            v5 = v4;
                            // branch -> 0x401530
                            goto lab_0x401530_11;
                        }
                        case 2: {
                            // 0x401503
                            printf(" * 2 - 323)");
                            v5 = v4;
                            // branch -> 0x401530
                            goto lab_0x401530_11;
                        }
                        case 3: {
                            // 0x401511
                            printf(" + 27)");
                            v5 = v4;
                            // branch -> 0x401530
                            goto lab_0x401530_11;
                        }
                        case 4: {
                            // 0x40151f
                            printf(" - 13)");
                            v5 = v4;
                            // branch -> 0x401530
                            goto lab_0x401530_11;
                        }
                    }
                    // 0x401588
                    return (int32_t)chars_printed;
                }
                // 0x401538
                chars_printed = (char *)printf("\n");
                // branch -> 0x401588
                // 0x401588
                return (int32_t)chars_printed;
            }
            case 7: {
                // 0x401503
                printf(" * 2 - 323)");
                v5 = v2;
                // branch -> 0x401530
                goto lab_0x401530_11;
            }
            case 8: {
                // 0x401511
                printf(" + 27)");
                v5 = v2;
                // branch -> 0x401530
                goto lab_0x401530_11;
            }
            case 9: {
                // 0x40151f
                printf(" - 13)");
                v5 = v2;
                // branch -> 0x401530
                goto lab_0x401530_11;
            }
        }
        // 0x401588
        return (int32_t)chars_printed;
    }
  lab_0x4014ac:
    // 0x4014ac
    if (v6 != a2) {
        // 0x401588
        return (int32_t)v6;
    }
    // 0x401530
    printf("((((((((1");
    v4 = 0;
    // branch -> 0x4014cd
    // 0x4014cd
    chars_printed = "\xc7\x04\x24\xca\xa0\x40";
    switch (g1[v4]) {
        case 0: {
            // 0x4014e9
            printf(" + 0)");
            // branch -> 0x4014f5
        }
        case 1: {
            // 0x4014f5
            printf(" * 3)");
            v5 = v4;
            // branch -> 0x401530
            goto lab_0x401530_11;
        }
        case 2: {
            // 0x401503
            printf(" * 2 - 323)");
            v5 = v4;
            // branch -> 0x401530
            goto lab_0x401530_11;
        }
        case 3: {
            // 0x401511
            printf(" + 27)");
            v5 = v4;
            // branch -> 0x401530
            goto lab_0x401530_11;
        }
        case 4: {
            // 0x40151f
            printf(" - 13)");
            v5 = v4;
            // branch -> 0x401530
            goto lab_0x401530_11;
        }
    }
    // 0x401588
    return (int32_t)chars_printed;
}

// Address range: 0x40158a - 0x40162f
int main(int argc, char ** argv) {
    ___main();
    printf("Start: ");
    char * v1;
    scanf("%d", &v1);
    printf("Stopp: ");
    char * v2;
    scanf("%d", &v2);
    _rek(v1, v2, 0);
    printf("Fertig? ");
    int32_t v3;
    scanf("%c", &v3);
    scanf("%c", &v3);
    return 0;
}

// --------------- Statically Linked Functions ----------------

// void ___main(void);
// int printf(const char *restrict, ...);

// --------------- Dynamically Linked Functions ---------------

// int scanf(const char *restrict, ...);

// --------------------- Meta-Information ---------------------

// Detected compiler/packer: gcc (4.9.3)
// Detected functions: 2
// Decompiler release: v2.1.2 (2016-01-27)
// Decompilation date: 2016-07-01 16:18:20
 

Anhänge

  • Schnelle.zip
    26,6 KB · Aufrufe: 5
Zuletzt bearbeitet von einem Moderator:
X

Xyz1

Gast
@JStein52 : Ich hab den Source mal hinzugefügt, damit's nicht so langweilig ist. :D

Und eure Programme? (länge, schnelligkeit, usw., wtf. :( )
 
X

Xyz1

Gast
Rekursion kostet in C nix. :D Konsolenausgabe entfernen... ein Programm ganz ohne Ausgabe finde ich eher nicht so spannend. Über die asymptotische Laufzeit brauchen wir wohl nicht sprechen, da ändert sich nämlich Nullkommanix. :D

Aber ist okay, nicht jeder kann alles wissen, so wie ich. :)

Gleich noch Nachtrag:
http://stackoverflow.com/questions/4008595/recursion-overhead-how-serious-is-it
Finally, remember that programmer time is more expensive than CPU time. Before you micro-optimize your code, it really is a good idea to measure to see if it really will be an issue.
Zum Vergrößern anklicken....

Wozu alles erneut schreiben, wenn es schon geschrieben wurde? Premature Optimization...
 
Zuletzt bearbeitet von einem Moderator:
InfectedBytes

InfectedBytes

Top Contributor
DerWissende hat gesagt.:
Rekursion kostet in C nix.
Zum Vergrößern anklicken....
Genau...dann vergleiche mal, nur so zum Spaß, eine iterative und rekursive Fakultäts funktion.

Achtung Spoiler!!! iterativ ist schneller.
Auch in C kosten Funktionsaufrufe eben was, da auch dort StackFrames erzeugt werden.

Asymptotische Laufzeit...na super, asymptotisch ist dein Code genauso schnell wie ne Java oder sogar JavaScript Lösung xD

DerWissende hat gesagt.:
Aber ist okay, nicht jeder kann alles wissen, so wie ich. :)
Zum Vergrößern anklicken....
xDDD
 
X

Xyz1

Gast
Es stimmt schon, Variablen müssen kopiert werden, aber bei 3 int's (freundlicherweise macht der Compiler sogar char's draus), beißt sich da nix. Wir habn auch keine hohe Rekursionstiefe (maximal 8). Usw.

----

Es ging mir lediglich darum, dass ich keine Komplettlösung darstelle.
 
F

flopalko

Bekanntes Mitglied
Geilster Thread ever :D
Der Wissende stellt Thesen auf wie Rekursion kostet in C nix, wenn er berichtigt wird meint er dass das bei 3 ints nichts ausmacht bei einer geringen Rekursionstiefe. Überraschung: in Java kostet das dann auch nix^^
Ganz ehrlich das ist genauso wie wenn ich sag ein Programm das 2GB RAM verbraucht ist speicherschonend weil ich es auf einem Server rennen hab der 128GB RAM hat und auf dem sonst nix rennt. Du kannst ja nicht vom Spezialfall auf den allgemeinen Fall schließen, was soll sowas? xD
 
Flown

Flown

Administrator
Mitarbeiter
Leute: ich muss jetzt @DerWissende etwas in Schutz nehmen. Manchmal halte ich ihn für einen ziemlichen Troll - was auch nicht zutrifft, eher eine Person mit einer Portion Arroganz und großem Ego, nehm ich an.
Er hat mit vielen seiner Aussagen recht und es sollte auch nicht immer alles in die Waagschale gelegt werden.
Viel schneller als C geht kaum? Natürlich geht es schneller mit Assembler, aber wer macht sich solche Mühe und für welchen Speedup?
Rekursion vs Iteration: Er hat auch recht, auch wenn es ein wenig unglücklich ausgedrückt ist. Es ist bei den "meisten" Algorithmen egal ob das Eine oder Andere, hauptsache es ist leselich!

Die Threads in dem er postet explodieren immer weil alles, wirklich alles, kritisiert wird. Wenn euch etwas stört: Berichtigen, Quellen dazu geben und fertig. Dem Leser ist es dann überlassen, was er glauben soll oder nicht.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Flown hat gesagt.:
Wäre nett, aber sonst würde hier eine Lösung gepostet werden und das wiederum wäre Hausaufgaben gratis erledigen und das will hier auch niemand machen oder?
Zum Vergrößern anklicken....
Naja, wäre immer noch C-Code, und wenn der TE schon an 'ner Idee scheitert und der Hinweis auf BFS nicht reicht, wird ihn der auch kaum weiterbringen, zumindest das dekompilierte ist ja auch schon gepostet..
 
X

Xyz1

Gast
Es nützt nichts. Selbst mit -O3 und -g macht der Compiler und Decompiler Optimierungen draus, und es kommt Halb-Chinesisch raus - mit dem der TO wahrscheinlich nicht viel anfangen können wird.

Ich geb euch jetzt einfach mal den Source:

C: 
int array[8];

void rek(int i, int j, int index) {
    int k;
    if (index == sizeof(array) / sizeof(int)) {
        for (k = 0; k < sizeof(array) / sizeof(int); k++) {
            switch(array[k]) {
                case 0:
                break;
                case 1:
                i *= 3;
                break;
                case 2:
                i *= 2;
                i -= 323;
                break;
                case 3:
                i += 27;
                break;
                case 4:
                i -= 13;
                break;
                default:
                return;
            }
            if (i < 0) {
                return;
            }
        }
        if (i == j) {
            printf("((((((((1");
            for (k = 0; k < sizeof(array) / sizeof(int); k++) {
                switch(array[k]) {
                case 0:
                printf(" + 0)");   
                case 1:
                printf(" * 3)");
                break;
                case 2:
                printf(" * 2 - 323)");
                break;
                case 3:
                printf(" + 27)");
                break;
                case 4:
                printf(" - 13)");
                break;
                default:
                return;
                }
            }
            printf("\n");
        }
    } else {
        for (k = 0; k <= 4; k++) {
            array[index] = k;
            rek(i, j, index + 1);
        }
    }
}

int main(int argc, char ** argv) {
    char c;
    int i, j;
    printf("Start: ");
    scanf("%d", &i);
    printf("Stopp: ");
    scanf("%d", &j);
    rek(i, j, 0);
    printf("Fertig? ");
    scanf("%c", &c);
    scanf("%c", &c);
    return EXIT_SUCCESS;
}
Achtung: Includes weggelassen.

Achtung: Nicht formatiert, Eclipse hat mir mal nicht geholfen.

Achtung: Ich weiß, dass die Eingabe so in der Form sehr rudimentär ist.

Wenn ihr möchtet, könnt ihr den ja kritisieren oder eine schnellere Version zum Besten geben.

Was die Rekursion betrifft, ihr tut so, als sei ich nicht in der Lage, aus einer Rekursion fein sauber Iteration zu machen.

Das stimmt natürlich nicht.

Und es stimmt, immer, wenn ich poste, geht das Thema sehr in die Länge. Vielleicht bin ich Anti-Communitfisch eingestellt. :D ^^

Freundliche Grüße

Achtung: Wäre nett, wenn sich der TO noch mal melden könnte, ob er etwas erreicht hat oder daran gescheitert ist.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Grad nur nen kurzen Blick drauf geworfen. Das sieht mehr nach stumpfem BruteForce aus, als nach Sinnvoller DFS oder BFS. Und damit auch ziemlich überflüssige Rekursion.
Das hätte man leichter mit einfachem quaternären(?) hochzählen machen können, dann hätte man sich ziemlich viel drumrum gespart...
 
X

Xyz1

Gast
quaternär nicht, nein. Aber ich weiß, was du meinst. Wie sollte es auch anders sein? :D

Naja, bleibt jedem überlassen, inwieweit elegant & richtig er das umsetzen möchte.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Auch BruteForce, aber um einiges schneller als das von @DerWissende :
C: 
void it() {
    #define SIZE 8
    #define START 1
    #define STOP 1000

    unsigned int  masks[SIZE] = {0x3<<14,0x3<<12,0x3<<10,0x3<<8,0x3<<6,0x3<<4,0x3<<2,0x3};
    unsigned int  ks[SIZE] = {14,12,10,8,6,4,2,0};

    for (int a = 0;a < 0x10000;a++) {
        int i = START;
        for (int k = 0; k < SIZE; k++) {
            int b = (a & masks[k]) >> ks[k] ;

            switch(b) {
                case 0:
                    i *= 3;
                    break;
                case 1:
                    i *= 2;
                    i -= 323;
                    break;
                case 2:
                    i += 27;
                    break;
                case 3:
                    i -= 13;
                    break;
            }
            if (i < 0) {
                break;
            }
        }
        if (i == STOP) {
            printf("((((((((1");
            for (int k = 0; k < SIZE; k++) {
                int b = (a & masks[k]) >> ks[k] ;
                switch(b) {
                    case 0:
                        printf(" * 3)");
                        break;
                    case 1:
                        printf(" * 2 - 323)");
                        break;
                    case 2:
                        printf(" + 27)");
                        break;
                    case 3:
                        printf(" - 13)");
                        break;
                }
            }
            printf("\n");
        }
    }
}
 
X

Xyz1

Gast
Deins ist zu kompliziert. Mit nicht quaternär meinte ich einfach Zähler um 1 inkrementieren. Bitte tu doch nicht so, als sei ich nicht geschickter als du. Jeder findet mal seinen Meister. ;) :mad: :rolleyes:
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
S Abwandlung der Fibonacci Folge Java Basics - Anfänger-Themen 3
berserkerdq2 Wo geschieht der "Rücksprung, bei der rekursiven Folge Java Basics - Anfänger-Themen 5
sserio Längste Collatz-Folge Java Basics - Anfänger-Themen 11
D Grösste Zahl in einer Folge herausfinden. (ULAM) Java Basics - Anfänger-Themen 9
J Rekursive Folge (a=a-1) Java Basics - Anfänger-Themen 9
GAZ Tribonacci Folge Rekursiv Java Basics - Anfänger-Themen 11
D Hofstäter Q Folge Java Basics - Anfänger-Themen 3
V Fibonacci Folge Java Basics - Anfänger-Themen 4
M Methoden Fibonacci-Folge Java Basics - Anfänger-Themen 6
J Fibonacci -Folge rekursiv berechnen Java Basics - Anfänger-Themen 18
S Negafibonacci Folge berechnen Java Basics - Anfänger-Themen 24
G Harmonische Rekursive Folge Java Basics - Anfänger-Themen 3
M Fibonacci-Folge mit while-Schleife Java Basics - Anfänger-Themen 4
J Byte Folge erkennen Java Basics - Anfänger-Themen 5
A Gerade Terme der Fibonacci-Folge aufsummieren Java Basics - Anfänger-Themen 12
R Roboter - Helmich Folge 6 Java Basics - Anfänger-Themen 32
S rekursive folge verbessern Java Basics - Anfänger-Themen 2
H JOptionPane YES Option mit Folge? Java Basics - Anfänger-Themen 2
P Collatz-Folge mittels indirekter Rekursion Java Basics - Anfänger-Themen 8
X Problem mit Ducci-Folge Java Basics - Anfänger-Themen 7
S Fibonacci Folge Java Basics - Anfänger-Themen 34
B Element in Folge suchen Java Basics - Anfänger-Themen 7
L iterative und rekursive Folge Java Basics - Anfänger-Themen 20
N Folge verschiedener Nährwerte zur Kubikwurzel Java Basics - Anfänger-Themen 15
I Fibonacci-Folge , direkter Weg. Java Basics - Anfänger-Themen 5
J Wurzel mit einer Folge brechnen Java Basics - Anfänger-Themen 5
E Rekursive definierten Folge Java Basics - Anfänger-Themen 10
D Bit-Folge bearbeiten Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen


Oben