Umgekehrter Reihenfolge der Zeilen ohne Umkehr Wörter in C

In C,wie wir das akzeptieren einer Eingabe, die mehrere Zeilen und dann hat die Ausgabe der Zeilen in umgekehrter Reihenfolge (ohne änderung der Reihenfolge der Wörter in jeder Zeile).

Zum Beispiel:

Eingang: Line-1 
Zeile 2 
Linie 3 
Linie 4 

Ausgang: Line 4 
Linie 3 
Zeile 2 
Linie 1

Was haben Sie versucht? Könnten Sie sich vorstellen, wie es zu tun, wenn Sie es selbst tun? (Nicht Programmierung)
mattgemmell.com/2008/12/08/what-have-you-tried
Die meisten c-Funktionen wie gets(), scanf() akzeptieren ein single-line-Eingang, ich.e bis neue-Zeile-Zeichen. Wie Eingaben zu übernehmen?
Zeile für Zeile, speichern alle von Ihnen im Gedächtnis?
Downvoters, werden mehr Art. Die OP scheint neu zu sein, um computer-Programmierung und seine Frage ist nicht "plz mache meine Hausaufgaben"
Meiner Meinung nach wird ein Anfänger nicht zulassen, die Frage, ohne zu präsentieren, was Sie schon ausprobiert oder zumindest angeben, was das problem ist. E. g. sein Kommentar über "how to accept input" ist einfach fehlt in diesem Beitrag.

InformationsquelleAutor user2018365 | 2013-01-30

c reverse string

2

Ist die Lösung einfach. Unter der Annahme, dass lines ist ein array von Zeilen (ohne abschließenden Zeilenumbruch) Länge size, sollte man folgende Schleife:
```
for(i = size - 1; i >= 0; --i)
    puts(lines[i])
```
I. e., Sie nur die Ausgabe der Zeilen in der umgekehrter Reihenfolge: ausgehend von der letzten und endet mit der ersten.

Über die Frage "Wie Eingangs-und store-Linien": es gibt mehrere Optionen. Die Eingabe kann durchgeführt werden, mit der Verwendung von getline (eine POSIX-Funktion) oder fgets Funktionen (Sie können manuell löschen Sie nachgestellte Zeilenumbrüche, falls erforderlich); nicht verwenden gets - es ist böse. Sie müssen eine Schleife verwenden, um die input-Zeilen. Linien können gespeichert werden, entweder in einem statischen oder in einem dynamisch wachsenden (über realloc) array - basierte auf Ihre Aufgabe. Oder Sie führen eine nicht-so-smart-trick: schreiben Sie eine rekursive Funktion, die den stack zum speichern von Linien (pseudocode):
```
function reverseLines():
{
    string line;
    input(line);
    if not end-of-input():
    {
        reverseLines();
        output(line);
    }
}
```
Aber wenn Ihr Eingang ist groß genug, treffen Sie die stack overflow Fehler.

InformationsquelleAutor nameless
2

Wenn Sie können noch die maximale Länge der Linie, die Sie Lesen können Linien mit standard C fgets() Funktion. Wenn Sie auf den letzten POSIX-konformen Betriebssystem oder GNU glibc, die Sie verwenden können, getline(), die die Zuordnung von Speicher für eine Zeile, so können Sie Lesen, die Länge der Linie. Lesen Sie diese Antwort hier bei SO.

Für jede Zeile, dann erhalten Sie char* Zeiger.

Wenn Sie setzen die maximale Anzahl von Linien zu unterstützen, können Sie char *lines[MY_MAX_LINE_COUNT] zum speichern der Zeiger, und dann einfach drucken in umgekehrter Reihenfolge aus dem array. Besser ist die Umsetzung einer sehr einfachen verknüpften Liste ermöglicht voranstellen (dies ist wahrscheinlich die am meisten einfache verkettete Liste " - code kann es sein, im Grunde ein Stapel mit nur push, keine Notwendigkeit für pop...), und drucken Sie dann die Linien aus, dass, wenn alle, die gelesen wurden.

Für den einfachen Fall, um zu vermeiden, die Gewährung einer verketteten Liste struct für jede Zeile, es könnte sein am besten speichern Sie die char* line-Zeiger in einem array, das ist gewachsen mit realloc():.

Erste der Variablen, die sich brauchen:
```
int arraysize = 16; /* any size will do, 16 is nice round number */
char *lines[16] = malloc(sizeof(char*) * arraysize);
int linecount = 0;
```
Dann Schleife Eingabe:
```
while(/* test for eof or whatever */) {
    char *line = /* code to get the line */;

    if (linecount == arraysize) {
      arraysize *= 2;
      lines = realloc(lines, sizeof(char*) * arraysize);
    }
    lines[linecount] = line; /* old lines are at indexes 0..(linecount-1) */
    ++linecount;
```
- Und Druck-Schleife für die:
```
for(int index = linecount-1 ; index >= 0 ; --index) {
  puts(lines[index]); /* if line has newline stripped, else printf("%s", lines[index]);
}
```
- +1 Eine einfache stack ist eine schöne Lösung.
InformationsquelleAutor hyde

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reverseLines(void);

int main (void) {
    reverseLines();

    return 0;
}

void reverseLines(void) {
    char *line;
    size_t len = 0;

    getline(&line, &len, stdin);

    if (strcmp(line, "") != 0) //NOT end of input
    {
        reverseLines();
        printf ("%s", line);
    }

    free (line);
}

/* References:
* 
* http://www.gnu.org/software/libc/manual/html_node/Line-Input.html
* http://souptonuts.sourceforge.net/code/getline.c.html
*/

Dank @nameless für pseudocode und @hyde für die getline-Funktion(ich wusste es nicht).

InformationsquelleAutor

-2

Können Sie eine Schleife verwenden, um diese Linien... d.h.
```
for(...) {

  scanf(...); /* or use getline() here*/

}
```
Und auch eine Schleife verwenden, um es zu drucken, wie die obige Antwort.

Und es ist einfach, wenn Sie einen neuen Mann in der Programmierung, bitte mehr Praxis und mehr. 🙂

InformationsquelleAutor Cheeray

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.