[Question]
  [
Your task is to display the letter "A" alone, without anything else, except any form of trailing newlines if you cannot avoid them, doing so in a program and/or snippet. Code that returns (instead of printing) is allowed.
Both the lowercase and uppercase versions of the letter "A" are acceptable (that is, unicode [U+0061](http://www.fileformat.info/info/unicode/char/0061/index.htm) or unicode [U+0041](http://www.fileformat.info/info/unicode/char/0041/index.htm). Other character encodings that aren't Unicode are allowed, but either way, the resulting output of your code must be the latin letter "A", and not any lookalikes or homoglyphs)
You must *not* use any of the below characters in your code, regardless of the character encoding that you pick:
* "*A*", whether uppercase or lowercase.
* "*U*", whether lowercase or uppercase.
* *X*, whether uppercase or lowercase.
* *+*
* *&*
* *#*
* *0*
* *1*
* *4*
* *5*
* *6*
* *7*
* *9*
Cheating, loopholes, etc, are not allowed.
Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest solution, in bytes, that follows all the rules, is the winner.
---
### Validity Checker
This Stack Snippet checks to make sure your code doesn't use the restricted characters. It might not work properly for some character encodings.
```
var t = prompt("Input your code.");
if (/[AaUuXx+&#0145679]/.test(t)) {
  alert("Contains a disallowed character!");
} else {
  alert("No disallowed characters");
}
```
*This Stack Snippet that makes sure you don't have a disallowed character is also available on [JSFiddle](https://jsfiddle.net/or1rjega/1/).*
### Leaderboard
```
var QUESTION_ID=90349,OVERRIDE_USER=58717;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&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(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.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(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <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><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><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
## Python 2, 14 bytes
```
print`3<3`[~3]
```
The expression `3<3` gives the Boolean `False`, and the backticks give its string representation `'False'`. From here, it remains to extract the letter `a`. Python is 0-indexed, so the `a` is at index `1`, which is a banned character. It can be expressed as `3-2`, but there's a shorter way. Python allows indexing from the back, with index `-1` for the last entry, `-2` for the one before it, and so on. We want index `-4`, but `4` is also a banned number. But, we can express it as `~3` using the bit-complement `~`, which gives `-n-1` for `~n`.
[Answer]
# Pluso, 1 byte
```
o
```
[Pluso Esolangs Page](https://esolangs.org/wiki/Pluso).
Pluso contains a single accumulator, that starts with the value 1. It uses two commands, **p** which increments the accumulator (mod 27), and **o** which prints the current value as an uppercase ASCII character, A-Z or space (where 1-26 represents A-Z respectively, and 0 represents space).
As the accumulator starts at 1, the command **o** with no prior **p** will output **A**.
[Answer]
# Pyth, 2 bytes
```
hG
```
Test it in the [Pyth Compiler](https://pyth.herokuapp.com/?code=hG&debug=0).
### How it works
```
 G  Yield the lowercase alphabet.
h   Extract the first character.
```
[Answer]
# PHP, ~~9~~ 6 bytes
```
<?=O^_^Q;
```
For 9 bytes: Inspired by [@Ton Hospel's answer](https://codegolf.stackexchange.com/a/90371/58556). Plus, it has the added benefit of looking a bit like a Kaomoji. :-)
The 6 bytes improved version:
```
<?=~¾;
```
wherein ¾ has the hex code of 0xBE (it is important to save the file in [Latin-1 encoding](https://en.wikipedia.org/wiki/ISO/IEC_8859-1), *not* UTF-8!).
[Answer]
## 05AB1E, ~~3~~ 2 bytes
```
Th
```
**Explanation**
```
T   # push 10
 h  # convert to hex
```
[Try it online](http://05ab1e.tryitonline.net/#code=VGg&input=)
Saved 1 byte thanks to Adnan
[Answer]
# JavaScript (ES6), ~~17~~ ~~16~~ 14 bytes
*Saved two bytes thanks to Neil!*
```
_=>` ${-_}`[2]
```
Returns the second character of `NaN`, which is `a`.
This is the shortest I could come up with for `A`, ~~43~~ 42 bytes:
```
_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]
```
Who says being an obfuscator doesn't help with code golf? Not I!
## Explanations
The first one, in depth.
```
_=>` ${-_}`[2]
```
`-_` is NaN, because `_` is undefined. To get this as a string, one would need one of the following:
```
-_+""
`${-_}`
(-_).toString()
```
The last is too long, and the first uses `+`. So we use the second one. Now, the `a` is at index `1`. This isn't any good, because `1` is forbidden. However, being a template string, we can put a space in there to make it at index `2`, thus leaving us with `` ${-_}``.
---
The second one, in depth.
```
_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]
```
This one was a doozy.
```
_=>`                                `[-~8]
```
This is the 9th character of the inside template string, `-~8` being equal to 9. In this case, this template string is just for stringification. This is the inside equation being stringified, in between `${...}`:
```
[][`constr${`${!_}`[2]}ctor`]
```
Let's expand this a bit:
```
(new Array())[`constr${`${!_}`[2]}ctor`]
```
This gets the property ``constr${`${!""}`[2]}ctor`` from an empty array. This property is, of course, a template string, but it has some text around it. It's roughly equivalent to:
```
"constr" + `${!_}`[2] + "ctor"
```
The inside is in turn equivalent to:
```
(!_).toString()[2]
```
`!_` is `true` (because `_` is `undefined`, and `!undefined === true`), and stringified is `"true"`. We get the second character of it, `u`; we have to get it this way to avoid explicitly putting `u` in our code.
So, this inside bit is equivalent to:
```
"constr" + "u" + "ctor" === "constructor"
```
So we are getting the constructor of the Array, the `Array` function. I couldn't put this down explicitly because it contains the forbidden `A`. Now, stringifying the `Array` function yields `"function Array() { [native code] }"`.
Back to the original code:
```
_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]
```
This is equivalent to, as we've seen:
```
_=>Array.toString()[-~8]
```
Equivalent to:
```
_=>Array.toString()[9]
```
Finally equivalent to:
```
_=>"A"
```
[Answer]
# [Hexagony](http://github.com/mbuettner/hexagony), 4 bytes
Ayyy lmao? Quite golfy for a non-golfing language haha. Code:
```
B(;@
```
[Try it online!](http://hexagony.tryitonline.net/#code=IEIgKAo7IEAgLgogLiAu&input=)
A more readable form:
```
 B (
; @ .
 . .
```
This puts the ASCII value of the letter `B`, which is 66, on the current memory edge. It substracts it by one using `(` and prints it with `;`. After that, the program is terminated using `@`.
Obligatory path image:
[![enter image description here](https://i.stack.imgur.com/NAlZ2.png)](https://i.stack.imgur.com/NAlZ2.png)
[Answer]
# brainfuck, 16 bytes
```
-[-[---<]>>-]<-.
```
This is based on [Esolang's brainfuck algorithm for 159](https://esolangs.org/wiki/Brainfuck_constants#159).
[Try it online!](http://brainfuck.tryitonline.net/#code=LVstWy0tLTxdPj4tXTwtLg&input=)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ØWḢ
```
[Try it online!](http://jelly.tryitonline.net/#code=w5hX4bii&input=)
### How it works
```
ØWḢ  Main link. No arguments.
ØW   Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_".
  Ḣ  Head; extract the first character.
```
---
# Jelly, 4 bytes
```
l-ṾṂ
```
[Try it online!](http://jelly.tryitonline.net/#code=bC3hub7huYI&input=)
### How it works
```
l-ṾṂ  Main link. No arguments.
l-    Take the logarithm of 0 with base -1. Yields (nan+infj).
  Ṿ   Uneval; yield the string representation, i.e., "nanıinf".
   Ṃ  Take the minimum, returning 'a'.
```
[Answer]
# CJam, 3 bytes
```
'@)
```
[Try it online!](http://cjam.tryitonline.net/#code=J0Ap&input=)
### How it works
```
'@   Push the character '@' on the stack.
  )  Increment its code point, yielding 'A'.
```
[Answer]
# [Actually](http://github.com/Mego/Seriously), 2 bytes
```
úF
```
[Try it online!](http://actually.tryitonline.net/#code=w7pG&input=)
Explanation:
```
úF
ú   lowercase English alphabet
 F  first element
```
[Answer]
# Ruby, ~~15~~ 12 bytes
```
$><<to_s[-3]
```
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 1 byte
```
"
```
or
```
B
```
Everyone seemed to forget it existed...
[Answer]
# Java, 55 bytes
```
void f(){System.err.write('c'-2);System.err.println();}
```
Since the code has to print it, one of the two built-in writers are required. `System.out` is, well, out, because it contains `u`. `System.err` works, however.
The next hurdle is Java's handling of `char` and `int`. Since it is not allowed to cast to `char` because it contains `a`, and because `'c' - 2` gets promoted to `int`, another mechanism is required. `System.err` is a `PrintWriter`, which has a `write(char)` method but not `write(int)`. Putting `'c' - 2` in there forces it to `char` without a cast.
Finally, every time I ran the program the buffer for `System.err` would not flush like it is supposed to, and the program printed nothing. So I had to flush it manually. However, `System.err.flush()` is not allowed, so I called `println()` which implicitly flushes the underlying stream.
[Answer]
## Vim, 2 Keystrokes
`vim -u NONE` then run the following (`-u NONE` turns off customization)
```
i<up>
```
When vim is run in compatible mode the arrow keys are don't get interpreted properly. `<up>` gets interpreted `<esc>OA` which leave the following in insert mode. Which would leave (with a couple of trailing newlines)
```
A
```
`i` starts insert mode.  
`<up>` exits insert mode, opens a line above and enters A into the buffer
Example of people encountering this in the wild. <https://stackoverflow.com/questions/6987317/while-moving-the-cursor-across-a-vim-process-open-in-a-tmux-session-every-now-a/6988748#6988748>
[Answer]
# Perl, ~~9~~ 8 bytes
xor is still allowed, but `say` isn't. So for 9 bytes:
```
print$/^K
```
However using output to STDERR gives 8 bytes:
```
die~"\x9e\xf5"
```
Replace `\x9e` and `\xf5` by their literal versions. Or generate the executable file using:
```
perl -e 'printf q(die~"%s"),~"a\n"' > a.pl
```
[Answer]
## [><>](http://esolangs.org/wiki/Fish), 6 bytes
```
'|;o-$
```
this creates a string of characters, bounces and creates it again in reverse, flips the top 2 stack items and subtracts:
'|' (124) minus ';' (59) is 'A' (65)
[Try it online](https://fishlanguage.com/playground/caqNePn7yk34hzWpY)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~7~~ 4 bytes
Saved 3 bytes thanks to *Teal pelican*
```
"-o.
```
[Try it online!](https://tio.run/##S8sszvj/X0k3X@//fwA "><> – Try It Online")
**Explanation**
```
"-o."   # pushes the string "-o."
-       # subtracts the charcode of o from the charcode of . (dot), 111-46=65
o       # prints as character
.       # tries to pop 2 coordinates to jump to, but as nothing is left on the stack
        # the program ends in an error
```
[Answer]
# MATL, 5 bytes
```
YNVH)
```
[**Try it Online**](http://matl.tryitonline.net/#code=WU5WSCk&input=)
**Explanation**
```
YN      % Creates a NaN value (not a number)
V       % Convert it to a string
H)      % Grab the second letter ('a')
        % Implicitly display the result
```
---
My original answer was the straight forward approach using the pre-defined literal `lY2` which yields `'A'...'Z'` and then selecting the first element, `'A'`.
```
lY2l)
```
[Answer]
# Javascript, ~~18 bytes~~ ~~16 bytes~~ ~~12 bytes~~ 11 bytes
```
` ${!2}`[2]
```
Based on modified [jsfuck](http://www.jsfuck.com/) basics (had to figure out how to replace `+` with `-`).
### Ungolfed?
Well, at least a version with comments (note that this version will probably not run):
```
` ${      // whitespace to make "a" the third letter
  !2      // returns false
}`        // convert to string "false"
[2]       // index the third letter in " false" (note the whitespace)
```
Old solution:
```
`${![]}`[-(-!![])]
```
[Answer]
## JavaScript (ES6), 21 bytes
```
_=>(8^2).toString(22)
```
I originally tried converting `false` to string to do this, but it took me 23 bytes at the time. I've since come up with a shorter way, which is this for 14 bytes:
```
_=>`!${!2}`[2]
```
I don't think you can get an uppercase `A` under the rules, since you need one of `String.fromCharCode` or `.toUpperCase()`, both of which contain `a`.
[Answer]
# Vim, ~~16 13 11~~ 10 keystrokes
Thanks to H Walters for saving two keys
Thanks to DJMcMayhem for saving another!
```
:h%<cr>jvyZZp
```
```
:h%<cr> #open help for percent
jvy     #move down one char (to the letter "a"), visual mode the character, yank
ZZ      #exit help for percent
p       #put yanked character
```
[Answer]
## R, ~~27~~ 12 bytes
**EDIT :** New version, from an excellent idea from @Jarko Dubbeldam
```
LETTERS[T*T]
```
---
Quite a funny challenge !
Basically, this takes the `26th` element of the reversed vector containing the uppercase letters (`LETTERS`, which is a **R**'s built-in vector)
*Previous version**s*** (same number of bytes) *:*
```
L=LETTERS;rev(L)[length(L)]
rev((L=LETTERS))[length(L)]
```
[Answer]
# Brainfuck, ~~192~~ 19 bytes
```
----[>---<----]>--.
```
Thanks to @NinjaBearMonkey for helping me save hella bytes
~~`-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.`~~
~~I'm not good at Brainfuck so I'm sure theres a shorter solution, but it works by decrementing below 0, rolling the byte over, and keep going until it gets down to 'A', then it prints.~~
[Answer]
## Lua, 36 bytes
This one took me a while since MANY of the standard Lua functions are taken away from the rules (all of `math`, `string.char`, `string.match`, `pairs`, even `next`)
This takes advantage of the fact that Lua has a global `_VERSION` that usually starts with "Lua" (e.g., `Lua 5.1`, or similar for other versions), so unless this is run on a non-mainstream interpreter, the third character will be an 'a'
```
print(({_VERSION:find("..(.)")})[3])
```
The `{...}[3]` is to group the results of `find` which also includes the indices where it matched, and then return the third item which is the matched character (the `a`)
[Answer]
# C, (19?) 24 bytes
Thanks to Dennis:
```
f(){printf("%c",88-23);}
```
same length:
```
f(){printf("%c",'C'-2);}
```
which enables also lowercase:
```
f(){printf("%c",'c'-2);}
```
There is a **19 bytes** solution as a function modifying its parameter, which has a flaw:
```
g(int*p){*p='C'-2;}
//Usage:
main(){
  int c; //cannot be char
  g(&c);
  printf("%c\n",c);
}
```
If `c` was declared `char`, `g` modifies the whole `int` so it smashes the stack which causes other values to be modified or the programm to abort with an error message. The only way to circumvent is to declare `int c;` in `main` and print with `"%c"`, but that feels like a loophole.
### older solutions
```
f(){printf("%c",'B'-2/2);} //26 bytes
f(i){i='B';printf("%c",--i);} //29 bytes
f(){int*i="B";int j[]={*i-(2/2),2-2};printf("%s",j);} //53 bytes
```
Just a function, since `main` is forbidden.
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 4 bytes
```
@Ztw
```
[Try it online!](http://brachylog.tryitonline.net/#code=QFp0dw&input=)
### Explanation
```
@Z      The string "zyxwvutsrqponmlkjihgfedcba"
  tw    Write the last element to STDOUT
```
[Answer]
# Vim, 6 bytes
`grNg??`
Challenge doesn't block `N`, and Vim has a ROT-13 feature. [FDinoff's answer](https://codegolf.stackexchange.com/a/91374/60590) is probably cooler, but this is ASCII and works everywhere.
[Answer]
# Haskell, 10 bytes
As a function (or rather a statement as no input is required)
```
f=pred 'B'
```
does the trick. [Try it on Ideone.](https://ideone.com/XmWsHQ)
A full program is impossible as this would need to contain a `main`.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix/), 5 bytes
```
o'@)^
```
[**Try in the online interpreter!**](http://ethproductions.github.io/cubix/?code=bydAKV4=&input=&speed=5)
Cubix is a language where (as the name implies) everything is executed on the faces of a cube. This code maps to the following cube:
```
  o
' @ ) ^
  .
```
The basic idea of this answer is to get a nearby character and increment it to what we need. In Cubix, `@` is the exit command needed to terminate the program, but also conveniently right under 'A' in the ASCII table. This means we can use the character once to mean two different things, saving bytes - here's the order in which the code is run:
* `'@` pushes the character code 64 to the stack.
* `)` increments the top of stack, yielding the desired character.
* `^` sends the instruction pointer north, wrapping around to...
* `o` outputs the top of stack, `A`.
* `@` terminates the program.
]