Contexte
En fait (le successeur de Sérieusement ) est un langage de golf impératif basé sur la pile que j'ai créé en novembre 2015. Comme beaucoup d'autres langues de golf, il a des commandes à un octet qui exécutent différentes fonctions en fonction du contenu de la pile. L'une de ses spécialités est les mathématiques - il a une grande variété de commandes basées sur les mathématiques. Cependant, pour effectuer des opérations mathématiques, vous devez mettre (un ou plusieurs) nombres sur la pile. Pousser une valeur spécifique dans le moins d'octets possible est délicat, car il existe de nombreuses options différentes. Dans ce défi, vous ferez exactement cela: représenter des nombres (en particulier des entiers) en fait en aussi peu d'octets que possible.
Le défi
Étant donné un entier Nen entrée, un code de sortie valide valide qui se traduit par Nêtre poussé vers la pile.
- L'entrée sera dans la plage d'un entier complément à deux signé 32 bits (c'est-à-dire les entiers dans la plage inclusive
[-2147483648, 2147483647]). - Le résultat doit être un entier (pas un flottant, une chaîne, une liste ou une fonction) et doit être au-dessus de la pile.
- Vous ne pouvez pas faire d'hypothèses sur le contenu de la pile (comme si elle est vide ou non). Aucune valeur existante sur la pile ne doit être modifiée ou réorganisée.
- Le dernier commit de Actually au moment où j'écris ce défi doit être utilisé. Si je fais des corrections de bugs ou des améliorations de performances (ou toute autre modification mineure qui ne supprime pas ou ne modifie pas la fonctionnalité des commandes autorisées), je mettrai à jour cette version.
- Votre solution doit faire au moins aussi bien que la solution triviale (ajouter
:à l'entrée pour faire un littéral numérique). - Votre score sera la somme des longueurs des solutions triviales moins la somme des longueurs des sorties pour la sélection de 1000 entiers de complément à deux signés 32 bits utilisés pour la notation, qui peuvent être trouvés ci-dessous. Je me réserve le droit de modifier les entiers de notation à tout moment, s'il y a un besoin (comme l'optimisation pour les cas de test ou les cas de test qui ne sont pas suffisamment approfondis).
- Les solutions doivent générer une réponse valide dans les 30 secondes pour chaque entrée. Le chronométrage sera effectué sur un espace de travail Cloud9 gratuit standard .
Commandes
Par souci de simplicité, seules 141 des 208 commandes (actuellement) peuvent être utilisées, et de nombreuses surcharges de ces 141 qui ne sont pas liées à la compression des nombres ont été supprimées. Voici la liste des commandes autorisées (le format est <hex code> (<symbol>): <descriptions of functions based on stack values and types>:
0B (♂): take the next command and map it over the top of the stack (for example, ♂A is equivalent to `A`M)
1F (▼): pop a,b: push b//gcd(a,b),a//gcd(a,b); pop [a]: push [x//gcd([a]) for x in [a]]
20 ( ): push the # of elements on the stack (push len(stack))
21 (!): pop a: push a! (factorial(a))
22 ("): string literal, reads until next " and pushes value onto stack. An implied " is present at EOF if needed.
23 (#): pop a: push list(a)
25 (%): pop a,b: push a%b
26 (&): pop a,b: push a & b (bitwise AND)
27 ('): pushes next character onto stack as character literal (length-1 string)
28 ((): rotates stack right by 1
29 ()): rotates stack left by 1
2A (*): pop a,b: push a*b; pop a,[b] or [b],a: apply a* to each element in the array; pop [a],[b]: push dot product of [a] and [b] (sum([a[i]*b[i] for i in len(a)])) (shorter is padded with 0s)
2B (+): pop a,b: push a+b; pop [a],[b]: push [a][b] (append [b] to [a]); pop a,[b] or [b],a: apply a+ to each element in the array
2D (-): pop a,b: push a-b; pop [a],[b]: push [a]-[b] (all elements of [a] not in [b])
2F (/): pop a,b: push a/b (float division); pop [a]: rotate [a] right by 1, push [a]
30 (0): push 0
31 (1): push 1
32 (2): push 2
33 (3): push 3
34 (4): push 4
35 (5): push 5
36 (6): push 6
37 (7): push 7
38 (8): push 8
39 (9): push 9
3A (:): numeric literal delimiter: pushes the longest string of characters in '0123456789+-.ij' as a numeric
3B (;): pop a: push a,a (duplicates top element)
3C (<): pop a,b: push 1 if a<b else 0
3D (=): pop a,b: push 1 if a==b else 0
3E (>): pop a,b: push 1 if a>b else 0
40 (@): pop a,b: push a,b (rotate top 2 elements)
41 (A): pop a: push abs(a)
43 (C): pop a: push cos(a)
44 (D): pop a: push a-1; pop [a]: push stddev([a])
45 (E): pop a: push erf(a); pop [a],b: push [a][b] (bth item in [a])
46 (F): pop a: push Fib(a) (Fib(0)=0, Fib(1)=Fib(2)=1); pop [a]: push a[0]
48 (H): pop [a],b: push [a][:b]
49 (I): pop a,b,c: push b if a is truthy, else push c
4B (K): pop a: push ceil(a)
4C (L): pop a: push floor(a)
4D (M): pop f,[a], execute f for each element in [a], using the element as a temporary stack, push [a] (similar to map(f,[a])); pop [a]: push max([a])
4E (N): pop [a]: push a[-1]
50 (P): pop a: push the a-th prime (zero-indexed)
52 (R): pop f,[a]: call f, using [a] as a temporary stack, push [a] (similar to reduce(f,[a])); pop [a]: push [a][::-1] (reverse); pop a: push [1,2,...,a] (range(1,a+1))
53 (S): pop a: push sin(a); pop [a]: push sorted(a)
54 (T): pop a: push tan(a); pop [a],b,c: set [a][b] to c, push [a]
55 (U): pop [a],[b]: push union of [a] and [b]
57 (W): loop delimiter: peek top of stack, repeat code in loop while a evaluates to true
58 (X): pop a: discard
59 (Y): pop a: push !bool(a) (logical negate, opposite of b)
5A (Z): pop [a],[b]: push zip([a],[b]); pop a, zip the next a lists
5B ([): begin list literal, values are delimited by commas (,)
5C (\): pop a,b: push a/b (integer division); pop [a]: rotate [a] left by 1, push [a]
5D (]): end list literal
5E (^): pop a,b: push a XOR b
5F (_): pop a: push ln(a)
60 (`): function literal delimiter, pushes function whose body contains all of the commands until the next `. An implied ` is present at EOF if needed.
61 (a): invert the stack ([a,b,c,d] -> [d,c,b,a])
62 (b): pop a: push 0 if a==0 else 1; pop "a" or [a]: push 0 if len(a)==0 else 1; pop f: push 0 if len(f)==0 else 1
63 (c): pop a: push character at ordinal a%256; pop [a],b: push [a].count(b)
64 (d): pop [a]: dequeue b from [a], push [a],b
65 (e): pop a: push exp(a)
66 (f): pop a: push the Fibonacci index of a if a is a Fibonacci number, else -1
67 (g): pop a,b: push gcd(a,b); pop [a]: push gcd([a])
68 (h): pop a,b: push sqrt(a*a+b*b) (Euclidean norm)
69 (i): pop [a]: push each element from [a], starting from end (flatten)
6B (k): pop all elements from stack, convert to list (in the order they were on the stack, starting from the top), and push
6C (l): pop [a]: push len([a])
6D (m): pop a: push int(a),frac(a) (modf(a)); pop [a]: push min([a])
6E (n): pop a,b: push a b times
6F (o): pop [a],b: push b to [a], push [a]
70 (p): pop a: push 1 if a is prime else 0; pop [a]: pop b from [a], push [a],b
71 (q): pop [a],b: enqueue b in [a], push [a]
72 (r): pop a: push [0,1,...,a-1] (range(0,a))
75 (u): pop a: push a+1
77 (w): pop a: push the full positive prime factorization of |a| (18 -> [[2,1],[3,2]], -5 -> [[5,1]])
78 (x): pop a,b: push [a,b) (range(a,b)); pop [a]: push range(*a)
79 (y): pop a: push the positive prime factors of |a| (18 -> [2,3], -5 -> [5])
7B ({): pop a: rotate stack right a times
7C (|): pop a,b: push a | b (bitwise OR)
7D (}): pop a: rotate stack left a times
7E (~): pop a: push ~a (unary bitwise negate)
80 (Ç): pop a,b: push a+bi; pop [a]: pop pairs of real numerics b,c from [a] and push b+ci (appending 0 to [a] if len([a]) is odd)
83 (â): pop a: push asin(a)
84 (ä): pop a: push acos(a)
85 (à): pop a: push atan(a)
86 (å): pop a,b: push atan2(a,b)
87 (ç): pop a: push asinh(a)
88 (ê): pop a: push acosh(a)
89 (ë): pop a: push atanh(a)
8B (ï): push i, the imaginary unit (sqrt(-1) or 0+1i)
8C (î): pop a, push 0+ai; pop [a], push [a] with every element multiplied by i
8D (ì): pop a: push 1/a
8E (Ä): pop a: push sinh(a)
8F (Å): pop a: push cosh(a)
90 (É): pop a: push tanh(a)
91 (æ): pop [a]: push mean([a])
9A (Ü): pop [a]: push mode([a])
9B (¢): pop a,b: push abs(a)*sgn(b)
9D (¥): pop [a],[b]: push the result of pairwise addition of [a] and [b], padding the shorter with 0s
9E (₧): pop z: push phase(z)
A0 (á): pop z: push the complex conjugate of z
A1 (í): pop [a],b: push [a].index(b) (0-based, -1 if not found)
A7 (º): pop a: push degrees(a)
A8 (¿): pop a,b: push int(a,b) (interpret a as a base-b int)
A9 (⌐): pop a: push a+2
AA (¬): pop a: push a-2
AB (½): pop a: push a/2 (float division)
AC (¼): pop a: push a/4 (float division)
AD (¡): pop a,b: push a string representing a in base b
B0 (░): pop [a],[b]: push [[b][i] if [a][i] for i in len(b)], pads [a] with 0s if necessary
B1 (▒): pop a: push totient(a) (# of integers <= a that are coprime with a)
B2 (▓): pop a: push pi(a) (# of primes <= a)
B3 (│): duplicate stack ([a,b,c] => [a,b,c,a,b,c])
B4 (┤): pop a,b: push 1 if a and b are coprime else 0
B9 (╣): pop a: push the ath row in Pascal's triangle
C5 (┼): duplicate each element on stack ([a,b,c] => [a,a,b,b,c,c])
C6 (╞): pop a: make a total copies of each element on stack (3 [a,b,c] -> [a,a,a,b,b,b,c,c,c])
C7 (╟): pop a: pop a elements and push a list containing those elements in their original order
CB (╦): push pi
CC (╠): push e
D1 (╤): pop a: push 10**a
D2 (╥): pop a: push log(a) (log base 10)
D3 (╙): pop a: push 2**a
D4 (╘): pop a: push lg(a) (log base 2)
D5 (╒): push ln(2)
DB (█): pop a,b: push C(a,b) (aCb)
DC (▄): pop a,b: push P(a,b) (aPb)
E2 (Γ): pop a: push Gamma(a)
E3 (π): pop [a]: push product([a])
E4 (Σ): pop [a]: push sum([a])
E7 (τ): pop a: push 2*a
ED (φ): push phi (golden ratio)
F1 (±): pop a: push -a (unary negate)
F2 (≥): pop a,b: push a>=b
F3 (≤): pop a,b: push a<=b
F7 (≈): pop a: push int(a)
F8 (°): pop a: push radians(a)
FB (√): pop a: push sqrt(a)
FC (ⁿ): pop a,b: push pow(a,b)
FD (²): pop a: push a*a
[a] refers to an iterable (list, string, etc.), "a" refers to a string, f refers to a function, and a (and b, and c, and so on) refers to a numeric (or any data type, if the command is type-agnostic).
Il est probable que beaucoup de ces commandes ne seront pas utilisées, mais je les ai incluses au cas où elles seraient utiles.
Notation
Voici les entiers qui seront utilisés pour la notation:
-2124910654
-2117700574
-2098186988
-2095671996
-2083075613
-2058271687
-2052250777
-2024215903
-2019485642
-2016095616
-2009838326
-2009173317
-2007673992
-2000014444
-1999825668
-1992515610
-1989566707
-1975506037
-1955473208
-1950731112
-1949886423
-1920624450
-1918465596
-1916287469
-1905036556
-1903956118
-1888944417
-1865221863
-1856600057
-1842797147
-1835637734
-1812631357
-1805740096
-1798015647
-1726688233
-1723609647
-1713776890
-1700307138
-1687644479
-1645515069
-1617635994
-1610444000
-1579053372
-1556891649
-1549652116
-1537732956
-1535180388
-1527162056
-1524851611
-1524658412
-1523244369
-1521379172
-1520191198
-1519035741
-1516978241
-1508892332
-1489938422
-1482102944
-1481823232
-1470621147
-1469145091
-1446844485
-1441790509
-1437843276
-1435359182
-1434186947
-1429816311
-1429393781
-1419752032
-1400387846
-1385152926
-1372620863
-1369257355
-1361933674
-1360480816
-1334846204
-1323741718
-1323660173
-1312800992
-1308824840
-1304658551
-1287829999
-1283767920
-1276288210
-1264275838
-1263965596
-1262866901
-1255421887
-1251428680
-1244825786
-1243200329
-1235305532
-1233977691
-1220537074
-1214100716
-1199414474
-1190725823
-1190401800
-1178717689
-1172378149
-1147869245
-1142875190
-1138538768
-1137864183
-1124917489
-1102987222
-1095920186
-1083001017
-1080902655
-1047122002
-1031842676
-1029877334
-1020849489
-1001684838
-998419619
-990915088
-985235989
-982515261
-979074894
-974195629
-973832940
-965324937
-944246431
-938387588
-933873331
-932692878
-928039285
-927947459
-914008773
-907981688
-906376330
-903502449
-898112547
-887444438
-862658502
-843628573
-822463032
-786051095
-776932426
-776033951
-752042328
-746532472
-743149468
-740225710
-734414418
-725435852
-708101516
-699674783
-694869277
-693246525
-690571518
-689249770
-688581912
-686864294
-681445866
-647992869
-641101583
-631409299
-624686189
-613079884
-593711206
-591688546
-591331185
-574790069
-573024823
-565387051
-565137163
-556338668
-556291492
-541411509
-538932064
-500479857
-482419890
-468050561
-424532545
-420534171
-408741873
-406973874
-387664799
-382084509
-367095703
-352332569
-352195997
-346430007
-324596389
-320119776
-306594578
-305952425
-283718911
-267302378
-243302738
-242955859
-232180029
-225394407
-217418127
-212286453
-208344820
-191300139
-186177744
-175765723
-161763935
-157025501
-140389149
-132298608
-126175769
-70566352
-68748576
-53985905
-52674668
-50228620
-39678495
-19825663
-8349922
-8186722
-8125700
-8073135
-8043230
-7994382
-7874433
-7863624
-7784916
-7782477
-7696343
-7607278
-7531250
-7388060
-7368780
-7367625
-7353084
-7334489
-7281141
-7267149
-7140057
-7119066
-7010389
-6992089
-6975258
-6863360
-6784772
-6741079
-6585985
-6550401
-6520011
-6495144
-6459702
-6294273
-6178342
-6169344
-6139663
-6090928
-6022637
-5992707
-5971334
-5925304
-5880940
-5873707
-5807953
-5703992
-5692895
-5535131
-5488812
-5468330
-5404148
-5290247
-5274221
-5264144
-5234715
-5224048
-5179837
-5084014
-5043990
-5028537
-5011679
-4998333
-4922901
-4880159
-4874060
-4787390
-4749096
-4736217
-4502308
-4480611
-4424319
-4363262
-4349743
-4290050
-4240069
-4239657
-4174072
-4093051
-4045363
-4037689
-4033352
-3839265
-3766343
-3716899
-3680075
-3679053
-3581776
-3539227
-3461158
-3282526
-3205947
-3183427
-3169708
-3166430
-3089822
-3061531
-2947574
-2930733
-2919246
-2872882
-2830770
-2739228
-2713826
-2634018
-2613990
-2525529
-2439507
-2432921
-2376201
-2335005
-2307524
-2265548
-2176176
-2123133
-2108773
-2105934
-2075032
-2073940
-2045837
-2045648
-1978182
-1945769
-1935486
-1881608
-1654650
-1602520
-1506746
-1505294
-1475309
-1457605
-1327259
-1312217
-1178723
-1027439
-880781
-833776
-666675
-643098
-593446
-468772
-450369
-443225
-418164
-402004
-319964
-307400
-279414
-190199
-176644
-66862
-32745
-32686
-32352
-32261
-32035
-31928
-31414
-31308
-30925
-30411
-29503
-29182
-28573
-28500
-28093
-27743
-27716
-27351
-27201
-26834
-25946
-25019
-24469
-24341
-24292
-24151
-23732
-22769
-22242
-22002
-20863
-20762
-20644
-20189
-20009
-19142
-19036
-18980
-18616
-18196
-18123
-17942
-17915
-17601
-17494
-16669
-16417
-16317
-15051
-14796
-14742
-14600
-14443
-14159
-14046
-13860
-13804
-13745
-13634
-13498
-13497
-12688
-12471
-12222
-11993
-11467
-11332
-10783
-10250
-10114
-10089
-9930
-9434
-9336
-9128
-9109
-8508
-8460
-8198
-8045
-7850
-7342
-7229
-6762
-6302
-6245
-6171
-5957
-5842
-4906
-4904
-4630
-4613
-4567
-4427
-4091
-4084
-3756
-3665
-3367
-3186
-2922
-2372
-2331
-1936
-1683
-1350
-1002
-719
-152
-128
-127
-124
-122
-121
-119
-116
-113
-112
-111
-107
-104
-102
-101
-100
-95
-94
-91
-90
-87
-81
-80
-79
-78
-73
-72
-69
-68
-66
-65
-63
-57
-54
-52
-51
-48
-47
-46
-45
-43
-41
-37
-33
-31
-30
-27
-25
-21
-18
-15
-12
-8
-1
0
1
3
4
5
6
11
14
17
23
25
26
27
28
29
31
32
39
41
46
49
51
52
56
58
61
64
66
67
70
74
79
80
86
88
89
92
93
99
102
104
109
113
117
120
122
123
127
695
912
1792
2857
3150
3184
4060
4626
5671
6412
6827
7999
8017
8646
8798
9703
9837
10049
10442
10912
11400
11430
11436
11551
11937
12480
13258
13469
13689
13963
13982
14019
14152
14259
14346
15416
15613
15954
16241
16814
16844
17564
17702
17751
18537
18763
19890
21216
22238
22548
23243
23383
23386
23407
23940
24076
24796
24870
24898
24967
25139
25176
25699
26167
26536
26614
27008
27087
27142
27356
27458
27800
27827
27924
28595
29053
29229
29884
29900
30460
30556
30701
30815
30995
31613
31761
31772
32099
32308
32674
75627
80472
103073
110477
115718
172418
212268
242652
396135
442591
467087
496849
675960
759343
846297
881562
1003458
1153900
1156733
1164679
1208265
1318372
1363958
1411655
1522329
1559609
1677118
1693658
1703597
1811223
1831642
1838628
1884144
1931545
2085504
2168156
2170263
2239585
2308894
2329235
2364957
2432335
2435551
2596936
2684907
2691011
2705195
2738057
2851897
2925289
2995414
3051534
3216094
3267022
3271559
3338856
3440797
3638325
3651369
3718696
3724814
3811069
3854697
3866969
3893228
3963455
3984546
4098376
4100957
4128113
4200719
4256344
4286332
4306356
4316314
4438803
4458063
4461638
4552228
4563790
4584831
4607992
4884455
4907501
5045419
5066844
5150624
5157161
5190669
5314703
5337397
5434807
5440092
5502665
5523089
5547122
5566200
5582936
5634068
5690330
5776984
5778441
5818505
5826687
5827184
5885735
6010506
6084254
6131498
6138324
6250773
6292801
6306275
6315242
6331640
6484374
6502969
6545970
6666951
6690905
6763576
6766086
6895048
6912227
6929081
6941390
6978168
7045672
7085246
7193307
7197398
7270237
7276767
7295790
7375488
7472098
7687424
7840758
7880957
7904499
7948678
7974126
8015691
8037685
8112955
8131380
8140556
8142384
8220436
8308817
8331317
22581970
45809129
48103779
78212045
79674901
97299830
110308649
131744428
136663461
138485719
139842794
152061792
152685704
153070991
156228213
164884737
174776199
189346581
193148547
208582124
223891881
227308187
237373798
241214067
242476929
245495851
260606593
275202667
285717038
317009689
322759532
325369206
339724742
340122632
345010859
352375176
355826263
359695034
366118516
370008270
382712922
386379440
401153345
404986391
426084981
442843409
473909474
475192613
492302667
494747879
506279889
509813998
537558350
548423414
548467404
566383324
574188786
574792333
591678147
596558084
597423476
602432742
603067874
629552047
630893263
635249783
644959276
650710927
664859367
669433203
684329599
699991513
714451929
723556530
739294558
750895264
757618344
781123405
796973385
801637715
804776709
829003666
829219068
840167037
854882202
860066192
864304878
864808449
867107161
871871263
880591851
883020336
883178082
920223781
936008673
939417822
956776353
958281059
962183717
964059257
967860573
974322643
974999286
980009921
1032949015
1044249483
1064892676
1075628270
1080848022
1085571657
1173635593
1174809080
1176744978
1209783795
1212074975
1252323507
1254757790
1301450562
1302240953
1314501797
1315121266
1339304157
1364304289
1376260506
1383883477
1395158643
1411117754
1440755058
1448365702
1466814914
1468433821
1490105126
1493912601
1495600372
1509536621
1511014977
1545693948
1548924199
1566583103
1569747154
1574097219
1597784674
1610710480
1618324005
1646105187
1649417465
1655649169
1660619384
1668826887
1671093718
1672456990
1673477565
1678638502
1682302139
1682515769
1687920300
1690062315
1706031388
1713660819
1772170709
1778416812
1833443690
1861312062
1876004501
1876358085
1882435551
1916050713
1944906037
1950207172
1951593247
1973638546
1976288281
1994977271
2020053060
2025281195
2029716419
2033980539
2052482076
2058251762
2069273004
2073978021
2111013213
2119886932
2134609957
2140349794
2143934987
Voici un programme Python 3 qui peut être utilisé pour vérifier et noter une soumission:
#!/usr/bin/env python3
import shlex
import os
import sys
import subprocess
try:
from seriously import Seriously
except:
print("Unable to load Seriously. Run 'pip3 install seriously' to install it.")
exit()
if len(sys.argv) < 2:
print("Usage: python3 {} 'command_to_call_your_program'".format(sys.argv[0]))
exit()
sys.stdin = open(os.devnull, 'r')
with open('nums.txt') as f:
nums = [int(x) for x in f]
total = 0
for num in nums:
p = subprocess.Popen(shlex.split(sys.argv[1]), stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
try:
out = p.communicate(str(num), timeout=30)[0].strip()
except subprocess.TimeoutExpired:
print("Program failed to finish within 30 seconds for {}".format(num))
exit()
val = Seriously().eval(out)[0]
if not len(out) <= len(':'+str(num)):
print("Failed to do at least as well as naive on {} ({})".format(num, out))
exit()
elif val != num or not isinstance(val, int):
print("Incorrect output: {} instead of {}".format(val, num))
exit()
else:
print("{}: {} ({})".format(num, out, len(out)))
total += len(out)
print("Total:", total)
Réponses:
Python 3,
515257 octets enregistrésCette brute de programme se fraye un chemin à travers un nombre important de programmes de 1 à 5 caractères, en utilisant un ensemble limité de
5456 instructions et beaucoup d'élagage en fonction de l'état de la pile avant d'ajouter chaque nouvelle instruction. Cela prend environ une minute pour fonctionner sur mon ordinateur portable. 6 caractères prendraient des heures.Voici un échantillonnage aléatoire des types de programmes réellement trouvés par cet algorithme:
la source
Ruby, 52 caractères enregistrés
basé sur ma réponse à une question similaire. Cela constitue une grande liste de façons d'accéder à un nombre et sélectionne la plus courte. Contrairement aux autres réponses publiées, il obtient la plupart de ses économies sur les petits nombres. En fait, je n'essaie pas les nombres avec des valeurs absolues supérieures à 2000.
Et une liste complète de tous les nombres raccourcis (triés par valeur absolue):
Remarque: ceux-ci n'ont pas été testés car je n'ai pas accès à En fait.
la source
Python 3,
5255 octets enregistrésCette solution fonctionne à l'envers des deux précédentes. Au lieu d'assembler des programmes de gauche à droite, je commence à la fin et je recule. Pour que cela fonctionne, je dois réellement exécuter mes programmes et je ne peux pas tailler les instructions en fonction de leurs paramètres car leurs paramètres n'existent pas encore lorsqu'ils sont ajoutés. Ma solution de contournement pour cela n'est pas présente dans cette réponse; cela implique de dire à SeriousCommands.py de lancer une IOError à chaque fois que les fonctions génératrices de folie sont appelées avec de gros arguments, et de lever cette exception pour que je puisse l'attraper.
Voici comment fonctionne ce programme:
Je commence avec une pile vide et je sais que je veux un seul numéro. Quelles instructions peuvent accomplir cela? 0-9 me donne un entier et ne nécessite rien sur la pile, donc ce sont des programmes complets. K, L, T, e et un tas d'autres m'obtiennent un nombre et ont besoin d'un nombre (je ne fais pas de différence entre les flottants et les entiers jusqu'à ce que la sortie soit vérifiée). *, +, etc. transformez deux nombres en un nombre. Etc.
Maintenant, j'ai quelques programmes complets et une liste de suffixes de programme incomplets qui peuvent transformer un arrangement connu de types sur la pile en un seul numéro que je veux. Répétez le processus et ajoutez à chacune d'entre elles toutes les instructions qui peuvent remplir une / certaines / toutes leurs exigences de pile, enregistrez celles qui sont des programmes complets et envoyez les incomplètes à l'étape suivante.
Au cours des deux dernières étapes, je taille beaucoup les possibilités car je sais que je ne peux plus avoir besoin de pile lorsque j'ai terminé (donc 0-9 sont les seules instructions valides à être ajoutées au programme en dernier) et avant cela Je ne peux avoir qu'un seul numéro comme exigence.
Sans surprise, cette solution produit exactement le même score que le meilleur de mes deux autres solutions. Ils trouvent presque exactement le même ensemble de résultats.
Ce programme peut probablement aller jusqu'à 6 caractères en moins de temps que l'autre, mais ce serait quand même prohibitif.
Je pense qu'une excellente solution pourrait être faite en combinant les deux, en assemblant les préfixes et les suffixes et en les joignant au milieu si leurs piles sont compatibles.
la source
Python 3,
3439 octets enregistrésCe programme calcule simplement tous les nombres qu'il peut atteindre en utilisant de simples combinaisons des opérateurs binaires et unaires, ce qui couvre 366k sur 4B entiers, pour un total de quelques dizaines de cas de test. Ensuite, je génère ces résultats ou la solution triviale. C'est techniquement contraire aux règles, car il est certain qu'il existe une meilleure solution pour certains cas, mais je suis convaincu que personne ne parviendra à trouver une solution qui réponde certainement à cette règle.
De plus, je ne fais que produire toutes les sorties à la fois, car 30 secondes de temps de configuration sont supportables une fois, pas 1000 fois. Les sections commentées augmentent considérablement la durée d'exécution tout en réduisant à peine le score.
Voici un échantillonnage aléatoire des types de programmes réellement trouvés par cet algorithme:
la source