Benutzerdefinierte iteration über array in C drucken bei jedem N-TEN Wert

Zur Zeit arbeite ich an einer Hausaufgabe und was ich zu tun habe, ist zu Fragen für die Größe des Arrays und das, was ich möchte, um eine Schleife durch Sie, wie viele Dinge ich sollte überspringen). Beispiel (habe ich Fett was wäre die user-Reaktion)

Wie groß ist das array?
10

Wie Sie Durchlaufen wird?
3

Bedingungen:

Dann sollte es eine Schleife durch jedes Dritte Element und starten Sie dann über die Schleife durch die Elemente, die nicht ausgewählt worden, bis zum letzten. Ich muss auch starten auf das erste Element (0), die Sie sehen können in meinem code, die ich angegeben habe.


Dies ist, was ich dachte, ich könnte das tun…

int amount=0, often=0, counter=0, x;

printf("Size of Array? ");
scanf("%d", &amount);
printf("iteration size? ");
scanf("%d", &often);

//sets the array (1 means it exists)
int[] array[amount];
for(x=0; x<amount; x++)
    array[x] = 1;

//the part that I'm confused on
//supposed to iterate through everything
for(x=0; x<amount; x++){
    if(array[0] == 1){
        printf("#0\n");
        array[0]=0;
    }
    if(array[x]==1)
        counter++;
    if(counter == often){
        printf("#%d\n", x);
        array[x]=0;
        counter=0;
    }
return 0;
}

Allerdings brauche ich, um kontinuierlich Durchlaufen, bis das gesamte array getan, außer das Letzte. Mine Stoppt nach I-Schleife durch das array einmal. Dies ist die Ausgabe habe ich vers die Ausgabe, die ich möchte.

Meine Ausgabe:

0

3

6

9

Wollte output:

0

3

6

9

4

8

5

2

7

Beachten Sie, wie die das wollten Ausgang durchläuft es erneut Kommissionierung der Dritten Reihe, der bisher nicht abgeholt noch. Das ist, wo ich bin verwirrt, und wie dieses problem zu lösen. Keine Anleitung oder Informationen wären toll, danke.

  • Sie müssen angeben, dass die Größe des array mit einem Konstanten Wert. int array[256] sollte gut genug für die meisten Zwecke.
  • Sind Sie sicher, dass das, was die Ausgabe sein soll? Von der Beschreibung hätte ich erwartet, daß 0,3,6,9,1,4,7,2,5,8 oder 0,3,6,9,2,5,8,1,4,7.
  • also du sagst, einfach die Größe des Arrays und mehrere es durch den Raum, in Iterationen?
  • ja der Ausgang sein sollte, was ich in Frage. Da kann man nicht zählen „0“ wieder, wenn die Schleife durch, da es bereits verwendet wurde (gleich für 3″) damit Sie am Ende auf „4“.
  • Ich würde für den einfachen Weg. Während der loop realloc alle die Zeit, die ein array wie dieses: in Jeder iteration ( Schritt NUR von EINEM, egal, was der Benutzer ausgewählt hat ), kann modulo-Division die ganze Zahl in der aktuellen position, die von der gewählten iterator. Wenn modulo ist 0, die printf ausgegeben werden kann, wenn es gesetzt ist, realloc dem anderen array und trage die zahlen in zwischen in das neue array. Die zweite Schleife würde die Schleife über das neue array und drucken Sie nur diejenigen, die nicht aufgeteilt wurden, die von der gewählten iterator ohne rest. Voila.
  • C99 erlaubt variable-length arrays. Es ist ein Syntaxfehler in der Zeile (die leere [] nicht dort sein sollte), sondern nur das archaisch-Compiler erlauben nicht die Verwendung eines VLA.

InformationsquelleAutor Joe | 2016-03-22

 

3 Replies
  1. 3

    Müssen Sie zu halten, looping, bis alle zahlen wurden gedruckt,
    zum Beispiel so:

    int total = amount;
    counter = often - 1;
    while (total > 0) {
        for(x=0; x<amount; x++){
            if(array[x]==1)
                counter++;
            if(counter == often){
                printf("#%d\n", x);
                array[x]=0;
                counter=0;
                total--;
            }    
        }
    }

    Edit: Das gesamte Programm:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main (void) {
      int amount=0, often=0, counter=0, x;
    
      printf("Size of Array? ");
      scanf("%d", &amount);
      printf("iteration size? ");
      scanf("%d", &often);
    
      //sets the array (1 means it exists)
      int array[amount];  //Fixed typo in declaration
      for(x=0; x<amount; x++)
        array[x] = 1;
    
      //the part that I'm confused on
      //supposed to iterate through everything
      int total = amount;
      counter = often - 1;
      while (total > 0) {
        for(x=0; x<amount; x++){
          if(array[x]==1)
            counter++;
          if(counter == often){
            printf("#%d\n", x);
            array[x]=0;
            counter=0;
            total--;
          }
        }
      }
      return 0;
    }

    Zusammenstellung:

     gcc -std=c99 -Wall a.c -o a

    Ausführen des Programms:

    Size of Array? 10
    iteration size? 3
    #0
    #3
    #6
    #9
    #4
    #8
    #5
    #2
    #7
    #1
    • Ich versuchte dies und ich erhalte 0, dann 4, und es dauert eine Weile zu laden. Ich bin mir nicht sicher, warum ich immer dieses problem. Haben Sie irgendwelche Ideen?
    • Es funktioniert für mich. Vergleichen Sie Ihre version, von mir und sehen, ob es da Unterschiede gibt.
    • Ah gefunden, meine Fehler zu! lemme geben Sie ihm einen Versuch und sehen, wie es funktioniert.
    • Auch haben Sie irgendwelche Ideen für einen besseren Titel zu diesem problem? Ich konnte nicht an nichts denken, und ich möchte sicherstellen, dass ich erreichen kann, so viele Menschen wie möglich.
    • Wie funktioniert das mit den Werten 10 und 2 oder 10 und 4? Wenn die Größe und Schritt nicht gegenseitig prime (wenn GCD(Größe, Schritt) ist nicht 1), müssen Sie zusätzliche Arbeit zu tun.
    • Der Algorithmus ist zum drucken jedes N-te der übrigen zahlen. Wenn Sie die höchste Zahl, die Sie nur weiter von der niedrigsten Anzahl der verbleibenden ohne rücksetzen der aktuellen Zählung. Der Algorithmus funktioniert für beliebige positive ganze zahlen, die passen in die gewählte Art.

  2. 1

    Beginnen wir mit einer Schleife, die überspringt alle drei zahlen:

    for(int i = 0; i < amount; i += 3)
    {
        print(i);
    
        array[i] = 0;
    }

    Nun, dies scheint nur zu Arbeit für 0, 3, 6, 9.

    Wir wollen in der Lage sein zu beginnen bei den ersten vorhandenen Wert, und wiederholen Sie diesen Vorgang, bis nichts mehr übrig ist.

    Also legen wir mal eine weitere Schleife auf der Außenseite, zu zählen, wie viele Elemente bleiben:

    int total = amount;
    
    while(total > 0)
    {
        for(int i = 0; i < amount; i += 3)
        {
            print(i);
    
            array[i] = 0;
            total--;
        }
    }

    Gut so weit, aber wir sind noch bei 0 beginnen zu jeder Zeit. Wir möchten, dass der start auf einen bestimmten Wert, und überspringen, bis die 3. Zahl erreicht ist.

    int total = amount;
    
    while(total > 0)
    {
        for(int i = getStartingIndex(array, 3); i < amount; i += 3)
        {
            while(array[i] == 0 && i < amount)
                i++;
    
            print(i);
    
            array[i] = 0;
            total--;
        }
    }

    Definieren wir unsere getStartingIndex Funktion:

    int getStartingIndex(int array[], int skipCount)
    {
        int index = 0;
    
        for(int i = 0; i < skipCount; i++)
        {
            while(array[index] == 0)
                index++;
    
            index++;
        }
    
        return index - 1;
    }

    Nun, wir starten auf den angegebenen Wert, und drucken Sie die zahlen, bis wir amount. Und dann gehen wir zurück zum Anfang, aber wir beginnen bei der Dritten, noch nicht verwendete Nummer.

    • Ich glaube, ich verstehe, lassen Sie mich das ausprobieren, wirklich schnell. Ich könnte auch ersetzen Sie den Wert 3 auch mit jeder loop-iteration, und es würde immer noch funktionieren, richtig?
    • Es sieht aus wie diese geben 0369147258, im Gegensatz zu 036948527, wie aufgeführt in der post. Lese den post nochmal, es sieht aus wie diese Bestellung ist eine Anforderung.
    • Also ich mag es, wie Sie schauen durch und das Teil funktioniert, aber was ist mit der überprüfung, ob die Zahl bereits verwendet wurde? Zum Beispiel habe ich bemerkt, dass wenn ich durch gehe ich aus „0369“ bis „147“, wenn ich sollte gehen „48“, weil ich bereits verwendet, 0 und 3. Ich weiß nicht, ob das Sinn macht aber erklären kann ich weiter wenn nötig. Grundsätzlich bin ich nicht Schleifen über zahlen, dass ich nicht angenommen.
    • Ah, die Dritte Zahl, die noch nicht ausgewählt worden, noch! Ich aktualisiert meine Antwort.
  3. 0

    Wir benötigen, um die aktuelle Schrittweite, läuft von null bis zum gewünschten step size-und jedes mal, wenn wir besuchen einen index, und markieren Sie Sie als „besucht“ werden wir zurücksetzen der Zähler auf null. Unsere Haupt-Schleife iteriert durch das array, bis es keine Indizes der noch nicht besuchten Links. Wir stellen sicher, dass der index nicht ausgeführt wird außerhalb der Grenzen des Arrays, also wenn der index zuvor die Länge des Arrays, setzen wir es auf null.

    Wenn Sie nicht möchten, dass das Letzte element gedruckt werden soll, ändern Sie einfach die while-Schleife ist abhängig von der while (visited_count < total_length - 1)

    int main() {
        int array[10] = { 0 };
        int total_length = 10;
        int visited_count = 0;
        int index = 0;
        int step_size = 3;
        int current_step = 3;
        while (visited_count != total_length) /* while there are unvisited elements */
        {
            if (!array[index] && current_step == step_size) /* array[index] has value zero, and we are at the desired step count, so print that element and mark it as visited */
            {
                array[index] = 1;
                visited_count++;
                printf("%d\n", index);
                current_step = 0; /* resetting the step counter */
            }
            index++; /* this is how we iterate over the array, incrementing it at each iteration */
            if (index == total_length) /* checking for out-of-bounds of the array, if we hit the total length, the index should be reset. */
            {
                index = 0;
            }
            if (!array[index]) /* now that we have stepped through the array, we increment the step counter if that element is not visited. */
            {
                current_step++;
            }
        }
        return 0;
    }

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.