10 9 8 7 6 5 4 3 2 1... Print 2016

Question

As a spin-off to my challenge over at Puzzling, your goal is to output 2016.

Rules:

• You must include the numbers 10 9 8 7 6 5 4 3 2 1 in that order. They can be used as individual integers or concatenated together (like 1098), but the 10 may not be separated into 1 and 0 - no character(s) may be present between the digits. Note that, in some languages, 10 may not actually represent the integer literal 10, which is acceptable.
• Your code must not contain any other numbers or pre-defined number variables or constants (so T in Pyth is not allowed, since it is a numeric constant).
• You must calculate 2016 using numerics. Simply outputting 2016 without performing any operations on the required numbers (for example, by decoding an encoded string consisting of only alphabetic characters) is not allowed. Outputting 2016 in pieces (such as 20, then 16) is also not allowed; you must have a single output consisting of the numeric value 2016.
• The valid answer with the fewest bytes wins.

Answer 1

Jelly, 17 15 14 bytes

109876:54+3_21

Try it online!

How it works

109876:54+3_21

109876            Initialize the left argument as 109876.
      :54         Perform integer division by 54, yielding 2034.
         +3       Add 3, yielding 2037.
           _21    Subtract 21, yielding 2016.

Answer 2

Hexagony, 61 bytes

Not gonna win, but I just wanted to do a challenge in Hexagony.

This uses a different method than other answers (much worse). It takes some factors of 2016 (2,3,6,7,8) and multiplies them all together.

Minified:

\109.8/7}_=\"6<}{>...$_5_4/*!@...../}3.."2\/="*=}<*...$1>"*"/

Unminified:

    \ 1 0 9 .
   8 / 7 } _ =
  \ " 6 < } { >
 . . . $ _ 5 _ 4
/ * ! @ . . . . .
 / } 3 . . " 2 \
  / = " * = } <
   * . . . $ 1
    > " * " /

Explanation coming soon;

Answer 3

Pyth, 16 bytes

+/109876 54-3 21

Does integer division, then adds (3-21).

Try it here.

Answer 4

TI-BASIC, 17 15 bytes

int(109876/54-√(321

This uses @nicael's method.

17 bytes:

10+9*8-7+654*3-21

This solution from Puzzling can be directly translated into TI-BASIC.

Answer 5

Japt, 17 16 bytes

Â(109876/54-321q

I hate this 17. Probably will find another solution. YAYZ.

Explanation:

• 321q is a square root of 321.
• ~~ floors the number.

Try it online!

Answer 6

Matlab / Octave, 23 bytes

(10-9+8-7)^(6-5+4)*3*21

Try it online

Answer 7

bc, 14

109876/54+3-21

Nothing exciting here - borrows from other answers.

Answer 8

Haskell, 31 bytes

[10,9*8*7+const 6 5..]!!4+3*2*1

Not the shortest, 10+9*8-7+654*3-21 like seen in other answers works in Haskell too, but something different.

This builds a list starting with 10 and 9*8*7+6 = 510, so the offset is 500 for the following elements. The whole list is [10,510,1010,1510,2010,2510 ...]. We pick the 4th element (index 0-based), i.e. 2010 and add 3*2*1 = 6. Voilà.

I use const 6 5 = 6 to get rid of the 5 which is not needed.

Answer 9

Python 2, 20 bytes

print 109876/54+3-21

Again, that same boring 2016.(740). Makes use of the fact that if you don't have a decimal number in your expression it returns an integer.

Answer 10

Java 7, 31 bytes

int c(){return 109876/54+3-21;}

Boring port from other answers, of which I believe @Dennis' Jelly answer was the first.

Answer 11

PHP, 27 bytes

<?=~~(109876/54+3-21);

(22 bytes) was too boring,

so I used 10 to 9 as separate numbers:

<?=10*(9-8+7-6),5+4-3+2<<1;

other solutions, mostly with small cheats:

30: <?=10**(9+8-7-6)/5+4*3+(2<<1);
30: <?=10*trim(9*8,7),6+5+4+3-2*1;
29: <?=10*trim(9*8,76),5*4-3-2+1;
31: <?=10*trim(9*8,765),4+(3*2<<1);
31: <?=10*trim(9*8,765),4*3+(2<<1);
32: <?=ceil(1098*76/54)+321+ord(~j);
33: <?=(10<<9)/876*543/M_PI*2-M_E&~1;

Answer 12

Polyglot, 17 Bytes

10+9*8-7+654*3-21

This code, first used in Thomas Kwa's TI-BASIC answer, also works in:

• AppleScript (full program)
• bc (full program)
• Math++ (expression or full program)
• Mathematica (function, therefore not valid)
• Powershell (full program)
• Japt (full program)
• JavaScript (console input, therefore not valid) Needs second verification
• Perl 5 (function, therefore not valid). Needs second verification
• Haskell (function, therefore not valid)
• Python REPL (expression, so REPL environment is needed to get the output)

Answer 13

Math++, 17 bytes

_(109876/54)+3-21

Actually, this prints 2016.0. But there's really no way to print the exact string 2016 in this language.

The 17-byte TI-BASIC solution would also work here.

Answer 14

><> (fish), 18 bytes

10987**r65r4*n;321

explaination:

multiplies 9 8 and 7 together to get 504, reverses the stack and reverses it again right before the 4 is added, then multiplies 504 and 4 to get 2016. Then prints the number and ends the program before the last 3 numbers (i could do it after too with no difference, if that matters rules-wise).

Answer 15

2, 15 chars / 17 bytes

109876/54+3-21⍜

Try it here (Firefox only).

Translates to round(109876/54+3-21).

Thanks to @Dennis for saving 2 bytes!

Answer 16

05AB1E, 15 bytes

109876 54÷3+21-

Try it online!

Port of Dennis' answer.

Answer 17

Forth, 22 bytes

Same calculation seen in other answers.

109876 54 / 3 + 21 - .

Try it online

Answer 18

C 37 bytes

main(){printf("%d",109876/54+3-21);}

Same theme as many present.

Answer 19

VBA, 15 bytes

?109876\54+3-21

(calculation unashamedly stolen from Dennis)

Answer 20

JavaScript (ES6), 21 bytes

f=

_=>~~(109876/54+3-21)

console.log(f())

If the "countdown" went to 0, it could be done in 19 bytes.

f=
_=>109876/54+3-21|0
console.log(f())

And, seeing as it's 2017 now, that can also be done in 21 bytes:

f=
_=>-~(109876/54+3-21)
console.log(f());

Answer 21

Milky Way 1.6.5, 28 25 bytes

10+9*(8)7;^*6*5/4*3/2*A!1

---

Explanation

10+9*                      ` perform 10*9 (leaves 90 at TOS)
     (8)7;^*               ` get rid of 8 and multiply the TOS by 7
            6*5/4*3/2*A    ` perform TOS*6/5*4/3*2 (leaves 2016 at TOS)
                       !   ` output the TOS
                        1  ` push 1 to the stack

Answer 22

BotEngine, 42 39 36 13x2=26

v109876543210
>ee   e@  eRP