csv Datei erstellen / Permutation (Sprache C )

[Esra-Maria A. (esramaria_a)]

Hallo Zusammen,

ich möchte eine csv Datei erstellen. Diese Datei soll in der Ersten 
Spalte eine gewisse Anzahl an Zuständen haben. z.B. 4374. Die zweite, 
dritte und vierte Spalte soll die Werte der Fakultät N = 3 (3! = 6) 
haben. (d.h. 012, 102, 201, 210, 021, 120). Die restlichen sechs Spalten 
können jeweils Werte von 0-2 annehmen (N=3).
Das heißt die Erste Spalte besitzt nun z.B. die Zustände 1-6.
1 012 000000
2 102 000000
3 201 000000
4 210 000000
5 021 000000
6 120 000000
7 012 000001
8 102 000001
9 201 000001
10 210 000001
11 021 000001
12 120 000001
usw.

Habe die letzten 9 Spalten mittels for-Schleifen geschrieben und darum 
eine while-Schleife gesetzt, welche die Zustände angeben soll.

Leider erhalte ich nicht die gewünschte Ausgabe. Siehe Dateianhang.

Könnte mir hier jemand vielleicht weiterhelfen?
Wäre euch sehr dankbar!

[CODE]#include <stdio.h>

int main()
{

int q = 1, x = 0, y = 0, z = 0;
int a = 0, b = 0, c = 0;


FILE *permutation=fopen("testn3.csv","w+");

fprintf(permutation, "Zustand; N; a; b; c;\n");

{


while(q <= 4374){

for(a=0; a<=3; a++)
{
for(b=0; b<=3; b++)
{
for(c=0; c<=3; c++)
{


for (x = 0; x <= 3; x++)
{

for (y = 0; y <= 3; y++)
{

for (z = 0; z <= 3; z++)
{



{


fprintf(permutation, "%d %25d %d %d %30d %30d %30d\n",
q,a,b,c,x,y,z);

q++;

}


}

}
}

}

}
}
}
}
}
/CODE]

[Kaj G. (Firma: RUB) (bloody)]

#include <stdio.h>

int main()
{
    
    int q = 1, x = 0, y = 0, z = 0;
    int a = 0, b = 0, c = 0;
    
    FILE *permutation=fopen("testn3.csv","w+");
    
    fprintf(permutation, "Zustand; N; a; b; c;\n");
    
    {
        while(q <= 4374){
            for(a=0; a<=3; a++)
            {
                for(b=0; b<=3; b++)
                {
                    for(c=0; c<=3; c++)
                    {
                        for (x = 0; x <= 3; x++)
                        {
                            for (y = 0; y <= 3; y++)
                            {
                                for (z = 0; z <= 3; z++)
                                {
                                    {
                                        fprintf(permutation, "%d %25d %d %d %30d %30d %30d\n",
                                                q,a,b,c,x,y,z);
                                        
                                        q++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

[Esra-Maria A. (esramaria_a)]

C#include <stdio.h>

int main() 
{
  
  int q = 1, x = 0, y = 0, z = 0;
  int a = 0, b = 0, c = 0;
  
  
  FILE *permutation=fopen("testn3.csv","w+");
  
  fprintf(permutation, "Zustand; N; a; b; c;\n");
  
    { 
  
  
  while(q <= 162){
    
  for(a=0; a<=2; a++)
  { 
      for(b=0; b<=2; b++)
        { 
          for(c=0; c<=2; c++)
            { 
            
      
      for (x = 0; x <= 2; x++)
          {
            
            for (y = 0; y <= 2; y++)
              {
                
              for (z = 0; z <= 2; z++)
                {
              
                                
        
          {
            
            
          fprintf(permutation, "%d %25d %d %d %30d %30d %30d\n", 
          q,a,b,c,x,y,z);
          
            q++;
              
                    }
        
            
                   }
            
                }
              }
        
             }
        
            }
            }
            }
            }
            }
            Code

[nicht"Gast" (Gast)]

Esra-Maria A. schrieb:
> ich möchte eine csv Datei erstellen. Diese Datei soll in der Ersten
> Spalte eine gewisse Anzahl an Zuständen haben. z.B. 4374. Die zweite,
> dritte und vierte Spalte soll die Werte der Fakultät N = 3 (3! = 6)
> haben. (d.h. 012, 102, 201, 210, 021, 120). Die restlichen sechs Spalten
> können jeweils Werte von 0-2 annehmen (N=3).
> Das heißt die Erste Spalte besitzt nun z.B. die Zustände 1-6.
> 1 012 000000
> 2 102 000000
> 3 201 000000
> 4 210 000000
> 5 021 000000
> 6 120 000000
> 7 012 000001
> 8 102 000001
> 9 201 000001
> 10 210 000001
> 11 021 000001
> 12 120 000001

Hallo,

sorry wenn ich das so schreibe. Mir tut sich da ein großes Fragezeichen 
auf. Du willst 6 Spalten, zeigst aber nur 3. Du willst was mit der 3! 
aber das soll 012,102,201 u.s.w sein.

Les das mal selber mit den Augen eines Fremden und dann beschreibe dein 
Problem noch mal. So ist das erst mal rumrate, was du willst.

Grüße

[Esra-Maria A. (esramaria_a)]

Ja sorry du hast vollkommen Recht. N=3 und drei weitere Variablen. Habe 
den Code nochmal optimiert und es soll folgendes ausgegeben werden. 
(Siehe Dateianhang)

C#include <stdio.h>

int main() 
{
  
  int q = 1, x = 0, y = 0, z = 0;
  int a = 0, b = 0, c = 0;
  
  
  FILE *permutation=fopen("testn3.csv","w+");
  
  fprintf(permutation, "Zustand; N; a; b; c;\n");
  
    { 
  
  
  while(q <= 162){
    
  for(a=0; a<=0; a++)
  { 
      for(b=0; b<=1; b++)
        { 
          for(c=0; c<=2; c++)
            { 
            
      
      for (x = 0; x <= 2; x++)
          {
            
            for (y = 0; y <= 2; y++)
              {
                
              for (z = 0; z <= 2; z++)
                {
              
                                
        
          {
            
            
          fprintf(permutation, "%d %25d %d %d %30d %30d %30d\n", 
          q,a,b,c,x,y,z);
          
            q++;
              
                    }
        
            
                   }
            
                }
              }
        
             }
        
            }
            }
            }
            }
            }
            
      
    
  
Code

[Christopher B. (chrimbo)]

Ich verstehe es trotzdem nicht, bei mir ist N! für N=3 immer 6

[Esra-Maria A. (esramaria_a)]

ja genau. Und Insgesamt mit N!*N^3 ergibt das Zustände von 1 - 162.

(N! = 3! => 6 * N^3 = 3^3 => 27 -> 6 * 27 = 162 Zustände)
Die Tabelle soll entsprechend aufgebaut werden. Und das klappt mit 
meinem Code nicht.

[Nop (Gast)]

Wird immer konfuser.. Fakultät und Permutation gehen munter 
durcheinander, jetzt ist da auch noch irgendwoher ein N^3 gekommen, und 
es sind immer noch nur drei Spalten, die erste Zeile der Tabelle gibt 5 
Spalten vor, mit Semikolon getrennt, im Schleifenbody werden dann 7 
Variablen ausgegeben, ohne Semikolon.

Ich würd mal sagen, wenn die Aufgabenstellung schon dermaßen unklar ist, 
dann wird der Code halt nicht funktionieren.

Kopier halt einfach die ersten 6 Zeilen immer hintereinander weg und 
zähl dabei die erste Spalte immer um 1 hoch. Die letzte Spalte wird 
offenbar alle 6 Zeilen um 1 erhöht. Irgendwie sowas soll der Code wohl 
machen, genau weiß man's nicht.

[Johann L. (gjlayde)]

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

int main (void)
{
    static const char * const p[] = { "012", "102", "201", "210", "021", "120" };
    int n = 0;

    for (char c0 = '0'; c0 <= '2'; c0++)
        for (char c1 = '0'; c1 <= '2'; c1++)
            for (char c2 = '0'; c2 <= '2'; c2++)
                for (size_t i = 0; i < sizeof (p) / sizeof (*p); i++)
                    printf ("%4d: %s %c%c%c\n", ++n , p[i], c0, c1, c2);

    return EXIT_SUCCESS;
}

Ausgabe:

   1: 012 000
   2: 102 000
   3: 201 000
   4: 210 000
   5: 021 000
   6: 120 000
   7: 012 001
   8: 102 001
   9: 201 001
  10: 210 001
  11: 021 001
  12: 120 001
  13: 012 002
  14: 102 002
  15: 201 002
  16: 210 002
  17: 021 002
  18: 120 002
  19: 012 010
  20: 102 010
  21: 201 010
  22: 210 010
  23: 021 010
  24: 120 010
  25: 012 011
  26: 102 011
  27: 201 011
  28: 210 011
  29: 021 011
  30: 120 011
  31: 012 012
  32: 102 012
  33: 201 012
  34: 210 012
  35: 021 012
  36: 120 012
  37: 012 020
  38: 102 020
  39: 201 020
  40: 210 020
  41: 021 020
  42: 120 020
  43: 012 021
  44: 102 021
  45: 201 021
  46: 210 021
  47: 021 021
  48: 120 021
  49: 012 022
  50: 102 022
  51: 201 022
  52: 210 022
  53: 021 022
  54: 120 022
  55: 012 100
  56: 102 100
  57: 201 100
  58: 210 100
  59: 021 100
  60: 120 100
  61: 012 101
  62: 102 101
  63: 201 101
  64: 210 101
  65: 021 101
  66: 120 101
  67: 012 102
  68: 102 102
  69: 201 102
  70: 210 102
  71: 021 102
  72: 120 102
  73: 012 110
  74: 102 110
  75: 201 110
  76: 210 110
  77: 021 110
  78: 120 110
  79: 012 111
  80: 102 111
  81: 201 111
  82: 210 111
  83: 021 111
  84: 120 111
  85: 012 112
  86: 102 112
  87: 201 112
  88: 210 112
  89: 021 112
  90: 120 112
  91: 012 120
  92: 102 120
  93: 201 120
  94: 210 120
  95: 021 120
  96: 120 120
  97: 012 121
  98: 102 121
  99: 201 121
 100: 210 121
 101: 021 121
 102: 120 121
 103: 012 122
 104: 102 122
 105: 201 122
 106: 210 122
 107: 021 122
 108: 120 122
 109: 012 200
 110: 102 200
 111: 201 200
 112: 210 200
 113: 021 200
 114: 120 200
 115: 012 201
 116: 102 201
 117: 201 201
 118: 210 201
 119: 021 201
 120: 120 201
 121: 012 202
 122: 102 202
 123: 201 202
 124: 210 202
 125: 021 202
 126: 120 202
 127: 012 210
 128: 102 210
 129: 201 210
 130: 210 210
 131: 021 210
 132: 120 210
 133: 012 211
 134: 102 211
 135: 201 211
 136: 210 211
 137: 021 211
 138: 120 211
 139: 012 212
 140: 102 212
 141: 201 212
 142: 210 212
 143: 021 212
 144: 120 212
 145: 012 220
 146: 102 220
 147: 201 220
 148: 210 220
 149: 021 220
 150: 120 220
 151: 012 221
 152: 102 221
 153: 201 221
 154: 210 221
 155: 021 221
 156: 120 221
 157: 012 222
 158: 102 222
 159: 201 222
 160: 210 222
 161: 021 222
 162: 120 222

Mit den Permutationen hab ich geschummelt, da einfach hingeschrieben. 
Falls N variablel sein soll, ist das Mittel der Wahl faktorielle 
Darstellung (dito für Iteration über alle Teilmengen wie "6 aus 49"):

https://de.wikipedia.org/wiki/Fakultätsbasiertes_Zahlensystem

Falls die Kombinationen variabel sein sollen, denn geht das besser mit 
Darstellung einer N-stelligen Zahl zu Basis B (hier mit B = N) anstatt 
einer N-fachen Schleife.  Und schleifen wird man über die Stellen (z.B. 
als int) und nicht direkt über das auszugebende Zeichen (hier als char).

Schließlich ist die Zählung der Permutationen recht ungewöhnlich; eine 
kanonische Zählung wäre

012
021
102
120
201
210

d.h. monoton wachsend wie man sie z.B. mit Faktoriellen erhält.

[Esra-Maria A. (esramaria_a)]

Vielen Dank für deine Antwort.

Ich habe jetzt N=3 genommen um es erst einmal übersichtlich zu testen. 
Normalerweise muss ich folgende Werte nehmen:

N=4, N=6 und N=8. Und das ist dann dementsprechend hoch. Da würde ich n 
lieber variabel lassen. Habe deinen Code getestet und funktioniert 
wunderbar. Aber würde die Werte gerne in einer csv Datei ausgeben 
lassen.

[Johann L. (gjlayde)]

Die Ausgabe kann direkt im C-File gemacht werden, oder indem man die 
Ausgabe von stdout in die gewünschte Datei piped wie in

$ ./programm > datei.txt