sciencetalk

Ik gebruik een flink aantal lego-achtige bouwsteentjes om 7 objecten te bouwen.
Hun massa’s zijn respectievelijk 750, 900, 110, 1292, 1573, 1849 en 2058 gram.
Deze waarden kunnen 10 gram afwijken.
Ik weet niet hoeveel bouwsteentjes gebruikt zijn.
Hoe kan ik de meest waarschijnlijke massa van de steentjes berekenen?
Het gaat vooral om de rekenwijze.
Anders gezegd: hoe bepaal je de grootste gemene deler van onbetrouwbare getallen?
Dit is geen huiswerk.

Ben benieuwd of hier een rekenmethode voor bestaat.

wat is zelf zou doen.
zoek de delers van het kleinste getal
kijk of je er nog een grotere deler van kunt vinden door er maximaal 10 bij of af te doen.

kijk of je de overige getallen ook kunt delen door de grootste deler van dat getal met een rest of tekort van maximaal 10
lukt dat ben je klaar
lukt dat niet neem de 1 na grootste deler van het kleinste getal enz.

hier zie ik 25 ff snel als vrij grote oplossing maar er kan best een grotere zijn.

Ik zou beginnen met de bandbreedte te bepalen.

Leuke vraag.
Volgens mij is het belangrijk om hem op te splitsen in 2 delen

Het berekenen van alle gemene delers die voldoen aan de basale eis dat ze binnen de gegeven meetfout vallen
Het toepassen van een bepaalde weging om het getal te kiezen dat je wilt

Vooral dat tweede punt heeft nog wel wat toelichting van de vraagsteller nodig. Ik zal een voorbeeldje geven.

Gegeven de getalen 3 en 5 met mogelijke meetfout 1. De geldige gemene delers zijn dan: [1, 2, 3, 4]
Maar welk getal kies je nu als meest geloofwaardige?

1, omdat dan overal de meetfout 0 is?
2, omdat in dat geval de meetfout voor alle getallen de zelfde kant op is, en dus verklaarbaar doordat het nulpunt van je weegschal verkeerd stond (een mogelijke fout zou kunnen zijn dat de werkelijke gewichten 2 en 4 waren, dus bij beide -1)
3, omdat dat de kleinste meetfout geeft voor een getal groter dan 1 (de absolute fout is resp [0,1])
4, omdat dat het grootste getal is dat voldoet? (de fout is resp + en - 1.)

stap 1 kan je makkelijk bruteforcen in python. bijvoorbeeld met deze code:

Code: Selecteer alles

import numpy as np

meetfout=10
gewichten=[ 750, 900, 110, 1292, 1573, 1849, 2058]
gewichten_sorted=sorted(gewichten)

def bepaal_rest_tweezijdig(getal, deler):
    positieve_rest=getal%deler
    if positieve_rest>deler/2:
        return positieve_rest-deler 
    else:
        return positieve_rest

#initieer alle mogelijke gehele getalen tussen 1 en het kleinste gewicht+meetfout
delers_om_te_testen=np.arange(1,gewichten_sorted[0]+meetfout+1)

#ga van het lichtse gewicht naar het zwaarste gewicht
for huidig_object in gewichten_sorted:
    #maak een lege lijst met geschikte getallen voor de volgende ronde
    delers_voor_volgende_ronde=[]
    print(f"Object {huidig_object}")
    print(f"we gaan de volgende waarden testen")
    print(delers_om_te_testen)

    #voor elk getal in de lijst met getallen die we nog moeten testen
    #bepaal of de absolute waarde van de tweezijdige rest kleiner dan of gelijk aan de meetfout 
    for deler in delers_om_te_testen:
        if abs(bepaal_rest_tweezijdig(huidig_object,deler))<=meetfout:
            #zo ja, dan voegen we dit getal toe aan de lijst met geschikte getallen voor de volgende ronde
            delers_voor_volgende_ronde.append(deler)
    print("voor de volgende ronde zijn de volgende delers over")
    print(delers_voor_volgende_ronde)
    #stel de lijst voor de volgende ronden als de lijst van de huidge ronde, en ga door naar de volgende ronde.
    delers_om_te_testen=delers_voor_volgende_ronde


geldige_delers=delers_om_te_testen
print(f"alle mogelijke delers voor de gewichten {gewichten_sorted} zijn\n{geldige_delers}")

waar dan deze uitvoer uitkomt:

Code: Selecteer alles

Object 110
we gaan de volgende waarden testen
[  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108
 109 110 111 112 113 114 115 116 117 118 119 120]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 35, 36, 37, 38, 39, 40, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120]
Object 750
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 35, 36, 37, 38, 39, 40, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 36, 37, 38, 39, 40, 50, 53, 54, 57, 58, 106, 107, 108]
Object 900
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 36, 37, 38, 39, 40, 50, 53, 54, 57, 58, 106, 107, 108]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 36, 39, 50, 53]
Object 1292
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 36, 39, 50, 53]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 30, 36, 39, 50]
Object 1573
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 30, 36, 39, 50]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 25, 27, 28]
Object 1849
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 25, 27, 28]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 25, 28]
Object 2058
we gaan de volgende waarden testen
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 25, 28]
voor de volgende ronde zijn de volgende delers over
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 25]
alle mogelijke delers voor de gewichten [110, 750, 900, 1292, 1573, 1849, 2058] zijn
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 25]

En de conclusie is dus (bij de gegeven meetfout van 10):

alle mogelijke delers voor de gewichten [110, 750, 900, 1292, 1573, 1849, 2058] zijn
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 25]

Nu is de vraag hoe je gaat wegen en welke waarde je daaruit kiest.

En daar zijn bijvoorbeeld deze methoden voor:

Code: Selecteer alles

import pandas as pd
df=pd.DataFrame(columns=gewichten_sorted,index=geldige_delers)
for gewicht in gewichten_sorted:
    for deler in geldige_delers:
        df.loc[deler,gewicht]=float(bepaal_rest_tweezijdig(gewicht,deler))
print(df)

print("SR = De som van de resten")
print("SAR = De som van de abolute waarden van de resten")
print("STD = De standaarddeviatie van de resten")
print("STD/dlr = De standaarddeviatie van de resten gedeeld door de wortel van grootste deler")

df['SR']=df.sum(axis=1)
df['SAR']=df.abs().sum(axis=1)
df['STD']=df.std(axis=1)
df['STD/dlr']=df.std(axis=1)/df.index
print(df)

met deze tabel als resultaat

Code: Selecteer alles

SR = De som van de resten
SAR = De som van de abolute waarden van de resten
STD = De standaarddeviatie van de resten
STD/dlr = De standaarddeviatie van de resten gedeeld door de wortel van grootste deler
     110   750  900  1292 1573 1849 2058    SR   SAR        STD   STD/dlr
1    0.0   0.0  0.0   0.0  0.0  0.0  0.0   0.0   0.0   0.000000  0.000000
2    0.0   0.0  0.0   0.0  1.0  1.0  0.0   2.0   4.0   1.364225  0.647479
3   -1.0   0.0  0.0  -1.0  1.0  1.0  0.0   0.0   4.0   1.509231  0.487405
4    2.0   2.0  0.0   0.0  1.0  1.0  2.0   8.0  16.0   5.246692  1.243863
5    0.0   0.0  0.0   2.0 -2.0 -1.0 -2.0  -3.0  10.0   3.876568  0.762521
6    2.0   0.0  0.0   2.0  1.0  1.0  0.0   6.0  12.0   3.968627  0.627373
7   -2.0   1.0 -3.0  -3.0 -2.0  1.0  0.0  -8.0  20.0   7.828012  1.105836
8   -2.0  -2.0  4.0   4.0 -3.0  1.0  2.0   4.0  22.0   7.533260  0.903192
9    2.0   3.0  0.0  -4.0 -2.0  4.0 -3.0   0.0  18.0   6.576473  0.707446
10   0.0   0.0  0.0   2.0  3.0 -1.0 -2.0   2.0  10.0   3.539460  0.339550
11   0.0   2.0 -2.0   5.0  0.0  1.0  1.0   7.0  18.0   6.064468  0.524765
12   2.0   6.0  0.0  -4.0  1.0  1.0  6.0  12.0  32.0  10.686180  0.847787
13   6.0  -4.0  3.0   5.0  0.0  3.0  4.0  17.0  42.0  13.794121  1.008830
14  -2.0  -6.0  4.0   4.0  5.0  1.0  0.0   6.0  28.0   9.619136  0.658247
15   5.0   0.0  0.0   2.0 -2.0  4.0  3.0  12.0  28.0   9.257129  0.586452
16  -2.0  -2.0  4.0  -4.0  5.0 -7.0 -6.0 -12.0  42.0  15.898113  0.976246
17   8.0   2.0 -1.0   0.0 -8.0 -4.0  1.0  -2.0  26.0   9.850268  0.563392
18   2.0  -6.0  0.0  -4.0  7.0 -5.0  6.0   0.0  30.0  10.988630  0.591070
19  -4.0   9.0  7.0   0.0 -4.0  6.0  6.0  20.0  56.0  18.527007  0.928600
20  10.0  10.0  0.0  -8.0 -7.0  9.0 -2.0  12.0  58.0  19.871112  0.952058
21   5.0  -6.0 -3.0 -10.0 -2.0  1.0  0.0 -15.0  42.0  16.385970  0.769788
25  10.0   0.0  0.0  -8.0 -2.0 -1.0  8.0   7.0  36.0  12.748638  0.489315

En dan kan je bijvoorbeeld kiezen voor:
25 = (obv index) Het grootste geldige getal
18 = (obv SR) Het grootste getal waarbij de gemiddelde meetfout exact 0 is
1 = (obv SAR) Het grootste getal waarbij de meetfout overal 0 is
2 = (obv STD) Het getal >1 waarbij de standaardafwijking van de meetfout het kleinste is
10 = (obv STD/dlr) het getal >1 waarbij de standaardafwijking minimaal is ten opzicht van het getal zelf.

CoenCo schreef: ↑zo 03 nov 2024, 13:15 En daar zijn bijvoorbeeld deze methoden voor:

Code: Selecteer alles

import pandas as pd
df=pd.DataFrame(columns=gewichten_sorted,index=geldige_delers)
for gewicht in gewichten_sorted:
    for deler in geldige_delers:
        df.loc[deler,gewicht]=float(bepaal_rest_tweezijdig(gewicht,deler))
print(df)

print("SR = De som van de resten")
print("SAR = De som van de abolute waarden van de resten")
print("STD = De standaarddeviatie van de resten")
print("STD/dlr = De standaarddeviatie van de resten gedeeld door de wortel van grootste deler")

df['SR']=df.sum(axis=1)
df['SAR']=df.abs().sum(axis=1)
df['STD']=df.std(axis=1)
df['STD/dlr']=df.std(axis=1)/df.index
print(df)

met deze tabel als resultaat

Code: Selecteer alles

SR = De som van de resten
SAR = De som van de abolute waarden van de resten
STD = De standaarddeviatie van de resten
STD/dlr = De standaarddeviatie van de resten gedeeld door de wortel van grootste deler
     110   750  900  1292 1573 1849 2058    SR   SAR        STD   STD/dlr
1    0.0   0.0  0.0   0.0  0.0  0.0  0.0   0.0   0.0   0.000000  0.000000
2    0.0   0.0  0.0   0.0  1.0  1.0  0.0   2.0   4.0   1.364225  0.647479
3   -1.0   0.0  0.0  -1.0  1.0  1.0  0.0   0.0   4.0   1.509231  0.487405
4    2.0   2.0  0.0   0.0  1.0  1.0  2.0   8.0  16.0   5.246692  1.243863
5    0.0   0.0  0.0   2.0 -2.0 -1.0 -2.0  -3.0  10.0   3.876568  0.762521
6    2.0   0.0  0.0   2.0  1.0  1.0  0.0   6.0  12.0   3.968627  0.627373
7   -2.0   1.0 -3.0  -3.0 -2.0  1.0  0.0  -8.0  20.0   7.828012  1.105836
8   -2.0  -2.0  4.0   4.0 -3.0  1.0  2.0   4.0  22.0   7.533260  0.903192
9    2.0   3.0  0.0  -4.0 -2.0  4.0 -3.0   0.0  18.0   6.576473  0.707446
10   0.0   0.0  0.0   2.0  3.0 -1.0 -2.0   2.0  10.0   3.539460  0.339550
11   0.0   2.0 -2.0   5.0  0.0  1.0  1.0   7.0  18.0   6.064468  0.524765
12   2.0   6.0  0.0  -4.0  1.0  1.0  6.0  12.0  32.0  10.686180  0.847787
13   6.0  -4.0  3.0   5.0  0.0  3.0  4.0  17.0  42.0  13.794121  1.008830
14  -2.0  -6.0  4.0   4.0  5.0  1.0  0.0   6.0  28.0   9.619136  0.658247
15   5.0   0.0  0.0   2.0 -2.0  4.0  3.0  12.0  28.0   9.257129  0.586452
16  -2.0  -2.0  4.0  -4.0  5.0 -7.0 -6.0 -12.0  42.0  15.898113  0.976246
17   8.0   2.0 -1.0   0.0 -8.0 -4.0  1.0  -2.0  26.0   9.850268  0.563392
18   2.0  -6.0  0.0  -4.0  7.0 -5.0  6.0   0.0  30.0  10.988630  0.591070
19  -4.0   9.0  7.0   0.0 -4.0  6.0  6.0  20.0  56.0  18.527007  0.928600
20  10.0  10.0  0.0  -8.0 -7.0  9.0 -2.0  12.0  58.0  19.871112  0.952058
21   5.0  -6.0 -3.0 -10.0 -2.0  1.0  0.0 -15.0  42.0  16.385970  0.769788
25  10.0   0.0  0.0  -8.0 -2.0 -1.0  8.0   7.0  36.0  12.748638  0.489315

En dan kan je bijvoorbeeld kiezen voor:
25 = (obv index) Het grootste geldige getal
18 = (obv SR) Het grootste getal waarbij de gemiddelde meetfout exact 0 is
1 = (obv SAR) Het grootste getal waarbij de meetfout overal 0 is
2 = (obv STD) Het getal >1 waarbij de standaardafwijking van de meetfout het kleinste is
10 = (obv STD/dlr) het getal >1 waarbij de standaardafwijking minimaal is ten opzicht van het getal zelf.

In de vorige post gaat iets mis. In de berekening van een nieuwe kolom worden alle bestaande kolommen meegenomen, dus ook die van sr, sar, std…

Leuk vraagstuk! Ik neem aan dat dit naar aanleiding van de eerdere vraag was hoe de elektrische lading van een elektron is vastgesteld?

Je gekozen waarden zijn 750, 900, 110, 1292, 1573, 1849 en 2058. Die 110 is een outlier. Is dit daadwerkelijk wat je bedoelde, of is dit een typfout?

Ik zou zelf een histogram maken van alle mogelijke eenheidsgewichten, en de relatieve fout bepalen van de meetwaarden gegeven die eenheidsgewichten. De minima zijn dan goede kandidaten om als eenheidsgewicht in aanmerking te komen. Natuurlijk zullen waarden als 1 en 2 daar beter op scoren, daarom denk ik dat het fair is om een minimum eenheidsgewicht te definiëren die in de grootte orde van de meetnauwkeurigheid ligt.

Als ik je voorbeeld neem, maar dan met 1100 i.p.v. 110, dan kom ik op een histogram als hieronder. Ik zou dan zeggen dat het gewicht van een bouwblokje 68 gram is. Als 110 geen typfout is, dan kom ik nog steeds op 68 gram uit als beste optie, maar met een minder duidelijke drop.

Dit is de code die ik gebruikt heb om dit te genereren.

Code: Selecteer alles

import matplotlib.pyplot as plt
from math import sqrt

COMPOUNDS = [750, 900, 1100, 1292, 1573, 1849, 2058]


def find_error(block_weight):
    error = 0
    for compound in COMPOUNDS:
        error += (compound % block_weight) ** 2
    return sqrt(error / len(COMPOUNDS))


def analyze_block_weights():
    result = {}
    for block_weight in range(20, 101):
        error = find_error(block_weight)
        result[block_weight] = error
        print(f"Block weight: {block_weight}, error: {error:.2f}")
    return result


def plot_errors(errors):
    block_weights = list(errors.keys())
    error_values = list(errors.values())

    plt.figure(figsize=(10, 5))
    plt.bar(block_weights, error_values, color='blue')
    plt.xlabel('Block Weight')
    plt.ylabel('Error')
    plt.title('Error per Block Weight')
    plt.savefig('error_per_block_weight.png')
    plt.show()


if __name__ == '__main__':
    error_per_block_weight = analyze_block_weights()
    plot_errors(error_per_block_weight)

Voor mij is de opgave onduidelijk.
Bedoel je dat ieder van de 7 objecten gebouwd wordt met 1 soort steentjes of worden daarvoor meer soorten gebruikt?
In het eerste geval is de oplossing natuurlijk simpel.
Dan is jouw vraag naar de meest waarschijnlijke massa van de steentjes natuurlijk triviaal omdat je die reeds opnoemde.

Wellicht geef je de massa's van de 7 objecten, maar dan is de vraag (en item titel "Massa van bouwsteentjes") misleidend omdat die "Massa van objecten" moest zijn.
In dat geval zoek je eerst de grootste gemene deler om te weten hoeveel (groepjes van) steentjes in ieder object gebruikt werden.
Die is 1, want 1849 = 43² dus enkel deelbaar door priemgetal 43, terwijl dat o.a. geen deler is van 110.
Alle steentjes wegen dan 1 gram (en kunnen zeker geen afwijking hebben van 10 gram).

Ik bedacht me nog dat het misschien eerlijker is om niet naar de absolute fout te kijken, maar naar de relatieve fout t.o.v. het eenheidsgewicht. In dat geval komt m=68 duidelijk als minimum uit de bus.

Gewijzigde code: het delen door block_weight van de error in de functie find_error().

Code: Selecteer alles

def find_error(block_weight):
    error = 0
    for compound in COMPOUNDS:
        error += ((compound % block_weight) / block_weight) ** 2
    return sqrt(error / len(COMPOUNDS))

physicalattraction schreef: ↑do 07 nov 2024, 10:58 Ik bedacht me nog dat het misschien eerlijker is om niet naar de absolute fout te kijken, maar naar de relatieve fout t.o.v. het eenheidsgewicht. In dat geval komt m=68 duidelijk als minimum uit de bus.

error_per_block_weight.png

Gewijzigde code: het delen door block_weight van de error in de functie find_error().
Code: Selecteer alles
def find_error(block_weight):
    error = 0
    for compound in COMPOUNDS:
        error += ((compound % block_weight) / block_weight) ** 2
    return sqrt(error / len(COMPOUNDS))

68 voldoet niet aan de manier waarop ik de vraagstelling interpreteer.

Ik ga er van uit dat de fout van max 10gram de meetfout van het totaalgewicht is.
Voor het samengestelde gewicht van 900 gram, kan de werkelijke massa dus 890 t/m 910 zijn.
Als het kleinste blokje een massa van 68 zou hebben, dan:
13x68=884 ==> voldoet niet want <890
14x68=952 ==> voldoet niet want >910

Ik heb het inderdaad anders opgevat. Ik zie die 10 gram meer als een maat voor de meetonnauwkeurigheid, en zocht naar de waarde die statistisch gezien de grootste kans heeft om de juiste waarde te zijn.

jazzer schreef: ↑wo 06 nov 2024, 14:10 Voor mij is de opgave onduidelijk.
Bedoel je dat ieder van de 7 objecten gebouwd wordt met 1 soort steentjes of worden daarvoor meer soorten gebruikt?
In het eerste geval is de oplossing natuurlijk simpel.

Slechts één soort steentjes. Simpel?
De marge is per meting genoemd.

(1) Vermits je een marge hebt van 20 g kan je van iedere hoeveelheid bouwstenen zeker een 21-voud maken.
(2) Omdat het kleinste object maximaal 120 g kan wegen, tracht je gemeenschappelijke delers tot 120 te vinden.
(3) Eerst onderzoek je of alle gegeven gewichten (met marge) deelbaar zijn door 120.
Indien ja is dat de meest waarschijnlijke massa M van de steentjes.
(4) Daarna procedure (3) voor M=119, ... indien nee voor 118, ... enzovoort tot eventueel 22. Indien nog altijd niet is M=21.
(5) De procedure (3) betekent dat je achtereenvolgens 750, 900, 110, 1292, 1573, 1849 en 2058 deelt door de M van dat ogenblik en telkens de rest R bepaalt.
Eerst verminder je R met 10 en kijkt of dat groter is dan 0, indien neen voldoet het actuele object, anders kijk je of R+10 kleiner is dan M. Indien dat zo is voldoet het actuele object niet en ga je meteen naar (4).
Anders volgend object zo testen, eventueel tot ook de 2058 beantwoordt. De oplossing is dan gevonden.

sciencetalk

Massa van bouwsteentjes

Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes

Re: Massa van bouwsteentjes