Hur kan jag enklast skriva ett program som slumpar fram 21 heltal mellan 0 och 100 till en vektor och när slumpningen är klar ska de sist slumpade talen skrivas ut. Slumpningen och utskrtft ska ske i två olika procedurer.

Novisen Arne

<code>
'1 Knapp och 1 ListBox
Option Explicit
Dim rndArray(99) As Long

Private Sub Form_Load()
Randomize
End Sub

Private Sub Command1_Click()
Dim rndNum As Long
Dim i As Long
List1.Clear
Do Until i >= 21
rndNum = Int(Rnd * 99) + 1
If rndArray(rndNum) = 0 Then
rndArray(rndNum) = 1
i = i + 1
End If
Loop
For i = 1 To 99
If rndArray(i) = 1 Then
List1.AddItem i
rndArray(i) = 0
End If
Next 'i
End Sub
</code>

Dim talen(21) As Integer

Private Sub Command1_Click()
Dim x As Integer

List1.Clear

For x = 1 To 21
talen(x) = Int(Rnd * 100 + 1)
Next

For x = 21 To 1 Step -1
List1.AddItem talen(x)
Next

End Sub

Private Sub Form_Load()
Randomize
End Sub

Frisker ! Du får kraftig bakläxa på detta. Du tillåter samma tal komma upp 2 ggr eller fler.
Du har inte med 0. Som frågeställaren besällde.
Du använder Integer i Vb som är helt onödigt, skall vara Long.
talen(x) = Int(Rnd * 100 + 1)
Kan skrivas Int(Rnd*101)

Som du skriver skulle du rent principiellt kunna få 21 st 68.

Sven: Din lösning var inte precis optimal heller. Din kan rent principiellt hänga sig pga. att den slumpar ett tal, testar om det redan är slumpat, om det är det så försöker den igen. om dennu slumpar samma tal hela tiden så...?

>Du har inte med 0. Som frågeställaren besällde.
Han skriver ju mellan 0 och 100. Dvs från och med 1 till och med 99.
Det står dessutom inget om att talen som slumpas bara får förekomma en gång.

>testar om det redan är slumpat, om det är det så försöker den igen. om dennu slumpar samma tal hela tiden så...?

Det är omöjligt då man använder timerns 1000 delar som frö.Håller med att det i princip kan hålla på i timmar
men någon gång måste det gå att få fram 21 olika.

Du kan ju provköra mitt förslag,jag lovar om du kör 100 000 gr så kommer det aldrig att hända att den hänger sig.

Ang 0 - 100 så kan det vara som AJ påpekar frågeställaren får klargöra,samma med 2 av samma, lätt att justera.

Du verkar ha något problem med datatyper?
Korta heltal tar ju mindre minne, så varför inte använda dem?
Om personen i fråga skall slumpa tal större än 65535 (2 ^16) så kanske det är nödvändigt.

>Du verkar ha något problem med datatyper?

Okunnigt "bullshit" du skriver .Eftersom 32 bitars datorer skyfflar 4 byte åt gången dvs Long
så finns det aldrig någon mening med att använda Integer i VB 6.Det betyder bara att programmet
måste göra en extra, helt onödig operation att omvandla dessa 4 byte till en Integer 2 byte.
Om du kör Integer i matematik i Vb så blir det en himmla massa onödiga omvandlingar och klockpulser

Det är oproffsigt att inte använd 32 bitars processorers hela kapacitet !

I moderna program .net mfl betyder Integer numera 4 byte dvs vårt Long. Använd Long i Vb 6 !

>Korta heltal tar ju mindre minne, så varför inte använda dem?
Därför hastighet alltid prioriteras före minne du sparar 2 byt /Integer , en fis i minnesrymden.

Vidare så deklareras dessa Long oftast i Privata Sub eller Functioner dvs dom lever så kort tid
att det är fullständigt meningslöst att bekymra sig för dessa 2 byte.

Angående slumpning, istället för att köra en loop och generera ett slumpvärde varje varv och kontrollera om det redan är använt så är det bättre att först skapa en array med alla nummer i ordning, varje nummer förekommer bara en gång, och sedan köra en loop genom arrayen och byta plats med den array(loopIndex) och Array(slumpIndex). slumpIndex ska naturligtvis vara inom arrayens gränser. På detta vis behövs bara två loopar genom hela arrayen för att generera en slumpad lista.
Ett ännu snabbare sätt är att använde en hjälparray och bara köra en loop ett varv genom arrayen (se mitt exempel).

<code>

Sub main()
Const MINVALUE As Integer = 0
Const MAXVALUE As Integer = 100

Dim arrInts() As Integer
Dim i As Integer

Randomize

arrInts = GetRandomArray(MINVALUE, MAXVALUE)

ReDim Preserve arrInts(20)

For i = LBound(arrInts) To UBound(arrInts)
Debug.Print "Värde " & i & ": " & arrInts(i)
Next

End Sub


Private Function GetRandomArray(Optional ByVal StartValue As Integer = 0, Optional ByVal EndValue As Integer = &H7FFF) As Integer()
Dim arrRet() As Integer
Dim arrSet() As Boolean
Dim RndNum As Integer, temp As Integer
Dim lngStart As Long, lngEnd As Long, i As Long

lngStart = StartValue: lngEnd = EndValue

If lngEnd - lngStart < 0 Then Exit Function
' ReDim arrRet(lngEnd - lngStart)
' ReDim arrSet(UBound(arrRet))
ReDim arrRet(lngEnd - lngStart)
ReDim arrSet(lngEnd - lngStart)


For i = LBound(arrRet) To UBound(arrRet)
RndNum = GetRandomNum(LBound(arrRet), UBound(arrRet))
If Not arrSet(i) Then
arrRet(i) = i + lngStart
arrSet(i) = True
End If

If Not arrSet(RndNum) Then
arrRet(RndNum) = RndNum + lngStart
arrSet(RndNum) = True
End If

temp = arrRet(i)
arrRet(i) = arrRet(RndNum)
arrRet(RndNum) = temp

Next

GetRandomArray = arrRet

End Function


Private Function GetRandomNum(ByVal MinVal As Integer, ByVal MaxVal As Integer) As Long
Dim temp As Currency
Dim result As Currency

'Temp variablen används för att ta hand om när MaxVal har maxvärde
temp = CLng(MaxVal) - CLng(MinVal) + 1

GetRandomNum = Int((temp) * Rnd + MinVal)


End Function

</code>

Sven, skriv ihop en programsnutt som visar att long är så mycket snabbare än integer så att vi alla kan testköra på våra datorer och bli övertygade.

Det säger väl sig själv om jag behöver använda två(2)klockpulser för att behandla en DataTyp
i stället för En(1) så tar det dubbelt så lång tid.Nu är det i verkligheten krångligare än så.
Det tar förmodligen 3 ggr så lång tid. Varför tror du man ändrat Integer till samma som Long i tex vb.net
Long finns inte längre i moderna språk man kallar den Integer och är (2 ^16)

Till Jan Buler
Du använder 38 programrader för att lösa samma sak som jag gör med mina 18 jag vet
inte om jag tycker att det är effektivare.

Jag vet inte hur vetenskapligt det här testet är, men det blir i alla fall en skillnad, även fast den är väldigt liten.

<code>
Private Sub Command1_Click()
Dim a As Integer, b As Integer, c As Long, d As Long, i As Long, StartTime As Single

StartTime = Timer
For i = 1 To 200000000
a = 15000
b = a
Next i
MsgBox Timer - StartTime

StartTime = Timer
For i = 1 To 200000000
c = 15000
d = c
Next i
MsgBox Timer - StartTime
End Sub
</code>


Jag testade att ändra koden lite och då blev "Long-versionen" mycket segare än "Integer-versionen".

<code>
Private Sub Command1_Click()
Dim a As Integer, b As Integer, c As Long, d As Long, i As Long, StartTime As Single

StartTime = Timer
For i = 1 To 200000000
a = 250
b = a * 2
Next i
MsgBox Timer - StartTime

StartTime = Timer
For i = 1 To 200000000
c = 250
d = c * 2
Next i
MsgBox Timer - StartTime
End Sub
</code>


Thomas

Jag har inte sagt att du har fel Sven, men varför kan du inte visa med ett exempel hur mycket tid men tjänar i praktiken. Det vora mycket bättre än att snacka klockpulser.

>Det vora mycket bättre än att snacka klockpulser.
Klockpulser är tid

Skall se om jag orkar skruva ihop ett exempel.Då skall man använd API QueryPreformenceCounter.
[QueryPerformanceCounter]

>Okunnigt "bullshit" du skriver .Eftersom 32 bitars datorer skyfflar 4 byte åt gången dvs Long
>så finns det aldrig någon mening med att använda Integer i VB 6.

Skyfflar 32 bitar mellan vaddå? Dagens CPU:er skyfflar väl betydligt fler bitar än så (128-256) både internt mellan register och externt med cache och ramminne.

Tester är det enda sättet att avgöra om en implementering äs snabbare än en annan. Förr kanske man kunde säga att 32 bitar var snabbare än 16 men med knappast med dagens CPUer.

Det som avgör är hur bra kompilatorn kan hålla instruktionsrör (piplines) fulla och undvika cache missar. Det senare kan i viss mån undvikas genom att inte använda mer minne än nödvändigt i stora arrayer men inte ens det gäller generellt.

>Förr kanske man kunde säga att 32 bitar var snabbare än 16 men med knappast med dagens CPUer.

Ok det köper jag,men vidhåller att det är helt onödigt och i princip felaktigt att deklarera Integer i VB 6.

Sven

Ok att jag använder fler programrader men hur många rader är det som kan komma att exkeveras vid körning. Om man ska slumpa ett tal för att sedan titta om det redan använts och i så fall slumpa om det igen så har du ju ingen aning om hur många gånger du måste ligga och lopa till du fått ett unikt värde.


Jag testade min lösning med att generera en slumpad array med unika tal mellan 1 och 32767 och det tog 60 ms att köra i VB6 utvecklingsmiljö på min dator. Prova att köra din lösning några gånger så får vi se vad det blir för tider. Jag kan tänka mig att programmet kan stå och stampa ganska länge då det 32767:nde talet ska skapas och det får inte vara samma som något av de tidigare skapade talen.

//
Janne