[Question]
  [
[Sandbox](https://codegolf.meta.stackexchange.com/a/18360/78850)
*Adapted from exercise 4 of [100 little Keg exercises](https://github.com/JonoCode9374/100-Little-Keg-Exercises)*
The ability to repeat chunks of code within a program is an important part of any programming language. Also just as important is the ability to make decisions based on different values. 
## The Challenge
I want you to write a program that:
* Starts at the number 0, and:
* For each number from 0 to 100 (inclusive):
* If the number is even, print the letter `E` (uppercase or lowercase)
* Otherwise: print the number
Keeping in the spirit of this challenge, your source code must fit the pattern of having characters with an odd ordinal value followed by characters with an even ordinal value. *Note that ordinal value is defined here as if I called python's `ord()` function on the character using your language's prefered code page.* In other words, the code points of your program should be as such:
```
Odd Even Odd Even Odd Even ...
```
or
```
Even Odd Even Odd Even Odd ...
```
More concisely, the code points of your program must alternate between being odd and even.
## Example Output
```
E 1 E 3 E 5 E 7 E 9 E 11 E 13 E 15 E 17 E 19 E 21 E 23 E 25 E 27 E 29 E 31 E 33 E 35 E 37 E 39 E 41 E 43 E 45 E 47 E 49 E 51 E 53 E 55 E 57 E 59 E 61 E 63 E 65 E 67 E 69 E 71 E 73 E 75 E 77 E 79 E 81 E 83 E 85 E 87 E 89 E 91 E 93 E 95 E 97 E 99 E
```
Output can be in any other convenient format with any other separator.
Leading and trailing whitespace is acceptable.
## Script Validation (UTF-8 only)
[Here is a Keg script to see if your program fits the parity pattern requirement](https://tio.run/##y05N//9fOTi5KLOgRCEtv0ihJLW4JDMvXaEgsSizpBJIlZSkFuUpJOcXFaUml@SlFhdzKYcWpxYrhIa46Vpw2WsYqVrpKegoaXLpGKpVKxra1ahYKanYGtiqaamp16pFJzhDdCoEQExKqEnwzEtGE4vV@f@/orKqsgIA "Keg – Try It Online")
Note that this can only be used for languages that use utf-8 as their codepage. 
[Here is an alternate Haskell script written by @WheatWizard which can handle newlines and shows which characters are invalid.](https://tio.run/##bZBBS8QwEIXv/RWPsrApdCvqbbEgVm968iKI7I7psC2mSU1SFv3zNaldi7CXwMy8983LNOQ@WKlxbLveWI978lRUDdlkblRGe2tU8WQ01UlHrUaJ2iSADBPW3uFmgwP7ai7DRLEPL/DeencrGqb6rvXbXRacHfUQYt@Zeo@rDAWMrbM/1OQ6GFLRGdTySyrG60zIcYkN5uItaB1/Dqwl77D6jQQIGbLncXM@gYIyiwG/2/56STzhT3smn2U/WL1wgH7wz96GjmvMERG7DOKBsMb6rDQw5/6xYQ0RalyUS5rVSZ/iJf1HeNRI03EkIbeMeC2ZMAiloG2WOMjw/xIsKH1Isx8 "Haskell – Try It Online")
[Here is a Python Script that tells you where you need to insert extra characters. (As well as the binary codes and the ord code of the characters)](https://tio.run/##bVJNb9swDD1Hv4JzUMACkqDJbgaMYhgKrJdhh96CYBBkularSYZEJ8tlfz0jEzvpPnwxKVKPj0@vP1IXw8fTaQ7PncuQbXI9AaH3GY5xgEOHCc9RQGyAopqDCxkTge1MMpYw5ZVSDbaw/96XXlcwh6cM1CH0hrgcYG@8ax7UrE@4hxr89n6nZm1M4BiL03W1q9Rs5lqIqSmdvtvAhxp@SSJXOJfyLCENjLbmeERyajq8v1LYjBw@QbnXmFx7hLLXIxPqDMEhprcMMj8OCeyQEgYC7zIJXB48MfT2D4oy/1Jamb7HwCx5CX0dL6tf6lqphKZhhKIoTGkrBM2JVQgG6tJUWmWwsOYzLE3xWGjuY7pfTGqWNjZnsXls6AcCEX@lWn/hQ@P/SksGMTPyE6mtW1wUXExCCkc36kJe1/VaVmmvN8hvq@Vauhim3v4HYKfU@3bebw5f8eBdwCwk5KHb6H08uPDCipIQd6Fx1hBy7z8OmvwjF28eEtjnM1T6Yai6VRZiChBlbhHcwUbddGjlfSR7lcxVZ4O4QOWrVmNU1OPH3H8SPO4xLGPDaN0Q3mAqFrzd2P/t4piqWPDedSEV1tFjKFuv2Z2i49j6FGxkD1maDM/N6DPeOj7/XT@dfgM)
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the answer with the fewest amount of bytes wins.
Let it be known that flags don't count towards being in the pattern. They also don't count towards byte count in this challenge. 
## Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=197210;
var OVERRIDE_USER=78850;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="<h1>"+q.body.replace(OVERRIDE_REG,"")+"</h1>")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery("<i>"+n.language+"</i>").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> 
```
  
[Answer]
# [Python 3](https://docs.python.org/3/), 72 bytes
```
x="E";z= 1
while 	z	<101:	x=x+ ["E"	,	f' {z} ' ] [z%2] ;z=z+ 1
exit	(	x)
```
[Try it online!](https://tio.run/##RY1BCsMgFETX5hS/gaCSBmq6S@uypxAXITGNIBpEqLX07Na0iy7fDPNme4bV2XOe3Kw4xjhHXt/qS@LAqseqjQKU0JWd2IAijy2I0qIjWjC80hswSBCp6SWURWrLRkUdEEGR5iITbOiYrDavbSCjMcT5mexPQkva9Af@55btyeI8aNAW/GjvihhlvzXtGKW0uNX04/wB "Python 3 – Try It Online")
Just by coincidence, `exit` and `while` are both available. The rest is just the program separated by spaces and tabs to make it alternate.
I'm hoping it's forgivable to output as an exit code, since `print` is unavailable.
[Answer]
# JavaScript (ES6), 42 bytes
Contains a literal `Tab`.
```
f= y =>y>98? ' E ':' E ' + -~y +f   (1 -~y )
```
[Try it online!](https://tio.run/##VY3LCsIwFETX9itmI72hbaCufJCKiF8hguGaaiQ00pZCNv56TLtzMxxmYM5bT3rg3n7GqvMPE82kHXEiKNxjqxCgmtDstkfkuCDfL4kC1TegaFdULyTiXQ7OsqG6RFULccgy9t3gnZHOP6klIf6Kq5Ry1tykmUwfiLiEFckFlvzS/Tltp5EE1thAKdgZ0m38AQ "JavaScript (Node.js) – Try It Online")
[Answer]
## Ruby, 41 bytes
```
n= 1
eval'puts"E";p	n;n=n+2; '*50;puts"E"
```
[Try it online!](https://tio.run/##KypNqvyfnJ@SamtjU/w/z1bBkCu1LDFHvaC0pFjJVcm6gDPPOs82T9vIWkFdy9TAGir@v5gLpEmvuKQos0CRiwskrAAWSS8uTVLQjynW11FQV1BHkkjOSCwq1stNLKiuSa5RSNbLL0pRNarVUoeo4QJbC1b5HwA) (with parity check)
This builds a string that contains the code to output `"E"` and `n`, then add 2 to `n`. Then it multiplies the string by 50 (repeating it 50 times) and `eval`s it. Finally, it prints the last `"E"` at the end.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 14 bytes
```
69H!Vo:E q"c@y
```
[Try it online!](https://tio.run/##y00syfn/38zSQzEs38pVoVAp2aHy/38A)
MATL uses ASCII encoding. The code points of the source code are
```
54  57  72  33  86 111  58  69  32 113  34  99  64 121
```
### How it works
```
69    % Push 69. This is the code point of 'E'
H     % Push 2
!     % Transpose: does nothing to 2
V     % Convert to string: gives '2'
o     % Convert to double: gives code point of '2', which is 50
:     % Range. Gives [1 2 ... 50]
E     % Multiply each element by 2. Gives [2 4 ... 100]
      % (Space:) Does nothing
q     % Subtract 1 from each element. Gives [1 3 ... 99]
"     % For each k in [1 3 ... 99]
  c   %   Convert to char. In the first iteration the top of the stack contains 69,
      %   which is converted into 'E'. In subsequent iterations the top of the stack
      %   contains 'E', which is left as is
  @   %   Push current k
  y   %   Duplicate from below: pushes another copy of 'E'
      % End (implicit)
      % Display stack, botom to top (implicit)
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~112~~ ~~105~~ 99 bytes
The code produces a string as in the example.
```
[ c|s<-"E 1 E 3 E 5 E 7 E 9 E"	:[ ' ':k:m:' ':	"E"	|k<-"123456789"	,m<-"1 3 5 7 9"	,m>' ' ],c<- s ]
```
I was not able to find a way to print an integer or convert it to string. This is why the solutions looks like this.
[Try it online!](https://tio.run/##y0gszk7NyflfXFKkYKsQ8z9aIbmm2EZXyVXBUMFVwRiITYHYHIgtFVyVOK2iFdQV1K2yrXKtQDSnElCsJhuo3tDI2MTUzNzCUolTJxfEB@o1BeoD8@2AahVidZJtdBWKFWL/5yZm5gEtKygtCS4p8slTANr9/19yWk5ievF/3QjngAAA "Haskell – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~15~~ ~~11~~ 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
т Ýxт>çÞ‡
```
-2 bytes thanks to *@Grimmy*.
Outputs as a list with lowercase `e`.
[Try it online.](https://tio.run/##yy9OTMpM/f//YpPC4bkVF5vsDi8/PO9Rw8L/Xv8B)
**Explanation:**
Shortest base version I could find was **~~8~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**: [`тÝx'EÞ‡`](https://tio.run/##yy9OTMpM/f//YtPhuRXqrofnPWpY6PX/PwA) (Outputs as a list with uppercase `E`.)
-1 byte thank to *@Grimmy*.
```
т        # Push 100
 Ý       # Pop and push a list in the range [0, 100]
  x      # Push a list with each value doubled (without popping the original list)
   'E   '# Push "E"
     Þ   # Pop and push an infinite list of "E": ["E","E","E",...]
      ‡  # Transliterate each doubled number to "E" in the original list
         # (after which this list is output implicitly as result)
       
```
The codepoints of this 7-byter are [`[15,221,120,39,69,222,135]` / `[1,1,0,1,1,0,]`](https://tio.run/##ASEA3v9vc2FiaWX//8W@xIZJU2s9w4ks///RgsOdeCdFw57igKE), which is already pretty good.
So I now have this:
```
т          # Push 100
           # No-op space
  Ý        # Pop and push a list in the range [0, 100]
   x       # Push a list with each value doubled (without popping the original list)
    т      # Push 100
     >     # Increase it by 1 to 101
      ç    # Convert this integer to a character with this ASCII codepoint: "E"
       Þ   # Pop and push an infinite list of "e": ["e","e","e",...]
        ‡  # Transliterate each doubled number to "e" in the original list
           # (after which this list is output implicitly as result)
```
This 9-byter has the codepoints: [`[15,32,221,120,15,62,231,222,135]` / `[1,0,1,0,1,0,1,0,1]`](https://tio.run/##ASUA2v9vc2FiaWX//8W@xIZJU2s9w4ks///RgiDDnXjRgj7Dp8Oe4oCh).
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 16 bytes
```
V101p? %N/T5NK\E
```
[Try it online!](https://tio.run/##K6gsyfj/P8zQwLDAXkHVTz/E1M87xvX/fwA "Pyth – Try It Online")
[Verify it online!](https://tio.run/##K6gsyfj/P1fVOcWo/P//MEMDwwJ7BVU//RBTP@8YVwA "Pyth – Try It Online")
Separated by `""`
## How it works:
```
V101p? %N/T5NK\E
V101                  - For 'N' in 0..100
     ? %N/T5        - If N modulo (10÷5) (or N%2) is truthy...
            N       - ...return N
             K\E    - Otherwise, return 'E' (K here is just a separator)
    p               - Print the result
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
³Ż¹⁾E Ḥ‘{$¦ K
```
[Code-points](https://github.com/DennisMitchell/jelly/wiki/Code-page): `[131, 210, 129, 142, 69, 32, 175, 252, 123, 36, 5, 32, 75]`
A full program, which given no arguments prints the result.
**[Try it online!](https://tio.run/##ASAA3/9qZWxsef//wrPFu8K54oG@RSDhuKTigJh7JMKmIEv//w "Jelly – Try It Online")**
(As a bonus given a non-negative integer argument it will print the sequence for that number, [e.g.](https://tio.run/##ASMA3P9qZWxsef//wrPFu8K54oG@RSDhuKTigJh7JMKmIEv///8xNg "Jelly – Try It Online"))
### How?
```
³Ż¹⁾E Ḥ‘{$¦ K - Main Link: no arguments
³             - literal 100 (if there are arguments provided, this is the 1st)
 Ż            - zero-range = [0,1,2,3,...,100]
  ¹           - identity (no-op)
          ¦   - sparse application...
         $    -   ...to indices: last two links as a monad:
      Ḥ       -      double = [0,2,4,6,...,200]
        {     -      use left argument as input to:
       ‘      -        increment = [1,3,5,7,...,201]
                     (note Jelly uses 1-based indexing)
   ⁾E.        -   ...what: literal character pair =  ['E', ' ']
           .  - no-op
            K - join with spaces
              - implicit, smashing print
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/) with `-trigraphs` flag, ~~161~~ 141 bytes
Thanks to WheatWizard for the validation script, which revealed that I mistakenly identified line endings as `CR` instead of `LF`! The fix didn't change the byte count, however.
To get this to even work, in addition to the many spaces and tabs, I used a macro that uses digraphs and token-pasting to generate the disallowed function names (`main` and `printf`). As Unix line endings are `LF` (decimal 10), I had to add a space at the end of the first line to continue the odd/even pattern. Saving some more space, I could coalesce `in` because the two letters fit the odd/even pattern.
[Parity verification](https://tio.run/##bVBNT8MwDD1nv@KpbFoissHGbR8CMbjBiQsSQlvaZmtEm5Q00zQQv324pWNC4mBbtt97fnKmqjed54eDKUrnA@5UUMNFpnynHSycDd7lw0dnVdoplLGYI3UdIKGNtqHCbICNDou2pU2uA2UgNqG64ZlW6a0Jk6UgZqFKcL4qXLrCWGAI51PxK9WwNk7lNZPQyT7JNV5aBYkRBmibV8JW@n2rbaKX6P5YAnhC3mV9WTZChBS1wQ9TXp0cN/LHOw3P67D19qQDlNvwFDxNqsztUMueFvWD0Ef/XyhptvNdpi049biYn9x0j/gIz9EfhQeLKDoczlK9NlZjz5VM5EYaCCj0Jr1J0mQGY@u6aTrTYfGUsIVUkkkGwQU@184zPgWL2Wx0OcI0ZvRNFp/TBwVhWUlITxEo1oKzuDe@jnopi9iERfegKlksMMXXNw "Haskell – Try It Online")
```
#define y(a,c,g,i ) a %:%:c %:%:	 in%:%:g %:%:i
	b; y(m,a,	,	 )() {for	(; 	b	<101 ;b	 = 	b+ 1 ) y(	p	,	r	,	t	,	f)(	b%2?"%d	"	:	"E 	"	,	b) ; }
```
[Try it online!](https://tio.run/##HYxBCsIwFETX4yk@kUCCv2BdNoorD5KkTQxoLWk3Rby6MXbxZhh4jG@i96Xs@yGkcaBVWfYcOZEmS7KTnd8SlMZ/x22lHZyp7pMtg0FaaXqHV4YyBIdze2zJONClrgO19WtVmKqZK0slaAUnT1chewh0EDeqzXCaDH1K@frwsHEuzZJTzHa6zz8 "C (gcc) – Try It Online")
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 32 bytes
```
>'D1+k$1:/$'D1+k$/2+:1.C(1+?.;8?
EOEOEOEOEOEOEOEOEOEOEOEOEOEOEOEO
```
[Try it online!](https://tio.run/##KyrNy0z@/99O3cVQO1vF0EpfBcLSN9K2MtRz1jDUtteztrD//x8A "Runic Enchantments – Try It Online")
`EO` sequence above just indicates whether each byte is even or odd.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
ØA 5ị¶ 101Ḷ× Ḃ$oÑK
```
[Try it online!](https://tio.run/##ASUA2v9qZWxsef//w5hBIDXhu4vCtiAxMDHhuLbDlyDhuIIkb8ORS/// "Jelly – Try It Online")
In the Jelly code page, these character have the byte values of
```
12 41 20 35 D8 7F 20 31 30 31 B2 11 20 BF 24 6F 10 4B
```
which follows the pattern `Even Odd Even Odd ...`
## How it works
Removing the extra spaces we get:
```
ØA5ị
101Ḷ×Ḃ$oÑK
```
which is:
```
ØA5ị       - Helper link: Yield "E"
ØA         - Yield the upper case alphabet
  5ị       - Take the fifth element ("E")
101Ḷ×Ḃ$oÑK - Main link: Yield "E 1 E 3 ... E 99 E"
101        - Yield 101
   Ḷ       - Lowered range:            [0, 1, 2, ..., 99, 100]
     Ḃ$    - Take the parity of each:  [0, 1, 0, ..., 1, 0]
    ×      - Multiply each together:   [0, 1, 0, 3, ..., 99, 0]
        Ñ  - Call the helper link:     "E"
       o   - Replace the 0s with "E"s: ["E", 1, "E", ..., 99, "E"]
         K - Join with spaces:         "E 1 E 3 ... E 99 E"
```
[Answer]
# [R](https://www.r-project.org/), 35 bytes
Thanks to ErikF for correcting a bug.
```
x=0	:{ 98+2} ;x[ c(	T	,!T) ] ="E";x
```
[Try it online!](https://tio.run/##K/r/v8LWgNOqWsHSQtuoVsG6IlohWYMzhFNHMURTIVbBVslVybri/38A "R – Try It Online")
Defines `x` as the vector of integers from 0 to 100, then replaces all the even values with `"E"` and outputs `x`.
Previous, quite different version:
# [R](https://www.r-project.org/), 42 bytes
```
for	(i in	 1:50) write(c(i*+2- 1,	"E"),1 )
```
[Try it online!](https://tio.run/##K/r/Py2/iFMjUyEzj1PB0MrUQFOhvCizJFUjWSNTS9tIV8FQh1PJVUlTx1BB8/9/AA "R – Try It Online")
Includes a few tabs instead of spaces. Uses newlines as separators.
`cat` and `print` are unusable, but luckily `write` is OK. I had to resort to `i*+2 -1` instead of `i*2-1` to keep the alternation.
[Answer]
# [Python 3](https://docs.python.org/3/), 65 bytes
```
exit	([ ["E"	,	j] [j%2]for	j	 in	 eval	('ran' +"g"+"e")(101 ) ] )
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P7Uis4RTI1ohWslViVOHMytWITpL1Sg2Lb@IM4tTITOPUyG1LDGHU0O9KDFPXUFbKV1JWylVSVPD0MBQQVMhVkHz/38A "Python 3 – Try It Online")
This submission was built on using tabs *and* spaces, as well as a Very Clever™ abuse of `eval`.
**Edit**: Fixed program to adhere to [restricted-source](/questions/tagged/restricted-source "show questions tagged 'restricted-source'") (I had an extra space by mistake).
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 18 bytes
I didn't expect such a small amount of whitespace ...
```
101,{.3(%\"E"if} %
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/39DAUKdaz1hDNUbJVSkzrVZB9f9/AA "GolfScript – Try It Online")
## Explanation
```
101,               # Generate range [0 1 2 ... 99 100]
    {          } % # Map every item using this scheme
     .             # Copy the item
      3(%          # Modulo by 3-1 (2)
         \         # If modulo-ing by 2 is truthy: return the item
          "E"if    # Otherwise, return "E"
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 20 bytes
```
"E"q♀{î♥☻/÷i¿{"E"}îq
```
[Try it online!](https://tio.run/##y00syUjPz0n7/1/JVanw0cyG6sPrHs1c@mjGbv3D2zMP7a8GCtceXlf4/z8A "MathGolf – Try It Online")
Very similar to the [FizzBuzz example](https://github.com/maxbergmark/mathgolf/blob/master/examples/fizzbuzz.mg). Uses the [MathGolf codepage](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py), can verify parity with [this script](https://tio.run/##PZJZTxNhGIXv@yvGcQEEQcEVxR33fV@qiLRAXdqCuCBiaq1jG3vRZd7pDCJ0oS1dREGW2NY0@d7Ey@l/OH@kVkO8O8lJnpzkPO7xsWGXs6teH3DZ7H3u/iG71CPJHINegl6GkYaRgZGCEYcniZiO2CfEDBheGB4YeRgF6BVoJcR8UAieilgVWWhFKPNQwlCiUCJQQvDPQlGhLUGrSBus8sZNm7c0NbdsbW3b1t6xfUdn185du/fs3de9X5asllZJPtBz8NDhI0ePHe89cfLU6TNnz52/cPHS5StXr12/cfPW7Tt3rdZ79/se9D8csNkHh4Ydjx4/eep0uUdGn409f/Hy1fjriTeTbxH08sd1Hlc4x0me4zinOct5LvA8f@MFLrKPP3CAM6zwMq/yEpf5J1dZ42mRFCmRhjf7O8IJ/so/uMSLHBZ5URJVBEOiKH6JikiIgihDC0OLQItC9UKdAyVASZAGIlAKFAbFQF9A06DPUENQVajLUItQp6F6oFZAM@tbQbOgKZAKyoEyoDgoBCqCsqB5UIOeBhkgHRQBRUEFUB6qDjUIzQ/NB60RQtA85iLPmtGax0zV3ouVms/MmLqZM5fhn6kp5gr8OQQSYhGBNAJzCMYRTPAaAn7xHX5DrME/hXdV0TgtzjOyxTLoGpUcksMpyVa51yqPNByY4IW/kujlDl5ziOrEv2KSF0bkbovkHnU4x5r/m9U@6HDamh0tmzvb7E5bT1NTS73@Bw).
```
"E"q                # Push and output "E"
    ♀               # Push 100
     {              # Loop from 1 to 100
      î             # Push loop counter
       ♥☻/          # Push 32, 16, and divide (basically pushes 2)
         ÷          # Is the loop counter divisible by 2?
          i         # Convert to integer (does nothing)
           ¿{"E"}   # If so, push "E"
                 î  # If not, push the loop counter
                  q # Output
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
101Ḷ¹⁾E Ḃ ?€Ḣ€K
```
[Try it online!](https://tio.run/##y0rNyan8/9/QwPDhjm2Hdj5q3Oeq8HBHk4L9o6Y1D3csApLe//8DAA "Jelly – Try It Online") [Try it online with parity!](https://tio.run/##y0rNyan8/9/QwPDhjm2Hdj5q3Oeq8HBHk4L9o6Y1D3csApLe/w/P8Mp8tHHdo4aZQJmHO/cBBXXCHjXMCUgsyiyptFIAMoNSi0tzSkDMuUf3ROI3DwA "Jelly – Try It Online")
A full program that takes no argument and prints the desired output. The footer demonstrates both the parity and result. 
[Answer]
# [Ruby](https://www.ruby-lang.org/), 50 bytes
Adaptation of the [Python answer](https://codegolf.stackexchange.com/a/197229/52194). Unlike Python, however, Ruby `puts` is valid code to use for output, eliminating the need for `exit` hacks.
I didn't want to do a direct port, but `map`, `each`, `upto`, and `times` are all forbidden by the spec...
```
x=0;(	puts ["E"	,	x] [x%2] ;x=x+ 1 ) while 	x	<101
```
[Try it online!](https://tio.run/##KypNqvz/v8LWwFqDs6C0pFghWslViVOHsyJWIbpC1ShWwbrCtkJbwVBBU6E8IzMnVYGzgtPG0MDw/38A "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 15 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ò#d_v) ?"E"):»Z
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8iNkX3YpID8iRSIpOrta)
```
ò#d               range [0-100]
   _              passed through
    v) ?          divisible by 2?
        "E"):»Z   replace with 'E' else replace with number
```
[Layout](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVE&code=cSBtYw&input=IvIjZF92KSA/YkViKTq7WiI)  : [242,35,100,95,118,41,32,63,98,69,98,41,58,187,90]
[Answer]
# [Haskell](https://www.haskell.org/), 296 bytes
```
w = k 1
a(c:e ) = c
i =(id)
e a =(a:)
m 1 =(a"1")
m 3 =(a"3")
m 5 =(a"5")
m 7 =(a"7")
m 9 =(a"9")
m c|c<1 = '0'|c<3 = '2'|c<5 = '4'|c<7 = '6'|c<9 = '8'
m c =(m$c - 10)
q 1 =0;
q c|m c<a"1"= 1 + q(c - 1 )
q c = q$c - 1
k c|c>98= e(a"E")$e(a"9")$e(a"9")$i"E";
k c = e(a"E")$e(m$q c )$e(m c )$k$c +2
```
[Try it online!](https://tio.run/##Tc7BCoMwDAbge58iiKBFBlbntGp32xPsCUpXmKhjbg4vvrtLIoyd8rVN0v9u370fhm1bwEAPStjY1R4knpzowMTdTQoPFmVrKUZQpEAF5Jydswt2wS7ZJVuzNdutrsV5iNIIlZMyUkE6kkrSiaRJVURTuGEMHRxApVJMlCBtsLoV31rKYvAugSnmHqAenIFpnxE9/XvWlQGPSS6BDP2e6Fc7vG2oD/57xpD2sLj2uC/JttF2D/P8zNf5Bcv2BQ "Haskell – Try It Online")
This was pretty hard since `show` and `print` are both unusable, so I had to convert integers to strings on my own.
[Answer]
## [W](http://github.com/a-ee/w) `z`, 19 bytes
```
10#0#.a2m a&#"E"#|M
```
Pretty much the same as below. `100.a2ma&"E"|M` The only difference is the 0-range (which does no good for the program).
## W, 19 bytes
```
101 a2m"E"#&a 1 -|M
```
## Explanation
Pretty simple: `#` and  are both readability characters here and have no result on the stack.
```
101a2m"E"&a1-|M
```
```
101           M % Foreach the range 1 -> 101
   a2m          % Modulo the current item by 2
      "E"&      % If true, return "E" (Because odd-1 -> even)
          a1-|  % Otherwise, return a-1
```
[Answer]
# PowerShell, 72 bytes
```
for`t(`t`$i =0;`$i -le 101 - 1 ;`$i =`$i + 1 ) {`$ab=(' e ',`t`$i ) ;`$ab[`$i %2] }
```
For testing:
```
$a = "for`t(`t`$i =0;`$i -le 101 - 1 ;`$i =`$i + 1 ) {`$ab=(' e ',`t`$i ) ;`$ab[`$i %2] }"
# Even/odd ok?
0..($a.Length-1) | % { [char]$a[$_] + "  " + ([byte][char]$a[$_] % 2)}
$a.Length
Invoke-Expression $a
```
Missed the even-odd part in the code, thanks for pointing it out!
[Try It Online](https://tio.run/##K8gvTy0qzkjNyfn/XyVRwVZBKS2/KKFEI6EkQSVTwdbAGkTp5qQqGBoYKugqGCqABWxBhDaQp6lQnaCSmGSroa6QqqCuA9GlCVKUmBQNYqsaxSrUKnF55pXlZ6fqulYUFKUWF2fm5ymoJP7/DwA)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal/tree/version-2) `HM`, 5 bytes
```
r⁽\EẆ
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyJITSIsIiIsInLigb1cXEXhuoYiLCIiLCIiXQ==)
This works in both the Vyxal codepage and UTF-8. -2 thanks to pacman256.
The `H` flag can be removed if you place a `₁` at the start, although it only works with UTF-8 then.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~24~~ 18 bytes
```
Ｆ¹⁰¹«¿⊗﹪⊕ι²E↥Ｉ⌈ι⁰→
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBw9DAUFOhmoszM01BwyW/NCknNUXDNz@lNCdfwzMvuSg1NzWvBCiUqamjYKSpqakQUJSZV6Kh5Kqkaa2QmlOcCtLLCRF0TiwGEqmZOZl56UANmprWcCkDELuWC5nnm1@WqmEVlJmeUQLk1v7//1@3LAcA "Charcoal – Try It Online") Link is to verbose version of code. Here are the 18 hex codes in Charcoal's code page:
```
C6 B1 B0 B1 A8 BF 9E A5 9C E9 B2 45 18 C9 1A A9 B0 13
```
Explanation:
```
Ｆ¹⁰¹«
```
Loop from 0 to 100.
```
¿⊗﹪⊕ι²
```
Test whether the index is even. The index is incremented to comply with the source code restriction, which reverses the sense of the test. The result of the test is doubled to comply with the source code restriction, but this doesn't change the outcome of the decision.
```
E
```
If the number was even then output an `E`.
```
↥Ｉ⌈ι
```
Otherwise take the ceiling of the number to comply with the source code restriction, cast the result to string, and uppercase the result to comply with the source code restriction.
```
⁰
```
Print 0 `-`s to comply with the source code restriction.
```
→
```
Leave a space between successive outputs.
Note: If a trailing space is acceptable, then the last two characters can be replaced with a space for 17 bytes, although there are alternative solutions, such as this:
```
Ｆ¹⁰¹«¿⊗﹪⊕ι²E ⁺⌈ι 
```
[Try it online!](https://tio.run/##LcqxCsJADADQ2X5FuCkBBevasTp0KPQX6jXVQHqBa89F/PZYxPXx4nPM0UZ1ny0D1uea4F0dZAa8WrkrT9jbVNSwSzHzwmnbSegIFyKCIUvaMNwgUAOsK/9l0LJiy6KSHr8d9kFN9XH300u/ "Charcoal – Try It Online") Link is to verbose version of code. Here are the 17 hex codes in Charcoal's code page:
```
C6 B1 B0 B1 A8 BF 9E A5 9C E9 B2 45 20 AB 1A E9 20
```
Explanation: Much like the above, except that in the even case we directly include the space in the literal while in the odd case the ceiling of the number is concatenated with a space.
[Answer]
# [Zsh](https://www.zsh.org/), ~~50 30~~ 34 bytes
*Bug fix: I was checking each pair of letters to make sure it had a character of each parity, instead of ensuring it alternated.*
```
"e"cho E"	"{"1"'.'.9"9"'.'.'0'2} E
```
~~[Try it online!](https://tio.run/##RU5LCsIwFFybUwyvkSbUjRURaysKtiAIXkCEfiJd@cS46ufsMV2Iuxnm29nW1eUHe9h3jTRFmF@L0JVVppZYYY0NttCCDNUtI7/NZH8vq/GPftz5nBCdbaciIR78hgFDkezVwSaJJqlSL2kaSe/QsFDqxTbK4gVUYBAhYI05Yq0xDDDTHBXH8yU/wf@T3ptAGskkGn4a9wU "Zsh – Try It Online")
[Try it online!](https://tio.run/##FY7LCsIwFETX5iuG20gSKgW7a62iYAqC4DdIm5KVVxpXfXx7TDezmXOYmYKP3fuHC8LYoWmg7KtVkRx1nmFpRzMdSRWqqKoUpVphY0KEmILfHCEGHuHA0CRnfQ11bUjqJlWGVjIn9Cy0/nLIz@UBOnPIkbHBHqUxWBa4bYna2@Np70hXZGJrSCeZRM8fF/8 "Zsh – Try It Online")~~
[Try it online!](https://tio.run/##NY7BCoJAGITP/U/x82vuroGoN82iIIWg6AHEg6zGnlpwOyn77NsqdJph5huY2Sgn@y@e0UwSqwpZ/WqYo5Gk0ljTjhbKiCUsKajYlKUst1g7zwHMRq1DgLeeUKp@Qk7hwi@mLAWFvPKdIEviiIMGczj5jAcbt8dcCIJBf0aAtkW/egoTxGka27/Psthi12EU4bjeaa73R31zPw "Zsh – Try It Online")
Self-tests. Contains a literal tab.
~~I couldn't figure out a way to finagle the most straightforward `echo E\ {1..99..2} E` into anything, mostly due to the double period.~~ EDIT: I did it. Turns out in normal expressions, quotes inside brace ranges don't really matter.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 16 bytes
```
1 +2	*	,50	JW"E"
```
[Try it online!](https://tio.run/##K8gs@P/fUEHbiFOLU8fUgNMrXMlV6f9/AA "Pip – Try It Online")
Outputs without separators.
Spaces and tabs are no-ops, so this boils down to:
```
    ,50       Range(50)                                               0, 1, ..., 49
  2*          Multiply each by 2                                      0, 2, ..., 98
1+            Add 1                                                   1, 3, ..., 99
       JW"E"  Join with "E", wrapping the outside with "E"s as well   E1E3E...E99E
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-p`, 55 bytes
```
} {do {$_.=$- %2?$-.' ':q(E ) } while(+$- =$- + 1 )<101
```
[Try it online!](https://tio.run/##K0gtyjH9/79WoTolX6FaJV7PVkVXQdXIXkVXT11B3apQw1VBU6FWoTwjMydVQxsoB5LXVjBU0LQxNDD8//9ffkFJZn5e8X/dAgA "Perl 5 – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 13 bytes
```
101rm2% _"E"?
```
[Run and debug it](https://staxlang.xyz/#c=101rm2%25+_%22E%22%3F&i=&a=1)
The program has these ASCII codes.
```
49 48 49 114 109 50 37 32 95 34 69 34 63
```
[Answer]
# [Ly](https://github.com/LyricLy/Ly), ~~36~~ 34 bytes
```
"E"' _&s&o '2_R_r_p[:+,u>' _l_&o<]
```
[Try it online!](https://tio.run/##y6n8/1/JVUldIV6tWC1fQd0oPii@KL4g2kpbp9QOKJoTr5ZvE/v/PwA "Ly – Try It Online")
At a high level, this one works like this...
* print the initial `E`
* generate the sequence `1..49`
* loops over that list printing the `N*2-1` plus `E`
Here's the decimal codepoints for the source:
```
34 69 34 39 32 95 38 115 38 111 32 39 50 95 82 95 114 95 112 91 58 43 44 117 62 39 32 95 108 95 38 111 60 93
```
The code uses a couple of Ly specific tricks to achieve the even/odd sequence. First spaces can be added most places and are ignored, which allows for an "even" no-op. And `_` (underscores) work as "odd" no-op's the same way. Finally, quoting characters can be done using double quotes (even) or as a series of single characters after single quotes (odd).
And the gory details:
```
"E"'                               - push "E " on stack
     _&s                           - stash a copy of the stack
        &o                         - print "E "
         '2                        - push 50 on the stack  
             _R                    - gen seq 0..49
               _r                  - reverse stack
                 _p                - pop 0 (first entry) off stack
                   [             ] - loop while stack not empty
                    :+,            - calc: <TOP>*2-1
                       u           - print as number
                        >          - switch to new stack
                         '         - push space
                           _l      - push "E " from stashed stack
                             _&o   - print stack
                                <  - switch back to original stack
```
]