C Array auf Inhalt prüfen?

[Atamer (Gast)]

Hallo,

wie kann ich ein Array in C prüfen ob alle Werte darin 0 sind? Also ohne 
eine Schleife zu durchlaufen.

Atamer

[Der Andere (Gast)]

Gar nicht

[Dussel (Gast)]

Der Andere schrieb:
> Gar nicht
Doch klar.

if(Array[0]==0&&Array[1]==0&&Array[2]==0&& … &&Array[n]==0)
{
…
}

[Genialer Programmierer (Gast)]

Atamer schrieb:
> Also ohne eine Schleife zu durchlaufen.

So:

if (elemnt[0] != 0)  err++;
if (elemnt[1] != 0)  err++;
if (elemnt[2] != 0)  err++;
if (elemnt[3] != 0)  err++;
if (elemnt[4] != 0)  err++;
if (elemnt[5] != 0)  err++;
if (elemnt[6] != 0)  err++;

// usw.

Braucht kaum Speicherplatz und geht ganz ohne Schleife.

[Mugga (Gast)]

...
m = 0;
m |= a[0];
...
m |= a[n];
...

[Mark B. (markbrandis)]

Dussel schrieb:
> Der Andere schrieb:
>> Gar nicht
> Doch klar.
>
>

if(Array[0]==0&&Array[1]==0&&Array[2]==0&& … &&Array[n]==0)
> {
> …
> }
>

Genialer Programmierer schrieb:
> Atamer schrieb:
>> Also ohne eine Schleife zu durchlaufen.
>
> So:
>
>

> 
> if (elemnt[0] != 0)  err++;
> if (elemnt[1] != 0)  err++;
> if (elemnt[2] != 0)  err++;
> if (elemnt[3] != 0)  err++;
> if (elemnt[4] != 0)  err++;
> if (elemnt[5] != 0)  err++;
> if (elemnt[6] != 0)  err++;
> 
> // usw.
> 
>

>
> Braucht kaum Speicherplatz und geht ganz ohne Schleife.

Der 1. April war doch schon. ;-)

Was wenn das Array z.B. 256 Elemente hat? 256 Zeilen Code hinschreiben 
oder wie? Das macht doch kein normaler Mensch.

[Mark B. (markbrandis)]

Atamer schrieb:
> Hallo,
>
> wie kann ich ein Array in C prüfen ob alle Werte darin 0 sind? Also ohne
> eine Schleife zu durchlaufen.

Warum sollte es ein sinnvoller Ansatz sein, keine Schleife zu verwenden? 
Das ist genau die Standardlösung, die immer und ohne Probleme 
funktioniert. Da braucht man schon einen guten Grund um davon 
abzuweichen.

[Der Andere (Gast)]

Wie kann ich ein Auto bauen das keine Räder hat.

Und jetzt nicht kommen mit: Ich bau eins das fliegt, wenn es fliegt ist 
es ein Flugzeug, kein Auto, wenn es schwimmt ist es ein Boot, ...

Trollfrage halt und ihr fallt darauf rein.

[Genialer Programmierer (Gast)]

Mark B. schrieb:
> Das macht doch kein normaler Mensch.

Du glaubst aber auch jeden Scheiss.

[Dirk B. (dirkb2)]

Mark B. schrieb:
> Warum sollte es ein sinnvoller Ansatz sein, keine Schleife zu verwenden?

Damit man was fertiges benutzen kann.

Selber schreiben oder denken geht heute nicht mehr.
"Ist ja umständlich. In Programmiersprache XY geht das ganz einfach"

[Genialer Programmierer (Gast)]

Dirk B. schrieb:
> Selber schreiben oder denken geht heute nicht mehr.

Bei solchem Aufwand eine Schleife zu schreiben lohnt es sich
schon mal im Internet zu suchen ob es da nicht was besseres gibt.

[Dirk B. (dirkb2)]

Ohne (eigene) Schleife:

Neues Array anlegen und mit 0 initialisieren oder mit memset auf 0 
setzen.
oder ausreichend Speicher mit calloc besorgen.

Dann mit memcmp vergleichen.

[Dussel (Gast)]

Mark B. schrieb:
> Was wenn das Array z.B. 256 Elemente hat? 256 Zeilen Code hinschreiben
> oder wie? Das macht doch kein normaler Mensch.
Die Frage war 'wie'. Die Antwort war 'Geht nicht'. Das ist in C falsch 
und ich habe gezeigt, dass es geht. Ob es sinnvoll ist, war nicht die 
Frage. Vielleicht entwickelt der Fragesteller ja gerade seinen eigenen 
C-Compiler und hat Schleifen noch nicht implementiert. ;-)

[Daniel A. (daniel-a)]

Vielleicht sowas in die richtung?

struct int_array {
  size_t set_count;
  int* data;
};

int array_data[10]={0};
struct int_array array={0,array_data};

void int_array_setValue( struct int_array* a, size_t i, int x ){
  int y = a->data[i];
  if( x && !y ) a->set_count++;
  if( y && !x ) a->set_count--;
  a->data[i] = x;
}

bool int_array_isNoneSet( struct int_array* a ){
  return !a->set_count;
}

[Sebastian V. (sebi_s)]

Oder mit Rekursion:

bool allZero(const int* data, size_t count)
{
    if(count == 0)
        return true;
    else
        return data[0] == 0 && allZero(data+1, count-1);
}

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Man könnte das ganze auch rekursiv lösen, z.B. indem man das Problem für 
ein Array der Größe N auf das der Größe N-1 zurückführt oder z.B. einen 
Binärbaum aufbaut. Im ersten Fall skaliert der Speicherverbrauch auf dem 
Stack linear mit der Größe des Arrays und im zweiten logarithmisch.

Im konkreten Fall mag solch ein Vorgehen unglaublich ineffizient sein, 
aber bei manchen andere Fragestellungen durchaus sinnlos und effizient.

Nachtrag:
Mist, zu spät... ;-)

[tictactoe (Gast)]

if (std::all_of(begin(a), end(a), [](auto x) { return x == 0; }))
   ...

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

tictactoe schrieb:

 if (std::all_of(begin(a), end(a), [](auto x) { return x == 0; }))

Das ist kein C, sondern C++.

[Markus F. (mfro)]

int tst(int *arr, int size) __attribute__((optimize("-funroll-loops")));

int tst(int arr[], int size)
{
    int i;


    for (i = 0; i < size; i++)
        if (arr[i] != 0)
            return 1;
    return 0;
}

[Heinz (Gast)]

Ausdrucken, dem Lehrling in die Hand drücken und alle Nullen 
unterstreichen lassen. Geht super und ohne Schleife. Es sei denn der 
Lehrling hat eine an.

[A. S. (Gast)]

Markus F. schrieb:
> ((optimize("-funroll-loops")));

naja, das geht ja nur bei festen Werten. Für eine optimal Laufzeit mit 
z.B. 100 oder 1000 Elementen sollte man Duffs Device (entsprechend) 
verwenden ;-)

https://de.wikipedia.org/wiki/Duff%E2%80%99s_Device

[Mac (Gast)]

Dirk B. schrieb:
> Ohne (eigene) Schleife:
>
> Neues Array anlegen und mit 0 initialisieren oder mit memset auf 0
> setzen.
> oder ausreichend Speicher mit calloc besorgen.
>
> Dann mit memcmp vergleichen.

Zweites Array ist nicht nötig. Alle Elemente sind 0, wenn das erste 
Element 0 ist und jedes Element gleich dem Nachfolger ist:

(a[0]==0) && (memcmp(a,a+1,sizeof(*a)*(a_len-1))==0) // a_len: Anzahl der Elemente in a. Der Typ von *a muss bitvergleichbar sein.

;)

[Mark B. (markbrandis)]

Vielleicht war hier tatsächlich eine rekursive Lösung gesucht anstatt 
einer iterativen. Dann klingt das Ganze ziemlich nach Hausaufgaben 
machen.