Array in Bereiche aufteilen, struct vermeiden, aber wie

Hallo,

klingt für mich nach einem Fall von XY-Problem: http://xyproblem.info

da1l6

da1l6 schrieb:
> Hallo,
>
> klingt für mich nach einem Fall von XY-Problem: http://xyproblem.info
>
> da1l6


Was für ein freundliches Forum. Hier ist man wohl gleich als Genies zur 
Welt gekommen und alles gleich vom Himmel gefallen.
Danke trotzdem

Tim T. schrieb:
> Hans schrieb:
>> da1l6 schrieb:
>>> Hallo,
>>>
>>> klingt für mich nach einem Fall von XY-Problem: http://xyproblem.info
>>>
>>> da1l6
>>
>>
>> Was für ein freundliches Forum. Hier ist man wohl gleich als Genies zur
>> Welt gekommen und alles gleich vom Himmel gefallen.
>> Danke trotzdem
>
> Das nicht, aber eine ausreichende Fähigkeit zum strukturierten Denken
> war eigentlich doch immer vorhanden.
> Und bei deiner Aufgabenstellung hätte ich auch lieber das ursprüngliche
> Problem zurück...
> WARUM ZUR HÖLLE willst du das Array unterteilen? Gibt es dafür
> irgendeinen nachvollziehbaren Grund?

Ich habe in 2 verschiedenen Arrays Werte zweier Graphen gespeichert.
Die Kurven sehen zB so wie oben im Bild aus. Zb zwischen den Werten 10 
und 20 soll etwas passieren. Zwischen anderen etwas Anderes. Die genaue 
Einteilung ist mir überlassen.
Ich nutze ein drittes Array worin ich die Indizes festhalte, damit ich 
sie nicht jedes Mal berechnen muss. Zum Beispiel Bereich 1 Index 10 -15. 
Bereich 2 21-32 etc.
Im Array dann zB {0, 5, 10, 15, 20, 25...} kann ich dann auf die 
Grenzwerte zugreifen, anstatt jedes Mal den Index für den Grenzwert zu 
berechnen. Bereich 1 wäre so nun Index 0 bis 1, Bereich 2 Index 10 bis 
15.
Das funktioniert zwar, aber ich müsste dann wie folgt arbeiten, wenn ich 
die Werte zweier Arrays auswerten möchte:

if( ((wert1 >= graph1[iArray[0]]) && (wert1< graph1[iArray[1]])) && 
(wert2 >= graph2[iArray[0]]) && (wert2< graph2[iArray[1]])) )

Versteht ihr jetzt?
Auf diese Weise sehe ich nicht auf Anhieb, dass es Bereich 1 ist, nur 
daran, dass die Indizes 0 und 1 sind. Wie macht man es in der Praxis?

Hans schrieb:

>
> Ich habe in 2 verschiedenen Arrays Werte zweier Graphen gespeichert.
> Die Kurven sehen zB so wie oben im Bild aus. Zb zwischen den Werten 10
> und 20 soll etwas passieren. Zwischen anderen etwas Anderes. Die genaue
> Einteilung ist mir überlassen.
> Ich nutze ein drittes Array worin ich die Indizes festhalte, damit ich
> sie nicht jedes Mal berechnen muss.
> Im Array dann zB {0, 5, 10, 15, 20, 25...} kann ich dann auf die
> Grenzwerte zugreifen, anstatt jedes Mal den Index für den Grenzwert zu
> berechnen. Bereich 1 wäre so nun Index 0 bis 1, Bereich 2 Index 10 bis
> 15.
> Das funktioniert zwar, aber ich müsste dann wie folgt arbeiten, wenn ich
> die Werte zweier Arrays auswerten möchte:
>
> if( ((wert1 >= graph1[iArray[0]]) && (wert1< graph1[iArray[1]])) &&
> (wert2 >= graph2[iArray[0]]) && (wert2< graph2[iArray[1]])) )
>
> Versteht ihr jetzt?
> Auf diese Weise sehe ich nicht auf Anhieb, dass es Bereich 1 ist, nur
> daran, dass die Indizes 0 und 1 sind. Wie macht man es in der Praxis?

So sollte es besser verständlich sein

Tim T. schrieb:
> zwei Positionen beschreiben lässt, Anfang und Ende

Rate mal, was ein Pointer ist, bzw. wie man das Dingsbums nennt, das 
sich zwischen zwei Pointern erstreckt.

Hans schrieb:
> Da komme ich um ein struct nicht herum oder?

Ja, ein struct, dass zwei integer enthält, begin und end.

Und von diesem struct dann ein Array, so viele Bereiche Du willst, z.b. 
8

struct sBereichsPtr B[8];

if wert2>Array[B[2].begin] ...

A. S. schrieb:
> Hans schrieb:
>> Da komme ich um ein struct nicht herum oder?
>
> Ja, ein struct, dass zwei integer enthält, begin und end.
>
> Und von diesem struct dann ein Array, so viele Bereiche Du willst, z.b.
> 8
>
> struct sBereichsPtr B[8];
>
> if wert2>Array[B[2].begin] ...

Danke für den Tipp

Stefanus F. schrieb:
> Tim T. schrieb:
>> zwei Positionen beschreiben lässt, Anfang und Ende
>
> Rate mal, was ein Pointer ist, bzw. wie man das Dingsbums nennt, das
> sich zwischen zwei Pointern erstreckt.

Wie würde man es mit Pointern machen?
Was meinst du mit dem Dingsbums zwischen 2 Pointern?
Da ist irgend einer Wert bestimmter Grösse zB 1 oder 2 Byte.
Dingsbums wäre dann also 1 oder 2 Byte.

da1l6 schrieb:
> Hallo,
>
> klingt für mich nach einem Fall von XY-Problem: http://xyproblem.info
>
> da1l6

Max Kanat-Alexander:

> If somebody comes up to you and says something like, “How do I make this pony 
fly to the moon?”, the question you need to ask is, “What problem are you trying 
to solve?” You’ll find out that they really need to collect gray rocks. Why they 
thought they had to fly to the moon, and use a pony to do it, only they know. 
People do get confused like this.

Hans schrieb:
> Wie würde man es mit Pointern machen?
> Was meinst du mit dem Dingsbums zwischen 2 Pointern?

Mit zwei Pointern beschreibst du einen Bereich im Speicher (Anfang und 
Ende).

Ich weiß, dass manche Leute Pointer eklig finden, aber C Entwickler 
müssen damit klar kommen. Ich finde auch Wasser eklig und doch kann ich 
den Kontakt damit nicht ganz vermeiden.

Tim T. schrieb:
> Und bringt hier keinerlei Vorteile, ob er sich nun jeweils den Index der
> Anfangs und End Arrayelemente merkt oder die Speicheradresse der beiden
> Elemente, ist hierbei total egal.

Ja, kann man so sehen. Für mich wäre die Nutzung von Pointern einfacher. 
Aber ich bin ja nicht jeder.

Stefanus F. schrieb:
> Tim T. schrieb:
> Und bringt hier keinerlei Vorteile, ob er sich nun jeweils den Index der
> Anfangs und End Arrayelemente merkt oder die Speicheradresse der beiden
> Elemente, ist hierbei total egal.
>
> Ja, kann man so sehen. Für mich wäre die Nutzung von Pointern einfacher.
> Aber ich bin ja nicht jeder.

Könntest du mal win bsp geben?

Hans schrieb:
> Könntest du mal win bsp geben?

Keine Lust. Das sollte in jedem Lehrbuch zu C im Kapitel über Pointer 
oder Buffer stehen.

Ok, einen kleines Beispiel gebe ich Dir:

1

#include <stdio.h>

2

#include <string.h>

3

4

void ausgeben(char* von, char* bis)

5

{

6

    while (von<bis)

7

    {

8

        putchar(*von);

9

        von++;

10

    }

11

}

12

13

int main()

14

{

15

    char text[]="Das ist ein Array, gefüllt mit Zeichen";

16

17

    char gesucht[]="ein Array";

18

    char* start=strstr(text,gesucht); 

19

    char* ende=start+strlen(gesucht);

20

21

    ausgeben(start,ende);

22

}

Das Schöne an der Funktion ausgeben() ist, dass die keine Ahnung haben 
muss, was sie ausgeben soll. Es muss nicht unbedingt ein Text in diesem 
einen Array sein. Der Text könnte auch ganz woanders stehen.

Zahlreiche Funktionen aus der Standard C Binbliothek machen es etwas 
anders: Sie erwarten einen Zeiger auf den Anfang und dann einen Integer, 
der die Länge angibt.

Hans schrieb:
> if( ((wert1 >= graph1[iArray[0]]) && (wert1< graph1[iArray[1]])) &&
> (wert2 >= graph2[iArray[0]]) && (wert2< graph2[iArray[1]])) )

Laut deiner Skizze liefern die Funktionen steigende / fallende Werte. Du 
prüfst aber so als würden beide Funkionen steigende Werte liefern.

Tim T. schrieb:
> &array[4] ist z.B. die Speicheradresse des fünften Wertes,
> &array[9] die des zehnten. Wenn du dir jetzt den Bereich merken willst,
> kannst du also entweder die Indexe 4 und 9 speichern oder die jeweiligen
> Speicheradressen (&array[4] und &array[9]).
> Aber zugeben ich bin auch nicht wirklich motiviert dir das jetzt alles
> vorzukauen.

schon verstanden, danke

Wenn die Werte in einem Array liegen und aufsteigend sortiert sind, dann 
wäre vielleich so etwas eine Möglichkeit? (einfach Intervallgrenzen in 
einem zweidim. Array ablegen)

1

    //Anzahl der Unterteilungen (Bereiche)

2

    #define ANZ_BER 5

3

4

    int arr[]={

5

                1,3, //Bereich 1

6

                4,6,7,8,11, //Bereich 2

7

                13,15,16,18,21,23,26,//Bereich 3

8

                29,32,37,42, //Bereich 4

9

                47,49 //Bereich 5

10

            };

11

12

    int indizes[ANZ_BER][2]={

13

                                {0,1},  // linke u. rechte Indizes fuer Bereich 1

14

                                {2,6},  // -||- fuer Bereich 2 

15

                                {7,13}, //usw.

16

                                {14,17},

17

                                {18,19}

18

                            };

19

20

    int aktueller_wert=39;

21

22

    for(int i=0; i<ANZ_BER; i++){

23

24

        if(aktueller_wert>=arr[indizes[i][0]] && aktueller_wert<=arr[indizes[i][1]]){

25

            printf("%d liegt im Bereich %d\n", aktueller_wert, i+1);

26

        }   

27

28

    }

zitter_ned_aso schrieb:
> Hans schrieb:
>> if( ((wert1 >= graph1[iArray[0]]) && (wert1< graph1[iArray[1]])) &&
>> (wert2 >= graph2[iArray[0]]) && (wert2< graph2[iArray[1]])) )
>
> Laut deiner Skizze liefern die Funktionen steigende / fallende Werte. Du
> prüfst aber so als würden beide Funkionen steigende Werte liefern.

wenn "graph1" rot ist (siehe Skizze), dann solltest du das anders 
testen.

1

if( ((wert1 <= graph1[iArray[0]]) && (wert1 > graph1[iArray[1]])) usw...

Das habe ich gemeint.

Die Funktionswerte von "graph1" (rot) werden ja kleiner.

zitter_ned_aso schrieb:
> Wenn die Werte in einem Array liegen und aufsteigend sortiert
> sind, dann wäre vielleich so etwas eine Möglichkeit? (einfach
> Intervallgrenzen in einem zweidim. Array ablegen)    //Anzahl der
> Unterteilungen (Bereiche)
>     #define ANZ_BER 5
>
>     int arr[]={
>                 1,3, //Bereich 1
>                 4,6,7,8,11, //Bereich 2
>                 13,15,16,18,21,23,26,//Bereich 3
>                 29,32,37,42, //Bereich 4
>                 47,49 //Bereich 5
>             };
>
>     int indizes[ANZ_BER][2]={
>                                 {0,1},  // linke u. rechte Indizes fuer
> Bereich 1
>                                 {2,6},  // -||- fuer Bereich 2
>                                 {7,13}, //usw.
>                                 {14,17},
>                                 {18,19}
>                             };
>
>     int aktueller_wert=39;
>
>     for(int i=0; i<ANZ_BER; i++){
>
>         if(aktueller_wert>=arr[indizes[i][0]] &&
> aktueller_wert<=arr[indizes[i][1]]){
>             printf("%d liegt im Bereich %d\n", aktueller_wert, i+1);
>         }
>
>     }

Die Werte der Graphen können sich bei mir immer leicht ändern.
Das iwo so das Problem. So müsste ich viel zu viel anpasse. Sortiert 
sind sie auch nicht. kann sein dass 2 oder 3 werte hintereinander die 
gleichen sind aber der andere graph die gleichrn indizes betreffend sich 
ändern können.

daher möchte ich die werte in den arrays möglichst nicht anfassen müssen

zitter_ned_aso schrieb:
> zitter_ned_aso schrieb:
> Hans schrieb:
> if( ((wert1 >= graph1[iArray[0]]) && (wert1< graph1[iArray[1]])) &&
> (wert2 >= graph2[iArray[0]]) && (wert2< graph2[iArray[1]])) )
>
> Laut deiner Skizze liefern die Funktionen steigende / fallende Werte. Du
> prüfst aber so als würden beide Funkionen steigende Werte liefern.
>
> wenn "graph1" rot ist (siehe Skizze), dann solltest du das anders
> testen.if( ((wert1 <= graph1[iArray[0]]) && (wert1 > graph1[iArray[1]]))
> usw...
>
> Das habe ich gemeint.
> Die Funktionswerte von "graph1" (rot) werden ja kleiner.

ach das meinst du
darauf habe ich beim erklären gar nicht geachtet, weil ich noch gar 
nicht so weit bin