Binary Sequence Predictor "game"?

[STxAxTIC]

I would consider that pretty baseline too. Test it out on all those strings at the bottom of my code (smartass).

[STxAxTIC]

By "long-term" I mean what's going on in the screenshot. Your answer helplessly pulls toward 50% no matter what really happens when you aren't busy knocking over straw men. Follow that link to the external site above, you may learn something (not from me, I know).

 

[SMcNeill]

I would consider that pretty baseline too. Test it out on all those strings at the bottom of my code (smartass).

But all those strings are pattern based and not really based on someone trying to be random, aren't they? 

As far as I can tell, just a random guesser that does an even/odd guess is pretty good at guessing what I'm going to click!

 

Almost a 60% accuracy, I was clicking left and right as randomly as I possibly could!  Apparently, me and my PC are in sync and it can read my mind!  I just don't know if that makes me MORE random than the average bear, or LESS...  Whichever it is, QB64 is pretty dang good at figuring out my next move!

[STxAxTIC]

But all those strings are pattern based and not really based on someone trying to be random, aren't they?

So what? If your code predicted anything, it would get those answers right.

As far as I can tell, just a random guesser that does an even/odd guess is pretty good at guessing what I'm going to click!

I know man, it's as far as you can tell. It's because you won't try the tests, won't really read anything, and you don't want to learn a thing from me, I know.

Show me your straw-man 60% accuracy case when you've fed it 300 input characters, or 3000.

Anyway, your public misunderstanding of this, as per usual directive, is on high display. Did you have a real question, or is this troll session over?

[SMcNeill]

Anyway, your public misunderstanding of this, as per usual directive, is on high display. Did you have a real question, or is this troll session over?

And ^this is why I insist you're the complete center of an asshole.

You post a screenshot showing 58% on 46 guesses.  You then tell us:

Qualitatively, this thing tends toward the high 50's, low 60's when I'm "trying" to be random. Since I've been staring at binary for some weeks now in various projects, I've become pretty good at beating the machine... for a while. The best I can do is keep it in the high 40's for 150 or so characters, then it catches on and it's right back to high-50s prediction rates. It continues to astound.

So your ASTOUNDING predictor gives you numbers between 40 and 60%, with a high of "high 40's"....

COLOR ME IMPRESSED!!

Also color me through with this topic, and YOU in general.  Asking "How is your shit better than a complete random predictor, based off your own results," isn't trolling.  I *was* wondering what I was missing out on that was so ASTOUNDish, but now I don't give a damn.

As one third of Odin, feel free to remove all my posts in this topic.  I'm finished with it and your grand ass delusions of astounding genius.  FU!!

[STxAxTIC]

Don't you have a coloring book to be working on?

[STxAxTIC]

Alright, made this thing quite a bit better, freakishly better. I deleted my main loop and re-coded the interface a few times, and ultimately decided on ultimate simplicity. There isn't even an INPUT statement anymore, you input the string into the code.

I also had this eureka moment - instead of testing a whole string and getting ONE prediction, why not make the program guess every single next character that's coming? Way better test, right? So it does that now. To be clear, here's what I mean: Suppose you feed the program 10010100010001. The first thing it does is sets the whole string aside, and then *pretends* that you trickle-fed the thing one character at a time. So on the first iteration it convinces itself you typed a 1, and then 10, and then 100, and then 1001, and then 10010, and so on. With each iteration, the program tries to guess the next number and reports on itself.

The results are crazy. Here's an example or two:

Consider the string:

Code: QB64: [Select]

1. TheString = "00101010001100101010010101010100101010010100101010010101010100100000101011110101001010010101010010000011101010100101010101001010010101010101010110101001010100101010101001010100101010100101010100101010101001010010101010010101010101010100101010101010101010101001010101010100101010101001010101001101010" ' 78
2.  

[/s]

Looks random enough, right? Welp, when I feed that through the program, the program can always guess the next letter 78% of the time. The string length is 299 for no good reason.

How about this one next?

Code: QB64: [Select]

1. TheString = "10101011100101100101010101010101010101010101010101010101010010011010100000000011111111111001011001101010101010110010101010101010101010101010100101100101010101010110011101011110101010101010101101101010101111010101100101001011010010101010101011010101001110101010111101110011010011001101001101011000101" ' 68
2.  

[/s]

For that string, the program sees what's coming 68% of the time. If you think this is somehow biased or buggy, you can always test with a "random" string not made by a human, but by a program. Alas, feeding this string into it:

Code: QB64: [Select]

1. TheString = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000" ' using RND function
2.  

[/s]

... the program doesn't stray too far from 50/50. It's 'cause I cooked this data with QB64's RND function. Basically you get the same standard deviation you'd see in a random walk, as you should. Any truly random data I feed it hovers around 50%. Good... so it works! So back to the hand-pounded data: I cannot believe what kind of results I'm getting. I'm 70% predictable?!

Try your own string. Hammer out a few hundred 0's and 1's and save that string in the program. It runs nice and fast, to the point where I had to slow it down by adding a delay. (Evidently it had some accuracy to spare, too. It doesn't seem to mind the cruder calclation.) Consider this the latest and greatest so far:

Code: QB64: [Select]

1. [s]Option _Explicit
2.  
3. Screen _NewImage(100, 30)
4.  
5. ' Version: 10
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. '''
42.  
43. Dim As Integer j, k
44. Dim TheString As String
45. Dim predictedGuess As Integer
46. Dim correctGuesses As Double
47. Dim totalGuesses As Double
48. Dim progressReport(1 To _Width) As Double
49.  
50. TheString = "101010101010101010101010101010101010101010101010101010101010101010101010"
51. 'TheString = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000" ' 63
52. 'TheString = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000" ' using RND function
53. 'TheString = "00101010001100101010010101010100101010010100101010010101010100100000101011110101001010010101010010000011101010100101010101001010010101010101010110101001010100101010101001010100101010100101010100101010101001010010101010010101010101010100101010101010101010101001010101010100101010101001010101001101010" ' 78
54. 'TheString = "11100101010011001001001010101001010000101001000010100010110111010101010011010100100100110101010010010110100101001001010010101010010010100101001010010100100101001001010010010110010010101010101001010101001010101010010101001001010101001010101010101010101010101010101010010101001010010100101001010101001" ' 68
55. 'TheString = "10101011100101100101010101010101010101010101010101010101010010011010100000000011111111111001011001101010101010110010101010101010101010101010100101100101010101010110011101011110101010101010101101101010101111010101100101001011010010101010101011010101001110101010111101110011010011001101001101011000101" ' 68
56. 'TheString = "10101101000110101000101010101010101010100101010101010100101110010101001001010100101010101001001010101001010000010010001010010010101010100110010101010101010101010110010101010010100101010010101010101001010101010101010010101010101010101010010101010101010101010101010010101001001010010100101010101010101" ' 76
57.  
58. Dim f
59.  
60. For j = 1 To Len(TheString)
61.     Cls
62.     Locate 1, 1
63.     Print "Analyzing:"
64.     Print
65.     Print Left$(TheString, j) + "["; Right$(TheString, Len(TheString) - j); "]"
66.     Print
67.     predictedGuess = Analyze(Left$(TheString, j), Mid$(TheString, j + 1, 1), 0)
68.     Print "Prediction: "; _Trim$(Str$(predictedGuess))
69.     Print "Actual:     "; _Trim$(Mid$(TheString, j + 1, 1))
70.     If (predictedGuess = Val(Mid$(TheString, j + 1, 1))) Then
71.         correctGuesses = correctGuesses + 1
72.     End If
73.     totalGuesses = totalGuesses + 1
74.     Print "I have been correct for "; _Trim$(Str$(Int(100 * correctGuesses / totalGuesses))); "% of "; _Trim$(Str$(totalGuesses)); " guesses."
75.     Print "Standard deviation: "; _Trim$(Str$(Sqr(j)));
76.  
77.     f = (_Width - 1) / Int(Len(TheString))
78.     If (f > 1) Then f = 1 / f
79.     progressReport(1 + Int(j * f)) = correctGuesses / totalGuesses
80.  
81.     For k = 1 To 1 + Int(j * (_Width - 1) / Int(Len(TheString)))
82.         Locate 20 - Int(10 * progressReport(1 + Int(k * f))), k: Print "*"
83.     Next
84.  
85.     _Delay .05
86.     _Display
87. Next
88.  
89. End
90.  
91. Function Analyze (TheStringIn As String, ActualIn As String, pswitch As Integer)
92.     Dim TheReturn As Integer
93.     Dim As Integer n
94.     Dim As Double r, j, k, h
95.     Dim Fingerprint(16) As String
96.     Dim p(2 To 10, 2) As Double ' Change the upper bound to a higer number for more accuracy.
97.  
98.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
99.     Fingerprint(1) = TheStringIn
100.     For n = 2 To UBound(Fingerprint)
101.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
102.     Next
103.  
104.     ' Initialize partial results.
105.     For n = LBound(p) To UBound(p)
106.         p(n, 1) = -999
107.     Next
108.  
109.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
110.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
111.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
112.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
113.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
114.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
115.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
116.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
117.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
118.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11)
119.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12)
120.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13)
121.  
122.     If (pswitch = 1) Then
123.         For n = 1 To _Width
124.             Print "-";
125.         Next
126.         Print
127.     End If
128.  
129.     If (pswitch = 1) Then
130.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3) ' Set the last number >=1 to print stats for that histogram.
131.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
132.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
133.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
134.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
135.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
136.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
137.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
138.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
139.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
140.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
141.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
142.         Print
143.     End If
144.  
145.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, p(), pswitch) ' Set the last number =1 to print guess for that histogram.
146.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, p(), pswitch)
147.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, p(), 0)
148.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, p(), 0)
149.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, p(), 0)
150.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, p(), 0)
151.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, p(), 0)
152.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, p(), 0)
153.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, p(), 0)
154.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, p(), 0)
155.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, p(), 0)
156.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, p(), 0)
157.     If (pswitch = 1) Then Print
158.  
159.     If (pswitch = 1) Then
160.         Print "Analyzing:"
161.         Print TheStringIn
162.  
163.         Print
164.         Print "Thinking:";
165.         For k = LBound(p) To UBound(p)
166.             If (p(k, 1) <> -999) Then
167.                 Print p(k, 1);
168.             Else
169.                 Print "_ ";
170.             End If
171.         Next
172.         Print
173.     End If
174.  
175.     j = 0
176.     r = 0
177.  
178.     For k = UBound(p) To LBound(p) Step -1
179.         If (p(k, 1) <> -999) Then
180.  
181.             ' This is the made-up part of the model:
182.             ' The variable r contributes to weighted average.
183.             ' The variable j is used for normalization.
184.             ' Scaling factor h influences weighted average calculaton.
185.             ' The factors multiplying h are totally arbitrary. Notes:
186.             '   setting o(h^2) means the later alphabets count for more.
187.             '   p(k, 1) euqals the calculated guess at frequency k.
188.             '   p(k, 2) euqals the peak count of the unscaled histogram.
189.             '   ...while p(k, 2) is here, it does not seem to help calculations.
190.  
191.             h = 1 + k - LBound(p)
192.  
193.             h = h ^ 2
194.  
195.             ' Standard weighted average:
196.             r = r + h * p(k, 1)
197.             j = j + h
198.  
199.         End If
200.     Next
201.     If (j <> 0) Then
202.         r = r / j
203.     End If
204.  
205.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
206.  
207.     If (r > .5) Then
208.         r = 1
209.     Else
210.         r = 0
211.     End If
212.  
213.     If (pswitch = 1) Then
214.         Print "Rounding to: "; _Trim$(Str$(r))
215.  
216.         ' Just for show, do the most naive thing possible by counting 1's.
217.         n = Len(TheStringIn)
218.         h = 0
219.         For k = 1 To n
220.             If Val(Mid$(TheStringIn, k, 1)) = 1 Then h = h + 1
221.         Next
222.         h = h / n
223.         Print
224.         Print "Naive (dec): "; _Trim$(Str$(h))
225.         If (h > .5) Then
226.             h = 1
227.         Else
228.             h = 0
229.         End If
230.         Print "Naive (int): "; _Trim$(Str$(h))
231.  
232.         ' Compare result to actual/known data if it was specified.
233.         If (ActualIn <> "?") Then
234.             Print
235.             Print "Actual:      "; ActualIn
236.             If (_Trim$(Str$(r)) <> ActualIn) Then
237.                 Beep
238.                 Print
239.                 Print "*** MISMATCH ***"
240.             End If
241.         End If
242.     End If
243.  
244.     TheReturn = r
245.     Analyze = TheReturn
246. End Function
247.  
248. Sub MakeGuess (OrigString As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
249.     Dim TheReturn As Double
250.     Dim As Integer j, k, n
251.     TheReturn = 0
252.     j = 1 '0
253.     k = 0
254.     For n = 1 To UBound(arralpha)
255.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(OrigString, wid - 1)) Then
256.             If (arralpha(n).Count >= j) Then
257.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
258.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
259.                 k = k + 1
260.                 j = arralpha(n).Count
261.             End If
262.         End If
263.     Next
264.     If (k <> 0) Then
265.         TheReturn = TheReturn / k
266.         arrbeta(wid, 1) = TheReturn
267.         arrbeta(wid, 2) = j
268.     Else
269.         TheReturn = .5
270.         arrbeta(wid, 1) = TheReturn
271.         arrbeta(wid, 2) = j
272.     End If
273. End Sub
274.  
275. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
276.     Dim As Integer j, k, n
277.     For n = 1 To UBound(arralpha)
278.         arralpha(n).Count = 0
279.     Next
280.     For j = 1 To w
281.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
282.             For n = 1 To UBound(arralpha)
283.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
284.                     arralpha(n).Count = arralpha(n).Count + 1
285.                 End If
286.             Next
287.         Next
288.     Next
289.     Call QuickSort(arralpha(), 1, UBound(arralpha))
290. End Sub
291.  
292. Sub PrintHisto (arr() As LetterBin, w As Integer)
293.     Dim As Integer j, n
294.     If (w > 0) Then
295.         If (w > UBound(arr)) Then
296.             j = UBound(arr)
297.         Else
298.             j = w
299.         End If
300.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
301.         For n = 1 To j
302.             Print arr(n).Signature; arr(n).Count
303.         Next
304.     End If
305. End Sub
306.  
307. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
308.     Dim As Integer j, k, n
309.     n = 0
310.     For k = 1 To 2
311.         For j = 1 To UBound(arrold)
312.             n = n + 1
313.             arrnew(n).Signature = arrold(j).Signature
314.         Next
315.     Next
316.     For j = 1 To UBound(arrnew)
317.         If (j <= UBound(arrnew) / 2) Then
318.             arrnew(j).Signature = "0" + arrnew(j).Signature
319.         Else
320.             arrnew(j).Signature = "1" + arrnew(j).Signature
321.         End If
322.     Next
323. End Sub
324.  
325. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
326.     Dim As Long piv
327.     If (LowLimit < HighLimit) Then
328.         piv = Partition(arr(), LowLimit, HighLimit)
329.         Call QuickSort(arr(), LowLimit, piv - 1)
330.         Call QuickSort(arr(), piv + 1, HighLimit)
331.     End If
332. End Sub
333.  
334. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
335.     Dim As Long i, j
336.     Dim As Double pivot, tmp
337.     pivot = arr(HighLimit).Count
338.     i = LowLimit - 1
339.     For j = LowLimit To HighLimit - 1
340.         tmp = arr(j).Count - pivot
341.         If (tmp >= 0) Then
342.             i = i + 1
343.             Swap arr(i), arr(j)
344.         End If
345.     Next
346.     Swap arr(i + 1), arr(HighLimit)
347.     Partition = i + 1
348. End Function[/s]
349.  

[STxAxTIC]

Press LEFT or RIGHT as randomly as you can.

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 19
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. ' Load test data.
42. ReDim Shared TestData(10000) As String
43. ReDim _Preserve TestData(LoadTestData(0))
44.  
45. ' This is the made-up part of the model.
46. Dim Shared AlphaWeight(1 To 13) As Double
47.  
48. ' Statistics and metrics:
49. Dim GuessPredicted As Integer
50. Dim GuessesCorrect As Double
51. Dim GuessesTotal As Double
52. Dim GuessStreak As Integer
53. Dim GuessStreakMax As Integer
54. Dim Grade(10000, 2) As Double
55.  
56. Call InitializeModel
57.  
58. '''
59. ' Bypass pre-cooked test data.
60. 'TestData(1) = "1111111111111111111111"
61. 'ReDim _Preserve TestData(1)
62. '''
63.  
64. Dim TheString As String
65. Dim As Integer k, m, n
66.  
67. For m = 1 To 1 'UBound(TestData)
68.  
69.     GuessPredicted = -1
70.     GuessesCorrect = 0
71.     GuessesTotal = 0
72.     GuessStreak = 0
73.     GuessStreakMax = 0
74.  
75.     For n = 1 To 9999 'Len(TestData(m))
76.  
77.         '''
78.         ' Research Mode
79.         'TheString = Left$(TestData(m), n)
80.         '''
81.  
82.         '''
83.         ' Gaming Mode
84.         Cls
85.         Locate 1, 1
86.         Print "Press LEFT or RIGHT."
87.         k = 0
88.         Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
89.         Select Case k
90.             Case 19200
91.                 TheString = TheString + "0"
92.             Case 19712
93.                 TheString = TheString + "1"
94.         End Select
95.         _KeyClear
96.         '''
97.  
98.         Cls
99.         Color 7
100.         Locate 1, 1
101.         For k = 1 To _Width
102.             Print "_";
103.         Next
104.         Print "Model:";
105.         For k = 1 To UBound(AlphaWeight)
106.             Print AlphaWeight(k);
107.         Next
108.         Print
109.         Print
110.         Print "Sequence (length "; _Trim$(Str$(Len(TheString))); "):"
111.         Print TheString ';
112.         Color 8
113.         'Print Right$(TestData(m), Len(TestData(m)) - n)
114.         Color 7
115.  
116.         ' Reconciliation
117.         If (GuessPredicted <> -1) Then
118.             Print
119.             Print "I predicted "; _Trim$(Str$(GuessPredicted)); " and you typed "; Right$(TheString, 1); "."
120.             If (GuessPredicted = Val(Right$(TheString, 1))) Then
121.                 Print "I am RIGHT this round."
122.                 GuessesCorrect = GuessesCorrect + 1
123.                 GuessStreak = GuessStreak + 1
124.                 If (GuessStreak > GuessStreakMax) Then GuessStreakMax = GuessStreak
125.                 Grade(n, 2) = 1
126.             Else
127.                 Print "I am WRONG this round."
128.                 GuessStreak = 0
129.                 Grade(n, 2) = 0
130.             End If
131.             GuessesTotal = GuessesTotal + 1
132.             Grade(n, 1) = GuessesCorrect / GuessesTotal
133.         End If
134.  
135.         If (GuessesTotal > 0) Then
136.             Print
137.             Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
138.             Print "My best streak has been "; _Trim$(Str$(GuessStreakMax)); "."
139.             If (GuessesTotal <> 0) Then
140.                 Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessesCorrect / GuessesTotal))); "% in "; _Trim$(Str$(GuessesTotal)); " guesses."
141.             End If
142.         End If
143.  
144.         GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
145.  
146.         Print
147.         Print "I have made a new prediction."
148.         Print "Press LEFT or RIGHT to test me."
149.  
150.         ' Draw bottom graph
151.         If (CsrLin <= 23) Then
152.             If (GuessesTotal <> 0) Then
153.                 Call PrintGraph(TheString, Grade())
154.             End If
155.         End If
156.  
157.         _Delay .02
158.         _Display
159.         _Limit 60
160.     Next
161.  
162.     _Delay 3
163. Next
164.  
165. End
166.  
167. Sub InitializeModel
168.     Dim As Integer k
169.     For k = LBound(AlphaWeight) To UBound(AlphaWeight)
170.         AlphaWeight(k) = 0 * k ^ 2
171.     Next
172.     'AlphaWeight(1) = 0
173.     'AlphaWeight(2) = 0
174.     'AlphaWeight(3) = 0
175.     'AlphaWeight(4) = 0
176.     AlphaWeight(5) = 1
177.     'AlphaWeight(6) = 0
178.     'AlphaWeight(7) = 0
179.     'AlphaWeight(8) = 0
180.     'AlphaWeight(9) = 0
181.     'AlphaWeight(10) = 0
182.     AlphaWeight(11) = 0
183.     AlphaWeight(12) = 0
184.     AlphaWeight(13) = 0
185. End Sub
186.  
187. Function Analyze (TheStringIn As String, arrweight() As Double, pswitch As Integer)
188.     Dim TheReturn As Integer
189.     Dim As Integer n
190.     Dim As Double r, j, k
191.     Dim StringPhase(UBound(arrweight)) As String
192.     Dim Partialguess(LBound(arrweight) To UBound(arrweight), 2) As Double
193.  
194.     StringPhase(1) = TheStringIn
195.     'For n = 2 To UBound(StringPhase) ' Uncomment for phase analysis.
196.     'StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
197.     'Next
198.  
199.     ' Initialize partial results.
200.     For n = LBound(Partialguess) To UBound(Partialguess)
201.         Partialguess(n, 1) = -999
202.     Next
203.  
204.     If (pswitch = 1) Then
205.         Print
206.         For n = 1 To _Width
207.             Print "-";
208.         Next
209.         Print
210.     End If
211.  
212.     If (arrweight(1) <> 0) Then Call CreateHisto(StringPhase(), 1, Alphabet1())
213.     If (arrweight(2) <> 0) Then Call CreateHisto(StringPhase(), 2, Alphabet2())
214.     If (arrweight(3) <> 0) Then Call CreateHisto(StringPhase(), 3, Alphabet3())
215.     If (arrweight(4) <> 0) Then Call CreateHisto(StringPhase(), 4, Alphabet4())
216.     If (arrweight(5) <> 0) Then Call CreateHisto(StringPhase(), 5, Alphabet5())
217.     If (arrweight(6) <> 0) Then Call CreateHisto(StringPhase(), 6, Alphabet6())
218.     If (arrweight(7) <> 0) Then Call CreateHisto(StringPhase(), 7, Alphabet7())
219.     If (arrweight(8) <> 0) Then Call CreateHisto(StringPhase(), 8, Alphabet8())
220.     If (arrweight(9) <> 0) Then Call CreateHisto(StringPhase(), 9, Alphabet9())
221.     If (arrweight(10) <> 0) Then Call CreateHisto(StringPhase(), 10, Alphabet10())
222.     If (arrweight(11) <> 0) Then Call CreateHisto(StringPhase(), 11, Alphabet11())
223.     If (arrweight(12) <> 0) Then Call CreateHisto(StringPhase(), 12, Alphabet12())
224.     If (arrweight(13) <> 0) Then Call CreateHisto(StringPhase(), 13, Alphabet13())
225.  
226.     If (pswitch = 1) Then ' Set the last argument >=1 to print stats for that histogram.
227.         If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call PrintHisto(Alphabet1(), 0)
228.         If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call PrintHisto(Alphabet2(), 0)
229.         If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call PrintHisto(Alphabet3(), 0)
230.         If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call PrintHisto(Alphabet4(), 0)
231.         If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call PrintHisto(Alphabet5(), 4)
232.         If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call PrintHisto(Alphabet6(), 0)
233.         If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call PrintHisto(Alphabet7(), 0)
234.         If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call PrintHisto(Alphabet8(), 0)
235.         If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call PrintHisto(Alphabet9(), 0)
236.         If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call PrintHisto(Alphabet10(), 0)
237.         If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call PrintHisto(Alphabet11(), 0)
238.         If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call PrintHisto(Alphabet12(), 0)
239.         If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call PrintHisto(Alphabet13(), 0)
240.         Print
241.     End If
242.  
243.     If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call MakeGuess(TheStringIn, 1, Alphabet1(), Partialguess(), 0) ' Set the last argument =1 to print guess for that histogram.
244.     If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call MakeGuess(TheStringIn, 2, Alphabet2(), Partialguess(), 0)
245.     If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call MakeGuess(TheStringIn, 3, Alphabet3(), Partialguess(), 0)
246.     If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call MakeGuess(TheStringIn, 4, Alphabet4(), Partialguess(), 0)
247.     If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call MakeGuess(TheStringIn, 5, Alphabet5(), Partialguess(), pswitch)
248.     If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call MakeGuess(TheStringIn, 6, Alphabet6(), Partialguess(), 0)
249.     If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call MakeGuess(TheStringIn, 7, Alphabet7(), Partialguess(), 0)
250.     If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call MakeGuess(TheStringIn, 8, Alphabet8(), Partialguess(), 0)
251.     If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call MakeGuess(TheStringIn, 9, Alphabet9(), Partialguess(), 0)
252.     If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call MakeGuess(TheStringIn, 10, Alphabet10(), Partialguess(), 0)
253.     If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call MakeGuess(TheStringIn, 11, Alphabet11(), Partialguess(), 0)
254.     If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call MakeGuess(TheStringIn, 12, Alphabet12(), Partialguess(), 0)
255.     If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call MakeGuess(TheStringIn, 13, Alphabet13(), Partialguess(), 0)
256.     If (pswitch = 1) Then Print
257.  
258.     If (pswitch = 1) Then
259.         Print "Thinking:";
260.         For k = LBound(Partialguess) To UBound(Partialguess)
261.             If (Partialguess(k, 1) <> -999) Then
262.                 Print Partialguess(k, 1);
263.             Else
264.                 Print "_ ";
265.             End If
266.         Next
267.         Print
268.     End If
269.  
270.     j = 0
271.     r = 0
272.  
273.     ' Weighted average calculation
274.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
275.         If (Partialguess(k, 1) <> -999) Then
276.             r = r + arrweight(k) * Partialguess(k, 1)
277.             j = j + arrweight(k)
278.         End If
279.     Next
280.     If (j <> 0) Then
281.         r = r / j
282.     End If
283.  
284.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
285.  
286.     If (r > .5) Then
287.         r = 1
288.     Else
289.         r = 0
290.     End If
291.  
292.     If (pswitch = 1) Then
293.         Print "Rounding to: "; _Trim$(Str$(r))
294.     End If
295.  
296.     If (pswitch = 1) Then
297.         For n = 1 To _Width
298.             Print "-";
299.         Next
300.         Print
301.     End If
302.  
303.     TheReturn = r
304.     Analyze = TheReturn
305. End Function
306.  
307. Sub MakeGuess (TheStringIn As String, wid As Integer, arralpha() As LetterBin, arrguess() As Double, pswitch As Integer)
308.     Dim TheReturn As Double
309.     Dim As Integer j, k, n
310.     TheReturn = 0
311.     j = 1
312.     k = 0
313.     For n = 1 To UBound(arralpha)
314.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
315.             If (arralpha(n).Count >= j) Then
316.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
317.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
318.                 k = k + 1
319.                 j = arralpha(n).Count
320.             End If
321.         End If
322.     Next
323.     If (k <> 0) Then
324.         TheReturn = TheReturn / k
325.     Else
326.         TheReturn = .5
327.     End If
328.     arrguess(wid, 1) = TheReturn
329.     arrguess(wid, 2) = j
330. End Sub
331.  
332. Sub CreateHisto (arrfinger() As String, wid As Integer, arralpha() As LetterBin)
333.     Dim As Integer j, k, n
334.     For n = 1 To UBound(arralpha)
335.         arralpha(n).Count = 0
336.     Next
337.     ' Uncomment this loop to enable phase analysis.
338.     'For j = 1 To wid
339.     j = 1
340.     For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod wid) Step wid
341.         For n = 1 To UBound(arralpha)
342.             If (Mid$(arrfinger(j), k, wid) = arralpha(n).Signature) Then
343.                 arralpha(n).Count = arralpha(n).Count + 1
344.             End If
345.         Next
346.     Next
347.     'Next
348.     Call QuickSort(arralpha(), 1, UBound(arralpha))
349. End Sub
350.  
351. Sub PrintHisto (arr() As LetterBin, wid As Integer)
352.     Dim As Integer j, n
353.     If (wid > 0) Then
354.         If (wid > UBound(arr)) Then
355.             j = UBound(arr)
356.         Else
357.             j = wid
358.         End If
359.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(wid))
360.         For n = 1 To j
361.             Print arr(n).Signature; arr(n).Count
362.         Next
363.     End If
364. End Sub
365.  
366. Sub PrintGraph (TheString As String, arrgrade() As Double)
367.     Dim As Integer j, k
368.     Dim As Double f, g
369.     For k = 1 To _Width
370.         Locate _Height - 5, k: Print "_"
371.         Locate _Height - 5 - 10, k: Print "_"
372.     Next
373.     Locate _Height - 5 + 1, 1: Print "0%"
374.     Locate _Height - 5 - 10 - 1, 1: Print "100%"
375.     f = (_Width) / Len(TheString)
376.     If (f > 1) Then f = 1
377.     For j = 2 To Len(TheString)
378.         g = Int(j * f)
379.         If (g = 0) Then g = 1
380.         Locate _Height - 5 - Int(10 * arrgrade(j, 1)), g
381.         If (arrgrade(j, 2) = 1) Then
382.             Print Chr$(251)
383.         Else
384.             Print "x"
385.         End If
386.     Next
387. End Sub
388.  
389. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
390.     Dim As Integer j, k, n
391.     n = 0
392.     For k = 1 To 2
393.         For j = 1 To UBound(arrold)
394.             n = n + 1
395.             arrnew(n).Signature = arrold(j).Signature
396.         Next
397.     Next
398.     For j = 1 To UBound(arrnew)
399.         If (j <= UBound(arrnew) / 2) Then
400.             arrnew(j).Signature = "0" + arrnew(j).Signature
401.         Else
402.             arrnew(j).Signature = "1" + arrnew(j).Signature
403.         End If
404.     Next
405. End Sub
406.  
407. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
408.     Dim As Long piv
409.     If (LowLimit < HighLimit) Then
410.         piv = Partition(arr(), LowLimit, HighLimit)
411.         Call QuickSort(arr(), LowLimit, piv - 1)
412.         Call QuickSort(arr(), piv + 1, HighLimit)
413.     End If
414. End Sub
415.  
416. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
417.     Dim As Long i, j
418.     Dim As Double pivot, tmp
419.     pivot = arr(HighLimit).Count
420.     i = LowLimit - 1
421.     For j = LowLimit To HighLimit - 1
422.         tmp = arr(j).Count - pivot
423.         If (tmp >= 0) Then
424.             i = i + 1
425.             Swap arr(i), arr(j)
426.         End If
427.     Next
428.     Swap arr(i + 1), arr(HighLimit)
429.     Partition = i + 1
430. End Function
431.  
432. 'Function Pathological$ (TheSeed As String, TheLength As Integer)
433. '    Dim TheReturn As String
434. '    TheReturn = TheSeed
435. '    Dim p
436. '    Do
437. '        Cls
438. '        Locate 1, 1
439. '        Print TheReturn;
440. '        p = Analyze(TheReturn, 0)
441. '        If (p = 1) Then
442. '            TheReturn = TheReturn + "0"
443. '        Else
444. '            TheReturn = TheReturn + "1"
445. '        End If
446. '    Loop Until Len(TheReturn) = TheLength
447. '    Pathological$ = TheReturn
448. 'End Function
449.  
450. Function LoadTestData (alwayszero As Integer)
451.     Dim n As Integer
452.     n = alwayszero
453.  
454.     '''
455.     ' Percussive cases:
456.     '''
457.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
458.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
459.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
460.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
461.     n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
462.     n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
463.  
464.     '''
465.     ' Human samples:
466.     '''
467.     ' (from Keybone)
468.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
469.     ' (from Keybone)
470.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
471.     ' (from Loudar)
472.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
473.     ' (from Luke)
474.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
475.     ' (from Sarafromct)
476.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
477.     ' (from Spriggs)
478.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
479.     ' (from Spriggs)
480.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
481.     ' (from Hotpants)
482.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
483.  
484.     LoadTestData = n
485. End Function
486.  
487.  

Reach much more at: http://barnes.x10host.com/pages/Binary-Analyzer.php

[STxAxTIC]

Here's an inform version. I love it.

 

(There might be something buggy about the way I carried this to inform so if you're looking to study the code or study the game you should use the resources in the post directly above this ^^^)

[Sanmayce]

Interesting, some time ago a fellow member posted some word-guesser, my suggestion is to try something new, namely "Letter-Guesser".

Instead of zeros and ones, the game to allow writing letters in a string (it could be more space effective if the written string is placed in a box instead of a line), and in REAL-TIME, heh-heh, to guess the next letter, thus whether the previous input was words making sense, or not, it would be an useful ... auto-completion etude.

I have in my to-do list to write a phrase-guesser, deriving from millions of bi-grams (as a start), in next year.

For a long time I wanted to have (and share) a simple application allowing typing (in kinda search box) English words, and the word being currently typed to be PAIRED with the previous one, thus forming a bi-gram being matched versus some big-ass bi-gram corpus. Then when, for example, I type "Sylvester St" the predictor to suggest few bi-grams, thus people who are unaware how the family name of the beloved actor is, would be saved from the shame.
Here is what Google suggests when typing "Sy":

 

Oh, and to boost its practicalness, if the user started on a wrong foot e.g. "Silvestor St" then the predictor to be ready to fire the correct "Sylvester Stallone" - that is to be capable of detecting "errors" in the word before last one as well.

[DANILIN]

please synthesize minimum 25000 values of 0 & 1
no matter: in a row or in a column
and having packed them into an archive
and place them in topic
to check for binomial distribution in several parts

[STxAxTIC]

please synthesize minimum 25000 values of 0 & 1

I hope you see the essence of this this game is to produce data by hand, so I was actually wishing you would generate 25,000 events *for* me. It's Christmas, what do ya think?

You may be able to check for elements of non-randomness using binomial distribution or other statistical methods but that's a far cry from what this code can do. We need a good Russian translator around here, I have a feeling you'd like this but it's hard to carry on with you due to my very poor understanding of Russian.

[DANILIN]

you understand correctly what I am writing
and I check myself through translation of translation

MS Excel formula
=randbetween(0;1)

and stretch down

but MS Word translation from column to row: replacement
^p
on clear string

5 KB = 25'000 (0\1)
 

25000.zip

Binomial Logarithmic Integral Pyramidal Distribution
BLIP distribution of Random numbers

25000 0\1 from array above have been investigated
and it is possible to investigate your numbers and 0 and 1

Code: [Select]

.984375 second              25396  in second 
 25000         elements     

 THEORY        Average       BIG           EVEN

 6250          6347          6348          6347
 3125          3058          3057          3059
 1562          1548          1549          1548
 781           774           774           774
 390           388           388           388
 195           194           194           194
 97            92            92            92
 48            51            51            51
 24            23            23            23
 12            15            15            15
 6             11            11            11
 3             5             5             5
Practical distributions correspond to theoretical ones
so random sequence is qualitative
and it is possible to study patterns of different sequences

Feature of program: index of indixes p(f(i)) & q(m(i))

Since 2019 & 1993

Code: QB64 $NOPREFIX: [Select]

1. 'dablip25.bas
2. n = 25000: Randomize Timer
3. Dim b(n), d(n), e(n), f(n)
4. Dim j(n), k(n), m(n), p(12), q(12)
5. tb = Timer: s = 0
6. Open "25000.txt" For Input As #1
7. For i = 1 To n: Locate 1, 1: Print i, ,: Input #1, b(i): Next
8. Locate 1, 1: Print " THEORY        Average       BIG           EVEN "
9.  
10. For i = 2 To n-1: s = s+b(i): m = s/i
11.  
12.     If b(i) < m Then d(i) = 0 Else d(i) = 1
13.     If (b(i) Mod 2) = 0 Then j(i) = 0 Else j(i) = 1
14.  
15.     If d(i) = d(i-1) Then e(i) = e(i-1)+1 Else e(i) = 0
16.     If e(i) = 0 Then f(i) = e(i-1) Else f(i) = 12
17.     If f(i) > 12 Then f(i) = 12
18.  
19.     If j(i) = j(i-1) Then k(i) = k(i-1)+1 Else k(i) = 0
20.     If k(i) = 0 Then m(i) = k(i-1) Else m(i) = 12
21.     If m(i) > 12 Then m(i) = 12
22.  
23.     p(f(i)) = p(f(i))+1: q(m(i)) = q(m(i))+1
24.  
25.     If (i Mod 1000) = 0 Then Locate 3, 1: Print i, " from ", n, Int(100 * i/n); " %",
26. Next
27.  
28. Locate 3, 1: For t = 1 To 12
29.     Print Int(n/(2^(t+1))), Int((p(t-1)+q(t-1))/2), p(t-1), q(t-1)
30. Next
31.  
32. Print: Print Timer-tb; "second", Int(n/(Timer-tb)); " in second  "
33. Print n, " elements ",

[DANILIN]

? have you calculated 25ooo 0\1 ?
from message above: 25000.zip

[DANILIN]

shuffle and make sure that number does not take its place
so far without control has array become binomially better

we create an array of numbers in a row
and in 1 pass we rearrange serial number and a random number
and if numbers of rearranged ones match: spinning line is my handwriting

check array and if there are numbers in their places:
we count number and write array as defective
marking matched ones with a minus sign

first and last numbers are displayed on screen but it is possible to write everything to file

how to copy text results from window is unknown therefore:
picture shows: 9 numbers were qualitatively shuffled from 6th attempt
in 0 seconds

next I plan to calculate whether sequence has become truly random
and apparently I will have to switch to index indexes as excel cells

 

+ update by 10%
result is visible if saved to disk or ram disk
between cells at least 10%
and number of repeated shuffles: up to 25% of array length

Code: QB64: [Select]

1. a = 100: DIM d(a): x=0: k=0: t$=CHR$(9): RANDOMIZE TIMER 'tas_ten.bas
2. PRINT ,: FOR i = 1 TO a: d(i)=i: NEXT
3. FOR i = 1 TO 5: PRINT d(i);: NEXT: PRINT ,
4. FOR i = a-3 TO a: PRINT d(i);: NEXT: z = TIMER
5. OPEN "b:/control.txt" FOR OUTPUT AS #1 ' ram disk
6. WHILE x < 1
7.     v = 0: FOR i = 1 TO a
8.        1 m = INT(RND*a)+1: IF ABS(d(i)-d(m)) < .1*a THEN v = v+1: GOTO 1
9.         PRINT #1, ABS(d(i)-d(m)); t$; d(i); t$; d(m); t$; i; t$; m; t$; d(i)/d(m); t$; d(m)/d(i)
10.         t = d(i): d(i) = d(m): d(m) = t
11.     NEXT
12.  
13.     s = 0: FOR i = 1 TO a
14.         IF d(i) = i THEN s = s+1
15.     NEXT
16.    5 k = k+1: PRINT: PRINT s; v,: IF s=0 THEN x = x+1
17.  
18.     FOR i = 1 TO 5
19.         IF d(i) = i THEN PRINT -d(i); ELSE PRINT d(i);
20.     NEXT: PRINT ,
21.     FOR i = a-3 TO a
22.         IF d(i) = i THEN PRINT -d(i); ELSE PRINT d(i);
23.     NEXT
24. WEND: PRINT: PRINT "    = "; k, TIMER-z: END

result control: open in notepad and search 1.0
as ratio is less than 10% and desired is missing
this means that elements are shuffled at a distance of at least 10% of array from each other

Code: [Select]

41 70 29 91 18 2.413793 .4142857
 59 24 83 92 38 .2891566 3.458333
 14 32 46 93 44 .6956522 1.4375
 23 10 33 94 88 .3030303 3.3
 29 19 48 95 36 .3958333 2.526316
 11 41 30 96 11 1.366667 .7317073
 38 1 39 97 21 2.564103E-02 39
 60 26 86 98 55 .3023256 3.307692
 17 4 21 99 58 .1904762 5.25
 26 100 74 100 59 1.351351 .74
returning to topic: binary arise if you identify parity and odd
and comparing relative average: less or more