Wettbewerb für C Anfänger: Aufgabe aus K&R Buch - Wer schreibt den besseren Code?



  • So, da ich gerade die Exercise 1-21 aus dem Buch "The C Programming Language" von K&R gelöst habe, würde ich mal gerne wissen ob ihr das besser hinkriegt.

    Die Aufgabenstellung ist folgende.
    Schreibt ein Programm in C, daß eine Eingabe entgegennimmt und dann alle Leerzeichen, da wo es geht*, durch Tabs ersetzt. *Also z.B. bis zu dem jeweils nächsten Tabstopp.
    Entscheident ist am Ende, daß die Abstände der Eingabe mit der Ausgabe identisch sind. D.h. der gleiche Satz genauso wieder rauskommt.
    Sollte die Eingabe mit Leerzeichen oder Tabs enden, so sollte sie durch ein Newlinezeichen ersetzt werden. Und Leerzeichen werden zur besseren Sichtbarkeit durch * ersetzt.

    Ich kann euch jedenfalls schonmal jetzt verraten, daß es die Aufgabe, obwohl sie einfach klingt, richtig in sich hat, wenn man wirklich an alle Unwägbarkeiten denken möchte.

    Da die Aufgabe in diesem Buch sich vorwiegend nur auf das erste Kapitel bezieht
    kommen noch ein paar Einschränkungen zur Aufgabenstellung hinzu.
    1. Ihr dürft keine Switch Anweisung benutzen.
    2. Ihr dürft keine selbstgeschriebenen Funktionen außer Main benutzen.
    (Im Buch wird zwar noch eine selbstgeschrieben Getline Funktion erwähnt, die dürft ihr natürlich nutzen, aber diese ist eigentlich nicht notwendig. Packt einfach alles in main)
    3. Stringverarbeitungen sind auch noch nicht Bestandteil des ersten Kapitels und damit auch nicht zulässig. Die Funktionen aus string.h dürfen also nicht benutzt werden.

    Damit man die Programme besser vergleichen kann, müssen noch folgende Bedingungen erfüllt werden:
    1. Die Breite der Tabs muß auf 8 Zeichen eingestellt sein.
    2. Zur besseren Lesbarkeit und Kenntnis über die Tabpositionen sollte am Anfang
    folgende Funktion in das Programm eingearbeitet und ausgegeben werden:

    printf("|\t|\t|\t|\t|\t\n"); // Zur Kontrolle
    

    3. Die Ausgabe von Leerzeichen sollte durch '*' ersetzt werden, damit man
    die Leerzeichen bei der Ausgabe von den Tabs unterscheiden kann.

    Damit ihr euer Programm auf Korrektheit prüfen könnt, könnt ihr folgende
    Eingabesätze zum Prüfen nutzen:

    Da war**jemand.\n
    ***\t**i\n
    Dies ist ein Test.\n
    Dies*****ist\n
    i**\n
    ***\t*\n
    *i\n
    

    Da wo anstatt Leerzeichen Sternchen angegegeben sind, sind Leerzeichen einzugeben, die Sternchen repräsentieren diese hier nur zur besseren Lesbarkeit.
    Achtet auch bei der Ausgabe, daß anstatt von Leerzeichen das '*' Zeichen ausgegeben wird.
    Für \t ist entsprechend ein Tab einzugeben und n\ bedeutet Newline bzw. Abschluß der Eingabe.

    Ablauf
    Das ganze soll so ablaufen, daß man eine Zeile eingibt und das Programm dann gleich darauf das Ergebnis für diese Zeile ausgibt.
    Danach sollen weitere Sätze eingegeben werden können.

    Siegbedingungen
    Gewinnen tut der, der den besseren eleganteren schöneren und schnelleren C Code schreibt und das Programm richtig funktioniert. D.h. von den obigen 7 Prüfbeispielen sollten mindestens 6 korrekt ausgegeben werden, ansonsten gibt's Punktabzug.
    Bei der Eingabe der Sätze ist davon auszugehen, daß eher Buchstaben, Zahlen usw. anstatt Tabs und Leerzeichen eingegeben werden, daher ist das Programm auf eine möglichst schnelle Abarbeitung dieser normalen Zeichen zu optimieren.
    Die Tatsache, daß der langsamste Faktor der Mensch ist, kann ignoriert werden.
    Stellt euch einfach vor, euer Programm müßte ganze Datensätze automatisch abarbeiten.

    Preise?
    Gibt's keinen. Die Erfahrung die ihr bei dieser Aufgabe lernt, ist Preis genug. Zumindest für C Einsteiger und lernende.
    Denn wie ich bereits schrieb, ist sie nicht trivial. Ein Debugger kann sehr nützlich sein.

    Jury
    Für die Jury habe ich noch niemanden und ich selbst bin Gast.
    Daher dachte ich an 2-3 erfahrene C Coder die sich freiwillig melden und hier im Forum registriert sind und mindestens 1000 Beiträge geschrieben haben.
    Entscheident ist, daß die Jury von der Teilnahme ausgeschlossen ist, immerhin sollte hier Neutralität gewahrt werden.
    Falls sich niemand meldet, dann starten wir einfach eine Umfrage und lassen darüber den Sieger auserkoren.

    So und damit ihr euch eine Vorstellung von der Aufgabenstellung machen könnt und einen Vergleich habt, poste ich euch hier mal meinen Code.
    Mal schauen ob ihr das besser hinkriegt.

    PS: Einen kleinen Fehler hat mein Programm, bei dem obigen 6. Testsatz zum Prüfen scheitert es.
    Aber auf solche Kleinigkeiten stößt man halt leider erst später im Laufe der Entwicklung und das auch noch zu berücksichtigen hätte zu viel Zeit und Aufwand gekostet und möglicherweise wäre dann gleich ein kompletter Rewrite sinnvoller gewesen, daher habe ich das sein gelassen, diesen einen Bug auch noch zu berücksichtigen.
    Mein Program hat also dann zwar schon einen kleinen Bug, aber betrachtet es mal so, ihr habt beim Wettbewerb einen Vorteil, weil ihr meinen Code schon sehen könnt und somit etwa Abschätzen könnt, was da auf euch zukommt.
    Ansonsten besteht es von den 7 Testsätzen immerhin 6.
    Mehr steht dazu auch noch etwas weiter unten im Programmcode drin.

    #include <stdio.h>
    
    #define TABSIZE 8
    
    /* Exercise 1-21
     * Program that replaces strings of blanks by the minimum
     * number of tabs and blanks to archieve the same spacing. */
    int main()
    {
      int c;
      int counter = 0;
      int charcount = 0;
    
      printf("Programmende mit STRG+D bzw. STRG+C\n");
      printf("|\t|\t|\t|\t|\t\n"); // Zur Kontrolle
      while ((c = getchar()) != EOF)
      {
    	  if (c == ' ')
    	  {
    	      do // zweite Schleife notwendig für Leerzeichenüberlauf über Tablänge
    		  {
    		      do // zähle Anzahl der folgenden Leerzeichen
                  {
                       counter++;
    			       charcount++;
    		      } while ((c = getchar()) == ' ' && charcount != 8);
    
    		      // if (charcount == TABSIZE || (charcount == counter && (c == '\t' || c == '\n')))
    		      if (charcount == TABSIZE || (charcount == counter && c == '\t') || (charcount != TABSIZE &&  c == '\n'))
     		      {
     		          /* Setzt Tab wenn nächsten 8 Zeichen innerhalb eines Tabbereichs nur Leerzeichen
     		             oder ein Tab war. Im Falle eines Newlines wird nur dieses gesetzt. */
    			       if (charcount == TABSIZE)
    			       {
    			           putchar('\t'); // Falls c != \t dann Ausgabe von Tab
    			           charcount = 0;
    			       }
    			       counter = 0; // Wegen überflüssige bis zum Tab laufende Leerzeichen
    		      }
    		      else
    		      {
    			      /* Es waren nur einige wenige Leerzeichen und das Tabende
    			       * wurde noch nicht erreicht. */
    			      do
    			      {
    				      putchar('*'); // Gebe alle gezählten Leerzeichen aus. Zum Debuggen * anstatt Blank
    				      counter--;
    			      } while (counter != 0);
    		      }
    		  } while (c == ' ');
    	  }
    	  // Gebe Zeichen aus, daß kein Leerzeichen sein kann.
    	  putchar(c);
    	  if (c == '\n' || c == '\t' || charcount == TABSIZE - 1)
    	  {
    	      /* Falls Newline oder falls nächste Zeichenzählung 8 ergeben würde.
    	         Das spart eine If Abfrage am Anfang. */
    	      charcount = 0;
    	  }
    	  else
    	  {
    	  	  charcount++;
    	  }
      }
      return 0;
    }
    
    /*  Folgendes geht noch nicht:
        Programm arbeitet nur immer bis zu den nächsten 8 Zeichen.
        D.h. wurden bei den ersten 8 Zeichen ein Leerzeichen oder Tab
        eingegeben und dann im nächsten 8-er Zeichenblock nur noch ein Newline
        eingegeben, dann werden zumindest die 8-er Zeichenblöcke zuvor mit einem
        Tab versehen und das Tab ausgegeben.
        D.h. es wird nicht erkannt, daß die Zeile komplett leer ist.
        /*
    

    Erfahrene C Coder dürfen natürlich auch mitmachen. Vielleich können wir Anfänger dann etwas lernen. 🙂

    So und jetzt hoffe ich doch an einer regen Teilnahme an diesem Wettbewerb und wünsche euch allen viel Spaß bei der Aufgabe.



  • Vielleicht wird dein Programm einfacher, wenn du die Eingabe immer in Blöcken von 8 Zeichen holst, und sobald ein Tab auftaucht die Ausgabe mit Leerzeichen auffüllst und den nächsten Block holst.



  • mngbd schrieb:

    und sobald ein Tab auftaucht die Ausgabe mit Leerzeichen auffüllst

    Das würde dann aber die Aufgabe verfehlen.

    Die Aufgabe ist ja, die Leerzeichen, wenn möglich, durch Tabs zu ersetzen und nicht umgekehrt.

    Das was du meinst, das kam in Exercise 1-20 schon dran und die habe ich schon längst gelöst.



  • C Anfänger schrieb:

    Das was du meinst, das kam in Exercise 1-20 schon dran und die habe ich schon längst gelöst.

    Stimmt, sorry.



  • Ich habe dein Programm nicht verstanden, zumal es Fehlausgaben machte.
    Naja so könnte das aussehen.

    Ich bin jetzt wohl raus ;D, da ich den Sinn dieses "Kontests" nicht verstehe.

    #include <stdio.h> 
    
    #define TABSIZE 8 
    
    int main() 
    { 
    	int c; 
    
    	printf("Programmende mit STRG+D bzw. STRG+C\n"); 
    	printf("|\t|\t|\t|\t|\t\n"); // Zur Kontrolle 
    
    	while ((c = getchar()) != EOF) 
    	{
    		if (c == ' ')
    		{
    		    int count = 0;
    			do
    			{ 
    				++count;
    			} while ((c = getchar()) == ' ');
    
    			for(int i = 0; i < count % TABSIZE; i++)
    				putchar('*');
    
    			if (c != ' ')
    				putchar(c);
    		}
    		else
    		{
    			putchar(c);
    		}
    	} 
    	return 0; 
    }
    


  • HighLigerBiMBam schrieb:

    Ich habe dein Programm nicht verstanden, zumal es Fehlausgaben machte.

    Welche Fehlausgaben meinst du?

    [QUOTE]
    Naja so könnte das aussehen.
    [/QUOT]
    Dein Programm enthält einen Fehler.

    Wenn du beim 2. Tabblock (oder vermutlich grundsätzlich später)
    erst ein Leerzeichen und dann ein Tab eingibst, dann wird das Leerzeichen ausgegeben und nicht durch ein Tab ersetzt wie es sein sollte.

    Gibt einfach mal folgendes ein:

    ***d\t*d*d*\t\n
    

    Ich bin jetzt wohl raus ;D, da ich den Sinn dieses "Kontests" nicht verstehe.

    Wie meinst du das mit Sinn?



  • Ich hab nochmal dein Progamm geprüft.
    Der Fehler tritt grundsätzlich genau dann auf, wenn du innerhalb eines Tabblocks zuerst irgendein Zeichen, gefolgt von einem oder mehreren Leerzeichen und dann Tab eingibst.

    D.h. aus so etwas:

    AB*****\t\n
    
    macht dein Programm:
    AB*****\t\n
    
    Und das ist falsch.
    Richtig wäre:
    AB\n
    
    Und fall es:
    AB*****\tCDE\t\n
    heißt, dann müßte das da rauskommen:
    AB\tCDE\n
    

    Deswegen sag ich ja, so trivial wie man meint ist es nicht. 😉
    Das alles fehlerfrei zu berücksichtigen ist nicht trivial.



  • Mein Programm ist nicht ohne Grund so komlex geworden.
    Am Anfang war es auch ganz schlank und klein, bis ich auf die ganzen Spezialfälle stoß, die es zu berücksichtigen gilt.



  • Ich sehe gerade, dein Programm enthält noch einen weiteren Fehler, den gleichen wie mein Programm.

    Aus einem:

    *\t\n
    
    macht dein Programm ein:
    \t\n
    

    Das ist also ein Tab zuviel.
    Eine komplett leere Zeile wird also auch nicht berücksichtigt.



  • C Anfänger schrieb:

    Ich sehe gerade, dein Programm enthält noch einen weiteren Fehler, den gleichen wie mein Programm.

    Aus einem:

    *\t\n
    
    macht dein Programm ein:
    \t\n
    

    Das ist also ein Tab zuviel.
    Eine komplett leere Zeile wird also auch nicht berücksichtigt.

    EDIT

    Ok ganz gleich sind die Fehler nicht, deines macht einen Fehler mehr.
    Wenn man folgendes eingibt:

    \tA\t\n
    
    Dann macht dein Programm ein
    \tA\t\n
    draus, während meines immerhin den zweiten Tab entfernt.
    \tA\n
    


  • Im großen und ganzen, so weit ich das bis jetzt feststellen konnte und wie die Beispiele zeigen macht dein Programm also bei Spezialfällen insgesamt schon 3 Fehler.
    Meines liegt da nur bei einem Fehler.



  • Du bist vielleicht ein Troll... Von Spezialfällen hast du nicht erwähnt, die meisten angeblichen Fehler sind nicht vorhanden, mach die Augen auf.

    So wie du es geschrieben hast arbeitet meins fehlerfrei. Und wenn du nicht merkst, dass bei deinem oft nicht Leerzeichen ersetzt werden, dann kann man dir nicht helfen.

    PS: Das Forum hat eine Editfunktion.



  • Ich verstehe die Aufgabenstellung irgendwie nicht...

    Es sollen also eine gewisse Anzahl von folgenden Leerzeichen als Tab dargestellt werden. Außerdem sollen Leerzeichen und Tabs am Ende der Eingabe entfernt werden.

    Ist das alles?

    #include <stdio.h>
    
    #define TAB_SIZE 8
    
    int main()
    {
    	char ch;
    
    	printf("|\t|\t|\t|\t|\t\n");
    
    	while ((ch = getchar()) != EOF)
    	{
    		if (ch == ' ')
    		{
    			int counter = 1;
    			int tab = 0;
    
    			while ((ch = getchar()) == ' ' || ch == '\t')
    			{
    				if (ch == ' ')
    				{
    					++counter;
    				}
    				else if (ch == '\t')
    				{
    					counter += TAB_SIZE;
    				}
    
    				if (counter >= TAB_SIZE)
    				{
    					tab = counter / TAB_SIZE;;
    					break;
    				}
    			}
    
    			if (tab)
    			{
    				//int i;
    
    				//for (i = 0; i < tab; ++i)
    				{
    					putchar('\t');
    				}
    			}
    			else
    			{
    				int i;
    
    				if (ch != '\n')
    				{
    					for (i = 0; i < counter; ++i)
    					{
    						putchar('*');
    					}
    				}
    
    				putchar(ch);
    			}
    		}
    		else
    		{
    			putchar(ch);
    		}
    	}
    
    	return 0;
    }
    

    Ich könnte das Programm anbieten. Da mir aber nicht klar ist, was wirklich verlangt ist, kann ich es nicht wirklich testen.



  • HighLigerBiMBam schrieb:

    Du bist vielleicht ein Troll... Von Spezialfällen hast du nicht erwähnt, die meisten angeblichen Fehler sind nicht vorhanden, mach die Augen auf.

    Die Aufgabenstellung ist eindeutig. Dort steht nämlich ganz klar drin:
    "Sollte die Eingabe mit Leerzeichen oder Tabs enden, so sollte sie durch ein Newlinezeichen ersetzt werden."

    Außerdem kannst du dir mal deinen Ton sparen.

    So wie du es geschrieben hast arbeitet meins fehlerfrei.

    Nein, das tut es nicht.
    Es besteht ja nicht einmal die Testbeispiele korrekt.

    Und wenn du nicht merkst, dass bei deinem oft nicht Leerzeichen ersetzt werden, dann kann man dir nicht helfen.

    Es werden da Leerzeichen ersetzt, wo es machbar ist, also bis zum nächsten Tab.
    Vor dem Tab z.b. 3 Leerzeichen durch ein Tab ersetzen kann man nicht, da das Tab ja bis zum Ende springt und dann das Spacing nicht mehr stimmt.

    Es ist doch ganz klar, daß du die Aufgabenstellung überhaupt nicht verstanden hast.
    Anstatt an deinem Programm weiterzuarbeiten versuchst du hier jetzt dein Programm zu rechtfertigen und die Aufgabenstellung falsch zu interpretieren.

    PS: Das Forum hat eine Editfunktion.

    Die geht nicht für Gäste.



  • hhhh schrieb:

    Ich verstehe die Aufgabenstellung irgendwie nicht...

    Es sollen also eine gewisse Anzahl von folgenden Leerzeichen als Tab dargestellt werden. Außerdem sollen Leerzeichen und Tabs am Ende der Eingabe entfernt werden.

    ...
    Ich könnte das Programm anbieten. Da mir aber nicht klar ist, was wirklich verlangt ist, kann ich es nicht wirklich testen.

    Ich werde nachher noch etwas dazu schreiben. Ich muß jetzt aber noch schnell einkaufen gehen.



  • Also, da es hier wohl Mißverständnisse bezüglich der Aufgabenstellung gibt, werde ich diese nochmal etwas ausführlicher hinschreiben.

    Es soll eine Zeile eingegeben werden können und unter folgenden Bedingungen wieder ausgegeben werden.

    1. Grundsätzlich gilt, daß sichtbare Zeichen (z.b. A-Z, a-z usw.) bei der Ausgabe an den gleichen Position stehen müssen, wie bei der Eingabe.
    2. Endet der Satz auf Leerzeichen oder Tabs, so sind diese Tabs und Leerzeichen zu entfernen und durch ein \n Newline auszutauschen.
    3. Enthält der Satz vor oder zwischen den Wörtern Leerzeichen, dann sollen diese durch Tabs ersetzt werden, wenn dieses möglich ist. Zu beachten ist hierbei, daß Regel 1 dabei nicht verletzt werden darf.
    4. Besteht die eingegebene Zeile ausschließlich nur aus Leerzeichen und Tabs (kein Zeichen sichtbar!), dann darf nur ein \n Newline ausgegeben werden.
    5. Die Tablänge beträgt 8 Zeichen.

    Beispiele: (* entsprechen Leerzeichen, /t sind Tabs und /n ist ein Newline
    
    [B]Zu Regel 2:[/B]
    ABCD**\n
    wird zu:
    ABCD\n
    
    ABCD****\n
    wird zu:
    ABCD\n
    
    ABCD******\n
    wird zu
    ABCD\n
    
    ABCD********\n
    wird zu
    ABCD\n
    
    ABCD\t*\n
    wird zu
    ABCD\n
    
    ABCD**\t***\n
    wird zu 
    ABCD\n
    
    abcdefgh12345678*\t\n
    wird zu
    abcdefgh12345678\n
    
    [B]Zu Regel 3[/B]
    ABC**DE\n
    wird zu
    ABC**DE\n
    // Man beachte, ein Tab ist hier nicht möglich, weil dann DE bei Tab=8 Regel 1 verletzten würde.
    
    ABCD********EF\n
    wird zu:
    ABCD\t****EF\n
    // Man beachte, daß, obwohl hier 8 Leerzeichen eingegeben wurden ein nach D 
    eingegebenes Tab nur die nächsten 4 Leerzeichen ersetzen kann, weil danach der 
    Tabstopp kommt und die 4 Leerzeichen danach einzeln eingegeben werden müssen.
    
    ABCD************EF\n
    wird zu:
    ABCD\t\tEF\n
    
    ABCD*****EF\n
    wird zu:
    ABCD\t*EF
    
    AB***C**DE\n
    wird zu:
    AB***C\tDE\n
    // Vor D kommt ein TAB, weil die letzten 2 Leerzeichen vor dem Tabstopp kamen.
    
    AB**\tDE\n 
    wird zu:
    AB\tDE\n
    
    **ABCD\n
    wird zu:
    **ABCD\n
    
    ********ABCD\n
    wird zu:
    \tABCD\n
    
    *******ABCD\n
    wird zu:
    *******ABCD\n
    // Es sind nur 7 Leerzeichen, daß reicht nicht für ein Tab bis zum nächsten Tabstopp
    
    **\t*ABCD\n
    wird zu:
    \t*ABCD\n
    
    [B]Zu Regel 4[/B]
    *\t**\n
    wird zu:
    \n
    
    \t**\n
    wird zu:
    \n
    
    **\t\n
    wird zu:
    \n
    

    So, diese Beispiele sollten, so weit ich das beurteilen kann, die genannten Regeln abdecken, wobei ich hier keine Gewähr gebe.
    D.h. eventuell habe ich noch ein Eingabebeispiel übersehen, daß hier noch nicht bedacht wurde, aber sich aus den Regeln ergibt.
    Zu bedenken ist nämlich hier, daß kaum eines der Beispiele über mehr als 16 Zeichen hinausgeht. D.h. gibt man eine > 16 Zeichen lange Eingabe ein, dann sollte das Programm die genannten Regeln ebenfalls erfüllen können.
    Als ich mein Programm schrieb, fielen mir nämlich solche Fälle auch auf.
    Bei kurzen Eingaben war alles korrekt, aber bei langen Zeilen mußte ich dann nochmal nachbessern.

    Auch solltet ihr berücksichtigen, daß je nach Programmcode Fehler beim Bearbeiten der vorherigen Eingaben auf die Bearbeitung der späteren Eingaben auswirken könnten und sich die Fehler aufaddieren.
    Das war bei mir so. Ich mußte daher das Programm öfters komplett neu starten um
    einen resetteten Zustand zu haben.
    Außerdem ist ein Debugger sehr hilfreich.
    Insbesondere bei Regel 2, da man hier schnell einen ausgegebenen \t Tab der gleich vor dem \n Newline Zeichen noch folgt übersehen könnte.
    Notfalls kann man, an der Codestelle wo die Newlines ausgegeben werden, noch
    eine optionales anderes Zeichen vor dem Newline auf die klassische Debugging Methode zum Debuggen ausgeben. für den Wettbewerb sollte diese Ausgabe aber dann wenigstens ausgeschaltet sein.

    So, ich hoffe es ist nun für jeden klarer, das ist das was funktional am Ende rauskommen soll. Die Siegbedingungen bezügl. Geschwindigkeit, Eleganz usw. sind weitere Bedingungen und schon ausführlich im ersten Posting beschrieben.
    Und bei Unklarheiten fragt ihr besser vorher, bevor ihr euer Programm postet. Ich denke nämlich, daß das Streit spart.

    @ hhhh
    Dein Programm verletzt z.b. Regel 3, das müßtest du noch nachbessern.
    Beispiel:
    Diesist\n
    wird bei dir zu:
    Dies
    ist\n
    Da aber der Tabstop bis zum 8 Zeichen geht sollte es so etwas ergeben:
    Dies\t*ist\n

    Auf komplett leere Zeilen habe ich dein Programm noch nicht getestet.
    Das müßte ich mit dem Debugger machen und vielleicht willst du erstmal das Problem bezügl. Regel 3 beheben.



  • Lösungen zu K&R-Aufgaben gibt es bereits, solltest du wohl auch kennen:
    http://www.clc-wiki.net/wiki/K%26R2_solutions:Chapter_1:Exercise_21

    Ich biete mal was an, was die getline gleich mit ersetzt und strikt C89 ist:

    #include <stdio.h>
    
    #define TABSPACE 8
    
    int main()
    {
      int c=EOF-1, tnum=0;
      do if( c!=EOF-1 )
         {
           if( c==EOF || c=='\n' )
             {tnum?putchar('\n'):1;break;}
           else if( c==' '||c=='\t' )
             tnum+=c==' '?1:TABSPACE;
           else
           {
             while( tnum>=TABSPACE ) putchar('\t'),tnum-=TABSPACE;
             while( tnum ) putchar('*'),--tnum;
             putchar(c);
           }
         } while( c=getchar(),1 );
      return 0;
    }
    


  • Wutz schrieb:

    Lösungen zu K&R-Aufgaben gibt es bereits, solltest du wohl auch kennen:
    http://www.clc-wiki.net/wiki/K%26R2_solutions:Chapter_1:Exercise_21

    Richtig und die sind alle nach den Aufgabenstellungen falsch.
    Ich finde es unglaublich, wie so etwas ungeprüft auf die Seite kommen kann.

    Wäre die Diskussionsseite ohne Registrierung zugänglich, dann würde ich die Fehler der Programme alle aufzählen.

    Ich biete mal was an, was die getline gleich mit ersetzt und strikt C89 ist:

    Es hat schon einen Fehler.
    Gib mal folgendes ein:

    Es**\tist
    Dein Programm macht aus der Eingabe
    Es\t**ist
    
    richtig wäre:
    Es\tist
    


  • Und, habt ihr an eurem Code schon gearbeitet?



  • @wutz

    war in c89 switch verboten oder wieso machst da so ne if geschichte?

    @edit: bevor ichs vergess,, es gewinnt nicht wer den unleserlichsten code produziert... dafür gibts den IOCCC 😉


Log in to reply