Nekomata, 2 bytes

Ħ¬

Attempt This Online!

Ħ is a new built-in in Nekomata v0.5.1, so I am using the staging version of ATO.

Ħ¬      Take 5 as an example
Ħ       Histogram; generate a list where the ith element (0-indexed) is the number of times i appears in the input
            5 -> [0,0,0,0,0,1]
 ¬      Logical NOT
            [0,0,0,0,0,1] -> [1,1,1,1,1,0]

JavaScript (Node.js), 25 bytes

-2 bytes thanks to @DLosc

x=>((2<<x)-2).toString(2)

Try it online!

Takes the number as the parameter to the function, then outputs the binary form of \$2^{x+1}-2\$

Python 2, 20 bytes

-3 byte thanks to @Jonathan Allan

print'1'*input()+'0'

Attempt This Online!

Python, 27 bytes

print('1'*int(input())+'0')

Attempt This Online!

Python, 25 bytes

print('1'*int(input()),0)

Uses a less strict output format. Thanks to @ayreguitar and @None1

Attempt This Online!

JavaScript (ES11), 16 bytes

-4 bytes thanks to @Unmitigated

Expects a BigInt and returns a string.

n=>10n**n/9n+"0"

Try it online!

Brachylog, 4 bytes

⟦ṡᵐ↔

Try it online!

Unifies the output with a list, e.g. [1,1,1,1,1,0]

Explanation

⟦      Range [0, …, Input]
 ṡᵐ    Map sign: 
         The sign of positive integers is 1
         Thankfully for this challenge, the sign of 0 is 0
   ↔   Reverse the list

Jelly, 3 bytes

>ŻY

A full program that accepts a (non-negative^*) integer, \$x\$, and prints \$x\$ ones followed by a zero.

^{* negative integers will do the same as zero.}

Try it online!

How?

>ŻY - Main Link: non-negative integer, X   e.g. 0      3
 Ż  - zero range                                [0]    [0,1,2,3]
>   - {X} greater than {that}?                  [0]    [1,1,1,0]
  Y - join with newline characters
    - implicit, smashing print

Perl 5 -p, 9 bytes

$_=1x$_.0

Try it online!

Knight (v2), 7 bytes

O+*,1P0

Try it online!

This answer takes full advantage of Knight's type coercion.

If you look at the code, you may notice that we seem to be multiplying (*) a list (,1) with a string (P), but due to type coercion, the second argument, which is P, is actually coerced to an integer, so this results in a list that consists of P 1's. Then, we seem to be adding the resulting list to an integer 0, but due to type coercion, the integer is coerced into a list, which, in this case, converts the 0 to a singleton list consisting of a 0. This singleton list is then concatenated at the end of the aforementioned list of 1's, resulting in a list of P 1's, followed by a single 0. Finally, O always coerces its input, which is a list, to a string, resulting in the list being joined by newline before being outputted to stdout.

Quipu, 32 bytes

1&0&1&/\
--[]/\
1&3&0&
>===??
\/

Attempt This Online!

Explanation

A Quipu program is composed of threads, vertical 2-character-wide strips that act as code and also as value storage. Threads are, by default, executed one at a time left to right. Each thread's value starts at 0.

Thread 0 stores the current value of the loop counter:

1&
--  # Subtract 1 from the previous value of this thread
1&  
>=  # If the result is >= 0, jump to thread 1
\/  # Otherwise, read a number and set thread 0's value to that

Thread 1 checks whether the loop counter has hit zero:

0&
[]  # Load value of thread 0
3&
==  # If the result is == 0, jump to thread 3

Thread 2 is the loop body:

1&
/\  # Output 1
0&
??  # Jump back to thread 0

Thread 3 runs after the loop exits:

/\  # Output this thread's value (0 by default)

Haskell, 42 37 bytes

-5 bytes thanks to Wheat Wizard.

main=do n<-readLn;print$10^n`div`9*10

Try it online!

Not math, 42 bytes

main=interact(\n->('1'<$[1..read n])++"0")

Try it online!

BitCycle -u, 10 bytes

?~
v~v
>!<

Try it online!

This somehow works even though it uses some sketchy undefined behavior. It doesn't work on the Javascript online interpreter though, so it has to be modified for that interpreter:

16 bytes

?~
v~v
>v<
A/
 !

Try it online!

MathGolf, 3 bytes

Ä10

Try it online.

Explanation:

Ä    # Loop the (implicit) input-integer of STDIN amount of times,
     # using 1 character as inner code-block:
 1   #  Push a 1 every iteration
  0  # After the loop: push a 0
     # (after which the entire stack is joined and output implicitly as result)

Google Sheets, 13 bytes

=REPT(1,A1)&0

SQL (Oracle), 31 bytes

Always fun when we can slip an SQL solution that actual isn't that bad:

select lpad(0,&n+1,1)from dual;

Bash, 22 bytes

echo $((10**-~$1/9-1))

Attempt This Online!

Bash, 22 bytes

yes 1|head -n$1;echo 0

Attempt This Online!

Piet + ascii-piet, 18 bytes (2×9=18 codels)

tabitkcmA ?cjsc aa

Try Piet online!

If we didn't have to consider the x=0 case, there is a nice 14 bytes answer:

tkvnM?esuA Q??

Try Piet online!

TI-BASIC (TI-84+CE), 13 12 10 bytes

• Removed one byte thanks to @KaiBurghardt.
• Removed two bytes by not specifying the increment (which is an optional argument)

seq(X<Ans,X,0,Ans

This creates a list with the correct number of 1's and 0's. The byte count is subtracting any bytes that are present in an empty program. To find the byte count, I looked at the memory stats on the calculator. See how to score TI-BASIC for more information.

The input is in the form of the Ans variable, which needs to be set before running the program. Here is an example of input and output on the TI-84 Plus CE:

99, 69 bytes

 999
99 9 9
9999 9 99 9






 9999 999
9
999 999 9
 9 99





9 99
9

Try it online!

This can 100% be golfed but it is very confusing to golf in this language, with all the 9's and all.

The main issue is this: the only way to access loops and conditionals in this language is through its GOTO command, which will conditionally GOTO a specified line. But because variables in 99 can only hold multiples of 9, so the GOTO command can only jump to lines with line numbers that are multiples of 9. That is why there is so much empty space between certain sections of the code: it is to accommodate for the limitations of the GOTO command.

For now, I am using a GOTO for lines 9 and 18, so that the loop starts at line 9, but I feel that there is a way to cut out the GOTO to line 18 and instead have a GOTO to line 0 (making the start of the loop at line 0), I'm just not sure how to go about doing it. The reason why I don't have a GOTO for line 0 is because line 0 is 999, which takes in input and sets it to the variable 999. If the input command was no-op after reading all the input, then I could have a GOTO to line 0, but instead it reads a 0 into the variable, which messes up the entire loop.

I'm also confident that re-arranging the way I assign the variables can also save 2 or 3 bytes, but I don't see anything for now.

In Floop, 110 bytes

s+n+@?[s-]n-s[-n@;]s+r[s-]s[s-n@+r+]s+r-[s-]r+s[o++++++++++n@-[s-]s[-r+]]s+r--[s-]r++s[n@+o-[s-]s[-r--n+@-n-]]

Try It Online! This was a massive pain to write. Takes about ten seconds for n=3.

This would be a fairly easy challenge even for a Turing tarpit like In Floop... if there was a print instruction. In Floop only outputs the value of the current variable on termination. So, we have to calculate the output value as a single integer by repeatedly adding 1 and multiplying by 10.

In Floop has four integer variables; n, o, r, and s; in addition to an arbitrarily large array of integers @ which can be indexed into by the variables. Unfortunately, the state machine I came up with for this has five, which I'll call input (@[1]), state (r), inv (s), acc (@[0]) and copy (o).

One other thing I should note is that In Floop can only check if a variable is nonzero, so I'll use the idiom s+r+[s-]s[-...] to check if a variable's zero a lot - Set s to 1, if condition's nonzero set it to 0, if s is nonzero set it to 0 and continue.

s+n+@?[s-]n-s[-n@;] # Termination check / setup
  n+@?    n-        # Try writing input value into input
s+    [s-]  s[-   ] # If it's zero
               n@;  # Print acc and terminate


s+r[s-]s[s-n@+r+] # Set up multiplication
s+ [s-]s[s-     ] # If 
  r               # State is 0 (start)
           n@+    # Increment acc
              r+  # State = 1 (multiplying)

s+r-[s-]r+s[o++++++++++n@-[s-]s[-r+]] # Multiply acc by 10
s+  [s-]. s[                        ] # If
  r-    r+                            # State is 1 (multiplying)
            o++++++++++               # Add 10 to copy
                       n@-            # Decrement acc
                          [s-]s[-  ]  # If acc == 0
                                 r+   # State = 2 (copying)

s+r--[s-]r++s[n@+o-[s-]s[-r--n+@-n-]] # Finish loop
s+   [s-]   s[                      ] # If
  r--    r++                          # State == 2 (copying)
              n@+                     # Increment acc
                 o-                   # Decrement copy
                   [s-]s[-         ]  # If copy is zero
                          r--         # State = 0 (setup)
                             n+@-n-   # Decrement input

Acc!!, 87 86 82 bytes

N
Count i while _%96 {
_/96*960+_%48*96+N
}
Count i while _ {
_-960
Write 49-0^_
}

Try it online!

Explanation

Depends on the slightly unofficial behavior of the official interpreter, in which the input always ends with a newline character.

# Accumulator format: value * 96 + next_char
# Read first character
N
# Loop until next_char is EOF (0)
Count i while _%96 {
  # _/96*96*10   Multiply previous value by 10
  # +_%48*96     Add new digit to it (or 10 if character was newline)
  # +N           Read next character
  _/96*960+_%48*96+N
}
# For an input number X, the accumulator is now equal to (X * 10 + 10) * 96
# which is the same as (X + 1) * 960
# Loop until accumulator reaches 0
Count i while _ {
  # Decrement accumulator in steps of 960
  _-960
  # Output '1' if accumulator is still positive, '0' if it is now 0
  Write 49-0^_
}

Acc!!, 65 bytes

Count i while _%11-10 {
_*10+_%11+N%48
}
Write 49)*(_/11
Write 48

Try it online!

Abuses a bug in the official interpreter

Acc!!, ^{105 88 85} 81 bytes

-5 byte thanks to @DLosc

Count i while _%11-10 {
_*10+_%11+N%48
}
Count i while _+1 {
Write 49-10/_
_-11
}

Try it online!

C (gcc), 49 bytes

-4 bytes thanks to @ceilingcat

main(c){for(scanf("%d",&c);~c;)putchar(49^!c--);}

Try it online!

APL+WIN, 6 bytes

Prompts for integer input:

⌽0,⎕⍴1

Try it online! Thanks to Dyalog Classic

Brainfuck+2, 11 bytes

;[>+:-<-]>:

Try it online

Explanation

; Input x as decimal number (only 0 to 255 are supported)
[ While x is nonzero
>+:-< Print 1
- Decrement x
]
>: Print 0

Pip, 6 bytes

LqP1
0

Try it online!

Retina 0.8.2, 7 bytes

.+
$*10

Try it online! Explanation: $* repeats a single character to its right, so the 0 does not get repeated. By default the repeat count is the entire match, which here is the input, so the input is replaced by the desired output.

05AB1E, 3 4 3 2 bytes

^{crossed out 4 is still regular 4 ;(}

Ý›

+1 byte as bugfix (L results in \$[1,0]\$ for edge-case \$n=0\$)
-1 byte thanks to @lyxal
-1 byte due to a comment of OP ("Any unambiguous output format is allowed"), so it'll output as a list

Try it online.

Explanation:

Ý   # Push a list in the range [0, (implicit) input of STDIN]
 ›  # Check for each value whether the (implicit) input is larger
    # (after which this list is output implicitly as result to STDOUT)

FreePascal, 58 B 54 B

Evidently, the output is just \$2^{x+1}-2\$ written to a base of two. This is shorter than producing the desired output iteratively.

var x:word;begin read(x);write(binStr(1<<(x+1)-2,x+1))end.

−4 B: As pointed out by dtanku, \$2^{x+1}-2 = 2^x2^1-2\$ so we pre‑evaluate \$2^1\$ and start exponentiating from \$2\$.

var x:word;begin read(x);write(binStr(2<<x-2,x+1))end.

NB: The read and its sister procedures accept all integer literals acceptable in FreePascal source code, thus $F is valid input, too.

Uiua 0.10.0, 3 bytes

0¬⊚

-1 byte thanks to @noodle man

Returns a list of 1s then a 0.

Other solutions

Just to showcase other features in Uiua and different options for output.

0=.⇡
0↯:1
⇌±⇡+1
>⇡+1.
¬⋯ⁿ:2
⇌[@0⍥@1]
0⍥&p‿1
0⍥1      #cannot be bound to a function name