# Mehrfache print ausgabe ohne Schleife oder Rekursiven aufruf?



## Erebos1988 (2. Okt 2009)

Ich habe hier eine Aufgabe vor mir und weiß nicht weiter.
Es soll mehrmals der gleiche Satz ausgegeben werden zb 1000 mal und das ohne Schleife und ohne Rekursion.
Der Quelltext soll aber auch keine 1000 Zeilen lang sein.

Das einzige was mir dann noch einfällt wären 3 Methoden die jeweils 10 prints enthalten, die verknüpft man noch miteinander und dann hätte man 10x10x10.

Wäre das wirklich die Lösung oder gibts da noch was besseres?


----------



## Marco13 (2. Okt 2009)

Das mit den Methoden klingt in Ermangelung von Alternativen für mich im Moment nach der einzigen Lösung - aber nur für eine Feste Anzahl...  Wie soll die Anzahl der Aufrufe angegeben werden?


----------



## Erebos1988 (2. Okt 2009)

Ist in dem Fall auf 1000 festgelegt, es kann auch nur was ganz simples sein, weil die meisten Leute nicht Programmieren können.
Tja dann wirds wohl wirklich so sein. Muss man erstmal drauf kommen, weil man ja gleich an schleifen denkt.


----------



## Landei (3. Okt 2009)

Ist das hier gemogelt?

```
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 *
 * @author Gronau
 */
public class TimerTest {
   public static void main(String... args) {
       final int times = 1000;
       final Timer timer = new Timer();
       Timer stopper = new Timer(true);
       timer.schedule(new TimerTask(){
            @Override
            public void run() {
                timer.cancel();
            }
        }, new Date(System.currentTimeMillis() + (times-1)*1000));
       timer.schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println("Cheater!!!");
            }
        }, new Date(), 1000);
   }
}
```


----------



## Erebos1988 (3. Okt 2009)

Ich denke das ist etwas zu umständlich :-D aber interessant finde ich es trotzdem.


----------



## 0x7F800000 (3. Okt 2009)

Erebos1988 hat gesagt.:


> Das einzige was mir dann noch einfällt wären 3 Methoden die jeweils 10 prints enthalten, die verknüpft man noch miteinander und dann hätte man 10x10x10.
> 
> Wäre das wirklich die Lösung oder gibts da noch was besseres?


Naja, die idee scheint (zumindest in diesem Knobelaufgaben-Kontext) richtig, nur hast du's schlecht faktorisiert^^

1000=5^3*2^3 , das ist weniger zu tippen, als zehnmal dasselbe^^

```
import static java.lang.System.*;

public class _ {
	private static Runnable twice(final Runnable r){
		return new Runnable(){@Override public void run(){r.run(); r.run();}};
	}
	private static Runnable fiveTimes(final Runnable r){
		return new Runnable(){
			@Override public void run(){
				twice(twice(r)).run();
				r.run();
			}
		};
	}
	private static Runnable tenTimes(final Runnable r){
		return twice(fiveTimes(r));
	}
	public static void main(String... args){
		tenTimes(tenTimes(tenTimes(new Runnable(){
			@Override public void run(){ out.println("rofl"); }
		}))).run();
	}
}
```


----------



## Marco13 (3. Okt 2009)

@Andrey: Sowas ähliches hatte ich bei meiner ersten Nachfrage schon im Hinterkopf - allerdings auf eine etwas ... "krampfige" Art "systematischer": Wenn die Anzahl der Aufrufe angegeben werden können soll, wäre das dann sowas wie

```
class Repeater
{
    public static void main(String args[])
    {
        //createCode();

        run(1);
        run(6);
        run(23);
        run(1000);

    }

    public static void run(int n)
    {
        System.out.println("Result for "+n+":");
        if ((n & (1<<0))!=0) run0001();
        if ((n & (1<<1))!=0) run0002();
        if ((n & (1<<2))!=0) run0004();
        if ((n & (1<<3))!=0) run0008();
        if ((n & (1<<4))!=0) run0016();
        if ((n & (1<<5))!=0) run0032();
        if ((n & (1<<6))!=0) run0064();
        if ((n & (1<<7))!=0) run0128();
        if ((n & (1<<8))!=0) run0256();
        if ((n & (1<<9))!=0) run0512();
    }
    public static void run0001() { System.out.println("run"); }
    public static void run0002() { run0001(); run0001(); }
    public static void run0004() { run0002(); run0002(); }
    public static void run0008() { run0004(); run0004(); }
    public static void run0016() { run0008(); run0008(); }
    public static void run0032() { run0016(); run0016(); }
    public static void run0064() { run0032(); run0032(); }
    public static void run0128() { run0064(); run0064(); }
    public static void run0256() { run0128(); run0128(); }
    public static void run0512() { run0256(); run0256(); }

    /*
    private static String pad(String s, int n)
    {
        while (s.length()<n) s = "0"+s;
        return s;
    }
    private static void createCode()
    {
        System.out.println("public static void run0001() { System.out.println(\"run\"); }");
        for (int i=1; i<=9; i++)
        {
            String n1 = pad(String.valueOf(1<<i), 4);
            String n0 = pad(String.valueOf(1<<(i-1)), 4);
            String s = "public static void run"+n1+"() { run"+n0+"(); run"+n0+"(); }";
            System.out.println(s);
        }
    }
    */

}
```

 :smoke:


----------



## 0x7F800000 (3. Okt 2009)

Lass mal raten: den code hast du machinell erzeugt und dabei 5 verschiedene schleifen verwendet^^


----------



## Marco13 (3. Okt 2009)

Ich wollte ja gewappnet sein, wenn er sich drüber beschwert, dass das nicht für 1 Milliarde Wiederholngen funktioniert --->


```
class Repeater
{
    public static void main(String args[])
    {
        //createCode();

        run(1);
        run(6);
        run(23);
        run(1000);

    }

    public static void run(int n)
    {
        System.out.println("Result for "+n+":");
        if ((n & (1<<0))!=0) run0000000001();
        if ((n & (1<<1))!=0) run0000000002();
        if ((n & (1<<2))!=0) run0000000004();
        if ((n & (1<<3))!=0) run0000000008();
        if ((n & (1<<4))!=0) run0000000016();
        if ((n & (1<<5))!=0) run0000000032();
        if ((n & (1<<6))!=0) run0000000064();
        if ((n & (1<<7))!=0) run0000000128();
        if ((n & (1<<8))!=0) run0000000256();
        if ((n & (1<<9))!=0) run0000000512();
        if ((n & (1<<10))!=0) run0000001024();
        if ((n & (1<<11))!=0) run0000002048();
        if ((n & (1<<12))!=0) run0000004096();
        if ((n & (1<<13))!=0) run0000008192();
        if ((n & (1<<14))!=0) run0000016384();
        if ((n & (1<<15))!=0) run0000032768();
        if ((n & (1<<16))!=0) run0000065536();
        if ((n & (1<<17))!=0) run0000131072();
        if ((n & (1<<18))!=0) run0000262144();
        if ((n & (1<<19))!=0) run0000524288();
        if ((n & (1<<20))!=0) run0001048576();
        if ((n & (1<<21))!=0) run0002097152();
        if ((n & (1<<22))!=0) run0004194304();
        if ((n & (1<<23))!=0) run0008388608();
        if ((n & (1<<24))!=0) run0016777216();
        if ((n & (1<<25))!=0) run0033554432();
        if ((n & (1<<26))!=0) run0067108864();
        if ((n & (1<<27))!=0) run0134217728();
        if ((n & (1<<28))!=0) run0268435456();
        if ((n & (1<<29))!=0) run0536870912();
        if ((n & (1<<30))!=0) run1073741824();
    }

    public static void run0000000001() { System.out.println("run"); }
    public static void run0000000002() { run0000000001(); run0000000001(); }
    public static void run0000000004() { run0000000002(); run0000000002(); }
    public static void run0000000008() { run0000000004(); run0000000004(); }
    public static void run0000000016() { run0000000008(); run0000000008(); }
    public static void run0000000032() { run0000000016(); run0000000016(); }
    public static void run0000000064() { run0000000032(); run0000000032(); }
    public static void run0000000128() { run0000000064(); run0000000064(); }
    public static void run0000000256() { run0000000128(); run0000000128(); }
    public static void run0000000512() { run0000000256(); run0000000256(); }
    public static void run0000001024() { run0000000512(); run0000000512(); }
    public static void run0000002048() { run0000001024(); run0000001024(); }
    public static void run0000004096() { run0000002048(); run0000002048(); }
    public static void run0000008192() { run0000004096(); run0000004096(); }
    public static void run0000016384() { run0000008192(); run0000008192(); }
    public static void run0000032768() { run0000016384(); run0000016384(); }
    public static void run0000065536() { run0000032768(); run0000032768(); }
    public static void run0000131072() { run0000065536(); run0000065536(); }
    public static void run0000262144() { run0000131072(); run0000131072(); }
    public static void run0000524288() { run0000262144(); run0000262144(); }
    public static void run0001048576() { run0000524288(); run0000524288(); }
    public static void run0002097152() { run0001048576(); run0001048576(); }
    public static void run0004194304() { run0002097152(); run0002097152(); }
    public static void run0008388608() { run0004194304(); run0004194304(); }
    public static void run0016777216() { run0008388608(); run0008388608(); }
    public static void run0033554432() { run0016777216(); run0016777216(); }
    public static void run0067108864() { run0033554432(); run0033554432(); }
    public static void run0134217728() { run0067108864(); run0067108864(); }
    public static void run0268435456() { run0134217728(); run0134217728(); }
    public static void run0536870912() { run0268435456(); run0268435456(); }
    public static void run1073741824() { run0536870912(); run0536870912(); }

    /*
    private static String pad(String s, int n)
    {
        while (s.length()<n) s = "0"+s;
        return s;
    }
    private static void createCode()
    {
        int padding = 10;
        System.out.println("public static void run0000000001() { System.out.println(\"run\"); }");
        for (int i=1; i<=30; i++)
        {
            String n1 = pad(String.valueOf(1<<i), padding);
            String n0 = pad(String.valueOf(1<<(i-1)), padding);
            String s = "public static void run"+n1+"() { run"+n0+"(); run"+n0+"(); }";
            System.out.println(s);
        }
        for (int i=1; i<=30; i++)
        {
            System.out.println("if ((n & (1<<"+i+"))!=0) run"+pad(String.valueOf(1<<i), padding)+"();");
        }

    }
    //*/

}
```



Keine Schleifen, keine Rekursion....


----------



## 0x7F800000 (3. Okt 2009)

Marco13 hat gesagt.:


> Ich wollte ja gewappnet sein, wenn er sich drüber beschwert, dass das nicht für 1 Milliarde Wiederholngen funktioniert --->


:applaus: :lol:


----------



## cfcnigel (7. Okt 2009)

Hallo,

ich habe die gleiche Aufgabe wie der Themenstarter,
nur das wir in der FH noch nicht wirklich etwas der gleichen durchgenommen haben.
Da ich schon andre Programmiersprachen kenne, hätte ich die Aufgabe mit einer Schleife gelöst, leider darf ich dies aber nicht.

Da ich bisher nur ein HelloWord Programm geschrieben habe, habe ich leider keine Ahnung wie sich das lösen lässt.

Hier die Aufgabe:

*A.1.f Eine Nachricht 1000 Mal ausgeben (5 Punkte)*
Schreiben Sie ein Java-Programm, das folgende Nachricht von Immanuel Kant 1000 Mal ausgibt:
_Habe Mut dich deines eigenen Verstandes zu bedienen!_
Ihr Programm sollte nicht 1000 Zeilen lang sein. Benutzen Sie Methoden, um das Programm zu kürzen.
Benutzen Sie keine Schleifen und keine Rekursion (kommt später in der Vorlesung), nur den einfachen
Methodenaufruf.

Gibt es dafür den keine einfach simple Lösung, die oben geposteten Vorschläge erscheinen mir recht kompliziert.

Hoffe auf Hilfe, Danke und Gruß


----------



## Leroy42 (7. Okt 2009)

cfcnigel hat gesagt.:


> Ihr Programm sollte nicht 1000 Zeilen lang sein....Gibt es dafür den keine einfach simple Lösung



Nicht 1000 Zeilen lang. Mehr Zeilen oder weniger Zeilen?

Wenn's weniger Zeilen sein sollen, dann schreib doch einfach eine Methode mit
kurzen Namen von der du in einer Zeile mehrere aufrufen kannst.

Etwa so:


```
...
public static x() {System.out.print("Habe Mut dich deines eigenen Verstandes zu bedienen!")}
...
public static void main(String[] args) {
    x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();
    x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();x();
    ...
}
```

Und das ganze jetzt sooft bis die 1000 Ausgaben erreicht werden. 

Zwar bei weitem nicht so _elegant_ wie die Lösungen meiner Vorredner aber wenn die
Aufgabe *so* gestellt wurde, würde ich diese Lösung mit Absicht so abgeben. :noe: D)


----------



## eRaaaa (7. Okt 2009)

hmm, was ist mit indirekten schleifen? die sind doch wohl erlaubt oder? 


```
String[] s = new String[1000];
		Arrays.fill(s, "Habe Mut dich deines eigenen Verstandes zu bedienen!");
		System.out.println(Arrays.toString(s));
```

:bae:


----------



## Leroy42 (7. Okt 2009)

eRaaaa hat gesagt.:


> hmm, was ist mit indirekten schleifen? die sind doch wohl erlaubt oder?



LOL! Noch besser!


----------



## eRaaaa (7. Okt 2009)

denke aber trotzdem nicht, dass das, das gewollte ergebnis des aufgabenstellers war, deshalb würd emich mal die musterlösung dazu interessieren.

@cfcnigel, wär cool wenn du die hier veröffentlichen könntest (oder halt per pn), wenn du mehr weisst :>


----------



## cfcnigel (7. Okt 2009)

Also meine Klassenkollegen machen das mit 3 Mal ne Methode aufrufen, den wie der Threadstarter schon schreibt 10x10x10... allerdings ist mir nicht klar wie. 
Die Kollegen von mir verraten natürlich auch nichts.


----------



## SlaterB (7. Okt 2009)

du hast eine Methode A,  die 10x was ausgibt,
an anderer Stelle rufst du A zweimal auf, mit diesen zwei Aufrufen erzeugst du insgesamt 20 Ausgaben


----------



## cfcnigel (7. Okt 2009)

könnt ihr mir bitte dazu den kompletten code posten, ich blicke da nämlich noch nicht so wirklich durch
wenn ich es so schreibe wie eRaaaa dann bekomme ich eine fehlermeldung: can not found symbol

[Java]
class tausend2
{
public static void main(String[] args )
	{
	String[] s = new String[1000];
        Arrays.fill(s,"Habe Mut dich deines eigenen Verstandes zu bedienen!");
        System.out.println(Arrays.toString(s));
	}
}
[/code]


----------



## eRaaaa (7. Okt 2009)

```
import java.util.Arrays;
```
 fehlt bei dir wohl 

wegen der 3 methoden-geschichte: versuchs doch vllt erstmal mit 2 und 100 mal den string ausgeben oder ähnlich.


----------



## ARadauer (7. Okt 2009)

wenn du keine Schleifen und keine Rekursion verwenden darfst, da du das erst lerns. Dann wirst du 100%ig auch kein  Arrays.fill verwenden dürfen!



> Die Kollegen von mir verraten natürlich auch nichts.









Was wird wohl der Lehrer erwarten? Sowas oder?

```
public class TausendNachrichten {

	public static void main(String[] args) {
		print1000Messages();
	}
	
	public static void print1000Messages(){
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
		print100Messages();
	}

	public static void print100Messages(){
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
		print10Messages();
	}

	public static void print10Messages(){
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();
		print1Message();		
	}

	public static void print1Message(){
		System.out.println("Die ersten Beispiele im Studium sind nur der Anfang... Es wird noch viel schwerer ;-)");		
	}

}
```

Ist ja ganz einfach oder? Und was ist der Sinn? Wiederholt sich ja immer alles... mhn vielleicht wären da Schleifen besser... und somit haben wir die Überleitung zum nächsten Kapitel... 

ich finde diese Art zu unterichten wirklich super, das bring die Studenten wirklich an die Materie heran.

mah sorry das war ja genau deine idee: *selbst schäm* das hab ich jetzt gar nicht mehr gelesen...


----------



## 0x7F800000 (7. Okt 2009)

eRaaaa hat gesagt.:


> hmm, was ist mit indirekten schleifen? die sind doch wohl erlaubt oder?



ja gut, wenn schon, dann schon:

```
import javax.script.*;

public class _ {
	public static void main(String[] args)throws Exception{
		new ScriptEngineManager().
			getEngineByName("JavaScript").
			eval("for(i=0;i<1000;i=i+1) print(\""
				+"Habe Mut dich deines eigenen Verstandes zu bedienen!"
				+"\\n\")");
	}
}
```
Keine schleifen, keine Rekursionen, keine zusätzliche methoden. Eine einzige Anweisung mit einem String-Literal als Argument :bae:

@cfcnigel: nicht nur dass du an der trivialsten Aufgabe hängen bleibst: da stehen schon 5 Lösungen und Vorschläge zur exakt der selben Aufgabe, und du kannst nicht mal irgendwas kopieren oder nachahmen? Bist du dir sicher, dass bei dir der Spruch vom Kant angekommen ist? ???:L


----------



## Landei (7. Okt 2009)

```
import java.util.Arrays;
import java.util.Comparator;

public class Thousand {

    private static int X = 1000;
    private int x = X--;

    public static void main(String... args) {
        Thousand[] array = new Thousand[]{
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
            new Thousand(), new Thousand(), new Thousand(),
        };
        TC tc =  new TC();
        Arrays.sort(array, tc);
        tc.compare(array[1], array[1]);
    }

    static class TC implements Comparator<Thousand> {

        public int compare(Thousand o1, Thousand o2) {
            say(); say(); say(); say(); say();
            return o1.x - o2.x;
        }
        private void say() {
            System.out.println("Habe Mut dich deines eigenen Verstandes zu bedienen!");
        }
    }
}
```


----------



## 0x7F800000 (7. Okt 2009)

Uuuuh... jetzt wird's langsam schwer... Wie kommst du darauf, dass es ausgerechnet 48 sein müssen? ???:L Experimentell?


----------



## Landei (7. Okt 2009)

Wie sonst? :-D


----------



## 0x7F800000 (7. Okt 2009)

naja, wenn man weiß dass da ein ganz bestimmter nicht randomisierter Merge-Sort algo zum einsatz kommt, hätte man es prinzipiell ausrechnen können^^


----------



## cfcnigel (8. Okt 2009)

Hallo,

erst mal vielen Dank an alle für ihre vielen Antworten. Ich habe Abgabe-Termin am Montag werde euch dann hier die Musterlösung präsentieren.

Da wir ja eigentlich beim Thema Schleifen sind, ich hätte das einfach so gelöst.

[Java]
class tausend
{
  public static void main ( String[] args )

  {
  int zaehler = 0;

  while (zaehler <= 1000 )
  	{
  	System.out.println("Habe Mutig dich deines Eigenen verstandes zu bedienen!");
  	zaehler = zaehler + 1;
  	}
  }
 }
[/code]


----------



## SlaterB (8. Okt 2009)

diese Lösung lässt leichte Punktabzüge befürchten


----------



## cfcnigel (8. Okt 2009)

Ja das wird wohl so sein, aber wenn wir uns mal die andren Lösungen ansehen ist das doch alles totaler quatsch  (nicht persönlich gemeint, die lösungen sind ja alle sehr gut). ich meine das alles macht es aber nur unnötig kompliziert und den quelltext sehr lange.


----------



## Opnox (8. Okt 2009)

Und deine "Lösung" geht einfach an der Aufgabenstellung vorbei. Was das für eine Punktzahl gibt kannst du dir ja dann in etwa vorstellen.


----------



## Beni (8. Okt 2009)

Wie wäre es einen grossen String mit 1000 Zeilen zu erzeugen?

```
String x = "Das ist der Satz.\n";
String x2 = x+x;  // * 2
String x4 = x2+x2;  // * 4
String x8 = x4+x4;  //  *8
...
```


----------



## SlaterB (8. Okt 2009)

hmm, da kam ja noch keiner drauf, leider auch nicht der Aufgabe entsprechend:
> Benutzen Sie Methoden, um das Programm zu kürzen.


----------



## Landei (8. Okt 2009)

cfcnigel hat gesagt.:


> Ja das wird wohl so sein, aber wenn wir uns mal die andren Lösungen ansehen ist das doch alles totaler quatsch  (nicht persönlich gemeint, die lösungen sind ja alle sehr gut). ich meine das alles macht es aber nur unnötig kompliziert und den quelltext sehr lange.



Es sind natürlich einige lustige Lösungen dabei (u.a. meine), aber die am Anfang genannte mit den Methoden für 10, 100 und 1000 Sätze, oder Beni's Vorschlag sehen doch sehr vernünftig aus. 

Ohne Schleife und Rekursion heisst eben genau das: Ohne Schleife und Rekursion. Und ich denke alle Lösungen, die nicht auf eine "versteckte" Schleife zugreifen (wie bei Arrays.fill) oder auf speziellen Sprachfeatures beruhen (Timer oder Arrays.sort-Implementierung) sind im Sinne der Aufgabenstellung korrekt.


----------



## ARadauer (8. Okt 2009)

```
while (zaehler <= 1000 )
```
generell kann man sagen, wenn man weiß wie viele iterationen eher for nehmen...


----------



## 0x7F800000 (8. Okt 2009)

cfcnigel hat gesagt.:


> [Java]
> int zaehler = 0;
> 
> while (zaehler <= 1000 )
> [/code]


Das ist doch jetzt nicht dein ernst?  Nicht nur dass du die witzloseste und ödeste Lösung versuchst, die in der Aufgabenstellung nicht zugelassen ist: nein, du vermasselst es auch noch... :autsch:


----------



## bygones (8. Okt 2009)

alles unschoen, dabei doch so einfach :lol:

[groovy]println 'Habe Mutig dich deines Eigenen verstandes zu bedienen!\n' * 1000[/groovy]

oh man... jetzt habe ich einfach mal copy und paste gemacht... ich hoffe mal instaendig der Satz ist ironischerweise von dir verfremdet worden...


----------



## 0x7F800000 (8. Okt 2009)

was du hir wollen mit groovy code? ???:L Wenn du schon dabei bist, andere Sprachen zu verwurschten, dann kannst du auch gleich mal eine spezialisierte Version von HQ9+ für cfcnigel schreiben, wo er nur einen einzigen buchstaben als quellcode anzugeben hat^^


----------



## maki (8. Okt 2009)

Ich hoffe aber dass die keine Sprungmarken sehen wollen...


----------



## 0x7F800000 (8. Okt 2009)

Mit Sprungmarken kann man in java doch eh nur aus Blöcken rausbrechen :bahnhof:


----------



## bygones (8. Okt 2009)

0x7F800000 hat gesagt.:


> was du hir wollen mit groovy code? ???:L Wenn du schon dabei bist, andere Sprachen zu verwurschten, dann kannst du auch gleich mal eine spezialisierte Version von HQ9+


die kann ich aber nicht ;-)


----------



## Terrestrex (8. Okt 2009)

Tach,

ist so etwas auch Rekursiv?:


```
int i = 0;
	public void printSatz(){
		if (i <1000){
			System.out.println(i + " Satz");
			i++;
			printSatz();
		}
```

In meine Naivität würde ich sagen, das ist ziemlich einfach, oder?


----------



## SlaterB (8. Okt 2009)

und ganz normal rekursiv


----------



## Leroy42 (8. Okt 2009)

Terrestrex hat gesagt.:


> ist so etwas auch Rekursiv?:


Ja


----------



## 0x7F800000 (8. Okt 2009)

Terrestrex hat gesagt.:


> ist so etwas auch Rekursiv?:


;( oh gott, wo bin ich denn hier gelandet, whaa^^ ;(


----------



## Landei (9. Okt 2009)

printSatz ruft sich selbst auf -> Rekursion


----------



## bygones (9. Okt 2009)

0x7F800000 hat gesagt.:


> ;( oh gott, wo bin ich denn hier gelandet, whaa^^ ;(



oh verzeih, dass einer eine Frage stellt und es nicht weiss... ja schlimme welt nicht... oh man


----------



## 0x7F800000 (9. Okt 2009)

bygones hat gesagt.:


> oh verzeih, dass einer eine Frage stellt und es nicht weiss... ja schlimme welt nicht... oh man


Ne, etwas nicht zu wissen und Fragen zu stellen ist völlig in Ordnung.
Aber da kommt einer ausgerechnet in diesem Thread vorbei, und stellt nach 20 Beiträgen verwundert fest, dass es mit einer Rekursion ja viel leichter ist: was? neeee? wirklich jetzt? Wieso sind wir hier bloß zu zehnt drei Tage lang nicht drauf gekommen^^ :autsch:


----------



## Terrestrex (13. Okt 2009)

@0x7F800000

ja, du hast recht. Ich habe bei Wiki gelesen, was alles unter Rekursion zu verstehen ist, und ich muss sagen, die Frage hätte ich mir ersparen können. 
Es ist leider so, dass ich teilweise, die Threads lese (aus Interesse) und manchmal ne Idee habe wie man etwas lösen könnte. Dass hier Leute mit viel mehr Erfahrung (und Wissen) gibt, weiß ich.

Also, Entschuldigung für die Betriebsstörungen.

Grüße

Terrex


----------



## Marco13 (13. Okt 2009)

Nicht so ernst nehmen 

Aber wenn cfcnigel oder Erebos1988 mal die Lustermösung posten könnten....?! feif:


----------



## 0x7F800000 (13. Okt 2009)

Terrestrex hat gesagt.:


> Also, Entschuldigung für die Betriebsstörungen.


Ne, wirklich: nicht zu ernst nehmen ist ein guter Tipp^^ 
Ich war nur bisschen gestresst, bygones hat hier noch irgendwas bissiges hingeschrieben, und das hat sich irgendwie unnötig hochgeschaukelt... Elende langeweile ist schuld, sry :bahnhof:


----------

