Aufgabenstellung:

Schreiben Sie ein Programm in C oder C++, ohne die Schlüsselworte "for", "do" und "while" zu benutzen, das folgendes ausgibt:

• Alle ganzen Zahlen von 1 bis 10
• Alle ganzen Zahlen von 10 bis 1

Die Aufgabe sollte auf keinen Fall zu ernst genommen werden. Es gibt bestimmt auch schöne Lösungen in anderen Sprachen, bei denen die entsprechenden Schlüsselworte halt auch nicht benutzt werden dürfen.

Mindestens sieben verschiede Lösungen sind mir in C bzw. C++ z. Z. bekannt. (Mit fünf war ich etwas vorschnell.) Ich habe sie noch mal zusammengetragen. Also, nicht zu früh aufhören zu grübeln. Für eine mögliche Lösung habe ich übrigens auch keine konkrete Implementation.

Die Aufgabe stammt ursprünglich nicht von mir. Ich kenne sie aber nur durch mündliche Überlieferung.

Na dann viel Spaß! MichaelSchikora

Sinn und Zweck dieser Aufgabe

vielleicht fällt ja jemanden ein Sinn ein.

Preise

Ich denke jede Lösung verdient zumindest einen bunten Zylinder (gibt es schon Bilder? siehe

Wie kann man dieses Training absolvieren

• Anonym. Sich hinsetzen, überlegen, eine Lösungsweg skizzieren, nach einer Woche vergleichen mit hier gegebenen Auflösung.
• Angemeldet. Man trägt sich unten in die Teilnehmerliste ein. Schickt eine Lösung via E-mail an den Aufgabensteller. Dieser postet nach einer Woche die Lösungen und verteilt die virtuellen Preise.
• Kommunikativ. Man hat eine Lösung, und postet sie unten im Diskussionsbereich. Man kooperiert bis die Erleuchtung kommt.
• Unfair. Man postet als Genie ALLE Lösung sofort hier, erklärt das Problem für trivial und qualifiziert sich somit als Aufgabensteller für die nächste Runde.

falsche Musterlösung

#include <stdio.h> int main() { int i; for( i=1 ; i<=10 ; ++i) printf("%d\n",i); for( i=10 ; i>0 ; ++i) printf("%d\n",i); return 0; }

Offizielle Teilnehmerliste

• ... <== hier eintragen (Neues nach oben)
• IP-Adresse 217.0.238.145, Simple Line Design:

  #include <stdio.h> void print_interval(int i, int end) { printf("%d ", i); if (i < end) print_interval(i + 1, end); if (i > end) print_interval(i - 1, end); } int main(void) { print_interval(1, 10); printf("\n"); print_interval(10, 1); return 0; }

Kommentar: die Lösung ist verwandt mit der Lösung von Martin Richter.

• Andreas Scherer
• Ist zwar nicht ganz "Standard", läuft aber auf allen wichtigen Systemen. :-)

#include <iostream> #include <numeric> #include <algorithm> int main( void ) { std::vector< int > ten( 10 ); /* std:: */ iota( ten.begin(), ten.end(), 1 ); std::copy( ten.begin(), ten.end(), std::ostream_iterator< int >( std::cout, " " ) ); std::cout << std::endl; std::copy( ten.rbegin(), ten.rend(), std::ostream_iterator< int >( std::cout, " " ) ); std::cout << std::endl; }

• Nero
• Gabs die schon so ? :) hab nicht genau nachgesehen
• Naja, die Idee mit den GOTOs war schon da .. aber die Implementation war nicht vollständig.

#include <iostream.h> int main() { int v1_10 = 1; l_up: cout << v1_10 << " "; v1_10++; if(v1_10 <= 10) { goto l_up; } cout << "\n"; int v10_1 = 10; l_down: cout << v10_1 << " "; v10_1--; if(v10_1 >= 1) { goto l_down; } cout << "\n"; return 0; }

• Ulrich Eckhardt
• fast wie die von RaphaelZimmerer?, aber ohne templates

#include <iostream> unsigned n = 0; struct N { N(){std::cout << ++n;} ~N(){std::cout << n--;} }; int main() { N nn[10]; }

• [Danke, hat mich zu meiner "Lösung #4 in C++" inspiriert. -- Volker]
• unter Verwendung von STL's Algorithmen

#incldue <iostream> #include <algorithm> #include <iterator> struct up { int n; up(int start):n(start){} int operator(){ return n++;} }; struct down { int n; down(int start):n(start){} int operator(){ return n--;} }; int main() { std::generate_n( std::ostream_iterator<int>(cout, " "), 10, up(1)); std::generate_n( std::ostream_iterator<int>(cout, " "), 10, down(10)); }

• RaphaelZimmerer?
• Mit Hilfe von Templates:

#include <iostream> template<int a> class out: public out<a-1> { public: out(){ std::cout << a << ' '; } ~out(){ std::cout << a << ' '; } }; class out<1> { public: out(){ std::cout << 1 << ' '; } ~out(){ std::cout << 1 << std::endl; } }; out<10> b; int main() { }

• Die Variante steht hier allerdings bereits seit geraumer Zeit: "Lösung #3 in C++", s. u. -- Volker
• Tatsache, ist viel eleganter als meine Lösung :). Habe das ganz übersehen. -- Raphael

• RalfWildenhues?: zusätzlich wird noch eine Datei namens "__" benötigt, in der 10 Zeilen mit je einem Unterstrich stehen. Weiterhin sind die bitwise-or-Operatoren '|' durch backslashes '\', die in der Wiki-Ansicht von Code aufgelöst werden, zu ersetzen.

#define E(L,_) __##_##L##__ /* ANSI C99 code except */ /* for namespace abuse */ #define __(_) ___(_) " " %:define r__ return p(n #define ____ E(INE, L) /* Ralf Wildenhues */ #define x 1##1 -____ #define ___(_) ""#_ #define _ __(____) #include<stdio.h> #define p printf #define d "%d " #define n "\n" int main(){p( #include"__" /*2002*/n); %: undef _ #define | _ print| f(d,x); #incl| ude | "__" r__ ); }

• Das ist ja un-glaub-lich ! Nebenbei: Ist das %:<--># in C99 erlaubt? MichaelSchikora
• Laut ISO/IEC 9899:1999 6.4.6#3 schon; nebenbei ist es auch C89, eine Vorversion war es lediglich nicht, daher trägt die Erwähnung von C99 nurmehr zur Obfuscation bei. -- Ralf

• AndreasBühmann

#include <iostream> void nested_pairs(int a, int b) { cout << a << endl; if (a < b) { nested_pairs(a + 1, b); } cout << a << endl; } int main() { nested_pairs(1,10); }

#include <iostream> void slopes(int i, int n) { if (i == n) return; cout << n - (i < 0 ? ~i : i) << endl; slopes(i + 1, n); } int main() { slopes(-10,10); }

• slopes geht schief, wenn das System nicht Zweierkomplement verwendet. -- RalfWildenhues?
• Stimmt. (Kennt jemand so ein System?) Ich wollte zuerst ein normales abs() verwenden, aber die doppelte Null im Einerkomplement bot sich für die Mitte (doppelte 10) irgendwie an. ;-) Portabler wird's durch

cout << n - (i < 0 ? (-i - 1) : i) << endl;

noch eine Variation zum Thema Rekursion

#include <iostream> void dac(int a, int b) { if (a == b) { cout << a << endl; } else { dac(a, (a+b)/2 + (a > b)); dac((a+b)/2 + (a < b), b); } } int main() { dac(1, 10); dac(10, 1); }

• Philipp Diethelm

#include <stdio.h> int main(int argc, char* argv[]) { volatile unsigned long esps; volatile char* szFmt = "%i "; volatile char* szNl = "\n"; _asm{ jmp progstart; // zum programmanfang (asm) /* Neue linie anfangen */ newline: mov esps, esp; // sp sichern mov edx, szNl; // 1. Parameter für printf push edx; call printf; // printf aufrufen mov esp, esps; // sp widerherstellen ret; // zurück /* Programmstartpunkt */ progstart: /* Raufzählen */ mov ecx, 10; // für loop (10x) mov eax, 0; // zählregister uploop: inc eax; // zähler inkrementieren push ecx; // zähler und loopregister sichern push eax; mov esps, esp; // sp sichern push eax; // 2. Parameter für printf push szFmt; // 1. Parameter für printf call printf; // Ausgabe mov esp, esps; // sp widerherstellen pop eax; // zähler und loopregister widerherstellen pop ecx; loop uploop; // ecx dekrementieren und wenn nicht 0, dann nochmals call newline; // Neue Zeile beginnen /* Runterzählen */ mov ecx, 10; // für loop (10x) downloop: push ecx; // zähler sichern mov esps, esp; // sp sichern push ecx; // 2.Parameter für printf push szFmt; // 1. Parameter für printf call printf; // Ausgabe mov esp, esps; // sp widerherstellen pop ecx; // zähler widerherstellen loop downloop; // ecx dekrementieren und wenn nicht 0, dann nochmals call newline; // Neue Zeile beginnen } return 0; }

• Martin Richter

#include <iostream> using namespace std; void Doit(int iFrom, int iTo, int iStep) { cout << iFrom << endl; if (iFrom!=iTo) Doit(iFrom+iStep,iTo,iStep); } int main(int, char *[]) { Doit(1,10,1); Doit(10,1,-1); return 0; }

• JirkaKlaue?

#include <stdio.h> int main() { int i=1, j=11; i: switch (!(i^j) + !i + (i*j == 1)) case 0: { printf("%d ", j-1 ? i++ : --i); goto i; case 1: j=1; goto i; } return puts(""); }

• DavidSchmitt

{ begin: int i = 1; cout << i << endl; if (++i > 10) goto begin; }

Das hier wird so natürlich nicht funktionieren, aber das Konzept sollte klar sein:

{ execlp("seq", "1", "10"); }

Oder um es noch etwas zu elaborieren:

{ execlp("perl", "-e", "for $i (1..10) { print $i,'\n'; };"); }

Und jetzt noch ohne "for" ;-)

Das war eigentlich mein Punkt. "for" ist kein Schlüsselwort in C sondern in perl.

{ execlp("perl", "-el", "print join ' ', 1..10;"); }

• VolkerGlave, Lösung #1 in C++:

  #include <iostream> int main() { std::cout << "1 2 3 4 5 6 7 8 9 10\n10 9 8 7 6 5 4 3 2 1\n"; return 0; }

Lösung #2 in C++:

#include <iostream> using namespace std; int f(int x){return x<10&&cout<<1+x<<endl<<f(1+x)<<endl,x;} int main(){return f(0);}

Lösung #3 in C++:

#include <iostream> template<int x> struct C : C<x - 1> { C() { std::cout << x << ' '; } ~C() { std::cout << x << ' '; } }; template<> struct C<0> {}; int main() { return C<10>(), 0; }

Lösung #4 in C++:

#include<iostream> struct S*p=0; struct S{S(){p=p?p:this;this->~S();}~S(){std::cout<<1+this-p<<' ';}}s[10]; int main(){}

Lösung #5 in C++ (per throw/catch):

#include<iostream> #include<utility> using namespace std; void f(){try{throw;}catch(pair<int,int>&e){ cout<<((e.first+=e.second)>10&&(e.first+=e.second=-e.second),e.first)<<' '; if(e.first+e.second)f(); }} int main(){try{throw make_pair(0,1);}catch(...){f();}}

Dieselbe C++-Lösung #5 nochmal "in schön":

#include <iostream> #include <utility> void f() { try { throw; } catch (std::pair<int, int>& e) { if ((e.first += e.second) > 10) e.first += e.second = -e.second; std::cout << e.first << ' '; if (e.first + e.second != 0) f(); } } int main() { try { throw std::make_pair(0, 1); } catch (...) { f(); } }

Lösung #1 in C:

#include <stdio.h> int main(int x,char* y[]) { return y&&main(0,0)||(printf("%d ",++x)-3&&main(x,0),printf("%d ",x)); }

"Lösung" #2 in C:

#define P(a,b) printf("* Alle ganzen Zahlen von %d bis %d\n",a,b) #include <stdio.h> int main() { return P(1,10)^P(10,1); }

[Das ist ja wohl die "Standard-Querdenker" Lösung? *g*] ... [Danke für das Korrigieren des Spiegelstriches nach "*" :-) -- vgl]

Lösung #3 in C (ohne jegliche eigene Defines, Variaben und Funktionen, ohne Rekursion, und ohne Verwendung der Ziffern 0 bis 9 und von Operatoren ;-):

#include <math.h> #include <signal.h> #include <stdio.h> int main() { printf("%d %d %d %d %d %d %d %d %d %d\n%d %d %d %d %d %d %d %d %d %d\n", SIGHUP,SIGINT,SIGQUIT,SIGILL,SIGTRAP,SIGABRT,SIGEMT,SIGFPE,SIGKILL,SIGBUS, '\n','\t','\b','\a',PLOSS,TLOSS,UNDERFLOW,OVERFLOW,SING,DOMAIN); }

Lösung #4 in C (per strlen()):

#include <stdio.h> #include <string.h> int f1(const char* s) { return *s && (f1(s + 1), printf("%d ", strlen(s))); } int f2(const char* s) { return *s && printf("%d ", strlen(s)) && f2(s + 1); } int f(const char* s) { return f1(s) && f2(s); } int main() { return f("DenkSport\n"); }

OffTopic-Lösung in SpracheJ

>:i.10,:_10

Auswertung

Welch eine Verspätung! Statt nach ein bis zwei Wochen, fang ich jetzt erst nach 6 Monaten an. *schäm*. Vielleicht besser spät als nie. Als hier geht's (ab ca. Sa. 07.03.03) zur SoftwareDenkSport C CPP 1 Auswertung.