Crea una funzione che ha dato un numero di righe n, crea un bigA.

• La barra orizzontale di bigAdeve essere nella riga centrale, o la più bassa delle due sen è pari
• Assumi un carattere monospace per l'output

L'output dovrebbe essere una stringa (o simile, ad esempio un array di caratteri) con chiare interruzioni di riga per spezzare le linee e con spazi bianchi corretti per il riempimento a sinistra (si può supporre che siano 4 spazi). Ci possono essere spazi bianchi sulla destra.

Esempi

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

Questo si ispira a Crea una "H" da "H" più piccole

05AB1E , 13 byte

Codice:

Ð;î¹)'A1376SΛ

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione:

Ð                  # 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.

Tela

Probabilmente dovrei documentare un po 'di più la tela (e molte altre funzioni), ma questo in sostanza lo riassume. L'area di disegno ha "modalità" diverse in base ai tipi di parametro forniti. Il comando canvas ha tre parametri: <length> <string> <direction> .

Poiché i parametri di lunghezza e direzione sono elenchi, "zip" questi elenchi per creare un insieme di istruzioni da eseguire. Il parametro string è solo la lettera A , quindi questo è il carattere di riempimento utilizzato da tutte le istruzioni. Il canvas interpreta questo come il seguente set di istruzioni (per input 7):

• Traccia una linea di lunghezza 7 con la stringa A in direzione ↗
• Traccia una linea di lunghezza 7 con la stringa A in direzione ↘
• Traccia una linea di lunghezza 4 con la stringa A in direzione ↖
• Traccia una linea di lunghezza 7 con la stringa A in direzione ←

Le indicazioni sono tradotte nel modo seguente:

7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

Se non è stato emesso nulla, 05AB1E emette automaticamente il risultato della tela.

Carbone , 17 15 byte

ＮθＰ×θAＭ⊘θ↗Ｐ^×θA

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Input n.

Ｐ×θA

Stampa la barra orizzontale del grande A. (Per i numeri pari, il n+1th si sovrappone comunque al lato destro.)

Ｍ⊘θ↗

Vai in cima al big A.

Ｐ^×θA

Stampa su entrambi i lati del grande A.

Python 2 , 80 byte

lambda n:'\n'.join(' '*(n+~i)+('A'+' A'[i==n/2]*n*2)[:i*2]+'A'for i in range(n))

Provalo online!

Dividi l'output desiderato nello spazio bianco sinistro, a sinistra Apiù gli spazi bianchi centrali, oppure a Adestra A. Calcola la parte centrale usando lo slicing su una stringa fissa. Ciò consente di utilizzare lo stesso modo per generare la prima riga.

Stax , 15 byte

┴3╬*ôP^x'┌_╓J²♫

Esegui ed esegui il debug

Disimballato, non modificato e commentato, il programma si presenta così.

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)

Esegui questo

JavaScript (ES6), 77 byte

Questo codice sorgente ha una forma rettangolare ! Oh aspetta ... sfida sbagliata: - /

f=(n,k=n>>1,p='A')=>--n?f(n,k,' '+p)+`
${p}${(k-n?' ':'A').repeat(n*2-1)}A`:p

Provalo online!

Python 3.6 , 79 byte o 73 byte

Utilizzo delle stringhe f per allineare le parti orizzontali della lettera:

lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}"[:-1]+'A'for i in range(n))

Con \busato per eliminarne uno A(possibilmente barare):

lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}\bA"for i in range(n))

Java (JDK 10) , 124 byte

n->{var a=new char[n][n+n-1];for(int c=n,r;c-->0;)for(r=n;r-->0;)a[r][n+n-c-2]=a[r][c]+=r==n/2&c>=r|r==n+~c?65:32;return a;}

Provalo online!

J , 65 byte

f=:3 :''' A''{~1(([:(<@;]+i.@+:)<.@-:)y)}([:(}:@|."1,.])=/~@i.)y'

Provalo online!

Può essere ridotto di ca. 12 byte semplicemente rendendo il verbo tacito, ma ho problemi a farlo.

Spiegazione:

3 : '...' indica un verbo esplicito di una riga

y è l'argomento

=/~@i. crea una matrice di identità con dimensione l'argomento

    =/~@i. 4
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

([:(}:@|."1,.]) antepone la matrice identità con la sua copia speculare con gli ultimi elementi di ogni riga rilasciati.

    ]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(...)}(...) cambia in 1 le posizioni nel suo argomento destro, selezionato da quello sinistro

([:(<@;]+i.@+:)<.@-:) - prepara la selezione procedendo come segue:

               <.@-: - 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'{~ rende uno spazio nei punti 0 e 'A' dove c'è 1

    ' A'{~1(([:(<@;]+i.@+:)<.@-:) 4)}a
   A   
  A A  
 AAAAA 
A     A

Tela , 17 13 byte

A×／╶½A×╶»╵：╋│

Provalo qui!

-4 byte grazie a dzaima !

Rubino , 66 byte

->n{(0...n).map{|i|(s=(i==n/2??A:?\s)*2*i+?A)[0]=?A;?\s*(n+~i)+s}}

Provalo online!

Restituisce come matrice di linee

SOGL V0.12 , 12 byte

 A*:╚╥≤.»I:ž

Provalo qui!

Spiegazione:

 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

Japt -R , 20 19 byte

Çç" A"gZ¶Uz¹i'A êÃû

Provalo

Spiegazione

                        :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

Alternativa

(Nella speranza che possa aiutarmi a individuare alcuni risparmi!)

Æ'AúXÄ" A"gX¶Uz¹êÃû

Rubino , 73 byte

->n{(0...n).map{|i|(?A.ljust(i*2,i==n/2??A:' ')+(i>0??A:'')).center n*2}}

Provalo online!

Gelatina , 23 20 19 18 byte

=þ`o\L‘HĊƲ¦UŒBị⁾A 

Provalo online!

=þ`crea una matrice di identità di dimensioni n.

L‘HĊƲtrova l'indice di riga della barra orizzontale ¦selezionando quella riga e applicandola o\ad essa che crea la barra.

Uinverte ogni riga in modo da non avere una "A" capovolta e ŒB(palindromize; vettorializza) crea la seconda metà della "A".

ị⁾A(con uno spazio che viene tagliato nella formattazione) sostituisce 0s con spazi e 1s con As.

T-SQL , 182 177 byte

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

Prima versione (con 182 byte):

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

La versione precedente funziona fino a @ n = 9.

Ecco un'altra versione, che funziona fino a @ n = 23, ma ha 2 byte extra:

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

Haskell , 98 97 95 byte e 109 byte

Due approcci molto diversi. Primo (95 byte):

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

e secondo (109 byte):

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

Provali qui! ; Prova qui la versione modificata!

Prova qui la terza versione!

Python 2 , 70 byte o 65 byte

L'elenco delle stringhe è un risultato accettabile, come indicato da @Budd nei commenti.

lambda n:['%*sA\n'%(n+i,('A'+i*2*' A'[i==n/2])[:-1])for i in range(n)]

Provalo online!

Soluzione apparentemente economica, usando \b. Sembra funky in TIO, in console fa il lavoro.

lambda n:['%*s\bA\n'%(n+i,'A'+i*2*' A'[i==n/2])for i in range(n)]

Provalo online!

Javascript, 124 byte

Una soluzione abbastanza ingenua, ha dato un colpo per esercitarsi nelle abilità js.

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)){}

Perl 5 -n , 57 byte

#!/usr/bin/perl -n
say$"x-$_.uc(A x($n+$_&-2?1:$n*2)|$"x2x$n++.A)for 1-$_..0

Provalo online!

Python 3 , 93 , 88 byte

lambda n:'\n'.join(f"{'A'+(x>0)*('A '[x!=n//2]*(x*2-1)+'A'):^{n*2-1}}"for x in range(n))

Provalo online!

-3 di @ovs usando f-string