商店页面
Comet 64
全部 讨论 截图 艺术作品 实况直播 视频 新闻 指南 评测

Comet 64

商店页面
Comet 64 > 指南 > Hanni 的指南
41 个评价
Comet 64 - Solutions + 100% Achievements
由 Hanni 和其他 2 人合作完成
Guidance for completing the game and obtaining 100% achievements!
2
2
5
2
3
   
奖励
收藏
已收藏
取消收藏
创建者
WeRGoN
离线
Hanni
离线
Giraffe
离线
类型: 成就, 攻略
Languages: 英语
发表于
更新日期
2021 年 2 月 6 日 上午 2:23
7 月 3 日 上午 3:05
2,443 不重复访客数
40 当前收藏人数
指南索引
总览
Introduction 
disk1 
disk2 
disk3 
disk4 
diskA 
diskB 
voodoo.txt 
Endings 
Lookup-Tables 
留言
Introduction


Comet 64 is a fun programming game featuring 59 levels and 13 Steam achievements. This guide provides optimized solutions granting all stars.

There are highly efficient solutions using lookup-tables for some levels. Since they don't grant all stars we list them in a separate section at the end of the guide. Those levels are marked with [LT].

Many thanks to N.G. and Shindo for their additional help!
disk1
End of Disk 1
Solve all puzzles in Disk 1



01. Launch Discount [Achievement: Hello World;]
reg = input * 0.8; output = reg;

02. Why so Negative?
reg = input * -1; output = reg;

03. BMI Guest
int = input; reg = input; reg = reg * reg; reg = int / reg; output = reg;

04. What Goes Up
int++; output = int;

05. Must Come Down [Achievement: The Holy Trinity]
int++; reg = 101-int; output = reg;

06. Compare the Pair
int = input; reg = input; check int > reg; jump if true: print; int = reg; print: output = int;

07. The Doppelgänger
next: int = input; check reg = int; reg = int; jump if false: next; output = int;

08. Sum'♥♥♥♥♥
add: int = input; check int = 0; reg = reg + int; jump if false: add; output = reg; reg = 0;

09. Round About
int = input + 0.5; output = int;

10. Just Around
reg = input / 1000; int = reg * 1000; output = int;
disk2
End of Disk 2
Solve all puzzles in Disk 2



11. Any Leftovers?
reg = input; int = reg / 4; int = int * 4; int = reg - int; output = int;

12. Some Leftovers
start: reg = input / 4; int = reg + 0.25; check reg < int; jump if false: start; reg = reg * 4; output = reg;

13. Differentiator
int = input - input; int = int * int; check int > 25; output = bool;

14. Reverse Integeering
reg = input * 10.1; int = reg / 100.1; int = int * 100; int = reg - int; output = int;

15. Doppelgänger 2
check input = input; output = bool;

16. Heads & Tails
begin: check input = heads; jump if true: end; int++; end: check input = null; jump if false: begin; check int > 50; jump if true: tails; check int < 50; jump if true: heads; output = draw; tails: output = tails; heads: output = heads;

17. Big Brother
int = input; reg = input; check int < reg; jump if true: small; reg = int; small: int = input; check int < reg; jump if true: second; reg = int; second: output = reg;

18. Middle Brother
int = input; reg = input; check int < reg; switch reg; jump if true: third; switch int; third: reg = input; check int > reg; jump if true: out; switch int; check int < reg; jump if true: out; int = reg; out: output = int;

19. Greatest of Brothers
reg = input; again: int = input; check reg > int; jump if true: next; reg = int; next: check input = null; jump if false: again; output = reg;

20. Golden Spiral
int = input; reg = 1; output = 1; loop: output = reg; reg = reg * 0.0162; reg = reg * 100; check reg > int; jump if false: loop;
disk3
End of Disk 3
Solve all puzzles in Disk 3



21. Easier Than It Looks
reg = input - 0.5; int = reg * reg; output = int;

22. Harder Than It Looks
reg = input - 0.5; reg = reg * reg; reg = reg - 0.25; output = reg;

23. Give me a Ballpark
loop: int = int + input; check input = null; jump if false: loop; reg = int / 10; output = reg;

24. Black Jack
loop: int = reg; check input = null; jump if true: end; reg = reg + input; check reg > 21; jump if false: loop; end: output = int; reg = reg - int;

25. Initial Impression
str = input; char = str[0]; output = char;

26. Lasting Impression
str = input; int = str.length - 1; char = str[int]; output = char;

27. thelongeststring
loop: check input = null; jump if true: end; str = input; int = str.length; check int > reg; jump if false: loop; reg = int; switch str; jump to: loop; end: switch str; output = str;

28. 46temoc
str = input; int = str.length; loop: int--; char = str[int]; switch str; str = str + char; switch str; check int > 0; jump if true: loop; switch str; output = str; switch null;

29. 46cemot
str = input; int = str.length - 1; check: reg = int - 1; char = str[int]; switch int; int = char; char = str[reg]; reg = char; check int < reg; switch int; jump if false: continue; str[int] = char; reg = int - 1; switch int; char = int; str[reg] = char; int = str.length; continue: int--; check int < 1; jump if false: check; output = str;

30. Comet LXIV [LT]
reg = input; ten: check reg > 8; jump if false: five; reg = reg - 10; check reg < 0; jump if true: minus; str = str + X; jump to: ten; five: check reg > 3; jump if false: one; reg = reg - 5; check reg < 0; jump if true: minus; str = str + V; one: check reg > 0; jump if false: out; str = str + I; reg--; jump to: one; minus: str = str + I; return; out: output = str; str = ;
disk4
End of Disk 4
Solve all puzzles in Disk 4



31. Coordinate Pairs
reg = input; int = input; output = reg, int;

32. Paired Coordinates
int = input; reg = input; switch reg; reg = input; output = int, reg; switch reg; int = input; output = reg, int;

33. Secret Message
str = input; int = str.length; loop: int--; char = str[int]; check char = g; jump if false: next; char = e; str[int] = char; next: check int = 0; jump if false: loop; output = str;

34. Root Input [LT]
reg = input; int = 0; loop: int = int + 2; reg = reg - int; check reg < 0; jump if false: loop; int = int / 2; output = int;

35. Negative Initiative
loop: int = input; check int < 1; jump if false: loop; output = int; check int = 0; jump if true: loop; skip: check input = 0; jump if false: skip;

36. As Easy As 01 10 11
int = input; check int > 7; jump if false: zero1; str = str + 1; int = int - 8; jump to: next1; zero1: str = str + 0; next1: check int > 3; jump if false: zero2; str = str + 1; int = int - 4; jump to: next2; zero2: str = str + 0; next2: check int > 1; jump if false: zero3; str = str + 1; int = int - 2; jump to: next3; zero3: str = str + 0; next3: check int > 0; jump if false: zero4; str = str + 1; jump to: next4; zero4: str = str + 0; next4: output = str; str = ;

37. Binary Transition [LT]
reg = input + 404; reg = reg / 100; int = reg; reg = reg - int; reg = reg * 100; switch reg; int = int / 5; int = int * 4; switch reg; reg = reg / 5; int = int + reg; output = int;

38. No Duplicates!
loop: int = int + input; check input = null; jump if false: loop; int = int - 45; output = int;

39. No Duplicates!
str = oooooooooo; loop: reg = input; char = str[reg]; check char = o; char = i; str[reg] = char; jump if true: loop; output = reg;

40. Let's Settle This
str = input; int = str.length; str = input; int = int + str.length; str = paper; check int = 9; jump if true: out; str = rock; check int = 12; jump if true: out; str = scissors; check int = 13; jump if true: out; str = draw; out: output = str;
diskA
A:\> Completed
Solve all puzzles in Disk A



A1: full_on [LT]
output = true;

A2: one_on [LT]
check int = 0; output = bool; int++;

A3: one_off [LT]
check int < 31; output = bool; int++;

A4: striped vertical [LT]
output = true; output = false;

A5: striped_horizontal [LT]
output = true; output = true; output = true; output = true; output = false; output = false; output = false; output = false;

A6: outer_circle [LT]
reg = int / 70; reg = reg * 70; check int = reg; output = true; output = bool; output = bool; output = true; int++;

A7: inner_circle [LT]
int = reg + 2; int = int / 4; check int = 1; output = false; output = bool; output = bool; output = false; reg++;

A8: forward_slash [LT]
output = false; output = false; output = false; line: output = true; output = false; output = false; int++; check int = 4; jump if false: line; int = 0; output = false;

A9: back_slash [LT]
line: output = true; output = false; output = false; output = false; output = false; int++; check int = 3; jump if false: line; output = true;
diskB
B:\> Completed
B:\> Completed



B1: output_bool [LT]
check int > 12; output = bool; int++;

B2: checker_board [LT]
output = true; output = false; output = true; output = false; output = false; output = true; output = false; output = true;

B3: ascending_order [LT]
int = reg; output = true; repeat: output = false; int--; check int > -1; jump if true: repeat; reg++;

B4: middle_path [LT]
output = false; output = true; output = true; output = false; output = false; output = false; output = false;

B5: criss_cross [LT]
left: output = false; output = false; output = true; int++; check int < 3; jump if true: left; right: output = false; output = false; output = false; output = false; output = true; int--; check int > 0; jump if true: right;

B6: shooting_stars [LT]
output = false; output = false; output = true;

B7: upper_right [LT]
row: int++; check int > reg; output = bool; check int < 4; jump if true: row; int = 0; reg++; check reg < 4; jump if true: row; reg = 0;

B8: play_button [LT]
start: reg++; check char = y; jump if false: row; reg = reg - 2; row: check int < reg; output = bool; int++; check int < 4; jump if true: row; int = 0; check reg = 4; jump if false: start; char = y; reg = reg + 0.1;

B9: hiroshima [LT]
int++; one: output = true; reg++; check reg = int; jump if false: one; zero: output = false; reg--; check reg = 0; jump if false: zero;
voodoo.txt
What Sorcery is This?
Enter the correct password to access voodoo.txt



As you may have already noticed the voodoo file is encrypted. The password was randomly generated upon starting the game for the first time. Complete all levels of a disk to unlock one of the characters (labeled 'code'). The achievement unlocks after decrypting the file.
Endings
The Father
Play the real ending


The Master
Play the secret ending



The game features two ending: 'The Father' and 'The Master'. For the first one you have to solve all 58 levels before completing the final level. For the second one you have to solve less than 58 levels before completing the final level (delete/backup your local save files if necessary).

Set the login username to masterotari to gain access to the final level.

99. ErRor [Achievement: Star of Bethlehem]
str = input; int = str.length - 1; char = str[0]; switch char; char = str[int]; str[0] = char; switch char; str[int] = char; print str;
Lookup-Tables
Some levels can be solved using lookup-tables. Since they don't grant all stars we list them here.

30. Comet LXIV
str = ooooooioooooiiooooiiioooivoooovoooooviooooviioooviiiooixooooxoooooxiooooxiioooxiiiooxivoooxvooooxvioooxviiooxviiioxixoooxxoooo; int = input * 6; switch null; loop: char = str[int]; check char = o; jump if true: end; switch str; str = str + char; switch str; int++; jump to: loop; end: switch str; output = str;

34. Root Input
str = xaxxbxxxxcxxxxxxdxxxxxxxxexxxxxxxxxxfxxxxxxxxxxxxgxxxxxxxxxxxxxxhxxxxxxxxxxxxxxxxixxxxxxxxxxxxxxxxxxj; int = input; char = str[int]; int = char; output = int;

37. Binary Transition
str = abxxxxxxxxcdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxefxxxxxxxxghxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxijxxxxxxxxklxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxmnxxxxxxxxop; int = input; char = str[int]; int = char; int = int - 1; output = int;

diskA and diskB: // replace an o with an i in the first line if you want to output true
str = oooooooooooooooooooooooooooooooo; char = str[reg]; check char = i; output = bool; reg++;
31 条留言
< >
Roronoa Pronouns 2024 年 10 月 6 日 下午 6:21 
For problem 24, my main problem was that I kept getting the "not enough outputs" error with no idea WHY I wasn't getting enough outputs. I started wondering what I was even supposed to be outputting--every card in the complete sequence, the last card drawn for this sequence, the total before busting, the total after busting? I had to look it up because I genuinely didn't understand how my program was not satisfying the conditions. (It looks like it was falling over because it hit the end of the input and then didn't output the total for the final hand, but I ended up just copying and pasting the solution here because I was done wrestling with vague feedback.)
DeathHero® 2024 年 3 月 18 日 上午 10:14 
THX :cupup:
Giraffe  [作者] 2023 年 10 月 29 日 上午 1:00 
@wrxmarcus I forgot who added the solution for #20 but 0.0162 seems to be an approximation of the golden ratio (1.618033988749...) divided by 100 (0.01618033988749...). The golden ratio and the fibonacci numbers are mathematically related, see https://en.wikipedia.org/wiki/Fibonacci_sequence#Relation_to_the_golden_ratio (warning: lots of math). If I am not mistaken, Numberphile also has a more digestible video about that relationship.
wrxmarcus 2023 年 10 月 28 日 上午 1:17 
For #20 The Golden Spiral -- I need to know how someone came up with reg = reg * 0.0162;?
Where does 0.0162 come from? How many Fn will this work? I'm at a complete loss as to how you go this number. thanks!
MLP 2023 年 7 月 24 日 下午 1:00 
Thank you, WeRGoN!
Left the game for some time
WeRGoN  [作者] 2023 年 2 月 10 日 上午 8:55 
@__theClaw();, Your solution is indeed a bit faster, but the main thing is that it is less hacky (looks like intended way). That's why I updated the guide with your code.

It's funny, that in my time I didn't find such a simple solution through rounding in the INT, but went into the wilderness of the REG. xD
WeRGoN  [作者] 2023 年 2 月 10 日 上午 8:41 
@MLP, Explanation of 12. Some Leftovers.

Our task is to separate a specific remainder of division from the rest ones. In this case, we cut off all the wrong options in 2 steps.

1) We want to cut off half of the options by rounding (we will use the ability of the REG to round to 2 decimal places). So, we need to divide the number by 4 and we have to divide by another 100 to round result. Let's divide row {1, 2, 3, 4} by 400.
{1, 2, 3, 4} / 400 = {0.0025, 0.005, 0.0075, 0.01} (with rounding = {0, 0.01, 0.01, 0.01})

Not the best result, since we were only able to cut off one wrong number. But 0.005 is right on the edge of rounding. We can easily and without consequence make it round down.
{1, 2, 3, 4} / 401 = {0.0024.., 0.0049.., 0.0074.., 0.099..} (with rounding = {0, 0, 0.01, 0.01})
WeRGoN  [作者] 2023 年 2 月 10 日 上午 8:41 
2) We need to learn how to separate the remainder of 3 from 0. The only option is to use the original value, which is stored in INT. Let's try just multiplying by 400 and compare the numbers.
{0, 0, 0.01, 0.01} * 400 = {0, 0, 4, 4} (with INPUT = {1, 2, 3, 4})
If we compare the two sequences (REG = {0, 0, 4, 4} and INT = {1, 2, 3, 4}), we can already make a simple conclusion:
"REMAINDER = 3 if REG > INT"

Thus 400 is sufficient. But I didn't notice it at the time and put 399 to be sure. xD
MLP 2023 年 2 月 7 日 下午 10:51 
@WeRGoN
Great guide!
I wanted to ask about the problem 12 . Some Leftovers

Why is used X/401 and then multiplied by 399? I get that it has to do with leaving the two significant decimals to round the number, but I fail to see why those numbers are used nor the maths behind...

Thank you in advance!
__theClaw(); 2023 年 2 月 2 日 上午 5:40 
Here's a more optimised solution to 12. Some Leftovers (solution by me):

[code]
start:
reg = input / 4;
int = reg + 0.25;
check reg < int;
jump if false: start;
reg = reg * 4;
output = reg;
[/code]