Software Denk Sport C CPP 1
 
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern

Dies ist auch nur eine kleine Übung.

Aufgabenstellung:

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

Bemerkung

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

Ich denke in einer Woche (bis zum 21.10.2002) sollten genug Lösungen eingetroffen sein.

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

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

#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;
}

#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;
}

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

#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()
{
}

#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__
);
}

#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);
}
    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);
}

#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;
}

#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;
}

#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("");
}

{
    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;");
}

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.


KategorieC KategorieCee KategorieCpp
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 29. November 2007 8:47 (diff))
Suchbegriff: gesucht wird
im Titel
im Text