Output the Arecibo Message
$begingroup$
The Arecibo message is a 1974 interstellar radio message carrying basic information about humanity and Earth sent to globular star cluster M13 in the hope that extraterrestrial intelligence might receive and decipher it... The message consisted of 1,679 binary digits, approximately 210 bytes...
The number 1,679 was chosen because it is a semiprime (the product of two prime numbers), to be arranged rectangularly as 73 rows by 23 columns. The alternative arrangement, 23 rows by 73 columns, produces an unintelligible set of characters (as do all other X/Y formats).
This is the message with color added to highlight its separate parts. The actual binary transmission carried no color information.
Source: Wikipedia
Your task is to output the Arecibo Message in the exact 23x73 arrangement shown in the image. Any of these output formats is acceptable:
- Text, using one character for ones and another for zeros (using the usual rules for row separation)
- A 2D array of two distinct values
- A 23x73 image with two distinct colors
- Aan uninterrupted stream of 1679 items of two distinct values (i.e. any of the above formats, but flat.)
- A 1679-bit integer. Indicate bit and byte order (endianness) in your solution.
For your convenience, here is a copy-pastable version (also an example output in text format):
00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000
If your language, for some reason, has a builtin for the Arecibo Message, you may not use that builtin.
Good Luck!
UPDATE: I accepted the 05AB1E answer since it was the first one to be shorter than the original message. Don't let that dissuade you from new solutions.
code-golf kolmogorov-complexity
$endgroup$
|
show 5 more comments
$begingroup$
The Arecibo message is a 1974 interstellar radio message carrying basic information about humanity and Earth sent to globular star cluster M13 in the hope that extraterrestrial intelligence might receive and decipher it... The message consisted of 1,679 binary digits, approximately 210 bytes...
The number 1,679 was chosen because it is a semiprime (the product of two prime numbers), to be arranged rectangularly as 73 rows by 23 columns. The alternative arrangement, 23 rows by 73 columns, produces an unintelligible set of characters (as do all other X/Y formats).
This is the message with color added to highlight its separate parts. The actual binary transmission carried no color information.
Source: Wikipedia
Your task is to output the Arecibo Message in the exact 23x73 arrangement shown in the image. Any of these output formats is acceptable:
- Text, using one character for ones and another for zeros (using the usual rules for row separation)
- A 2D array of two distinct values
- A 23x73 image with two distinct colors
- Aan uninterrupted stream of 1679 items of two distinct values (i.e. any of the above formats, but flat.)
- A 1679-bit integer. Indicate bit and byte order (endianness) in your solution.
For your convenience, here is a copy-pastable version (also an example output in text format):
00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000
If your language, for some reason, has a builtin for the Arecibo Message, you may not use that builtin.
Good Luck!
UPDATE: I accepted the 05AB1E answer since it was the first one to be shorter than the original message. Don't let that dissuade you from new solutions.
code-golf kolmogorov-complexity
$endgroup$
8
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
5
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
3
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
4
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday
|
show 5 more comments
$begingroup$
The Arecibo message is a 1974 interstellar radio message carrying basic information about humanity and Earth sent to globular star cluster M13 in the hope that extraterrestrial intelligence might receive and decipher it... The message consisted of 1,679 binary digits, approximately 210 bytes...
The number 1,679 was chosen because it is a semiprime (the product of two prime numbers), to be arranged rectangularly as 73 rows by 23 columns. The alternative arrangement, 23 rows by 73 columns, produces an unintelligible set of characters (as do all other X/Y formats).
This is the message with color added to highlight its separate parts. The actual binary transmission carried no color information.
Source: Wikipedia
Your task is to output the Arecibo Message in the exact 23x73 arrangement shown in the image. Any of these output formats is acceptable:
- Text, using one character for ones and another for zeros (using the usual rules for row separation)
- A 2D array of two distinct values
- A 23x73 image with two distinct colors
- Aan uninterrupted stream of 1679 items of two distinct values (i.e. any of the above formats, but flat.)
- A 1679-bit integer. Indicate bit and byte order (endianness) in your solution.
For your convenience, here is a copy-pastable version (also an example output in text format):
00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000
If your language, for some reason, has a builtin for the Arecibo Message, you may not use that builtin.
Good Luck!
UPDATE: I accepted the 05AB1E answer since it was the first one to be shorter than the original message. Don't let that dissuade you from new solutions.
code-golf kolmogorov-complexity
$endgroup$
The Arecibo message is a 1974 interstellar radio message carrying basic information about humanity and Earth sent to globular star cluster M13 in the hope that extraterrestrial intelligence might receive and decipher it... The message consisted of 1,679 binary digits, approximately 210 bytes...
The number 1,679 was chosen because it is a semiprime (the product of two prime numbers), to be arranged rectangularly as 73 rows by 23 columns. The alternative arrangement, 23 rows by 73 columns, produces an unintelligible set of characters (as do all other X/Y formats).
This is the message with color added to highlight its separate parts. The actual binary transmission carried no color information.
Source: Wikipedia
Your task is to output the Arecibo Message in the exact 23x73 arrangement shown in the image. Any of these output formats is acceptable:
- Text, using one character for ones and another for zeros (using the usual rules for row separation)
- A 2D array of two distinct values
- A 23x73 image with two distinct colors
- Aan uninterrupted stream of 1679 items of two distinct values (i.e. any of the above formats, but flat.)
- A 1679-bit integer. Indicate bit and byte order (endianness) in your solution.
For your convenience, here is a copy-pastable version (also an example output in text format):
00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000
If your language, for some reason, has a builtin for the Arecibo Message, you may not use that builtin.
Good Luck!
UPDATE: I accepted the 05AB1E answer since it was the first one to be shorter than the original message. Don't let that dissuade you from new solutions.
code-golf kolmogorov-complexity
code-golf kolmogorov-complexity
edited 8 hours ago
Beefster
asked 2 days ago
BeefsterBeefster
2,6771344
2,6771344
8
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
5
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
3
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
4
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday
|
show 5 more comments
8
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
5
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
3
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
4
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday
8
8
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
5
5
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
3
3
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
4
4
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday
|
show 5 more comments
19 Answers
19
active
oldest
votes
$begingroup$
05AB1E, 215 210 200 bytes
Saved 15 bytes thanks to Magic Octopus Urn
•cOž¤4é57ñΛÖ₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxGÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:
Try it online!
or with Additional formatting
Base-255 encoded trinary string with occurrences of 0000
replaced by 2
.
$endgroup$
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace0000
with2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201
$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
add a comment |
$begingroup$
Java, 688 678 590 379 361 bytes
Returns a string.
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")
-10 bytes by returning the raw stream (old answer)
-88 bytes by using base 10 numerics (thanks @ceilingcat!)
-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)
-18 bytes by using a different encoded integer (thanks again @JollyJoker)
Try it online!
Explanation:
n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
.toString(3) // Re-encode as ternary
.replace("2","0000") // Replace 2 with "0000"
// Implicit return
$endgroup$
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
add a comment |
$begingroup$
Jelly, 213 bytes
“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’
Try it online!
I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.
Try it online - with further decoding to demonstrate output!
If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.
$endgroup$
add a comment |
$begingroup$
Brainfuck, 2360 2008 1938 bytes
-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...
Try it online!
I will probably golf this even further soon.
$endgroup$
add a comment |
$begingroup$
C# (Visual C# Interactive Compiler), 366 332 329 319 bytes
int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));
Replace all instances of ␀
with to test.
Try it online!
C# (Visual C# Interactive Compiler), 305 bytes, 210 chars
_=>"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))
Same with above, replace with ␀
with to test. Output as
IEnumerable<string>
.
Try it online!(Courtesy of Jo King)
$endgroup$
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the++
in12-i++%2
is a nop (at least, it worked for me when I removed it)
$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
add a comment |
$begingroup$
Deadfish~, 1115 bytes
ooooooiodoiodoiodoiod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{d}iodoooiodoooiodoooiodooiodoioodooiodo{i}c{d}iodoiodoiodoiodoiodoiodoiodoiodooiodooiodoo{i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo
Try it online!
If someone has the patience to golf this further, I salute you ahead of time. :P
$endgroup$
add a comment |
$begingroup$
Perl 6, 368 bytes
.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)
Try it online!
The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.
$endgroup$
$begingroup$
You can use>>.say
and&{S/.//}
to save bytes. Have you thought about using a different base instead?
$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
add a comment |
$begingroup$
Wolfram Language (Mathematica), 383 bytes
StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]
Try it online!
$endgroup$
add a comment |
$begingroup$
Node.js, 333 bytes
Returns a binary string of 1,679 characters.
_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s
Try it online! (with formatted output)
JavaScript (ES8), 413 bytes
Returns a binary string of 1,679 characters.
_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))
Try it online! (with formatted output)
$endgroup$
add a comment |
$begingroup$
Bubblegum, 275 236 bytes
00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580 {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8 ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6 ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715 .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4 ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1 Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690 .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00 ....1......
Try it online!
$endgroup$
add a comment |
$begingroup$
Perl 5, 460 bytes
printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/
Try it online!
$endgroup$
add a comment |
$begingroup$
bash + GNU tools, 351 bytes
base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip
TIO
$endgroup$
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
add a comment |
$begingroup$
Java (OpenJDK 8), 364 bytes
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")
Try it online!
Explanation: First had n->new java.math.BigInteger(str,36).toString(2)
, just converting a radix 36 number to binary, but that needed nine extra chars for leading zeroes. Then, I got the idea of run-length encoding some zeroes as twos. A length of four zeroes seems to minimize the radix 36 length, so n->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
See the discussion under this answer for the leading zeroes bug fix by @KevinCruijssen
$endgroup$
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
add a comment |
$begingroup$
[Python 2], 346 bytes
s='';
for c in '''%pG+K$K&j h!kk ppjGDI2S2S1[1e?v~vw,x"z wgqcde e9G0G;G0eG,e6vv~w&G(gn wy uuuuG9G%I(G*I.G$I)eG$I%e)I,G'G'G$G%I&G&vI%G)w#I.y,w#I(vI%G&G%G'G$G&I'W'I'W(G&G$G&G&G&G+I(I'I(iq*G&G-G$e+g c!sG%m!md~ M$}(K$cO%K$eO%K$I%G$aBM$G-c hpoI(pG/K-e/eU+M&M(I*I&S(Q$y&y#hG$ng"j j G'hW+g#G+G(G-k*''':c=ord(c)-31;s+=c<39and'0'*c or bin(c-39)[2:]
print s
I encoded the length of strings of 0s as a byte starting at chr(31). Then I encoded the remaining 10101 as binary numbers starting at chr(70) up to chr(126). Binary strings that didn't fit were split up into smaller chunks.
Edit: Reduced to 326 bytes. Thanks Jo King
Edit: Fixed a bug in the code generator program
New contributor
$endgroup$
$begingroup$
Actually, a list comprehension is even shorter.[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer
$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string ino
to a variable.
$endgroup$
– xnor
1 hour ago
add a comment |
$begingroup$
Python 2, 336 bytes
print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]
Try it online!
Prints a string of bytes
$endgroup$
add a comment |
$begingroup$
Bash, 702 697 bytes
xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X
Try it online!
$endgroup$
add a comment |
$begingroup$
Ruby, 362 bytes
puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)
Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib
or base64
.
Try it online!
$endgroup$
add a comment |
$begingroup$
[C++ (VC++)(but tested with gcc as well)], 585 bytes
#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}
Try it online!
ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char arecibo="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
int i = 0,j;
while (i<sizeof(arecibo)-1)
{
char digit = arecibo[i];
int count=0;
if (digit >= '0' & digit <= '9')
{
digit -= '0';
}
else if (digit>='A'& digit<='F')
{
digit -= 'A'-10;
}
else if (digit > 'F'&digit<='Z')
{
//digit does not contain any valid hex digit in this case
count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
digit = arecibo[i - 1];
}
for (count; count >= 0; count--)
{
for (j = 0; j<4; j++)
{
cout << (int)(((digit)&(8 >> j))>0);
}
}
i++;
}
return 0;
}
as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the ,
Operator and the like.
Output Format is uninterrupted stream of 1679 0/1-values.
$endgroup$
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
add a comment |
$begingroup$
Perl 6, 348 bytes
{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}
Based on Benjamin Urquhart's Java solution.
Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.
Try it online!
$endgroup$
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
return StackExchange.using("mathjaxEditing", function () {
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
});
});
}, "mathjax-editing");
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "200"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f182924%2foutput-the-arecibo-message%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
19 Answers
19
active
oldest
votes
19 Answers
19
active
oldest
votes
active
oldest
votes
active
oldest
votes
$begingroup$
05AB1E, 215 210 200 bytes
Saved 15 bytes thanks to Magic Octopus Urn
•cOž¤4é57ñΛÖ₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxGÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:
Try it online!
or with Additional formatting
Base-255 encoded trinary string with occurrences of 0000
replaced by 2
.
$endgroup$
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace0000
with2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201
$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
add a comment |
$begingroup$
05AB1E, 215 210 200 bytes
Saved 15 bytes thanks to Magic Octopus Urn
•cOž¤4é57ñΛÖ₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxGÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:
Try it online!
or with Additional formatting
Base-255 encoded trinary string with occurrences of 0000
replaced by 2
.
$endgroup$
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace0000
with2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201
$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
add a comment |
$begingroup$
05AB1E, 215 210 200 bytes
Saved 15 bytes thanks to Magic Octopus Urn
•cOž¤4é57ñΛÖ₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxGÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:
Try it online!
or with Additional formatting
Base-255 encoded trinary string with occurrences of 0000
replaced by 2
.
$endgroup$
05AB1E, 215 210 200 bytes
Saved 15 bytes thanks to Magic Octopus Urn
•cOž¤4é57ñΛÖ₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxGÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:
Try it online!
or with Additional formatting
Base-255 encoded trinary string with occurrences of 0000
replaced by 2
.
edited yesterday
answered 2 days ago
EmignaEmigna
47.9k434146
47.9k434146
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace0000
with2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201
$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
add a comment |
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace0000
with2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201
$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
@MagicOctopusUrn: Thanks! That makes it 210 even :)
$endgroup$
– Emigna
yesterday
$begingroup$
It's actually even better if you replace
0000
with 2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
It's actually even better if you replace
0000
with 2
by 9 more bytes. - pastebin.com/aZ6tHxjx for 201$endgroup$
– Magic Octopus Urn
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
$begingroup$
@MagicOctopusUrn: Yes, I found that as well and was just about to post it :)
$endgroup$
– Emigna
yesterday
1
1
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
Cool! Since the Arecibo messages is 210 bytes (23 * 73 / 8 = 209.875), your solution (currently at 200 bytes) is shorter than the message itself!
$endgroup$
– J-L
9 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
$begingroup$
I went ahead and made this the accepted answer since it was the first one to be shorter than the message itself.
$endgroup$
– Beefster
8 hours ago
add a comment |
$begingroup$
Java, 688 678 590 379 361 bytes
Returns a string.
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")
-10 bytes by returning the raw stream (old answer)
-88 bytes by using base 10 numerics (thanks @ceilingcat!)
-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)
-18 bytes by using a different encoded integer (thanks again @JollyJoker)
Try it online!
Explanation:
n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
.toString(3) // Re-encode as ternary
.replace("2","0000") // Replace 2 with "0000"
// Implicit return
$endgroup$
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
add a comment |
$begingroup$
Java, 688 678 590 379 361 bytes
Returns a string.
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")
-10 bytes by returning the raw stream (old answer)
-88 bytes by using base 10 numerics (thanks @ceilingcat!)
-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)
-18 bytes by using a different encoded integer (thanks again @JollyJoker)
Try it online!
Explanation:
n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
.toString(3) // Re-encode as ternary
.replace("2","0000") // Replace 2 with "0000"
// Implicit return
$endgroup$
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
add a comment |
$begingroup$
Java, 688 678 590 379 361 bytes
Returns a string.
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")
-10 bytes by returning the raw stream (old answer)
-88 bytes by using base 10 numerics (thanks @ceilingcat!)
-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)
-18 bytes by using a different encoded integer (thanks again @JollyJoker)
Try it online!
Explanation:
n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
.toString(3) // Re-encode as ternary
.replace("2","0000") // Replace 2 with "0000"
// Implicit return
$endgroup$
Java, 688 678 590 379 361 bytes
Returns a string.
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")
-10 bytes by returning the raw stream (old answer)
-88 bytes by using base 10 numerics (thanks @ceilingcat!)
-211 bytes (I knew it could be golfed!) by using a base-36 encoded BigInteger (thanks @JollyJoker!)
-18 bytes by using a different encoded integer (thanks again @JollyJoker)
Try it online!
Explanation:
n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
.toString(3) // Re-encode as ternary
.replace("2","0000") // Replace 2 with "0000"
// Implicit return
edited 8 hours ago
answered 2 days ago
Benjamin UrquhartBenjamin Urquhart
47017
47017
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
add a comment |
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
$begingroup$
Comments are not for extended discussion; this conversation has been moved to chat.
$endgroup$
– Adam Lear♦
3 hours ago
add a comment |
$begingroup$
Jelly, 213 bytes
“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’
Try it online!
I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.
Try it online - with further decoding to demonstrate output!
If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.
$endgroup$
add a comment |
$begingroup$
Jelly, 213 bytes
“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’
Try it online!
I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.
Try it online - with further decoding to demonstrate output!
If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.
$endgroup$
add a comment |
$begingroup$
Jelly, 213 bytes
“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’
Try it online!
I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.
Try it online - with further decoding to demonstrate output!
If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.
$endgroup$
Jelly, 213 bytes
“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’
Try it online!
I played around with Huffman coding, but the improvements in data size were outweighed by the extra code. As such, this is simply a base-250 encoded version of the desired output. Output consists of an integer that when decoded as bijective base 2 will yield the 1D list of 1s and 2s. Thanks @Emigna for pointing out the change in rules.
Try it online - with further decoding to demonstrate output!
If a more conventional binary encoding is preferred, here is one that encodes an integer representation of the inverted binary message. The most significant bit of the integer represents the beginning of the message.
edited 2 days ago
answered 2 days ago
Nick KennedyNick Kennedy
1,51649
1,51649
add a comment |
add a comment |
$begingroup$
Brainfuck, 2360 2008 1938 bytes
-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...
Try it online!
I will probably golf this even further soon.
$endgroup$
add a comment |
$begingroup$
Brainfuck, 2360 2008 1938 bytes
-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...
Try it online!
I will probably golf this even further soon.
$endgroup$
add a comment |
$begingroup$
Brainfuck, 2360 2008 1938 bytes
-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...
Try it online!
I will probably golf this even further soon.
$endgroup$
Brainfuck, 2360 2008 1938 bytes
-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...
Try it online!
I will probably golf this even further soon.
edited 10 hours ago
answered 2 days ago
orthoplexorthoplex
1614
1614
add a comment |
add a comment |
$begingroup$
C# (Visual C# Interactive Compiler), 366 332 329 319 bytes
int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));
Replace all instances of ␀
with to test.
Try it online!
C# (Visual C# Interactive Compiler), 305 bytes, 210 chars
_=>"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))
Same with above, replace with ␀
with to test. Output as
IEnumerable<string>
.
Try it online!(Courtesy of Jo King)
$endgroup$
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the++
in12-i++%2
is a nop (at least, it worked for me when I removed it)
$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
add a comment |
$begingroup$
C# (Visual C# Interactive Compiler), 366 332 329 319 bytes
int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));
Replace all instances of ␀
with to test.
Try it online!
C# (Visual C# Interactive Compiler), 305 bytes, 210 chars
_=>"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))
Same with above, replace with ␀
with to test. Output as
IEnumerable<string>
.
Try it online!(Courtesy of Jo King)
$endgroup$
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the++
in12-i++%2
is a nop (at least, it worked for me when I removed it)
$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
add a comment |
$begingroup$
C# (Visual C# Interactive Compiler), 366 332 329 319 bytes
int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));
Replace all instances of ␀
with to test.
Try it online!
C# (Visual C# Interactive Compiler), 305 bytes, 210 chars
_=>"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))
Same with above, replace with ␀
with to test. Output as
IEnumerable<string>
.
Try it online!(Courtesy of Jo King)
$endgroup$
C# (Visual C# Interactive Compiler), 366 332 329 319 bytes
int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));
Replace all instances of ␀
with to test.
Try it online!
C# (Visual C# Interactive Compiler), 305 bytes, 210 chars
_=>"*ЀʂЄ࢈ҲપԤ␀␀␀ȀȀȀ␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺȂ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀␀ΨՕŔ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))
Same with above, replace with ␀
with to test. Output as
IEnumerable<string>
.
Try it online!(Courtesy of Jo King)
edited yesterday
answered 2 days ago
Embodiment of IgnoranceEmbodiment of Ignorance
2,946127
2,946127
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the++
in12-i++%2
is a nop (at least, it worked for me when I removed it)
$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
add a comment |
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the++
in12-i++%2
is a nop (at least, it worked for me when I removed it)
$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
TIO link with NUL bytes
$endgroup$
– Jo King
yesterday
$begingroup$
I believe the
++
in 12-i++%2
is a nop (at least, it worked for me when I removed it)$endgroup$
– someone
yesterday
$begingroup$
I believe the
++
in 12-i++%2
is a nop (at least, it worked for me when I removed it)$endgroup$
– someone
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
$begingroup$
@someone They are a copy-paste from the old answer I forgot to remove
$endgroup$
– Embodiment of Ignorance
yesterday
add a comment |
$begingroup$
Deadfish~, 1115 bytes
ooooooiodoiodoiodoiod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{d}iodoooiodoooiodoooiodooiodoioodooiodo{i}c{d}iodoiodoiodoiodoiodoiodoiodoiodooiodooiodoo{i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo
Try it online!
If someone has the patience to golf this further, I salute you ahead of time. :P
$endgroup$
add a comment |
$begingroup$
Deadfish~, 1115 bytes
ooooooiodoiodoiodoiod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{d}iodoooiodoooiodoooiodooiodoioodooiodo{i}c{d}iodoiodoiodoiodoiodoiodoiodoiodooiodooiodoo{i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo
Try it online!
If someone has the patience to golf this further, I salute you ahead of time. :P
$endgroup$
add a comment |
$begingroup$
Deadfish~, 1115 bytes
ooooooiodoiodoiodoiod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{d}iodoooiodoooiodoooiodooiodoioodooiodo{i}c{d}iodoiodoiodoiodoiodoiodoiodoiodooiodooiodoo{i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo
Try it online!
If someone has the patience to golf this further, I salute you ahead of time. :P
$endgroup$
Deadfish~, 1115 bytes
ooooooiodoiodoiodoiod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{d}iodoooiodoooiodoooiodooiodoioodooiodo{i}c{d}iodoiodoiodoiodoiodoiodoiodoiodooiodooiodoo{i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo
Try it online!
If someone has the patience to golf this further, I salute you ahead of time. :P
answered 2 days ago
squidsquid
1214
1214
add a comment |
add a comment |
$begingroup$
Perl 6, 368 bytes
.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)
Try it online!
The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.
$endgroup$
$begingroup$
You can use>>.say
and&{S/.//}
to save bytes. Have you thought about using a different base instead?
$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
add a comment |
$begingroup$
Perl 6, 368 bytes
.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)
Try it online!
The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.
$endgroup$
$begingroup$
You can use>>.say
and&{S/.//}
to save bytes. Have you thought about using a different base instead?
$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
add a comment |
$begingroup$
Perl 6, 368 bytes
.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)
Try it online!
The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.
$endgroup$
Perl 6, 368 bytes
.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)
Try it online!
The long string is the message as a single base-36 number (with a single prefixed 1 bit to preserve the leading zeroes) which is then converted back to binary and printed 23 bits at a time.
answered 2 days ago
SeanSean
3,54637
3,54637
$begingroup$
You can use>>.say
and&{S/.//}
to save bytes. Have you thought about using a different base instead?
$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
add a comment |
$begingroup$
You can use>>.say
and&{S/.//}
to save bytes. Have you thought about using a different base instead?
$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
$begingroup$
You can use
>>.say
and &{S/.//}
to save bytes. Have you thought about using a different base instead?$endgroup$
– Jo King
2 days ago
$begingroup$
You can use
>>.say
and &{S/.//}
to save bytes. Have you thought about using a different base instead?$endgroup$
– Jo King
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
Yes, I tried using base 65536/Unicode, but the message runs into some forbidden surrogate codepoints. I was able to avoid that by adding a fixed offset to each codepoint, but astonishingly, some of the generated strings crashed Emacs a few times. Resolving the issues started taking more time than I could afford to commit. I'll probably revisit the problem later.
$endgroup$
– Sean
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
$begingroup$
There's no point going into multiple byte characters, since that increases your byte count. 289 bytes by implementing my tips from above and using base 122 (to avoid carriage returns)
$endgroup$
– Jo King
2 days ago
add a comment |
$begingroup$
Wolfram Language (Mathematica), 383 bytes
StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]
Try it online!
$endgroup$
add a comment |
$begingroup$
Wolfram Language (Mathematica), 383 bytes
StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]
Try it online!
$endgroup$
add a comment |
$begingroup$
Wolfram Language (Mathematica), 383 bytes
StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]
Try it online!
$endgroup$
Wolfram Language (Mathematica), 383 bytes
StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]
Try it online!
answered 2 days ago
J42161217J42161217
13.9k21353
13.9k21353
add a comment |
add a comment |
$begingroup$
Node.js, 333 bytes
Returns a binary string of 1,679 characters.
_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s
Try it online! (with formatted output)
JavaScript (ES8), 413 bytes
Returns a binary string of 1,679 characters.
_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))
Try it online! (with formatted output)
$endgroup$
add a comment |
$begingroup$
Node.js, 333 bytes
Returns a binary string of 1,679 characters.
_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s
Try it online! (with formatted output)
JavaScript (ES8), 413 bytes
Returns a binary string of 1,679 characters.
_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))
Try it online! (with formatted output)
$endgroup$
add a comment |
$begingroup$
Node.js, 333 bytes
Returns a binary string of 1,679 characters.
_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s
Try it online! (with formatted output)
JavaScript (ES8), 413 bytes
Returns a binary string of 1,679 characters.
_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))
Try it online! (with formatted output)
$endgroup$
Node.js, 333 bytes
Returns a binary string of 1,679 characters.
_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s
Try it online! (with formatted output)
JavaScript (ES8), 413 bytes
Returns a binary string of 1,679 characters.
_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[sS]/g,c=>c.charCodeAt().toString(2).padStart(8,0))
Try it online! (with formatted output)
edited 2 days ago
answered 2 days ago
ArnauldArnauld
80.8k797334
80.8k797334
add a comment |
add a comment |
$begingroup$
Bubblegum, 275 236 bytes
00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580 {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8 ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6 ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715 .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4 ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1 Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690 .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00 ....1......
Try it online!
$endgroup$
add a comment |
$begingroup$
Bubblegum, 275 236 bytes
00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580 {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8 ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6 ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715 .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4 ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1 Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690 .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00 ....1......
Try it online!
$endgroup$
add a comment |
$begingroup$
Bubblegum, 275 236 bytes
00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580 {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8 ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6 ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715 .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4 ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1 Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690 .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00 ....1......
Try it online!
$endgroup$
Bubblegum, 275 236 bytes
00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630 .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68 E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580 {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8 ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6 ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715 .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4 ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1 Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690 .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00 ....1......
Try it online!
edited yesterday
answered 2 days ago
orthoplexorthoplex
1614
1614
add a comment |
add a comment |
$begingroup$
Perl 5, 460 bytes
printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/
Try it online!
$endgroup$
add a comment |
$begingroup$
Perl 5, 460 bytes
printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/
Try it online!
$endgroup$
add a comment |
$begingroup$
Perl 5, 460 bytes
printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/
Try it online!
$endgroup$
Perl 5, 460 bytes
printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/
Try it online!
answered 2 days ago
XcaliXcali
5,505520
5,505520
add a comment |
add a comment |
$begingroup$
bash + GNU tools, 351 bytes
base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip
TIO
$endgroup$
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
add a comment |
$begingroup$
bash + GNU tools, 351 bytes
base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip
TIO
$endgroup$
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
add a comment |
$begingroup$
bash + GNU tools, 351 bytes
base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip
TIO
$endgroup$
bash + GNU tools, 351 bytes
base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip
TIO
edited yesterday
answered yesterday
Nahuel FouilleulNahuel Fouilleul
3,025211
3,025211
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
add a comment |
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
$begingroup$
didn't see your bash post before I posted mine - so much smaller!
$endgroup$
– Noodle9
yesterday
add a comment |
$begingroup$
Java (OpenJDK 8), 364 bytes
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")
Try it online!
Explanation: First had n->new java.math.BigInteger(str,36).toString(2)
, just converting a radix 36 number to binary, but that needed nine extra chars for leading zeroes. Then, I got the idea of run-length encoding some zeroes as twos. A length of four zeroes seems to minimize the radix 36 length, so n->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
See the discussion under this answer for the leading zeroes bug fix by @KevinCruijssen
$endgroup$
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
add a comment |
$begingroup$
Java (OpenJDK 8), 364 bytes
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")
Try it online!
Explanation: First had n->new java.math.BigInteger(str,36).toString(2)
, just converting a radix 36 number to binary, but that needed nine extra chars for leading zeroes. Then, I got the idea of run-length encoding some zeroes as twos. A length of four zeroes seems to minimize the radix 36 length, so n->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
See the discussion under this answer for the leading zeroes bug fix by @KevinCruijssen
$endgroup$
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
add a comment |
$begingroup$
Java (OpenJDK 8), 364 bytes
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")
Try it online!
Explanation: First had n->new java.math.BigInteger(str,36).toString(2)
, just converting a radix 36 number to binary, but that needed nine extra chars for leading zeroes. Then, I got the idea of run-length encoding some zeroes as twos. A length of four zeroes seems to minimize the radix 36 length, so n->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
See the discussion under this answer for the leading zeroes bug fix by @KevinCruijssen
$endgroup$
Java (OpenJDK 8), 364 bytes
n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")
Try it online!
Explanation: First had n->new java.math.BigInteger(str,36).toString(2)
, just converting a radix 36 number to binary, but that needed nine extra chars for leading zeroes. Then, I got the idea of run-length encoding some zeroes as twos. A length of four zeroes seems to minimize the radix 36 length, so n->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
See the discussion under this answer for the leading zeroes bug fix by @KevinCruijssen
answered yesterday
JollyJokerJollyJoker
39116
39116
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
add a comment |
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
$begingroup$
Nice. It's impressively short for Java!
$endgroup$
– Eric Duminil
18 hours ago
add a comment |
$begingroup$
[Python 2], 346 bytes
s='';
for c in '''%pG+K$K&j h!kk ppjGDI2S2S1[1e?v~vw,x"z wgqcde e9G0G;G0eG,e6vv~w&G(gn wy uuuuG9G%I(G*I.G$I)eG$I%e)I,G'G'G$G%I&G&vI%G)w#I.y,w#I(vI%G&G%G'G$G&I'W'I'W(G&G$G&G&G&G+I(I'I(iq*G&G-G$e+g c!sG%m!md~ M$}(K$cO%K$eO%K$I%G$aBM$G-c hpoI(pG/K-e/eU+M&M(I*I&S(Q$y&y#hG$ng"j j G'hW+g#G+G(G-k*''':c=ord(c)-31;s+=c<39and'0'*c or bin(c-39)[2:]
print s
I encoded the length of strings of 0s as a byte starting at chr(31). Then I encoded the remaining 10101 as binary numbers starting at chr(70) up to chr(126). Binary strings that didn't fit were split up into smaller chunks.
Edit: Reduced to 326 bytes. Thanks Jo King
Edit: Fixed a bug in the code generator program
New contributor
$endgroup$
$begingroup$
Actually, a list comprehension is even shorter.[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer
$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string ino
to a variable.
$endgroup$
– xnor
1 hour ago
add a comment |
$begingroup$
[Python 2], 346 bytes
s='';
for c in '''%pG+K$K&j h!kk ppjGDI2S2S1[1e?v~vw,x"z wgqcde e9G0G;G0eG,e6vv~w&G(gn wy uuuuG9G%I(G*I.G$I)eG$I%e)I,G'G'G$G%I&G&vI%G)w#I.y,w#I(vI%G&G%G'G$G&I'W'I'W(G&G$G&G&G&G+I(I'I(iq*G&G-G$e+g c!sG%m!md~ M$}(K$cO%K$eO%K$I%G$aBM$G-c hpoI(pG/K-e/eU+M&M(I*I&S(Q$y&y#hG$ng"j j G'hW+g#G+G(G-k*''':c=ord(c)-31;s+=c<39and'0'*c or bin(c-39)[2:]
print s
I encoded the length of strings of 0s as a byte starting at chr(31). Then I encoded the remaining 10101 as binary numbers starting at chr(70) up to chr(126). Binary strings that didn't fit were split up into smaller chunks.
Edit: Reduced to 326 bytes. Thanks Jo King
Edit: Fixed a bug in the code generator program
New contributor
$endgroup$
$begingroup$
Actually, a list comprehension is even shorter.[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer
$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string ino
to a variable.
$endgroup$
– xnor
1 hour ago
add a comment |
$begingroup$
[Python 2], 346 bytes
s='';
for c in '''%pG+K$K&j h!kk ppjGDI2S2S1[1e?v~vw,x"z wgqcde e9G0G;G0eG,e6vv~w&G(gn wy uuuuG9G%I(G*I.G$I)eG$I%e)I,G'G'G$G%I&G&vI%G)w#I.y,w#I(vI%G&G%G'G$G&I'W'I'W(G&G$G&G&G&G+I(I'I(iq*G&G-G$e+g c!sG%m!md~ M$}(K$cO%K$eO%K$I%G$aBM$G-c hpoI(pG/K-e/eU+M&M(I*I&S(Q$y&y#hG$ng"j j G'hW+g#G+G(G-k*''':c=ord(c)-31;s+=c<39and'0'*c or bin(c-39)[2:]
print s
I encoded the length of strings of 0s as a byte starting at chr(31). Then I encoded the remaining 10101 as binary numbers starting at chr(70) up to chr(126). Binary strings that didn't fit were split up into smaller chunks.
Edit: Reduced to 326 bytes. Thanks Jo King
Edit: Fixed a bug in the code generator program
New contributor
$endgroup$
[Python 2], 346 bytes
s='';
for c in '''%pG+K$K&j h!kk ppjGDI2S2S1[1e?v~vw,x"z wgqcde e9G0G;G0eG,e6vv~w&G(gn wy uuuuG9G%I(G*I.G$I)eG$I%e)I,G'G'G$G%I&G&vI%G)w#I.y,w#I(vI%G&G%G'G$G&I'W'I'W(G&G$G&G&G&G+I(I'I(iq*G&G-G$e+g c!sG%m!md~ M$}(K$cO%K$eO%K$I%G$aBM$G-c hpoI(pG/K-e/eU+M&M(I*I&S(Q$y&y#hG$ng"j j G'hW+g#G+G(G-k*''':c=ord(c)-31;s+=c<39and'0'*c or bin(c-39)[2:]
print s
I encoded the length of strings of 0s as a byte starting at chr(31). Then I encoded the remaining 10101 as binary numbers starting at chr(70) up to chr(126). Binary strings that didn't fit were split up into smaller chunks.
Edit: Reduced to 326 bytes. Thanks Jo King
Edit: Fixed a bug in the code generator program
New contributor
edited 35 mins ago
New contributor
answered 2 hours ago
BenjaminBenjamin
112
112
New contributor
New contributor
$begingroup$
Actually, a list comprehension is even shorter.[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer
$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string ino
to a variable.
$endgroup$
– xnor
1 hour ago
add a comment |
$begingroup$
Actually, a list comprehension is even shorter.[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer
$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string ino
to a variable.
$endgroup$
– xnor
1 hour ago
$begingroup$
Actually, a list comprehension is even shorter.
[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer$endgroup$
– Jo King
1 hour ago
$begingroup$
Actually, a list comprehension is even shorter.
[bin(c-39)[2:],'0'*c][c<39]
. You're also missing the link part of your answer$endgroup$
– Jo King
1 hour ago
$begingroup$
You don't need to save the big string in
o
to a variable.$endgroup$
– xnor
1 hour ago
$begingroup$
You don't need to save the big string in
o
to a variable.$endgroup$
– xnor
1 hour ago
add a comment |
$begingroup$
Python 2, 336 bytes
print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]
Try it online!
Prints a string of bytes
$endgroup$
add a comment |
$begingroup$
Python 2, 336 bytes
print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]
Try it online!
Prints a string of bytes
$endgroup$
add a comment |
$begingroup$
Python 2, 336 bytes
print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]
Try it online!
Prints a string of bytes
$endgroup$
Python 2, 336 bytes
print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]
Try it online!
Prints a string of bytes
answered yesterday
TFeldTFeld
16.5k21451
16.5k21451
add a comment |
add a comment |
$begingroup$
Bash, 702 697 bytes
xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X
Try it online!
$endgroup$
add a comment |
$begingroup$
Bash, 702 697 bytes
xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X
Try it online!
$endgroup$
add a comment |
$begingroup$
Bash, 702 697 bytes
xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X
Try it online!
$endgroup$
Bash, 702 697 bytes
xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X
Try it online!
edited yesterday
answered yesterday
Noodle9Noodle9
30137
30137
add a comment |
add a comment |
$begingroup$
Ruby, 362 bytes
puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)
Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib
or base64
.
Try it online!
$endgroup$
add a comment |
$begingroup$
Ruby, 362 bytes
puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)
Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib
or base64
.
Try it online!
$endgroup$
add a comment |
$begingroup$
Ruby, 362 bytes
puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)
Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib
or base64
.
Try it online!
$endgroup$
Ruby, 362 bytes
puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)
Integer written in base 36. There's surely a more efficient way to compress the integer, e.g. with zlib
or base64
.
Try it online!
edited yesterday
answered yesterday
Eric DuminilEric Duminil
46128
46128
add a comment |
add a comment |
$begingroup$
[C++ (VC++)(but tested with gcc as well)], 585 bytes
#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}
Try it online!
ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char arecibo="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
int i = 0,j;
while (i<sizeof(arecibo)-1)
{
char digit = arecibo[i];
int count=0;
if (digit >= '0' & digit <= '9')
{
digit -= '0';
}
else if (digit>='A'& digit<='F')
{
digit -= 'A'-10;
}
else if (digit > 'F'&digit<='Z')
{
//digit does not contain any valid hex digit in this case
count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
digit = arecibo[i - 1];
}
for (count; count >= 0; count--)
{
for (j = 0; j<4; j++)
{
cout << (int)(((digit)&(8 >> j))>0);
}
}
i++;
}
return 0;
}
as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the ,
Operator and the like.
Output Format is uninterrupted stream of 1679 0/1-values.
$endgroup$
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
add a comment |
$begingroup$
[C++ (VC++)(but tested with gcc as well)], 585 bytes
#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}
Try it online!
ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char arecibo="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
int i = 0,j;
while (i<sizeof(arecibo)-1)
{
char digit = arecibo[i];
int count=0;
if (digit >= '0' & digit <= '9')
{
digit -= '0';
}
else if (digit>='A'& digit<='F')
{
digit -= 'A'-10;
}
else if (digit > 'F'&digit<='Z')
{
//digit does not contain any valid hex digit in this case
count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
digit = arecibo[i - 1];
}
for (count; count >= 0; count--)
{
for (j = 0; j<4; j++)
{
cout << (int)(((digit)&(8 >> j))>0);
}
}
i++;
}
return 0;
}
as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the ,
Operator and the like.
Output Format is uninterrupted stream of 1679 0/1-values.
$endgroup$
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
add a comment |
$begingroup$
[C++ (VC++)(but tested with gcc as well)], 585 bytes
#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}
Try it online!
ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char arecibo="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
int i = 0,j;
while (i<sizeof(arecibo)-1)
{
char digit = arecibo[i];
int count=0;
if (digit >= '0' & digit <= '9')
{
digit -= '0';
}
else if (digit>='A'& digit<='F')
{
digit -= 'A'-10;
}
else if (digit > 'F'&digit<='Z')
{
//digit does not contain any valid hex digit in this case
count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
digit = arecibo[i - 1];
}
for (count; count >= 0; count--)
{
for (j = 0; j<4; j++)
{
cout << (int)(((digit)&(8 >> j))>0);
}
}
i++;
}
return 0;
}
as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the ,
Operator and the like.
Output Format is uninterrupted stream of 1679 0/1-values.
$endgroup$
[C++ (VC++)(but tested with gcc as well)], 585 bytes
#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}
Try it online!
ungolfed Version (lacks the break after the 1679th element though and goes until the 1680th):
#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
const char arecibo="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
int i = 0,j;
while (i<sizeof(arecibo)-1)
{
char digit = arecibo[i];
int count=0;
if (digit >= '0' & digit <= '9')
{
digit -= '0';
}
else if (digit>='A'& digit<='F')
{
digit -= 'A'-10;
}
else if (digit > 'F'&digit<='Z')
{
//digit does not contain any valid hex digit in this case
count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
digit = arecibo[i - 1];
}
for (count; count >= 0; count--)
{
for (j = 0; j<4; j++)
{
cout << (int)(((digit)&(8 >> j))>0);
}
}
i++;
}
return 0;
}
as an Explanation: i concatenated the 73 lines of sample output given to one long line.
i encoded them in hexadecimal where the bit order is msbfirst (using this program https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe)
i shortened the Output of that by about 70 hexadecimal Digits by using the letters 'G'-'Z' as a sign to repeat the last Digit for a certain amount of times (Z = 2more times, Y = 3more times …)
the rest should be relatively self explainatory for Code-Golfers. abusing the preprocessor to shorten loops, abusing the ,
Operator and the like.
Output Format is uninterrupted stream of 1679 0/1-values.
answered yesterday
der benderder bender
212
212
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
add a comment |
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
$begingroup$
before anybody asks the const is for compatibility with VC++ (what the main development work was done with)
$endgroup$
– der bender
yesterday
add a comment |
$begingroup$
Perl 6, 348 bytes
{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}
Based on Benjamin Urquhart's Java solution.
Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.
Try it online!
$endgroup$
add a comment |
$begingroup$
Perl 6, 348 bytes
{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}
Based on Benjamin Urquhart's Java solution.
Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.
Try it online!
$endgroup$
add a comment |
$begingroup$
Perl 6, 348 bytes
{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}
Based on Benjamin Urquhart's Java solution.
Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.
Try it online!
$endgroup$
Perl 6, 348 bytes
{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}
Based on Benjamin Urquhart's Java solution.
Uses a straight stream of 0 and 1 characters. The link below has some code to prettify the output.
Try it online!
answered 22 hours ago
bb94bb94
1,045611
1,045611
add a comment |
add a comment |
If this is an answer to a challenge…
…Be sure to follow the challenge specification. However, please refrain from exploiting obvious loopholes. Answers abusing any of the standard loopholes are considered invalid. If you think a specification is unclear or underspecified, comment on the question instead.
…Try to optimize your score. For instance, answers to code-golf challenges should attempt to be as short as possible. You can always include a readable version of the code in addition to the competitive one.
Explanations of your answer make it more interesting to read and are very much encouraged.…Include a short header which indicates the language(s) of your code and its score, as defined by the challenge.
More generally…
…Please make sure to answer the question and provide sufficient detail.
…Avoid asking for help, clarification or responding to other answers (use comments instead).
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f182924%2foutput-the-arecibo-message%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
8
$begingroup$
If a language has a built in for Arecibo message, I can tell, with all certainty, that I've seen everything in this world c:
$endgroup$
– Luis felipe De jesus Munoz
2 days ago
5
$begingroup$
Mathematica (IIRC) has an image builtin for Lena, so it wouldn't surprise me if it also has an Aricebo message as well.
$endgroup$
– Beefster
2 days ago
$begingroup$
@RobertS. no because there are other valid formats besides text.
$endgroup$
– Beefster
2 days ago
3
$begingroup$
In the spirit of the original format, a flat result/output should be allowed. The whole point of 1679 bits is exactly that the proper number of rows and columns can be inferred from the signal length.
$endgroup$
– Adám
2 days ago
4
$begingroup$
@LuisfelipeDejesusMunoz Mathematica has a builtin to determine goats in a picture, so an Arecibo message builtin wouldn't really surprise me either.. That language is built on builtins of the universe.. >.>
$endgroup$
– Kevin Cruijssen
yesterday