Rekursion

[Codusa]

Hallo,
Also mal angenommen man will aus den Zeichen von 0-9 und a-z alle möglichen Strings generieren.
Man hat 36 Zeichen. Die Länge des Strings soll aber Variabel sein. Und Strings wie "aaaaaaa" oder "aaabbbb" sollen möglich sein
Wie realisiert man das in PB?
Natürlich per Rekursion, aber da hakts bei mir dann.

Code: Alles auswählen

Procedure proc()
  Static count,ebn
  ebn+1
  If ebn <= 0
    ProcedureReturn count
  Else
    
    For i = 0 To 35
      count + 1
;       Debug ebn
      If ebn < ListSize(word())
        ProcedureReturn proc()
      Else
        ebn-1
      EndIf
      
      
    Next
    ebn-1
    ProcedureReturn proc()
  EndIf
EndProcedure

Gibt natürlich einen Stackoverflow weil die Abbruchbedingung nicht erfüllt werden kann, ich scheitere irgendwie daran folgendes Rekursiv umzusetzen:

Code: Alles auswählen

for i=0 to 35
  for k=0 to 35
    debug str(i)+"|"+str(k)
  next
next

[ts-soft]

Hallo,
Also mal angenommen man will aus den Zeichen von 0-9 und a-z alle möglichen Strings generieren.
Man hat 36 Zeichen. Die Länge des Strings soll aber Variabel sein. Und Strings wie "aaaaaaa" oder "aaabbbb" sollen möglich sein
Wie realisiert man das in PB?
Natürlich per Rekursion, aber da hakts bei mir dann.

Wer nen Teufel tun und eine Rekursion nutzen

Code: Alles auswählen

EnableExplicit

Procedure.s Proc(length)
  Protected result.s, i
  
  Dim values.c(35)
  For i = 0 To 9
    values(i) = i + 48
  Next
  For i = 10 To 35
    values(i) = i + 87
  Next  
  For i = 1 To length
    result + Chr(values(Random(35)))
  Next
  
  ProcedureReturn result
EndProcedure

Debug Proc(1)
Debug Proc(10)

Ich hoffe das macht was Du möchtest, auch wenn es sich nicht rekursiert

[NicTheQuick]

Ich mag Rekursion nicht so, deswegen hier eine iterative Variante:

Code: Alles auswählen

Procedure Words(maxLen.i)
	Protected Dim *word.Character(maxLen + 1)
	Protected Dim result.c(maxLen + 1)
	Protected i.i
	
	*word(0) = ?Chars
	result(0) = *word(0)\c
	
	While (Not *word(maxLen))
		Debug PeekS(@result(0))
		*word(0) + SizeOf(Character)
		If (*word(0)\c = 0)
			i = 0
			While (*word(i)\c = 0)
				If (Not *word(i + 1))
					*word(i + 1) = ?Chars
				Else
					*word(i + 1) + SizeOf(Character)
				EndIf
				result(i + 1) = *word(i + 1)\c
				*word(i) = ?Chars
				result(i) = *word(i)\c
				i + 1
			Wend
		Else
			result(0) = *word(0)\c
		EndIf
	Wend
	
EndProcedure

DataSection
	Chars:
		Data.s "abcdefghijklmnopqrstuvwxyz0123456789"
EndDataSection

Words(2)

[Codusa]

Ich hoffe das macht was Du möchtest, auch wenn es sich nicht rekursiert

Nicht wirklich
Es sollen alle möglichen Kombinationen durchgegangen werden, wie bei NicTheQuick (Danke übrigens!)
Bei dir wird ja einfach ein zufälliges Zeichen angehängt...
Trotzdem Danke, dass du dich zu so später Stunde noch bemüht hast!

[ts-soft]

Dann hab ich das doch etwas missverstanden. Du brauchst einen Brute-Force algorhytmus

[Codusa]

Dann hab ich das doch etwas missverstanden. Du brauchst einen Brute-Force algorhytmus

Brauchen nicht unbedingt... Aber ich wollte sehen, wie so einer aussehen kann. Und wie schnell er werden kann.

@NicTheQuick
Wie bekomme ich eine Mindestlänge rein?

[Kiffi]

Ich mag Rekursion nicht so

Um Rekursionen zu mögen, muss man zunächst Rekursionen mögen.

[Lord]

Ich mag Rekursion nicht so

Um Rekursionen zu mögen, muss man zunächst Rekursionen mögen.

...und da er keine Rekursion mag, mag er keine Rekursion.

[Mr.L]

Ich mag Rekursion
Hier meine rekursive Variante

Code: Alles auswählen

#MAX_WORDLEN	= 2
Global Chars$	= "abcdefghijklmnopqrstuvwxyz0123456789"
Global Word$	= Space(#MAX_WORDLEN + 1)
Procedure GenerateWords(*word.Byte)	
	If *word\b = 0 : ProcedureReturn : EndIf
	Debug Word$
	*c.Byte = @chars$
	While *c\b
		*word\b = *c\b
		GenerateWords(*word + 1)		
		*c + 1
	Wend
	*word\b = ' '
EndProcedure
GenerateWords(@Word$)

[STARGÅTE]

@Mr.L:
Bitte nutze immer Character (c) als Struktur für Zeichen.
Nur dann ist sichergestellt, dass der Code auch unter Unicode läuft und zum anderen sind die Werte unsigned.
Nicht alle haben als Standard Kompilierungsformat Ascii eingestellt.
Sachen wie "*word + 1" müssten dann auch zu "*word + SizeOf(Character)" umgeschreiben werden.