Convert from base 10 to base 2 without built-in base conversions

Question

Background:

You have been given an assignment to convert base 10 numbers to base 2 without using any premade base conversion functions. You can't use any imported libraries either.

Problem:

Convert an input string from base 10 (decimal) to base 2 (binary). You may not use any premade base conversion code/functions/methods, or imported libraries. Since this is code-golf, the shortest answer in bytes will win.

Input will be anything from -32768 to 32767 (include sign byte handling in your code)

Answer 1

Java 10, 80 71 57 bytes

n->{var r="";for(n=n<0?-n:n;n>1;n/=2)r=n%2+r;return n+r;}

-9 bytes due to a rule in the comments.. Negative base-10 inputs may return the positive/absolute base-2 value as output apparently.

Explanation:

Try it online.

n->{                   // Method with integer parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(n=n<0?-n:n;      //  Transform the input to its absolute value
      n>1;             //  Loop as long as `n` is still >= 2:
      n/=2)            //    After every iteration: integer-divide `n` by 2
    r=n%2+r;           //   Prepend `n` modulo-2 to the result
  return n             //  Return the last `n`
         +r;           //  appended with the result

Answer 2

MATL, 15 17 bytes

t0<?16Ww+]`2&\t]x

Try it on MATL Online

TIO

(+2 bytes removing leading 0 for negative numbers, sign bit should be the first bit.)

Output on MATL Online should be read bottom-up (MSB is at the bottom).

The main part is pretty simple: `2&\t = while the value is greater than 0, divide by 2 and accumulate the remainders.

Handling negative numbers and giving them 2's complement representation was the tricky part. In the end I went with the "subtract from \$ 2^N \$" method of getting a number's two's complement. Since we're only required to handle values upto -32768, for negative numbers the code creates \$ 2^{16} = 65536 \$ with 16W, adds the input to that (eg. 65536 + (-42)), which gives something MATLAB sees as a positive number but represents the input's signed binary representation in 16-bit form.