Your task is to write a program, function or snippet (yes, snippets are allowed) that simply outputs an integer. However, you must be able to separate your submission into prefixes that also produce distinct integers. You cannot use any bytes that have appeared in previous prefixes. For example, we can have the prefixes:

1         # 1    (Now we can't use 1)

1-6       # -5   (Now we can't use - or 6)

1-6/3     # -1   (Now we can't use / or 3)

1-6/2+0xA # 9    Final submission

Rules

• Your goal is to create to try and create the most unique integers, while keeping them close to zero.
  
  
  
  
  • The scoring system is ((number of unique integers)**3)/(sum of absolute values), where the higher your score, the better. The above example scores $(4^3)/(1+lvert-5rvert+lvert-1rvert+9) = 64/16 = 4$.
  
  
  
  


• There should be at least two unique integers (no dividing by zero!)


• Please format your answer similar to:

# Language, $(4^{3})/16 = 4$



   1-6/2+0xA (the full program)

• Mention if your submission is composed of snippets that evaluate to a value, functions or full programs.


• List each of the prefixes and (optionally) an explanation for how they work.

vim, 14³ / 53 = 51.77

i10<esc>X<c-x>r2hx<c-a>Pa<del>4<c-c>d^s5<c-o>I-<c-o>$<c-o>C6<c-h>7

Try it online! (all prefixes)

Breakdown:

i1                  1

0                   10

<esc>X              0

<c-x>               -1  <c-x> decrements

r2                  -2

hx                  2   hx is X, but we've already used that

<c-a>               3   <c-a> increments

P                   -3  paste the - from two steps ago

a<del>4             -4

<c-c>d^             4   <c-c> is an <esc> alternative

s5                  5

<c-o>I-<c-o>$<c-o>  -5  <c-o> allows a single normal mode input

C6                  -6  trailing <c-o> from previous line used here

<c-h>7              -7  <c-h> = backspace

Python 3, $(6^{3})/12 = 18$

0x1-2+3|True*~4

This is a snippet.

The individual prefix snippets are:

0          # gives 0



0x1        # gives 1 (hex syntax)



0x1-2      # gives -1 (1 minus 2)



0x1-2+3    # gives 2 (-1 plus 3)



0x1-2+3|True # gives 3 (True == 1; 2 bitwise-OR 1 == 3)



0x1-2+3|True*~4 # gives -5 (~4 == -5; True*~4 == -5; 2|-5 == -5)

Python's bitwise operators treat negative integers as two's complement with unlimited 1s to the right, so -5 is treated as ...11111011, which when ORed with ...000010 gives ...11111011 unchanged.

Python 2, $11^3/53 = 25.1132075472$

015-8*2+6/3&9%7ifelse 4^ord('b')

Prefixes:

0                                   # 0



01                                  # 1



015                                 # 13 (octal)



015-8                               # 5



015-8*2                             # -3



015-8*2+6                           # 3



015-8*2+6/3                         # -1



015-8*2+6/3&9                       # 9 (-1 bitwise-AND 9 = 9)



015-8*2+6/3&9%7                     # 2



015-8*2+6/3&9%7ifelse 4           # 4



015-8*2+6/3&9%7ifelse 4^ord('b') # 12 (4 bitwise-XOR 8 -- OR would also work)

Not optimal, but the best I could personally find with this particular structure.

TI-BASIC (TI-84+ CE), $239^3/14344 = 951.75$

111-length("+×-/ABCDEFGHIJK...

The 256 bytes in TI-BASIC break down thusly:

• 240 bytes are one-byte tokens that can be quoted


• 11 are the start of two-byte tokens


• 2 are unused


• The remaining 3 are the ",→, and newline characters which break strings.

The string contains all 238 allowable bytes in the first category not already in 111-length(.

The program calculates 239 distinct integers, ranging from 111 down to -127. The score is therefore $$ frac{239^3}{sum_{n = -127}^{111} |n|} = 951.7511.$$