1D Array in 2D Array splitten

horphi

Hallo,

ich benutzte diese Funktion zum Arraysplit.

Allerdings benötigt sie sehr viel Zeit. Für 3000 Zeilen (aus einem 1D Array werden ~55 Reihen 2D Array erstellt) ca. 2,5 Minuten...

Kann man den Split noch beschleunigen?

@@ Debug(618) : _StringSplit2D Start!: / Zeit:21:33:08
@@ Debug(644) : _StringSplit2D END!: / Zeit:21:35:29

AutoIt

Func _StringSplit2D(ByRef $sString, $sDelim = "|", $sDelim2 = ";") ; splittet auch ARRAYS
	ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : _StringSplit2D Start!:  ' & ' / Zeit:' & _NowTime() & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
	If IsString($sString) Then
		$aTmp = StringSplit($sString, $sDelim, 2)
	ElseIf IsArray($sString) Then
		If UBound($sString, 0) > 1 Then Return SetError(1)
		$aTmp = $sString
	Else
		Return SetError(1)
	EndIf
	Local $iStart = 0
	If $aTmp[0] = UBound($aTmp) - 1 Then $iStart = 1
	Local $aRet[1][1]
	For $i = $iStart To UBound($aTmp) - 1
		$aSplit = StringSplit($aTmp[$i], $sDelim2, 2)
		If $i = UBound($aRet) - 1 Then
			ReDim $aRet[UBound($aTmp) + 1][UBound($aRet, 2)]
		EndIf
		For $x = 0 To UBound($aSplit) - 1
			If $x = UBound($aRet, 2) - 1 Then
				ReDim $aRet[UBound($aRet)][UBound($aSplit)]
			EndIf
			$aRet[$i + 1][$x] = $aSplit[$x]
		Next
	Next
;~ 	$aRet[0][0] = UBound($aRet) - 1
;~ 	$aRet[0][1] = UBound($aRet, 2)
	ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : _StringSplit2D END!:  ' & ' / Zeit:' & _NowTime() & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
	Return $aRet
EndFunc   ;==>_StringSplit2D

Alles anzeigen

Danke und Gruß,

Horphi

**alpines**

Ich nehme mal stark an, dass dein größter Performanceverlust die dauernden ReDims sind.
Guck dir z.B. mal @AspirinJunkies DynArray UDF an, dort erstellt er Arrays die doppelt / dreifach so groß sind wie benötigt und kennzeichnet im Array wie befüllt es ist.
So kannst du dir die etlichen ReDims sparen und statt beispielsweise 100 ReDims nur eins vornehmen.

**autoiter**

Hallo @horphi,
Ohne von der DynArray UDF abraten zu wollen, will ich nur folgendes zu ReDim schreiben:
Genau wie @alpines es breits geschrieben hat, vermute auch ich hier das Problem.

Beispielhaft für eine deiner Schleifen:
Statt $aRet[1][1] zu deklarieren, würde ich es direkt mit maximalen Größe erstellen (UBound($aTmp).
So muss das Array nicht mehrfach vergrößert werden (Langwieriger Prozess, mit kopieren des vorhandenen Arrays).
Wenn unter Umständen das Zielarray am Ende nicht so groß sein soll, wie die Anzahl der Schleifendurchläufe, dann empfiehlt sich eine Zähler-Variable.
Hier ein Beispiel:

AutoIt

#include <Array.au3>


test()


Func test()
	Local $aArray[4] = [1, 2, 3, 1] ; Die Quelldaten
	Local $iMax = UBound($aArray) ; der Maximalwert
	Local $aResult[$iMax][2] ; Das ZielArray mit Maxiimalgröße
	_ArrayDisplay($aResult)
	Local $iCount = 0 ; Die Zählervariable - erster Wert ist Null für das erste Element im Array
	For $i = 0 To $iMax - 1
		If $aArray[$i] = 1 Then ; Wenn der Wert Eins ist, dann ..
			$aResult[$iCount][0] = $aArray[$i] ; Zuweisung zum Zielarray
			$iCount += 1 ; der Wert wird um Eins erhöht, damit das nächste mal das nächst höhere Element gefüllt wird.
		EndIf
	Next
	ReDim $aResult[$iCount][2] ; Einmaliger ReDim auf die wirklich benötigte Größe
	_ArrayDisplay($aResult)
EndFunc   ;==>test

Alles anzeigen

(Auch habe ich schon Arrays in Größe deklariert, die sicher nicht erreicht wurde. Etwa $aArray[10000][200] und ohne Ubound mit einer Zählervariable (oder zwei, falls zweidimensional und notwendig ) das Array nach der Schleife mit ReDim angepasst.)

**Oscar**

Ich verstehe bei der Aufgabenstellung nicht, wieso überhaupt das ReDim gebraucht wird.
Mit StringSplit die Zeilen splitten, somit kennt man die erste Dimension. Anschließend erstmal eine Zeile nach Spalten splitten und man kennt die zweite Dimension.
Damit kann man das Ausgabe-Array dimensionieren und die Daten dort hineinkopieren.

horphi

Hallo Oscar,

also brauche ich gar kein ReDim?

VG

**Musashi**

Hallo @horphi !
ReDim wird nur benötigt, wenn Du die Größe eines bestehenden Arrays verändern willst (dieser Prozess ist recht zeitintensiv).
Ist Dir die Größe des Arrays bereits bekannt, dann kannst Du es auch gleich 'richtig' dimensionieren.

Gruß Musashi

**Oscar**

Zitat von horphi

also brauche ich gar kein ReDim?

Stell mal eine Beispiel-Datei (muss keine 3000 Zeilen enthalten) zur Verfügung, dann kann ich Dir zeigen, wie das gemeint ist.

**AspirinJunkie**

Eine weitere Möglichkeit wäre erst einmal mit einem Array-In-Array zu arbeiten statt direkt mit einem 2D-Array und erst ganz am Ende daraus das 2D-Array zu erzeugen.
Dann wird deine Funktion ziemlich trivial:

AutoIt

#include <Array.au3>


Global $s_String = BinaryToString(InetRead("https://pastebin.com/raw/w3SgtP9Q"))


$a_Splitted = _StringSplit2D($s_String)
_ArrayDisplay($a_Splitted)




Func _StringSplit2D(ByRef $sString, $sDelim = @CR, $sDelim2 = ",")
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 2)
	For $i = 0 To UBound($a_FirstDim) - 1
		$a_FirstDim[$i] = StringSplit($a_FirstDim[$i], $sDelim2, 2)
	Next
	Return _ArrayAinATo2d($a_FirstDim)
EndFunc   ;==>_StringSplit2D






; #FUNCTION# ======================================================================================
; Name ..........: _ArrayAinATo2d()
; Description ...: Convert a Arrays in Array into a 2D array
; Syntax ........: _ArrayAinATo2d(ByRef $A)
; Parameters ....: $A             - the arrays in array which should be converted
; Return values .: Success: a 2D Array build from the input array
;                  Failure: False
;                     @error = 1: $A is'nt an 1D array
;                            = 2: $A is empty
;                            = 3: first element isn't a array
; Author ........: AspirinJunkie
; =================================================================================================
Func _ArrayAinATo2d(ByRef $A)
	If UBound($A, 0) <> 1 Then Return SetError(1, UBound($A, 0), False)
	Local $N = UBound($A)
	If $N < 1 Then Return SetError(2, $N, False)
	Local $u = UBound($A[0])
	If $u < 1 Then Return SetError(3, $u, False)


	Local $a_Ret[$N][$u]


	For $i = 0 To $N - 1
		Local $t = $A[$i]
		If UBound($t) > $u Then ReDim $a_Ret[$N][UBound($t)]
		For $j = 0 To UBound($t) - 1
			$a_Ret[$i][$j] = $t[$j]
		Next
	Next
	Return $a_Ret
EndFunc   ;==>_ArrayAinATo2d

Alles anzeigen

In einer Funktion kombiniert würde dann so aussehen:

AutoIt

#include <Array.au3>


Global $s_String = BinaryToString(InetRead("https://pastebin.com/raw/w3SgtP9Q"))
Global $a_Splitted = _StringSplit2D($s_String)
_ArrayDisplay($a_Splitted)


Func _StringSplit2D(ByRef $sString, $sDelim = @CRLF, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 3)
	Local $a_Out[UBound($a_FirstDim)][1]
	Local $a_Line, $i_2DMax = 1


	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 3)
		If UBound($a_Line) > $i_2DMax Then
			$i_2DMax = UBound($a_Line)
			ReDim $a_Out[UBound($a_Out)][$i_2DMax]
		EndIf
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
 	Return $a_Out
EndFunc

Alles anzeigen

Ein ReDim würde nur erfolgen wenn eine Zeile mehr Elemente hat als bisherige.
Im konkreten Beispiel also nur ein einziges mal - das ist verkraftbar.

**Oscar**

Zitat von AspirinJunkie

Ein ReDim würde nur erfolgen wenn eine Zeile mehr Elemente hat als bisherige.
Im konkreten Beispiel also nur ein einziges mal - das ist verkraftbar.

Stimmt! So benötigt man nur ein ReDim.
Es geht aber auch ganz ohne ReDim, indem man ein zusätzliches StringSplit einfügt:

AutoIt

Func _NewStringSplit2D(ByRef $sString, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 2)
	Local $a_Line = StringSplit($a_FirstDim[$i_Start], $sDelim2, 2)
	Local $a_Out[UBound($a_FirstDim)][UBound($a_Line)]
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 2)
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_NewStringSplit2D

Alles anzeigen

Das zusätzliche StringSplit ist auch etwas schneller als das ReDim. Wobei sich das erst bei mehreren Durchläufen bemerkbar macht:

AutoIt

#include <Array.au3>


Global $s_String = BinaryToString(InetRead("https://pastebin.com/raw/w3SgtP9Q"))
Global $iTimer = TimerInit()
For $i = 0 To 99
	$a_Splitted = _StringSplit2D($s_String)
Next
ConsoleWrite(TimerDiff($iTimer) & @CR)
_ArrayDisplay($a_Splitted)
Global $iTimer = TimerInit()
For $i = 0 To 99
	$a_Splitted = _NewStringSplit2D($s_String)
Next
ConsoleWrite(TimerDiff($iTimer) & @CR)
_ArrayDisplay($a_Splitted)


Func _StringSplit2D(ByRef $sString, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 2)
	Local $a_Out[UBound($a_FirstDim)][1]
	Local $a_Line, $i_2DMax = 1
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 2)
		If UBound($a_Line) > $i_2DMax Then
			$i_2DMax = UBound($a_Line)
			ReDim $a_Out[UBound($a_Out)][$i_2DMax]
		EndIf
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_StringSplit2D


Func _NewStringSplit2D(ByRef $sString, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 2)
	Local $a_Line = StringSplit($a_FirstDim[$i_Start], $sDelim2, 2)
	Local $a_Out[UBound($a_FirstDim)][UBound($a_Line)]
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 2)
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_NewStringSplit2D

Alles anzeigen

**AspirinJunkie**

Das wäre tastächlich die favorisierte Variante wenn bekannt ist dass alle Zeilen die selbe Anzahl an Delimitern haben.
Ich bin halt auch davon ausgegangen, dass einige Zeilen weniger enthalten können als andere.
Wenn z.B. die erste Zeile nur 5 Elemente hat und alle anderen 7.

Statt dem StringSplit für die Anzahl der Delimiter für die zweite Dimension wäre wahrscheinlich ein StringReplace + @extended die schnellere Variante.

**Oscar**

Zitat von AspirinJunkie

Ich bin halt auch davon ausgegangen, dass einige Zeilen weniger enthalten können als andere.
Wenn z.B. die erste Zeile nur 5 Elemente hat und alle anderen 7.

Ah, ok! Wenn die Daten in der zweiten Dimension eine unterschiedliche Anzahl an Elementen aufweisen, dann lieber so, wie von Dir vorgeschlagen.

Und: ja, StringReplace und @extended ist noch etwas schneller als StringSplit:

AutoIt

Func _NewStringSplit2D(ByRef $sString, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 2)
	Local $tmp = StringReplace($a_FirstDim[$i_Start], $sDelim2, ''), $iSecondDim = @extended + 1
	Local $a_Out[UBound($a_FirstDim)][$iSecondDim] , $a_Line
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 2)
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_NewStringSplit2D

Alles anzeigen

Und es ist auch gar nicht das eine ReDim, was zu der kürzeren Laufzeit führt, sondern das fehlen der If-Anweisung innerhalb der For...Next-Schleife.

**AspirinJunkie**

Na dann gehen wir doch mal ans Finetuning:

Beim StringSplit auch den ENTIRESPLIT-Parameter setzen (also =3) - sollte in dem Fall ca. Faktor 3 schneller sein.
Beim StringReplace den CaseSense-Parameter auf 1 setzen - wird hier nur einmal aufgerufen daher fast egal (könnte dort aber ca. Faktor 20 ausmachen)
Als Ersatzstring bei StringReplace einen String der selben Länge nehmen wie der Suchstring
Die Variable $tmp kann weg
Wer sieht noch was?

**Oscar**

Mit allen Optimierungen (das mit ENTIRESPLIT hat mich überrascht) bei beiden Funktionen, sind sie nahezu gleichauf (120ms weniger bei der New-Variante).
Dafür ist Deine Funktion universeller (wegen automatischer Anpassung der 2. Dimension):

AutoIt

#include <Array.au3>


Global $s_String = BinaryToString(InetRead("https://pastebin.com/raw/w3SgtP9Q"))
Global $iTimer = TimerInit()
For $i = 0 To 99
	$a_Splitted = _StringSplit2D($s_String)
Next
ConsoleWrite(TimerDiff($iTimer) & @CR)
_ArrayDisplay($a_Splitted)
Global $iTimer = TimerInit()
For $i = 0 To 99
	$a_Splitted = _NewStringSplit2D($s_String)
Next
ConsoleWrite(TimerDiff($iTimer) & @CR)
_ArrayDisplay($a_Splitted)


Func _StringSplit2D(ByRef $s_String, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 3)
	Local $a_Out[UBound($a_FirstDim)][1], $a_Line, $i_2DMax = 1
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 3)
		If UBound($a_Line) > $i_2DMax Then
			$i_2DMax = UBound($a_Line)
			ReDim $a_Out[UBound($a_Out)][$i_2DMax]
		EndIf
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_StringSplit2D


Func _NewStringSplit2D(ByRef $s_String, $sDelim = @CR, $sDelim2 = ",", $i_Start = 0)
	Local $a_FirstDim = StringSplit($s_String, $sDelim, 3)
	StringReplace($a_FirstDim[$i_Start], $sDelim2, $sDelim2, 0, 1)
	Local $iSecondDim = @extended + 1, $a_Out[UBound($a_FirstDim)][$iSecondDim], $a_Line
	For $i = $i_Start To UBound($a_FirstDim) - 1
		$a_Line = StringSplit($a_FirstDim[$i], $sDelim2, 3)
		For $j = 0 To UBound($a_Line) - 1
			$a_Out[$i][$j] = $a_Line[$j]
		Next
	Next
	Return $a_Out
EndFunc   ;==>_NewStringSplit2D

Alles anzeigen

Ich denke, dass ich mich geschlagen gebe und Deine Funktion als Gewinner darstelle.

horphi

Sach mal, da bin ich ein paar Stunden auf der Fähre und ihr fangt an hier sowas zu zaubern... WOW.

Vielen Dank.

Die probier ich gleich mal aus.

Viele Grüße,

horphi

horphi

326 ms für den gleichen Input. Vielen DANK!