text:
The Letter A without A
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 or unicode U+0041. 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, 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.
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="
"+e.body.replace(OVERRIDE_REG,"")+"
")});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;/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}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

@ColdGolf You seem to be saying "yes" to functions, but functions don't display, they usually return.

Is ending up with a variable that contains just a also good enough ?

That's not what I meant. The supposed code doing a variable assignment would not contain any of the forbidden characters. I'm just trying to understand what is covered by "display by means other than printing". If "return from a function" is OK, what about "assign to a variable" ?

I was going to post an answer in detour, then I realized the only cell that can print strings is u. :/

Why those particular characters?

@immibis A for obvious reasons. U for Unicode escape strings (\u0041 is A), X for hex escape strings (\x41), + for Unicode ordinals (U+0041), & for HTML entities, # for I actually don't know, 65 is the decimal ordinal of A, 41 is the hex ordinal of A, 97 is the decimal ordinal of a, and 0 for a few of the previous reasons.

@Mego don't forget the number "10" cast into hex is "A". --> %x, -~9

Aww, impossible in Shakespeare Programming Language because you have to declare Acts

I enjoy the rule 'cheating is not allowed'.

This may have been covered, but why is the numeral 8 allowed?

Pluso, 1 byte
o

Pluso Esolangs Page.
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.

Welcome to PPCG! I would recommend putting the explanation in your answer, in case the link dies for whatever reason.

Explanation added. Waiting for moderator approval.

Thanks for the recommendation (and the welcome), I have updated my answer to include a brief explanation.

I just upvoted to put you at 666 rep. Sorry about that.

Doesn't this fail the "is an esolang" test because it can't do primality checking?

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.

That's a really cool solution. Also, couldn't you do [2] instead of [~3]?

@DJMcMayhem It's 0-indexed unfortunately, it would need [1].

... why are 1 and 4 'banned' numbers??

The challenge's rules say so.

@ChrisCirefice As to why they're banned my guess is to rule out just using the ascii representation of A or a.

@Dason Whoops I guess I didn't read the problem description well enough... I thought the language didn't allow them!

I'm now even considering using "~0" being read as "zero indexed first element from the back".  I wonder why we would use "-1" notation in Python....

@PascalvKooten Because a negative integer literal is faster than negating a number. Premature optimization all the way.

@mbomb007 Indeed, so that's not the real reason. I think this is one of the most elegant codegolfing solution.

I. am. stunned.

Pyth, 2 bytes
hG

Test it in the Pyth Compiler.
How it works
 G  Yield the lowercase alphabet.
h   Extract the first character.

The pyth compiler doesn't seem to be working at all at the moment, might want to change it to a try it online link

@EdgyNerd I find it a bit ironic that you sent this comment to Dennis, the creator of the Try it Online site

PHP, 9 6 bytes
<?=O^_^Q;

For 9 bytes: Inspired by @Ton Hospel's answer. 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, not UTF-8!).

An alternative version is f^E^b.

Yes, the 9-byte solutions are abundant. I started with y^'8' and x^'9', unfortunately numbers have to be cast to string or it will XOR the resulting type will be an integer.

+1 for the face ^_^

The 6 Byte version doesn't print A. It prints =A.

@UTF-8: How so? I tested it with PHP 5.6.12 as well as PHP 7.0.3, it only outputs "A". The <?= is the shorthand for <?php echo, then there's a bitwise negation operator and the character 0xBE, followed by the necessary semicolon. Where should = come from? Can you show me how to reproduce what you're getting?

I tested it on the command line. Take a loot at this screenshot. http://phpfiddle.org yields the same result (screenshot). I'm using PHP 7.0.8, btw. Maybe it's different with PHP 5.

You're right, I can reproduce it on my Linux system while the Windows version doesn't output =. I will look into that.

I know the answer to this riddle now: In UTF-8 the "fraction three quarters" codepoint is encoded as two bytes: 0xC2 0xBE, 0xBE being the same as in ISO-8859-1. I noticed that when I saved this to a file on my linux box, which I access via SSH with UTF-8, of course, that the file is 7 bytes. So, save the script with Latin-1 encoding and it will be 6 bytes and not output the = character.

Let´s have a R^B^Q :D

The guy is called UTF-8

@Joao-3 It doesn't really matter but I can't for the life of me understand what this comment is supposed to mean

05AB1E, 3 2 bytes
Th

Explanation
T   # push 10
 h  # convert to hex

Try it online
Saved 1 byte thanks to Adnan

Th for two bytes :)

@Adnan Oh of course. Hex :)

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"

@ColdGolf It's alright.

-_ saves you two bytes.

@Neil nice, one, thanks!

Would it be against the principles of an obfuscator to add an explanation...? I'm curious about how this works.

@trichoplax I suppose it wouldn't hurt to reveal my methods here ;) I added an explanation for both.

Can't you just do the first code then .toUpperCase()?

@OldBunny2800 No. a is a forbidden character, and is in toUpperCase.

Oh , stupid me.

I thought this was Perl at first.

Since the question didn't say anything on how it's presented, you could remove the function declaration and replace _ with {}, saving 2 bytes: \ ${-{}}`[2]`

@Unity3D your answer assumes a repl environment. Otherwise, it is neither returned nor displayed.

Hexagony, 4 bytes
Ayyy lmao? Quite golfy for a non-golfing language haha. Code:
B(;@

Try it online!
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:

"more readable" + hexagony = ???

brainfuck, 16 bytes
-[-[---<]>>-]<-.

This is based on Esolang's brainfuck algorithm for 159.
Try it online!

This.... this is wizardry.

This solution uses the cell at index -1, which isn't supported across all brainfuck interpreters and would result in a crash.  You can run it here to see
https://fatiherikli.github.io/brainfuck-visualizer/#LVstWy0tLTxdPj4tXTwtLg==

@Cody On PPCG, languages are defined by their implementation. As long as there is one interpreter that behaves as desired, it is a valid solution.

How hard was it for you to avoid the forbidden characters?

@HagenvonEitzen I had to dig a bit to find an algorithm that could avoid +. (the shortest way to print A would be >+[+[<]>>+<+]>.), but thanks to list of constants on Esolang, not too hard.

I got -[-[---<]>>-]<-. which is 19, nice algorithm though

Jelly, 3 bytes
ØWḢ

Try it online!
How it works
ØWḢ  Main link. No arguments.

ØW   Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_".
  Ḣ  Head; extract the first character.

Jelly, 4 bytes
l-ṾṂ

Try it online!
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'.

Too bad the second approach is longer. ._.

Thanks for including the second approach. It's beautiful

CJam, 3 bytes
'@)

Try it online!
How it works
'@   Push the character '@' on the stack.
  )  Increment its code point, yielding 'A'.

Actually, 2 bytes
úF

Try it online!
Explanation:
úF
ú   lowercase English alphabet
 F  first element

are you the author? I haven't seen this language before.

I've seen it pop up a couple times in challenges now. I think it has the most clever name of any of the golfing languages on the site :-) I've been watching Suits lately and I find it to be very Harvey.

Ruby, 15 12 bytes
$><<to_s[-3]

You can save 2 bytes changing $><< to p , makes p to_s[-3]

@Ephi p calls inspect on its arguments, so the output will be quoted, which would disqualify it.

I missed that part of the challenge, I'll let those comments as I think it's an interesting information :)

Bubblegum, 1 byte
"

or
B

Everyone seemed to forget it existed...

Never used Bubblegum before, so perhaps excuse my ignorance, but where can I find the docs for Bubblegum? Also, I tried http://bubblegum.tryitonline.net/ with both your answers, but it doesn't seem to output anything.

@KevinCruijssen Doc: https://esolangs.org/wiki/Bubblegum TIO seemed to accept only the hexdump of the source code, so try it like this: http://bubblegum.tryitonline.net/#code=MDAwMDAwMDogMjIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi&input=

Ah, that's my problem; not using the hexdump. Thanks and +1 for being the shortest with a single-byte answer (tied with Pluso).

@KevinCruijssen There is a 1 byte Pluso answer. It has some problems with a strange site rule, though.

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.

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

I laughed as I read it. This is good work. Great weaponization of something I know, but wouldn't have thought of.

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

@ColdGolf: That's not clear to me. Do you mean I can use say (contains a) for printing as long as the construction of the argument doesn't use the forbidden characters ?

"However, you must not use any of the below characters in your code:

A, whether uppercase or lowercase." From that, I'd print "No using the letter with code point 65";.

@ColdGolf is that meant to answer the question in any way?

><>, 7 4 bytes
Saved 3 bytes thanks to Teal pelican
"-o.

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

I would have done "B"1-o;

@DanTheMan That should have been the more obvious solution. I wonder why I didn't think of that :P

@DanTheMan :- Going off what Dan posted you can reduce this down further to; "1-o;B or even better "+o;& as either case is allowed making this 5 bytes :) - you can even make it 4 bytes with an error; "-o.

@Tealpelican: That's brilliant! Using strings are often shortest in challenges like these, but I didn't even consider that :)

Once I saw Dan's comment it reminded me of an older challenge quite like this so just used the same concept :)

><>, 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

Nice! I got '$-o;| which is almost the same but without the bouncing. (|;o-$' also works.)

@randomra oh true! that would definitely run faster, so nice job

MATL, 5 bytes
YNVH)

Try it Online
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)

Javascript, 18 bytes 16 bytes 12 bytes 11 bytes
` ${!2}`[2]

Based on modified jsfuck 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:
`${![]}`[-(-!![])]

You can replace the parenthesis with a space between the minus signs.

@Pietu1998: I noticed that 3 is allowed so replaced the whole thing with boring old 3-2 to get 1

Saved one byte thanks to Conor O'Brien's answer

Uh, no offense, but this pretty much is my answer. Except you use false instead of NaN and don't use a function.

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.

You can get uppercase a using JSF or a derivative using computed properties

@Downgoat Conor O'Brien already showed how.

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.

not a serious competitor. If you actually golf it down, the downvoter might invert their vote

Wouldn't it be much shorter to just count up to 65, even with 65 plusses?

'+' isn't allowed, so I had to go backwards

Sorry, I didn't see that. There's still far shorter ways to make 191, though.

how do you even post 192 bytes, then post a golfed solution of less than 10% of original?

@DestructibleWatermelon the 192 byte one is the brute force, obvious solution.  As I said, I'm not good at brainfuck.  When NinjaBearMonkey posted a list of ways to make other numbers with fewer characters, I modified one of those to do this.  The first 16 bytes of my solution are on that page, the last 3 are from me.

What is the strikethrough --------------------- for?

That was the 192 byte solution, I just left it up and did the strikethrough instead of deleting it because I thought it was funny going from 192 to 19

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

Very nice approach!

Save 3 bytes; instead of :h<cr>, try :h%<cr>.  That's one extra character, but you wind up on the help for %, with your cursor right over an a.  So from here you can replace 33ll with j.

Apologies for obvious typo (save 2 bytes)

You can use ZZ instead of :q<cr> to save another one.

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 versions (same number of bytes) :
L=LETTERS;rev(L)[length(L)]
rev((L=LETTERS))[length(L)]

A bit late, but you can save quite a bit with LETTERS[T*T]. T evaluates to 1 when doing numerical operations.

I found a shorter solution!

This isn't technically a solution --- it prints '[1] "a"' , rather than just 'a'

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)

print(({type{}:find".(.)"})[3])  31 bytes

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.
A full program is impossible as this would need to contain a main.

I don't think this is valid. The task requires to "print" or "display"  A. Your functions just returns it and the linked program displays it via putChar which uses u.

You're right, however the rules have been updated and now returning from a function seems to be ok.

No, the rules still say print and/or display.

Dennis asked explicitly whether returning from a function instead of printing is ok and OP replied with yes, but the afterwards updated wording of the question still doesn't reflect this. I guess we still have to wait for further clarification.

The OP confirmed that A should be printed/displayed and not returned.

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.

88-23 should save a few bytes.

For lower case a, you can use (333-33)/3-3. It's not as short as 'c'-2, but it's 3er. 33*3-2 is also possible.

If you use write() instead of printf you can make it a program; specify the build steps to ensure you don't link against any libc at all; if there is no _start the first symbol is jumped to and _exit is allowed so it's safe. At least one version of gcc will optimize write() into the direct syscall with no function call at all.

Depending on your IDE you can do something like this: printf("%c",~'ɦ');, though the "A" will have an accent mark added heh

@AlbertRenshaw ɦ is a 2-byte-character

@cmaster putchar includes A and U which is both forbidden

@KarlNapf Ooops. Missed that. Sorry.

Brachylog, 4 bytes
@Ztw

Try it online!
Explanation
@Z      The string "zyxwvutsrqponmlkjihgfedcba"
  tw    Write the last element to STDOUT

Vim, 6 bytes
grNg??
Challenge doesn't block N, and Vim has a ROT-13 feature. FDinoff's answer is probably cooler, but this is ASCII and works everywhere.

Cubix, 5 bytes
o'@)^

Try in the online interpreter!
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.

Ha, awesome double use of @ :-)

Sesos, 3 bytes
The code contains two unprintable characters, so here is a hexdump:
0000000: a85a0d                                            .Z.

Try it online! (Note that this uses the assembly code, which TIO converts to the binary above as an intermediate step. The binary is shown as a debug message.)
It is generated from this assembly program:
add 65
put

Could you elaborate on the unprintable characters part?

@ColdGolf Binary Sesos isn't a character based language; it stores its source code in form of a little-endian base-256 integer.

@ColdGolf Yes, the three characters that you see are meaningless; what matters is their binary representation.

Hmm... I'd say the assembly code is the source code of that program and it uses "a" and "6", which are forbidden. Otherwise everybody might just compile their program to an x86 binary and voilà, no forbidden characters used!

I agree. It isn't just 'a' is disallowed, its the value of 97 too. Sorry to disappoint.

@YetiCGN Submitting binary programs is perfectly acceptable.

OK, I've read up about how Sesos SBIN binaries work and I agree. The link is misleading thought, because it contains the assembler source code with the forbidden characters.

@YetiCGN TIO doesn't support binaries right now. I've added a note to the link.

Powershell v5, 13 12 11 bytes
"$(!2)"[$?]

Thanks to krontogiannis for saving me a byte.
Old 12 byte solution.
"$(!$?)"[$?]

Explanation:
"$(!$?)"[$?]
    $?        #returns the status of the last command, in this case, the call to this PS file
   !          #false operator
 $(   )       #runs the code in between () even while its in between ""
"      "      #converts to string
        [$?]  #returns index 1 (true) of the preceding string (1 is forbidden)

I don't have any earlier versions easily available to test on right now, but this should work back to v2 at least.

Take the False value using a simple constant: "$(!2)"[$?] (11 bytes)

I posted this: [Convert]::ToString((8-3)*2,16) then scrolled through and was like daheck, does "$(!2)"[$?] actually work!?

Labyrinth, 6 5 bytes
833.@

Explanation
833     # push 833 to stack
    .   # print modulo 256 as byte
     @  # exit

Try it online
Saved 1 byte thanks to Martin Ender.

Actually making use of that modulo: 833.@

@MartinEnder: Brilliant!

Pure Bash, 23
r=({Y..b})
echo ${r[8]}

Creates this array and displays the 8th member:
Y Z [  ] ^ _ ` a b

Deadfish~, 8 bytes
iiisdsic

The only difference from regular Deadfish is that it uses c, which outputs the accumulator as a character instead of an integer.
Explanation

increment 3 times (3)
square (9)
decrement (8)
square (64)
increment (65)
Output as a character ("A")

PHP, 14 bytes
<?=chr(88-23);

88 - 23 = 65, the ASCII value of A. 8, 2, and 3 are the only legal digits to use, and - is allowed.

Wow, exactly 1k ! Should I upvote?

@NoOneIsHere: Go ahead, or I'll never get past it :)

VBA, 12 bytes
?Chr(88-23);
in the VBA Immediate window.

You could remove ; to make it 11 bytes

@Anastasiya-Romanova秀 ...except the instructions say to avoid a linefeed if you can.

Dyalog APL, 12 bytes
⊃⎕DR/88-8 23
Equivalent to 80 ⎕DR 65

dc, 4 bytes
833P

UCHAR_MAX overflow rolls through the table six three times before landing at 65.

Mathematica, 16 bytes
First@WordList[]

WordList[] gives a list of common English words. First takes the first element of this list, which is "a".

Is WordList guaranteed not to change in a newer Mathematics update?

@ColdGolf It doesn't matter if it's updated. As long as any version of the language (i.e. any given interpreter or compiler) correctly runs this code, the answer is valid as far as PPCG is concerned. Otherwise, no answer would be valid since we couldn't be sure that any answer would still work in any future update of any language, since the authors of those languages are free to make changes that break backwards-compatibility.

@ColdGolf Wordlist is lexigraphically sorted.  The only word that could come before "a" is "".

Bash, 14 13 bytes
tr PQ @-B<<<Q

Output:
A

13 bytes: tr QQ @-B<<<Q

@pxeger Nice find! The last char in SET2 will be ignored, which is fine, we need the first 2 chars only for this to work. Thanks.

Java 9 jshell, 18 bytes
printf("%c",'C'-2)

jshell is a Java REPL that comes with Java 9.

Brachylog, 7 bytes
@P:33mw

Try it online!
Explanation
@P is the following string:
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

(the first character is a space)
And its 33rd element is the required letter A.
@P:33mw
@P        generate the string above
  :33     append the number 33, yielding ["...",33]
     m    pass the array as Input of m, and the
          required character becomes the Output
      w   recycles the right argument of the previous
          predicate as the left argument, and then
          prints to STDOUT

dc, 8 7 bytes
-1B thanks to Dennis
88 23-P

Pushes 88, pushes 23, subtracts, leaving 65. Print top of stack (65) as an ASCII string, sans trailing newline.
Edit:
These are a few of the other ways I came up with. It basically became a game of "generate the numbers 65 and 97 using only [238B-F] and without addition". Ironically, I find the longest ones most interesting.
_Fdd/r-oC 2-n  # involves changing the base
2_2/8d*3*2/-P
Idd2/2/-2*on   # also changes base
2d8r^r_2/-P
8d*2_2/-P
B 3d**2-P
33 3*2-P

Bash, 19 17 bytes
Prints lower-case a:
printf \\$[282/2]

(Thanks to Dennis for reminding me of the deprecated syntax)

Nice, I came up with b=\echo {@..B}.`;<<<$b[8/2]` for 27b (in Zsh)

Octave, 13 11 8 bytes
Didn't expect to golf this answer down, but wohoo, a bug(?) in Octave made it possible to save two bytes! :) Converting this to a "full program", instead of a function saves an additional three bytes, leaving us with 8 bytes:
['',833]

['',833] concatenates the empty string with the number 883. The ASCII code for A is 65, so 883 might seem a bit odd. I think this must be a bug, but what Octave does when concatenating an empty string and a number is that it takes the number modulus 256. mod(883, 256) == 65 which just so happens to be the ASCII code for A.
Octave does not do this when using the "proper" method, char(883), in which case we will get:

warning: range error for conversion to character value

Retina, 8 bytes
M`
T`O`L

Try it online!
Explanation
M`

This counts the number of matches of the empty regex in the empty input, so it produces a 1.
T`O`L

This is a transliteration which substitutes characters from the first set with corresponding characters from the second set. However, O and L are shorthands which expand to the odd digits and the upper case alphabet, respectively, so this replaces the 1 with A.

Groovy, 9 bytes
f={--'B'}

Try it online!
Makes use of the decrement operator overloading on Strings, per CharSequence.previous().
Previous solution
I missed the fact that a return value was an acceptable alternative to printing the result.
Groovy, 12 bytes
print(--'B')

Whitespace, 15 bytes
It's easy to avoid characters with a language that doesn't use any of them!
Try it online!
.
.
.

The .'s are unneccessary, and are just to make the codeblock work.
For a more readable format: s = space, t = tab, newline placement matters
ssstssssst
t
ss

First line pushes (ss) positive (s) 65 (tssssst, binary 1000001) onto the stack)
Second and third lines print top of stack as char.

R 3.2.2, 34 32 bytes
This is a tricky challenge in R, since the only function that will print without quotes and junk is cat, which contains an "a". We have to get it by indirect means. In a fresh R installation with no extra packages, the base package (in which cat resides) is the eighth in the search list (luckily 8 isn't prohibited!)
cat is the 297th thing in the base package, but 9 and 7 are prohibited. I think 322-23-2 is the most efficient way to calculate 297, but I may be wrong!
(Edit: I was wrong. Thanks to Albert Masclans for pointing out that 33*3*3 is more efficient. I also added the R version number since later versions of R will probably introduce more things into the base package.)
"a" is held in the first element of letters (alternatively, use LETTERS if you want "A") but since 1 is prohibited, we use 3-2 to get it.
    get(ls(8)[33*3*3])(letters[3-2])

I love how you did it. 297 = 3333

Commodore 64 BASIC, 6 bytes
2?"♠"

There's a non-printing character after the first quotation mark, with byte value 14.
How this works: The Commodore 64 has two character sets: "shifted mode" (which contains the full upper- and lower-case alphabet, and the startup "unshifted mode", which contains the upper-case alphabet and a selection of symbols.  The "spade" symbol in unshifted mode has the same byte value as uppercase "A" in shifted mode, so if you switch modes before printing out a "♠", you get the letter "A" instead.
The question now becomes: what's the most efficient way of switching modes?  The "approved" method is POKE 53272,23, but that's rather long for code golf.  There's a control character (byte value 14) that switches to shifted mode, but you can't type it in directly, and ?CHR$(14) is still rather long.  Further, both of these contain disallowed characters, and working around that would expand them quite a bit.
You can cut it down to a single byte, though, by combining it with the code to print out the "A".  The Commodore has no memory protection, so after typing in a proxy program (I used 2?"Q♠"), you can modify the in-memory representation to replace the "Q" with byte value 14.  For a freshly-started C64, POKE 2055,14 will do the job.

Vim, 19 bytes (not competing)
:redi@"|Ni!<CR>pJd3w~D

Do you demand a shrubbery?

R, 11 bytes
el(LETTERS)

el(LETTERS) is equivalent to LETTERS[[1]].
Try it online!

Whispers v2, 190* 108 bytes
> e
> 8
>> 2²
> e
> e
> e
> e
>> ≻3
> e
> e
> e
> e
> e
> e
> e
> e
> e
> e
> e
> e
> e
>> '8
>> Error 22

Try it online!
Outputs A to STDERR, which is an accepted method of output
*82 bytes saved by golfing formula from \$65 = (3 - (-2)) - (-2 \times 3) \times (8 - (-2))\$ to \$65 = 8^2+1\$
How it works
Whispers is different to most languages, in that numbers (0123456789) don't always represent their numerical values. A Whispers program is a series of lines, each of which matches (at least) one of a series of regexes. All the regexes require a line to begin with either >  or >>  (note the space).
Lines that begin with >  are nilad lines, and return a constant value each time. on these lines, digits do represent their respective numerical values. For example, line 2 (> 8) returns the integer \$8\$.
However, lines beginning with >>  treat numbers as line references, rather than numerical values. This means that >> 2² doesn't actually return \$2^2 = 4\$. Rather, it retrieves the value on line 2 and returns its square. Execution works by starting on the last line, and getting values passed along through other lines, similar to a game of Chinese Whispers (hence the name).
Now, as we can't use any of 0145679, we have to construct either \$65\$ or \$97\$ using only \$2\$, \$3\$ and \$8\$. Furthermore, we can't refer to any lines aside from 2, 3, 8, 22, 23, etc. which is why we have so many lines that are just > e. These are all unexecuted, and just serve to pad the important lines to line numbers that we can use.
We use the formula \$65 = 8^2 + 1\$ in order to build \$65\$ (the char code of A). Luckily, Whispers has an increment command (≻), so we don't have to deal with addition or calculating the number \$1\$. So, we start execution on the last line:
>> Error 22

This calls line 22, outputs its value to STDERR, then exits. Line 22, directly above, is
>> '8

' is the to character command, equivalent to Python's chr builtin, so here, we take the value on line 8 and convert it to a Unicode character. Now, we can see lines 2, 3 and 8, in order:
> 8
>> 2²
>> ≻3

Kind of counter intuitively, these lines are executed in reverse order: first line 8 increments the value on line 3, then line 3 squares the value on line 2 i.e. \$8\$. Ultimately, line 8 returns \$8^2 + 1 = 65\$ which is then cast to character and outputted to STDERR.

Jolf, 3 bytes
Fpl

Try it here!
First (F) of the lowercase alphabet (pl).

Are you tired of verifying your code manually? Use this!

Another one for three bytes:
~TS

This is the hexadecimal char code of a newline (0x0A)

reticular, 9 bytes
"C"c2-co;

Try it online!
This is basically C converted from a char to a char code, subtracting two, converting back to a char, printing it with o, then finally terminating it with ;.

C++14, 30 bytes
As unnamed lambda (allowed in Python):
[](decltype('B')*c){*c='C'-2;} //'c'-2 for lowercase

//Usage:
#include <iostream>
main(){
  char c;
  [](decltype('B')*c){*c='C'-2;}(&c);
  std::cout << c << std::endl;
}

33 bytes
Function that assigns to its parameter:
int f(decltype('B')*c){*c='C'-2;}

//Usage:

#include <iostream>
main(){
 char c;
 f(&c);
 std::cout << c << std::endl;
}

Pretty hard to do it otherwise since no #include, return or auto because of U. Modifying parameters for return values seems ok Meta

You could just use the same printf code as in your C solution inside the lambda and get rid of the argument to make it shorter.

suggest passing c by reference and taking advantage of implicit conversions to make this 27 bytes

Snowman, 14 bytes
{8vn2nPNiNwRsp

Explanation
{               # activate bdg
 8              # set b to 8
  vn            # no-op
    2           # set d to 2
     nP         # set b to 8^2=64
       NiN      # set b to b+1 = 65
          wR    # wrap in array
            sp  # print

Try it online

......You rang?

Dyalog APL, 15 bytes
{⍵::2⌷⊃⎕DM⋄⍺}⍴⍬

The straightforward options are all banned: both ⎕AV (APL character set vector) and ⎕UCS (Unicode conversion) contain banned characters.
It gives one uppercase A:
      {⍵::2⌷⊃⎕DM⋄⍺}⍴⍬
A

Explanation:

{...}⍴⍬: pass 0 (length of empty vector) into the function
⍵::: trap the error with code ⍵, which will be 0. A trap on 0 means to trap all errors.
2⌷⊃⎕DM: the 2nd character of the first line of the error message
⋄⍺: try to return the value of the left argument. There isn't one, so this will raise a VALUE ERROR, which the A is then extracted from.

Ruby, 17 bytes
print (88-23).chr

Thanks to Dennis for the expression, a big improvement over 23*8/2-3*8-3, my first idea.

You can replace print  with $><< for -2 bytes.

(88-23).chr → ""<<88-23. Sadly when you combine it with $><< as suggested by @Jordan, you have to make sure the second << gets evaluated first. Fortunately that can be solved without enclosing it in parenthesis: just use the first << as method, not as operator: $>.<<""<<88-23.

Mathematica, 27 25 24 bytes
Writes 10 in base 24. Half the length is one function name :(
IntegerString[2(8-3),33]

Thanks to Xavier for pointing out that the base doesn't have to be 16 (as in my original hexadecimal solution), and thanks to c-- for saving another byte!

What about First@WordList[]?

@Xavier: Make that an answer and I'll upvote it!

Done! A small gain for your approach: IntegerString[8 + 2, 3*3 + 2] :-)

Unfortunately the mean OP doesn't let us use + in this challenge :) I upvoted your answer though!

Ah yes, I have missed the + in the constraints. +1 as well!

But you did help me save 2 bytes :D

Glad this was of help! :)

you could do base 33 for -1 byte

Lua, 36 bytes
_,_,y=type{}:find(".(.)")io.write(y)

Explanation:

type{} is equivalent to type({}) and returns the string "table" with the desired 'a'.
string.find's very infrequently-used 3rd return value is the first capture from the pattern. Most of the other ways that could be used to chop up a string are forbidden by the alphabet restrcitions.

Comments:
Alternatively, print for -3 bytes if not required to suppress the trailing newline.
I really wanted to use _VERSION to get the 'a', but type{} is shorter.
This should work in Lua 5.1-5.3. Lua 5.0 doesn't support the string metatable, so it is a bit longer.

_,_,z=type{}:find".(.)"print(z) 31 bytes

SMBF, 4 bytes
<-.B

Try it Online!
Explanation:
<-    Wrap pointer around to the "B" and decrement it, giving "A"
  .   Print
   B  Data storage

Pyke, 2 bytes
Gh

Try it here!
Gh - alphabet[0]

Python 3, 18 17 bytes
print(chr(88-23))

Prints the Unicode value 0x41 = 65 - credit SnoringFrog
Previous answers
print(str(int)[3])

Prints index 3 (the fourth character) of the string "<class 'int'>":
print(chr(33*3-2))

Prints the Unicode value 0x61 = 97

88-23 saves one byte over 33*3-2 in the second example

@SnoringFrog - how did I miss it?! Thanks!

Fission, 5 bytes
R'B_O

Try it online!
How it works
R      Spawn an atom that moves to the right.
 'B    Set the atom's mass to 'B'.
   _   Decrement the atom's mass.
    O  Print the character that corresponds to the atoms mass and destroy the atom.

PHP, 12 bytes
<?=chr(833);

Due to an overflow the above produces an 'A' (see example 2 of the PHP doc).

DC, 6 bytes
3BFFvP

...spits out an A and nothing else.

JavaScript ES6 ES5, 23 17 12
12 bytes
`${!3}`[3-2]

17 bytes: (typeof!3)[2- -3]
23 bytes: _=()=>(typeof!3)[2- -3]
Edit 05/10/2016:
Took advantage of templating strings, as well as boolean coercion and string/array indexing... Also realized my previous code used +, I could always salvage 2+3 as 2- -3 at a cost of 2 bytes for each previous example... (Updated code and scores for previous submissions)
Edit 30/08/2016:
I took a different approach, exploiting the fat arrow functions as well as the typeof return type, which is a string. So converting a number to a boolean was easier then, had to encase it in parentheses before pulling the 5th element of the resulting string...
Seems that there was no mention of my answer requiring to be in the form of a function, so I've just stripped the fat arrow function declaration.

Piet, 30 codels
I'm sure that this can be improved, but I'm a bit of a Piet newbie.

Side note: I have titled it Icy Toll Gate to a Nether Portal. It's artistic, but not abstract, so it kind of follows the main design principle!

Following community consensus on the meta, piet is now scored by the byte count of the image. You can try to compress it as much as possible provided there is a piet interpreter which accepts it.

JavaScript, 21
Capital A because there seems to be no other solution to find a capital A
_=>`${[].keys()}`[8]

`${[].keys}` => "[object Array Iterator]"
8th index is A
_=>`${keys}`[38]

Also works in browser for similar reasons.
Edited to add function

Powershell, 11 bytes
" $(!2)"[2]

Every non-0 integer evaluates to True when casted to [bool].
!2 implicitly converts 2 to [bool] and negates it, so it becomes False.
$() blocks inside a string allow expressions to be evaluated before being converted to string.
When accessing a string with an index the string is treated as a char-array.
Since we're not allowed to use 1 i had to use a space to shift the a in False one to the right.
Another option would be a negative index: "$(!2)"[-4].

Lenguage, 62,544,587,333,324 bytes
Unary, 134,032,404,790,876 bytes
I couldn't resist ;)
Programs consists of 62544587333324 and 134032404790876 times the character B (or any allowed character you choose to). (Actually pretty short for Lenguage/Unary..)
Port of @Dennis♦' Brainfuck answer.
Byte-counts generated by this program I wrote in 05AB1E.

Do your brainfuck include +?

@l4m2 What do you mean?

!@#$%^&*()_+, 3 bytes
`^@

Try it online! Outputs lowercase.
Shortest for A seems to be 5 bytes: >^^^@ or B_^_@.
Explanation
`^@
`     push the character "`"
 ^    increment (to `a`)
  @   output as character

Keg, 3 2 bytes
B;

This pushes the ASCII character B onto the stack, and then decrements the value by 1. The value will automatically be printed.

International Phonetic Esoteric Language, 8 bytes
My original answer used the old instruction set and interpreter, which have since been completely rewritten. Still abusing Unicode, and somehow the same length heh.
"C"ʁ2zχo

Explanation:
"C"ʁ     (push "C", convert str to num 67) ( -- 67)
    2    (push 2) ( -- 67 2)
     z   (subtract) ( -- 65)
      χ  (convert num to str) ( -- "A")
       o (print) ( -- )

International Phonetic Esoteric Language, 8 bytes (WIP language) (OLD)
2<C>ʀdχo

The wonders of abusing Unicode as your instruction set.
No TIO interpreter yet, but is runnable by cloning the repository above, and calling python main.py "code here".
2<C>ʀdχo
2        ; push 2
 <C>     ; push "C"
    ʀ    ; pop, push ord("C")
     d   ; pop, push 67 - 2
      χ  ; pop, push chr(65)
       o ; pop, print string

Python 3, 24 bytes
print(chr(88-23),end='')

Prints an uppercase A without a newline.
Python 2, 16 bytes (with newline)
print chr(88-23)

you can do print(end=chr(88-23)) for 21 bytes

x86-16 machine code, IBM PC DOS, 6 bytes
Binary (CP437):
░@@═)├

Unassembled listing:
B0 40       MOV  AL, '@'    ; One below ASCII 'A'
40          INC  AX         ; increment char
CD 29       INT  29H        ; write AL to console
C3          RET             ; return to DOS

Excel, 15 bytes
=MID(2=3,2,3-2)

Show the second character in FALSE
VBA (immediate window), 14 12 bytes
Lower case (12): ?chr(33*3-2)
Upper case (14): ?chr(8*8--3-2) or ?chr(23*3-2-2)

Piet + ascii-piet, 14 bytes (10×2=20 codels)
sSsSKNMTFVrFff

Try Piet online!
(Previous record: 30 codels / ascii-piet bytes)

In ascii-piet, a represents a dark blue cell, and u is a light magenta cell. (x and symbols and digits do not exist.) This program has only one dark color but four different light colors, so I had to rotate the hue so that the resulting ascii-piet representation contains neither a nor u.
The program itself is pretty simple:
4 dup dup * * 1 + outC

Could you save a few bytes by expanding the 4 into an 8 through the black region, and removing a dup and a *?

@emanresuA It would have to be 16 rather than 8 (64 is 444), which would increase the size.

@DLosc What I meant was 8 dup *

@emanresuA Ah, I see. That still wouldn't save bytes, though? It would be the same dimensions, and with ASCII-Piet it would actually increase the bytecount (since black codels at the ends of lines can be left implicit in ASCII-Piet).

MATL, 5 Bytes
'b'qc

Try it online!

It's annoying that this requires the c, but unfortunately that behavior is a MATLAB/Octave thing.

SQF, 30 15
Using the function-as-a-file format:
toString[88-23]

Call as: call FUNCTION
Finally a challenge where SQF can compete. Not win, but actually competing is nice.

3var, 14 11 8 bytes
iii       # set A to 3
   s      # square A to 9
    d     # decrease A to 8
     s    # square A to 64
      i   # increment A to 65
       P  # print A as ascii

Try it online
Saved 3 bytes thanks to Joffan.

Is there a reason to involve R and B - why not iiisdsiP?

@Joffan: You are of course correct. There's no reason at all to use R. Thanks!

Pyth - 3 bytes
Alternate longer answer.
.HT

Try it online here.

@ColdGolf accept the first one.

also mine is 3 bytes so it can't win.

Jellyfish, 5 bytes
P;>'@

Try it online!

Befunge-98, 6 bytes
'Lb-,q

Very basic: 'Lb- pushes (76-11 aka 65), , prints, q quits because using @ is too boring.

Caker, 24 bytes
ωΩθΩθθθθθΩθΘ

Body must be at least 30 characters; you entered 29.

Perl 6, 14 bytes
print 'B'.pred

pred is short for "predecessor"

WolframAlpha, 10 bytes
chr(88-23)

Do you mean "Wolfram Language"?

@ColdGolf WA is a program using Wolfram language. It can also be called from Mathematica by typing equality sign twice (==). Check the link.

Are you implying I can't use WA?

Nope, it was just an interesting thing.

PHP, 15 14 bytes
(PHP7 only) Longer than others but a tricky approach :
<?=([].b)[.2];

[] instance an Array
.b cast to string = 'Array' and add any character (here b) at the end (thank you Business Cat)
[.2] : = [0] take first letter (A)

This is PHP 7 only, right?

You're right PHP7 only, I'll edit

I can't fully test it since I don't have PHP7, but I think you can replace '' with some letter that is legal to use like b. If you do [].b it will concatenate Array with the string b giving Arrayb.

Thank you ! You're right. You can test it with any PHP online interpreter. (Errors and Warning can be ignored)

Oracle SQL 11.2, 56 50 bytes
Shorter way to compute 65, thanks to the previous answers using it.
SELECT NVL(MIN('.'),CHR(88-23))FROM col WHERE 2=3;

Old version :
SELECT NVL(MIN('.'),CHR(3*3*8-2-2-3))FROM col WHERE 2=3;

Ugly, but I had to find a way around DUAL

Verbosy, 13 bytes
~` /3 ^3 \3 o

Verbosy is actually a language I wrote (see the link). Hopefully that's allowed...
Explanation:
~`: set Current to the ` character.
/3: put the ` character into slot 3
^3: increment the character in slot 3 by 1
\3: put the character in slot 3 into Current
o: prints Current

R, 12 bytes
I was losing it until I realized I can use 2 and 3.
 LETTERS[3-2]

Straw, 6 bytes
Bæ}Æ>

Take the codepoint of B (Bæ), get the tail of the string (unary decrement) (}), take the character associated with the codepoint (Æ), and print it (>)
Try it online

QBasic, 17 bytes
PRINT CHR$(88-23)

Exploits the fact that the function which converts an integer to char is named CHR.

PowerShell, 89 59 32 Bytes:
[Convert]::ToString((8-3)*2,8*2)

$d=2-2;[char][byte]"".insert($d,(3*3)-(2*2)).insert($d,2*3)
$b=[string]::Concat(2*3);$c=[string]::Concat((3*3)-(2*2));[char][byte]$b.insert(2*2-3,$c)

edit: use of a I see no way around this(not a golf language) It is possible...

This is now fixed

Japt, 3 bytes
Any of these 3-byte programs work:
;Bg
;Cg
;Hd

Test it online!
How it works
;      Set B to the uppercase alphabet,
           C to the lowercase alphabet,
       and H to 65, among other things.
 Bg    Take the first char of B.
 Hd    Take the character with charcode H.
       Implicitly output.

Any of these 4-byte programs work as well:
;EgG
;EgI
;FgG
;FgH
°I d
IÄ d

Java 7, 73 69 bytes
Golfed:
void m(){System.err.println(new Object().toString().split("")[3-2]);}

Ungolfed:
void m()
{
    System.err.println(new Object().toString().split("")[3 - 2]);
}

Outputs a to the standard error.

I don't use Java but would 'C'-2 work and save you a byte?

no, but [3-2] would :P thanks. Why it wouldnt work? Because .split("") splits a string by character and stores it into a string. something like ["j", "a", "v", "a", ".", "l", "a", "n", "g", ...]. with [3 - 2] I get the second string in that array, which is a.

Interesting, thanks for the explanation! +1, clever solution

TI-Basic, 14 Bytes
:ClrHome
:Disp "Ans
:Output(1,2,"

Note the two trialing spaces at the end of line 3.

TI-Basic has its own character encoding where many commands are 1 or 2-byte tokens. For example, ClrHome is a single byte. Ans is a single byte, so it does not violate the challenge rules.

Cheat version, 3 bytes
:"a

In this code, use the a from the statistic menu: VARS > 5 > Right Arrow > Right Arrow > 2.

C, 20 24
Surprisingly, you can cast negative integers to characters in C and you will get ASCII characters. I ran a loop up to -10,000 and found a few values that produce the character "A". One of which was -8383 which uses no invalid characters. Another being -2239 which breaks the rule of using '9', however you can use a bit operation of ~2238 which becomes -2239.
The generation function for negative integers producing 'A', at least in C-GCC4.9.2, is 65-256*i ... The first few are -191, -447, -703, -959 (Note: this is the same as 'A'-(256*n))

f(){printf("%c",-8383);}
f(){printf("%c",~2238);}
f(){printf("%c",-'¿');} //¿ (2 bytes) is x00BF in unicode (or 191 in base10), -191 = A
Bonus: printf("%c",-'₿'); //negative bitcoin produces A because bitcoin symbol is x20BF which is base_10 is 8383, -8383 cast to char is 'A', but the bitcoin symbol is 3 bytes putting my score to 25 so this is my popularity contest answer, not my codegolf answer

Edit: I can't use putchar since it contains a "U" and an "A". I've updated the answer above to use printf and thus increased my code by 4 bytes from a score of 20 to 24

Suggest L"" instead of "%c",-'¿'

Chicken, 495 bytes
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken

You have to copy and paste the code but you can try it online.

Braingolf, 7 bytes
"C"2-@;

Try it online!
Screw you @totallyhuman :(
Explanation
It subtracts 2 from C and prints.
Braingolf, 12 bytes
Keeping this one because IMO it's the better answer, and took way more effort to do.
/..*3*<2*-@;

Try it online!
Man, this was hard.
Explanation
/..*3*<2*-@;
/             Niladic division, push 5 [5]
 ..           Duplicate twice          [5,5,5]
   *          Multiply last 2 items    [5,25]
    3         Push 3                   [5,25,3]
     *        Multiply by 3            [5,75]
      <       Left-shift stack         [75,5]
       2      Push 2                   [75,5,2]
        *     Multiply last 2 items    [75,10]
         -    Subtract last 2 items    [65]
          @   Print as character, 65 is the ASCII value of A
           ;  Suppress implicit output

Braingolf, 9 bytes
And here's a shorter one that still uses the "calculate 65" method
/82*3-*@;

Try it online!
Explanation
Uses niladic division for 5, calculates 13 from (8 * 2) - 3, then multiplies 5 and 13 to make 65
Braingolf, 11 bytes
And finally here's one that prints a lowercase a.
*v/2*c/3-@;

Try it online!
Explanation
*v/2*c/3-@;
*            Niladic multiply, push 1000 [1000]
 v           Switch to stack2            []
  /          Niladic division, push 5    [5]
   2*        Double                      [10]
     c       Collapse stack into stack1  [1000,10]
      /      Divide last 2 items         [100]
       3-    Subtract 3                  [97]
         @;  Print as ASCII and suppress implicit output
             97 is the ASCII value of a

:P - - - - - - -

Woefully, 335 bytes
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| | --push5; A[5], B[]
| |
| |
| |
| |
| | -- dupeA2B; A[5], B[5]
|| |
||| |
|||| |
||||| |
|||||| |
||||||| | -- swap dec/ascii (set to ascii)
|||||| |
||||| |
|||| |
||| |
|| | --push3; A[5,3], B[5]
|| |
|| | --popA2B; A[5], B[5, 3]
||| |
||| |
||| |
||| |
||| | --multiply; A[15], B[5]
|||| |
|||| |
||||| |
|||| |
||| |
|| |
| | --push2; A[15, 2], B[5]
| |
| | --popA2B; A[15], B[5, 2]
|| |
|| |
|| |
|| | --sub; A[13], b[5]
| |
| |
| |
| |
| | --multiply; a[65], b[]
|| |
||| |
|||| |
||||| |
|||||| | --print; OUTPUT; "A"
|||||| | --no op ends program

Try it online!
I've added the explanation of each step at the end of the step.

Pushy, 2 bytes
ZQ

Try it online!
Z          \ Push 0
 Q         \ Index into 0-indexed uppercase alphabet, print result

x86 MS-DOS, 10 bytes
b4 02 mov ah,0x2
b2 40 mov dl,0x40
fe c2 inc dl
cd 21 int 0x21
cd 20 int 0x20

Try yourself
echo "B402B240FEC2CD21CD20" | xxd -r -p > TEST.COM

Acc!!, 16 11 bytes
Write 32*2-(2-3)
  Write 88-23

Write tells it to output ASCII, 32*2=64, -(-1) gives 65
I realized 88-23 also gives 65
Try it online!

Pascal (FPC), 26 bytes
begin write(pred('B'))end.

Try it online!
At first, I wanted to use standard 88-23 approach, but luckily, there is the pred() which returns previous element of an ordinal type (integers, characters and enumerated types).

Kotlin, 7 bytes
{'C'-2}

This is a lambda that returns the Char A. Char overloads the minus operator. Since C is 2 characters after A in Unicode, 'C'-2 produces A.
Try it online!

Java 8, 9 bytes
()->'C'-2

-31 (!) bytes thanks to ASCII-only!
Try it online!

How?

I'm not sure. Best guess is the result of the subtraction is implicitly cast to char because of the return type of the function.

34

9

@ASCII-only I thought that returned an integer. I guess golfing at night is not the best idea ;) Thanks.

9 bytes excluding the semicolon btw

@ASCII-only fixed, now time for sleep.

Python - 20 bytes
print(chr(-~(8<<3)))

IPython 7.11.1 - 19 bytes
print(__doc__[3^3])

Submissions must be full programs or functions, snippets are not allowed. You would need to print this somehow.

Brainetry, 141 bytes
a b
a b c d
a b c d e f g h
a b c d
a b c d e f g h
a b c
a b c d e f g h i
a b
a b
a b c d
a b c
a b c d
a b c d e f g h i
a b
a b c d e f g

The code above is the golfed version of this program:
Hey, look,
I'm not even going
to try, ok? I will jvst write regvl@rly
@nd then svbstitvte the
letters yov do not w@nt me to vse.
Is this ok@y?
I re@lly hope yov do not mind. Other th@n
th@t, this
is @
f@irly st@nd@rd ch@llenge, I
jvst went online
@nd googled short w@ys
of gener@ting the const@nt 65 in br@infvck. Of covrse
I w@s
sent str@ight to the Esol@ngs web p@ge.

In the first section, you have a's. In the second section you have 5 and 6.

BRASCA, 1 byte
Uppercase: D
Lowercase: h
TRY IT | try it
Explanation
There's isnt really that much to explain. D pushes 65 to the stack, h pushes 97 to the stack, and implicit output does the rest.

TeX, 7 bytes
^^!\bye

An extra 12 bytes if you wanted to supress the page number:
^^!\def\folio{}\bye

I receive the error ! I can't find file 'a'.

@Kai You must write the code in a text file and then run tex on it, passing the code as an argument to tex won't work.

Vyxal, 2 bytes
«∧

Try it Online!
Pushes 'a' as a compressed string, which is printed automatically.

Factor, 12 bytes
[ "y""8"v- ]

Try it online!

Risky, 1.5 bytes
[--

Try it online!
 -    The difference of...
[     64 and...
  -   -1

KonamiCode, 17 bytes
v(^^^^^^>^^^^^)<<

k (ngn/k), 26 bytes
.""/("`";$8-8;":";`k@$@())

@() evaluates to the type of (), or `A. using `k@$ converts it to a string and then pretty prints it, giving us "A". we put this in an array, along with "`", "0", and ":", which once we join with ""/ gives us `0:"A". we evaluate this as k code with . which prints A to stdout.
try it on the ngn/k repl.

Fig, \$3\log_{256}(96)\approx\$ 2.469 bytes
[cv

Try it online!
[cv
[    # first item of
 cv  # lowercase vowels

Python 2, 17 bytes
print`help`[23-2]

Try it online!
Explanation
help in python gives help for things. When just help is typed, a message saying Type help() for interactive help, or help(object) for help about object. is printed, which has a as its 22nd letter, or 21 when zero-indexed.

K (ngn/k), 26 15  14 bytes
.`c$"c3='cD"-3

Try it online!
-11 bytes from Bubbler
-1 byte from Bubbler (this was primo)

Same strategy but much simpler: .`c$"b2<.$C$"-2

I was fishing around for something like this but got tired.  I was also avoiding all digits for not paying attention.

-1: .`c$"c3='cD"-3 which encodes `0:$`A.

This is very clever.  I feel bad adding to this post, but I will anyway. ;)

Vyxal 3 g, 1 byte
n

Try it Online!
no idea why this happens but n is a builtin for lowercase alphabet and -g flag takes the minimum of the top of the stack which turns out to work on strings ???

Wow...shortest and sweetest possible, nice work!

Befunge 93, 7 bytes
"C"2-,@

Pretty simple.

Brainfuck, 24 bytes
not as good as Dennis' anyones, but still posting it.
----[---->-<]>--[->-<]>.

ECMAScript 6, 41 59 55 bytes
Golfed
This is the golfed version, which doesn't support the use strict pragma. If you want to allow this to be compatible with it, simply replace s=(2-2>(3-2) with var s=(2-2)>(3-2).
Version 3 of this replaced the old substring (that uses the disallowed character u) with slice, a byte-efficient version that fits these rules.
You can try this on JSFiddle or use the below Stack Snippet.

s=(2-2)>(3-2);console.log(s.toString().slice((3-2),2));

Ungolfed
This version of golfed code (version 3) supports the use strict pragma and is 79 bytes.
You can try this on JSFiddle or use the below Stack Snippet.

"use strict";
var s = (2-2) > (3-2);
console.log(s.toString().slice((3-2), 2));

Technically, this doesn't follow the rules as it uses u and a (in use and var respectively), but it was needed to support use strict.

console.log((3<2).toString().slice(3-2,2)) works too.

@BartekChom, thanks. Will update main post.

Why not console.log(String(!2)[~-2])

Ruby, 20 Bytes
print ("c".ord-2).chr

Subtracts 2 from the unicode-code from "c".

C# Interactive (REPL), 21 bytes
(3<2).ToString()[3-2]

I really wonder how much smaller it can become in C# in a REPL environment.

I don't think this is valid, since it's just a snippet. It has to be wrapped in a function, which would almost definitely need to have an A or a U in it somewhere.

@DJMcMayhem I can't seem to see anything specifying that it must be wrapped in a function. I also noticed a few answers aren't even necessarily printing the result explicitly either.
It's also worth mentioning that by using something like C# Interactive (built into Visual Studio 2015, it's possible to just add the snippet I have above and it will output the correct value ('a'). Meaning if PowerShell can get away without a explicit print equivalent, C# could too?

I've asked about this here and have as such now specified that the solution is for C# Interactive (or any other REPL C# environment that might exist).

Python 2, 16 bytes
print chr(88-23)

Simpler but longer (21 bytes):
print chr(ord('c')-2)

Senva, 9 bytes 4 bytes
There is two ways to write this program, let's begin by the longest :
82.8--8-~

This stores 82 in the memory, substract 8, 8 again, 1, then display the memory as an ASCII char (65 is the ASCII code of A). The cell's value is 82 - 8 - 8 - 1 = 65.
The second way is a little bit pernicious :
B_-~

This converts the 'B' character to its ASCII char code, substract 1, and then display it as an ASCII char.

JavaScript (ES6), Uppercase, 34 30 bytes
1. I started from the answers of Conor O'Brien to get this:
_=>this[`${` ${-$}`[2]}tob`]("QQ")

Since btoa("A") gives "QQ==", it's doing atob("QQ") wich gives "A".
2. Completing the answer of chronixlol :
_=>String.fromCodePoint(88-23)

Insomnia, 2 bytes
Since any character is allowed, I used an unprintable character in the code (\u001a). Hex dump included below:
0000000: 641a                                     d.

StackExchange doesn't display control characters in the post, so click on edit to see the raw source code below and copy it to test on the online interpreter:
d

@TheBitByte: a is in the hex dump, not in the code. The code only contains character d and the control character 0x1A (decimal: 26)

C# Interactive (REPL), 12 bytes
Lower case:
$"_{3<2}"[2]

This works by getting the third character from the string _False.
Upper case:
$"{new{}.GetType()}"[8-3]

This creates an anonymous object and gets its type, which is always of the form <>f__AnonymousType0#9. It then turns this into a string and gets the 6th character.
Answers are given as C# Interactive to compete with the other C# answer, though they can easily be converted to a printing anonymous lambda by wrapping them with:
()=>System.Console.Write(...);

This adds 27 characters to each solution.

Note the method to wrap the call could be an Action and be displayed as: ()=>System.Console.Write(...);, Note the System. and ending ;.

The problem with that is that you can't declare an Action without an explicit cast. Which you can't do, because the 'A' in 'Action' is disallowed.

You don't need to declare the Action as the action by itself is fine i.e ()=>...

Had a look and it does seem like anonymous lambdas are allowed. I've changed the answer accordingly.

3d, 7 bytes
Don't know if competing, but still, here it is.
Program:
>'b.-!;

Output:
a

Explanation:
>        Set direction of the IP
 'b      Push Unicode ordinal of character 'b'
   .     Push digit 1
    -    Push difference
     !   Print as Unicode character
      ;  End of program

Game Maker Language, 26 bytes
So lucky that the command is chr() instead of char()...
get_string('',chr(33*3-2))

Basically, we have to get chr(65) or chr(97) to get A or a. Also, I had to use get_string to show the output since return, show_message, show_question, etc. all contained restricted characters.

Javascript, 32 bytes
Uppercase A:
String.fromCodePoint(33*2-(3-2))

“Your task is to print/display” – Your code is just a snippet generating the value.

MSX-BASIC, 25 bytes
?CHR$(3*3*3*2-(-3-3-3-2))

MIXAL - 101 bytes including tabs
Run on your MIX machine. Or assemble and run using the GNU MIX Development Kit (http://www.gnu.org/software/mdk/).
S       ENT2    2/2
        ST2     8
        ENT3    22*2-3-2-2
        ST3     P(8-3:8-3)
        ENT2    22-3
        ST2     P(8-2-2:8-2-2)
P       IN      8
        HLT
        END     S

The biggest challenge is not being able to use OUT, the only output command, or 19, the number of the teletype output device. I get around the source restrictions by creating forbidden numbers using MIX assembler arithmetic, and by using MIX's self-modifying code features.

Enter the number 1 into index register 2 (assembler turns 2/2 into 1)
Store the contents of index register 2 at memory address 8, later to be sent to the output device
Enter the number 37 into index register 3 using assembler arithmetic. 37 is the operation code OUT, which we need but can't use because it has a U.
Store the contents of index register 3 (=37) in the opcode field (5:5) of the instruction already stored at address 'P' as part of the program (in other words, change IN to OUT)
Enter the number 19 into index register 2. The teletype output device is no. 19.
Store the contents of index register 2 (=19) in the field-specification field (4:4) of the instruction at address 'P' (change 0 to 19 to specify the teletype device as output).
Instruction 'P': We have now rewritten this line as P     OUT    8(19). So, send the contents stored at address 8 (= 1 = character code for 'A') to the teletype device for output.
Stop the machine.

Microscript II, 6 bytes
2s'C-K

Basically subtracts 2 from the char code of C, then converts back to a character before printing implicitly.
In the original Microscript, it becomes this 7-byte program:
2s'C-Ph

Kotlin, 22 bytes
{print("${3<2}"[3-2])}

This is a lambda that prints a to the console when invoked. Converts false (3<2) to string via string template and returns the 1-indexed character.

Ruby REPL, 11 bytes
(88-23).chr

88 - 23 = 65. 65 is the decimal representation of ASCII A. The chr function changes the decimal representation to the character. The REPL displays the result.

does this display that character though?

F# Interactive, 17 bytes
string(3<2).[3-2]

This produces the following in the Output:
val it : char = 'a'

to print it to STDOUT, well, it becomes larger: 29 chars.
printf"%c"<|string(3<2).[3-2]

Woefully, 400 bytes
| || |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
|| |
||| |
||| |
||| |
||| |
||| |
|||| |
|||| |
|||| |
|||| |
|||| |
||| |
|| |
| |
|| |
|| |
|| |
||| |
|| |
| |
| |
| |
| |
|| |
|| |
|| |
||| |
||| |
||| |
||| |
|||| |
|||| |
||||| |
|||| |
||| |
|| |
| |
|| |
||| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |

Can probably be golfed more

This language is cool, I've made my own version for this at 335 bytes - but not sure if I should answer such an old question with this language already used.

@Tealpelican go for it! we don't care about necros (except when it's like a hundred tag adding necros, but that's irrelevant), and we don't care that much about reusing langs

JavaScript, Node console, 23
Shortest JavaScript I can do for a capital A.
This only works in the Node REPL console.
Object.keys(this)[2][3]

This only works in Firefox REPL (27)
Object.keys(this)[8*3][2*3]

Elixir, 16 bytes
IO.write [88-23]

Try it online on ElixirPlayground !
Elixir outputs the character(s) with the ASCII code specified in the list.
Using IO.puts would make it 1 byte shorter, but u is not allowed.
As expected, the interactive mode removes the need of explicitly calling IO functions for on-screen output.

Elixir Interactive, 7 bytes
[88-23]

Scala, 15 bytes
((2>3)+"")(3-2)

Explanation:
(
  (2>3) //false
  +""   //toString
)(3-2)  //zero-indexed 1st char is 'a'

k, 14 bytes
*|$`byte$38-28

This returns "a"

What is this k language.  Is it K? Where can I find out more about it?

http://kparc.com/k.txt is the manual
https://kx.com/ is the parent company's site - k in this case refers to k4, which is the c interpreter that underpins kdb+ and q.

SmileBASIC, 10 bytes
?KEY(2)[2]

KEY accesses the function buttons used in the editor.
They can be set to any string, but by default they are 1:FILES 2:LOAD" 3:SAVE" 4:LIST ERR\r 5:RUN

It's scored in bvtes, not characters.

Relying on user defaults might not be a good idea, but this is clever.

Luckily all the function keys are reset when restarting SB, so this will always print A if it's the first thing you run.

GO, 22 20 bytes
print(string(88-23))
Try it online!

,,,, 6 bytes
'Co2-c

Explanation
'Co2-c

'C      push "C"                    ["C"]
  o     convert to ASCII ordinal    [67]
   2-   subtract 2                  [65]
     c  convert to ASCII character  ["A"]
        implicit output             []

Pyth, 3 2 bytes
-1 from Dave reminding me to actually read the docs
hG

Explanation:
hG      The first entry in G (the alphabet)

Try it online!

hG is one byte shorter

longer but cuter is Ch^^2 2 3

@Dave Really? Didn't know that's how that worked

h of a sequence returns the first value

You crossed out 3 and replaced it with 3 lol

@Dave I should really head back to my desktop. This phone keyboard is so problematic.

K (oK), 8 bytes
Solution:
`c$88-23

Try it online!
Explanation:
Interpretted right-to-left:
   88-23 / 88 minus 23 is 65
`c$      / cast to character ("A")

Python, 31 bytes
print(chr(-~(2**(8-2))),end='')

Explanation: 8-2 is 6, and 2**6 (2 to the power of 6) is 64. chr(65) is A, so I need to add 1 without using + (or 1). I then used -~ which adds 1, creating chr(65) which is A.

MathGolf, 3 2 bytes
-1 byte thanks to maxb
╩Z

Try it online!
Fetches the 90th word in the dictionary, which is a uppercase 'A'.

You can shave a byte off using ♂¢

For lowercase you have ╩♦

There's also ╩Z for the uppercase. Check out the MathGolf chat, I have a great tool coming up for challenges like this one.

J, 14 10 8 6 bytes
hfd-!3

Attempt This Online!
-2 thanks to south, with another 4 on a variation of south's idea
-2 thanks to Bubbler and south, taking that idea one step further
We take the hex representation of -6.

I found 12! I am unsure if anything shorter is possible, but there's likely more 12's to find.

You can get rid of the ] for 11 with {.{:3!:3%:3 too.  Both yours and mine are snippets, though, which is no longer allowed.   I'll go ahead and update anyway since the problem is old.

@south Using a variant of your idea got it down to 10.

@south Now down to 8.

Haha, awesome! I feel a little silly I missed a byte save there lol. Didn't know hfd existed either :P, love it.

Here's 7, hfd-3*2.

6 (variation of south's): hfd-!3. Another fun 7: hfd?.23 (?.23 deterministically returns 10)

Ahead, 6 bytes
'C2-o@

'C      push 67 (C in unicode)
  2     push 2
   -    subtract
    o   print char
     @  end

Try it online!

Scratch, 38 bytes
when gf clicked
think(letter(2)of<[]<[

Try it online!
think is used instead of say because say has an a.

MathGolf, 2 bytes
♂¢

Try it online.
Explanation:
♂     # Push 10
 ¢    # Convert to hexadecimal (and output implicitly)

Brian & Chuck, 7 bytes
B?
!<-.

Try it online!
code:
Brian:
B    constant B
?    switch to Chuck

Chuck:
<    go to B
-    decrement it
.    and print it

Brain-Flak, 28 bytes
(((((()()()()){}){}){}){}())

Try it online!
code:
(((((()()()()){}){}){}){}()) push 65
                             implicitly print stack

Julia 1.0, 12 bytes
print('d'-3)

Try it online!

W d, 2 bytes
∑Ƿ

Explanation
Pretty much boils down to this after decompression:
'A

Wren, 41 bytes
System.write(String.fromCodePoint(88-23))

Try it online!

You're not allowed to use characters 6 and 5 :/

6 and 5 are disallowed because the asker knew someone would try this lol

Pip, 4 bytes
/O@z

Try it online!
Explanation
   z  Lowercase alphabet
  @   First character
 O    Output without newline
/     Invert

That last (first?) instruction requires some more explanation:
By default, Pip prints the last expression in the program with a trailing newline. (This is why we couldn't do @z for 2 bytes, since the challenge states that newlines should be avoided if at all possible.) That's a problem because O@z, in addition to outputting a without a newline, is also an expression that evaluates to a. So O@z by itself would print aa plus a newline.
There are two ways to get rid of the extra output: First, we could output inside an if statement (5 bytes: IzO@z or other similar programs). Second, we could make the final expression in the program evaluate to nil. Nil produces no output when printed, not even the trailing newline. The usual way to suppress auto-printing is to end the program with u, a variable preset to nil. Unfortunately, u is banned. We could use the nil expression (), which would put us back at 5 bytes: O@z().
Enter the unary division operator /, which inverts its operand. In this case, if we invert O@z, the operand is the string a. Non-numeric strings evaluate to 0 in numeric contexts, which means we're dividing by 0. This gives nil, which suppresses the newline exactly as desired.

Wenyan, 39 33 bytes (WIP language)
加陰以『』夫其之二書之

Update: Wenyan now supports 『』 in place of 「「」」 for quoting strings. (starting from v0.1.2)
Literally console.log((false+"")[2-1]) but not using any of +, a and 1
Explanation
　　　　　　　　　書之          // console.log(               )
　　　　　夫其之　　　          //             (        )[ -1]
　陰　　　　　　　　　          //              false
加　以　　　　　　　　          //                   +
　　　『』　　　　　　          //                    ""
　　　　　　　　二　　          //                        2

Note: Indexing in Wenyan is 1-based.

What might make this non-competing?

@pppery For being a language invented in December 2019. I have heard that such restriction is removed, but the challenge was posted in 2016 so I doubt whether the change is applicable here.

That rules change does in fact apply to challenges that predate it.

But 加陰以""夫其之2書之 is only 27 bytes.

Ruby, 16 bytes
$><<[*??..?B][2]

Get's the third element in the range from '?' to 'B', which is 'A'!
Explanation
$><<[*??..?B][2]

    [*      ]     create an array containing the elements from
        ..        the inclusive range from
      ??          literal '?' character to
          ?B      literal 'B' character
                  this array is now ['?', '@', 'A', 'B']
             [2]  get the 3rd element of this array ('A')
  <<              append/write that to
$>                standard output

Try it online!

Google Sheets/Excel (15 bytes)
Assuming your localization is in English:
=MID(2=3,2,2/2)
Note: this will not work on LibreOffice because it will change FALSE to 0 instead of "FALSE".

MAWP, 5 bytes
88WM;

Creates ASCII code for \$8*8+1(existing)=65\$ and outputs it.
Try it!

HTML5, 99 48 47 bytes

 after </script to parse correctly
(old versions)

Try it below:

Deobfuscated (old version):
<!DOCTYPE html>

[!!2].join``[2]

is [true].join("") is true.toString() is "true", and the 2nd index of "true" is u
` ${!2}`[2]

This is " false" index 2, which with the space at the beginning is a (inspired by slebetman)

Nim, 12 bytes
echo'B'.pred

Try it online!

Knight, 10 9 bytes
O G F T T

Try it online!
# print...
OUTPUT(
   # extract a substring
   # Specifically, the "a" from "false"
   GET(
     FALSE # coerces to "false"
     TRUE # 1
     TRUE # 1
   )
)

1 byte to a massive dum moment, thanks MarcMush

O G F T T seems to work too

Lmao I'm dumb....

PICO-8, 16 bytes
?chr(ord("c")-2)

Moves back from C to get to A.

PostScript, 7 bytes
<~@/~>=

Prints "a", which is written using Ascii85 encoding as @/.

Aheui (esotope), 18 bytes
밣따밯타맣희

Try it online!
This answer "cheats" by choosing a language where the entirety of ASCII (other than newline) is meaningless, but constructing a number is hard (the only constants you can push directly are 0 and 2-9, and -1 on EOF). At least 65 is simpler to construct than 97.
A straightforward program that prints charcode 65 would be 7 chars (21 bytes): 밣발다발따맣희, or in pseudo-assembly:
push 8; push 5; add; push 5; mul // pushes 65
putchar; halt

But the program at the top uses a specific behavior of arithmetic operators that, if there are not enough operands, the next direction is reversed. So 밣따 (push 8; mul) at start runs like this:
push 8 // [8]
mul // fails; go back to `push 8`
push 8 // [8, 8]
mul // [64], proceeds to the next command on its right

Then the remaining instructions are:
밯    getchar // push -1 instead because EOF
타    sub     // adds 1 to 64 to get 65
맣희  putchar; halt

(,), 56 Chars or \$56\times \log_{256}(3)\approx\$ 11.09 Bytes
((),()()()()()()()()()()()()())(,,,(())(())(())(())(()))

Google Sheets, 25 bytes
=LEFT(SORT(RITZCODERZ()))

YASEPL, 13 12 bytes
=m$8^=d-:m›

:3

UNBABTIZED, 18 bytes
!0,88.(°0,23.:°0

!0,88. put 88 in cell 0
(°0.23. subtract 23 from cell 0
:°0 print cell 0 as character

Perl6, 20
(?0).comb[3>2].print

Also (88-23).chr.print (17 bytes, from the Ruby answer), but that's arguably degenerate.

Visual C++, 32 bytes
std::clog<<decltype('C')('C'-2);

or
std::clog<<decltype('C')(260>>2);

on the basis of @Karl Napf
dont know why it gets downvoted
it clearly compiles on VisualC++2015 and outputs A on my Machine

1. The downvote was cast automatically by the Community user when you edited your answer. I consider this a bug. 2. I'm not fluent in C++, but this looks like a snippet. Submissions have to be full programs or functions (named or lambdas) by default.

Lolo, 30 bytes
loloLo lOLo lo LOlo LO lOlolol

The only way to make characters in Lolo is to get it's number representation and convert it into a character.
Here, I get 65 which gives me A.

Pyth, 6 bytes
C-*TT3

Try It Online
Explanation
C         ASCII integer to character
  -*TT3    (Ten*Ten)-3 (97)

R, 12 bytes
LETTERS[2/2]

Pretty self-explanatory: LETTERS is all the upper case letters, and 2/2 evaluates to 1, so we get the the first element.

PHP, 19 Bytes
<?=chr(ord('C')-2);

Get the ASCII value for C and take 2 off it.  Doesn't need any special encoding and will work in PHP 4, 5 and 7
If you turn errors off you can reduce it to 17:
<?=chr(ord(C)-2);

turning off errors is not necessary: omitting the quotes will yield a notice; those are not printed with default settings.

R, 12 bytes
letters[2/2] #12 bytes; rules followed!
I tried other ways of doing this, but they broke the rules :(
tail(rev(letters),n=2/2) #24 bytes; uses 'a'
head(letters,n=2/2) #19 bytes; uses 'a'

Forth, 19 bytes
Creates the number 65 (23*3-2-2), then outputs it as the character A.
23 3 * 2 - 2 - emit

Try it online

SmileBASIC, 12 bytes
Self-explanatory.
?CHR$(88-23)

SOGL V0.12, 2 bytes
Κ‘

Try it Here!
A simple compressed string of "A". Really it should be more than a byte (3 bits on saying that it's a character + ~6.5 bits = 8.5 bits = 1 1⁄16 bytes), but I got lucky.

Common Lisp, 33 bytes
(elt(string(type-of 3/2))(- 3 2))

type-of 3/2 returns the symbol RATIO, string transforms it into a string, and finally elt gets the character at index 1 (i.e. A).
Try it online!

AutoHotkey, 19 bytes
Send % Chr(8-2 8-3)

This types a single character, A. It does so through AHK's surprising yet convenient implicit concatenation.
Send tries to write a string.
%tells it to use the value of an expression (Rather than just plaintext)
Chr() converts a number to a character. 8-2 8-3 evaluates to 6 5 which evaluates to 65, the ASCII code for A.

Recursiva, 4 bytes
Y(L'

Try it online!
Explanation:
Y(L'
Y     - From, Take n-th element 'A'
 (    - Upper-case alphabet 'ABC...Z'
  L   - Length of i.e. 0
   '  - empty string

VBA, 19 Bytes
Anonymous VBE immediate window function that takes no input and outputs A to the VBE immediate window
?Chr(-(-32-32-3)-2)

PHP 21 or 67 Bytes
Try it online
Kinda cheating but implode on $_SERVER just leaves a on the 8th position
<?=join($_SERVER)[8];

Else
Creating an array of letter strating at chr(88) and end it at chr(33) leaves an A at position 23
<?php $u=[];for($i=88;$i>33;$i--){$u[]=chr($i);}echo join($u)[23];

Pepe, 10 bytes
reeEEeeeeE

Try it online!
reeEEeeeeE pushes a to stack and outputs it.

Japt -g, 2 bytes
;B

Test it here

C# (.NET Core), 44 bytes
Console.Write(Convert.ToString(33-23, 8*2));

Try it online!
Converts the decimal value 10 to its hexadecimal equivalent (a).

Aheui (esotope), 21 bytes
밡밤다발따맣홄

Try it online!

Explanation:
밡: push 9, move cursor right by 1(→).
밤: push 4, →
다: add, →
발: push 5, →
따: mul, →
맣: print as character, →
홄: end.

Lean Mean Bean Machine, 11 9 bytes
O
"
b
)
!

Try it online!
O Spawn a marble,
"b set it to b,
) decrement it,
! print it.
I don't recall when this was changed, but LMBM now automatically destroys a marble if it falls out of bounds, so the ; is no longer needed

MBASIC, 19 bytes
2 PRINT CHR$(88-23)

I swear I came up with this solution before finding those other (similar) BASIC answers. Apparently great minds do think alike. :-)

AppleScript, 16
string id(88-23)

Number Factory, 4 bytes
%>>%

You can test it with my interpreter.
There are several coincidences that together make this as short as it is:

The factory contains a room specifically for the output of letters.
The encoding scheme used by that room is 1-indexed.
The initial room contains 1.
The initial room and the alphabetic output room are only 2 squares apart.

Runic Enchantments, 6 bytes
'Bl-k@

Try it online!
"length of stack" acts as a placeholder for the value 1. 'Lb-k@ and 'C2-k@ both also work and are the same number of bytes.

Keg, 1 byte (SBCS)
Ȧ

Ah, yes, restricted-source challenges. The exact thing the push'n'print feature was added to Keg for. Very simple this program: just print the letter a to output.
No, it's not cheating because it's a feature designed for all restricted source challenges. And also, Ȧ doesn't have any forbidden code points.
No TIO yet because it needs a quick update but works on the Github interpreter (just make sure to use Keg.py)

05AB1E, 6 4 bytes
2<.b

Try it online!
Explanation
2<    # push 2 and decrement (now 1 is on the stack)
  .b  # push the [top value]th letter of the alphabet (the 1st letter)
      # implicit output

So I assume this is a duplicate of another answer?

@a'_' I'm not allowed to use 1 EDIT: just found a better solution

BBC Basic IV, 19 15 bytes
23PRINTCHR$(88-23)

Older Answer: 19 bytes
23PRINTCHR$(8^2-(2-3))

The statement...
P.TOP-PAGE

...shows the size of the program, which is 19 bytes.

PRINTCHAR has A inside.

It's PRINTCHR$, there is no A. I have a typo and have corrected it.

Befunge-93, 7 bytes
"}<"-,@

Try it online!
Explanation
"}<"        Push 125 and 60 using ASCII mode
    -       Subraction
     ,      Print as ASCII
      @     End the program (so you don't get AAAAAA... :) )

Pxem, 9 bytes (filename) + 0 bytes (content) = 9 bytes.

Filename: CBB.-.-.o
Content: none.

The code is equivalent to:
push 'B'
push 'B'
push 'C'
push(abs(pop()-pop())) if size>=2 else nop
push(abs(pop()-pop())) if size>=2 else nop
printf("%c",pop()) if size>=1 else nop

Pxem, 6 bytes: filename.
First two characters are as escaped notation.
\303\003.$.p

Try it online!

Python 3, 33 bytes
print(chr(223-33-33-33-33--3--3))

Try it online!

StupidStackLanguage, 9 bytes
rvvddqmif

Try it online!
Explanation
r         # push length of stack (0)
 vvdd     # push 8 to stack
     qm   # square
       i  # increment
        f # print as ASCII

Flobnar, 8 bytes
!g<
@:*,

Try it online!
Uses the initial value 0 of : (the current argument), and the fact that 33 ('!') * 33 % 256 == 65 == 'A'. Other candidates include:
95 ('_') * 95 % 256 == 65 == 'A'
49 ('1') * 49 % 256 == 97 == 'a'
79 ('O') * 79 % 256 == 97 == 'a'

but all of these are either not useful or simply banned. Particularly it is too bad that 7 is also banned.
@        Start here, facing west
,        Evaluate and print mod 256 as char (using -w flag):
*          Multiply its north and south (both of which point to <)
<          Evaluate to left
g          Take north as x and south as y, and get the code value at (x,y)
:          Both x and y evaluate to 0
         (0,0) is '!' == 33, so (33 * 33 = 1089) % 256 = 65 = 'A' is printed

what about          88-23

@Hippopotomonstrosesquipedalian Flobnar doesn't have two-digit number literals.

Kustom, 33 bytes
$tc(reg,tc(type,أ),".....$","")$

explained:
$tc(reg,      regex replace
  tc(type,أ),  text type of some Arabic character (="ARABIC")
  ".....$",   replace 5 characters at the end...
  ""          ... with the empty string
)$

Thunno, \$ 5 \log_{256}(96) \approx \$ 4.12 bytes
Z23-C

Attempt This Online!
Explanation
Z23-C  # No inputs
Z2     # Push 100
  3    # Push 3
   -   # Subtract to get 97
    C  # Get the character at that codepoint ('a')
       # Implicit output

Thunno, \$ 6 \log_{256}(96) \approx \$ 4.94 bytes
Z3Z2/h

Attempt This Online!
Explanation
Z3Z2/h  # No inputs
Z3      # Push 1000
  Z2    # Push 100
    /   # Divide to get 10
     h  # Convert to hexadecimal to get 'a'
        # Implicit output

Thunno, \$ 7 \log_{256}(96) \approx \$ 5.76 bytes
88 23-C

Attempt This Online!
Explanation
88 23-C  # No inputs
88       # Push 88
   23    # Push 23
     -   # Subtract to get 65
      C  # Get the character at that codepoint ('A')
         # Implicit output

How does the character encoding work in this language? it's physically impossible to have a fraction of a bit!

@Hippopotomonstrosesquipedalian it doesn't actually have a fraction of a bit. It's just an approximation of how much it would take up, since Thunno uses only the 96 printable ASCII characters. It's allowed by Meta rules.

Fig, \$3\log_{256}(96)\approx\$ 2.469 bytes
[cB

Try it online!
Didn't see that there was another Fig answer, but here's a different version.
[cB
 cB # "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
[   # First char of the above

GolfScript, 7 bytes
'B'{(}%

Try it online!

Python 3, 17 Bytes
print(chr(88-23))

$$88-23=65$$

Duplicate answers are ok, but just wanted to let you know that this has already been posted

C89, 22 bytes
f(){printf("%c",833);}

Explanation
$ man 3 printf || info '(libc)Other Output Conversions'

"%c ... the int argument is [first] converted to an unsigned char,"

'A' == 65
\$833 \equiv 65\ (\textrm{mod}\ 256)\$

Try it online!

Deadfish~, 10 bytes
iisiiiisic

Try it online!

Python, 32 bytes
print(chr(ord("@")-(-ord("pretend this is SOH"))))

The character in the second ord there is SOH. SOH, which is ASCII 1, is negated and subtracted from @, which is ASCII 64, to make ASCII 65, which is A.

authors: n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳


text:
Repetition of letters
Your task is to take an input, for example:
a,b,4,5
And produce an output, which per this example is aaaabbbbb
a,b,4,5 means: the lowercase character "a" is repeated 4 times, and is then followed by the lowercase character "b" repeated 5 times, making the total number of characters 4+5=9
Another example: the input a,B,5,4, should produce the output aaaaaBBBB, which is: the lowercase letter "a" is repeated 5 times, followed by the uppercase letter "B" repeated 4 times.
Some more examples:
Input --> Output

a,b,4,6         --> aaaabbbbbb
a,b,c,1,2,3     --> abbccc
a,e,d,f,g,1,2,3,4,5 --> aeedddffffggggg
A,b,4,5         --> AAAAbbbbb
A,b,C,1,2,3     --> AbbCCC
A,B,c,D,1,2,3,4 --> ABBcccDDDD

Note how the output must have only the required letters, nothing else, except trailing newlines.
The format of the input should be exactly as you see in the above examples, so your code does not have to support any additional formats/styles of the input.
The output must be displayed in a format exactly as the examples show, this means no commas, spaces, etc, separating the letters. Trailing newlines are okay, if you cannot avoid them.
Standard loopholes are disallowed, and the output is case sensitive.
This is code-golf, so the shortest code in bytes wins!

will the numbers always be increasing?

Nope. They don't have to be.

This seems quite similar to Run Length Decoding.

@ColdGolf Stricter input/output is a pretty trivial modification to a challenge.

My  challenge's input and output seem to be the reverse of the linked challenge.

Will the numbers always be one digit, as in your examples?

Nope, not always, they can be anything.

@ColdGolf can we accept input as a list or list of letter-number pairs? I ask because the language I'm thinking of doesn't do well with string parsing, and it's lists look funny when typed out....

The input must be the same format as the post.

Dear administration, it is not the duplicate of the one of link , or if it is, the original one is a question incomprehensible

05AB1E, 11 bytes
',¡2äøvy`×?

Explanation
',¡             # turn input into a list split at commas
   2ä           # divide that list in 2
       ø        # zip, turning the list into pairs of [letter, number]
        v       # for each pair
         y`×?   # print letter number of times

Try it online

Pyth -  14 bytes
Ac2cz\,s*VGsMH

Try it online here.

Python 2 - 88 bytes
X=map(str,input().split(','))
k=len(X)/2
print''.join(X[i]*int(X[i+k])for i in range(k))

Edited to remove whitespace

Quoted input is acceptable, so you can do input() instead of raw_input(). Additionally, you can drop the whitespace between print and '', and between ) and for. Be sure to take a look at http://codegolf.stackexchange.com/q/54/45941 for more golfing suggestions! I've also changed the header to Python 2, because we typically only use "Python" for code that can run under either 2 or 3. Last but certainly not least, welcome to PPCG!

idk if it'll be shorter, but chopping in half can also be done through zip(*[iter(foo)]*2)

APL, 26 bytes
{(∊(//)C⎕VFI⍵)/⍵~⎕D,C←','}

Test:
          {(∊(//)C⎕VFI⍵)/⍵~⎕D,C←','}'A,b,C,1,2,3'
AbbCCC

APL has a built-in for this, so all the code is really doing is parsing the string:
      1 2 3/'AbC'
AbbCCC

Explanation:

⍵~⎕D,C←',': remove all digits and commas from the input, leaving only the letters. (Since it only has to deal with single letters, this works.)
∊(//)C⎕VFI⍵: using the comma as a field separator, get all valid numbers in the input.
/: replicate each letter by the required amount

Same basic idea: {(⍎⍵∩c)/⍵~c←⎕D,','}

PHP, 84 bytes
$b=split(',',$argv[1]);while($i<$n=count($b)/2)echo str_repeat($b[+$i],$b[$n+$i++]);

Takes the input string as the first argument as in php script.php a,B,c,3,2,6.

Python 2, 66 bytes
i=input();l=len(i)/2
print''.join(s*y for s,y in zip(i[:l],i[l:]))

Uses every Python golfer's favourite function, zip(). Takes input with letters in quotes e.g.:
'a','b',4,6

Ideone it!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes