started at ; stage 2 since . guess by
we made it! let's celebrate: give me 100 terms of the kolakoski sequence. submissions may be written in any language.
ever dipped your toes in the field of compression? there's a basic concept there known as run-length encoding. you've probably heard of it. it makes it more efficient to store repeated symbols: to store "aaaaa", instead of keeping 5 copies of the character 'a', you can just remember "there are 5 'a's here", right? so instead of just storing each character, you store them along with a "run length" that tells you how many times it's repeated. "apple" becomes "1a2p1l1e". simple, right?
let's forget about strings for a second. in fact, let's forget about what the runs consist of at all. let's remember "apple" as "1211", just the length of the runs. we'll define a function f that turns a string into a series of run lengths, so that f("apple") = "1211". I could repeat the operation to get f("1211") = "112"... this iteration reminds me of the look-and-say sequence, but it's a little different. because we don't keep the content of the runs, only their lengths, the string doesn't grow infinitely. if I keep going, I get "21", then "11", then "2". unlike look and say, it isn't growing to infinity. it in fact turns out that this operation has fixed points: infinite sequences x such that f(x) = x. the sequence is equal to its own sequence of run lengths!
the Kolakoski sequence is the unique such sequence that consists of only 1 and 2 and starts with 1. let's look at it:
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2 1 1 2 1 2 2 1 1
- --- --- - - --- - --- --- - --- --- - - --- - - --- ---
1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2
above are the terms of the sequence and below the runs and their lengths are shown. for the infinite Kolakoski sequence, these two sequences are one and the same.
ordinarily, I'd let you generate as many terms of this sequence as you liked in any way that you liked. but this is round 100, so your challenge is to give me exactly 100 terms of the kolakoski sequence. as any language is allowed, there is no fixed API.
you can download all the entries
comments 0
do_you_know_who_i_am_now.luau ASCII text, with CRLF line terminators
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
print(1)
print(2)
print(2)
local i = 3
local last = 2
while i < 100 do
local num = 2 - i % 2
print(num)
i += 1
if last == 2 then
print(num)
i += 1
end
last = num
end
comments 0
post a comment
100.I ASCII text
11;2 [.\%2+1 w #h< g] 100
comments 0
post a comment
cg.gay ASCII text
1
2
3
4
5
6
hello my name is essaie and this is my submission to code guessing (gay)
you can tell i am essaie as my spelling is purrfect (i discovered grammar checkers)
Kind Regards,
lychee
comments 0
post a comment
hereyougolmao.txt ASCII text, with no line terminators
11,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2,1,2,1,1,2,1,2,2,1,1,2,1,1,2,1,2,2,1,2,2,1,1,2,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,1,2,2,1,2,1,1,2,2,1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1,2,2
comments 2
olus.rs ASCII text, with very long lines (306)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
use std::fmt;
use std::fmt::{Display, Formatter};
#[derive(Debug, Default)]
struct One;
#[derive(Debug, Default)]
struct OneNotFlip;
#[derive(Debug, Default)]
struct Two;
#[derive(Debug, Default)]
struct List<T, U>(T, U);
#[derive(Debug, Default)]
struct State<T,U>(T, U);
impl Display for One {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "1")
}
}
impl Display for Two {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "2")
}
}
impl<T: Display, U: Display> Display for List<T, U> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "{}, {}", self.0, self.1)
}
}
trait Flip {
type O;
}
impl Flip for Two {
type O = One;
}
impl Flip for One {
type O = Two;
}
trait First {
type O;
}
impl<T, U> First for State<T, U> {
type O = T;
}
trait Prepend<T> {
type O;
}
impl<T> Prepend<T> for One {
type O = List<T, One>;
}
impl<T> Prepend<T> for Two {
type O = List<T, Two>;
}
impl<T, U: Prepend<T>, V> Prepend<T> for List<U, V> {
type O = List<<U as Prepend<T>>::O, V>;
}
trait Compute {
type O;
}
impl<T, U: Flip, V> Compute for State<List<T, U>, List<V, Two>>
where List<V, OneNotFlip>: Prepend<<U as Flip>::O> {
type O = State<List<List<T, U>, <U as Flip>::O>, <List<V, OneNotFlip> as Prepend<<U as Flip>::O>>::O>;
}
impl<T, U: Flip, V> Compute for State<List<T, U>, List<V, One>>
where V: Prepend<<U as Flip>::O> {
type O = State<List<List<T, U>, <U as Flip>::O>, <V as Prepend<<U as Flip>::O>>::O>;
}
impl<T, U: Flip, V> Compute for State<List<T, U>, List<V, OneNotFlip>>
where V: Prepend<U> {
type O = State<List<List<T, U>, U>, <V as Prepend<U>>::O>;
}
trait Do<N> {
type O;
}
impl<T> Do<()> for T {
type O = T;
}
impl<T, N> Do<(N,)> for T
where T: Do<N>,
<T as Do<N>>::O: Compute {
type O = <<T as Do<N>>::O as Compute>::O;
}
type Init = State<List<List<List<List<One, Two>, Two>, One>, One>, List<One, One>>;
type NinetyFive = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),),);
type FinalState = <Init as Do<NinetyFive>>::O;
type Output = <FinalState as First>::O;
fn main() {
let x = <Output as Default>::default();
println!("{}", x)
}
comments 0
post a comment
cg100.love Zip archive data, made by v3.0 UNIX, extract using at least v1.0, last modified May 11 2026 22:15:38, uncompressed size 53, method=store
bart.png PNG image data, 880 x 1347, 8-bit/color RGBA, non-interlaceddir r
class.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
-- currently a class is a table T with T.__index = T
-- then to make an instance of this class, we do
-- setmetatable(instance,T)
-- this should be fine for anything we wish to do.
-- it is possible we will eventually split this into two separate
-- tables perhaps? i don't see why we would ever do that though
local function class()
local T = {}
T.__index = T
setmetatable(T, {__call = function(cls, ...) return cls.make(cls, ...) end})
return T
end
local function extend(Base)
local T = class()
for k,v in pairs(Base) do
if k:sub(1,2) == "__" and k~="__index" then
T[k]=v
end
end
getmetatable(T).__index = Base
return T
end
return setmetatable({
class=class,
extend=extend
},{__call=class})
math.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
local M = {}
function M.lerp(a,b,t) return (1-t)*a + t*b end
function M.smoothstep(x)
if x<0 then return 0 end
if x>1 then return 1 end
return x*x*(3 - 2*x)
end
function M.slerp(a,b,t) return M.lerp(a,b,M.smoothstep(t)) end
function M.sign(x)
if x == 0 then return 0
elseif x < 0 then return -1
elseif x > 0 then return 1
end
end
function M.clamp(x,minv,maxv)
return math.min(math.max(x,minv),maxv)
end
function M.clerp(a,b,t) return M.lerp(a,b,M.clamp(t,0,1)) end
function M.round(x) return math.floor(x+0.5) end
-- [-1,1] -> [0,1]
function M.squish(x) return (x/2)+0.5 end
-- [0,1] -> [-1,1]
function M.unsquish(x) return (x*2)-1 end
function M.sqlerp(a,b,t) return M.lerp(a,b,M.squish(t)) end
return M
pos.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
local class = require'r.class'
local rmath = require'r.math'
local Pos = class()
function Pos.new(cls)
return setmetatable({},cls)
end
function Pos.init(self,x,y)
self.x = x
self.y = y
return self
end
function Pos.make(cls,...)
return cls:new():init(...)
end
function Pos.__add(self,other)
return Pos:make(self.x+other.x,self.y+other.y)
end
function Pos.__sub(self,other)
return Pos:make(self.x-other.x,self.y-other.y)
end
function Pos.__unm(self) return Pos(-self.x,-self.y) end
function Pos.__mul(a,b)
if type(a) == "number" then
return Pos:make(a*b.x,a*b.y)
elseif type(b) == "number" then
return Pos:make(a.x*b,a.y*b)
else
error("can only multiply Pos by scalar")
end
end
function Pos.__div(a,b)
assert(type(b) == "number","can only divide Pos by scalar")
return a*(1/b)
end
function Pos.__eq(a,b) return a.x==b.x and a.y==b.y end
function Pos.lensq(self) return self.x^2 + self.y^2 end
function Pos.len(self) return math.sqrt(self:lensq()) end
function Pos.norm(self)
local l = self:len()
if l < 0.00001 then return Pos(0,0) else return self/l end end
function Pos.l1(self) return math.abs(self.x) + math.abs(self.y) end
function Pos.linf(self) return math.max(math.abs(self.x),math.abs(self.y)) end
function Pos.dot(self,other) return self.x*other.x+self.y*other.y end
function Pos.vals(self) return self.x, self.y end
function Pos.floor(self) return Pos:make(math.floor(self.x),math.floor(self.y)) end
function Pos.ceil(self) return Pos:make(math.ceil(self.x),math.ceil(self.y)) end
function Pos.round(self) return Pos:make(rmath.round(self.x),rmath.round(self.y)) end
function Pos.divmod(self,size) local div = (self/size):floor() return div, self-div*size end
function Pos.__tostring(self)
return string.format("(%.2f,%.2f)",self.x,self.y)
end
function Pos.key(self) return self.x .. ':' .. self.y end
function Pos.unkey(cls,k)
local a,b = k:match"(%-?%d+):(%-?%d+)"
return Pos(tonumber(a),tonumber(b)) end
function Pos.rot(self,a)
local c,s = math.cos(a),math.sin(a)
-- [ C, -S ]
-- [ S, C ]
return Pos(self.x*c - self.y*s, self.x*s + self.y*c) end
function Pos.sproj(self,b) return self:dot(b:norm()) end
function Pos.proj(self,b) return self:sproj(b)*b:norm() end
function Pos.angle(self) return (math.atan2 or math.atan)(self.y,self.x) end
-- inplace arithmetic
function Pos.addby (self,by) self.x=self.x+by.x self.y=self.y+by.y end
function Pos.addbyv(self,x,y)self.x=self.x+x self.y=self.y+y end
function Pos.subby (self,by) self.x=self.x-by.x self.y=self.y-by.y end
function Pos.subbyv(self,x,y)self.x=self.x-x self.y=self.y-y end
function Pos.mulby (self,by) self.x=self.x*by self.y=self.y*by end
function Pos.divby (self,by) self.x=self.x/by self.y=self.y/by end
return Pos
qw.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
-- qw"aaa bbb ccc" --> { "aaa", "bbb", "ccc" }
local function qw(str)
local out = {}
for x in str:gmatch"%S+" do
table.insert(out, x)
end
return out
end
-- qw.s"aaa bbb ccc" --> { aaa=true, bbb=true, ccc=true }
local function qws(str)
local out = {}
for x in str:gmatch"%S+" do
out[x] = true
end
return out
end
-- for k in qw.i"aaa bbb ccc" do ... end
local function qwi(str) return pairs(qws(str)) end
return setmetatable({qw=qw,s=qws,i=qwi},{__call=function(_,...) return qw(...) end})
bartmono.wav RIFF (little-endian) data, WAVE audio, Microsoft PCM, 16 bit, mono 48000 Hz
click0.wav RIFF (little-endian) data, WAVE audio, Microsoft PCM, 24 bit, stereo 44100 Hzconf.lua ASCII text
1function love.conf(t) t.window.title='KOLAKOSKI' end
lafont.png PNG image data, 70 x 71, 8-bit/color RGBA, non-interlaceddkjson.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
-- Module options:
local always_use_lpeg = false
local register_global_module_table = false
local global_module_name = 'json'
--[==[
David Kolf's JSON module for Lua 5.1 - 5.4
Version 2.8
For the documentation see the corresponding readme.txt or visit
<http://dkolf.de/dkjson-lua/>.
You can contact the author by sending an e-mail to 'david' at the
domain 'dkolf.de'.
Copyright (C) 2010-2024 David Heiko Kolf
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
--]==]
-- global dependencies:
local pairs, type, tostring, tonumber, getmetatable, setmetatable =
pairs, type, tostring, tonumber, getmetatable, setmetatable
local error, require, pcall, select = error, require, pcall, select
local floor, huge = math.floor, math.huge
local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat =
string.rep, string.gsub, string.sub, string.byte, string.char,
string.find, string.len, string.format
local strmatch = string.match
local concat = table.concat
local json = { version = "dkjson 2.8" }
local jsonlpeg = {}
if register_global_module_table then
if always_use_lpeg then
_G[global_module_name] = jsonlpeg
else
_G[global_module_name] = json
end
end
local _ENV = nil -- blocking globals in Lua 5.2 and later
pcall (function()
-- Enable access to blocked metatables.
-- Don't worry, this module doesn't change anything in them.
local debmeta = require "debug".getmetatable
if debmeta then getmetatable = debmeta end
end)
json.null = setmetatable ({}, {
__tojson = function () return "null" end
})
local function isarray (tbl)
local max, n, arraylen = 0, 0, 0
for k,v in pairs (tbl) do
if k == 'n' and type(v) == 'number' then
arraylen = v
if v > max then
max = v
end
else
if type(k) ~= 'number' or k < 1 or floor(k) ~= k then
return false
end
if k > max then
max = k
end
n = n + 1
end
end
if max > 10 and max > arraylen and max > n * 2 then
return false -- don't create an array with too many holes
end
return true, max
end
local escapecodes = {
["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f",
["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t"
}
local function escapeutf8 (uchar)
local value = escapecodes[uchar]
if value then
return value
end
local a, b, c, d = strbyte (uchar, 1, 4)
a, b, c, d = a or 0, b or 0, c or 0, d or 0
if a <= 0x7f then
value = a
elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then
value = (a - 0xc0) * 0x40 + b - 0x80
elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then
value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80
elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then
value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80
else
return ""
end
if value <= 0xffff then
return strformat ("\\u%.4x", value)
elseif value <= 0x10ffff then
-- encode as UTF-16 surrogate pair
value = value - 0x10000
local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400)
return strformat ("\\u%.4x\\u%.4x", highsur, lowsur)
else
return ""
end
end
local function fsub (str, pattern, repl)
-- gsub always builds a new string in a buffer, even when no match
-- exists. First using find should be more efficient when most strings
-- don't contain the pattern.
if strfind (str, pattern) then
return gsub (str, pattern, repl)
else
return str
end
end
local function quotestring (value)
-- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js
value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8)
if strfind (value, "[\194\216\220\225\226\239]") then
value = fsub (value, "\194[\128-\159\173]", escapeutf8)
value = fsub (value, "\216[\128-\132]", escapeutf8)
value = fsub (value, "\220\143", escapeutf8)
value = fsub (value, "\225\158[\180\181]", escapeutf8)
value = fsub (value, "\226\128[\140-\143\168-\175]", escapeutf8)
value = fsub (value, "\226\129[\160-\175]", escapeutf8)
value = fsub (value, "\239\187\191", escapeutf8)
value = fsub (value, "\239\191[\176-\191]", escapeutf8)
end
return "\"" .. value .. "\""
end
json.quotestring = quotestring
local function replace(str, o, n)
local i, j = strfind (str, o, 1, true)
if i then
return strsub(str, 1, i-1) .. n .. strsub(str, j+1, -1)
else
return str
end
end
-- locale independent num2str and str2num functions
local decpoint, numfilter
local function updatedecpoint ()
decpoint = strmatch(tostring(0.5), "([^05+])")
-- build a filter that can be used to remove group separators
numfilter = "[^0-9%-%+eE" .. gsub(decpoint, "[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0") .. "]+"
end
updatedecpoint()
local function num2str (num)
return replace(fsub(tostring(num), numfilter, ""), decpoint, ".")
end
local function str2num (str)
local num = tonumber(replace(str, ".", decpoint))
if not num then
updatedecpoint()
num = tonumber(replace(str, ".", decpoint))
end
return num
end
local function addnewline2 (level, buffer, buflen)
buffer[buflen+1] = "\n"
buffer[buflen+2] = strrep (" ", level)
buflen = buflen + 2
return buflen
end
function json.addnewline (state)
if state.indent then
state.bufferlen = addnewline2 (state.level or 0,
state.buffer, state.bufferlen or #(state.buffer))
end
end
local encode2 -- forward declaration
local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder, state)
local kt = type (key)
if kt ~= 'string' and kt ~= 'number' then
return nil, "type '" .. kt .. "' is not supported as a key by JSON."
end
if prev then
buflen = buflen + 1
buffer[buflen] = ","
end
if indent then
buflen = addnewline2 (level, buffer, buflen)
end
-- When Lua is compiled with LUA_NOCVTN2S this will fail when
-- numbers are mixed into the keys of the table. JSON keys are always
-- strings, so this would be an implicit conversion too and the failure
-- is intentional.
buffer[buflen+1] = quotestring (key)
buffer[buflen+2] = ":"
return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder, state)
end
local function appendcustom(res, buffer, state)
local buflen = state.bufferlen
if type (res) == 'string' then
buflen = buflen + 1
buffer[buflen] = res
end
return buflen
end
local function exception(reason, value, state, buffer, buflen, defaultmessage)
defaultmessage = defaultmessage or reason
local handler = state.exception
if not handler then
return nil, defaultmessage
else
state.bufferlen = buflen
local ret, msg = handler (reason, value, state, defaultmessage)
if not ret then return nil, msg or defaultmessage end
return appendcustom(ret, buffer, state)
end
end
function json.encodeexception(reason, value, state, defaultmessage)
return quotestring("<" .. defaultmessage .. ">")
end
encode2 = function (value, indent, level, buffer, buflen, tables, globalorder, state)
local valtype = type (value)
local valmeta = getmetatable (value)
valmeta = type (valmeta) == 'table' and valmeta -- only tables
local valtojson = valmeta and valmeta.__tojson
if valtojson then
if tables[value] then
return exception('reference cycle', value, state, buffer, buflen)
end
tables[value] = true
state.bufferlen = buflen
local ret, msg = valtojson (value, state)
if not ret then return exception('custom encoder failed', value, state, buffer, buflen, msg) end
tables[value] = nil
buflen = appendcustom(ret, buffer, state)
elseif value == nil then
buflen = buflen + 1
buffer[buflen] = "null"
elseif valtype == 'number' then
local s
if value ~= value or value >= huge or -value >= huge then
-- This is the behaviour of the original JSON implementation.
s = "null"
else
s = num2str (value)
end
buflen = buflen + 1
buffer[buflen] = s
elseif valtype == 'boolean' then
buflen = buflen + 1
buffer[buflen] = value and "true" or "false"
elseif valtype == 'string' then
buflen = buflen + 1
buffer[buflen] = quotestring (value)
elseif valtype == 'table' then
if tables[value] then
return exception('reference cycle', value, state, buffer, buflen)
end
tables[value] = true
level = level + 1
local isa, n = isarray (value)
if n == 0 and valmeta and valmeta.__jsontype == 'object' then
isa = false
end
local msg
if isa then -- JSON array
buflen = buflen + 1
buffer[buflen] = "["
for i = 1, n do
buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder, state)
if not buflen then return nil, msg end
if i < n then
buflen = buflen + 1
buffer[buflen] = ","
end
end
buflen = buflen + 1
buffer[buflen] = "]"
else -- JSON object
local prev = false
buflen = buflen + 1
buffer[buflen] = "{"
local order = valmeta and valmeta.__jsonorder or globalorder
if order then
local used = {}
n = #order
for i = 1, n do
local k = order[i]
local v = value[k]
if v ~= nil then
used[k] = true
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
if not buflen then return nil, msg end
prev = true -- add a seperator before the next element
end
end
for k,v in pairs (value) do
if not used[k] then
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
if not buflen then return nil, msg end
prev = true -- add a seperator before the next element
end
end
else -- unordered
for k,v in pairs (value) do
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
if not buflen then return nil, msg end
prev = true -- add a seperator before the next element
end
end
if indent then
buflen = addnewline2 (level - 1, buffer, buflen)
end
buflen = buflen + 1
buffer[buflen] = "}"
end
tables[value] = nil
else
return exception ('unsupported type', value, state, buffer, buflen,
"type '" .. valtype .. "' is not supported by JSON.")
end
return buflen
end
function json.encode (value, state)
state = state or {}
local oldbuffer = state.buffer
local buffer = oldbuffer or {}
state.buffer = buffer
updatedecpoint()
local ret, msg = encode2 (value, state.indent, state.level or 0,
buffer, state.bufferlen or 0, state.tables or {}, state.keyorder, state)
if not ret then
error (msg, 2)
elseif oldbuffer == buffer then
state.bufferlen = ret
return true
else
state.bufferlen = nil
state.buffer = nil
return concat (buffer)
end
end
local function loc (str, where)
local line, pos, linepos = 1, 1, 0
while true do
pos = strfind (str, "\n", pos, true)
if pos and pos < where then
line = line + 1
linepos = pos
pos = pos + 1
else
break
end
end
return strformat ("line %d, column %d", line, where - linepos)
end
local function unterminated (str, what, where)
return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where)
end
local function scanwhite (str, pos)
while true do
pos = strfind (str, "%S", pos)
if not pos then return nil end
local sub2 = strsub (str, pos, pos + 1)
if sub2 == "\239\187" and strsub (str, pos + 2, pos + 2) == "\191" then
-- UTF-8 Byte Order Mark
pos = pos + 3
elseif sub2 == "//" then
pos = strfind (str, "[\n\r]", pos + 2)
if not pos then return nil end
elseif sub2 == "/*" then
pos = strfind (str, "*/", pos + 2)
if not pos then return nil end
pos = pos + 2
else
return pos
end
end
end
local escapechars = {
["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f",
["n"] = "\n", ["r"] = "\r", ["t"] = "\t"
}
local function unichar (value)
if value < 0 then
return nil
elseif value <= 0x007f then
return strchar (value)
elseif value <= 0x07ff then
return strchar (0xc0 + floor(value/0x40),
0x80 + (floor(value) % 0x40))
elseif value <= 0xffff then
return strchar (0xe0 + floor(value/0x1000),
0x80 + (floor(value/0x40) % 0x40),
0x80 + (floor(value) % 0x40))
elseif value <= 0x10ffff then
return strchar (0xf0 + floor(value/0x40000),
0x80 + (floor(value/0x1000) % 0x40),
0x80 + (floor(value/0x40) % 0x40),
0x80 + (floor(value) % 0x40))
else
return nil
end
end
local function scanstring (str, pos)
local lastpos = pos + 1
local buffer, n = {}, 0
while true do
local nextpos = strfind (str, "[\"\\]", lastpos)
if not nextpos then
return unterminated (str, "string", pos)
end
if nextpos > lastpos then
n = n + 1
buffer[n] = strsub (str, lastpos, nextpos - 1)
end
if strsub (str, nextpos, nextpos) == "\"" then
lastpos = nextpos + 1
break
else
local escchar = strsub (str, nextpos + 1, nextpos + 1)
local value
if escchar == "u" then
value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16)
if value then
local value2
if 0xD800 <= value and value <= 0xDBff then
-- we have the high surrogate of UTF-16. Check if there is a
-- low surrogate escaped nearby to combine them.
if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then
value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16)
if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then
value = (value - 0xD800) * 0x400 + (value2 - 0xDC00) + 0x10000
else
value2 = nil -- in case it was out of range for a low surrogate
end
end
end
value = value and unichar (value)
if value then
if value2 then
lastpos = nextpos + 12
else
lastpos = nextpos + 6
end
end
end
end
if not value then
value = escapechars[escchar] or escchar
lastpos = nextpos + 2
end
n = n + 1
buffer[n] = value
end
end
if n == 1 then
return buffer[1], lastpos
elseif n > 1 then
return concat (buffer), lastpos
else
return "", lastpos
end
end
local scanvalue -- forward declaration
local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta)
local tbl, n = {}, 0
local pos = startpos + 1
if what == 'object' then
setmetatable (tbl, objectmeta)
else
setmetatable (tbl, arraymeta)
end
while true do
pos = scanwhite (str, pos)
if not pos then return unterminated (str, what, startpos) end
local char = strsub (str, pos, pos)
if char == closechar then
return tbl, pos + 1
end
local val1, err
val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
if err then return nil, pos, err end
pos = scanwhite (str, pos)
if not pos then return unterminated (str, what, startpos) end
char = strsub (str, pos, pos)
if char == ":" then
if val1 == nil then
return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")"
end
pos = scanwhite (str, pos + 1)
if not pos then return unterminated (str, what, startpos) end
local val2
val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
if err then return nil, pos, err end
tbl[val1] = val2
pos = scanwhite (str, pos)
if not pos then return unterminated (str, what, startpos) end
char = strsub (str, pos, pos)
else
n = n + 1
tbl[n] = val1
end
if char == "," then
pos = pos + 1
end
end
end
scanvalue = function (str, pos, nullval, objectmeta, arraymeta)
pos = pos or 1
pos = scanwhite (str, pos)
if not pos then
return nil, strlen (str) + 1, "no valid JSON value (reached the end)"
end
local char = strsub (str, pos, pos)
if char == "{" then
return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta)
elseif char == "[" then
return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta)
elseif char == "\"" then
return scanstring (str, pos)
else
local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos)
if pstart then
local number = str2num (strsub (str, pstart, pend))
if number then
return number, pend + 1
end
end
pstart, pend = strfind (str, "^%a%w*", pos)
if pstart then
local name = strsub (str, pstart, pend)
if name == "true" then
return true, pend + 1
elseif name == "false" then
return false, pend + 1
elseif name == "null" then
return nullval, pend + 1
end
end
return nil, pos, "no valid JSON value at " .. loc (str, pos)
end
end
local function optionalmetatables(...)
if select("#", ...) > 0 then
return ...
else
return {__jsontype = 'object'}, {__jsontype = 'array'}
end
end
function json.decode (str, pos, nullval, ...)
local objectmeta, arraymeta = optionalmetatables(...)
return scanvalue (str, pos, nullval, objectmeta, arraymeta)
end
function json.use_lpeg ()
local g = require ("lpeg")
if type(g.version) == 'function' and g.version() == "0.11" then
error "due to a bug in LPeg 0.11, it cannot be used for JSON matching"
end
local pegmatch = g.match
local P, S, R = g.P, g.S, g.R
local function ErrorCall (str, pos, msg, state)
if not state.msg then
state.msg = msg .. " at " .. loc (str, pos)
state.pos = pos
end
return false
end
local function Err (msg)
return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall)
end
local function ErrorUnterminatedCall (str, pos, what, state)
return ErrorCall (str, pos - 1, "unterminated " .. what, state)
end
local SingleLineComment = P"//" * (1 - S"\n\r")^0
local MultiLineComment = P"/*" * (1 - P"*/")^0 * P"*/"
local Space = (S" \n\r\t" + P"\239\187\191" + SingleLineComment + MultiLineComment)^0
local function ErrUnterminated (what)
return g.Cmt (g.Cc (what) * g.Carg (2), ErrorUnterminatedCall)
end
local PlainChar = 1 - S"\"\\\n\r"
local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars
local HexDigit = R("09", "af", "AF")
local function UTF16Surrogate (match, pos, high, low)
high, low = tonumber (high, 16), tonumber (low, 16)
if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then
return true, unichar ((high - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000)
else
return false
end
end
local function UTF16BMP (hex)
return unichar (tonumber (hex, 16))
end
local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit))
local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP
local Char = UnicodeEscape + EscapeSequence + PlainChar
local String = P"\"" * (g.Cs (Char ^ 0) * P"\"" + ErrUnterminated "string")
local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0))
local Fractal = P"." * R"09"^0
local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1
local Number = (Integer * Fractal^(-1) * Exponent^(-1))/str2num
local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1)
local SimpleValue = Number + String + Constant
local ArrayContent, ObjectContent
-- The functions parsearray and parseobject parse only a single value/pair
-- at a time and store them directly to avoid hitting the LPeg limits.
local function parsearray (str, pos, nullval, state)
local obj, cont
local start = pos
local npos
local t, nt = {}, 0
repeat
obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state)
if cont == 'end' then
return ErrorUnterminatedCall (str, start, "array", state)
end
pos = npos
if cont == 'cont' or cont == 'last' then
nt = nt + 1
t[nt] = obj
end
until cont ~= 'cont'
return pos, setmetatable (t, state.arraymeta)
end
local function parseobject (str, pos, nullval, state)
local obj, key, cont
local start = pos
local npos
local t = {}
repeat
key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state)
if cont == 'end' then
return ErrorUnterminatedCall (str, start, "object", state)
end
pos = npos
if cont == 'cont' or cont == 'last' then
t[key] = obj
end
until cont ~= 'cont'
return pos, setmetatable (t, state.objectmeta)
end
local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray)
local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject)
local Value = Space * (Array + Object + SimpleValue)
local ExpectedValue = Value + Space * Err "value expected"
local ExpectedKey = String + Err "key expected"
local End = P(-1) * g.Cc'end'
local ErrInvalid = Err "invalid JSON"
ArrayContent = (Value * Space * (P"," * g.Cc'cont' + P"]" * g.Cc'last'+ End + ErrInvalid) + g.Cc(nil) * (P"]" * g.Cc'empty' + End + ErrInvalid)) * g.Cp()
local Pair = g.Cg (Space * ExpectedKey * Space * (P":" + Err "colon expected") * ExpectedValue)
ObjectContent = (g.Cc(nil) * g.Cc(nil) * P"}" * g.Cc'empty' + End + (Pair * Space * (P"," * g.Cc'cont' + P"}" * g.Cc'last' + End + ErrInvalid) + ErrInvalid)) * g.Cp()
local DecodeValue = ExpectedValue * g.Cp ()
jsonlpeg.version = json.version
jsonlpeg.encode = json.encode
jsonlpeg.null = json.null
jsonlpeg.quotestring = json.quotestring
jsonlpeg.addnewline = json.addnewline
jsonlpeg.encodeexception = json.encodeexception
jsonlpeg.using_lpeg = true
function jsonlpeg.decode (str, pos, nullval, ...)
local state = {}
state.objectmeta, state.arraymeta = optionalmetatables(...)
local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state)
if state.msg then
return nil, state.pos, state.msg
else
return obj, retpos
end
end
-- cache result of this function:
json.use_lpeg = function () return jsonlpeg end
jsonlpeg.use_lpeg = json.use_lpeg
return jsonlpeg
end
if always_use_lpeg then
return json.use_lpeg()
end
return json
liberationsans.ttf TrueType Font data, 19 tables, 1st "FFTM", 30 names, Macintoshmain.lua Unicode text, UTF-8 text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
local G,τ = love.graphics, 2*math.pi math.randomseed(os.time())
local BART=false
-- local pprint=require'pprint' pprint.setup{use_tostring=true}
local Pos = require'r.pos' local rmath = require'r.math' local class='r.class'
local qw = require'r.qw' local yves = G.newImage'bart.png' local yvesr=yves:getWidth()/2
local popsound = love.audio.newSource('popmono.wav','static')
local bartsound = love.audio.newSource('bartmono.wav','static')
local nodes = {} local nodes_free = {} local inters = {}
local function np(i) local nx,p = unpack(i) return nodes[nx],p,nx end
local function connect(i1,i2) local n1,p1,a1 = np(i1) local n2,p2,a2 = np(i2)
assert(n1) assert(n2) assert(p1<=#n1) assert(p2<=#n2)
n1[p1] = i2 n2[p2] = i1 if p1==1 and p2==1 then table.insert(inters,a2) end end
local function colfromhex(x) if x:sub(1,1) == '#' then x=x:sub(2) end
local o = {} for i=1,5,2 do table.insert(o,tonumber(x:sub(i,i+1),16)/255) end return o end
local node_types={
Z = {nports=1,color='#526B8E',r=15}, S = {nports=2,color='#FFE47A',r=10},
ε = {nports=1,color='#F4CDEC',r=10}, δ = {nports=3,color='#B1FBEA',r=10},
Add = {nports=3,color='#800000',r=20}, Hi={nports=1,color='#ffffff',r=10},
Mul = {nports=3,color='#004B00',r=20}, Exp={nports=3,color='#00ffff',r=30},
LyricLy = {nports=4,color='#00ff00',r=30}, -- LENS OUT S PROD
S1 = {nports=1,color='#ce722c',r=15},
S2 = {nports=1,color='#6a84a8',r=15},
C1 = {nports=2,color='#fe9e5b',r=10},
C2 = {nports=2,color='#9cb7de',r=10},
Flip = {nports=2,color='#884400',r=15},
Push = {nports=3,color='#0088bb',r=15},
Gate0 = {nports=3,color='#008800',r=17},
Gate1 = {nports=3,color='#00bb00',r=17},
} for k,v in pairs(node_types) do v.type = k v.color=colfromhex(v.color) end
local function mknode(type,pos,a)
local node = setmetatable({pos=pos,a=a,prev_pos=pos,prev_a=a},{__index=assert(node_types[type]),
__tostring=function(x)local o = x.type..'(' for _,c in ipairs(x) do o=o..'{'..c[1]..','..c[2]..'}'..',' end return o..')' end})
for i = 1,node.nports do node[i] = false end return node end
local function mknode2(type,pos,a) local n =mknode(type,pos,a)
table.insert(nodes,n) return #nodes,n end
-- for i=1,4 do local node = mknode'S' table.insert(nodes,node)
-- node.pos=Pos(50+25*i,rmath.sqlerp(40,140,math.sin(τ/20*i))) node.a = 0
-- local i = #nodes if i > 1 then connect({i-1,1},{i,2}) end end
-- local n0 = mknode'Z' table.insert(nodes,n0) n0.pos=Pos(20,100) n0.a=0 connect({#nodes,1},{1,2})
-- local n1 = mknode'δ' table.insert(nodes,n1) n1.pos=Pos(220,100) n1.a=0 connect({#nodes,1},{#nodes-2,1}) local a1=#nodes
-- -- local n2 = mknode'ε' table.insert(nodes,n2) n2.pos=Pos(250,80) n2.a=τ/2 connect({#nodes,1},{a1,2})
-- -- local n3 = mknode'ε' table.insert(nodes,n3) n3.pos=Pos(250,120) n3.a=τ/2 connect({#nodes,1},{a1,3})
-- local n4 = mknode'Exp' table.insert(nodes,n4) n4.pos=Pos(250,120) n4.a=τ/2 connect({#nodes,1},{a1,3}) connect({#nodes,2},{a1,2})
-- local n5 = mknode'Hi' local a5=table.insert(nodes,n5) n5.pos=Pos(300,120) n5.a=τ/2 connect({#nodes,1},{#nodes-1,3})
local nn0,N0 = mknode2('Hi',Pos(300,120),τ/2)
-- local nnp = mknode2('Push',Pos(400,120),0)
-- local prev={nn0,1} for i=1,3 do local nn=mknode2('C1',Pos(350,200+i*10),0) connect({nn,2},prev) prev={nn,1} end
-- connect({nnp,3},prev)
-- local nn1 = mknode2('S1',Pos(500,200),0)
-- local nd = mknode2('δ',Pos(500,250),0)
-- connect({nd,1},{nn1,1})
-- local ne = mknode2('ε',Pos(500,230),0)
-- connect({ne,1},{nd,3})
-- local nf = mknode2('Flip',Pos(450,200),0)
-- connect({nf,1},{nd,2})
-- connect({nnp,1},{nf,2})
-- local na=mknode2('C2',Pos(500,300),0)
-- connect({nnp,2},{na,2})
local ni1 = mknode2('C1',Pos(300,125),0)
local ni2 = mknode2('C2',Pos(300,125),0)
local ni3 = mknode2('C2',Pos(300,125),0)
local ni4 = mknode2('C1',Pos(300,125),0)
connect({ni1,1},{nn0,1})
connect({ni2,1},{ni1,2})
connect({ni3,1},{ni2,2})
connect({ni4,1},{ni3,2})
local nL = mknode2('LyricLy',Pos(400,120),0)
connect({ni4,2},{nL,2})
local nz0 = mknode2('S1',Pos(420,100),0)
connect({nz0,1},{nL,3})
local ng = mknode2('Gate0',Pos(400,150),0)
local nC1 = mknode2('C1',Pos(400,170),0)
local nC2 = mknode2('C2',Pos(400,180),0)
connect({nC2,1},{nC1,2})
connect({nC1,1},{ng,1})
connect({ng,3},{nL,1})
connect({nC2,2},{nL,4})
local nz2 = mknode2('Z',Pos(600,100),0)
local prev = {nz2,1} for i=1,95 do local nn = mknode2('S',Pos(600,100+i*10),0) connect(prev,{nn,2}) prev={nn,1} end
connect(prev,{ng,2})
for i,n in ipairs(nodes) do n.pos=n.pos+Pos(100,300) n.prev_pos = n.pos n.prev_a = n.a end
local function portpos(i) local n,p,a = np(i) return n.pos + Pos(n.r,0):rot(n.a+τ/n.nports*(p-1)) end
local font = G.newFont'liberationsans.ttf' local text=G.newText(font) G.setFont(font)
local function each_wire() return coroutine.wrap(function()
for i,n in pairs(nodes) do for p=1,n.nports do if n[p] and (n[p][1]>i or n[p][2]>p) then
coroutine.yield({i,p}, n[p]) end end end end) end
local function draw_nodes()
for i,n in pairs(nodes) do
G.push() G.translate(n.pos.x,n.pos.y)
G.setColor(n.color)
if BART then G.draw(yves,0,0,n.a,n.r/yvesr,nil,yvesr,yvesr) else G.circle('fill',0,0,n.r) end
G.setColor(0,0,0) G.circle('line',0,0,n.r)
text:set(n.type) local w,h = text:getDimensions()
G.setColor(0,0,0) G.draw(text,-w/2,-h/2) G.pop() end
G.setColor(0,0,0) for i1, i2 in each_wire() do
local e1,e2 = portpos(i1), portpos(i2)
G.line(e1.x,e1.y,e2.x,e2.y)
function tri(e1,e2) local p = rmath.lerp(e1,e2,0.2)
G.push() G.translate(p:vals()) G.rotate((e2-e1):angle())
G.setColor(0,0,0) G.polygon('fill',0,-6,0,6,6,0) G.pop() end
if i1[2] == 1 then tri(e1,e2) end if i2[2] == 1 then tri(e2,e1) end end end
local springlength,springconst = 20, 50
local repulsion,repulsionmaxdist = 100000,50
local function springs(dt) local accels,torques={},{}
local function exert(on,at,by)
local para = at-on.pos local perp = para:rot(τ/4)
if not accels[on] then accels[on] = Pos(0,0) end accels[on]:addby(by)
-- i don't know why this works better with a /10
torques[on] = (torques[on] or 0) + by:sproj(perp) * para:len()/10 end
for i1,i2 in each_wire() do
local n1,p1 = np(i1) local n2,p2 = np(i2) local pp1,pp2 = portpos(i1),portpos(i2)
local x = (pp1-pp2):len() - springlength local f = springconst * x
local dir = (pp2-pp1):norm() exert(n1,pp1,f*dir) exert(n2,pp2,-f*dir) end
for i,n in pairs(nodes) do for j,m in pairs(nodes) do if i<j then
local d = n.pos-m.pos if d:lensq() < repulsionmaxdist^2 then local f = d:norm()*repulsion/(d:len()^2)
if d:len() ~= 0 then exert(n,n.pos,f) exert(m,m.pos,-f) end end end end end
for i,n in pairs(nodes) do if n.type~='Hi' then
local d = n.pos-Pos(love.mouse.getPosition()) local f =d:norm()*repulsion/(d:len()^2)
exert(n,n.pos,f) end end
for i,n in pairs(nodes) do local pos,a = n.pos,n.a local new_pos,new_a = pos,a
if n.type ~= 'Hi' and accels[n] then new_pos = 2*pos - n.prev_pos + dt*dt*accels[n] n.prev_pos = pos end
if torques[n] then new_a = 2*a - n.prev_a + dt*dt*torques[n] n.prev_a = a end
n.pos = rmath.lerp(pos, new_pos, 0.8) n.a = rmath.lerp(a, new_a, 0.3)
n.pos.x = rmath.clamp(n.pos.x,0,G.getWidth()) n.pos.y = rmath.clamp(n.pos.y,0,G.getHeight()) end end
local pop,rules
local t,tp=0,3 function love.update(dt) t=t+dt for i=1,5 do springs(math.min(dt,1/30)) end
tp = tp - dt while tp < 0 do pop() tp = math.log(1-math.random())/(-2*#inters) end end
function love.keypressed(k,s,i) if not i and k=='f9' then BART=not BART love.window.setTitle((BART and 'BART' or 'KO')..'LAKOSKI') end end
function love.draw() G.clear(1,1,1) draw_nodes() G.origin() --[[G.print(tostring(tp),10,10)]] end
function love.mousemoved(x,y) if love.mouse.isDown(1) then N0.pos = Pos(x,y) end end
rules = {} local function addrule(t1,t2,s1,s2) if t2<t1 then t1,t2,s1,s2 = t2,t1,s2,s1 elseif t1==t2 then s2=s1 end
rules[t1..'__'..t2]={s1,s2} end
local N=setmetatable({},{__index=function(t,k) return setmetatable({type=k},{__call=function(f,...) return {type=k,...} end}) end})
addrule('ε','Z',{},{}) addrule('ε','S',{},{N.ε})
addrule('Add','Z',{'x','x'},{}) addrule('Add','S',{'b',N.S'z'},{N.Add('b','z')})
-- addrule('δ','Z',{N.Z,N.Z},{}) addrule('δ','S',{N.S'x',N.S'y'},{N.δ('x','y')})
addrule('Mul','Z',{N.ε,N.Z}) addrule('S','Mul',{N.Mul('b2','t')},{N.δ(N.Add('t','z'),'b2'),'z'})
addrule('Exp','Z',{N.ε,N.S(N.Z)},{}) addrule('Exp','S',{N.δ(N.Mul('t','z'),'b2'),'z'},{N.Exp('b2','t')})
addrule('Push','S1',{N.C1('a'),'a'},{}) addrule('Push','S2',{N.C2('a'),'a'},{})
addrule('Flip','S1',{N.S2},{}) addrule('Flip','S2',{N.S1},{})
addrule('ε','S1',{},{}) addrule('ε','S2',{},{})
addrule('ε','C1',{},{N.ε}) addrule('ε','C2',{},{N.ε})
addrule('δ','S1',{N.S1,N.S1},{}) addrule('δ','S2',{N.S2,N.S2},{})
addrule('ε','LyricLy',{},{N.ε,N.ε,N.ε})
-- WHERE THE MAGIC HAPPENS
addrule('C1','LyricLy',{N.LyricLy('x1','x2','x3')},{N.C1('x1'),N.δ(N.Push('prod','x3'),N.Flip('x2')),'prod'})
addrule('C2','LyricLy',{N.LyricLy('x1','x2','x3')},{N.C2('x1'),N.δ(N.δ(N.Push('prod','i'),N.Push('i','x3')),N.Flip('x2')),'prod'})
-- WHERE THE MAGIC HAPPENS
addrule('C1','Gate0',{'rest'},{N.Gate1('x2','rest'),N.C1('x2')})
addrule('C2','Gate0',{'rest'},{N.Gate1('x2','rest'),N.C2('x2')})
addrule('S','Gate1',{'n'},{'x3',N.Gate0('n','x3')})
addrule('Z','Gate1',{},{N.ε,N.ε})
addrule('ε','ε',{},{})
-- local function pick() local hasde,hasany,types = {},{},qw.s"δ ε"
-- for i,nx in ipairs(inters) do table.insert(hasany,i) local n = assert(nodes[nx],'huh?')
-- if types[n.type] or types[nodes[n[1][1]].type] then table.insert(hasde,i) end end
-- local rix if #hasde>0 then rix=hasde[math.random(#hasde)] else rix=hasany[math.random(#hasany)] end
-- return table.remove(inters,rix) end
pop = function() if #inters == 0 then return end --local a1=pick()
local a1 = table.remove(inters,math.random(#inters))
local n1 = assert(nodes[a1]) local n2,p2,a2 = np(n1[1]) assert(n2 and p2==1)
if n2.type<n1.type then n1,p1,a1,n2,p2,a2 = n2,p2,a2,n1,p1,a1 end
local rule = rules[n1.type..'__'..n2.type] if (not rule) or rule.disabled then return end
local s1,s2 = unpack(rule)
local function remove(ix) nodes[ix] = nil nodes_free[ix]=true end
local function insert(n) local ix = next(nodes_free)
if ix then nodes_free[ix]=nil nodes[ix]=n return ix else table.insert(nodes,n) return #nodes end end
local bary = (n1.pos+n2.pos)/2 local baryr = (n1.pos-n2.pos):len()/2
remove(a1) remove(a2) local named={} local function build(onto,pattern)
if type(pattern) == 'string' then
if named[pattern] == nil then named[pattern] = onto
else connect(onto,named[pattern]) named[pattern]='did it already' end
else assert(type(pattern)=='table','aaa '..type(pattern))
local nports=node_types[pattern.type].nports assert(#pattern+1 == nports)
local ang = math.random()*τ local offs = Pos(math.random()*baryr,0):rot(ang)
local n = mknode(pattern.type,bary+offs,ang) n.prev_pos=bary-offs local a = insert(n)
connect({a,1},onto) for p=2,nports do build({a,p},pattern[p-1]) end end end
for p=2,n1.nports do build(n1[p],s1[p-1]) end for p=2,n2.nports do build(n2[p],s2[p-1]) end
local snd,pitch = (BART and bartsound or popsound):clone(),30/(n1.r+n2.r) snd:setPitch(pitch) snd:play() end
-- local profile = require"jit.profile" local function profile_start(period,file)
-- local function cb(thread,samples,vmstate)
-- file:write(profile.dumpstack(thread,"pF;l;",-100),vmstate," ",samples,"\n") end
-- profile.start("vli"..tonumber(period), cb)
-- end
-- function love.load() profile_start(10,io.open('./trace','w')) end
pop.wav RIFF (little-endian) data, WAVE audio, Microsoft PCM, 24 bit, stereo 44100 Hz
1cg: couldn't decode file contents
popmono.wav RIFF (little-endian) data, WAVE audio, Microsoft PCM, 16 bit, mono 44100 Hz
1cg: couldn't decode file contents
pprint.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
-- https://github.com/jagt/pprint.lua/blob/master/pprint.lua
-- public domain
local pprint = { VERSION = '0.1' }
local depth = 1
pprint.defaults = {
-- If set to number N, then limit table recursion to N deep.
depth_limit = false,
-- type display trigger, hide not useful datatypes by default
-- custom types are treated as table
show_nil = true,
show_boolean = true,
show_number = true,
show_string = true,
show_table = true,
show_function = false,
show_thread = false,
show_userdata = false,
-- additional display trigger
show_metatable = false, -- show metatable
show_all = false, -- override other show settings and show everything
use_tostring = false, -- use __tostring to print table if available
filter_function = nil, -- called like callback(value[,key, parent]), return truty value to hide
object_cache = 'local', -- cache blob and table to give it a id, 'local' cache per print, 'global' cache
-- per process, falsy value to disable (might cause infinite loop)
-- format settings
indent_size = 2, -- indent for each nested table level
level_width = 80, -- max width per indent level
wrap_string = true, -- wrap string when it's longer than level_width
wrap_array = false, -- wrap every array elements
sort_keys = true, -- sort table keys
}
local TYPES = {
['nil'] = 1, ['boolean'] = 2, ['number'] = 3, ['string'] = 4,
['table'] = 5, ['function'] = 6, ['thread'] = 7, ['userdata'] = 8
}
-- seems this is the only way to escape these, as lua don't know how to map char '\a' to 'a'
local ESCAPE_MAP = {
['\a'] = '\\a', ['\b'] = '\\b', ['\f'] = '\\f', ['\n'] = '\\n', ['\r'] = '\\r',
['\t'] = '\\t', ['\v'] = '\\v', ['\\'] = '\\\\',
}
-- generic utilities
local function escape(s)
s = s:gsub('([%c\\])', ESCAPE_MAP)
local dq = s:find('"')
local sq = s:find("'")
if dq and sq then
return s:gsub('"', '\\"'), '"'
elseif sq then
return s, '"'
else
return s, "'"
end
end
local function is_plain_key(key)
return type(key) == 'string' and key:match('^[%a_][%a%d_]*$')
end
local CACHE_TYPES = {
['table'] = true, ['function'] = true, ['thread'] = true, ['userdata'] = true
}
-- cache would be populated to be like:
-- {
-- function = { `fun1` = 1, _cnt = 1 }, -- object id
-- table = { `table1` = 1, `table2` = 2, _cnt = 2 },
-- visited_tables = { `table1` = 7, `table2` = 8 }, -- visit count
-- }
-- use weakrefs to avoid accidentall adding refcount
local function cache_apperance(obj, cache, option)
if not cache.visited_tables then
cache.visited_tables = setmetatable({}, {__mode = 'k'})
end
local t = type(obj)
-- TODO can't test filter_function here as we don't have the ix and key,
-- might cause different results?
-- respect show_xxx and filter_function to be consistent with print results
if (not TYPES[t] and not option.show_table)
or (TYPES[t] and not option['show_'..t]) then
return
end
if CACHE_TYPES[t] or TYPES[t] == nil then
if not cache[t] then
cache[t] = setmetatable({}, {__mode = 'k'})
cache[t]._cnt = 0
end
if not cache[t][obj] then
cache[t]._cnt = cache[t]._cnt + 1
cache[t][obj] = cache[t]._cnt
end
end
if t == 'table' or TYPES[t] == nil then
if cache.visited_tables[obj] == false then
-- already printed, no need to mark this and its children anymore
return
elseif cache.visited_tables[obj] == nil then
cache.visited_tables[obj] = 1
else
-- visited already, increment and continue
cache.visited_tables[obj] = cache.visited_tables[obj] + 1
return
end
for k, v in pairs(obj) do
cache_apperance(k, cache, option)
cache_apperance(v, cache, option)
end
local mt = getmetatable(obj)
if mt and option.show_metatable then
cache_apperance(mt, cache, option)
end
end
end
-- makes 'foo2' < 'foo100000'. string.sub makes substring anyway, no need to use index based method
local function str_natural_cmp(lhs, rhs)
while #lhs > 0 and #rhs > 0 do
local lmid, lend = lhs:find('%d+')
local rmid, rend = rhs:find('%d+')
if not (lmid and rmid) then return lhs < rhs end
local lsub = lhs:sub(1, lmid-1)
local rsub = rhs:sub(1, rmid-1)
if lsub ~= rsub then
return lsub < rsub
end
local lnum = tonumber(lhs:sub(lmid, lend))
local rnum = tonumber(rhs:sub(rmid, rend))
if lnum ~= rnum then
return lnum < rnum
end
lhs = lhs:sub(lend+1)
rhs = rhs:sub(rend+1)
end
return lhs < rhs
end
local function cmp(lhs, rhs)
local tleft = type(lhs)
local tright = type(rhs)
if tleft == 'number' and tright == 'number' then return lhs < rhs end
if tleft == 'string' and tright == 'string' then return str_natural_cmp(lhs, rhs) end
if tleft == tright then return str_natural_cmp(tostring(lhs), tostring(rhs)) end
-- allow custom types
local oleft = TYPES[tleft] or 9
local oright = TYPES[tright] or 9
return oleft < oright
end
-- setup option with default
local function make_option(option)
if option == nil then
option = {}
end
for k, v in pairs(pprint.defaults) do
if option[k] == nil then
option[k] = v
end
if option.show_all then
for t, _ in pairs(TYPES) do
option['show_'..t] = true
end
option.show_metatable = true
end
end
return option
end
-- override defaults and take effects for all following calls
function pprint.setup(option)
pprint.defaults = make_option(option)
end
-- format lua object into a string
function pprint.pformat(obj, option, printer)
option = make_option(option)
local buf = {}
local function default_printer(s)
table.insert(buf, s)
end
printer = printer or default_printer
local cache
if option.object_cache == 'global' then
-- steal the cache into a local var so it's not visible from _G or anywhere
-- still can't avoid user explicitly referentce pprint._cache but it shouldn't happen anyway
cache = pprint._cache or {}
pprint._cache = nil
elseif option.object_cache == 'local' then
cache = {}
end
local last = '' -- used for look back and remove trailing comma
local status = {
indent = '', -- current indent
len = 0, -- current line length
}
local wrapped_printer = function(s)
printer(last)
last = s
end
local function _indent(d)
status.indent = string.rep(' ', d + #(status.indent))
end
local function _n(d)
wrapped_printer('\n')
wrapped_printer(status.indent)
if d then
_indent(d)
end
status.len = 0
return true -- used to close bracket correctly
end
local function _p(s, nowrap)
status.len = status.len + #s
if not nowrap and status.len > option.level_width then
_n()
wrapped_printer(s)
status.len = #s
else
wrapped_printer(s)
end
end
local formatter = {}
local function format(v)
local f = formatter[type(v)]
f = f or formatter.table -- allow patched type()
if option.filter_function and option.filter_function(v, nil, nil) then
return ''
else
return f(v)
end
end
local function tostring_formatter(v)
return tostring(v)
end
local function number_formatter(n)
return n == math.huge and '[[math.huge]]' or tostring(n)
end
local function nop_formatter(v)
return ''
end
local function make_fixed_formatter(t, has_cache)
if has_cache then
return function (v)
return string.format('[[%s %d]]', t, cache[t][v])
end
else
return function (v)
return '[['..t..']]'
end
end
end
local function make_userdata_formatter(has_cache)
local function utype(v)
local mt = getmetatable(v)
if not mt then return '?' end
return mt.__name or '?'
end
if has_cache then
return function(v)
return string.format('[[userdata <%s> %d]]', utype(v), cache.userdata[v])
end
else
return function (v)
return string.format('[[userdata <%s>]]', utype(v))
end
end
end
local function string_formatter(s, force_long_quote)
local s, quote = escape(s)
local quote_len = force_long_quote and 4 or 2
if quote_len + #s + status.len > option.level_width then
_n()
-- only wrap string when is longer than level_width
if option.wrap_string and #s + quote_len > option.level_width then
-- keep the quotes together
_p('[[')
while #s + status.len >= option.level_width do
local seg = option.level_width - status.len
_p(string.sub(s, 1, seg), true)
_n()
s = string.sub(s, seg+1)
end
_p(s) -- print the remaining parts
return ']]'
end
end
return force_long_quote and '[['..s..']]' or quote..s..quote
end
local function table_formatter(t)
if option.use_tostring then
local mt = getmetatable(t)
if mt and mt.__tostring then
-- return string_formatter(tostring(t), true)
return tostring(t)
end
end
local print_header_ix = nil
local ttype = type(t)
if option.object_cache then
local cache_state = cache.visited_tables[t]
local tix = cache[ttype][t]
-- FIXME should really handle `cache_state == nil`
-- as user might add things through filter_function
if cache_state == false then
-- already printed, just print the the number
return string_formatter(string.format('%s %d', ttype, tix), true)
elseif cache_state > 1 then
-- appeared more than once, print table header with number
print_header_ix = tix
cache.visited_tables[t] = false
else
-- appeared exactly once, print like a normal table
end
end
local limit = tonumber(option.depth_limit)
if limit and depth > limit then
if print_header_ix then
return string.format('[[%s %d]]...', ttype, print_header_ix)
end
return string_formatter(tostring(t), true)
end
local tlen = #t
local wrapped = false
_p('{')
_indent(option.indent_size)
_p(string.rep(' ', option.indent_size - 1))
if print_header_ix then
_p(string.format('--[[%s %d]] ', ttype, print_header_ix))
end
for ix = 1,tlen do
local v = t[ix]
if formatter[type(v)] == nop_formatter or
(option.filter_function and option.filter_function(v, ix, t)) then
-- pass
else
if option.wrap_array then
wrapped = _n()
end
depth = depth+1
_p(format(v)..', ')
depth = depth-1
end
end
-- hashmap part of the table, in contrast to array part
local function is_hash_key(k)
if type(k) ~= 'number' then
return true
end
local numkey = math.floor(tonumber(k))
if numkey ~= k or numkey > tlen or numkey <= 0 then
return true
end
end
local function print_kv(k, v, t)
-- can't use option.show_x as obj may contain custom type
if formatter[type(v)] == nop_formatter or
formatter[type(k)] == nop_formatter or
(option.filter_function and option.filter_function(v, k, t)) then
return
end
wrapped = _n()
if is_plain_key(k) then
_p(k, true)
else
_p('[')
-- [[]] type string in key is illegal, needs to add spaces inbetween
local k = format(k)
if string.match(k, '%[%[') then
_p(' '..k..' ', true)
else
_p(k, true)
end
_p(']')
end
_p(' = ', true)
depth = depth+1
_p(format(v), true)
depth = depth-1
_p(',', true)
end
if option.sort_keys then
local keys = {}
for k, _ in pairs(t) do
if is_hash_key(k) then
table.insert(keys, k)
end
end
table.sort(keys, cmp)
for _, k in ipairs(keys) do
print_kv(k, t[k], t)
end
else
for k, v in pairs(t) do
if is_hash_key(k) then
print_kv(k, v, t)
end
end
end
if option.show_metatable then
local mt = getmetatable(t)
if mt then
print_kv('__metatable', mt, t)
end
end
_indent(-option.indent_size)
-- make { } into {}
last = string.gsub(last, '^ +$', '')
-- peek last to remove trailing comma
last = string.gsub(last, ',%s*$', ' ')
if wrapped then
_n()
end
_p('}')
return ''
end
-- set formatters
formatter['nil'] = option.show_nil and tostring_formatter or nop_formatter
formatter['boolean'] = option.show_boolean and tostring_formatter or nop_formatter
formatter['number'] = option.show_number and number_formatter or nop_formatter -- need to handle math.huge
formatter['function'] = option.show_function and make_fixed_formatter('function', option.object_cache) or nop_formatter
formatter['thread'] = option.show_thread and make_fixed_formatter('thread', option.object_cache) or nop_formatter
-- formatter['userdata'] = option.show_userdata and make_fixed_formatter('userdata', option.object_cache) or nop_formatter
formatter['userdata'] = option.show_userdata and make_userdata_formatter(option.object_cache) or nop_formatter
formatter['string'] = option.show_string and string_formatter or nop_formatter
formatter['table'] = option.show_table and table_formatter or nop_formatter
if option.object_cache then
-- needs to visit the table before start printing
cache_apperance(obj, cache, option)
end
_p(format(obj))
printer(last) -- close the buffered one
-- put cache back if global
if option.object_cache == 'global' then
pprint._cache = cache
end
return table.concat(buf)
end
-- pprint all the arguments
function pprint.pprint( ... )
local args = {...}
-- select will get an accurate count of array len, counting trailing nils
local len = select('#', ...)
for ix = 1,len do
pprint.pformat(args[ix], nil, io.write)
io.write('\t')
end
if len > 0 then
io.write('\n')
end
end
setmetatable(pprint, {
__call = function (_, ...)
pprint.pprint(...)
end
})
return pprint
comments 0
post a comment
oldbnengb.yp ASCII text, with very long lines (466)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# kolkaoksit is defined as the run legnths encoding of the kokkalsoi sequnece
# we need to omcpute one hundred terms of hte kolksaoksi systme
# secuqnece
# so we need one hundred runs lenghts of the kolakoasi sequcense to liost at
# ksf
koklklk = [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1]
koklslk = []
# too kkkkkeep track of whk where' lookings
lookins = 1 # tmeporaory
lookings = 0 # i forgotr why ityped this
#ok
#OH IForgot
# ocunt
count = 0
for i in koklklk:
tmeproary = i
if tmeproary == lookins:
count +=1
else:
koklslk.append(count)
count = 1
lookins = tmeproary
print(koklslk)
oldenburg.ua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
0 [1]
pop do (
fork pick below (last pop)
-1
switch(
fix +3 neg
| coupon (+3 neg)
)
fork (+1 gi|back join dgi)
| <100 len gi
)
take 100
# I'm a bit snick and snired
# What's the point of typoes
# and comma splices and fake
# signatures if you shrimply
# do the right thing instead
# I should just have fun and
# have the wombats ride free
# That's snailsick and snail
# tired if you're new around
# here i am just using slang
comments 0
post a comment
cg1100100.lua ASCII text
1
2
3
4
5
6
7
8
local s = {1}
local n = 2
for p = 2, 66 do
table.insert(s, n)
if s[p] == 2 then table.insert(s, n) end
n = (n == 1) and 2 or 1
end
print(table.concat(s, ","))
Doesn't parse, mismatched parenthesis on line 40 i think you need to move the erring closing parenthesis before the comma all the way to the end Indeed! Its execution looks pretty coolcomments 3
olus2000 ¶Life replying to olus2000 ¶Olek Sabak ¶post a comment
no_no_no_my_counter_is_ruined.py Unicode text, UTF-8 text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from copy import copy
from time import sleep #for suspenseful purposes
from itertools import zip_longest,starmap #gotta have long enough zippers and locatory mechanisms when your robes are as spacefaring as these
strist=lambda col=0: lambda l: '['+''.join(map(('░▒▓█' if col else '░█').__getitem__,l))+']' #string-list portcreateaure(portmanteau-creature)
dbg=lambda x,*a: (x,print('\n'.join(map(strist(),a+(x,)))))[0]
X=lambda f: (lambda g: g(g))(lambda g: f(lambda: g(g))) #much better than the Y combinator whatever that thing is
watch=lambda x: bool(x and x[0]) #they watch
bite=lambda x: bool(x and x.pop(0)) #bites you tee hee
"""help me i have forgotten how to count
i am trying to count in binary but all i get is this weird sequence
my binary counter is developing dendritic tendrils everywhere
why are the least-place-value bits beckoning to me so ominously... whatever could be their significance"""
def feast(eu,cond,old,meal,other,val):
new=[]
while cond():
new.append(meal())
if eu==2: print(strist(1)(weave(*(new+old(),other)[::(-1)**val])),end='\r');sleep(1/2**5)
return new
weave=lambda x,y: starmap(lambda i,j: i|j<<1,zip_longest(x,y,fillvalue=0))
def kolakoski(eu=0): #you see i ran out of letters and had to use the vowels in debug
yield 1
x=[];y=[1]
while 1:
if eu: print(strist(1)(weave(y,x)),2-watch(x));sleep(1/2**4)
yield 2-watch(x)
z=copy(y)
if eu:
z=feast(eu,lambda: not bite(z),lambda: x,lambda: not bite(x),y,1)+x
x=[bite(z)]+z
yy=feast(eu,munch:=lambda: bite(y)|bite(z),lambda: y,lambda: 0,x,0)+[1]
while y: yy.append(munch())
y=yy
else: #i think this way is much more elegant and neatly tessellated together
#but unfortunately humans appear to have eyes instead of brains that can execute and appreciate Python rapidly in their mind
#sigh my art form shall forever remain beyond your species
x,y=[bite(z:=X(lambda f: x if bite(z) else [not bite(x)]+f()))]+z),X(lambda f: [0]+f() if (munch:=lambda: bite(y)|bite(z))() else [1]+X(lambda g: y and [munch()]+g())
K = kolakoski(2) #2 to watch it traverse turingfully in real time, 1 to just see the states, 0 if it's okay because you can already taste RAM
print([next(K) for _ in range(100)])
'''btw (highly spoilerful; i recommend you dedicate yourself wholly to deciphering my pythology first)
this is just doing https://11011110.github.io/blog/2016/10/14/kolakoski-sequence-via.html if you are wondering'''
comments 0
post a comment
cg100.c ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include <stdio.h>
#include <stdlib.h>
#define LEFT 1
#define RIGHT 2
typedef struct item {
int value;
struct item* left;
struct item* right;
} Item;
typedef struct queue {
Item** queue;
int start;
int end;
} Queue;
void dequeue(Queue* queue) {
if(queue->start != queue->end) {
// not working, seems to be coming from this function
printf("%d\n", (queue->queue)[queue->start]->value);
queue->start++;
}
}
Item* peek(Queue* queue) {
return queue->queue[queue->start];
}
void enqueue(Queue* queue, Item* item) {
(queue->queue)[queue->end] = item;
queue->end += 1;
}
int hasLeft(Item* item) {
if(item->value >= LEFT) {
return 1;
}
return 0;
}
int hasRight(Item* item) {
if(item->value >= RIGHT) {
return 1;
}
return 0;
}
void traversal(Item* tree) {
int depth = 0;
Item *queueArr[1000];
Queue queue;
queue.queue = queueArr;
queue.start = 0;
queue.end = 0;
Item* node = tree;
while(depth < 10000) {
if(depth == 99) {
printf("2\n"); // can't figure out the crash :(
}
dequeue(&queue);
if(hasLeft(node)) {
node->left->value = depth % 2 + 1;
enqueue(&queue, node->left);
}
node = peek(&queue);
if(hasRight(node)) {
node->right->value = depth % 2 + 1;
enqueue(&queue, node->right);
}
node = peek(&queue);
depth++;
}
}
Item* genTree(int depth) {
if(depth == 0) {
return 0;
}
Item* parent = malloc(sizeof(Item));
parent->left = genTree(depth - 1);
parent->right = genTree(depth - 1);
parent->value = 1;
return parent;
}
int main() {
Item* tree = genTree(12);
traversal(tree);
free(tree);
}
comments 0
post a comment
SQLite Script.sql ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
-- Output Table
CREATE TABLE sequence (
i INTEGER PRIMARY KEY
, value INTEGER
);
-- Range Table
CREATE TABLE ranges (
value INTEGER
, iteration INTEGER
);
CREATE VIEW output
AS
SELECT group_concat(value)
FROM sequence
WHERE i < 100
ORDER BY i;
-- Generate new number batch
CREATE TRIGGER gen
INSTEAD OF INSERT ON output
FOR EACH ROW
BEGIN
INSERT OR IGNORE
INTO sequence
SELECT
count(value) OVER (ORDER BY i ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW)
, i % 2 + 1
FROM sequence
NATURAL JOIN ranges;
END;
INSERT INTO ranges
VALUES (1, 0), (2, 0), (2, 1);
INSERT INTO sequence
VALUES (0, 1), (1, 2);
-- Trigger 10 times
INSERT INTO output
VALUES ('0'), ('1'), ('2'), ('3'), ('4'), ('5'), ('6'), ('7'), ('8'), ('9');
SELECT *
FROM output;
you can run this with the --debug flag enabled to see the desugared program code and final stack statecomments 1
[cg's #12] ¶post a comment
thank you code guessing <3.py Unicode text, UTF-8 text, with very long lines (21340)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
# it's the 100th anniversary of Code Guessing!!!
# how the years fly by so fast...
#
# thank you so much for all the amazing rounds,
# for all the mind-blowing entries,
# for all the clever social deductions,
# for all the silly gimmick rounds,
# for all the really cool challenges and also the boring ones,
# for all the features on the website, and how they've grown over time,
# for all the annoying language restrictions,
# for all the anonymous chatters that decided to join #announcements,
# for all the cool games everyone has made,
# for all the languages made for the purpose of CG,
# for all the entries attributed to SoundOfSpouting#6980 (UID: 151149148639330304),
# for all the times boris johnson had to step in to break a tie,
# for all the malware entries that leak your submission,
# for all the statistical analysis of player patterns,
# for all the shufflers that don't even try to guess,
# for all the oldies that have stuck with CG since single-digit rounds,
# for all the players that burnt out and quit,
# for all the newbies that started after joining the code guessing server,
# for razetime, how we miss you always,
# for LyricLy for all the work you've done over the years to grow Code Guessing into something beautiful.
#
# but reminiscing aside. it's time for me to submit my code
# i hope you like it :) i have a suspicion you might
# scroll all the way to the bottom if you want to just see the kolakoski implementation!
#
# below is the obligatory suspicious first line of code
# you've learned to skip past these by now, right? ^-^
with (lambda g = {}, src="": exec(b"".join([bytes([int(src[i:i+8].replace("\u200b", "0").replace("\u200c", "1"), 2)]) for i in range(0, len(src), 8)]), g) or g)()["poy"]:
# =============================================
# = =
# = [[[[]]]][[ ]][[[[]]] ][[[] ]] =
# = [[[[] ]] ][[[] ]] [[[[] ]] =
# = ][[[] ]] [[[[] ]] ][[[] ]] =
# = [[[[]]]][[ ]][[[ [] ]]][[[] =
# = ]][[[ []]]] [[ []]][ =
# = [[[]] ]][[[ ]] ][[[[ =
# = ]]]][ [[]]][[[[ ]]]][ =
# = =
# = [[]]] [[[[]]]] =
# = [[[[[[[ []]] ]] =
# = ]]][[[[]] ]][[ [ ]] =
# = ][[[[] ]]][ [ [] =
# = ]][[[[ ]]]] [ [] =
# = ][[[[] ]]][[ []]] [[ =
# = [[]]]] [[[]] ][[[[]]] =
# = =
# = =
# = ][[[ ]]][ =
# = [[ [] ]] ][ =
# = [[ ]] ][ [[ =
# = =
# = []]] ][[[ =
# = ]]][ [[[] =
# = ]]][ [[]]][ [[[] =
# = ]]][ [[]] ][[[ []]] =
# = ][[[[[[[ [[]]]] =
# = ]]] ]] =
# = =
# =============================================
#
# POY (short for Python cOncatenative programmYng) is a concatenative
# programming language that uses [] characters for its source code.
# It's somewhat Factor-flavored, despite rhyming with Joy.
# The language is implemented, as you'd expect, as a DSL within Python :3
#
# POY is stack-based, and its source code is a sequence of concatenated and nested quotations.
# These are written in syntax as one would expect: [], [[]], [][[]], etc.
# However, an empty quotation is not allowed to be on the right side of a concatenation.
# Any whitespace in the source code is ignored.
#
# Certain kinds of concatenated quotations in POY have special meaning.
# In particular, a sequence of three quotations in a row is defined as a word call.
# Example: [] [[[]]] [[]]
# The leftmost quotation is pushed onto the stack. The middle quotation defines
# the namespace of the word being called; this determines how the rightmost
# quotation is interpreted. The middle and right quotations are a (possibly revursively nested) quotation
# without any concatenations, and the depth of its nesting is used as an index.
# The first index is called the namespace index, and the second index is called the word index.
# Together, these are used to execute a given piece of functionality within the runtime.
#
# As a special case, if the namespace index is 1, i.e. the middle quotation is [[]],
# the right quotation is instead called against the current stack. In this special case,
# the right quotation is allowed to contain concatenations in its subtree as well.
#
# The set of words included in the POY 1.0 runtime are included below.
# Each line begins with the namespace and word index, and ends with a namespaced word.
# These words are not documented, but you should be able to understand their behavior
# from their names alone.
# 2, 1: base/swap
# 2, 2: base/dup
# 2, 3: base/drop
# 2, 4: base/call
# 2, 5: base/quote
# 2, 6: base/over
# 2, 7: base/swapd
# 2, 8: base/dupd
# 2, 9: base/nip
# 2, 10: base/rot
# 2, 11: base/-rot
# 3, 1: number/0
# 3, 2: number/++
# 3, 3: number/--
# 3, 4: number/+
# 3, 5: number/-
# 3, 6: number/neg
# 3, 7: number/*
# 3, 8: number/div
# 3, 9: number/floordiv
# 3, 10: number/%
# 3, 11: number/pow
# 3, 12: number/round
# 4, 1: array/new
# 4, 2: array/push
# 4, 3: array/get
# 4, 4: array/iota
# 4, 5: array/map
# 5, 1: combinator/2dup
# 5, 2: combinator/dip
# 5, 3: combinator/keep
# 5, 4: combinator/times
# 6, 1: boolean/t
# 6, 2: boolean/f
# 6, 3: boolean/if
# 7, 1: io/.
#
#
#
# Now: time for sans undertale
[[][[[]]][[[[]]]][
[[[[ ]]]]
][ []
][ [[
[] ]]
][ []][[[ []
]] ][[[]] ][
[[ [[]]]] ][ [[]]][ [[
[] ]]][[] ][
[[[] ]] ][ []][
[] ][[[][[[]]][[[[]]]][[[ []
]] ][ [] ][ [[ [] ]]
][[[ ]]][[[[]]]][[[ ]]][
[[[]]]][[[ [[[[[[[]]]
]] ]]]]][[[[]]]][[]][[[[]]]][[[]] ][
[[[] ]] ][ [[ ]] ][ [[[]
]] ][ [[[[[[ []]]]] ]] ][
[[ []]] ][[]][ [[ []]]][ [[]] ][
[[ [] ]] ][ [[ ]]
][ [[ [] ]] ][ [[
[[ ]] ]]][ []][ [[ ][
[[]] ][ [[ [] ]] ][[[
]]][[[ ]]][[]][[[][[[ ]]][[[
[]]] ][[[[[]]]]][[[ []]]
]]][[[[[[]]]]]][[[]]]]][[[[[[]]]]]
][[[]]][[[]]][[[ [[[[[[[[]]]]]]]]
]]][[[[]]]][ [[[[[]]]]]][
[[]]][ [[ ]] ][[[[]
]] ][[] ][[[ []
]]][[[]]][ [[[]]]][[[
]]][[[[]]]][[[]]][
[[[] ]]][
[[ ]]
][ [[
[] ]]
][ [[]]][ [[
[] ]]][[[ [[
[[ [[[[[] ]] ]]]]]] ]]
][ [[[]]] ][
[]][ [[ [] ]]][
[[ ]]][[[[]]]][[[]]][[[[] ]]
][ [[ ]] ][ [[ [] ]]
][[[ ]]][[[[]]]][[] ][[[
[]]]][[[]] ][[[[]]]][
[[ ]]][[[[]]]][[[]]][[[[]]]][[[[[ [[
[]]] ]] ]] ][ [[ [] ]]][
[[ [[ [[[[]] ]]]]]] ][ [[
]] ][[[ [[[[]] ]] ]]][[[ []]] ][
[] ][ [[ [] ]] ][
[[ ]] ][ [[ [] ]]
][ [[ ]]][ [[[] ]] ][
[[]] ][ [[ [] ]] ][[[
]]][[[ []]]][[[[[[[[[ [[[]]]
]]]] ]]]]][[[[]]]][ []][
[[[]]]][[[]]][[[[]]]][[[]]][[[[]]]
][[[]]][[[[]]]][ [[]]][[[[]]]][[[
]]][[[[]]]][ [[]]][[[[]]]
][[[]] ][ [[ []]]][
[] ][[[ []]] ][
[[]]][[[[] ]]][[[]]][
[[[]]]][[]][[[[]]]
][[[ ]]][
[[ []
]] ][
[[ ]]
][ [[[]]] ][
[[ ]]][[[ []
]] ][[[]] ][ [[[]]] ][
[[ ]]][[[ []
]]][ [[ [[ [[[]
]] ]]]]][[[[]]]][[[[[[[[] ]]
]] ]] ][ [[ [] ]] ][
[[]] ][[[[]]]][[[[[ [[[]
]]]]]]][[[ []]]][[]][
[[ []]]][[[]]][[[[]]]][[[]]][[[[] ]]
][[[ ]] ][ [[ [] ]] ][[[
]] ][ [[[]]] ][[[]] ][ [[
[] ]]][ [[]]][ [[ []]]][ []][ [[
[] ]] ][ [[ ]] ][
[[ [] ]] ][ [[ ]]
][ [[ []]] ][[] ][ [[
[]]] ][ [[ ]] ][ [[[]
]]][[[ ]]][[[[]]]][[[ ]]][[[
[]]] ][[[]]][[[[]]] ][[[
]]][[[[]]]][[[[[[[[]]]]]]]][[[[]]]
][[[[[[[[]]]]]]] ][[[[]]]][[[[[[[
[[]]]]]]]]][ [[[]]]][[[[[
[]]]]] ][ [[ ]]][[[
[[ [[]] ]]]] ][
[[[]]]][[] ][[[[]]]][
[[]]][[[[]]]][[[]]
][[[ []]]
][ [[
]] ][
[[ []
]] ][[[[[ [[
[[ [[[]]] ]]
]] ]]]]][ [[ []]]][ []
][ [[[]]] ][
[[]] ][ [[ []]]
][ [[]]][[[[]]]][[[]]][[[ []
]] ][ [[ ]] ][ [[ []
]]][ [[]]][[[[]]]][ [[]]
][[[[]]]][ [[]]][[[[]
]] ][[]][[[[]]]][[[]]][[[[]]]][[[ ]]
][[[ [] ]] ][ [] ][ [[[]
]] ][ [[]]][ [[[]]] ][ [[
]] ][[[ []]]][ [[ ]]][[[ []]] ][
[[ ]] ][ [[ [] ]]
][ [[ ]] ][ [[ []
]] ][ [[[[ [[[] ]] ]]
]]][ [[ [] ]] ][ [[[[
[[[]]] ]]]]][[[[]]]][ []][[[
[]]] ][[[]]][[[[]]] ][[[
]]][[[[]]]][[[]]][[[[]]]][[[]]][[[
[]]]][[[]]][[[[] ]]][[[[[[[[]]]]]
]]][[[[]]]][ [[[]]]][[[[]
]]][[[ [] ]] ][[[[]
]] ][[[ []]] ][
[[[]]]][[[ [[[[[]]]]]
]]][[[[]]]][[]][[[
[]]] ][[[
]] ][
[[ []
]] ][
[[ ]]][[[ []
]] ][[[]] ][
[[ []]]][ [[ ]]][[[ []
]] ][[[]] ][
[[[] ]] ][ [[]]
][ [[[]]]][[]][[[[]]]][[[ ]]
][ [[ [] ]] ][ [[ ]]
][[[ []]]][[]][[[[] ]]][
[[]]][[[[] ]]][[[]]][
[[ []]]][[[]]][[[[]]]][[[]]][[[[] ]]
][[[ ]] ][ [[ [] ]] ][[[
[[ [[ []]]]] ]]][[[ [] ]]
][ [[[[ [[[]]] ]] ]]][[[ []]] ][
[[ [[ [[ [[ ]] ]]
]] ]] ][ [[ [] ]]
][ [[ [[]] ]]][ [[ ]]
][[[ [[ [[ ]] ]] ]]][
[[[]]] ][[]][[[[]]]][ [[]]][
[[[] ]]][[[]]][[[[] ]]][
[[[[[[[[[[[]]]]]]]]]]]][[[[]]]][[]
][[[[]]]][[[]]][ [[[]]]][[[]]][[[
[]]]][[[]]][ [[[]]]][[[]]
][[[[] ]] ][ [[]]][
[[ []]] ][[[ ]]
][[[[]]]][ [[]]][[[[]
]]][[]][[[[]]]][[[
]]][ [[[]
]] ][
[[ ]]
][ [[
[] ]]][[] ][
[[ []]]][ [[
]] ][[[[] ]] ][[[]] ][
[[ []]]][ [[
]]][ [[ [] ]]][
[[ ]]][[[[]]]][[[]]][[[[] ]]
][ [[ [[ [[ [] ]] ]]
]]][ [[[]]]][[[[[[[ []]]
]]]]][[[[] ]]][[[]]][
[[ []]]][[]][[[[]]]][[[]]][[[[]]] ][
[[]] ][ [[ [] ]] ][ []][
[[ [] ]]][[[ ]]][[[ [] ]]
][ [[]] ][[[[] ]] ][[[]] ][[[ []
]] ][ [[ ]] ][ [[
[] ]] ][ [[ ]] ][
[[ [] ]]][ [[[[ [[ []
]]]] ]] ][ [[ [] ]]][
[[[[[[ []]]]]]]][[[[] ]]][[[
[]]] ][[[[]]]][[[[[ [[[]
]]]]]]][[[[]]]][[]][[[[]]]][[[]]][
[[[]]]][[[]]][[[ []]]][[[]]][[[[]
]]][[[]]][[[ []]]][[[]]][
[[[]]] ][ [[ ]]][[[
[] ]]][ []][ [[
[]]]][[[]] ][[[[]]]][
[[]]][[[[]]]][[]][
[[[] ]]][
[[ ]]
][ [[
[] ]]
][ [[]]][ [[
[] ]]][[[ ]]
][ [[[]]] ][ [[]]][ [[
[] ]]][[[ ]]
][[[ [] ]] ][[[
[[ [[[]]]]]]]][[[[]]]][[[ [[
[[ [] ]] ]] ]] ][ [[
[]]] ][[[[[[[[[]]]] ]]]]
][[[[]]]][ [[[[[]]]]]
][ [[]]][[]][[[[]]]][[]][[[[]]]][ [[
]]][ [[ [] ]] ][ [[ ]]][
[[ [] ]]][[[ ]]][[[ [] ]]
][ [[]] ][[[[] ]] ][[[]] ][[[ []
]] ][ [] ][ [[ []
]] ][ [[ ]] ][ [[
[] ]] ][[[ ]]][ [[ []
]]][ [[ ]] ][ [[ []]]
][[[[[ [[[]]]]]]]][[[ []]]][
[]][ [[[]]]][[[]]][ [[[]
]]][[[]]][[[[]]]][[]][[[[]]]][[[]]
][[[[]]]][[[]]][ [[[]]]][[[]]][[[
[]]]][[[]]][ [[[]]]][[[]]
][[[[] ]] ][ [[[[[[
[] ]]]] ]]][ [[
[]]]][[[[[ [[[]]]]]]]
][[[[]]]][[[]]][[[
[]]] ][[[
]] ][
[[ []
]] ][
[[ [[[[[] ]]
]] ]]][[[ []
]] ][[]][ [[ []]]][ [[
]] ][[[[] ]]
][[[ ]] ][ [[[]
]] ][[[]]][[[[]]]][[[]]][ [[
[] ]] ][ [[ ]] ][ [[
[]]] ][[]][[[[]]]][ [[]]
][[[[]]]][ [[]]][[[[]
]] ][[[]]][[[[]]]][[[[[[[[]]]]]]] ][
[[[] ]] ][ [[ [[ [[ [[]]
]] ]] ]]][[[ []]]][ [[ [[
]] ]]][ [[[]]] ][ []][[[ []]] ][
[[ ]] ][ [[ [] ]]
][ [[ ]] ][ [[ []
]] ][ [[[[ ]]]] ][ [[
[]]] ][ [[ [[ [[ [[[[
[[]]]] ]]]]]]]]][[]][ [[][[[
]]][ [[[]]]][[[[]]] ][[]
][[[[]]]][[[]]][[[[]]]][[[]]][[[[]
]]][[[[[[[[[[[]] ]]]]]]]]][[[[]]]
][[[[[]]]]]] ][[[[[[]]]]]
][[[[] ]] ][ []][[[
][ [[]] ][[[ []
]]][[[[]]] ][[]][[[[]
]]][[[]]][[[[]]]][
[[]] ][[[
[] ]]
][ [[
]] ][
[[ []]]][ [[
]] ][[[[] ]]
][ [[[[[[ [[ []]]]] ]]
]] ][[[[] ]]
][[] ][ [[ []]]
][ [[]]][[[[]]]][[[[[]]]] ][
[[ ]] ][ [[ [[ [[ []
]]]] ]]][[[[[]]]]][ [[]]
][[[]]][[] ]]][[[[[[]
]] ]]][[[[]]]][[[[]]]][[]][[[[]]] ][
[[]] ][ [[ [] ]] ][ [[]]
][ [[ []]]][ [[[[[[ [[ []
]] ]]]] ]]][[[ [] ]]][[] ][[[ []
]] ][ [[ ]] ][ [[
[] ]] ][ [[ ]] ][
[[ [] ]]][ [[[[ [[ []
]]]] ]] ]] ][ [[ []]]
][[]][ [[[]]]][[[]]][ [[[]]]
][[[ ]]][[[[]]]][[[ ]]][
[[[]]]][[[]]][[[[]]]][[]][[[[]]]][
[[]]][[[[]]]][[[ ]]][[[[]]]][[[]]
][[[[]]]][[[ ]]][[[[]]]][
[[]]][ [[ [] ]]][[[
[[ [[[] ]]]] ]]
][[[[]]]][ []][[[[]]]
][[[]]][[[[]]]][[[
]]][ [[[]
]] ][
[[ ]]
][ [[
[] ]]][[[ ]]
][ [[[]]] ][
[[ ]]][[[ [] ]]][[[ [[
[[ []]]]] ]]
][[[ [] ]] ][[[
[] ]]][[[[[[]]]]]][[[[[]] ]]
][ [[ ]] ][ [[ [] ]]
][[[ ]]][[[[]]]][[[ [[[[
[]]]]]]]][ []][[]][[]
][ [[]]][[[[]]]][[]][[]][[[]]][[[ []
]]][ [] ][ [] ][ [[ ]]][
[[ [] ]]][[] ][[]][ [[ ]]
][ [[[] ]]][[] ][ []][[[ ]]][ [[
[] ]] ][ [] ][ []
][ [[ ]] ][ [[ []
]] ][ []][ []][ [[ ]]
][[[ [] ]] ][ [] ][[]
][[[]] ][[[[]]]][[]][ []][[[
]]][ [[[]]]][[]][[] ][[[
]]][[[[]]]][[]][[]][[[]]][[[[]]]][
[]][[]][[[]]][[[ []]]][[]][[]][[[
]]][[[[]]]][ []][[]][[[]]
][[[[] ]] ][ []][[]
][ [[]] ][[[ []
]]]][[[]]] [[[[[]]]]]
comments 0
post a comment
entry.py ASCII text
1print((l:=[1,2,2], list(l.extend(list(i%2+1 for _ in range(0, l[i]))) for i in range(2,66)), l)[2])
comments 0
post a comment
cg100_1.py ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
kolakoski = [1, 2]
index = 1
length = 2
while length < 100:
current_len = kolakoski[index]
last_len = kolakoski[index - 1]
last = kolakoski[length - 1]
last_influenced = not (index == length - 1)
if current_len == 1:
kolakoski.append(3 - last)
else:
if last_len == 1 and not last_influenced:
kolakoski.append(last)
else:
kolakoski.append(3 - last)
kolakoski.append(3 - last)
length = len(kolakoski)
index += 1
print(kolakoski[:100])
cg100_10.hs ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
-- package Main
import Control.Monad
data KolakoskiStep =
Singular Int |
Double Int Int deriving (Show)
getNext :: [Int] -> Int -> KolakoskiStep
getNext kolakoski index = do
let current_len = kolakoski !! index
let last_len = kolakoski !! (index - 1)
let last_val = last kolakoski
let len = length kolakoski
let last_influenced = (index /= (len - 1))
if current_len == 1 then
Singular (3 - last_val)
else
if last_len == 1 && not last_influenced then
Singular last_val
else Double (3 - last_val) (3 - last_val)
loop kolakoski index =
if ((length kolakoski) < 100) then do
case getNext kolakoski index of
Singular a -> loop (kolakoski ++ [a]) (index + 1)
Double a b -> loop (kolakoski ++ [a, b]) (index + 1)
else print kolakoski
main :: IO ()
main = do
loop [1, 2] 1
cg100_2.c ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdio.h>
int main(int argc, char** argv)
{
int kolakoski[101] = {0};
kolakoski[0] = 1;
kolakoski[1] = 2;
int index = 1;
int len = 2;
while (len < 100)
{
int current_len = kolakoski[index];
int last_len = kolakoski[index - 1];
int last = kolakoski[len - 1];
int last_influenced = !(index == len - 1);
if (current_len == 1)
{
kolakoski[len++] = 3 - last;
}
else
{
if (last_len == 1 && last_influenced == 0)
{
kolakoski[len++] = last;
}
else
{
kolakoski[len++] = 3 - last;
kolakoski[len++] = 3 - last;
}
}
++index;
}
for(int i = 0; i < 100; ++i)
{
printf("%d ", kolakoski[i]);
}
printf("\n");
return 0;
}
cg100_3.cpp ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <array>
int main(int argc, char** argv)
{
std::array<int, 101> kolakoski = {0};
kolakoski[0] = 1;
kolakoski[1] = 2;
std::size_t index = 1;
std::size_t len = 2;
while (len < 100)
{
std::size_t current_len = kolakoski[index];
std::size_t last_len = kolakoski[index - 1];
int last = kolakoski[len - 1];
bool last_influenced = !(index == len - 1);
if (current_len == 1)
{
kolakoski[len++] = 3 - last;
}
else
{
if (last_len == 1 && !last_influenced)
{
kolakoski[len++] = last;
}
else
{
kolakoski[len++] = 3 - last;
kolakoski[len++] = 3 - last;
}
}
++index;
}
for(std::size_t i = 0; i < 100; ++i)
{
std::cout << kolakoski[i] << ' ';
}
std::cout << std::endl;
return 0;
}
cg100_4.lua ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
local kolakoski = {1, 2}
local index = 2
local length = 2
while length < 100 do
local current_len = kolakoski[index]
local last_len = kolakoski[index - 1]
local last = kolakoski[length]
local last_influenced = not (index == length)
if current_len == 1 then
table.insert(kolakoski, 3 - last)
else
if last_len == 1 and not last_influenced then
table.insert(kolakoski, last)
else
table.insert(kolakoski, 3 - last)
table.insert(kolakoski, 3 - last)
end
end
length = #kolakoski
index = index + 1
end
local i = 1
while i <= 100 do
io.write(kolakoski[i])
io.write(' ')
i = i + 1
end
print()
cg100_5.js ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var kolakoski = [1, 2];
var index = 1;
var length = 2;
while (length < 100) {
const current_len = kolakoski[index];
const last_len = kolakoski[index - 1];
const last = kolakoski[length - 1];
const last_influenced = !(index === length - 1);
if (current_len === 1) {
kolakoski.push(3 - last);
} else {
if (last_len === 1 && !last_influenced) {
kolakoski.push(last);
} else {
kolakoski.push(3 - last);
kolakoski.push(3 - last);
}
}
length = kolakoski.length;
++index;
}
console.log(kolakoski);
cg100_6.java ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class cg100_6 {
public cg100_6() {
super();
}
public static void main(String[] args) {
int[] kolakoski = new int[101];
kolakoski[0] = 1;
kolakoski[1] = 2;
int index = 1;
int length = 2;
while (length < 100) {
int current_len = kolakoski[index];
int last_len = kolakoski[index - 1];
int last = kolakoski[length - 1];
boolean last_influenced = !(index == length - 1);
if (current_len == 1)
kolakoski[length++] = 3 - last;
else {
if (last_len == 1 && !last_influenced) {
kolakoski[length++] = last;
} else {
kolakoski[length++] = 3 - last;
kolakoski[length++] = 3 - last;
}
}
++index;
}
for (int i = 0; i < 100; ++i) {
System.out.print(kolakoski[i]);
System.out.print(' ');
}
System.out.println();
}
};
cg100_7.go ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main
import "fmt"
func main() {
var kolakoski []int = make([]int, 0)
kolakoski = append(kolakoski, 1)
kolakoski = append(kolakoski, 2)
var index int = 1
var length int = 2
for length < 100 {
var current_len int = kolakoski[index]
var last_len int = kolakoski[index-1]
var last int = kolakoski[length-1]
var last_influenced bool = !(index == length-1)
if current_len == 1 {
kolakoski = append(kolakoski, 3-last)
} else {
if last_len == 1 && !last_influenced {
kolakoski = append(kolakoski, last)
} else {
kolakoski = append(kolakoski, 3-last)
kolakoski = append(kolakoski, 3-last)
}
}
length = len(kolakoski)
index = index + 1
}
fmt.Println(kolakoski);
}
cg100_8.rs ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() -> () {
let mut kolakoski = vec![1, 2];
let mut index: usize = 1;
let mut length: usize = 2;
while length < 100 {
let current_len: i32 = kolakoski[index];
let last_len: i32 = kolakoski[index - 1];
let last: i32 = kolakoski[length - 1];
let last_influenced: bool = !(index == length - 1);
if current_len == 1 {
kolakoski.push(3 - last);
} else {
if last_len == 1 && !last_influenced {
kolakoski.push(last);
} else {
kolakoski.push(3 - last);
kolakoski.push(3 - last);
}
}
length = kolakoski.len();
index += 1;
}
println!("{:?}", kolakoski);
}
cg100_9.cs ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class cg100_9 {
cg100_9(){
}
public static void Main() {
int[] kolakoski = new int[101];
kolakoski[0] = 1;
kolakoski[1] = 2;
int index = 1;
int length = 2;
while(length < 100) {
int current_len = kolakoski[index];
int last_len = kolakoski[index - 1];
int last = kolakoski[length - 1];
bool last_influenced = !(index == length - 1);
if(current_len == 1) {
kolakoski[length++] = 3 - last;
} else {
if (last_len == 1 && !last_influenced) {
kolakoski[length++] = last;
} else {
kolakoski[length++] = 3 - last;
kolakoski[length++] = 3 - last;
}
}
++index;
}
for(int i = 0; i < 100; ++i) {
Console.Write(kolakoski[i]);
Console.Write(' ');
}
Console.WriteLine();
}
}
comments 0
post a comment
k.py ASCII text, with CRLF line terminators
1
2
3
s=[1,2,2]
for i in range(2,66):s+=[(s[-1]==1)+1]*s[i]
print(s)
comments 0
post a comment
cg100.jff Unicode text, UTF-8 text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
<?xml version="1.0" encoding="UTF-8" standalone="no"?><!--Created with JFLAP 7.1.--><structure>
<type>turing</type>
<automaton>
<!--The list of states.-->
<state id="0" name="q0">
<x>99.0</x>
<y>45.0</y>
<initial/>
</state>
<state id="1" name="q1">
<x>276.0</x>
<y>129.0</y>
</state>
<state id="2" name="q2">
<x>436.0</x>
<y>221.0</y>
</state>
<state id="3" name="q3">
<x>268.0</x>
<y>223.0</y>
</state>
<state id="4" name="q4">
<x>352.0</x>
<y>325.0</y>
</state>
<state id="5" name="q5">
<x>82.0</x>
<y>238.0</y>
</state>
<state id="6" name="q6">
<x>200.0</x>
<y>428.0</y>
</state>
<state id="7" name="q7">
<x>334.0</x>
<y>521.0</y>
</state>
<state id="8" name="q8">
<x>469.0</x>
<y>322.0</y>
</state>
<state id="9" name="q9">
<x>659.0</x>
<y>265.0</y>
</state>
<state id="10" name="q10">
<x>664.0</x>
<y>374.0</y>
</state>
<state id="12" name="q12">
<x>369.0</x>
<y>741.0</y>
</state>
<state id="13" name="q13">
<x>466.0</x>
<y>524.0</y>
</state>
<state id="14" name="q14">
<x>561.0</x>
<y>461.0</y>
</state>
<state id="15" name="q15">
<x>569.0</x>
<y>585.0</y>
</state>
<state id="16" name="q16">
<x>698.0</x>
<y>458.0</y>
</state>
<state id="17" name="q17">
<x>705.0</x>
<y>590.0</y>
</state>
<state id="19" name="q19">
<x>987.0</x>
<y>597.0</y>
</state>
<!--The list of transitions.-->
<transition>
<from>6</from>
<to>4</to>
<read>¹</read>
<write>¹</write>
<move>R</move>
</transition>
<transition>
<from>17</from>
<to>19</to>
<read/>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>0</from>
<to>1</to>
<read/>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>14</from>
<to>16</to>
<read/>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>13</from>
<to>15</to>
<read>2</read>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>3</from>
<to>5</to>
<read/>
<write>¹</write>
<move>R</move>
</transition>
<transition>
<from>12</from>
<to>6</to>
<read>2</read>
<write>²</write>
<move>S</move>
</transition>
<transition>
<from>19</from>
<to>12</to>
<read>¹</read>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>2</from>
<to>3</to>
<read/>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>12</from>
<to>6</to>
<read>1</read>
<write>¹</write>
<move>S</move>
</transition>
<transition>
<from>16</from>
<to>19</to>
<read/>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>9</from>
<to>19</to>
<read/>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>19</from>
<to>12</to>
<read>²</read>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>10</from>
<to>19</to>
<read/>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>4</from>
<to>8</to>
<read/>
<write/>
<move>L</move>
</transition>
<transition>
<from>7</from>
<to>13</to>
<read/>
<write/>
<move>L</move>
</transition>
<transition>
<from>6</from>
<to>7</to>
<read>²</read>
<write>²</write>
<move>R</move>
</transition>
<transition>
<from>6</from>
<to>6</to>
<read>1</read>
<write>1</write>
<move>L</move>
</transition>
<transition>
<from>6</from>
<to>6</to>
<read/>
<write/>
<move>L</move>
</transition>
<transition>
<from>6</from>
<to>6</to>
<read>2</read>
<write>2</write>
<move>L</move>
</transition>
<transition>
<from>19</from>
<to>19</to>
<read/>
<write/>
<move>L</move>
</transition>
<transition>
<from>19</from>
<to>19</to>
<read>1</read>
<write>1</write>
<move>L</move>
</transition>
<transition>
<from>19</from>
<to>19</to>
<read>2</read>
<write>2</write>
<move>L</move>
</transition>
<transition>
<from>15</from>
<to>17</to>
<read/>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>4</from>
<to>4</to>
<read>1</read>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>4</from>
<to>4</to>
<read>2</read>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>7</from>
<to>7</to>
<read>1</read>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>7</from>
<to>7</to>
<read>2</read>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>1</from>
<to>2</to>
<read/>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>8</from>
<to>10</to>
<read>2</read>
<write>2</write>
<move>R</move>
</transition>
<transition>
<from>13</from>
<to>14</to>
<read>1</read>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>5</from>
<to>6</to>
<read/>
<write>1</write>
<move>R</move>
</transition>
<transition>
<from>8</from>
<to>9</to>
<read>1</read>
<write>1</write>
<move>R</move>
</transition>
</automaton>
</structure>
cg100.png PNG image data, 1335 x 761, 8-bit/color RGB, non-interlaced
comments 0
post a comment
cogging.erl ASCII text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
-module(cogging).
-export([koalakoskie/1]).
%% Returns a koalakosksokigei sequence with length at least N.
koalakoskie(0) -> [];
koalakoskie(1) -> [1];
koalakoskie(2) -> [1,2];
koalakoskie(N) -> expand_until_length(N, [1,2]).
expand_until_length(N,L)
when is_integer(N), length(L) >= N
-> L;
expand_until_length(N,L)
when is_integer(N), N >= 0
-> expand_until_length(N,expand(L)).
flip(1) -> 2; flip(2) -> 1.
expand(L) -> expand_with(1,L).
expand_with(X,[1|T]) -> [X|expand_with(flip(X),T)];
expand_with(X,[2|T]) -> [X,X|expand_with(flip(X),T)];
expand_with(_,[]) -> [].
main(_) ->
{L,_}=lists:split(100,koalakoskie(100)),
io:format("one hundered values of it:~n~p~n",[L]).
comments 0
post a comment
ans.k ASCII text
1
2
/ didn't say first 100
100#1
comments 0
post a comment
Kolakoski's World.zip Zip archive data, made by v2.0 UNIX, extract using at least v2.0, last modified May 11 2026 22:05:50, uncompressed size 0, method=store
dir Kolakoski's World v3
dir data
dir minecraft
custom_boss_events.dat gzip compressed data, original size modulo 2^32 30
1cg: couldn't decode file contents
game_rules.dat gzip compressed data, original size modulo 2^32 1966
1cg: couldn't decode file contents
random_sequences.dat gzip compressed data, original size modulo 2^32 2791
1cg: couldn't decode file contents
scheduled_events.dat gzip compressed data, original size modulo 2^32 44
1cg: couldn't decode file contents
scoreboard.dat gzip compressed data, original size modulo 2^32 30
1cg: couldn't decode file contents
stopwatches.dat gzip compressed data, original size modulo 2^32 45
1cg: couldn't decode file contents
wandering_trader.dat gzip compressed data, original size modulo 2^32 67
1cg: couldn't decode file contents
weather.dat gzip compressed data, original size modulo 2^32 115
1cg: couldn't decode file contents
world_clocks.dat gzip compressed data, original size modulo 2^32 118
1cg: couldn't decode file contents
world_gen_settings.dat gzip compressed data, original size modulo 2^32 637
1cg: couldn't decode file contents
icon.png PNG image data, 64 x 64, 8-bit/color RGBA, non-interlaceddir dimensions
dir minecraft
dir overworld
dir data
dir minecraft
chunk_tickets.dat gzip compressed data, original size modulo 2^32 30
1cg: couldn't decode file contents
raids.dat gzip compressed data, original size modulo 2^32 55
1cg: couldn't decode file contents
world_border.dat gzip compressed data, original size modulo 2^32 212
1cg: couldn't decode file contents
dir entities
r.-1.-1.mca datar.0.-1.mca data
1cg: couldn't decode file contents
dir region
r.-1.-1.mca data
r.0.-1.mca datadir the_end
dir data
dir minecraft
chunk_tickets.dat gzip compressed data, original size modulo 2^32 30
1cg: couldn't decode file contents
ender_dragon_fight.dat gzip compressed data, original size modulo 2^32 207
1cg: couldn't decode file contents
raids.dat gzip compressed data, original size modulo 2^32 55
1cg: couldn't decode file contents
world_border.dat gzip compressed data, original size modulo 2^32 212
1cg: couldn't decode file contents
dir the_nether
dir data
dir minecraft
chunk_tickets.dat gzip compressed data, original size modulo 2^32 30
1cg: couldn't decode file contents
raids.dat gzip compressed data, original size modulo 2^32 55
1cg: couldn't decode file contents
world_border.dat gzip compressed data, original size modulo 2^32 212
1cg: couldn't decode file contents
level.dat gzip compressed data, from TOPS/20, original size modulo 2^32 569
1cg: couldn't decode file contents
session.lock Unicode text, UTF-8 text, with no line terminators
1☃
comments 0
post a comment
main.py ASCII text
1
2
3
p=2;r=1,2,2
while p-66:r+=(3^r[-1],)*r[p];p+=1
print(*r)
comments 0
post a comment
main.rs ASCII text, with very long lines (326)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fn main() {
let mut seq = vec![1,2,2];
let mut i = 2;
while seq.len() < 100 {
let n = 3 - seq.last().unwrap();
let m = seq[i];
i += 1;
for _ in 0..m {
seq.push(n);
}
}
println!("{:?}", &seq[..100]);
// check validity
assert_eq!(seq[..100], [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2]);
}
post a comment