[Question]
  [
In some nations there are recommendations or laws on how to form emergency corridors on streets that have multiple lanes per direction. (In the following we only consider the lanes going in the direction we are travelling.) These are the rules that hold in Germany:
* If there is only one lane, everyone should drive to the right such that the rescue vehicles can pass on the left.
* If there are two or more lanes, the cars on the left most lane should drive to the left, and everyone else should move to the right.
### Challenge
Given the number `N>0` of regular lanes, output the layout of the lanes when an emergency corridor is formed using a string of `N+1` ASCII characters. You can use any two characters from ASCII code `33` up to `126`, one to denote the emergency corridor, and one for denoting the cars. Trailing or leading spaces, line breaks etc are allowed.
### Examples
Here we are using `E` for the emergency corridor, and `C` for the cars.
```
N  Output
1  EC
2  CEC
3  CECC
4  CECCC
5  CECCCC
6  CECCCCC
   etc
```
  
[Answer]
# Python 2, 29 26 bytes
```
lambda n:10**n*97/30-1/n*9
```
Example:
```
>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233
```
[Answer]
# Python 3, ~~35~~ 33 bytes
```
lambda N:'C'*(N>1)+'EC'+'C'*(N-2)
```
Edit: dropping `f=` to save 2 bytes, thanks to [@dylnan](https://codegolf.stackexchange.com/users/75553/dylnan)'s reminder.
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUcHPSt1ZXUvDz85QU1vd1VldG8LVNdL8n5ZfpJCpkJmnUJSYl56qYahjrmnFpVBQlJlXopGpk6aRqan5HwA)
To visualize it:
```
lambda N:'üöò'*(N>1)+'üöîüöò'+'üöò'*(N-2)
```
Output:
```
1 üöîüöò
2 üöòüöîüöò
3 üöòüöîüöòüöò
4 üöòüöîüöòüöòüöò
5 üöòüöîüöòüöòüöòüöò
6 üöòüöîüöòüöòüöòüöòüöò
```
[Try üöî online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUcHPSv3D/Fkz1LU0/OwMNbVBnClgAW24uK6R5v@0/CKFTIXMPIWixLz0VA1DHXNNKy6FgqLMvBKNTJ00jUxNzf8A)
# Python 3, 40 bytes
A straightforward solution:
```
lambda N:str(10**N).replace('100','010')
```
[Try it online!](https://tio.run/##BcExCoAwDADA3VdkayJFUhwEwS/4ApeqrQa0ltjF19e7/JXzSX2N01Ivf6@7h3mEtyg6btuZOg358ltA45iNNezYUI2PgoAkUJ@OgM4ONDaQVVJBsRGFqP4)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 32 bytes
```
f(n){printf(".%.*f"+1%n,n-1,0);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zuqAoM68kTUNJT1VPK01J21A1TydP11DHQNO69j9QRiE3MTNPQ1OhmoszLb9IQQMklKlgq2BoDaRsbBXMgLS2NlieM00jU9MaSMOMjMlTAvFruWr/AwA "C (gcc) ‚Äì Try It Online")
Uses `0` and `.` characters:
```
.0
0.0
0.00
0.000
0.0000
```
[Answer]
# Japt, ~~5~~ 4 bytes
Uses `q` for cars and `+` for the corridor.
```
√ß¬¨i√Ñ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=56xpxA==&input=OA==)
Credit to Oliver who golfed 4 bytes off at the same time as I did.
---
## Explanation
A short solution but a tricky explanation!
The straightforward stuff first: The `√ß` method, when applied to an integer, repeats its string argument that number of times. The `i` method takes 2 arguments (`s` & `n`) and inserts `s` at index `n` of the string it's applied to.
Expanding the 2 unicode shortcuts used gives us `√ßq i+1`, which, when transpiled to JS becomes `U.√ß("q").i("+",1)`, where `U` is the input. So we're repeating `q` `U` times and then inserting a `+` at index 1.
The final trick is that, thanks to Japt's index wrapping, when `U=1`, `i` will insert the `+` at index `0`, whatever value you feed it for `n`.
[Answer]
# R, 50 bytes
-11 thanks to Giuseppe!
```
pryr::f(cat("if"(x<2,12,c(21,rep(2,x-1))),sep=""))
```
Outputs 1 for emergency corridor and 2 for normal lanes
## My attempt, 61 bytes
Nothing fancy to see here, but let's get R on the scoreboard =)
```
q=pryr::f(`if`(x<2,cat("EC"),cat("CE",rep("C",x-1),sep="")))
```
Usage:
```
q(5)
CECCCC
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~38~~ ~~34~~ 32 bytes
```
f 1="EC"
f n="CE"++("C"<*[2..n])
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P03B0FbJ1VmJK00hz1bJ2VVJW1tDyVnJRivaSE8vL1bzf25iZp5tbmKBb7yCRkFpSXBJkU@eXpqmQrShnp5Z7H8A "Haskell ‚Äì Try It Online")
[Answer]
# Python 2, ~~30~~ ~~29~~ 28 bytes
```
lambda n:`10/3.`[1/n:n-~1/n]
```
Print `3` instead of `C` and `.` instead of `E`.
**Explanation:**
[Try it online.](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKsHQQN9YLyHaUD/PKk@3DkjF/k/LL1LIVMjMUyhKzEtP1TDUUTA00LTiUlAoKMrMK1HI1EnTyNT8DwA)
```
lambda n:    # Method with integer parameter and string return-type
  `10/3.`    #  Calculate 10/3 as decimal (3.333333333) and convert it to a string
  [1/n       #   Take the substring from index 1 if `n=1`, 0 otherwise
   ,n-~      #   to index `n+1` +
       1/n]  #    1 if `n=1`, 0 otherwise
```
---
# Python 2, ~~33~~ ~~32~~ ~~31~~ ~~29~~ 28 bytes
```
lambda n:1%n-1or'1-'+'1'*~-n
```
Prints `1` instead of `C` and `-` instead of `E`.
-2 bytes thanks to *@ovs*.  
-1 byte thanks to *@xnor*.
**Explanation:**
[Try it online.](https://tio.run/##BcExDoAgDADA3Vd0MQWFxDqS@BMXjKJNtJCGxcWv411565VlbmlZ2x2fbY8ggXrxlBXJ44iEw@elpazAwAIa5TwMOaDJhg6gKEsFdsmwbT8)
```
lambda n:    # Method with integer parameter and string return-type
  1%n-1      #  If `n` is 1: Return '-1'
  or         #  Else:
    '1-'+    #   Return '1-', appended with:
    '1'*~-n  #   `n-1` amount of '1's
```
[Answer]
# Pyth, ~~10~~ ~~9~~ 8 bytes
```
Xn1Q*NQZ
```
Uses `0` to denote the emergency corridor and `"`.  
[Try it here](http://pyth.herokuapp.com/?code=Xn1Q%2aNQZ&input=5&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5&debug=0)
### Explanation
```
Xn1Q*NQZ
    *NQ     Make a string of <input> "s.
 n1Q         At index 0 or 1...
X      Z    ... Insert 0.
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 42 bytes
```
,[[>]+[<]>-]>>[<]<[<]>+>+<[<-[--->+<]>.,>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fJzraLlY72ibWTjfWzg5I24DY2nbaQFo3WldXF8iKtdPTsYv9/x8A "brainfuck ‚Äì Try It Online")
Takes input as char code and outputs as `V` being normal lanes and `W` being the cleared lane. (To test easily, I recommend replacing the `,` with a number of `+`s)
### How it Works:
```
,[[>]+[<]>-] Turn input into a unary sequence of 1s on the tape
>>[<]<[<]    Move two cells left of the tape if input is larger than 1
             Otherwise move only one space
>+>+<        Add one to the two cells right of the pointer
             This transforms:
               N=1:  0 0' 1 0  -> 0 2' 1 0
               N>1:  0' 0 1 1* -> 0 1' 2 1*
[<-[--->+<]>.,>]  Add 86 to each cell to transform to Ws and Vs and print
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
√é>‚àç1I‚â†«ù
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cJ/do45eQ89HnQuOz/3/3xgA "05AB1E ‚Äì Try It Online")
0 is C and 1 is E.
**Explanation**
```
√é>          # Push 0 and input incremented            -- [0, 4]
  ‚àç         # Extend a to length b                    -- [0000]
   1I‚â†      # Push 1 and input falsified (input != 1) -- [0000, 1, 1] 
      «ù     # Insert b in a at location C             -- [0100]
            # Implicit display
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/) (MATLAB\*), ~~31 30 28 27~~ 22 bytes
```
@(n)'CE'(1+(n>1==0:n))
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI09T3dlVXcNQWyPPztDW1sAqT1Pzv6pjTklqUV5iSapCWn6RQnFibqpCUiWQl5xfmldipQDSFq2urmBigaQtlosrTcNQU0HV1RnIMAIynMEsYwgLxDSBMkFsUxgbxDGDc5z/AwA "Octave ‚Äì Try It Online")
The program works as follows:
```
@(n)                   %Anonymous function to take input
            n>1==0:n   %Creates [1 0] if n is 1, or [0 1 (0 ...)] otherwise
         1+(        )  %Converts array of 0's and 1's to 1-indexed
    'CE'(            ) %Converts to ASCII by addressing in string
```
The trick used here is XNORing the seed array of `0:n` with a check if the input is greater than 1. The result is that for `n>1` the seed gets converted to a logical array of `[0 1 (0 ...)]` while for `n==1` the seed becomes inverted to `[1 0]`, achieving the necessary inversion.
The rest is just converting the seed into a string with sufficient appended cars.
---
(\*) The TIO link includes in the footer comments an alternate solution for the same number of bytes that works in MATLAB as well as Octave, but it results in a sequence of '0' and '1' rather than 'E' and 'C'. For completeness, the alternate is:
```
@(n)['' 48+(n>1==0:n)]
```
---
* Saved 1 byte by using `n==1~=0:1` rather than `0:1~=(n<2)`. `~=` has precedence over `<`, hence the original brackets, but is seems that `~=` and `==` are handled in order of appearance so by comparing with 1 we can save a byte.
* Saved 2 bytes by changing where the negation of `2:n` is performed. This saves a pair of brackets. We also have to change the `~=` to `==` to account for the fact that it will be negated later.
* Saved 1 byte using `<` again. Turns out that `<` has same precedence as `==` after all. Placing the `<` calculation before the `==` ensures correct order of execution.
* Saved 5 bytes by not creating two separate arrays. Instead relying on the fact that the XNOR comparison will convert a single range into logicals anyway.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~11~~ 9 bytes
```
‚Äô0·∫ã‚Åæ0E;·πô·ªä
```
[Try it online!](https://tio.run/##AR8A4P9qZWxsef//4oCZMOG6i@KBvjBFO@G5meG7iv///zEw "Jelly ‚Äì Try It Online")
Full program.
Uses `0` instead of `C`.
[Answer]
# C (gcc), 39 bytes
```
f(n){printf("70%o"+!n,7|(1<<3*--n)-1);}
```
[Try it online!](https://tio.run/##NYzBDsIgEETvfMWKMWFFjMQDB9Av8WKo6CZ2MbWeKt@OtImnmbx5mWjuMdY1cXx@uhuE99hR3j/ONSnG6TUQj0lJd9hkqVe8c19lQzhujWE0Fn2pTYD@SqxQTAIg5QHUzAhOYH2LAK6F1tjW2WiOIvRL@/9fWC6kiFJ/ "C (gcc) ‚Äì Try It Online")
Borrowed and adapted the printf trick from [ErikF's answer](https://codegolf.stackexchange.com/a/161306/20779).
[Answer]
# Python 3, 32 bytes
```
lambda n:f"{'CE'[n<2:]:C<{n+1}}"
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPKk2pWt3ZVT06z8bIKtbK2aY6T9uwtrhW6X9afpFCnkJmnkJRYl56qoahjpmmFZcCEBQUZeaVaOTpKKRp5Glq/gcA "Python 3 ‚Äì Try It Online")
Uses an f-string expression to format either`'E'`or`'CE'` padded on the right with`'C'`so it has width of`n+1`.
```
f"{          :       }    a Python 3 f-string expression.
   'CE'[n<2:]             string slice based on value of n.
             :            what to format is before the ':' the format is after.
              C           padding character
               <          left align
                {n+1}     minimum field width based on n
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~100~~ 66 bytes
```
{({}[()]<((((()()()()){}){}){}())>)}{}(({}<>)())<>{<>{({}<>)<>}}<>
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/v1qjujZaQzPWRgMENCFQs7oWgoBMO81aIA1UZWMHkrGxqwYiCNfGrhZI/f9v@F/XEQA "Brain-Flak ‚Äì Try It Online")
Uses `"` as the emergency lane and `!` as the normal lanes.
[Answer]
# C#, 34 bytes
```
n=>n++<2?"EC":"CE".PadRight(n,'C')
```
[Try it online!](https://tio.run/##LY09C8IwFADn5lc8upgQLepoWx2KTgpFBwdxCOmHD9oXyIuCSH97Leh0yx1neWHZjrYzzFB613rTw0dEHExACy@HFZwMkuTgkdrbHYxvWU2KuLw51H1yeJLNkMIcfsoWGshHyrekdbbexfsi3sTFPk5KU52xfQRJ81kxU@koROM8yKkFhBxW6YQMVsuJWisR/QeFI3ZdnVw9hvqIVMtGolKpENEghvEL)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~21 17~~ 16 bytes
```
(-‚â†‚àò1)‚åΩ'E',‚ç¥‚àò'C'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P9UnMS@1@FHbBA3dR50LHnXMMNR81LNX3VVd51HvFiBX3Vn9//9HbRMh6g6teNS72cgAAA)
Thanks to Erik for saving 4 bytes and Ad√°m for one further byte.
### How?
```
(-‚â†‚àò1)‚åΩ'E',‚ç¥‚àò'C' ‚çù Tacit function
           ‚ç¥‚àò'C' ‚çù Repeat 'C', according to the input
       'E',      ‚çù Then append to 'E'
      ‚åΩ          ‚çù And rotate
    1)           ‚çù 1
  ‚â†‚àò             ‚çù Different from the input? Returns 1 or 0
(-               ‚çù And negate. This rotates 0 times if the input is 1, and once if not.
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~35~~ ~~33~~ 32 bytes
*2 bytes saved thanks to Angs, 1 byte saved thanks to Lynn*
```
(!!)$"":"EC":iterate(++"C")"CEC"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P91WQ1FRU0VJyUrJ1VnJKrMktSixJFVDW1vJWUlTyRko9j83MTPPtqAoM69EJV3B5D8A "Haskell ‚Äì Try It Online")
# [Haskell](https://www.haskell.org/), ~~32~~ ~~30~~ 29 bytes
*This is zero indexed so it doesn't comply with the challenge*
```
g=(!!)$"EC":iterate(++"C")"CEC"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P91WQ1FRU0XJ1VnJKrMktSixJFVDW1vJWUlTyRko9j83MTPPtqAoM69EJV3B@D8A "Haskell ‚Äì Try It Online")
# [Haskell](https://www.haskell.org/), 30 bytes
*This doesn't work because output needs to be a string*
```
f 1=21
f 2=121
f n=10*f(n-1)+1
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P03B0NbIkCtNwcjWEEzn2RoaaKVp5Okaamob/s9NzMyzLSjKzCtRSVMw@Q8A "Haskell ‚Äì Try It Online")
Here we use numbers instead of strings, `2` for the emergency corridor, `1` for the cars. We can add a `1` to the end by multiplying by 10 and adding `1`. This is cheaper because we don't have to pay for all the bytes for concatenation and string literals.
It would be cheaper to use `0` instead of `1` but we need leading zeros, which end up getting trimmed off.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~30~~ 29 bytes
```
lambda n:"CEC"[~n:]+"C"*(n-2)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPSsnZ1Vkpui7PKlZbyVlJSyNP10jzf1p@kUKmQmaeQlFiXnqqhqGOuaaVQkFRZl6JRqZOmkampuZ/AA "Python 3 ‚Äì Try It Online")
OK, there is a lot of Python answers already, but I think this is the first sub-30 byter among those still using "E" and "C" chars rather than numbers.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 28 bytes
```
n=>n<2?21:"12".padEnd(n+1,1)
```
[Try it online!](https://tio.run/##bck5CoAwEADA3mekSvCAXY9CjFY@JBgVRTai4vcjggcS25lR7WptlmHeQjK6tZ20JEsqsELIGSCLZqVr0px8CEDYxtBqpjaaTM87DkJKhsCE93U8HX4ivsKd5B630qfcy9470x4 "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 [bytes](https://github.com/abrudz/SBCS)
```
‚â°‚àò1‚åΩ'CE',1‚Üì‚ç¥‚àò'C'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HnwkcdMwwf9exVd3ZV1zF81Db5Ue8WoJC6szpQtneugm9iZp5CWmlecklmfp6CRnFpUm5mcTGQrcnFlabwqG2CAj4zuLhAZoSkFpekFsFN4eIqAQpA9PZO1VG3UlDXSUOoVEhOLE4thioyhFBGEMoYQplAKFMIZQahzCGUBYSyhGo3AAA "APL (Dyalog Unicode) ‚Äì Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
√º‚ô£√†j#F 
```
[Run and debug it](https://staxlang.xyz/#p=8105856a234620&i=1%0A2%0A3%0A20&a=1&m=2)
This uses the characters "0" and "1". This works because when you rotate an array of size 1, it doesn't change.
Unpacked, ungolfed, and commented, it looks like this.
```
1]( left justify [1] with zeroes. e.g. [1, 0, 0, 0]
|)  rotate array right one place
0+  append a zero
$   convert to string
```
[Run this one](https://staxlang.xyz/#c=1]%28%09left+justify+[1]+with+zeroes.+e.g.+[1,+0,+0,+0]%0A%7C%29%09rotate+array+right+one+place%0A0%2B%09append+a+zero%0A%24%09convert+to+string&i=1%0A2%0A3%0A20&m=2)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 19 bytes
```
n=>--n?"0"+10**n:10
```
[Try it online!](https://tio.run/##DcVBCoAgEADAc71i8aSJoZcOlfUWqQxDdkPD75tzmccVl48U3k8hnVf1tqLdlMKdaSaNHgacja6eEvDiEgSwYJbWamFqSyn67iDMFK8x0s09D0Is9Qc "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~27~~ ~~20~~ 19 bytes
```
$_=1x$_;s/1?\K1/E1/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tawQiXeuljf0D7G21Df1VD//3/jf/kFJZn5ecX/dQsA "Perl 5 ‚Äì Try It Online")
Saved a byte by using `1` for the cars and `E` for the emergency corridor.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
‚Åµ*·πæ·πô·ªä·πô
```
Displays car lanes as **0**, the emergency lane as **1**.
[Try it online!](https://tio.run/##y0rNyan8//9R41athzv3Pdw58@HuLiD53@xw@6OmNZH/AQ "Jelly ‚Äì Try It Online")
### How it works
```
‚Åµ*·πæ·πô·ªä·πô  Main link. Argument: n
‚Åµ*      Compute 10**n.
  ·πæ     Uneval; get a string representation.
   ·πô·ªä   Rotate the string (n‚â§1) characters to the left.
     ·πô  Rotate the result n characters to the left.
```
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), ~~141~~ ~~104~~ 103 bytes
```
[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  S N
_Push_2][T  S S T   _Subtract][S N
S _Duplicate_input-2][N
T   T   N
_If_negative_Jump_to_Label_-1][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][S S T    T   N
_Push_-1][T N
S T _Print_as_integer][T    S S T   _Subtract][N
S S T   N
_Create_Label_LOOP][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_EXIT][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][T    S S T   _Subtract][N
S N
T   N
_Jump_to_LOOP][N
S S N
_Create_Label_-1][T N
S T _Print_as_integer][N
S S S N
_Create_Label_EXIT]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.  
`[..._some_action]` added as explanation only.
Prints `1` instead of `C` and `-` instead of `E`.
-1 byte thanks to *@JoKing* by suggesting the use of `1` and `-1` instead of `0` and `1`.
### Explanation in pseudo-code:
```
Integer i = STDIN-input as integer - 2
If i is negative (-1):
  Print i (so print "-1")
Else:
  Print "1-1"
  Start LOOP:
    If i is negative:
      EXIT program
    Print "1"
    i = i-1
    Go to the next iteration of the LOOP
```
### Example runs:
**Input: `1`**
```
Command   Explanation                 Stack      Heap    STDIN   STDOUT   STDERR
SSSN      Push 0                      [0]
SNS       Duplicate top (0)           [0,0]
TNTT      Read STDIN as integer       [0]        {0:1}   1
TTT       Retrieve heap at 0          [1]        {0:1}
SSSTSN    Push 2                      [1,2]      {0:1}
TSST      Subtract top two            [-1]       {0:1}
SNS       Duplicate input-2           [-1,-1]    {0:1}
NTSN      If neg.: Jump to Label_-1   [-1]       {0:1}
NSSN      Create Label_-1             [-1]       {0:1}
TNST      Print top as integer        []         {0:1}           -1
NSSSN     Create Label_EXIT           []         {0:1}
                                                                         error
```
[Try it online](https://tio.run/##VYrLCcAwDEPP0hRaoSOVEkhvgRQ6vivbp9rgz9N75/2Mvc5rREiiG0SWP4io6Q0m6FxJrflAwQ4s6Wd1aM@07EwZcXw) (with raw spaces, tabs and new-lines only).  
Stops with error: Exit not defined.
**Input: `4`**
```
Command   Explanation                   Stack      Heap    STDIN   STDOUT   STDERR
SSSN      Push 0                        [0]
SNS       Duplicate top (0)             [0,0]
TNTT      Read STDIN as integer         [0]        {0:4}   4
TTT       Retrieve heap at 0            [4]        {0:4}
SSSTSN    Push 2                        [4,2]      {0:4}
TSST      Subtract top two              [2]        {0:4}
SNS       Duplicate input-2             [2,2]      {0:4}
NTSN      If neg.: Jump to Label_-1     [2]        {0:4}
SSSTN     Push 1                        [2,1]      {0:4}
SNS       Duplicate top (1)             [2,1,1]    {0:4}
TNST      Print as integer              [2,1]      {0:4}           1
SSTTN     Push -1                       [2,1,-1]   {0:4}
TNST      Print as integer              [2,1]      {0:4}           -1
TSST      Subtract top two              [1]        {0:4}
NSSTN     Create Label_LOOP             [1]        {0:4}
 SNS      Duplicate top (1)             [1,1]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [1]        {0:4}
 SSSTN    Push 1                        [1,1]      {0:4}
 SNS      Duplicate top (1)             [1,1,1]    {0:4}
 TNST     Print as integer              [1,1]      {0:4}           1
 TSST     Subtract top two              [0]        {0:4}
 NSNTN    Jump to Label_LOOP            [0]        {0:4}
 SNS      Duplicate top (0)             [0,0]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [0]        {0:4}
 SSSTN    Push 1                        [0,1]      {0:4}
 SNS      Duplicate top (1)             [0,1,1]    {0:4}
 TNST     Print as integer              [0,1]      {0:4}           1
 TSST     Subtract top two              [-1]       {0:4}
 NSNTN    Jump to Label_LOOP            [-1]       {0:4}
 SNS      Duplicate top (-1)            [-1,-1]    {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [-1]       {0:4}
NSSSN     Create Label_EXIT             [-1]       {0:4}
                                                                            error
```
[Try it online](https://tio.run/##VYrLCcAwDEPP0hQaoguVEkhvgRQ6vivbp9rgz9N75/2Mvc5rREiiG0SWP4io6Q0m6FxJrflAwQ4s6Wd1aM@07EwZcXw) (with raw spaces, tabs and new-lines only).  
Stops with error: Exit not defined.
[Answer]
# [AutoHotkey](https://autohotkey.com/docs/AutoHotkey.htm) 32 bytes
Replaces the letter "C" with "EC" unless amount of C > 1, then it sends "CEC" and exits the app.
```
::C::EC
:*:CC::CEC^c
^c::ExitApp
```
C => EC  
CC => CEC then exits the program. Any further Cs will be entered after the program exits.
[Answer]
# APL+WIN, ~~20~~ 16 bytes
4 bytes saved thanks to Ad√°m
Prompts for integer n:
```
(-2‚â†‚ç¥n)‚åΩn‚Üê1‚éï/‚çï10
```
1 for emergency corridor o for cars.
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
1":1&<=i.,]
```
[Try it online!](https://tio.run/##y/r/P81WT8FQycpQzcY2U08n9n9qcka@QpqanYKhdqaeoel/AA "J ‚Äì Try It Online")
Based on ngn‚Äôs [comment](https://codegolf.stackexchange.com/questions/161281/make-an-emergency-corridor/161294#comment391068_161294).
üöò and üöî:
[`1&<,~/@A.'üöî',~'üöò'$~,&4`](https://tio.run/##y/r/P81WT8FQzUanTt/BUU/9w/xZU9R16kD0DHWVOh01k/@pyRn5CmlqdgqG2pl6hob/AQ "J ‚Äì Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/create_explanation.py), ~~7~~ 6 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
√∫‚ñë\‚î¥‚ïú‚ï™
```
[Try it online.](https://tio.run/##AS8A0P9tYXRoZ29sZv9xIiDihpIgInH/w7rilpFc4pS04pWc4pWq//8xCjIKMwo0CjUKOQ)
Output `1` for `E` and `0` for `C`.
**Explanation:**
```
√∫         # 10 to the power of the (implicit) input
          #  i.e. 1 ‚Üí 10
          #  i.e. 4 ‚Üí 10000
 ‚ñë        # Convert it to a string
          #  i.e. 10 ‚Üí "10"
          #  i.e. 10000 ‚Üí "10000"
  \       # Swap so the (implicit) input is at the top of the stack again
   ‚î¥‚ïú     # If the input is NOT 1:
     ‚ï™    #  Rotate the string once towards the right
          #   i.e. "10000" and 4 ‚Üí "01000"
          # Output everything on the stack (which only contains the string) implicitly
```
]