Print "~n~n"
Print "eindimensionale arrays erstellen"
Print "--------------------------------"

' man kann ein leeres array ohne wertezuweisung erstellen
Local x:Int[]

Print "~nlocal x:int[]"
Print "~n Sizeof(x) = " + SizeOf(x) +" (bytes)" ' ausgabe = 0
Print " Len(x)    = " + Len(x) +" (anzahl)"   ' ausgabe = 0

' man kann auch nur angeben wie goss das array sein soll ohne wertezuweisung
' es wird allen feldern automatisch der wert 0 zugewiesen
Local y:Int[10] ' b[0..9]

Print "~nlocal y:int[10]"
Print "~n Sizeof(y) = " + SizeOf(y) +" (bytes)" ' ausgabe = 10
Print " Len(y)    = " + Len(y) +" (anzahl)"   ' ausgabe = 40, da 10 * 4 bytes = 40 bytes sind

' auch kann man ein leerem array nur die werte zuweisen
' die groesse wird automatisch zugewiesen
Local z:Int[] = [1,2,3]

Print "~nlocal z:int[] = [1,2,3]"
Print "~n Sizeof(z) = " + SizeOf(z) +" (bytes)" ' ausgabe = 3
Print " Len(z)    = " + Len(z) +" (anzahl)"   ' ausgabe = 12, da 3 * 4 bytes = 12 bytes sind


Print "~n~n"
Print "eindimensionale arrays loeschen"
Print "-------------------------------"

' löschen tun wir einfach zur array = null
' natürlich darf man flushmem() nicht vergessen
' dies bewirkt dass alle null-zeiger geloescht werden
x = Null
y = Null
z = Null

FlushMem()

' testen wir:
Print "~nx = null"
Print "y = null"
Print "z = null"
Print "flushmem()"

Print "~nsizeof(x) = "+ SizeOf(x) ' ausgabe = 0
Print "sizeof(y) = "+ SizeOf(y)   ' ausgabe = 0
Print "sizeof(z) = "+ SizeOf(z)   ' ausgabe = 0



Print "~n~n"
Print "eindimensionale arrays laenge ermitteln"
Print "---------------------------------------"

Local a:Int[] = [0,1,2,3,4,5,6,7]

' um die groesse bzw anzahl oder laenge zu bestimmen
' kann man "array.length" verwenden
Print "~nlocal a:int[] = [0,1,2,3,4,5,6,7]"
Print "~n laenge oder anzahl von a.length     : " + a.length ' ausgabe = 8

' oder "Len(array)"
Print " oder: laenge oder anzahl von len(a) : " + Len(a)   ' ausgabe = 8


Print "~n~n"
Print "eindimensionale arrays anzahl belegter bytes ermitteln"
Print "------------------------------------------------------"

' dies geht mit sizeof()
Print "~nlocal a:int[] = [0,1,2,3,4,5,6,7]"
Print "~n sizeof(a) = "+ SizeOf(a) ' ausgabe = 32, da 8 * 4 bytes = 32 sind



Print "~n~n"
Print "eindimensionale arrays redimensionieren"
Print "---------------------------------------"

' bei einer werteuebergabe wird das array auch redimensioniert
a = [0,1,2,3,4,5,6,7] ' a[0..7]

' gleich mal testen
Print "~nredimensionieren durch werteuebergabe:"
Print "~n a = [0,1,2,3,4,5,6,7]"
Print "~n laenge oder anzahl von len(a)       : " + Len(a) ' ausgabe = 8

' wen wir die neue groesse des array kennen so kann man das array redimensionieren
' der inhalt von vorher bleibt dabei erhalten
a = a[..16] ' a[0..15]

' gleich mal die groesse prüfen
Print "~nredimensionieren:"
Print "~n a = a[..16]"
Print "~n neu laenge oder anzahl von len(a)   : " + Len(a) ' ausgabe = 16

' wen wir später mit types arbeiten, so kann man ein array
' auch durch new redimensionieren, wobei der inhalt geloescht wird
a = New Int[10]

' testen wir gleich mal:
Print "~nredimensionieren durch new"
Print "~n a = new int[10]"
Print "~n laenge oder anzahl von len(a)       : " + Len(a) ' ausgabe = 10


Print "~n~n"
Print "eindimensionale arrays bereiche kopieren"
Print "----------------------------------------"

a = [0,1,2,3,4,5,6,7]

' man kann das ganze array kopieren
' dazu erstellen wir zuerst ein neues array
Local b:Int[]

' wen man das von 0 bis 5 kopieren will
b = a[..5]

' testen wir:
Print "~nvon anfang bis gewolltes feld:"
Print "~n b = a[..5]"
Print "~n len(b) = "+ Len(b) ' ausgabe = 5

' dies geht auch explezit:
b = a[0..5]

' testen wir
Print "~nexplizit von 0 bis gewolltes feld:"
Print "~n b = a[0..5]"
Print "~n len(b) = "+ Len(b) ' ausgabe = 5

' oder von irgendwo in der mitte bis zum ende
b = a[5..]

' testen wir:
Print "~nvon 5 bis ende:"
Print "~n b = a[5..]"
Print "~n len(b) = "+ Len(b) ' ausgabe = 3

' oder auch wieder explizit, wobei ich dies vermeiden würde
' da es bei einer zu grossen angabe zu einem ueberlauf kommen wuerde:
Print "~nvon 5 bis 7:"
Print "~n b = a[5..7]"
Print "~n len(b) = "+ Len(b) ' ausgabe = 3


Print "~n~n"
Print "eindimensionale arrays, werte mit verschiedenen schleifen-typen abrufen"
Print "-----------------------------------------------------------------------"

' gleich mal kontollieren welche Elemente uebernommen wurden
' dies machen wir durch "for var = eachin array"
' hier wird der wert vom "array" der variabel "i" uebergeben !!!
Print "~nfor var = eachin array~n"
For i = EachIn a
   Print " var = "+ i ' Ausgabe: 2,3,4
Next

' die ausgabe kann auch anders erfolgen
' mit "for var = 0 to len(array) -1"
' man darf aber nicht vergessen:
' die laenge des array mit -1 ab zuziehn
' da wir sonst einen ueberlauf haben!!!
' dies ist aber nur eine normale for..to..next schleife
' also muessen wir das array noch aufloesen: array[i]
Print "~nfor var = 0 to len(array) -1~n"
For i = 0 To Len(a) -1
   Print " a["+i+"] = "+ a[i] ' Ausgabe: a[0] = 2, a[1] = 3, a[2] = 4
Next
Print

' es geht aber noch besser, mit until !!!
' "for var = 0 until len(arry)
' hier wüssen wir die laenge nicht korrigieren
' dies ist auch eine normale for..until..next schleife
' auch hier muessen wir das array aufloesen: array[i]
Print "~nfor var = 0 until len(array)~n"
For i = 0 Until Len(a)
   Print " a["+i+"] = "+ a[i] ' Ausgabe: a[0] = 2, a[1] = 3, a[2] = 4
Next


Print "~n~n"
Print "eindimensionale arrays sortieren"
Print "--------------------------------"

' ein array sind praktisch gleich wie ein strings
' auch ein array kann man sortieren
a = [5,3,1,4,0,5]

Print "~na = [5,3,1,4,0,5]"

' unsortiert:
Print "~nunsortiert:~n"
For i = EachIn a
   Print " var = " + i
Next

' nun sortieren wir nach groesse
a.sort

Print "~nsortiert:~n"
For i = EachIn a
   Print " var = " + i
Next

' man auch string in einem array alphapetisch sortieren:
Local s:String[] = ["eins","zwei","drei","vier","fuenf"]

Print "~nLocal s:String [] = [~qeins~q,~qzwei~q,~qdrei~q,~qvier~q,~qfuenf~q,]"

Print "~nunsortiert:~n"
For k:String = EachIn s
   Print " var = " + k
Next

' nun sortieren wir die strings aufsteigend
' von a bis z
s.sort 'true

Print "~naufsteigend sortiert (a-z):"
Print "~n array.sort [true]~n"
For k:String = EachIn s
   Print " var = " + k
Next

' wir können die strings auch absteigend sortieren
' also von z bis a, dies machen wir indem ein fals hinter sort steht
s.sort False

Print "~nabsteigend sortiert (z-a):"
Print "~n array.sort false~n"
For k:String = EachIn s
   Print " var = " + k
Next