array op nummeren?

Q1 is de hele array en Q1 + 1 dat kan niet.

Je kan wel een 2 dimensionaal array maken

Q[][] =  { [3,4,5,6,7,8], [4,5,6,7,8,0,0] , [5,6,7,8,9,0]} 

ik twijfel nu even of dit de juiste manier is van initialiseren maar dat kan je opzoeken

Dan is
Q[1][4] = 7

int teller = 1
if Q[teller][4] == 7
  if Q[teller + 1][2] == 6
    top = 1

PS het kan op precies andersom zijn en dat
Q[4][1] = 7 maar daar kom je snel genoeg achter

ik kan niet zomaar omzetten naar een 2D array.

Stop het in één array en gebruik offsets.

Op woensdag 20 november 2024 19:23:19 schreef JoWi:
Stop het in één array en gebruik offsets.

dan kan ik het net zo goed in een 2D array stoppen.

(Q1+1)[2]

Dat zou dan eerder zoiets zijn

temp = (Q + ('1' + 1))
temp[2]

Maar dat gaat volgens mij nooit zo werken.

dan kan ik het net zo goed in een 2D array stoppen.

Dat lijkt mij toch de enige weg. Je kan de 2D array ook tijdelijk maken. Dus eerste de 2D array vullen uit de 3 losse arrays dan je bewerking erop loslaten en dan alles weer terug naar de 3 losse array's

ik had echt gedacht (en gehoopt) dat het een stuk simpeler zou zijn

Zoiets?

Q1 [3,4,5,6,7,8]
Q2 [4,5,6,7,8]
Q3 [5,6,7,8,9,]
Qs [&Q1,&Q2,&Q3]

if Q1[4] == 7:
    if Qs[0+1] == 6:
        TOP = 1

Wel link natuurlijk, als je Qs[3] vraagt… (of een andere buiten bereik).

Waarom kan het geen 2d array zijn? Wat is eigenlijk het onderliggende originele probleem, is dat niet handiger op te lossen?

Ik vraag me af wat voor array Qs dan is geworden 1D of?

 if Qs[0+1] == 6:

Je refereert dan wel naar wat Q2 zou moeten zijn maar dat is dan de hele array

 if Qs[0+1][2] == 6:

Zoiets?
Q1 [3,4,5,6,7,8]
Q2 [4,5,6,7,8]
Q3 [5,6,7,8,9,]

Maak een array van pointers

int* arrays[] = {Q1, Q2, Q3};

De toegang tot de data is dan

arrays[i][j];

[Bericht gewijzigd door MGP op woensdag 20 november 2024 21:04:22 (14%)]

Zeker python?

Wat wil je nu eigenlijk? Want ik snap er niks van.

Waarschijnlijk wil je iets van een matrix achtige berekening.

Geef eens een voorbeeld wat erin en eruit moet komen.

Op woensdag 20 november 2024 18:53:54 schreef benleentje:
Q1 is de hele array en Q1 + 1 dat kan niet.

Je kan wel een 2 dimensionaal array maken

Q[][] =  { [3,4,5,6,7,8], [4,5,6,7,8,0,0] , [5,6,7,8,9,0]} 

ik twijfel nu even of dit de juiste manier is van initialiseren maar dat kan je opzoeken

Dan is
Q[1][4] = 7

niet dat is 8

initialiseren doe je zo:

Q[][] =  { 
{3,4,5,6,7,8},
{4,5,6,7,8,0},
{5,6,7,8,9,0}
}

ik twijfel even of je bij een 2 dimensionaal array beide indexen ongedefinieerd qua size kan laten, ik meen van niet elke index moet hier ook gelijk aantal items hebben.
Het is vast allemaal weer top secret, iets met stappen motors, grote scannende XY tafel.

Ik zou idd ook gewoon een 2 dimensionaal array maken, en ander een array met pointers naar de andere arrays, dan kun je er ook makkelijk doorheen itereren. Maar Trix zit tegenwoordig in micro python volgens mij, daar heb je geen pointers denk ik, maar is vast hetzelfde mogelijk

Op woensdag 20 november 2024 22:29:55 schreef henri62:
Zeker python?
Waarschijnlijk wil je iets van een matrix achtige berekening.

yep

ik wil niet echt iets berekenen, ik wil meer dingen vinden in een matrix.
het is al vaker gebleken dat het lastig is uit te leggen, dus ik heb in excel geprobeerd om het samen te vatten in een plaatje, onder het motto: 1 plaatje zegt vaak meer dan 100 woorden
dit plaatje is qua rijen en kollomen een voorbeeld, dit word straks:
1e test opstelling 120 rijen en 230 kollomen daar test ik nu mee
2e test opstelling 288 rijen en 230 kollomen

even wat toevoegen om een volledig beeld te schetsen:

die letter P heeft mooi strakke lijnen, in werkelijkheid zijn die lijnen een beetje grilliger (is dat nederlands )

ik ben nu zover dat ik de 2 buitenste vertikale lijnen kan vinden,
voor de 1e lijn "scan" ik van links naar rechts de bytes tot ik een byte tegen kom die ongelijk = aan 0 (!=0), dan bekijk ik of die byte 3 aaneengesloten bits (pixels) heeft met een "1" zo ja,
bekijk ik of de byte rechts v/d gevonden byte dezelfde bits een "1" hebben zo ja,
dan bekijk ik die byte daarnaast ook op dezelfde manier.
dan heb ik dus een blok gevonden van 3x3 bits (pixels), en die keur ik dan goed om de 1e vertikale lijn te benoemen.
dit om losse "1" pixels "weg te filteren"

de bovenste en de onderste lijn is lastiger
daar wil ik ook een blok hebben van 3x3 pixels, alleen hier kan je 1 byte "overschrijden" omdat wanneer b.v. bit 0 "1" is je in de byte eronder ook bit 6 & 7 moet bekijken.

dus om dat byte overschrijdende checken te voorkomen wou ik vanuit de byte arrays een array vullen met alleen "1" en "0" word dan 230x8 = 1840 bits
alleen dat is binnen python niet zo heel eenvoudig (voor mij dan ),
ik had dat voor mekaar, alleen bleek dat zoveel geheugen in te nemen dat ik daar mee in de problemen kwam. ik wist (volgens mij) wel hoe dat kwam, maar niet hoe dat op te lossen.

dat zoeken van de edges heb ik allemaal al eens werkend gehad op een atmega2560 (dacht ik) met C. maar blijkbaar kan C beter omgaan met bit bewerkingen dan python. waarmee ik niet zeg dat het in python niet kan.

Je kunt een nieuwe array aanmaken met de bestaande arrays als elementen. Dan kun je indexen op de nieuwe array.

#!/bin/python3

Q1 = [ 1,2,3,4,5,6 ]
Q2 = [ 4,2,3,4,7,6 ]
Q3 = [ 3,4,5,6,7,8 ]

Q  = [ Q1, Q2, Q3 ]

# Alle elementen printen
for x in Q:
   for v in x:
      print(v)
   print('\n')

# Kan ook zo
for x in range(len(Q)):
   for y in range(len(Q[x])):
      print(Q[x][y])
   print('\n')

Eén array is toch genoeg? Je kunt testen of er een overgang is:

Horizontaal: if array[x] <> array[x-1] then...
Vertikaal: if array[y] <> array [y-230] then...

het is gelukt volgens de methode ven dekees en andere.
ik zit weer op het rechte spoor