14
\$\begingroup\$

This is an challenge where every part of your answer should aim to be unique from every other answer.

This question will work in the following way:

  • I will post the first answer. The next answer will stem from that, and all other answers will originate from it.
  • In this answer I will include a program and specify three things:
    • The language the program is written in
    • The integer it outputs
    • The bytes the next program must use
  • The next user will then write an answer, and specify the same three things - the language they used, the integer they output and the bytes the next program must use
  • And so on, until the chain ends.

Each answer will do the following:

  • It will include a program, written in a language that hasn't been used by any previous answer.

  • The program outputs an integer, through one of our standard I/O formats, that no previous answer in the chain has outputted before. This integer must be deterministic and consistent between executions, and may be positive, negative or \$0\$.

  • It will take either no input, or an empty input if necessary, and will output nothing more than the integer to a standard output method (STDOUT, function return, Javascript's alert etc.)

  • It only uses the bytes allowed to it by the previous answer. It may use each byte as many times as it likes, but each byte must be used at least once.

  • The answer will specify a set of bytes (containing no duplicates) that the next answer must use. This set of bytes may not have been used by any previous answer, and can be any subset of the integers between \$0\$ and \$255\$. There must be a minimum of 1 and a maximum of 256 bytes in this subset, and the number of bytes must be unique of all existing answers (i.e. if one answer allows the next to use 120 bytes, no other answer may allow 120 bytes).

Through this, each new answer will determine how difficult (or easy) the next answer is; only allowing a small subset of bytes will make it substantially more difficult than if allowing a larger set. "Bytes" means that you may use languages with non-UTF-8 encodings, by simply taking the characters those bytes represent in that code page.

For the sake of fairness, the first answer (which I'll post) will have all 256 bytes available to it, so that the answers truly are unique in all the specified ways.

Scoring

Your score is the number of answers you have in the chain, with a higher score being better.

Formatting

Please format your answer in the following way:

# [N]. [Language], [# of bytes available] available bytes

    [program]

This outputs [output]

This uses the characters [characters/bytes], allowed by [previous answer](link)

The next answer may use the following bytes:

    [list of bytes]

Rules

  • You must wait an hour between posting two answers
  • You may not post two answers in a row
  • So long as they're unique, the language, integer and bytes are up to your choice
  • You are under no obligation to golf your code
  • You may submit either a full program or function
  • Different versions of languages (e.g Python 2 and Python 3) are not considered separate languages. As a general rule, if the only way the language names differ is by a version number, or if the languages are usually thought of as versions of each other, they are considered the same language.
  • You may use any language that wasn't specifically invented to answer this challenge
  • The chain ends when 14 days pass with no new answers being posted or after 256 answers have been posted (as no new byte sets will be available).

Good luck!

\$\endgroup\$
  • \$\begingroup\$ Sandbox \$\endgroup\$ – caird coinheringaahing Oct 11 at 16:58
  • \$\begingroup\$ @RobinRyder "the number of bytes must be unique of all existing answers", so only 256 possible byte sets exist \$\endgroup\$ – caird coinheringaahing Oct 11 at 19:51
  • \$\begingroup\$ Thanks, I missed that part. \$\endgroup\$ – Robin Ryder Oct 11 at 19:58
  • 1
    \$\begingroup\$ @Razetime I‘ll say that, if a language exists on (e.g.) esolangs.org before the challenge was posted, then it qualifies as a "language that wasn’t specifically invented to answer this challenge“, so it’s fine to use (even if the language doesn’t yet have an implementation), so long as you provide a working interpreter with it per site rules (whether that interpreter already existed or needs to be created now doesn’t affect it‘s acceptability as a spec already existed before the challenge) \$\endgroup\$ – caird coinheringaahing Oct 14 at 7:46
  • 1
    \$\begingroup\$ So this question is capped at 256 (255?) different answers? I'd love to see the entire thing. \$\endgroup\$ – val says Reinstate Monica Oct 14 at 12:30

23 Answers 23

7
\$\begingroup\$

5. Retina 0.8.2 -m, 8 available bytes

The code is given as three separate files. Here are their hexdumps:

00000000: 002a 0f2a 062a 092a 042a 142a            .*.*.*.*.*.*
00000000: 4545 4545 4545                           EEEEEE
00000000: 45                                       E

This outputs 6. Try it online!

The first file uses bytes 0, 15, 6, 9, 4, 20, and 42, and the other two files consist entirely of E (byte 69), covering the list specified by the previous answer.


Normally, Retina takes patterns and replacements in a single file separated by newlines, but we don't have newlines available. Fortunately, Retina 0.8.2 still makes available the language's original multi-file code format.* This program has two stages, a replacement stage and a count stage:

  • Find all regex matches of _*_*_*_*_*_* in the input, where _ represents the various unprintable characters. Since the input is empty, this matches once. Replace that match with EEEEEE.
  • In the resulting string, count the number of matches of E (six).

* IIRC, Retina was originally designed this way to take advantage of a PPCG scoring loophole. Now I'm using it to take advantage of a different kind of loophole. Seems appropriate.


The next answer may use the 54 bytes whose codepoints are prime numbers:

2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251
| improve this answer | |
\$\endgroup\$
6
\$\begingroup\$

2. Python 3, 94 available bytes

values = {(k,): ord(k) for k in "ABCDEFGHIJKLMNOPQRSTUVWXYZ@"};combined = [~values[g.upper(),] + 1 // 2 - 3 * 4 & 5 % 6 > 0 < 7 ^ 8 for g in 'hjqwxyz'];_ = sum(combined) | 7 + 9;_ += ord("$") + ord("\n");print(_ + ord("`"))#!?

Try it online!

Outputs 163

I could've just printed a number and stuck everything else in a comment, but I thought I'd add some unnecessary fluff to it to make it more interesting :P

This uses all printable ASCII bytes as required by the previous answer. Python is a unique language, and 163 is a unique number.


The next answer must contain all bytes except the printable ASCII characters; that is, codepoints 0 through 31 and 127 through 255.

| improve this answer | |
\$\endgroup\$
6
\$\begingroup\$

3. x86 machine code (MS-DOS .COM), 161 available bytes

B8 19 0E 04 17 BB 01 00 CD 10 C3
02 03 05 06 07 08 09 0A 0B 0C 0D 0F
11 12 13 14 15 16 18 1A 1B 1C 1D 1E 1F
80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F
90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF
B0 B1 B2 B3 B4 B5 B6 B7 B9 BA BC BD BE BF
C0 C1 C2 C4 C5 C6 C7 C8 C9 CA CB CC CE CF
D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF
E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF
F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

Relevant code (the rest is filler):

B8 19 0E    MOV AX,0E19H
04 17       ADD AL,17H
BB 01 00    MOV BX,0001H
CD 10       INT 10H
C3          RET

The DOS functions that print use printable characters (INT 21H and INT 29H), so I use INT 10H instead. This program outputs 0.


The next answer must use every codepoint except for the digits 0 through 9 (48 through 57 inclusive).

| improve this answer | |
\$\endgroup\$
6
\$\begingroup\$

21. Incident, 9 available bytes

Decoded as codepage 437:

£ñ¥££₧Ç£¢£%₧£%¢£ñ¥ñÇ¢£$¥ñ£¥ñ£¥%Ç₧ñ$¥%ñƒ%ñ¢Ç$₧%Ç¢%ñƒñ$ƒñ$ƒ%ǃñÇ₧ñ%₧ññƒ%%₧%%₧Ç$¥%%ƒ%£ƒ%£¢Ç$¢ñ%¥%£₧ññƒññ¥ñ%¢ñ£¥£$¥£$¥ñÇ¥£%¥Ç£¢Ç£¢££ƒ££¥£ñ¢Ç%ƒÇ%¢Ç%¢ÇñƒÇñ¥Çñ

or as an xxd reversible hexdump:

00000000: 9ca4 9d9c 9c9e 809c 9b9c 259e 9c25 9b9c  ..........%..%..
00000010: a49d a480 9b9c 249d a49c 9da4 9c9d 2580  ......$.......%.
00000020: 9ea4 249d 25a4 9f25 a49b 8024 9e25 809b  ..$.%..%...$.%..
00000030: 25a4 9fa4 249f a424 9f25 809f a480 9ea4  %...$..$.%......
00000040: 259e a4a4 9f25 259e 2525 9e80 249d 2525  %....%%.%%..$.%%
00000050: 9f25 9c9f 259c 9b80 249b a425 9d25 9c9e  .%..%...$..%.%..
00000060: a4a4 9fa4 a49d a425 9ba4 9c9d 9c24 9d9c  .......%.....$..
00000070: 249d a480 9d9c 259d 809c 9b80 9c9b 9c9c  $.....%.........
00000080: 9f9c 9c9d 9ca4 9b80 259f 8025 9b80 259b  ........%..%..%.
00000090: 80a4 9f80 a49d 80a4                      ........

Try it online!

Prints 33. This is a) because 33 is by far the easiest two-digit number to print in Incident, b) because I already had a program to print 33 handy, and all I needed to do was try to fit it into the given set of available bytes.

This program was harder to write than I expected (given that I'd already written it); 9 bytes is not a lot (the more the better with Incident, although it can work with very restricted sets if necessary), and working with character encoding issues is annoying. I started working with UTF-8, planning to change to Latin-1 later, but a) the program parses differently in UTF-8 (Incident looks at the raw bytes, so the encoding matters), b) I couldn't figure out what encoding @Razetime's currency symbols were in (euro isn't normally at 0x9C), and c) TIO apparently feeds UTF-8 to Incident so the program didn't work there directly, and I had to write my own wrapper in the TIO link above. A much more fruitful technique was to work with ASCII (abcde,.:;), and tr it into the set of available bytes at the end (Incident is tr-invariant; consistently replacing one codepoint in the program with another unused codepoint makes no difference to the program's behaviour).

Explanation

Parsing the program

In the rest of this explanation, I'm going to represent the program in a more readable, equivalent, ASCII form (which is just a consistent replacement of the 9 available bytes):

cb,cc:dc.ca:ca.cb,bd.ce,bc,bc,ad:be,ab;ab.de:ad.ab;be;be;ad;
bd:ba:bb;aa:aa:de,aa;ac;ac.de.ba,ac:bb;bb,ba.bc,ce,ce,bd,ca,
dc.dc.cc;cc,cb.da;da.da.db;db,db

This program uses 17 different commands. The original program represented each command as a single byte:

lm3kklijhhdebbodbeedifgaaoaccofcggfhjjik33mml111222

but this uses 17 different bytes, and we only have 9 available. So instead, each of the commands is represented as a pair of letters from abcde (i.e. the first five our our currency symbols). This would lead to a huge number of accidental mis-parses if I just wrote it out directly (in fact, Incident fails to parse a single token!), so additional characters drawn from .,:; (i.e. the last four of our currency symbols) were inserted in between them in order to ensure that it recognised the correct pairs of bytes as tokens. (As a reminder, Incident tokenises the source by treating each substring of bytes that occurs exactly three times as a token, with a few adjustments for overlapping tokens and tokens that are subsets of each other.)

To translate the original program into the form with command pairs separated by additional characters, I used the Jelly program

O%38+10%25b€5ị“abcde”j”.

I then used simulated annealing to choose appropriate separating characters to make sure that none of the tokens ended up overlapping (usually these characters weren't part of the token, but in a few cases they became part of an adjacent token, without changing the behaviour of the program).

Program behaviour

cb,                Call subroutine cb (which prints a 3)
cc:                Goto label cccc (used to call cb a second time)
dc.                Goto label dcdc (apparently unused?)

ca:ca.             Jump target
cb,                Entry/exit point for subroutine cb (which prints a 3)
bd.                Call subroutine bd (which prints half a 3)
ce,                Goto label cece

bc,bc,             Jump target
ad:                Call subroutine ad (which prints a 0 bit)
be,                Goto label bebe

ab;ab.             Jump target
de:                Output a 0 bit (and jump to the centre of the program)
ad.                Entry/exit point for subroutine ad (which prints a 0 bit)
ab;                Goto label abab

be;be;             Jump target
ad;                Call subroutine ad (which prints a 0 bit)
bd:                Entry/exit point for subroutine bd (which prints half a 3)
ba:                Call subroutine ba (which prints a 1 bit)
bb;                Goto label bbbb

                   CENTRE OF THE PROGRAM:
aa:aa:de,aa;       After outputting a bit, jump back to where you were

ac;ac.             Jump target
de.                Output a 1 bit (and jump to the centre of the program)
ba,                Entry/exit point for subroutine ba (which prints a 1 bit)
ac:                Goto label acac

bb;bb,             Jump target
ba.                Call subroutine ba (which prints a 1 bit)
bc,                Goto label bcbc

ce,ce,             Jump target
bd,                Call subroutine bd (which prints half a 3)
ca,                Goto label caca (i.e. return from subroutine cb)

dc.dc.             Jump target
cc;cc,             Jump target

cb.                Call subroutine cb (which prints a 3)

da;da.da.          No-op to ensure "de" is in the centre of the program
db;db,db           No-op to ensure "de" is in the centre of the program

This is pretty straightforward as programs go: we define a subroutine cb to print 3, and it does so in terms of a subroutine bd which prints half a 3 (Incident prints a bit at a time, and the bit pattern of 3 is 11001100 in Incident's bit order, so to print half a 3 you just need to print 1100). Unfortunately, the behaviour of an Incident command (except for unconditional jumps, which go from x to xx) depends on its position in the program, so a huge number of jumps are required in order to make the program's control flow run all the commands in the right order. The sequence in which the commands that actually do something must be given is fairly fixed (e.g. a subroutine must be called from exactly 2 locations, with the first location before it is defined, and the second location after it is defined; and I/O behaviour depends on which command is in the centre of the program), so because we can't reorder the commands to say which order we want to run them in, we reorder the control flow instead, putting jumps just before and after pretty much all of them.

I'm not completely sure why I put two different jump labels cccc and dcdc back when I originally wrote this program, but Incident is sufficiently hard to write that I'm not sure I want to change things now. (Perhaps it was in an attempt to get the centre of the program into the right place.)

Restriction

Time for a change of pace, given how unreadable the programs in this answer are. The next answer must use all 26 lowercase ASCII letters, plus the ASCII space character: abcdefghijklmnopqrstuvwxyz , i.e. 0x61-0x7a, plus 0x20.

(Please try to keep the restrictions fairly reasonable from now on; one of the inspirations behind Incident was "escaping from tricky situations in puzzles", but now that it's been used, we won't have our get-out-of-jail card to free us from such situations if they happen again.)

| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

4. Vyxal, 245 available bytes

#λ¬∧⟑∨⟇÷«»°․⍎½∆øÏÔÇæʀʁɾɽÞƈ∞⫙ß⎝⎠ !"#$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}~⎡⎣⨥⨪∺❝𣥧¦¡∂ÐřŠč√∖ẊȦȮḊĖẸṙ∑Ṡİ•Ĥ⟨⟩ƛıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘŚśŜŝŞşšŢţŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſƀƁƂƃƄƅƆƇƊƋƌƍƎ¢≈Ωªº
    
ij

This outputs 10.

This uses every character except in the range [48, 57].

After everything is ignored in the comment, simply push 10 to the stack and auto print.


The next answer may only have bytes in this list: [69, 42, 0, 15, 6, 9, 4, 20]

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

7. Charcoal, 16 available bytes

11»;∧”″⟲⌊$@Qdy✂Dα

Try it online! Outputs the integer 11, after which the » ends the block (program), ignoring the remaining 14 bytes.


The next answer must not use any bytes which code for ISO-8859-1 characters with an alphanumeric appearance i.e. 0-9, A-Z, _, a-z, but also ¢¥©ª®°²³µ¹º¼½¾, À-Ö, Ø-ö, or ø-ÿ.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The first answer has already outputted 1, so you have to output a different unique number. (11, maybe?) \$\endgroup\$ – Razetime Oct 12 at 9:44
  • 1
    \$\begingroup\$ @Razetime Bah, I never seem to be able to read questions correctly... \$\endgroup\$ – Neil Oct 12 at 9:48
  • 1
    \$\begingroup\$ Just to make sure, because you specify bytes not characters, do you mind changing the wording to something like "The next answer must not use any bytes whose Unicode characters have an alphanumeric appearance i.e. ..." just in case the next answer uses a custom cope page rather than Unicode? \$\endgroup\$ – caird coinheringaahing Oct 12 at 11:56
  • 1
    \$\begingroup\$ @cairdcoinheringaahing How's this version? \$\endgroup\$ – Neil Oct 12 at 14:40
  • \$\begingroup\$ @Neil Yep, that's great! \$\endgroup\$ – caird coinheringaahing Oct 12 at 14:40
4
\$\begingroup\$

12. 05AB1E, 62 available bytes

5oCsnqaDZbOSF10u69pWEjBAf2KUMkLIgePzG8dTyHwNX3lRtmir7cQxhJ4YvV

Try it online!

Outputs 64.

I got this by scrambling the bytes until it eventually gave me a nice number.


The next answer must use the byte set of powers of two and three: [1, 2, 3, 4, 8, 9, 16, 27, 32, 64, 81, 128] (12).

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Ah yes, SBCS. I thought I would have to rely on Glypho. \$\endgroup\$ – PkmnQ Oct 13 at 14:27
  • \$\begingroup\$ @PkmnQ yeah, golfing language SBCSs are a lifesaver in this challenge :P \$\endgroup\$ – HyperNeutrino Oct 13 at 14:41
  • 1
    \$\begingroup\$ Unfortunately the only other one I know is Actually, and the selection of symbols I get is absolutely useless. The only thing in my control that I can push is the program itself, but I don't know what I can do with that. \$\endgroup\$ – PkmnQ Oct 13 at 14:45
3
\$\begingroup\$

1. Whispers v2, 256 available bytes

> 1
>> Output 1
	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ

Try it online!

Outputs 1

This uses all 256 bytes (from 0x00 to 0xFF).

The next answer must use the printable ASCII bytes (0x20 to 0x7E, to ~, \$32\$ to \$126\$ etc.). Note that this does not include newlines.


How it works

Only the first two lines are actually executed. Every other line doesn't begin with > so it's ignored. From there, it's kinda simple. The first line returns 1 and the second outputs it.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

6. Jelly, 54 available bytes

¦¬£¿Æ׌çøþ%)/;=CGISYaegkmq³⁹⁻ⱮƤṣɗɲʂḌṂḂ¤ḊḢĿạẉẓḋOṁỌȯ»+¶5

Try it online!

This outputs 5. Why? Because counts as a newline in Jelly (like, \n and are the exact same thing), and only the last link (line) is run in Jelly, everything except the 5 is ignored. Actually, moving the to other places works too, because Jelly's really forgiving and just puts 0 through the chain of evaluation a bunch and since there's a number, I'm able to output something besides 0.


The next answer must use the 16 bytes with square codepoints:

0,1,4,9,16,25,36,49,64,81,100,121,144,169,196,225

| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ Fun fact: you can basically use any of ɲʂÆŒq to break the chain and the program will ignore everything before them, so any of those 5 chracters can go before the 5 and the same thing will happen \$\endgroup\$ – caird coinheringaahing Oct 12 at 12:33
  • \$\begingroup\$ @cairdcoinheringaahing ooh, that's cool :D \$\endgroup\$ – HyperNeutrino Oct 12 at 14:30
3
\$\begingroup\$

9. Bash, 64 available bytes

Prints -13579.

/us?/???/ec?o	-13579	#
!%')+;=ACEGIKMOQSUWY[]_agikmqwy{}

Hexdump for clarification:

00000000: 2f75 733f 2f3f 3f3f 2f65 633f 6f09 2d31  /us?/???/ec?o.-1
00000010: 3335 3739 0923 0103 0507 0b0d 0f11 1315  3579.#..........
00000020: 1719 1b1d 1f21 2527 292b 3b3d 4143 4547  .....!%')+;=ACEG
00000030: 494b 4d4f 5153 5557 595b 5d5f 6167 696b  IKMOQSUWY[]_agik
00000040: 6d71 7779 7b7d 7f                        mqwy{}.

Try it online!

/us?/???/ech?o is a glob, which searches for a filename matching that pattern (where ? can be any one character). The file this finds is /usr/bin/echo which is very useful for printing integers.

Next is a tab character, separating the executable from its argument, which is -13579 (I thought I'd shake things up with a negative number!)

Then another tab character and a #, starting a comment. Then are all the remaining odd ASCII bytes (from 0x01 to 0x7F, excluding the ones already used), which Bash dutifully ignores. (although with a little bit of stderr moaning at on TIO's version)


Next arbitrary byte set is all bytes except:

  • bytes greater than or equal to 0x9A
  • ASCII lowercase letters
  • ASCII uppercase letters C, T and S
  • ASCII digits
  • ASCII space, new line feed, and horizontal tab
  • ASCII closing parenthesis, closing square bracket, and closing curly brace

This makes a total of 107 available bytes?

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

8. !@#$%^&*()_+, 184 available bytes

(?@)    

 !"#$%&'*+,-./:;<=>[\]^`{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡£¤¦§¨«¬®¯±´¶·¸»¿×÷

The code outputs the integer 34, the ASCII value of the character ".

This uses the characters specified by previous answer.

Try it online!

How does it work?

The starting (?@) indicates that the code will run ?@ while the stack is not zero. Since the stack is zero at the start, the code does not excecute. Both of these characters print some sort of thing, which makes it necessary to put them in brackets.

The code then pushes a few codepoints, including the codepoint of ", which is 34. # prints out that number.

Since there are no more printing commands, the rest of the code can be thought as filler.

Next set of bytes!

The next answer should use all characters with an odd ASCII value, or:

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Is it only odd characters or can we also use others? (I assume it's the former) \$\endgroup\$ – user Oct 12 at 17:40
  • \$\begingroup\$ @user Indeed, it is the former. \$\endgroup\$ – SunnyMoon Oct 12 at 17:44
  • \$\begingroup\$ Does "all characters with an odd ASCII value" mean only valid ASCII, i.e. up to 0x7F? \$\endgroup\$ – pxeger Oct 12 at 18:59
  • 2
    \$\begingroup\$ Damn, not allowing spaces and newlines is evil! \$\endgroup\$ – pxeger Oct 12 at 19:11
  • 1
    \$\begingroup\$ If this is only up to 0x7F, I‘d recommend removing the characters beyond that from the character set you provided (e.g. Ÿ) \$\endgroup\$ – caird coinheringaahing Oct 13 at 1:40
3
\$\begingroup\$

11. Lenguage, 2 available bytes

[The program is too long to be displayed]

Big thanks to the bois who made this Lenguage!

The program prints 2 by the way.

The program is basically a whopping 73788735513442661331 tabs and an acknowledgement. (Yes, an acknowledgement. It is in a program simply for it to follow the byte set of allowed by the previous answer)


The next program should use only and all alphanumeric characters upto 0x5A, or:

0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Just to clarify, this does use both the tab and acknowledgement characters, yes? \$\endgroup\$ – caird coinheringaahing Oct 13 at 13:36
  • \$\begingroup\$ @caird Just assume the program is entirely tabs and one acknowledgment. \$\endgroup\$ – SunnyMoon Oct 13 at 13:39
  • \$\begingroup\$ You have to use all the characters, so at least 1 byte has to be an acknowledgement byte (shouldn't be much of an issue though) \$\endgroup\$ – caird coinheringaahing Oct 13 at 13:40
  • \$\begingroup\$ Would be a good idea to have a pastebin link or something for the program \$\endgroup\$ – Razetime Oct 13 at 14:57
  • \$\begingroup\$ @Razetime That is practically impossible... \$\endgroup\$ – SunnyMoon Oct 13 at 17:22
3
\$\begingroup\$

15. Neim, 1 available byte

A

Try it online!

Outputs 42. I don't know why. I've never used this language before. I was literally just clicking through random languages on TIO and this happened to work...

It seems that repeating A just repeats the 42, so I could've done an arbitrarily large integer in the form 42424242...


The next answer should use the byte set [48, 49, 50] (characters ['0', '1', '2']).

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ +1 for outputting 42 \$\endgroup\$ – aidan0626 Oct 14 at 2:34
3
\$\begingroup\$

17. Whitespace, 32 available bytes

The available bytes were 0x01 through 0x20 inclusive.

   	  	   																																																		
	
 	


	

 

Try it online!

STN translation:

SSSTSSTSSS[50 copies of T]N # Push a big number
TN STN # Print as integer? Not quite sure, I just copied this part from esolangs
NN # Terminate the program
[Garbage from 0x01 to 0x20]

Prints 82190693199511551. As the code is easy enough to output larger numbers, I figured I'd output something large enough so no one needs to bother with output clashes. So I made a working program and padded the number literal with tabs until the program became exactly 100 bytes :)


Next answer: Use only []{}, which is 0x5b 0x5d 0x7b 0x7d in hex.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

10. Keg, 107 avaliable bytes

E[``F;.#{(`ϧ∑¿∂•ɧ÷Ë≬ƒß‘“„«®©ëλº√₳¬≤Š≠≥Ėπ!"#$%&'*+,-./:<=>?@ABDEFGHIJKLMNOPQRUVWXYZ\\^_	⊂½‡™±¦→←↶↷✏█↗↘□²ⁿ║ṡ⟰⟱⟷ℤ	

Try it online!

This outputs 69 (HA!)

Now, you're gonna say "but Lyxal... the answer said YOU CAN'T HAVE ASCII NEWLINE/TAB!! AND YET YOU STILL HAVE THOSE CHARACTERS!!!"

Normally, you'd be right to say that this is invalid, but this time you're wrong. Keg's special. We play with a SBCS... A SBCS which just happens to have the newline and tab in a different spot than they usually are.

Codepage

Don't judge my Poor Design Choices™


The next answer can only use the bytes with values 6 and 9 (haha funny number)

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Wait, so only 2 bytes are allowed? \$\endgroup\$ – SunnyMoon Oct 13 at 9:40
  • \$\begingroup\$ @SunnyMoon you can use those 2 bytes as much as you want \$\endgroup\$ – Lyxal Oct 13 at 9:53
  • \$\begingroup\$ Lenguage anyone? \$\endgroup\$ – user Oct 13 at 13:04
  • 1
    \$\begingroup\$ @user we'll probably need lenguage for the inevitable one-byte set that someone gives us :P \$\endgroup\$ – HyperNeutrino Oct 13 at 13:27
  • \$\begingroup\$ @HyperNeutrino ♦ Of course! \$\endgroup\$ – SunnyMoon Oct 13 at 13:36
2
\$\begingroup\$

16. Bitwise Cyclic Tag But Way Worse, 3 available bytes

111011112000000

This outputs 7. Try it online!


I found a language that used 0, 1, and 2, took an educated guess at what an "output one character" program would look like, and tweaked it until it was a digit. I'm... not really sure how this works.

After some investigation, it turns out that BCTBWW doesn't actually work like Bitwise Cyclic Tag (maybe that's why it's way worse). When BCT encounters an instruction like 10, it conditionally enqueues a 0 to the data-string and moves to the next instruction after the 0. BCTBWW uses the same enqueuing logic, but it doesn't skip over the bit that was enqueued--it executes the 0 as the next instruction. Here's how the above program works:

Instruction        Data-string   Comment
                   1             With empty input, data-string starts as 1
11                 11
 11                111
  10               1110
   0                110
    11              1101
     11             11011
      11            110111
       12           110111       12 is a no-op
        2           110111       2 converts the data-string to bytes and outputs it
         0           10111
          0           0111
           0           111
            0           11
             0           1
              0                  Data-string is empty, program halts

The output is thus the single byte 0b110111 = 0x37, which is the digit 7.


The next answer must use the byte set 0x01 through 0x20 (1 through 32, inclusive).

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

18. {} (Level 8), 4 available bytes

{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{{}{}{}{}{}}[]

{} (Level 8) is a brainfuck clone.

According to the esolangs wiki page, {} evaluates to + in brainfuck, and {{}{}{}{}{}} evaluates to ..

Here's the same program, translated to brainfuck: Try it online!

This program prints 9.

[] does nothing in this program, since it isn't a command.

The next program must use the following 13 bytes taken from this thread: [2,5,8,10,22,25,31,40,77,80,96,101,137]

Or, as hex:

02 05 08 0A 16 19 1F 28 4D 50 60 65 89 (courtesy of PkmnQ)

| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ Mind either adding in or taking away one extra byte from the byte set, there‘s already been one of length 14 \$\endgroup\$ – caird coinheringaahing Oct 14 at 8:40
  • \$\begingroup\$ Here are the allowed bytes as hex. 02 05 08 0A 16 19 1F 28 4D 50 60 65 89 \$\endgroup\$ – PkmnQ Oct 14 at 14:13
  • \$\begingroup\$ I would be able to do this in Actually or Seriously if they didn't decide to to be stubborn and not default to 0 if it isn't a valid input. \$\endgroup\$ – PkmnQ Oct 14 at 14:26
2
\$\begingroup\$

19. Beatnik, 13 available bytes

Pee
MeMeMeMeMeMeMeMeeMeMeMeMe
Pee
MeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeP
MeeeP
MeeeP
eeeeeeeeeeeeeeeee 
(`‰

Yes, I deliberately used the words "Pee", "Meme", "Meep", and "E".

This (abominable) program outputs the integer 21.

Try it online!


Next byte set...

Only use all of the non-alphabetic and non-whitespace characters which can be typed while pressing the shift key on a standard QWERTY keyboard:

!"#$%&()*+:<>?@^_{|}~

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ One more thing: space (codepoint 20) is not there in the byteset. \$\endgroup\$ – Razetime Oct 15 at 3:00
  • \$\begingroup\$ @Razetime Codepoint 137 in this site is \$\endgroup\$ – SunnyMoon Oct 15 at 7:24
  • \$\begingroup\$ @Razetime Also, isn't the space character codepoint 32? Codepoint 20 is "Device Control 4" (Which is invisible in this post due to technical limitations). \$\endgroup\$ – SunnyMoon Oct 15 at 7:26
  • \$\begingroup\$ space is 20 in hex, and it is not in the allowed bytes. \$\endgroup\$ – Razetime Oct 15 at 7:49
  • \$\begingroup\$ The output of 6 is also already taken. \$\endgroup\$ – Bubbler Oct 15 at 8:27
2
\$\begingroup\$

20. MAWP v1.1, 21 available bytes

!!!!!!::::::"#$%&()*+<>?@^_{|}~

Try it!

Prints 111111,

Using the bytes !"#$%&()*+:<>?@^_{|}~.

The first 12 bytes do the hard work(cloning the existing 1 and printing it), then the rest do a whole lot of nothing. () does othing since nothing is on the stack, and the rest fo the characters don't change anything since : needs to be there for outputting their result.

Restriction

The next answer must only use the currency symbols shown here, and %:

¤£€$¢¥₧ƒ%

[37,164,156,128,36,155,157,158,159]

[0x25,0xa4,0x9c,0x80,0x24,0x9b,0x9d,0x9e,0x9f]

or

0x24-0x25, 0x80, 0x9b-0x9f, 0xa4 (from Bubbler)

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Sorted bytes are 0x24-0x25, 0x80, 0x9b-0x9f, 0xa4. \$\endgroup\$ – Bubbler Oct 16 at 2:23
2
\$\begingroup\$

22. StupidStacklanguage, 27 available bytes

abaacdaiiiiiiiqmiiiiiiiqqqqfffffeghjklmnopqrstuvwxyz 

Try it online!

This prints 88888.

This uses abcdefghijklmnopqrstuvwxyz (Printable ascii alphabets and space) from the previous answer.

The next answer must use the following bytes which are palindromes in base 2:

!-3?AIU]ckw¥½ÃÛçÿ

[33,45,51,63,65,73,85,93,99,107,119,127,165,189,195,219,231,255]

[0x21,0x2d,0x33,0x3f,0x41,0x49,0x55,0x5d,0x63,0x6b,0x77,0x7f,0xa5,0xbd,0xc3,0xdb,0xe7,0xff]


How it works:

ab pushes a 0 and pops it.

aacd pushes two 0's and subtracts them and decrements the result.

aiiiiiii pushes a 0 and adds 7 to it.

qm squares it.

iiiiiii adds 7 to that.

qqqq duplicates it 4 times.

fffff then displays that as printable ascii.

e takes in input. Since there is no input, the program errors and ends execution, and the rest of the program does nothing.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

23. Trigger, 17 available bytes

333!333-333?AIU]ckw¥½ÃÛçÿ

Try it online!

Outputs 333.

Not sure if these are the correct characters to show, but even if they aren't, the language spec says it doesn't matter.

The next answer must use all bytes except:

  • Alphanumeric characters 0x30 to 0x39, 0x41 to 0x5A, 0x61 to 0x7A
  • The null byte 0x00
  • Brackets 0x40, 0x41, 0x5B, 0x5D, 0x7B, 0x7D
  • Mathematical operators 0x25, 0x42, 0x43, 0x45, 0x47
  • Bitwise operators 0x21, 0x26, 0x5E, 0x7C
  • Whitespace 0x09, 0x0A, 0x0C, 0x0D, 0x20
  • Common punctuation 0x22, 0x27, 0x2C, 0x2E, 0x3F
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

13. Poetic, 12 available bytes

QQQQQQQQQQQQQQQQQQQQQQQQ    QQQQQQQQQQQ@QQQQQ€QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQQQQ QQQ QQ QQQQQQQ QQQQQQQQQQ

This code outputs the number 4!

Uses the Q's and @'s and other stuff specified by the previous answer.


Next byte set...

Only use every accented ASCII alphabets and all the accents or diacritics in your code, or:

ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ`´^~¨°

Note: The degree (°) symbol has to be used as a diacritic

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The byte set you've provided has 62 bytes in, which has already been done in your previous answer. Would it be possible to change the bytes to be a unique number? \$\endgroup\$ – caird coinheringaahing Oct 13 at 18:53
  • \$\begingroup\$ @caird Done! (I hope the number of bytes is still unique) \$\endgroup\$ – SunnyMoon Oct 13 at 19:00
  • \$\begingroup\$ Looks like it, so no harm done! \$\endgroup\$ – caird coinheringaahing Oct 13 at 19:01
1
\$\begingroup\$

14. V, 68 available bytes

ÁÀÁÂÁÃÁÅÁÆÁÇÁÈÁÉÁÊÁËÁÌÁÍÁÎÁÏÁÐÁÑÁÒÁÓÁÔÁÕÁÖÁÙÁÚÁÛÁÜÁÝÁÞÁßÁàÁáÁâÁãÁäÁåÁæÁçÁèÁéÁêÁëÁìÁíÁîÁïÁðÁñÁòÁóÁôÁõÁöÁøÁùÁúÁûÁüÁýÁþÁÿÁ`Á´Á^Á~Á¨Á°ØÄ

This outputs 65. Try it online!


V is the perfect language for using accented letters.

  • Á inserts the character that follows it into the buffer. We use this command over and over to insert 65 out of our 68 characters.
  • Ø counts matches of the following regex and replaces the buffer with the count.
  • Ä is a compressed regex that stands for \D. Thus, in the characters we inserted previously, we count the ones that are not digits--which is all 65 of them.

Let's get the hard one out of the way. The next answer must use only byte 65 (0x41), A.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I have to say, I'm surprised it took so long to get to just a single byte \$\endgroup\$ – caird coinheringaahing Oct 14 at 0:34
  • \$\begingroup\$ Yeah... since Lenguage is off the table now, I wanted to make sure the 1 byte was something doable, so I decided I'd better pick it myself. :P \$\endgroup\$ – DLosc Oct 14 at 0:36

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.