Forum: PC-Programmierung geschicktes Suchen von Elementen im Array


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von hans (Gast)


Bewertung
-4 lesenswert
nicht lesenswert
Ich stehe im Moment vor der kniffligen Frage, wie ich es zustande 
bringen kann einen richtigen Wert aus 3 Arrays herauszufinden.

Das Problem ist folgendes:

Es gibt 3 Arrays mit jeweils der Länge 10
Tatsache ist, dass einzelne Arrays unterschiedlich befüllt sein können, 
also zB gefüllt mit einem Wert, zwei oder sogar 10.

Ein konkretes Beispiel.

Die Arrays haben zB folgende Werte:
array1: 18, 20, 21, 60, 115, 140, 141, 150, 152
array2: 23, 79, 0,  0,  0,   0,   0,   0,   0
array3: 28, 29, 30, 85, 0,   0,   0,   0,   0

Die obigen Zahlen sind mit einem Offset von +-7 ermittelt worden.
Die wahre/richtige Zahl wäre in diesem Fall 23 (array2). Array2 könnte 
aber auch folgende Zahlen enthalten 23, 24, 79. Tatsache ist aber, dass 
in jedem array eine der wahren Zahl ähnlicher Wert mit der genannten 
Abweichung +-7 vorhanden ist.

Jetzt ist es meine Aufgabe eine geschickte Variante zu finden, um die 
richtige Zahl zu finden.

Dazu habe ich mir überlegt, auch eine Offset zu nutzen, ebenfalls +-7.
Dann überprüfe ich zuerst, welches Array über die geringste Anzahl an 
Elementen verfügt. Hier wäre es das array2.  Dann nehme ich das erste 
Element von array2 und durchsuche zB zuerst array1 und dann array3 mit 
dem genannten Offset. Die Treffer speichere ich in einem neuen Array. 
Damit hätte ich nun 2 Arrays:

array21: 18, 20, 21
array23: 28, 29, 30

Die Summe (18+20+21)der Zahlen aus array21 durch die Länge gibt 19.
Die Summe (28+29+30)der Zahlen aus array23 durch die Länge gibt 29.

Der Summe aus dieser Zahlen wiederum erstes Element aus array2 ->23 und 
der obigen Resultate +19+29 = 71
Der Mittelwert 71/3 = 23.66, also 23
Wenn es 24 gewesen wäre, wäre es auch kein Problem.

Nun könnte dies noch die falsche Zahl sein, was insofern bedeutet, dass 
ich auch die anderen Elemente im array2 überprüfen muss. Oder die 
richtige Zahl könnte erst später kommen und ich müsste solange immer die 
Daten speichern.  2 oder eindimensionale Arrays, was ja irgendwie Unfug 
wäre, laut meinem Bauchgefühl.

Jetzt kommt hier meine Frage:
Findet ihr das wie ich es vorhabe zu umständlich und geht es einfacher?
Muss ich überhaupt die nächsten Zahlen im array2 noch überprüfen?
Es gibt ja nämlich keine andere Kombination.
Deshalb müsste es ja eigentlich reichen zu überprüfen, ob ein Wert in 
allen 3 arrays vorkommt und nur dann die Berechnung durchführen.

: Gesperrt durch Moderator
von g457 (Gast)


Bewertung
7 lesenswert
nicht lesenswert
> Findet ihr das wie ich es vorhabe zu umständlich und geht es einfacher?

Ja, würfel einfach. Oder überdenke nochmals, was 'wahre Zahl' heissen 
soll, überdenke fürderhin wie Du es so beschreiben kannst, dass ein 
Normalsterblicher das versteht, und dann poste das Ergebnis hier.

von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
4 lesenswert
nicht lesenswert
Dem kann ich mich nur anschließen.

von hans (Gast)


Bewertung
-4 lesenswert
nicht lesenswert
Ich habe extra ein Beispiel abgegeben. Es gibt 3 Arrays in denen ich 
einen bestimmten Wert +- Offset ermitteln möchte und erklärt wie ich es 
machen würde. Was ist nun daran so schwer zu verstehen? Wie die Arrays 
aussehen können habe ich doch auch beschrieben.
Was noch?

von zitter_ned_aso (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Die wahre Zahl muss ihr herausfinden ;-) In Frage kommen alle Zahlen aus 
dem  kürzesten Array (23, 79). Mit der ersten Zahl (23) fängt man an.

Ob 23 die richtige Zahl ist, muss berechnet werden:

array21: 18, 20, 21
array23: 28, 29, 30


weil |18-23|<7, |20-23|<7, |21-23|<7, usw..

Ist die Ungleichung erfüllt (Offset < 7), so muss man die Werte 
übernehmen und mit den denen weiter rechnen.

Die Summe (18+20+21)der Zahlen aus array21 durch die Länge gibt 19.
Die Summe (28+29+30)der Zahlen aus array23 durch die Länge gibt 29.

also (18+20+21)/3=19,...=19 (eigentlich 20)
 (28+29+30)/3=29

Dann diese Zahlen (19 und 29) mit der "wahren Zahl"(Annahme: 23) 
addieren:
19+29+23=71
71/3=23,....=23

Also die Illuminaten ähm die Annahme ist erfüllt: 23 ist die wahre Zahl

von A. S. (rava)


Bewertung
0 lesenswert
nicht lesenswert
du willst outlier entfernen und dann mitteln.

Bist du dir sicher, dass es nicht zwei Lösungen gibt? Wenn array1 z.B. 
noch eine 80 enthielte, dann wäre dieses cluster auch eine Lösung.

Willst du eine gute Heuristik oder lieber eine exakte Lösung, 
möglicherweise mit mehr Rechenaufwand?


Wenn die Zahlen immer so klein sind (z.B. max 256), dann würde ich fast 
brute force jeder der 256 Ziel-mittelwerte durchprobieren:
1
int solution = 0;
2
int solution_rsme = MAX_INT;
3
for(int sol=0; sol < 256; ++sol)
4
{
5
    * falls keine Zahl sol-7 < x < sol+7 in array1 ist, continue
6
    * falls keine Zahl sol-7 < x < sol+7 in array2 ist, continue
7
    * falls keine Zahl sol-7 < x < sol+7 in array3 ist, continue
8
9
    * RMSE zu den gültigen Zahlen in array1-3 ermitteln
10
      (hab zugegebenermaßen deine genaue Rechenvorschrift nicht kapiert)
11
    * falls RSME < solution_rsme, dann solution = sol; solution_rsme = RSME;
12
}


Mit dem code bekommst du auch gute Mittelwerte, falls sie nicht in den 
arrays sind.
Falls das nicht deine Anforderung ist, dann geh durch alle arraywerte 
durch


es geht aber sicher noch geschickter, wenn du mehr über das Problem 
verrätst

: Bearbeitet durch User
von Aha!? (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Woher weiß man dass die 'wahre' Zahl im Array mit den wenigsten Zahlen 
ungleich Null enthalten ist ?

Warum ist die wahre Zahl immer die erste im Array ?

Was kennzeichnet eine 'wahre' Zahl ?
Um mal beim Beispiel vom TO zu bleiben:
Warum ist die 'wahre' Zahl nicht 21 aus array1 ?

array1: 18, 20, 21, 60, 115, 140, 141, 150, 152
array2: 23, 79, 0,  0,  0,   0,   0,   0,   0
array3: 28, 29, 30, 85, 0,   0,   0,   0,   0

21-18<7 & 21-20<7 & 21-23<7

Warum müssen es 3 Arrays sein?

Sag doch mal ob das ein konkretes Problem beschreibt oder nur eine 
Aufgabe aus dem Informatikunterricht ist.

von Tim T. (tim_taylor) Benutzerseite


Bewertung
4 lesenswert
nicht lesenswert
Es ist die 42, dagegen stinkt die 23 aber sowas von ab!

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Aha!? schrieb:
> Woher weiß man dass die 'wahre' Zahl im Array mit den wenigsten Zahlen
> ungleich Null enthalten ist ?

Gute Frage, anscheinend muss man das bei jedem Array prüfen und bei 
jedem Array wird man fündig.

hans schrieb:
> Tatsache ist aber, dass
> in jedem array eine der wahren Zahl ähnlicher Wert mit der genannten
> Abweichung +-7 vorhanden ist.

von Fpgakuechle K. (fpgakuechle) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Ein Speicher-array der Länge x ist immer mit x Werten gefüllt?! Oder wie 
ist ein 'gefüllter' Wert von einem 'Ungefüllten' zu unterscheiden? Oder 
ist diese Frage nur mit dem richtigen Dopingmittel intus beantwortbar?!

Beitrag #5782430 wurde von einem Moderator gelöscht.
von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Er braucht nur einen Wert.

hans schrieb:
> einen richtigen Wert aus 3 Arrays herauszufinden

In jedem Array ist dieser Wert (mit unterschiedlichen Nachkommastellen) 
vorhanden.

hans schrieb:
> Tatsache ist aber, dass
> in jedem array eine der wahren Zahl ähnlicher Wert mit der genannten
> Abweichung +-7 vorhanden ist.


Also nimmt er den kürzensten Array und arbeitet damit.

hans schrieb:
> Dann überprüfe ich zuerst, welches Array über die geringste Anzahl an
> Elementen verfügt

So habe ich das verstanden. Und diesen Schritt teile ich ;-)

von hans (Gast)


Bewertung
-3 lesenswert
nicht lesenswert
Also ich beschreibe das Problem nochmals:

Das Problem ist folgendes:

Es gibt 3 Arrays mit jeweils der Länge 10

Ein konkretes Beispiel.

Die Arrays haben zB folgende Werte:
1. Fall
array1: 18, 20, 21, 60, 115, 140, 141, 150, 152, 160
array2: 23, 79, 0,  0,  0,   0,   0,   0,   0,   0
array3: 28, 29, 30, 85, 0,   0,   0,   0,   0,   0

Könnte aber auch so aussehen:
2. Fall
array1: 28, 29, 30, 0,   0,   0,   0,   0,   0,   0
array2: 23, 24, 79, 160, 0,   0,   0,   0,   0,   0
array3: 18, 20, 21, 85,, 115, 140, 141, 150, 152, 170

Es wurden mehrere ähnliche Zahlen abgelegt. Im 1. Fall wären das
im array1 18, 20, 21
array2 23
array3 28, 29, 30

Es handelt sich also um Zahlen die mit einem Offset von +-7 zur 
wahren/richtigen Zahl ermittelt worden sind. In diesem Beispiel ist die 
richtige Zahl die 23.

Diese Zahl soll nun aus den obigen Ergebnissen automatisch berechnet 
werden.

Mein Vorgang den richtigen Wert zu ermitteln:

Dazu habe ich mir überlegt von array1,2 und 3 jenes zu verwenden, das 
über die geringste Anzahl an Elementen verfügt. Hier wäre Fall 1 
beteffend das  array2 mit 2 Werten.

Ich nehme also das erste Element (23) und suche nach ähnlichen Werten in 
den anderen beiden. Bei der Suche nach ähnlichen Elementen verwende ich 
ebenfalls ein Offset von +-7.

Die Ergebnisse speichere ich dann in neuen Arrays.
Die beiden Arrays dann enthielten folgende Ergebnisse, weil alle Werte 
innerhalb von 23-Offset und 23+Offset liegen.

array21: 18, 20, 21
array23: 28, 29, 30

Dann bilde ich die Summe.
Summe array21 = 59
Summe array23 = 87

und teile die Summen durch die Anzahl der Elemente, beide also durch 3, 
weil beide 3 Elemente enthalten.
59/3 = 19.66 = 19 in integer
87/3 = 29

Ich bilde also den Mittelwert aus allen Treffern meiner Suche mit dem 
Offset.

Im letzten Schritt wird nun wieder aus den Mittelwerten 19 und 29 und 
dem ersten Element von array2 23 die Summe gebildet.
19+29+23 = 71
Der Mittelwert wiederum gibt 23.6, also 23 in integer.

Wenn nun die richtige Zahl später im Array vorkommen würde, angenommen 
index 8, dann müsste ich die Werte stets solange speichern, bis die 
Berechnung durchgeführt worden ist.

Deshalb meine Fragen oben im ersten Post.

von Sven B. (scummos)


Bewertung
1 lesenswert
nicht lesenswert
Das klingt irgendwie nach Hausaufgabe, weil es sehr schwer ist 
irgendeinen Sinn darin zu sehen was du zu erreichen versuchst. In dem 
Fall wäre es vielleicht am einfachsten, die originale Aufgabe zu posten 
...

von Tim T. (tim_taylor) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Was machst du wenn der 2. Wert im kürzesten Array innerhalb +-7 zum 
ersten Wert aus diesem Array liegt?

von leo (Gast)


Bewertung
1 lesenswert
nicht lesenswert
hans schrieb:
> ähnlicher Wert mit der genannten
> Abweichung +-7 vorhanden ist.

Dividier deine Zahlen durch 14 und denk noch mal nach, wie du das 
"Problem" formulieren willst.

leo

von Gerd E. (robberknight)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Jetzt ist es meine Aufgabe eine geschickte Variante zu finden, um die
> richtige Zahl zu finden.

Was ist für Dich geschickt?

Möglichst wenig Rechenzeit?
Möglichst wenig Arbeitsspeicherverbrauch?
Möglichst geringe Codegröße?

Wie skaliert nachher Dein Problem in der Praxis?
Viele Arrays? Oder viele Werte in nur 3 Arrays?

Was für Wertebereiche haben die Zahlen in den Arrays?

: Bearbeitet durch User
von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Die Ergebnisse speichere ich dann in neuen Arrays.
> Die beiden Arrays dann enthielten folgende Ergebnisse, weil alle Werte
> innerhalb von 23-Offset und 23+Offset liegen.
>
> array21: 18, 20, 21
> array23: 28, 29, 30
>
> Dann bilde ich die Summe.
> Summe array21 = 59
> Summe array23 = 87
>
> und teile die Summen durch die Anzahl der Elemente, beide also durch 3,
> weil beide 3 Elemente enthalten.
> 59/3 = 19.66 = 19 in integer
> 87/3 = 29



Diese Mittelwerte (19, 29) kann man auch so berechnen (direkt mit den 
einzelnen Offsets, man berechnet die ja sowieso beim Vergleichen):
1
int mittelwert(int arr[], int arr_len, int magic_number, int offset){
2
    int sum_offset=0;
3
    int counter=0; 
4
    int temp=0;
5
6
    for(int i=0; i<arr_len; i++){
7
        temp=arr[i]-23;
8
        if(abs(temp)>offset){    
9
            break;
10
        }
11
        else{
12
            counter++;
13
            sum_offset+=temp;
14
        }   
15
    }   
16
      
17
    return sum_offset/3.0+magic_number;
18
}

Dann kann man die Funktion so testen:
1
   int arr1[]={18, 20, 21, 60, 115, 140, 141, 150, 152};
2
    int arr2[]={ 23, 79, 0,  0,  0,   0,   0,   0,   0};
3
    int arr3[]={ 28, 29, 30, 85, 0,   0,   0,   0,   0};
4
5
    int magic_number=arr2[0];
6
    int offset=7;
7
    int arr_len=sizeof(arr1)/sizeof(arr1[0]);
8
9
    int m_wert1=mittelwert(arr1, arr_len, magic_number, offset);
10
    int m_wert2=mittelwert(arr3, arr_len, magic_number, offset);
11
12
    printf("Mittelwert: %d\n", m_wert1);
13
    printf("Mittelwert: %d\n", m_wert2);
14
15
    double new_magic_number=(m_wert1+m_wert2)/2.0;
16
    printf("berechnete magic number: %.2f\n", new_magic_number);
17
    printf("urspruengliche magic number: %d\n", magic_number);

Man muss noch durch das (kleinste) Array iterieren.

von hans (Gast)


Bewertung
-3 lesenswert
nicht lesenswert
Keine Angst es ist keine Hausaufgabe.
Ich bin nur dabei mich durch eigene Übungen auf dem Laufenden zu halten 
und programmiertechnisch nicht alles zu vergessen.

zitter_ned_aso schrieb:
> Die wahre Zahl muss ihr herausfinden ;-)

Ich muss zugeben, dass ich es schnell formuliert habe, aber du hast 
alles bis auf die offenen Fragen verstanden.

Also es ist so:
Es gibt eine Kombination aus 3 Zahlen, wobei jede einzelne Zahl in einem 
separaten Array gehalten wird.
1
Werte1: 5,6,6,7, 7,10,36,50,53,55,57,61,64,68,72,77,80,82,83,86,86,85,83,84, 84, 83, 83, 81, 80, 80, 76, 74, 73, 71, 69, 67, 66
2
Werte2: 5,8,8,9, 9,11,21,28,32,33,36,38,41,45,50,59,64,68,73,81,87,93,99,103,107,111,115,119,124,133,141,151,160,166,171,173,175
3
Werte3: 6,8,9,10,9,11,18,23,25,25,27,27,27,29,30,33,35,35,36,37,38,38,39,40, 41, 42, 42, 42, 42, 44, 44, 47, 48, 49, 50, 49, 50

Die Kombinationen sind so im Array abgelegt, dass ich nach Indizes 
suchen kann.
Eine Kombination wäre zB wenn man Index 14 betrachtet
72, 50, 30 (Werte1, Werte2, Werte3)

Wenn ich exakt diese Werte messen würde erhielte ich mit einem Offset 
von +-7 und für den Wert 72, würde mein Array1 wie folgt befüllt werden: 
(es sind Indizes aus Werte1)

array1: 13, 14, 15 und andere weiter rechts
für 50:
array2: 13, 14, 15
für 30:
array3: 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
(Hier fällt mir übrgens gerade auf, dass meine Arrays zu klein wären)


Wenn ich zB folgende Werte messe:
74, 52, 33

bekomme ich zwar andere Werte aber ich bin nahe dran und kann die 
Position feststellen.

Weil die Werte eben einen Zusammenhang zueinander haben, darf aus diesem 
Grund die Arrays auch nicht sortieren oder irgendwelche Werte 
weglöschen.

Aha!? schrieb:
> Woher weiß man dass die 'wahre' Zahl im Array mit den wenigsten
> Zahlen
> ungleich Null enthalten ist ?
>
> Warum ist die wahre Zahl immer die erste im Array ?

Das ist nur Zufall, je nach dem was ich gerade messe und wie weit ich 
von der eigentlichen Kombination weg bin.


> Um mal beim Beispiel vom TO zu bleiben:
> Warum ist die 'wahre' Zahl nicht 21 aus array1 ?

Weil 3 ähnliche Zahlen vorhanden sind, welche es ist muss ich eben 
berechnen. Im array 2 kann ja auch 24 und 25 stehen.
>
> array1: 18, 20, 21, 60, 115, 140, 141, 150, 152
> array2: 23, 79, 0,  0,  0,   0,   0,   0,   0
> array3: 28, 29, 30, 85, 0,   0,   0,   0,   0
>
> 21-18<7 & 21-20<7 & 21-23<7
>
> Warum müssen es 3 Arrays sein?

Muss nicht, wenn es einfacher geht.
>

Fpga K. schrieb:
> Ein Speicher-array der Länge x ist immer mit x Werten gefüllt?!
> Oder wie
> ist ein 'gefüllter' Wert von einem 'Ungefüllten' zu unterscheiden? Oder
> ist diese Frage nur mit dem richtigen Dopingmittel intus beantwortbar?!

Mit meinem neuen Beispiel oben hängt das ab, wie oft in der Kombination 
die Zahlen innerhalb der Grenzen +-7 liegen.
Wie du oben siehst, habe ich mich sogar damit vertan, die Arraylänge auf 
maximal 10 festzulegen.

Tim T. schrieb im Beitrag #5782430:
> Der TO ist einfach ein sprachlicher Krüppel und nicht in der Lage
> einfach, kurz und eindeutig zu erklären welche Eigenschaft die wahre
> Zahl von den anderen Zahlen unterscheidet. Traurig, iss aber so...

Es ist nicht ganz leicht, aber ich hoffe nicht Tim. ;)

Tim T. schrieb:
> Was machst du wenn der 2. Wert im kürzesten Array innerhalb +-7
> zum
> ersten Wert aus diesem Array liegt?

Das ist eben auch meine Frage, im array 2 könnten die Werte ja zB auch 
24,25 und 26 sein.

Die Hauptsache ist, ich komme in die Nähe des wahren Wertes (Index).

Gerd E. schrieb:
> hans schrieb:
>> Jetzt ist es meine Aufgabe eine geschickte Variante zu finden, um die
>> richtige Zahl zu finden.
>
> Was ist für Dich geschickt?
>
> Möglichst wenig Rechenzeit?
> Möglichst wenig Arbeitsspeicherverbrauch?
> Möglichst geringe Codegröße?

Ich hätte jetzt gesagt, möglichst wenig Programmieraufwand und 
Verwendung von wenig arrays und Variablen, damit man den Überblick 
behält.
Es sollte natürlich auch nicht zu viel Rechenzeit benötigen.
>
>
> Was für Wertebereiche haben die Zahlen in den Arrays?

0 bis max. 400, daher uint16

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> return sum_offset/3.0+magic_number;

kleine Korrektur:
1
    return (double)sum_offset/counter+magic_number;

Ich hatte ja extra eine counter-Variable angelegt ;-)

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> kleine Korrektur:

und noch eine (wenn man bestimmte Parameter übergibt, so sollte man sie 
auch nutzen):

1
int mittelwert(int arr[], int arr_len, int magic_number, int offset){
2
    int sum_offset=0;
3
    int counter=0;
4
    int temp=0;
5
6
    for(int i=0; i<arr_len; i++){
7
        temp=arr[i]-magic_number;
8
        if(abs(temp)>offset){
9
            break;
10
        }
11
        else{
12
            counter++;
13
            sum_offset+=temp;
14
        }
15
    }
16
17
    return (double)sum_offset/counter+magic_number;
18
}

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> zitter_ned_aso schrieb:
>> kleine Korrektur:
>
> und noch eine (wenn man bestimmte Parameter übergibt, so sollte man sie
> auch nutzen):
>
> int mittelwert(int arr[], int arr_len, int magic_number, int offset){
>     int sum_offset=0;
>
>     return (double)sum_offset/counter+magic_number;
> }

entspricht in meinem beispiel magic_number hier dem ersten Element von 
array 2, also 23?

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> int magic_number=arr2[0];

ja

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> zitter_ned_aso schrieb:
>> int magic_number=arr2[0];
>
> ja

dann hört deine for loop nach 3 Elementen auf ausgehend von array1 zB.
Der Wert sum_offset beträgt dann 10, zurückgegeben wird dann aber
10/3 + 23
Das ist nicht der Mitteilwert
Oder meinst du magic_number - sumoffset/3

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
>
> Dann kann man die Funktion so testen:
>    int arr1[]={18, 20, 21, 60, 115, 140, 141, 150, 152};
>     int arr2[]={ 23, 79, 0,  0,  0,   0,   0,   0,   0};
>     int arr3[]={ 28, 29, 30, 85, 0,   0,   0,   0,   0};
>
>     int magic_number=arr2[0];
>     int offset=7;
>     int arr_len=sizeof(arr1)/sizeof(arr1[0]);
>
>     int m_wert1=mittelwert(arr1, arr_len, magic_number, offset);
>     int m_wert2=mittelwert(arr3, arr_len, magic_number, offset);
>
>     printf("Mittelwert: %d\n", m_wert1);
>     printf("Mittelwert: %d\n", m_wert2);
>
>     double new_magic_number=(m_wert1+m_wert2)/2.0;
>     printf("berechnete magic number: %.2f\n", new_magic_number);
>     printf("urspruengliche magic number: %d\n", magic_number);
>
> Man muss noch durch das (kleinste) Array iterieren.

Danke schon mal dafür.

Die Frage aber, wie man es machen würde, wenn die wahre Zahl erst viel 
später kommt, zB index 8

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Der Mittelwert von Arrayelementen mit:
1
|array_alement-23| <= 7


Also

(18+20+21)/3=19.67 (dieser Mittelwert wird berechnet, aber ohne 
Nachkommastellen)

zitter_ned_aso schrieb:
>> array21: 18, 20, 21


18-23=-5
20-23=-3
21-23=-2

Das sind einzelne Offsets. Die addiere ich, teile die Summe durch deren 
Anzahl:
1
(-4+-3+-2)/3=-3.3333333

Und addiere dieses Ergebnis zu der Zahl 23:
1
23 + (-3.333)=19.67

weil
1
(18+20+21)/3 = ((23-5)+(23-3) + (23-3))/3= (23+23+23)/3 + (-5 + -3 + -2)/3 = 23 + (-3.333)=19.67
Ich rechne gleich mit den einzelnen Offsets. Das meinte ich.


Das ist mein Teilvorschlag. Ich dachte wenn ich schon diese Offsets 
berechne, dann kann ich sie auch nutzen.

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Die Frage aber, wie man es machen würde, wenn die wahre Zahl erst viel
> später kommt, zB index 8

Wenn man das zweite Array auf diese Zahlen prüfen will, dann muss man 
halt durch das gesamte Array iterieren, die Zahl berechnen und dann 
vergleichen:
1
    int magic_number=0;
2
    int temp=0; 
3
    for(int i=0; i<arr_len; i++){
4
        
5
        //Annahme
6
        magic_number=arr2[i];
7
8
        //berechnete magic number 
9
        temp=(mittelwert(arr1, arr_len, magic_number, offset)+
10
               mittelwert(arr3, arr_len, magic_number, offset)+
11
                magic_number) / 3;
12
        
13
        if(temp==magic_number)
14
            break;
15
    }
16
    printf("magic number: %d\n", magic_number);

Aber die if-Bedingung ist nicht korrekt. Da muss man sich was überlegen. 
Weil gewisse Schwankungen ja erlaubt sind. Z.B. die Zahl 24 (für 23) 
wird auch akzeptiert...

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:

>
> Und addiere dieses Ergebnis zu der Zahl 23:
> 23 + (-3.333)=19.67
>
> weil(18+20+21)/3 = ((23-5)+(23-3) + (23-3))/3= (23+23+23)/3 + (-5 + -3 +
> -2)/3 = 23 + (-3.333)=19.67
> Ich rechne gleich mit den einzelnen Offsets. Das meinte ich.
>
> Das ist mein Teilvorschlag. Ich dachte wenn ich schon diese Offsets
> berechne, dann kann ich sie auch nutzen.

Richtig, du hast Recht. Danke für deinen Teilvorschlag.
Irgendwie hat mich das abs() nicht mehr losgelassen und habe deshalb nur 
noch positive Zahlen gesehen.

Ich meine, dass das so ein guter Ansatz ist durch die Arrays zu 
iterieren und alles bleibt auch noch überschaubar.
Ich versuche das mal so umzusetzen.

Bezüglich dem Problem, dass die richtige Zahl auch später kommen kann 
und man die Berechnungen nicht immer durchführen muss, hatte ich mir 
überlegt, zu allererst zu überprüfen, ob alle Arrays Werte enthalten, 
die  innerhalb der Grenzen (Offsets) liegen.
Also wieder das kleinste array hernehmen und nachschauen, ob Werte in 
anderen Arrays enthalten sind, die dem jeweiligen Wert +-Offset 
entsprechen.
Wenn beiden anderen Arrays passende Werte enthalten sind, dann wird 
deine vorgeschlagene Berechnung durchgeführt.
Das müsste so denke ich funktionieren.

von foobar (Gast)


Bewertung
5 lesenswert
nicht lesenswert
.oO(Je mehr er schreibt, um so wirrer wird es ...)

Beschreib doch einfach mal deine ursprüngliche Aufgabe und nicht deine 
verquerten Lösungsversuche.

von hans (Gast)


Bewertung
-3 lesenswert
nicht lesenswert
foobar schrieb:
> .oO(Je mehr er schreibt, um so wirrer wird es ...)
>
> Beschreib doch einfach mal deine ursprüngliche Aufgabe und nicht deine
> verquerten Lösungsversuche.

Scheint aber Leute zu geben, die es doch verstehen.
Ausserdem habe ich es weiter oben schon gemacht.

Jetzt waere es wohl nützlich wenn die Beitraege Nummern hätten.
So kann ich nur sagen suche nach Beitraegen mit blau dargestellten 
Zahlen.

von x^y (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Bitte versuche doch einfach das Problem zu beschreiben, dass du 
ursprünglich mal lösen wolltest, ohne irgendeine konkrete halbgare 
Lösungsidee. Diese funktioniert offensichtlich nicht, sonst wärst du 
ja nicht hier.

Ich drehe den Spieß mal um:

a)
Ich habe ein Array wie folgt:

[12, 4, 5, 9, 44, 0, 7]
Ich möchte daraus jetzt die Elemente an den Indizes 2 und 6. Es könnten 
aber auch ganz andere Zahlen sein, dann wären die Indizes anders. Ich 
weiß aber nicht wie ich das machen soll. Bitte helft mir doch!


b)
Ich möchte aus einer Menge an Zahlen alle Primzahlen extrahieren.

von Lass es besser sein (Gast)


Bewertung
0 lesenswert
nicht lesenswert
x^y schrieb:
> Bitte versuche doch einfach
> [12, 4, 5, 9, 44, 0, 7]
> Ich möchte daraus jetzt die Elemente an den Indizes 2 und 6. Es könnten
> aber auch ganz andere Zahlen sein, dann wären die Indizes anders. Ich
> weiß aber nicht wie ich das machen soll. Bitte helft mir doch!
>

Es gibt hier eine Menge fragestellende Leute, die nicht gerade den 
Eindruck machen, als hätten sie einen hohen Intelligenzquotienten.
Du bist nicht Teil dieser Gattung, aber auch nur aus der Sicht, dass du 
kein Fragestellender bist.

von Lothar M. (lkmiller) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Scheint aber Leute zu geben, die es doch verstehen
Ich bezweifle das.

>. Ausserdem habe ich es weiter oben schon gemacht.
Was eigentlich interessant ist: was sind das für Werte? Kommen die aus 
dem echten Leben von Sensoren? Oder werden die gewürfelt? Warum stehen 
die drei gemessenen Werte in Relation zueinander? Wenn es Sensorwerte 
oder Messwerte sind: warum ist davon nur 1 "richtig und wahr"? Wurden 
die anderen Messungen irgendwie gestört?

Und was stellt "Die Wahre Zahl" eigentlich dar? Welche Information trägt 
sie selbst oder ihr Index im Array? Gibt's da keinem sinnvollen Namen 
dafür?

Kurz: beschreib doch einfach mal das eigentliche Problem.


> Jetzt waere es wohl nützlich wenn die Beitraege Nummern hätten.
Es gibt eine Zitatfunktion, und du kannst auch einfach den Link auf den 
Beitrag in deinen Text reinkopieren
 Diese Funktionalität reicht normalerweise.

von x^y (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Lass es besser sein schrieb:
> Es gibt hier eine Menge fragestellende Leute, die nicht gerade den
> Eindruck machen, als hätten sie einen hohen Intelligenzquotienten.
> Du bist nicht Teil dieser Gattung, aber auch nur aus der Sicht, dass du
> kein Fragestellender bist.

Schade, und ich hatte schon Hoffnungen!

von Stefan ⛄ F. (stefanus)


Bewertung
1 lesenswert
nicht lesenswert
Welche Eigenschaft unterscheidet die "wahre zahl" von den falschen 
zahlen?

> Die obigen Zahlen sind mit einem Offset von +-7 ermittelt worden.

Was bedeutet das? Weichen sie maximal um 7 von der wahren Zahl ab? Warum 
sehe ich in deinem Beispiel dann überwiegend Zahlen, die sehr viel mehr 
Abstand zueinander haben?

Vergiss mal deine Lösungsansätze, aus denen kann ich die Aufgabe nicht 
extrahieren. Deine Beispiele nützen auch nicht, solange nicht klar ist 
welcher Zusammenhang zwischen ihnen besteht.

Ich rate jetzt mal ganz wild:

Irgend jemand gibt eine beliebige "wahre Zahl" vor.
Anschließend werden drei Arrays mit beliebigen Zahlen befüllt, von denen 
(pro Array) wenigstens eine Zahl maximal um maximal 7 von der "wahren 
Zahl" abweicht.
Du sollst durch betrachten der drei Array herausfinden, welche "wahre 
Zahl" vorgegeben wurde.

Ist das so korrekt?

Wenn ja, dann ist diese Aufgabe nicht eindeutig lösbar, denn es gibt 15 
mögliche Zahlen, die der Bedingung (maximal +/-7) entsprechen.

Also habe ich es wohl auch nicht kapiert.

: Bearbeitet durch User
von Achim S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Scheint aber Leute zu geben, die es doch verstehen.

Trotzdem sind deine Erklärungskünste bescheiden. Kann es sein, dass es 
dir schwerfällt, dich in die Situation des Lesers einzudenken, der 
keinen anderen Zugang zur Problemstellung hat, als das, was du hier 
vorstellst?

hans schrieb:
> Jetzt waere es wohl nützlich wenn die Beitraege Nummern hätten.

Die Beiträge haben einen Titel, den du als Link zitieren kannst. Mit der 
rechten Maustaste auf den farbig hinterlegten Titel des Beitrags gehen, 
dann auf "Link-Adresse kopieren", dann hast du den gewünschten Verweis 
auf einen bestimmten Beitrag.

Inzwischen ist es gar nicht mehr so einfach, sich in der Vielzahl der 
Beträge zurecht zu finden. Ich beziehe mich mal auf die Beschreibung in 
Beitrag "Re: geschicktes Suchen von Elementen im Array"

Deine drei Arrays sind also bereits der Größe nach sortiert, und man 
kann erkennen, wenn ein Array "nicht weiter gefüllt" ist (weil dann die 
0 drinsteht), korrekt?

Falls ich die Problemstellung richtig verstanden habe ist mein 
Lösungsvorschlag:

- du initialisierst für jedes Array einen Index (Idx1, Idx2, Idx3), der 
auf das erste Element des Arrays zeigt
- ab jetzt läuft eine Schleife
- du bildest zwischen den drei indizierten Arraywerten alle möglichen 
Differenzen (Also Diff1=Ar1[Idx1]-Ar2[Idx2], Diff2=Ar1[Idx1]-Ar3[Idx3], 
Diff3=Ar2[Idx2]-Ar3[Idx3])
- falls mindestens zwei der drei Differenzwerte kleine 7 sind, hast du 
die richtigen Werte gefunden. Der "wahre" Wert ist derjenige, der von 
den dreien in der Mitte liegt. (Auswertung z.B. über "betragsmäßig 
gerinste Differenz zum arithmetischen Mittelwert)
- falls mindestens zwei der drei Differenzwerte >=7 sind, musst du 
weiter suchen. Dazu erhöhst du nur einen der drei Indizies, und zwar 
denjenigen, der aktuell auf den kleinsten Zahlenwert zeigt
- das wiederholst du so lange, bis du die richtige Zahl gefunden hast 
oder bis du in einem der Arrays auf leere Stellen stößt. Falls du auf 
leere Stellen stößt, ist kein "wahrer Wert" vorhanden.

Passt das zur Lösung deines Problems?

von Stefan ⛄ F. (stefanus)


Bewertung
1 lesenswert
nicht lesenswert
Aus der Hornbach Werbung: Wenn du es Dir vorstellen kannst, dann kannst 
du es auch bauen.

Heißt für Programmierer: Wenn du die Aufgabe klar und vollständig 
formulieren kannst, dann kannst du es auch programmieren.

von Achim S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Achim S. schrieb:
> falls mindestens zwei der drei Differenzwerte kleine 7 sind

Tschuldigung: die korrekte und vollständige Anweisung hätte lauten 
müssen: falls mindestens zwei der drei Differenzwerte betragsmäßig 
kleiner 7 sind...

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Er hat die Zahlen gegeben:

hans schrieb:
> Werte1: 5,6,6,7,
> 7,10,36,50,53,55,57,61,64,68,72,77,80,82,83,86,86,85,83,84, 84, 83, 83,
> 81, 80, 80, 76, 74, 73, 71, 69, 67, 66
> Werte2: 5,8,8,9,
> 9,11,21,28,32,33,36,38,41,45,50,59,64,68,73,81,87,93,99,103,107,111,115, 
119,124,133,141,151,160,166,171,173,175
> Werte3:
> 6,8,9,10,9,11,18,23,25,25,27,27,27,29,30,33,35,35,36,37,38,38,39,40, 41,
> 42, 42, 42, 42, 44, 44, 47, 48, 49, 50, 49, 50

Jetzt bildet er ein 3-Tupel. Und zwar wie folgt:
Er nimmt z.B. am Index 14 die Arrayalemente aus drei Arrays raus.

Das wären dann die Zahlen:
hans schrieb:
> 72, 50, 30 (Werte1, Werte2, Werte3)


so würde er vorgehen, wenn er diesen Index (14) gekannt hätte. So könnte 
er sofort dieses 3-Tupel zu diesem Index angeben. Aber er hat nur die 
INDIZES von den Zahlen, die im Abstand von +/-7  von diesem Index 
liegen. Und mit diesen Indizes will er den ursprunglichen Index(14) 
berechnen.



Array Werte1:
die Zahl 72 mit dem Index 14. Die Zahl davor(68) und die Zahl danach(77) 
liegen in dem vorgegeben Offset-Bereich (+/-7).

Also:

68 | 72 | 77   (Arraywerte)
------------
13|  14 | 15  (Indizes)


Array Werte2:

25 | 50
-------
13 | 14  (Indizes)


Array Werte3:
23| 25| 25| 27 |27|.......|36|37
-------------------------------------
7 | 8  | 9 | 10 |11........|18|19  (Indizes)


Und das ist die Aufgabe:

Er hat drei Arrays mit Indizes, die ich oben angegeben habe:

    int arr1[]={13,14,15};
    int arr2[]={13,14};
    int arr3[]={7,8,9,10,11,12,13,14,15,16,17,18,19};

In jedem dieser Arrays ist der korrekte Index versteckt und muss 
berechnet werden. Ok, wenn  es so ist, dann nehmen wir halt das kürzeste 
Array arr2 zum Rechnen und berechnen zu jeder Zahl (hier 13 und 14) 
einen entsprechenden Index.

Berechnung für die Zahl 13:

1) Mittelwert für arr1 bilden: (13 +14 +15) /3 =14
2) Mittelwert für arr2 bilden: (7+8+...+19)/ 13=13

Jetzt den Mittelwert aus 1), 2) und der Zahl 13 selbst berechnen:

(14+13+14)/3=13.3333 Das ist der berechnete Index für die Zahl 13.


Berechnung für die Zahl 14:

Genauso. An Ende kommt raus:
1) 14
2) 13

und (14 + 14 +13) /3 = 13.67 (der berechnete Index für die Zahl 14 ---> 
noch näher dran)

Und das war wohl die Aufgabe: Aus Indizes die ursprungliche Position im 
Array (näherungsweise) zu berechnen. Das 3-Tupel hatte Index 14, wir 
haben 13,...  berechnet.  So habe ich es verstanden.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
Ich finde es nicht hilfreich, die Aufgabe zu beschrieben, indem man Mit 
Zahlen-Ketten anfängt und dann einen Algorithmus beschreibt, der irgend 
etwas tut.

Zuerst bitte die Aufgabe klarstellen!

: Bearbeitet durch User
von Marc V. (Firma: Vescomp) (logarithmus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Ich nehme also das erste Element (23) und suche nach ähnlichen Werten in
> den anderen beiden. Bei der Suche nach ähnlichen Elementen verwende ich
> ebenfalls ein Offset von +-7.

 Nur das es kein Offset, sondern Grenzwerte sind.
 Nach dem Ersten Beitrag von TO habe ich zuerst vergeblich Elemente mit
 einem Offset von +/- 7 in allen 3 Arrays gesucht.

Lothar M. schrieb:
> Und was stellt "Die Wahre Zahl" eigentlich dar? Welche Information trägt
> sie selbst oder ihr Index im Array? Gibt's da keinem sinnvollen Namen
> dafür?

 Das wollte ich auch fragen.

 Selten so eine Frage gesehen, die so umständlich und so falsch
 beschrieben worden ist.

: Bearbeitet durch User
von Achim S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> und dann einen Algorithmus beschreibt, der irgend
> etwas tut.
>
> Zuerst bitte die Aufgabe klarstellen!

Das hat er ja mehrfach versucht (mit mäßigem Erfolg). Die Beschreibung 
des Algorithmus, der die Aufgabenstellung löst, kann durchaus dabei 
helfen klarzustellen, ob die Aufgabenstellung richtig interpretiert 
wurde.

Mein Algorithmus löst meine Interpretation der Aufgabenbeschreibung, die 
ich folgendermaßen beschreiben würde:

"In einer der drei Arrays (es ist unbekannt in welchem) ist eine "wahre" 
Zahl vorhanden. Die wahre Zahl ist dadurch ausgezeichnet, dass es in den 
beiden anderen Arrays jeweils mindestens eine Zahl gibt, die von der 
wahren Zahl weniger als +-7 entfernt ist. Die Aufgabe besteht darin, 
diese wahre Zahl zu finden. Die Lösung kann, muss aber nicht eindeutig 
sein."

zitter_ned_aso interpretiert offenbar die Aufgabenstellung anders, und 
die unterschiedlichen Interpretation werden in den unterschiedlichen 
Algorithem sehr deutlich.

von Stefan ⛄ F. (stefanus)


Bewertung
1 lesenswert
nicht lesenswert
Deswegen soll zuerst die Aufgabe geklärt werden, nicht die 
unpassenden/falschen Lösungsansätze.

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
zitter_ned_aso schrieb:
> So habe ich es verstanden.

Und so berechne ich aus Indezes den ursprunglichen Indexwert:
1
#include <stdio.h>
2
#include <stdlib.h>
3
4
double mittelwert(int arr[], int arr_len, int magic_number, int offset){
5
    int sum_offset=0;
6
    int counter=0; 
7
    int temp=0;
8
9
    for(int i=0; i<arr_len; i++){
10
        temp=arr[i]-magic_number;
11
        if(abs(temp)>offset){        
12
            continue;
13
        }
14
        else{
15
            counter++;
16
            sum_offset+=temp;
17
        }
18
    }
19
    
20
    return (double)sum_offset/counter+magic_number;
21
}
22
23
int main(void) {
24
25
    int arr1[]={13,14,15};
26
    int arr2[]={13,14};
27
    int arr3[]={7,8,9,10,11,12,13,14,15,16,17,18,19};
28
    
29
    const int arr1_len=sizeof(arr1)/sizeof(arr1[0]);
30
    const int arr2_len=sizeof(arr2)/sizeof(arr2[0]);
31
    const int arr3_len=sizeof(arr3)/sizeof(arr3[0]);
32
33
    double temp;
34
    int magic_number=0;
35
    int offset=7;
36
37
38
    for(int i=0; i<arr2_len; i++){
39
        magic_number=arr2[i]; 
40
        temp=( mittelwert(arr1, arr1_len, magic_number, offset) + 
41
               mittelwert(arr3, arr3_len, magic_number, offset) + 
42
               magic_number )/3.0;
43
        printf("arraywert: %d\tberechneter wert: %f\n", magic_number, temp); 
44
    }
45
  
46
    
47
        return EXIT_SUCCESS;
48
}

Das liefert dann die Ausgabe:
1
arraywert: 13  berechneter wert: 13.333333
2
arraywert: 14  berechneter wert: 13.666667
In der letzten Zahl hat man die kleinste Abweichung also muss das die 
gesuchte Zahl sein.

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Benennt man die Arrays um
1
    int arr3[]={13,14,15};
2
    int arr1[]={13,14};
3
    int arr2[]={7,8,9,10,11,12,13,14,15,16,17,18,19};

So bekommt man die Ausgabe:
1
arraywert: 7  berechneter wert: 11.333333
2
arraywert: 8  berechneter wert: 11.833333
3
arraywert: 9  berechneter wert: 12.166667
4
arraywert: 10  berechneter wert: 12.500000
5
arraywert: 11  berechneter wert: 12.833333
6
arraywert: 12  berechneter wert: 13.166667
7
arraywert: 13  berechneter wert: 13.500000
8
arraywert: 14  berechneter wert: 13.833333
9
arraywert: 15  berechneter wert: 14.166667
10
arraywert: 16  berechneter wert: 14.500000
11
arraywert: 17  berechneter wert: 14.833333
12
arraywert: 18  berechneter wert: 15.166667
13
arraywert: 19  berechneter wert: 15.500000
Auch hier ist die Abweichung am kleinsten in der Zeile:

arraywert: 14  berechneter wert: 13.833333

Also ist die gesuchte Zahl = 14.

von Achim S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> Deswegen soll zuerst die Aufgabe geklärt werden, nicht die
> unpassenden/falschen Lösungsansätze.

Genau um das zu tun - endlich die eigentliche Problemstellung zu klären 
- setze ich meine Beschreibung eines möglichen Lösungswegs doch ein. 
Wenn dieser Algorithmus die richtige Lösung liefert, dann ist damit auch 
klar, dass die dahinterstehende Interpretation der Aufgabenbeschreibung 
richtig ist. Wenn nicht, dann nicht.

Wenn der Algorithmus das Problem allgemein richtig löst, dann ist das 
eine eindeutige Aussage zur Problemstellung. Statt sich - wie vom TO 
bisher geschehen - an Beispielen entlangzuhangeln, die mehrdeutige 
Interpretationen zulassen.


Ach ja, und meine (aus meiner Sicht klare) Interpretation der 
Problembeschreibung:

Achim S. schrieb:
> "In einer der drei Arrays (es ist unbekannt in welchem) ist eine "wahre"
> Zahl vorhanden. Die wahre Zahl ist dadurch ausgezeichnet, dass es in den
> beiden anderen Arrays jeweils mindestens eine Zahl gibt, die von der
> wahren Zahl weniger als +-7 entfernt ist. Die Aufgabe besteht darin,
> diese wahre Zahl zu finden. Die Lösung kann, muss aber nicht eindeutig
> sein."

ist übrigens gar nicht so weit entfernt von einem Teil der Beschreibung, 
die der TO zu Beginn gab:

hans schrieb:
> Tatsache ist aber, dass
> in jedem array eine der wahren Zahl ähnlicher Wert mit der genannten
> Abweichung +-7 vorhanden ist.

Mit seinen Beispielen ist dann leider eher Mehrdeutigkeit in die 
Beschreibung gekommen als Eindeutigkeit.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
Es wurden nun reichlich Interpretationen der Aufgabe genannt und anhand 
von Beispiel erläutert. Um weiter zu kommen möchte ich den TO nun 
bitten, die richtige Interpretation zu benennen oder die Aufgabe klar zu 
formulieren.

von x^y (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Achim S. schrieb:
> "In einer der drei Arrays (es ist unbekannt in welchem) ist eine "wahre"
> Zahl vorhanden. Die wahre Zahl ist dadurch ausgezeichnet, dass es in den
> beiden anderen Arrays jeweils mindestens eine Zahl gibt, die von der
> wahren Zahl weniger als +-7 entfernt ist. Die Aufgabe besteht darin,
> diese wahre Zahl zu finden. Die Lösung kann, muss aber nicht eindeutig
> sein."

DAS verstehe ich. Solange diese Aussage natürlich nicht vom Autor kommt, 
ist es Spekulation. Eine Beschreibung erfordert zugegeben nachdenken, 
aber das muss ein Fragesteller leisten können, sonst kann man ihm nicht 
helfen. Nach meinem Verständnis:

Bestimme aus 3 Zahlenmengen ein 3-Tuple so, dass die größte 
betragsmäßige Abweichung vom Median-Wert des 3-Tuple minimal ist. Dieses 
3-Tuple ist eine Lösung, falls deren betragsmäßige Abweichung vom 
Median-Wert kleiner als eine gegebene Schwelle ist (hier: 7).

von zitter_ned_aso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Tatsache ist aber, dass
> in jedem array eine der wahren Zahl ähnlicher Wert mit der genannten
> Abweichung +-7 vorhanden ist.

Diese Zahl ist also in jedem Array versteckt. Je länger ein Array ist 
umso mehr muss man prüfen. Also nimmt man zum Rechnen das kleinste 
Array:

hans schrieb:
> Dann überprüfe ich zuerst, welches Array über die geringste Anzahl an
> Elementen verfügt. Hier wäre es das array2.

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Versteht es nicht falsch, aber ich glaube meine Erklärungsversuche sind 
nur deshalb so bescheiden, weil ihr mein eigentliches Ziel dieser 
Teilaufgabe erfahren wollt und ich euch nicht gleich verraten möchte, 
dass zu meiner Reise meine ganze Familie mitkommt und wir vor Ort noch 
unsere Grosseltern zum Picknick am Kollosseum in Rom treffen, wenn es 
mich im Moment nur interessiert vom Eifelturm zum Kolesseum zu kommen 
und nach der besten Route mit dem stinknormalen PKW frage. Da brauch ich 
doch die Information nicht, wer mein Auto wie zusammengebaut, was für 
ein Baujahr es ist und wer sonst mit dabei ist!?
So verstehe ich das.

Das Muster ist nämlich immer das Selbe hier. Dann kommen nämlich wieder 
Antworten wie, nimm doch einen Pickup, so kannst du nämlich dein 
Fahrzeug besser mit der Ausrüstung beladen, die du dann zum Picknick 
benötigen würdest etc. etc. etc. Oder flieg doch mit dem Flugzeug, mit 
dem Auto brauchst du viel zu lange. Das interessiert mich alles nicht, 
deshalb erspare ich mir die Information.
Gegeben ist das Array mit den Werten in den 3 verschiedenen Arrays. Und 
wenn ich annähernde Werte einer Kombination messe, möchte ich wissen, wo 
die Werte in den Ausgangsarrays sind und habe dazu meine Vorgehensweise 
beschrieben und wissen wollen, ob das so funktionieren würde. Basta!
Und trotzdem, ja es sind Sensorwerte von einem magnetischen Sersor, von 
denen ich 3 habe. Ich bin von Hand ausgehend von Sensor 1 mit dem Metall 
zum Sensor 3 gefahren und die Werte in den Arrays festgestellt. (Siehe 
Bild). Die Werte habe ich im 1s Takt aufgenommen. Dies deshalb, weil ich 
vermeiden wollte, dass mehrere gleiche Kombinationen aufgenommen werden, 
was heisst, dass ich von Hand also auch eine bestimmte Geschwindigkeit 
halten muss. Ich gebe zu, dass dies keine saubere Aufnahme ist, aber 
eine Doktorarbeit wollte ich daraus auch nicht machen, da ich nur wissen 
möchte, ob es so auch funktioniert.
Jetzt habe ich es mir zum Spass zur Aufgabe gemacht, daraus die 
ungefähre Metallposition zu ermitteln und das versuche ich mit den 
Indizes. Ich traue mich zu behaupten, dass ich damit, Indizes zu 
berechnen, nicht ganz so verkehrt liege.
Um die gemessenen Werte vergleichen und mit Indizes arbeiten zu können, 
habe ich auch im 1s Takt ausserdem darauf geachtet, dass immer alle 3 
Werte gleichzeitig ausgewertet werden. Dann kann ich nämlich davon 
ausgehen, dass es die Kombination sicher gibt, auch wenn ich mal nicht 
so sauber messe und zwischendurch kurz eingeschlafen bin.
So jetzt wisst ihr es und nun?

Ich finde zitter ned aso hat es am Besten getroffen. Deshalb "zittere" 
ich ihn mal und korrigiere ihn an manchen Stellen.

zitter_ned_aso schrieb:
> Er hat die Zahlen gegeben:
>
> hans schrieb:
>> Werte1: 5,6,6,7,
>> 7,10,36,50,53,55,57,61,64,68,72,77,80,82,83,86,86,85,83,84, 84, 83, 83,
>> 81, 80, 80, 76, 74, 73, 71, 69, 67, 66
>> Werte2: 5,8,8,9,
>> 9,11,21,28,32,33,36,38,41,45,50,59,64,68,73,81,87,93,99,103,107,111,115,
> 119,124,133,141,151,160,166,171,173,175
>> Werte3:
>> 6,8,9,10,9,11,18,23,25,25,27,27,27,29,30,33,35,35,36,37,38,38,39,40, 41,
>> 42, 42, 42, 42, 44, 44, 47, 48, 49, 50, 49, 50

Ich hatte nur einen Teil angegeben, die vollständige Messung von sensor 
1 zum letzten Sensor ist:
1
werte1 = {5,6,6,7, 7,10,36,50,53,55,57,61,64,68,72,77,80,82,83,86,86,85,83,84, 84, 83, 83, 81, 80, 80, 76, 74, 73, 71, 69, 67, 66, 62, 61, 60, 59, 57, 55, 55, 54, 52, 51, 49, 48, 47, 46, 45, 43, 42, 40, 40, 39, 38, 37, 35, 34, 34, 34, 34, 34, 34, 35, 34, 36, 35, 36, 36, 36, 36, 36, 36, 37, 38, 38, 39, 40, 42, 43, 45, 46, 47, 48, 49, 50, 51, 51, 52, 53, 54, 56, 59, 60, 61, 62, 63, 64, 67, 68, 70, 75, 77, 80, 80, 82, 83, 83, 85, 85, 86, 87, 88, 89, 90, 90,90,91,91,90,90,89,87,84,82,80,78,76,75,71,70,67,64,61,57,54,52,49,46,44,42,37,32,26,22,19,15,14,13,12,11,11,11,10,10,10,9, 9, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};
2
werte2 = {5,8,8,9, 9,11,21,28,32,33,36,38,41,45,50,59,64,68,73,81,87,93,99,103,107,111,115,119,124,133,141,151,160,166,171,173,175,179,184,188,190,192,196,196,197,198,199,203,205,206,207,208,207,207,206,206,205,203,199,193,186,181,177,170,164,161,153,147,143,138,135,130,125,121,118,115,112,110,108,105,101,95, 88, 85, 82, 81, 80, 79, 75, 74, 70, 68, 66, 64, 63, 59, 58, 56, 54, 53, 53, 53, 52, 51, 50, 48, 47, 46, 45, 46, 45, 45, 45, 42, 42, 41, 40, 40, 40,40,40,38,37,36,36,36,36,35,34,32,31,30,30,30,30,29,27,25,24,24,24,23,23,23,21,19,17,16,17,16,15,15,14,13,13,13,14,14,14,14,12,11,12,12,13,13,13,13,12,11,11,11,13,13,12,12};
3
werte3 = {6,8,9,10,9,11,18,23,25,25,27,27,27,29,30,33,35,35,36,37,38,38,39,40, 41, 42, 42, 42, 42, 44, 44, 47, 48, 49, 50, 49, 50, 50, 52, 54, 55, 57, 59, 58, 59, 60, 62, 67, 69, 72, 73, 76, 78, 80, 84, 88, 91, 93, 95, 98, 104,111,115,123,131,140,151,159,166,169,177,179,184,189,190,192,196,200,203,210,214,220,221,224,225,226,227,228,227,227,224,223,221,220,219,215,213,210,208,205,201,198,194,187,176,167,159,155,148,143,139,134,129,121,116,108,104,101,96,92,86,82,76,73,70,67,63,59,56,52,49,47,44,43,41,38,35,32,30,28,28,27,26,26,23,21,19,18,18,17,16,16,14,14,13,13,14,14,14,14,12,11,12,12,13,13,13,13,12,11,11,12,13,13,13,12};

> Jetzt bildet er ein 3-Tupel. Und zwar wie folgt:
> Er nimmt z.B. am Index 14 die Arrayalemente aus drei Arrays raus.

Nein, ich habe einmal die Werte in den Arrays gemessen. Also sind das 
Werte, die sicher vorkommen mit einer gewissen Abweichung, da ich ja nur 
im Sekundentakt die Werte aufgenommen habe. Es gibt ja zwischen den 
einzelnen Samples auch irgendwelche Werte. Daher verwende ich ein Offset 
von +/- 7.


> Das wären dann die Zahlen:
> hans schrieb:
>> 72, 50, 30 (Werte1, Werte2, Werte3)
>
> so würde er vorgehen, wenn er diesen Index (14) gekannt hätte. So könnte
> er sofort dieses 3-Tupel zu diesem Index angeben. Aber er hat nur die
> INDIZES von den Zahlen, die im Abstand von +/-7  von diesem Index
> liegen. Und mit diesen Indizes will er den ursprunglichen Index(14)
> berechnen.

Ich glaube du meinst zwar das Richtige, aber hast es meiner Meinung nach 
anders formuliert. Ich messe dann tatsächliche Werte mit den Sensoren. 
Diese verwende ich dann dazu um durch die 3 Arrays mit den aufgenommenen 
Sensorwerten zu gehen und nach den 3 aktuellen Sensorwerten  +/- Offset 
zu suchen.

Das Ergebnis lege ich dann in den Index Arrays ab.

>
> Array Werte1:
> die Zahl 72 mit dem Index 14. Die Zahl davor(68) und die Zahl danach(77)
> liegen in dem vorgegeben Offset-Bereich (+/-7).
>
> Also:
>
> 68 | 72 | 77   (Arraywerte)
> ------------
> 13|  14 | 15  (Indizes)


richtige wäre

> 68 | 72 | 77 | 76 | 74 | 73 | 71 | 69 | 67 | 66(Arraywerte)
> -----------------------------------------------
> 13|  14 | 15 | 30 | 31 | 32 | 33 | 34 | 35 | 36 (Indizes)



>
> Array Werte2:
>
> 25 | 50
> -------
> 13 | 14  (Indizes)


richtige wäre
 45 | 50 (Arraywerte)


>
> Array Werte3:
> 23| 25| 25| 27 |27|.......|36|37
> -------------------------------------
> 7 | 8  | 9 | 10 |11........|18|19  (Indizes)
>
> Und das ist die Aufgabe:
>
> Er hat drei Arrays mit Indizes, die ich oben angegeben habe:
>
>     int arr1[]={13,14,15, 30, 31, 32, 33, 34, 35, 36};
>     int arr2[]={13,14};
>     int arr3[]={7,8,9,10,11,12,13,14,15,16,17,18,19};
>
> In jedem dieser Arrays ist der korrekte Index versteckt und muss
> berechnet werden. Ok, wenn  es so ist, dann nehmen wir halt das kürzeste
> Array arr2 zum Rechnen und berechnen zu jeder Zahl (hier 13 und 14)
> einen entsprechenden Index.
>
> Berechnung für die Zahl 13:
>
> 1) Mittelwert für arr1 bilden: (13 +14 +15) /3 =14
> 2) Mittelwert für arr2 bilden: (7+8+...+19)/ 13=13
>
> Jetzt den Mittelwert aus 1), 2) und der Zahl 13 selbst berechnen:
>
> (14+13+14)/3=13.3333 Das ist der berechnete Index für die Zahl 13.
>
> Berechnung für die Zahl 14:
>
> Genauso. An Ende kommt raus:
> 1) 14
> 2) 13
>
> und (14 + 14 +13) /3 = 13.67 (der berechnete Index für die Zahl 14 --->
> noch näher dran)
>
> Und das war wohl die Aufgabe: Aus Indizes die ursprungliche Position im
> Array (näherungsweise) zu berechnen. Das 3-Tupel hatte Index 14, wir
> haben 13,...  berechnet.  So habe ich es verstanden.

von hans (Gast)


Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
hier noch das vergessene Bild

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Gegeben ist das Array mit den Werten in den 3 verschiedenen Arrays.

Was jetzt, ein Array oder drei Arrays?

> wenn ich annähernde Werte einer Kombination messe, möchte ich wissen, wo
> die Werte in den Ausgangsarrays sind

Meinst du drei direkt aufeinander folgende ähnliche Werte?

Was hat das ganze dann damit zu tun, den "wahren" Wert zu finden?

Ich verstehe noch nicht, welche Bedeutung die drei Arrays zueinander 
haben. Sind sie völlig unabhängig voneinander? Wenn ja, dann sollten wir 
die ganze Diskussion zunächst auf ein Array reduzieren.

Nach dem Blick auf deine Zeichnung denke ich, dass der kleinste 
gemessene Wert wohl der relevante sein wird. Melden zwei Sensoren kleine 
Werte, dann befindet sich das Metallstück irgendwo zwischen den beiden 
Sensoren.

Was das alles mit dem "wahren" Wert zu tun haben soll, ist mir aber 
weiterhin schleierhaft. Mit jeder weiteren Erklärung wird es für mich 
noch verwirrender.

Können wir nochmal ganz vorn vorne anfangen, mit der Zeichnung und einer 
unverschleierten Erklärung, worauf du hinaus willst?

: Bearbeitet durch User
von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> hans schrieb:
>> Gegeben ist das Array mit den Werten in den 3 verschiedenen Arrays.
>
> Was jetzt, ein Array oder drei Arrays?
>
>> wenn ich annähernde Werte einer Kombination messe, möchte ich wissen, wo
>> die Werte in den Ausgangsarrays sind
>
> Meinst du drei direkt aufeinander folgende ähnliche Werte?
>
> Was hat das ganze dann damit zu tun, den "wahren" Wert zu finden?
>
> Ich verstehe noch nicht, welche Bedeutung die drei Arrays zueinander
> haben. Sind sie völlig unabhängig voneinander? Wenn ja, dann sollten wir
> die ganze Diskussion zunächst auf ein Array reduzieren.
>
> Nach dem Blick auf deine Zeichnung denke ich, dass der kleinste
> gemessene Wert wohl der relevante sein wird. Melden zwei Sensoren kleine
> Werte, dann befindet sich das Metallstück irgendwo zwischen den beiden
> Sensoren.
>
> Was das alles mit dem "wahren" Wert zu tun haben soll, ist mir aber
> weiterhin schleierhaft. Mit jeder weiteren Erklärung wird es für mich
> noch verwirrender.
>
> Können wir nochmal ganz vorn vorne anfangen, mit der Zeichnung und einer
> unverschleierten Erklärung, worauf du hinaus willst?

Nein, ich bin schneller, wenn ich es einfach mache. Mir scheint es im 
Moment so, als ob ihr es einfach nicht verstehen wollt.

Was verstehst du jetzt daran nicht, dass die Sensorwerte alle 
gleichzeitig im Sekundentakt aufgenommen wurden. Also haben sie direkten 
Zusammenhang oder nicht? Und wenn ich alle 3 Werte separat in ein Array 
lege, haben die Arrays einen Zusammenhang zueinander.
Also noch einfacher als ein Bild noch dazu abzugeben geht es wirklich 
nicht mehr.

Wenn ich zwischen Sensor 2 und 3 bin, gibt Sensor 1 das kleinste Signal 
ab.
Ich habe eher den Eindruck, dass du nicht weisst wie ein Magnetsensor 
funktioniert. Aber lassen wir das Thema jetzt. Ich habe jetzt genug.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Wenn ich zwischen Sensor 2 und 3 bin, gibt Sensor 1 das kleinste Signal
> ab.

Ich war vom umgekehrten Fall ausgegangen: Metall nahe = kleiner Wert, 
weil du im Eröffnungsbeitrag kleine Zahlen finden wolltest. Aber Ok, 
dann ist es halt anders herum.

Warum suchst du nicht einfach den größten Wert in den drei Arrays?

: Bearbeitet durch User
von x^y (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ich erlaube mir mal die Aufgabenstellung zu extrahieren:

hans schrieb:
> es sind Sensorwerte von einem magnetischen Sersor, von
> denen ich 3 habe
> Ich bin von Hand ausgehend von Sensor 1 mit dem Metall
> zum Sensor 3 gefahren
> Die Werte habe ich im 1s Takt aufgenommen
> ich [habe] auch [...] darauf geachtet, dass immer alle 3
> Werte gleichzeitig ausgewertet werden.
> ich [habe] es mir [...] zur Aufgabe gemacht, daraus die
> ungefähre Metallposition zu ermitteln

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> hans schrieb:
>> Wenn ich zwischen Sensor 2 und 3 bin, gibt Sensor 1 das kleinste Signal
>> ab.
>
> Ich war vom umgekehrten Fall ausgegangen: Metall nahe = kleiner Wert,
> weil du im Eröffnungsbeitrag kleine Zahlen finden wolltest. Aber Ok,
> dann ist es halt anders herum.
>
> Warum suchst du nicht einfach den größten Wert in den drei Arrays?

Stefan, ich mache es dir jetzt einmal einfach, damit auch du verstehst 
wie so ein Sensor funktioniert.

Du bist Sensor 1. Dann nimmst du noch 2 deiner besten Kollegen und 
stellst sie nacheinander im Abstand von zB 3m von dir entfert hin. Dein 
Maximalwert und die deiner Kollegen ist sagen wir 50.

Jetzt nehme ich die Werte auf. Wenn ich bei dir stehe schreist du 50, 
dein Kollege in der Mitte von mir aus 5 und der andere aussen zB 2.
Befinde ich mich genau zwischen dir und deinen mittleren Kollegen 
schreist du 25, dein mittlerer Kollege auch 25 und der andere 10 vllt.
Wenn ich diese Position suche, was bringt es mir nach den grössten 
Werten zu suchen? Erkläre mir das mal bitte.

Ich brauche genau diese Werte, die im Array abgelegt sind. Hast du es 
jetzt endlich verstanden?
Ich bin raus.

Danke an zitter ned aso

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
x^y schrieb:
> Ich erlaube mir mal die Aufgabenstellung zu extrahieren:
>
> hans schrieb:
>> es sind Sensorwerte von einem magnetischen Sersor, von
>> denen ich 3 habe
>> Ich bin von Hand ausgehend von Sensor 1 mit dem Metall
>> zum Sensor 3 gefahren
>> Die Werte habe ich im 1s Takt aufgenommen
>> ich [habe] auch [...] darauf geachtet, dass immer alle 3
>> Werte gleichzeitig ausgewertet werden.
>> ich [habe] es mir [...] zur Aufgabe gemacht, daraus die
>> ungefähre Metallposition zu ermitteln

und dennoch braucht man das alles nicht wissen, um meine ursprüngliche 
Frage zu beantworten.

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:

> Jetzt nehme ich die Werte auf. Wenn ich bei dir stehe schreist du 50,
> dein Kollege in der Mitte von mir aus 5 und der andere aussen zB 2.
> Befinde ich mich genau zwischen dir und deinen mittleren Kollegen
> schreist du 25, dein mittlerer Kollege auch 25 und der andere 10 vllt.
> Wenn ich diese Position suche, was bringt es mir nach den grössten
> Werten zu suchen? Erkläre mir das mal bitte.
>


Noch genauer:
Die richtige Kombination wäre dann 25, 25, 10
messen tue ich aber nie genau die Werte. Mit dem Rauschen zB
23, 26, 12
Trotzdem weiss ich wo ich etwa bin, wenn ich mit einem Offset +/-7 suche 
und die Werte mittle, wie es zitter ned aso vorgeführt hat oder ich 
bereits x-mal erklärt habe.

von x^y (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Lieber hans, es ist mir auch egal. Du hast zwei Probleme: Ein 
technisches und ein persönliches. Das technische ist lösbar. In diesem 
Fall führt dein persönliches aber dazu, dass ich dir dein technisches 
nicht lösen möchte. Ich werde nicht bezahlt dir in meiner Freizeit hier 
Lösungen zu servieren.

von Achim S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Mir scheint es im
> Moment so, als ob ihr es einfach nicht verstehen wollt.

Hehe, ja klar, das wir es wohl sein: alle anderen Teilnehmer an dieser 
Diskussion haben sich verschworen, um dich auf den Arm zu nehmen. 
Deswegen tun sie alle so, als würden sie deine Problembeschreibung nicht 
verstehen, obwohl die ja von dir glasklar erläutert wurde.

Eine andere Erklärung für die Entwicklung dieses Threads ist kaum 
vorstellbar ;-)

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Achim S. schrieb:
> hans schrieb:
> Mir scheint es im
> Moment so, als ob ihr es einfach nicht verstehen wollt.
>
> Hehe, ja klar, das wir es wohl sein: alle anderen Teilnehmer an dieser
> Diskussion haben sich verschworen, um dich auf den Arm zu nehmen.
> Deswegen tun sie alle so, als würden sie deine Problembeschreibung nicht
> verstehen, obwohl die ja von dir glasklar erläutert wurde.
> Eine andere Erklärung für die Entwicklung dieses Threads ist kaum
> vorstellbar ;-)

Darum hat es zitter ned aso gleich verstanden, weil er ja auch die 
Krankheit hat immer gleich die gesamte Aufgabenstellung wissen zu 
wollen. Und versucht/ sich bemüht hat die Teilaufgabe zu lösen ohne den 
Ursprung der Daten zu kennen. Das hast du ja zwar auch versucht, aber 
meiner Meinung nach gibt es da echt Leute die sich wirklich enorm 
begriffstutzig geben. Nitchtsdestotrotz ist jetzt die Aufgabenstellung 
ja klar.Wie erwartet ändert das nichts an der Teilaufgabe.
Naja egal jetzt. Ich habe keine Lust mehr aufsowas.

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
x^y schrieb:
> Lieber hans, es ist mir auch egal. Du hast zwei Probleme: Ein
> technisches und ein persönliches. Das technische ist lösbar. In diesem
> Fall führt dein persönliches aber dazu, dass ich dir dein technisches
> nicht lösen möchte. Ich werde nicht bezahlt dir in meiner Freizeit hier
> Lösungen zu servieren.

Naja das Gleiche könnte ich auch von dir behaupten mit deinem Beiträgen.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> jetzt endlich verstanden?

Ich bin noch unsicher, da ich den Zusammenhang zu deinem Eröffnungspost 
nicht erkennen kann.

Ist es so korrekt?:

Ein Metallstück befindet sich in der Nähe von drei Sensoren. Siehe deine 
Zeichnung. Je näher das Metallstück zum Sensor liegt, umso größer ist 
der Messwert.

Du erfasst die Messwerte der drei Sensoren in regelmäßigen Abständen. 
Für jeden dieser Zeitpunkte möchtest du ermitteln, wo sich das 
Metallstück befunden hat.

Ich denke, das wird eine geometrische Rechen-Aufgabe. Zuerst würde ich 
den Messwert in eine Distanz umrechnen und gff. linearisieren, falls der 
Sensor nicht lineare Werte liefert.

Dann haben wir also zu jedem Zeitpunkt drei Distanzen. Mit Zwei Sensoren 
hätten wir ein Dreieck:
1
    Metall
2
     o
3
    / \
4
d1 /   \ d2
5
  /     \
6
 /       \
7
o---------o
8
S1        S1

c1 = Distanz zum linken Sensor
d2 = Distanz zum zweiten Sensor

Das Verhältnis zwischen der linken Distanz und der rechten Distanz gibt 
darüber Auskunft, wo sich das Metall zwischen den Sensoren befindet.

Wenn wir einen dritten Sensor dazu nehmen, suchst du dir die beiden 
Sensoren mit der geringsten Distanz aus, und nur deren Werte sind für 
die folgende Berechnung relevant.

Wir zerlegen das Dreieck:
1
  
2
      α1          α2
3
     /|           |\
4
 c1 / |           | \ c2
5
   /  | b1     b2 |  \
6
  /   |           |   \
7
β1----γ1         γ2----β2
8
   a1               a2

γ ist 90°

Du musst nur ausrechnen, wie groß a1 und a2 ist oder wie groß sie 
relativ zueinander sind.

Geht der Ansatz in die richtige Richtung?

Falls ja, dann hat die ganze Aufgabe mit Arrays ungefähr nichts zu tun.

: Bearbeitet durch User
Beitrag #5783346 wurde von einem Moderator gelöscht.
von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
Lass es besser sein schrieb im Beitrag #5783346:
> Wie man erkennen kann gibt es einen richtigen Haufen Zurückgebliebener
> hier, inkl TO

Dann kläre uns auf, Mister Superhirn.

von Lass es besser sein (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> Lass es besser sein schrieb:
> Wie man erkennen kann gibt es einen richtigen Haufen Zurückgebliebener
> hier, inkl TO
>
> Dann kläre uns auf, Mister Superhirn.

Lass es besser sein

von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
3 lesenswert
nicht lesenswert
hans schrieb:
> aber meiner Meinung nach gibt es da echt Leute die sich wirklich enorm
> begriffstutzig geben

Du hast Dir wirklich alle Mühe gegeben, nicht zu erklären, was Du 
willst. Daß "zitter" herausgefunden hat, was Du willst, würde ich als 
großen Zufall gepaart mit an Boshaftigkeit grenzender Hartnäckigkeit 
seinerseits einschätzen.

Deine Reaktion auf Nachfragen anderer in diesem Thread waren leider 
unterirdisch.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
Rufus Τ. F. schrieb:
> Daß "zitter" herausgefunden hat, was Du willst, würde ich als
> großen Zufall ... einschätzen.

Er hat das herausgefunden:

> Diese Zahl ist also in jedem Array versteckt. Je länger ein Array
> ist umso mehr muss man prüfen. Also nimmt man zum Rechnen das
> kleinste Array

Das kann nicht sein. Ein Array enthält die Messwerte eines Sensors. Die 
Position zwischen zwei Sensoren kann man wohl kaum herausfinden, indem 
man nur die Werte eines Sensors berücksichtigt.

von hans (Gast)


Bewertung
-1 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> Rufus Τ. F. schrieb:
>> Daß "zitter" herausgefunden hat, was Du willst, würde ich als
>> großen Zufall ... einschätzen.
>
> Er hat das herausgefunden:
>
>> Diese Zahl ist also in jedem Array versteckt. Je länger ein Array
>> ist umso mehr muss man prüfen. Also nimmt man zum Rechnen das
>> kleinste Array
>
> Das kann nicht sein. Ein Array enthält die Messwerte eines Sensors. Die
> Position zwischen zwei Sensoren kann man wohl kaum herausfinden, indem
> man nur die Werte eines Sensors berücksichtigt.

Ja um das zu verstehen müsstest du erst mal meine Beiträge lesen.
Wer sagt oder besser, wo habe ich geschrieben, dass ich den Wert von nur 
einem Sensor berücksichtige?
Ich bitte um Antwort.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> Wer sagt oder besser, wo habe ich geschrieben, dass ich den Wert von nur
> einem Sensor berücksichtige?

Das hat zitter gesagt, passt aber eben nicht zu deinen Beiträgen.

von hans (Gast)


Bewertung
-1 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> hans schrieb:
>> Wer sagt oder besser, wo habe ich geschrieben, dass ich den Wert von nur
>> einem Sensor berücksichtige?
>
> Das hat zitter gesagt, passt aber eben nicht zu deinen Beiträgen.

bitte um Zitat.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> bitte um Zitat.

Stefanus F. schrieb:
> Er hat das herausgefunden:
>> Diese Zahl ist also in jedem Array versteckt. Je länger ein Array
>> ist umso mehr muss man prüfen. Also nimmt man zum Rechnen das
>> kleinste Array

von hans (Gast)


Bewertung
-1 lesenswert
nicht lesenswert
Stefanus F. schrieb:
> hans schrieb:
>> bitte um Zitat.
>
> Stefanus F. schrieb:
>> Er hat das herausgefunden:
>>> Diese Zahl ist also in jedem Array versteckt. Je länger ein Array
>>> ist umso mehr muss man prüfen. Also nimmt man zum Rechnen das
>>> kleinste Array

Diese Zahl ist also in jedem Array versteckt == es wird nur ein 
Sensorwert berücksichtigt

Je länger ein Array ist umso mehr muss man prüfen == es wird nur ein 
Sensorwert berücksichtigt

Also nimmt man zum Rechnen das kleinste Array == es wird nur ein 
Sensorwert berücksichtigt

3x false, sogar in Programmiersprache

Mir ist schleierhaft wie du zur der Aussage kommst, dass nur ein 
Sensorwert verwendet wird.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
hans schrieb:
> es wird nur ein Sensorwert berücksichtigt

Das habe ich weder geschrieben, noch gemeint.

Ich habe geschrieben, das zitter nur ein Array, also nur die Werte eines 
Sensor verwenden wollte.

Ich zitiere nochmal mich selbst:

Stefanus F. schrieb:
> Ein Array enthält die Messwerte eines Sensors. Die
> Position zwischen zwei Sensoren kann man wohl kaum herausfinden, indem
> man nur die Werte eines Sensors berücksichtigt.

Hans, anstatt hier über einzelne Worte zu diskutieren, konzentriere doch 
doch bitte darauf, die Aufgabe zu beschreiben. Was ist denn mit meinem 
Ansatz mit den Dreiecken. Geht das in die richtige Richtung?

von hans (Gast)


Bewertung
0 lesenswert
nicht lesenswert
> Stefanus F. schrieb:
> Hans, anstatt hier über einzelne Worte zu diskutieren, konzentriere doch
> doch bitte darauf, die Aufgabe zu beschreiben. Was ist denn mit meinem
> Ansatz mit den Dreiecken. Geht das in die richtige Richtung?

Nein, das ist nämlich der Grund, weshalb ich glaube, dass der Rest der 
Leute hier das Geschriebene nicht verstehen, weil sie Dinge hinein 
interpretieren, die gar nicht da stehen, so wie du es gerade tust und 
solange das so ist, brauchen wir auch nicht weiter diskutieren. Ich sage 
nicht, dass ich zu den Besten Erklärern gehöre, sonst wäre ich nämlich 
auchLehrer geworden, aber das eigentliche Problem ist nämlich im MOment 
nichts Anderes als das, dass ihr falsch interpretiert und Dinge lest, 
die gar nicht da stehen.

Stefanus F. schrieb:
> hans schrieb:
>> es wird nur ein Sensorwert berücksichtigt
>
> Das habe ich weder geschrieben, noch gemeint.


Stefanus F. schrieb:
> Rufus Τ. F. schrieb:
>> Daß "zitter" herausgefunden hat, was Du willst, würde ich als
>> großen Zufall ... einschätzen.
>
> Er hat das herausgefunden:
>
>> Diese Zahl ist also in jedem Array versteckt. Je länger ein Array
>> ist umso mehr muss man prüfen. Also nimmt man zum Rechnen das
>> kleinste Array
>
> Das kann nicht sein. Ein Array enthält die Messwerte eines Sensors. Die
> Position zwischen zwei Sensoren kann man wohl kaum herausfinden, indem
> man nur die Werte eines Sensors berücksichtigt.

Hier hast du es doch schwarz auf weiss. Du hast ja auf das von ihm 
Geschriebene geantwortet und behauptet, dass man die Position der 
Sensoren nicht herausfinden kann, in dem man nur die Werte eines Sensors 
berücksichtigt.
Weisst du nicht einmal was du selbst schreibst? Muss ich es auch noch 
schwarz dick und doppelt unterstreichen?

Aber jetzt kommt bestimmt noch einer und stellt in den Raum, dass ich 
wieder Unrecht habe und es an mir liegt, dass du das was du selbst 
schreibst nicht einmal verstehst oder zwei Zeilen später vergessen hast.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
Tut mir Leid, ich kann Dir nicht weiter helfen. Offensichtlich sprechen 
wir nicht die gleiche Sprache. Ich wünsche Dir trotzdem Glück, die Sache 
erfolgreich zu Ende zu bringen.

von Hr. Stangl (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Könnte es sein, dass du die Leute hier einfach nur ordentlich 
verarschst?

Sieht für mich auf so aus.

von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
2 lesenswert
nicht lesenswert
hans schrieb:
> aber das eigentliche Problem ist nämlich im MOment nichts Anderes als
> das, dass ihr falsch interpretiert und Dinge lest, die gar nicht da
> stehen.

Nein. Entschiedener Widerspruch.

Das eigentliche Problem ist, daß Du Dich seit bald einem Tag 
konsequent weigerst, Dein Problem zu beschreiben.

Beitrag #5783527 wurde von einem Moderator gelöscht.
von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
1 lesenswert
nicht lesenswert
"hans": Auch für Dich gelten die Forenregeln. Nur ein Pseudonym pro 
Thread.

Im übrigen musst Du nicht auch noch anfangen, Leute zu beleidigen.

von Lass es besser sein (Gast)


Bewertung
-2 lesenswert
nicht lesenswert
Rufus Τ. F. schrieb:
> hans schrieb:
>> aber das eigentliche Problem ist nämlich im MOment nichts Anderes als
>> das, dass ihr falsch interpretiert und Dinge lest, die gar nicht da
>> stehen.
>
> Nein. Entschiedener Widerspruch.
>
> Das eigentliche Problem ist, daß Du Dich seit bald einem Tag
> konsequent weigerst, Dein Problem zu beschreiben.

Nein, das eigentliche Problem ist, daß Du Dich seit bald einem Tag
konsequent weigerst, sein beschriebenes Problem zu lesen.

Beitrag "Re: geschicktes Suchen von Elementen im Array"

und zwischendurch während du dich auf deinen faulen A... gesetzt hast, 
war nämlich auch schon jemand anders so frei und hat es für dich auch 
noch zusammengefasst und übersetzt:

Beitrag "Re: geschicktes Suchen von Elementen im Array"

Aber im Vorteil sind nur jene, die auch wirklich lesen können.

Wie bereits aber schon tausende Male wiederholt und schriftlich für die 
Ewigkeit hier im Forum festgehalten, hat nicht nur der TO Defizite am 
Intelligentsquotienten, sondern du auch und zwar enorm.

von hans (Gast)


Bewertung
-1 lesenswert
nicht lesenswert
Rufus Τ. F. schrieb:
> "hans": Auch für Dich gelten die Forenregeln. Nur ein Pseudonym
> pro Thread.
>
> Im übrigen musst Du nicht auch noch anfangen, Leute zu beleidigen.

Hä was redest du?

von Rufus Τ. F. (rufus) (Moderator) Benutzerseite


Bewertung
4 lesenswert
nicht lesenswert
Da hier wiederholt gegen Forenregeln verstoßen wird, und sich der 
Threadersteller jetzt als seine eigene Sockenpuppe zur Schau stellt,

beende ich das Elend hiermit.

Dieser Beitrag ist gesperrt und kann nicht beantwortet werden.