C While-Schleife für ein array von ganzen zahlen

Dies ist eine noob Frage. Ich habe ein array namens Counter[N][N] und ich will so etwas wie:

 

 

While (each element of Counter < 10000) {do something}

 

 

While (there exists an element of Counter < 10000) {do something}

Gibt es einen einfachen Weg, das zu tun, in C?

Sie können mit einer doppelt verschachtelten Schleife zu überprüfen, können Sie dann ein, wenn etwas zu tun ist.
mein post,es gibt u Antwort
Sind Sie jetzt bitten", WENN es ein einzelnes element in Zähler weniger als 10000"?
Das ist genau das, was ich meinte.
Ok, ich bin mir nicht sicher, was die Anwendung von dieser ist. Schleife über ein 2D-array für jede while-Schleife ist vielleicht nicht die beste Idee. Was du tust, zu planen, WENN es ein element ist? Wenn Sie planen, Bearbeiten Sie das element, um es kleiner oder größer als 10000, Sie möchten verwenden Sie FOR-Schleifen wie in meinem Beispiel. Auf diese Weise werden Sie nur mit einer Schleife durch das array einmal.

InformationsquelleAutor Ariaramnes | 2012-09-22

  1. 2

    Diese Funktion testet, ob der Zähler-array übergeben in einem element kleiner als der angegebene Wert:

    bool has_element_less_than(int value, int counter[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
             if (counter[i][j] < value)
                 return true;
        }
    }

    return false;
}

    Verwenden Sie es:

    if (has_element_less_than(10000, counter))
    do_something();

    Könnte man umgehen mit Variablen dimension von arrays in C99 durch die übergabe N als parameter an die Funktion. Es wird vorausgesetzt, Sie haben die C99-header <stdbool.h> vorhanden und inklusive.

    Ist dies, was Sie nach? Sie erwähnen ', Während' es ist also nicht klar, ob Sie brauchen, um eine while loop — wenn Sie das tun, ich denke, das ist der job:

    int i = 0;

while (i < N)
{
    int j = 0;
    while (j < N)
    {
         if (counter[i][j] < 10000)
         {
             counter[i][j] = do_something(i, j, counter[i][j]);
         }
         j++;
    }
    i++;
}

    Oder, mehr umgangssprachlich, aber mit for Schleifen:

    for (int i = 0; i < N; i++)
{
    for (int j = 0; j < N; j++)
    {
         if (counter[i][j] < 10000)
         {
             counter[i][j] = do_something(i, j, counter[i][j]);
         }
    }
}

    Beachten Sie, dass dieser code ist mit C99; Sie können erklären i und j außerhalb der loops und es wird C89-code. Auch, wenn Sie aus irgendeinem Grund brauchen Sie i oder j (oder, wahrscheinlicher, beide) nach der Schleife, müssen Sie deklarieren Sie die Variablen außerhalb der Schleife.

    Die zweite Lösung mit for Schleifen ist mehr idiomatische C; die for Schleife ist sehr gut für diesen job und was sollten Sie planen, zu verwenden, nicht zuletzt, weil es Pakete, die alle loop Steuerelemente in einer einzigen Zeile, im Gegensatz zu den while - loop-Lösung, die das initialize-code auf eine Zeile (außerhalb der Schleife), der Zustand auf der anderen, und die erneute Initialisierung auf noch eine Dritte Linie.

    Sie könnten bemerken, dass die meisten Antworten könnte trivial angepasst auf die Antwort der überarbeiteten Frage, indem Sie den code in eine Funktion tun, die "etwas tun" ist, wenn der erste Wert kleiner als das limit ist, entdeckt zu werden, und dann sofort die Rückkehr. Der einzige Nachteil ist, festverdrahtung, die Handlung in dem, was sonst eine Allgemeine routine. Auch, wenn Sie müssen wissen, welches element kleiner ist als das limit, müssen Sie ein paar von output (Zeiger) Argumente für die has_element_less_than() Funktion.

    InformationsquelleAutor Jonathan Leffler

  2. 2

    Könnten Sie tun,

    for(int x = 0; x < N; x++) {
    for(int y = 0; y < N; y++) {
        if (Counter[x][y] < 10000){
             //Do something with Counter[x][y]
        }
    }
}

    InformationsquelleAutor btstevens89

  3. 1

    kann dies schön gemacht, mit Zeiger

      while(true)
  {
     int* pEnd = &Counter[0][0] + N*N;
     int* pCurrent = &Counter[0][0];

     bool AnyLess = false;
     while(pCurrent < pEnd && !AnyLess) { AnyLess |= *pCurrent++ < 10000; } 
     if(!AnyLess)
        break;

  }
    Ich glaube nicht, dass das, was der OP gefragt, glaube ich, Sie wollen, um eine Schleife über jedes element in Counter weniger als 10000, die nicht Loop-Schleife über die ersten 10000 Elementen.
    schon gesehen, ich bin nur Bearbeitung der post ...
    Hinweise ???? Horror für Neulinge wie mich .
    Zeiger sind gut, wenn Sie wollen, es zu tun, sehr schnell und mit einer kurzen Quellcode, siehe andere Antworten, wenn Sie es wollen, ohne Zeiger
    Der OP fragte nach einer einfachen Möglichkeit dies zu tun, in C. Wann mit einem array, Spiele mit dem Zeiger ist fast immer die Antwort.

    InformationsquelleAutor user287107

  4. 1

    Einfach, wenn man eine Funktion schreiben, die 1 zurück falls alle Elemente kleiner als 10000 :

    int check_array_lt(int row_count, int col_count, int** array, int value)
{
  int i,j;
  for(i=0;i<row_count;i++)
    for(j=0;j<row_count;j++)
      if (array[i][j]>=value)
        return 0;
  return 1;
}

    dann verwenden Sie es :

    while( check_array_lt(N,N,counter,10000) ) {
  do something
}

    Für die zweite version der Frage (ist nicht mehr jedes element < 10000", sondern "mindestens ein element < 10000') :

    int check_array_lt_atleast(int row_count, int col_count, int** array, int value)
{
  int i,j;
  for(i=0;i<row_count;i++)
    for(j=0;j<row_count;j++)
      if (array[i][j]<value)
        return 1;
  return 0;
}

    Wie gesagt von Jonathan Leffler, diese Lösung funktioniert nur, wenn das array wird dynamisch erzeugt, wenn der Zähler als array deklariert mit #defined N, als meine Lösung zerfällt in Jonathan.

    'Alle Elemente weniger als 10000' unterscheidet sich von 'mindestens eines der Elemente ist weniger als 10000'.
    Richtig ... es war nur eine Antwort auf die OP ' s "Erster Entwurf". Ich werde zu aktualisieren meinem Beitrag. ... fertig 🙂
    Ich weiß, ich bin eine pest, aber... Ein int **array parameter ist sehr Verschieden von einem int array[][N] parameter. Der ehemalige erfordert ein array von Zeigern, von denen jeder Punkte auf (das erste element) ein array von int; der zweite rechnet mit einem 2D-array. Wenn Sie versuchen, Ihren code mit einem eigentlichen 2D-array, ich denke, du wirst auf Probleme stoßen, vor allem, wenn die meisten der Werte im array sind Nullen.
    Nicht ein Schädling an alle, das ist, was ich mag, da ich immer etwas lernen. Ich veränderte meine Antwort entsprechend Ihren Punkt. Thx 🙂

    InformationsquelleAutor Kwariz

  5. 0

    Verschachtelte for-Schleife

    for(i=0;i<N;i++)
for(j=0;j<N;j++){

if(counter[i][j]<10000)
{
//Do something
}
}
    Natürlich!, aber ich habe die falsche Frage. Ich entschuldige mich.

    InformationsquelleAutor Mudassir Hasan

  6. 0

    Lösung für die BEARBEITETE Frage

        for(i=0;i<N;i++)
    for(j=0;j<N;j++){

    if(counter[i][j]<10000)
    {
       //Do something
    }else
       goto OUT;
    }

    OUT:
    printf("out of loops");

    In meiner arroganten Meinung

    springen

    Anweisung ist die elegante Konstrukt in der Sprache zu Programmieren . Wenn das jemand werden will Milliardär wie Bill Gates , müssen Sie viel springen, während die Entwicklung Ihrer bahnbrechenden software .

    Angenommen counter[0][0] enthält 1000000 und jeder andere Wert ist 0. Dein code springt aus der Schleife auf das erste element sieht es so aus, ignoriert alle anderen, die zeigen, dass bei der Verarbeitung getan werden muss. Bitte Einrücken, Ihre loops in einen mehr Orthodoxen Weise. Siehe auch McConnell, "Code Complete" und GOTO noch schädlich? für einige von den vielen Gesprächen, die von GOTO.

    InformationsquelleAutor Mudassir Hasan

  7. 0

    obwohl Sie nicht Fragen, für c# ist, ist hier die c# - Lösung, denn es wäre so einfach:

        var Counter = new int[N,N];
    while(Counter.Cast<int>.Any(i => i < 10000)) { dosomething(); }

    InformationsquelleAutor user287107

  8. 0

    Was ist das?

     int flag=0;
        for(i=o;i<n;i++)
        {
            for(j=o;j<n;j++)
            {
                if(counter[i][j]<10000)
                    //statements;
                else
                {
                  flag=1;
                    break;
                }

            }
  if(flag==1)
    break;
        }
    Danke, das würde funktionieren, wenn meine Frage war das erste, aber das wollte ich nicht, sorry.
    es prüft, ob element mit dem Wert 1000 ist vorhanden, wenn vorhanden dann geht es weiter zu arbeiten, wenn es got-Wert >1000 dann bricht die Schleife
    Die break Aussagen müssen näher erklärt werden. Wenn das element weniger als 1000 (beachten Sie, dass die Frage, sagte 10000, aber was ist eine Größenordnung, die zwischen Freunden), Sie wollen etwas Aussagen und brechen, sonst brechen Sie sowieso. Das ist nicht viel von einer inneren Schleife; iteriert nur einmal.
    Leffler:plz, siehe aktualisierten post
    Einstellung Flaggen...sehr schöner Mechanismus, um aus mehreren Schleifen..etwas neues Gelernt..danke..von Ihnen positiv bewertet werden

    InformationsquelleAutor Ravindra Bagale

Schreibe einen Kommentar