[Question]
  [
Create a function which given a number of lines `n`, makes a `bigA`.
* The horizontal bar of `bigA` must be at the middle row, or the lower of the two if `n` is even
* Assume a monospace font for output
Output should be a string (or similar, eg character array) with clear linebreaks to break up the lines, and with correct whitespace for left-padding (you can assume \t to be 4 spaces). There can be any whitespace on the right. 
## Examples
### n = 1
`A`
### n = 2
```
 A
AAA
```
### n = 3
```
  A
 AAA
A   A
```
### n = 4
```
   A
  A A
 AAAAA
A     A
```
### n = 5
```
    A
   A A
  AAAAA
 A     A
A       A
```
This is inspired by [Create an "H" from smaller "H"s](https://codegolf.stackexchange.com/questions/157664/create-an-h-from-smaller-hs)
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
### Code:
```
Ð;î¹)'A1376SΛ
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f//8ATrw@sO7dRUdzQ0NjcLPjf7/39zAA "05AB1E – Try It Online")
### Explanation:
```
Ð                  # Triplicate the input.
 ;î                # Compute ceiling(n / 2).
   ¹               # Push the first input again.
    )              # Wrap into an array. For input 7, this would result in:
                     [7, 7, 4, 7].
     'A            # Push the character 'A'
       1376S       # Push the array [1, 3, 7, 6]. These are the directions of the canvas.
                     This essentially translates to [↗, ↘, ↖, ←].
            Λ      # Write to canvas using the previous three parameters.
```
### Canvas
I should probably document the canvas a little bit more (and a lot of other functions), but this basically sums it up. The canvas has different 'modes' based on the parameter types given. The canvas command has three parameters: **<length> <string> <direction>**. 
Since the length and direction parameters are lists, it 'zips' these lists to create a set of instructions to be executed. The string parameter is just the letter **A**, so this is the fill character used by all instructions. The canvas interprets this as the following set of instructions (for input 7):
* Draw a line of length **7** with the string **A** in direction **↗**
* Draw a line of length **7** with the string **A** in direction **↘**
* Draw a line of length **4** with the string **A** in direction **↖**
* Draw a line of length **7** with the string **A** in direction **←**
The directions are translated in the following manner:
```
7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3
```
If nothing has been outputted, 05AB1E automatically outputs the canvas result.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~17~~ 15 bytes
```
ＮθＰ×θAＭ⊘θ↗Ｐ^×θA
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05rLtzSnJLOgKDOvRCMkMze1WKNQR0HJUUkTJJVflqrhkZhTlpoCVKqjYBVaEJSZnlGCqssqTkcBTef//yb/dctyAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input `n`.
```
Ｐ×θA
```
Print the horizontal bar of the big `A`. (For even numbers, the `n+1`th overlaps the right side anyway.)
```
Ｍ⊘θ↗
```
Move to the top of the big `A`.
```
Ｐ^×θA
```
Print both sides of the big `A`.
[Answer]
# [Python 2](https://docs.python.org/2/), 80 bytes
```
lambda n:'\n'.join(' '*(n+~i)+('A'+' A'[i==n/2]*n*2)[:i*2]+'A'for i in range(n))
```
[Try it online!](https://tio.run/##XcoxDsIwDEbhq3iznSCgGSNl6DnaDkEQMII/VdSFhauHzqzve@tne1SEXtLcX/l9uWZC5Bl8fFaDMLET@K@pFx7ZM408WUo4hcXBBZ2iubD43UptZGSglnG/CVT7XxoOw1nj2gybFLF9@AE "Python 2 – Try It Online")
Divide the desired output into the left whitespace, left `A` plus middle whitespace or `A`s, and the right `A`. Compute the middle part using slicing on a fixed string. This allows to use the same way to generate the first line.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 15 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
┴3╬*ôP^x'┌_╓J²♫
```
[Run and debug it](https://staxlang.xyz/#p=c133ce2a93505e7827da5fd64afd0e&i=1%0A2%0A4%0A5&a=1&m=2)
Unpacked, ungolfed, and commented, the program looks like this.
```
m       map over [1 .. input] using rest of the program, output each result
'A      "A" literal
xhi=    is the iteration index equal to (integer) half the input?
65*     multiply by 65 (character code of "A")
]i*     repeat that character (" " or  "A") i times
+       concat to initial "A"
x)      left pad to the original input
|p      palindromize (concatenate the reverse minus the last character)
```
[Run this one](https://staxlang.xyz/#c=m+++%09map+over+[1+..+input]+using+rest+of+the+program,+output+each+result%0A%27A++%09%22A%22+literal%0Axhi%3D%09is+the+iteration+index+equal+to+%28integer%29+half+the+input%3F%0A65*+%09multiply+by+65+%28character+code+of+%22A%22%29%0A]i*+%09repeat+that+character+%28%22+%22+or++%22A%22%29+i+times%0A%2B+++%09concat+to+initial+%22A%22%0Ax%29++%09left+pad+to+the+original+input%0A%7Cp++%09palindromize+%28concatenate+the+reverse+minus+the+last+character%29&i=1%0A2%0A4%0A5&a=1&m=2)
[Answer]
# JavaScript (ES6), 77 bytes
This source code has a [rectangle shape](https://codegolf.stackexchange.com/q/160034/58563)! Oh wait ... wrong challenge :-/
```
f=(n,k=n>>1,p='A')=>--n?f(n,k,' '+p)+`
${p}${(k-n?' ':'A').repeat(n*2-1)}A`:p
```
[Try it online!](https://tio.run/##bcqxCoMwFEDR3a/oICSvSYTYdhGS4n90MNiktMrLQ6WL@O2pjoWs596P@7q5n960KIxPn1IwHOVg0FotybCWgbFK4T0cLNmJCQLRFeVKW7nyYS@7NcdXTZ68Wziea6Vha7uGUh9xjqOvxvjigWsQ7IEMin@u83zJ8zXPN4D0Aw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3.6](https://docs.python.org/3/), 79 bytes or 73 bytes
Using **f-strings** to align horizontal parts of the letter:
```
lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}"[:-1]+'A'for i in range(n))
```
With `\b` used to delete one `A` (possibly cheating):
```
lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}\bA"for i in range(n))
```
[Answer]
# [J](http://jsoftware.com/), 65 bytes
```
f=:3 :''' A''{~1(([:(<@;]+i.@+:)<.@-:)y)}([:(}:@|."1,.])=/~@i.)y'
```
[Try it online!](https://tio.run/##y/r/P83WyljBSl1dXcFRXb26zlBDI9pKw8bBOlY7U89B20rTRs9B10qzUrMWJF5r5VCjp2Sooxeraatf55Cpp1mp/j81OSNfIU3BiAvKMIUxDA3@AwA "J – Try It Online")
It can be reduced by approx. 12 bytes by simply making the verb tacit, but I have problems doing it.
## Explanation:
`3 : '...'` denotes an explicit one-liner verb
`y` is the argument
`=/~@i.` creates an identity matrix with size the argument
```
    =/~@i. 4
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
```
`([:(}:@|."1,.])` prepends the identity matrix with its mirror copy with last elements of each row dropped.
```
    ]a =. ([:(}:@|."1,.])=/~@i.) 4
0 0 0 1 0 0 0
0 0 1 0 1 0 0
0 1 0 0 0 1 0
1 0 0 0 0 0 1
```
`1(...)}(...)` changes to 1 the positions in its right argument, selected by the left one
`([:(<@;]+i.@+:)<.@-:)` - prepares the selection by doing the following:
```
               <.@-: - halves the argument and finds the floor (finds the row number)
    <@;              - box the row, followed by a list of columns:  
        ]+i.@+:      - a list form the argumnt to the doubled row number
    ([:(<@;]+i.@+:)<.@-:) 4
┌───────────┐
│┌─┬───────┐│
││2│2 3 4 5││
│└─┴───────┘│
└───────────┘
    1(([:(<@;]+i.@+:)<.@-:) 4)}a
0 0 0 1 0 0 0
0 0 1 0 1 0 0
0 1 1 1 1 1 0
1 0 0 0 0 0 1
```
`' A'{~` renders a space in the places of 0 and 'A' where there is 1
```
    ' A'{~1(([:(<@;]+i.@+:)<.@-:) 4)}a
   A   
  A A  
 AAAAA 
A     A
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~17~~ 13 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
A×／╶½A×╶»╵：╋│
```
[Try it here!](https://dzaima.github.io/Canvas/?u=QSVENyV1RkYwRiV1MjU3NiVCREElRDcldTI1NzYlQkIldTI1NzUldUZGMUEldTI1NEIldTI1MDI_,i=MTQ_)
*-4 bytes thanks to [dzaima](https://codegolf.stackexchange.com/users/59183/dzaima)!*
[Answer]
# [Java (JDK)](http://jdk.java.net/), 121 bytes
```
n->{var a=new char[n][n+n-1];for(int c=n*n,r,q;c-->0;a[r=c%n][q=c/n]=a[r][n+n-q-2]+=r==n/2&q>=r|r==n+~q?65:32);return a;}
```
[Try it online!](https://tio.run/##bVBNT4NAEL3zKyYkNVAK/TB66HYxxsTEg6cekcO6hboVBphdamqtf71uC40HPUzezL73dj42YivCzer9qMq6IgMbW0etUUU0ZM6ft7xFaVSF/5LaUCbKE@XIQmgNz0Ih7B2Aun0tlARthLGwrdQKSst5S0MK10kKgtbaP0sBntA89m0W8k1QkiZpDDnwI4bxfisIBMfsA84cpgkGGE5TllfkKTQgOQ5xRKOGyTCMJ0wkxOXA6houx5hyW3eeJpylASfOcTy7amJOX6c8@G7ubm/m1zOfUWZaQhDscGTnyS4tFHCYMgsLixObBMFleIDLyECZbgtjpXkk6rrYecpnvabbG7Ql74nETve38zqPH5Wi7o8zn9td/UhWRZFJ4z10WJGONpVCK/DcF3T936932mRlVLUmqq3f5J67VJ/ZHAarAQ60DXRHagS6dxycUxxO6fEH "Java (JDK) – Try It Online")
## Credits
* -3 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 66 bytes
```
->n{(0...n).map{|i|(s=(i==n/2??A:?\s)*2*i+?A)[0]=?A;?\s*(n+~i)+s}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWsNAT08vT1MvN7GguiazRqPYViPT1jZP38je3tHKPqZYU8tIK1Pb3lEz2iDW1t7RGiikpZGnXZepqV1cW/tfxc7GJi3aJFbLPibvPwA "Ruby – Try It Online")
Returns as array of lines
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 12 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
 A*:╚╥≤.»I:ž
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTIwQSolM0EldTI1NUEldTI1NjUldTIyNjQuJUJCSSUzQSV1MDE3RQ__,inputs=NA__,v=0.12)
Explanation:
```
 A*           repeat "A" input times
   :          duplicate it
    ╚         create a "/" diagonal of one of the copies of As
     ╥        palindromize it horizontally
      ≤       get the other copy of the "A"s on top
       .»I:   push floor(input/2)+1 twice
           ž  and at those coordinates in the palindromized diagonals place in the row of As
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-R`, ~~20~~ 19 bytes
```
Çç" A"gZ¶Uz¹i'A êÃû
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=x+ciIEEiZ1q2VXq5aSdBIOrD+w==&input=OAotUg==)
---
## Explanation
```
                        :Implicit input of integer U
Ç                       :Create the range [0,U) and pass each Z through a function
         Uz             :  Floor divide U by 2
       Z¶               :  Test for equality with Z (true=1, false=0)
  " A"g                 :  Get the character in the string " A" at that index
 ç                      :  Repeat Z times
           ¹            :  (Closes a few nested methods)
            i'A         :  Prepend an "A"
                ê       :  Palindromise
                 Ã      :End function
                  û     :Centre pad each element to the length of the longest element
                        :Implicitly join with newlines and output
```
---
## Alternative
(In the hope that it might help me spot some savings!)
```
Æ'AúXÄ" A"gX¶Uz¹êÃû
```
[Answer]
# Javascript, 124 bytes
A fairly naive solution, gave it a shot to practice js skills.
`for(i=-1,p=" ".repeat(n-1)+"A ";++i<n;console.log(i-~~(n/2)?p:p.slice(0,i)+"A".repeat(n)),p=p.slice(1,n)+" "+p.slice(n-1)){}`
Unpacked
```
for(
 //create the first line
 i=-1, p=" ".repeat(n-1)+"A "; 
 ++i<n;
 console.log( 
 //if we are not at the bar
      i-~~(n/2)?
 //otherwise, use the modified previous line
      p
 //slice the start of the previous line and add As
      :p.slice(0,i)+"A".repeat(n)), 
 //add a space in between the previous line and remove padding on each side
 p=p.slice(1,n)+" "+p.slice(n-1)){}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 73 bytes
```
->n{(0...n).map{|i|(?A.ljust(i*2,i==n/2??A:' ')+(i>0??A:'')).center n*2}}
```
[Try it online!](https://tio.run/##HcfdCkAwFADgV9ndfnBo5UZty3PgAlFHnDRzITz7lO/u8@dwxdnEzNItCgAgCVu/3w8@wtWwLucRBCqdojGUa@fqijMuE4G2@MOlhHGiMHlGSr9v3D1SYHNTdsq1FD8 "Ruby – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~23~~ ~~20~~ ~~19~~ 18 bytes
```
=þ`o\L‘HĊƲ¦UŒBị⁾A 
```
[Try it online!](https://tio.run/##ASwA0/9qZWxsef//PcO@YG9cTOKAmEjEisaywqZVxZJC4buL4oG@QSD/w4dZ//80MA "Jelly – Try It Online")
`=þ`` creates an identity matrix of size `n`.
`L‘HĊƲ` finds the row index of the horizontal bar with `¦` picking that row out and applying `o\` to it which creates the bar.
`U` reverses each row so we don't have an upside down "A" and `ŒB` (palindromize; vectorizes) makes the second half of the "A".
`ị⁾A` (with a space that is getting trimmed in the formatting) replaces `0`s with spaces and `1`s with `A`s.
[Answer]
# [T-SQL](https://www.microsoft.com/sql-server), ~~182~~ 177 bytes
```
DECLARE @n INT=5DECLARE @ INT=0a:DECLARE @s VARCHAR(9)=STR(POWER(10,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1IF @<@n GOTO a
```
First version (with 182 bytes):
```
DECLARE @n INT=5DECLARE @ INT=0WHILE @<@n BEGIN DECLARE @s VARCHAR(9)=STR(POWER(10,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1 END
```
The version above works up to @n=9. 
Here is another version, which works up to @n=23, but has 2 extra bytes:
```
DECLARE @n INT=5DECLARE @ INT=0WHILE @<@n BEGIN DECLARE @s VARCHAR(23)=STR(POWER(10.,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1 END
```
Ungolfed:
```
DECLARE @n INT=5
DECLARE @i INT=0
WHILE @i<@n BEGIN
    DECLARE @s VARCHAR(9)=STR(POWER(10,@i),@n)
    PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@i=@n/2,'A',' '))
    SET @i+=1
END
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~98~~ ~~97~~ 95 bytes and 109 bytes
Two very different approaches. First (95 bytes):
```
c!n=([1..n]>>c)++"A"
f n=unlines[" "!(n-x)++drop 3([" "!(abs$n`div`2-x+1)!!0]!(2*x))|x<-[1..n]]
```
and second (109 bytes):
```
m True='A'
m _=' '
g n=unlines[[m(abs(n-j)==l||l==q&&elem j[q+1..q+n])|j<-[1..2*n]]|l<-[0..n-1],q<-[n`div`2]]
```
~~[Try them here!](http://rextester.com/PDHKH9517)~~; ~~[Try modified version here!](http://rextester.com/TBXH98462)~~
[Try third version here!](http://rextester.com/SLVQ22299)
[Answer]
# [Python 2](https://docs.python.org/2/), 70 bytes or 65 bytes
List of strings is acceptable result, as @Budd stated in comments.
```
lambda n:['%*sA\n'%(n+i,('A'+i*2*' A'[i==n/2])[:-1])for i in range(n)]
```
[Try it online!](https://tio.run/##Xc29DsIgEADgWZ/iluY4ipoyOJAwsPcNKAPGvzN6NNjFp6edXb/lm3/Ls4hto5/aO38u1wziInb6GybBTknPRmHAnrXVCAEjey8nmyi6w5DoXiowsEDN8rgpodT@aDBncvvdXFkWQDy@CosaFRMZwO1oKw "Python 2 – Try It Online")
---
Seemingly cheaty solution, using `\b`. It looks funky in TIO, in console it does the job. 
```
lambda n:['%*s\bA\n'%(n+i,'A'+i*2*' A'[i==n/2])for i in range(n)]
```
[Try it online!](https://tio.run/##Xcy9DsIgFAbQWZ/iLs0FSjQyODRhYO8blA40/l1TPxrs0qenzq5nOMu2vjJc7X2sc/pMt0ToBm7MN04hghuFViwHbsU4wxR4EO9xdqN@5EJCAioJz7uCHusfXexVd8fDUgQrMZ/eWaB6JVpb4l9edw "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 57 bytes
```
#!/usr/bin/perl -n
say$"x-$_.uc(A x($n+$_&-2?1:$n*2)|$"x2x$n++.A)for 1-$_..0
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJFqUJXJV6vNFnDUaFCQyVPWyVeTdfI3tBKJU/LSLMGKG1UARTV1nPUTMsvUjAEKdYz@P/f8l9@QUlmfl7xf928/7q@pnqGBnoGAA "Perl 5 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 93, 88 bytes
```
lambda n:'\n'.join(f"{'A'+(x>0)*('A '[x!=n//2]*(x*2-1)+'A'):^{n*2-1}}"for x in range(n))
```
[Try it online!](https://tio.run/##FYvBCoJAFADP9RUvQd5b3TK1LoKB36EGG7pl1FsxD7uI3256nGGmd@PLcLrovFo@6vtoFHCGFePpbTom7U1YYEj2dhYBYQFY2kPOUZTUAdkgOcYiXAOR3SfeaJ49bQaw0DEMip8tsRDLptymylhCIiGVcJFwrbP9rh86Hgn9pmL/hz45qcmJ9fkD "Python 3 – Try It Online")
-3 by @ovs using f-string
]