Random Gruppenverteilung erstellen

Hallo,
ich versuche gerade eine automatische Gruppenverteilung zu erstellen.
Es wird abgefragt, wieviel Spieler teilnehmen und wieviel Gruppen es gibt.

Dann sollen die Namen einglesen werden und zufällig auf die Spieler verteilt werden.

Code:

---

//Gruppenverteilung
#include <stdio.h>
#include <stdlib.h>
int spieler;
int anzahl;
char name;

int main()
{
    // Anzahl der teilnehmenden Spieler
    printf("Wieviel Spieler nehmen am Turnier teil?\n");
    scanf("%i",&spieler);
    printf("Sie haben %i Spieler ausgewaehlt.\n\n", spieler);
   
    // Eingabe der Spieler
    anzahl = 1;
    while (anzahl <= spieler)
    {
        printf("Spieler %i:\n", anzahl);
        // Hier sollen die Namen eingelesen werden
        printf("Spieler %i. heisst %s\n",anzahl,name);
        anzahl = anzahl + 1;

    } // Ende while
    system("Pause");

    return 0;
} // Ende main

---

Meine Frage nun: Wie lese ich am besten einen Namen ein? Bei scanf kann ich glaube ich nur ein Wort einlesen weil er das Leerzeichen nicht erkennt.
Dann gibts aber auch noch Befehle wie gets oder getchar; welchen müsste ich jetzt hier anwenden und warum?

Viele Grüße

http://www.cplusplus.com/reference/c.../cstdio/fgets/

Beachten: \n ist dann mit im String.

Ich hab jetzt folgendes deklariert:
char name[25];

Und bei der Abfrage dann:
fgets(name, 25, stdin);

Leider überspringt er diese Eingabe in meiner Schleife

Definition von fgets:
str: Pointer to an array of chars where the string read is stored.

Versuchs mal mit einem fgets((char*) &name, 25, stdin);

fgets(&name, 25, stdin);
^--- bitte stirb!

fflush(stdin);
sollte dein Problem lösen (vor fgets aufrufen), jedoch ist das Verhalten von fflush bei stdin nicht vom Standard vorgeschrieben... man sollte sich also eigentlich nach einer besseren Variante umsehen.

Probier mal die Funktion gets_s bei der Funktion wird kein '\n' hinten angehängt

Der Beitrag von BlackBerry hat mir sehr geholfen. Erstmal vielen Dank!

Nur weiß ich nicht genau was der Befehl "fflush(stdin);" macht, den ohne gehts nicht :).

Leider will ich ja mit meinen Eingaben weiterarbeiten und dafür muss ich wissen unter welchem Name diese gespeichert sind.
Mit welchem Befehl kann ich z.B. auf den 2. Namen zugreifen und diesen willkürlich einer Gruppe zuweisen?

Viele Grüße

PS: Sorry für die Anfängerfragen, bin aber leider noch ein Anfänger^^

Code:

---

anzahl = 1;
    while (anzahl <= spieler)
    {
        printf("Spieler %i: ", anzahl);
        fflush(stdin);
        fgets(&name, 25, stdin);
        printf("\nSpieler %i. heisst %s\n",anzahl,name);
        anzahl = anzahl + 1;

    } // Ende while

---

Zitat:

---

Zitat von FeroX1337

Nur weiß ich nicht genau was der Befehl "fflush(stdin);" macht, den ohne gehts nicht :).

---

Das darf offiziell niemand wissen:

Zitat:

---

Zitat von http://www.utas.edu.au/infosys/info/documentation/C/CStdLib.html#fflush

Effect undefined for input stream.

---

Tatsache ist, dass man scanf nicht benutzen sollte, da es die böse Angewohnheit hat Zeichen im input buffer zu belassen, obwohl diese bereits zur Auswertung der Ausdrücke in scanf benutzt wurden.

In dem Fall heißt das: scanf liest deine Zahl ein und lässt das \n (Zeilenumbruch; generiert, wenn du ENTER drückst) im input buffer.
Nun kommt fgets, welches genau auf so ein Zeichen wartet um abzubrechen - es findet dieses Zeichen - und (wer hätte es gedacht) bricht ab.

Was fflush(stdin) jedoch auf allen von mir bisher benutzten Systemen getan hat (aber immer im Kopf behalten: es dürfte sich auch anders verhalten), ist den input buffer zu leeren. Damit wartet fgets dann wirklich auf neue Zeichen und liest nicht die ein, die bereits da sind.

Zitat:

---

Zitat von FeroX1337

Mit welchem Befehl kann ich z.B. auf den 2. Namen zugreifen und diesen willkürlich einer Gruppe zuweisen?

---

Was für eine Gruppe? Du hast keine Gruppen.

Zitat:

---

Zitat von BlackBerry

Was für eine Gruppe? Du hast keine Gruppen.

---

Ich will sagen wir mal 20 Namen einlesen (mit der While Schleife) und dann die 20 Namen in 4(soll variabel sein) Gruppen unterteilen.
Um dies zu machen muss ich ja auf die eingegebenen Namen zugreifen.
Nur wie ist die Frage. Und die 2. Frage dann wie ich die Gruppenverteilung zufällig mache.

Code:

---

char szCoolName[20][32];
...
printf("Rand User:%s", szCoolName[rand()%20]);

---

und malloc/free oder new/delete sind ein muß wenn es variabel sein soll.

Ich habe das jetzt mal auf die Schnelle mit einer LinkedList implementiert.

Grundidee ist, dass man eine maximale Länge für einen Namen vorgibt und dann entsprechend Speicher reserviert: Anzahl der Namen * Maximale Länge pro Name

Die LinkedList speichert als Datenelement einen Zeicher auf einen char.
Jetzt liest man einen Namen in den reservierten Speicher ein, fügt die Adresse von dem Namen in die LinkedList ein und liest den nächsten Namen dort ein, wo der andere aufgehört hat.
Im Speicher sieht das also so aus:
Name1\x00Name2\x00Name3\x00...
Dabei gibt es so viele LinkedLists, wie Gruppen -- jede LinkedList stellt also eine Gruppe dar.
Die Einträge der LinkedLists zeigen dabei dann auf die Namen im Speicher.

Code:
#1182907 - Pastie

Wie man wahrscheinlich sieht programmiere ich erst seit einigen Wochen.
Aus diesem Grund kenn ich mich nur mit den Standard Befehlen aus.
Gibt es keine einfache möglichkeit mit scanf/gets/fgets usw namen in einer schleife eingeben zu lassen und danach abzurufen?
Mein Code bis jetzt:

Code:

---

//Gruppenverteilung
#include <stdio.h>
#include <stdlib.h>
int spieler;
int anzahl;
char name[25];
int auswahl;

int main()
{
    // Anzahl der teilnehmenden Spieler
    printf("Wieviel Spieler nehmen am Turnier teil?\n");
    scanf("%i",&spieler);
    printf("Sie haben %i Spieler ausgewaehlt.\n\n", spieler);
    system("Pause");
    system("Cls");
   
    // Eingabe der Spieler
    anzahl = 1;
    while (anzahl <= spieler)
    {
        printf("Spieler %i: ", anzahl);
        fflush(stdin);
        fgets(&name, 25, stdin);
        printf("\nSpieler %i. heisst %s\n",anzahl,name);
        anzahl = anzahl + 1;

    } // Ende while
    printf("Welchen Spielername aufrufen?:"),
    scanf("%i",&auswahl);
    printf("\nSie haben Spielername %i. gewaehlt.\n",auswahl);
    system("Pause");

    return 0;
} // Ende main

---

Ich verstehe nicht, wo da jetzt die Frage sein soll. Es gibt keine einfachere Möglichkeit sowas in C zu machen.
Wenn du später auch auf die Namen zugreifen willst, so musst du dich dann wohl oder übel auch um die Speicherverwaltung kümmern.
Als Beispiel dafür verweise ich nochmal auf meinen Code: #1182907 - Pastie

Es wäre einfacher das direkt als Array darzustellen.
Und die Speicherdarstelleung ist auch falsch. (Name1\x00 POINTER Name2\x00 ...)

Code:

---

#define MAX_PLAYER_NAME_LENGTH 32
int main()
{
  char* szAllNames;
  int iPlayers, i = 0, iTotalStrlen = 0;

  scanf("%i", &iPlayers);
  szAllNames = (char*) malloc(MAX_PLAYER_NAME_LENGTH * iPlayers);
  for(; i< iPlayers; i++)
  {
      scanf("%s", &szAllNames[iTotalStrlen]);
      iTotalStrlen += strlen(&szAllNames[iTotalStrlen]);
  }
  free(szAllNames)
}

---

(eben aus dem kopf (== wahrscheinlich ein kleiner fehler der es zum abstürzen bringt drin). aber das prinzip sollte klar sein)

Zitat:

---

Zitat von wacked

Es wäre einfacher das direkt als Array darzustellen.
Und die Speicherdarstelleung ist auch falsch. (Name1\x00 POINTER Name2\x00 ...)

---

Es ist doch direkt als Array implementiert.
Nur jetzt sag mir noch wie du die dann den Gruppen hinzufügen würdest? TADA: du musst die Namen irgendwie referenzieren.

Was das (Name1\x00 POINTER Name2\x00 ...) angeht, kann ich nur sagen: falsch von dir, richtig von mir.
Das Layout ist
Name1\x00Name2\x00Name3\x00...
(^------- keine Pointer... das sind wirklich char's!)
in namesbuf. Referenziert werden jeweils die Anfänge der Namen in den LinkedLists für die Gruppen.

Bitte beim nächsten Mal genauer lesen.

Zitat:

---

Zitat von wacked

iTotalStrlen += strlen(&szAllNames[iTotalStrlen]);

---

Das ist falsch. Dann hättest du anschließend folgendes Layout im Speicher:
Name1Name2Name3...
Die Namen wären also nicht null-terminiert und somit hättest du Probleme, sobald du versuchst die anzuzeigen, sobald alle Namen eingelesen sind.
Was du hier also machst ist eine Art strcat.

Vielleicht zur Einfachheit !

Code:

---

struct _User
{ char myName[256]; }User[1024];

static nUseranzahl = 0;

int main(int argc, char **argv)
{
    //TODO Like in BB Paste.
}

---

Oh sorry so kompliziert will ich nicht denken. Da ich aber nicht komplett als Vollidiot darstellen will füge ich das gruppen zeug noch dazu (natürlich teste ich wieder nicht. dann kann man nämlich fehler machen ohne dass es einem zum verhängniss wird)

Code:

---

struct LIST
{
    char* szName;
    LIST* Next;
};
void DumpList(LIST* LIST)
{
    LIST* Tmpg_LIST = LIST;
    int i = 0;
    while(Tmpg_LIST->Next)
    {
        printf("%i=>%s\n", i++, Tmpg_LIST->szName);
        Tmpg_LIST = Tmpg_LIST->Next;
    }
    printf("%i=>%i\n", i++, Tmpg_LIST->szName);
}
bool IsInLinkedList(LIST* LIST, char* szSearchName)
{
    LIST* Tmpg_LIST = LIST;
    while(Tmpg_LIST->Next)
    {

        if(Tmpg_LIST->szName == szSearchName)
        {
            return true;
        }
        Tmpg_LIST = Tmpg_LIST->Next;
    }
    return Tmpg_LIST->szName == szSearchName;
}
bool AddToLinkedList(LIST* LIST,char* szAddName)
{
    LIST* LastEntry = LIST;
    while(LastEntry->Next)
    {
        LastEntry = LastEntry->Next;
    }

    LastEntry->Next = (LIST*) malloc(sizeof(LIST));
    if(!LastEntry->Next)
    {
        return false;
    }
    LastEntry = LastEntry->Next;
    LastEntry->szName = szAddName;
    LastEntry->Next = 0;
    return true;
}

---

Code:

---


#define MAX_PLAYER_NAME_LENGTH 32
int main()
{
  char* szAllNames;
  LIST* pGroups;
  int iPlayers /* Maximal players NOT players per group*/, i = 0, j = 0, iTotalStrlen = 0, iGroups = 0;


  scanf("%i", &iGroups);
  pGroups = (LIST*) malloc(sizeof(LIST) * iGroups);
  scanf("%i", &iPlayers);
  szAllNames = (char*) malloc(MAX_PLAYER_NAME_LENGTH * iPlayers);
 
  for(; j < iGroups; j++)
  {
    for(; i < iPlayers; i++)
    {
        scanf("%s", &szAllNames[iTotalStrlen]);
        AddToLinkedList(pGroups[j], &szAllNames[iTotalStrlen]);
        iTotalStrlen += strlen(&szAllNames[iTotalStrlen]);
    }
  }
  for(; j < iGroups; j++)
    DumpLinkedList(pGroups[j]);
 
  free(szAllNames)
}

---

Mit POINTER meinte ich den Pointer auf den nächsten Eintrag der Linked List. (Was natürlich in diesem Fall auch falsch ist aber von meiner Unfähigkeit Strukturen zu lesen herrührt)

Actually it should be C++. Man darf in C nicht beim deklarien direkt etwas zuweisen oder so was richtig?
Und das mit der Tempg_LIST und LastEntry liegt daran dass es in dem Code aus dem ich es rauskopiert habe beide globale Variablen sind. Wenn ich dann keine temporären Variablen benutzt hätte würde logischerweiße das Durchsuchen der Liste nicht (mit dieser Funktion) funktioniern.

Aber lassen wir meine Fehler hier mal raus. Ist schon peinlich genug.

Ich versuche gerade ein einfaches Beispiel zu erstellen:
Daher möchte ich nun erst einmal:
3 Namen in ein String-Array speichern und auslesen; wie ich 3 integer Werte in ein 3er array speichere ist klar; ich will aber 3 Namen z.B. Max Mustermann, Susi Schneider, usw. in ein array speichern.

Code:

---

#include <stdio.h>
#include <stdlib.h>
int laufv;
char namen[100];
int auswahl;

int main()
{
    // Eingabe der Spieler
    for (laufv = 1; laufv <= 3; laufv++)
    {
        printf("Spieler %i: ", laufv);
        scanf("%s",?????);

    } // Ende for Eingabe
    system("Pause");
    system("Cls");

    // Ausgabe der Spieler

        printf("Welchen Spieler moechten sie auswaehlen?:");
        scanf("%i",&auswahl);
        printf("Sie haben Nr.%i gewaehlt. Der Name lautet:%s",&auswahl,????);
        system("Pause");
 
        return 0;
} // Ende main

---

Das zeigt mal wieder, dass du meinen Post weder gelesen, noch überhaupt beachtet hast.

@ BlackBerry Ich habe deinen Post gelesen und auch deine Source angeschaut; nur werde ich aus dieser "linklist" nicht schlau;
das einzige was ich machen will, ist eine einfache speicherung von 3 namen in einem array; dafür müsste es doch auch was einfacheres geben als eine linklist.

ich hab auch schon bisschen gegoogelt und zum thema string array etwas gefunden; also es muss ihrgendwie gehen, da ich aber nicht genau weiß wie, komme ich leider nicht vorwärts

PS: Ebenso habe ich gesagt, dass ich Neuling iim bereich der programmierung bin und daher die hälfte der befehle in der link list nicht nachvollziehen kann

... und das zeigt wieder, dass du das gesammte Konzept der CStrings nicht verstanden hast.
Wenn du einen CString speichern willst, dann hast du einen hinreichend großen Speicherblock (d.h. einen Bereich im Speicher, der groß genug ist und dir zur Benutzung zur Verfügung steht) und einen Zeiger auf das erste Element im String (==> char *).
Da du aber nur den Anfang kennst ist es doch irgendwie einleuchtend, dass du das Ende irgendwie markieren musst. Dazu dient das 0-Zeichen (ASCII 0x00). Gibst du also beispielsweise einen String aus, so fängst du beim Anfang an und gibst Zeichen für Zeichen aus, bis du das 0-Zeichen erreicht hast, welches dir also das Ende signalisiert.

Willst du mehrere Strings speichern, so benötigst du wieder einen hinreichend großen Abschnitt im Speicher und eine Menge an Zeigern, die jeweils auf das erste Zeichen der verschiedenen Strings zeigen.
Wenn du dir dabei viele Aufrufe zu malloc() sparen willst, dann reservierst du gleich einen großen Block im Speicher und fängst an diesen zu beschreiben.
Der erste String kommt dann gleich an den Anfang von dem Block. Der zweite landet hinter dem ersten (präziser: hinter dem 0-Zeichen vom ersten, da man später ja noch wissen will, wo der erste CString aufhört). Der dritte landet dann hinter dem zweiten usw.

Jetzt bleibt nur noch das Problem sich zu merken, wo nun welcher String ist.
Hier kam jetzt bei mir die LinkedList ins Spiel, weil ja zusätzlich zu den Namen auch die Gruppe verwaltet werden sollte...
Natürlich könnte man es auch so lösen:

Code:

---

const unsigned int NAME_MAX_LENGTH = 30;
const unsigned int NAMES_MAX_COUNT = 50;

char names_buff[NAMES_MAX_COUNT * NAME_MAX_LENGTH];
struct
{
    unsigned int group;
    char *name;
} names[NAMES_MAX_COUNT];

---

names_buff würde dann die Namen enthalten (Name1\x00Name2\x00Name3\x00...) und names würde dann jeweils den Zeiger auf das erste Zeichen in einem Namen und dessen Gruppe enthalten.

names[i-1].name wäre dann der Name des i-ten Spielers und names[i-1].group der Index seiner Gruppe.

Ich habe nun mein Vorhaben stark vereinfacht.
Ich möchte nicht mehr die Namen einer Gruppe zuordnen, sondern mit einer einfachen Schleife eine beliebige Anzahl von Namen (z.B. Max Mustermann) unter Variablen speichern.
Nach dieser Eingabe soll eine kurze Abfrage erfolgen und der gewünschten Namen wieder ausgeben.

Zwar habe ich mir die Linklist genauer angeschaut, aber erscheint mir zu meinem Problem noch extrem kompliziert. Das müsste auch einfach gehen, als einfache ein und ausgabe.

grüße

Wenn dir die Linked-List zu kompliziert erscheint, dann lies doch einfach mal was ich vorhin geschrieben habe... willst du keine Gruppe verwalten vereinfacht sich

Code:

---

struct
{
    unsigned int group;
    char *name;
} names[NAMES_MAX_COUNT];

---

einfach zu

Code:

---

char *names[NAMES_MAX_COUNT];

---

Das Konzept mit names_buf bleibt unverändert.
Dir sollte eigentlich schon längst aufgefallen sein, dass hier schon alles dasteht und du es lediglich noch zusammensetzen musst.

Mir wird das jetzt auch langsam zu blöd mich hier ständig zu wiederholen.