Alphabet triangle

Question

You are to print this exact text:

A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

Specs

• Extra trailing newlines are allowed at the end of the output.
• Extra trailing spaces (U+0020) are allowed at the end of each line, including the extra trailing newlines.
• You can use all lowercase instead of all uppercase, but you cannot print partially lowercase partially uppercase.
• You can return the text as a function output instead of printing it in a full program.

Scoring

Since this is a triangle, and a triangle has 3 sides, and 3 is a small number, your code should be small in terms of byte-count.

Answer 1

Canvas, 6 bytes

Ｚ［│］──

Try it here!

Explanation:

Z       push the alphabet
 [ ]    map over the prefixes
  │     palindromize horizontally
    ──  palindromize vertically without mirroring characters

Answer 2

brainfuck, 109 bytes

+++++[<+++++>-]<+[>>[>[.>]]>++++++++++<<[>>.<]>[<]>--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<]

Try it online!

Explanation

+++++[<+++++>-] 26 times
<+[
  >>[>[.>]]     print every letter up to new char position
  >++++++++++<<[>>.<]  if any letter exists print lf
  >[<]>         resync pointer position
  --[<++++++++>-] set new char to A minus 1
  <[+.<]        increment each letter and print it
  <-            decrement counter
]
>>,             delete last letter
>[.>]           print rest of middle line
+++++ +++++.    print lf
[               while chars exist
  <[.<]         print all
  >,            delete last
  >[.>]<        print second half (including lf)
]

Alternative

If a leading newline would be alowed, this could also be done with 97 bytes.

+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<]

Try it online!

Explanation

+++++[<+++++>-]     26 times
<+[
  >>[>[.>]]           print every letter up to new char position
  >++++++++++.        print lf
  --[<++++++++>-]     set new char to A minus 1
  <[+.<]              increment each letter and print it
  <-                  decrement counter
]
>>,                 delete last letter
>[.>]               print rest of middle line
+++++ +++++.        print lf
[                   while chars exist
  <[.<]               print all
  >,                  delete last
  >[.>]<              print second half (including lf)
]

Both codes need interpreters that use "end of input = 0".

Answer 3

Common Lisp, 170 bytes

(let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))(loop for i from 1 to 51 do(let ((l (subseq r 0 (- i (* 2 (- i 26) (floor i 26))))))(format t "~a~a~%" l (subseq (reverse l) 1)))))

Run it: TIO here.

Formatted:

(let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
  (loop for i from 1 to 51
    do(let ((l (subseq r 0 (- i (* 2 (- i 26) (floor i 26))))))
      (format t "~a~a~%" l (subseq (reverse l) 1)))))

Breakdown:

• (let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) - variable r holds string range of all characters
• variable l holds a substring from the r of length based on the line number, where l = r[0:i - (2 * (i - 26) * i % 26)] ... (2 * (i - 26) * i % 26) this part ensures the i to be this sequence 0...26...0
• format prints the l string and its reversed counter part with skipped first letter (to avoid ABBA, ABCCBA , etc.)

Answer 4

Python 2, 70 bytes

x=25
exec'b=bytearray(range(65,91-abs(x)));print b+b[-2::-1];x-=1;'*51

Try it online!

Answer 5

Zsh, 100 96 92 80 57 bytes

Try it online!

-23!! thanks to @pxeger

eval Z+={A..Z}';<<<$Z`rev<<<$Z[1,-2]`;'>f
{<f;tac f}|uniq

We build the string $Z by iterating over A..Z, concat $Z with its reverse, and add the resulting string to file f. Then we print f forwards and backwards.

_{100 bytes   96 bytes   92 bytes   80 bytes}

Answer 6

Elixir, 107 bytes

import Enum
a=reduce ?A..?Z,[],&(&2++[(at(&2,-1)||[])++[&1]])
map a++tl(reverse a),&IO.puts&1++tl reverse&1

Try it online!

Answer 7

Julia 1.0, 39 bytes

~c=['A':c;c-1:-1:'A']
!()=join.(.~~'Z')

Try it online!

output is a list of strings

Answer 8

MATL, 12 bytes

26Zv"1Y2@Zv)

Try it on MATL Online

Pretty straightforward in MATL, thanks to the Zv symmetric range function.

26Zv - Make the symmetric range around 26 i.e. [1:26 25:-1:1]

" - Iterate through that

1Y2 - Push the literal 'A':'Z' on the stack

@ - Push the current loop index on the stack

Zv - Make the symmetric range around the index

) - Index into the alphabets using this symmetric range

Answer 9

Python 2, 86 85 bytes

n=0;exec'x=25-abs(n-25);print bytearray(65+x-abs(y-x)for y in range(2*x+1));n+=1;'*51

Try it at Ideone.

This follows a simple process. First, create the range [0, 1, ..., 24, 25, 24, ..., 1, 0]. Then, for each value x in that range, create another range [0, 1, ..., x, ..., 1, 0] and map each of those values to a character in 'A..Z'. Finally, print each string of characters.

Answer 10

JavaScript (ES6), 122 bytes

_=>(s='',r=x=>[...x].reverse().join``,t=[...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map(c=>s+c+r(s,s+=c)).join`
`)+r(t.slice(0,650))

As an anonymous function. (4 more bytes if you want to alert it)

Test

document.write('<pre>'+(

_=>(
  s='',
  r=x=>[...x].reverse().join``,
  t=
    [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
    .map(c=>
      s+c+r(s,s+=c)
    ).join`\n`
)+r(t.slice(0,650))

)());

Answer 11

Pyke, 19 16 bytes

27Gm<m[D_t+)RK[X

Try it here!

Answer 12

Python 2.7, 136 bytes

x=[chr(y) for y in range(65,91)]
for y in range(25):print ''.join(x[:y]+x[y::-1])
for y in range(25,-1,-1):print ''.join(x[:y]+x[y::-1])

Answer 13

Python 2, 98 bytes

This is what I think is a unique approach in that it recursively builds up half a line at a time and calls the alphabet-building function twice to build a full line. Golfing suggestions welcome.

f=lambda a:a and f(a-1)+chr(64+a)or""
for i in range(-26,27):print f(26-abs(i))+f(27-abs(i))[::-1]

Answer 14

Convex, 21 bytes

U{[),U&)\¿@\N]}%)\¿@\

Try it online!

Answer 15

Pyth, 13 bytes

L+bt_bjyyM._G

Demonstration

L+bt_b Concatenates a thing with its reverse without the first element. Define as y.

._G: Form all prefixes of the alphabet

yM: Apply y to each element.

y: Apply y to the list as a whole.

j: Join on newlines.

Answer 16

Racket, 147 bytes

At least it beats QBasic.

((λ(x)(display(string-join(x(build-list 26(λ(n)(list->string(map integer->char(x(range 65(+ 66 n))))))))"\n")))(λ(m)(append m(cdr(reverse m)))))

Answer 17

Java 169 156bytes

String a="abcdefghijklmnopqrstuvwxyz";
public void alphabetTriangle(){
  for(int i=0;++i<27;){
    System.out.println(a.substring(0,a)+new StringBuilder(a).reverse().substring(1,-i+1));
  }
}

Golfed

String a="abcdefghijklmnopqrstuvwxyz";void l(){for(int i=0;++i<27;){System.out.println(a.substring(0,a)+new StringBuilder(a).reverse().substring(1,-i+1));}}

It is actually same as the batch solution with some shortcuts

Thanks to @Value Ink for saving 15 bytes by shortening the method name.

Answer 18

Python, 109 bytes

z="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def a(x):v=z[:x]+z[x-26::-1]+"\n";return v+a(x+1)+v if x<25 else v
print a(0)

Build up a string with a recursive call in the middle to build the triangle out. Might come back to try and get it <100.

Answer 19

Guile, 188 bytes

(define(t d e)(if(= e 27)(apply string-append(map list->string(append(reverse(cdr d))d)))(t(cons(let((a(map integer->char(iota e #x41))))(append a(cdr(reverse a))'(#\newline)))d)(1+ e))))

Or in a readable form:

(define (triangle done depth)
  (if (= depth 27)
    (apply string-append
     (map list->string
      (append (reverse (cdr done))
              done)))
    (triangle 
     (cons (let ((alphabet (map integer->char (iota depth #x41))))
            (append alphabet (cdr (reverse alphabet)) '(#\newline)))
      done)
    (1+ depth))))

Call the program with (triangle '() 1) or (t '() 1), note that srfi-1 needs to be loaded.

The program creates a list of the chars in the alphabet, from a to the last letter in the current line. It then takes that lists, reverses it and removes the original last character, appends the two lists and adds a newline character at the end. It then does that 26 times, from A to Z. It then converts the lists to strings and concats them.

The program returns a string, which then should be passed to display, but this wasn't needed in the challenge.

Answer 20

JavaScript (177 175 chars)

This is my best attempt at golfing this problem. I cannot find a way to do this with fewer characters

o='';

for(i=1;i<=26;i++){
 l='';
  for(j=1;j<=i;j++){
   l+=String.fromCharCode(j+64);
  }
 o+=l+l.slice(0,l.indexOf(l.slice(-1))).split('').reverse().join('')+"\n";
}

console.log(o);

Answer 21

Python 3, 123 101 98 bytes

for i in range(1,52):r=[chr(j+65)for j in range(abs(26*(i//26)-i%26))];print(''.join(r+r[-2::-1]))

lol I am really bad at this

thanks @Leaky Nun for the r[-1::-1] == r[:-1][::-1] tip (:

Alternative solution, with help from @Leaky Nun (8885 bytes)

for i in range(1,52):r=[*map(chr,range(65,91-abs(i-26)))];print(''.join(r+r[-2::-1]))

Answer 22

Clojure, 182 bytes

(let[d dec w str c char n \u000A](defn p[x s](if(= x 65)s(p(d x)(w(c(d x))s(c(d x))))))(println(#(if(= % 65)%2(recur(d %)(w(p(d %)(c(d %)))n %2(p(d %)(c(d %)))n)))90(w(p 90 "Z")n))))

My first codegolf :). There is probably a much easier way to do it, but I am very new to clojure.

Ideone

Answer 23

Racket 327 bytes

(define(sr s)(list->string(reverse(string->list s))))(let loop((n 0)(s"A")(ol'("A")))(let*((st string)(mr(floor(/(string-length s)2)))
(mc(string-ref s mr))(ss(substring s 0 mr))(ns(string-append ss(st mc)(st(integer->char(+ 65(add1 n))))(st mc)(sr ss))))(if(< n 25)
(loop(add1 n)ns(cons ns ol))(append(reverse ol)(rest ol)))))

Ungolfed:

(define (f)

  (define (sr s)                     ; sub-fn to reverse a string;
    (list->string
     (reverse
      (string->list s))))

  (let loop ((n 0)
             (s "A")
             (ol '("A")))
    (let* ((st string)
           (mr (floor(/(string-length s)2)))
           (mc (string-ref s mr))
           (ss (substring s 0 mr))
           (ns (string-append 
                ss
                (st mc)
                (st (integer->char (+ 65(add1 n))))
                (st mc)
                (sr ss))))
      (if (< n 25)
          (loop (add1 n)
                ns
                (cons ns ol))
          (append(reverse ol)(rest ol))
          ))))

Testing:

(f)

Output:

'("A"
  "ABA"
  "ABCBA"
  "ABCDCBA"
  "ABCDEDCBA"
  "ABCDEFEDCBA"
  "ABCDEFGFEDCBA"
  "ABCDEFGHGFEDCBA"
  "ABCDEFGHIHGFEDCBA"
  "ABCDEFGHIJIHGFEDCBA"
  "ABCDEFGHIJKJIHGFEDCBA"
  "ABCDEFGHIJKLKJIHGFEDCBA"
  "ABCDEFGHIJKLMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNONMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMNMLKJIHGFEDCBA"
  "ABCDEFGHIJKLMLKJIHGFEDCBA"
  "ABCDEFGHIJKLKJIHGFEDCBA"
  "ABCDEFGHIJKJIHGFEDCBA"
  "ABCDEFGHIJIHGFEDCBA"
  "ABCDEFGHIHGFEDCBA"
  "ABCDEFGHGFEDCBA"
  "ABCDEFGFEDCBA"
  "ABCDEFEDCBA"
  "ABCDEDCBA"
  "ABCDCBA"
  "ABCBA"
  "ABA"
  "A")

Answer 24

CJam, 29 bytes

'[,65>:A,{)A<_W%(;+}%_W%(;+N*

Pretty simple.

Explanation:

'[,65>:A e# Get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ" and store in A
,{       e# For i in range(26), collecting j:
  )      e#   j += i + 1
  A<     e#   j = a[:i]
  _W%    e#   k = reverse(j)
  (;     e#   k.pop()
  +      e#   j += k
}%       e# End
_W%      e# Duplicate and reverse
(;       e# Pop()
+        e# Append
N*       e# Join with newlines

Answer 25

Clojure, 111 bytes

#(let[f(fn[i](concat(range i)(range i -1 -1)))](doseq[i(f 25)](println(apply str(for[j(f i)](char(+ j 65)))))))

A function which prints the result. f is an utility function which creates the sequence from 0 to i and back to 0.

Answer 26

Common Lisp, 175 bytes

(let*((a"abcdefghijklmnopqrstuvwxyz")(f"~a~a~%")(b(reverse a)))(#1=dotimes(i 26)(#2=format t f(#3=subseq a 0 i)(#3#b(- 25 i))))(#1#(i 25)(#2#t f(#3#a 0(- 24 i))(#3#b(1+ i)))))

Try it online!

Ungolfed version:

(let* ((a "abcdefghijklmnopqrstuvwxyz")          ; define the alphabet
       (b (reverse a)))                          ; and reverse it
  (dotimes (i 26)                                ; print first half, 26 lines
    (format t "~a~a~%" (subseq a 0 i) (subseq b (- 25 i))))
  (dotimes (i 25)                                ; print second half
    (format t "~a~a~%" (subseq a 0 (- 24 i)) (subseq b (1+ i)))))

Answer 27

Recursiva, 12 bytes

{pB26'PpZ0(}

Try it online!

Explanation:

{pB26'PpZ0(}
{                   - For each
 p                  - Palindromize [1,2..26,25,24...1]
  B26               - Range 26 [1,2....26]
     '              - iteration command begin
      P             - Print
       p            - palindromize 'ABCDEDCBA'
        Z0(}        - Slice upper-case alphabet "(" from 0 to current count "}" 
                      for example if }=5 'ABCDE'

Answer 28

VBA, 91 Bytes

Anonymous VBE immediate window function that takes no input and outputs the alphabet triangle to the VBE immediate window

For i=-25To 25:For j=0To-Abs(i)+25:s=s+Chr(65+j):Next:?s;StrReverse(Left(s,j-1)):s="":Next

-1 byte for use of ; over & in ? statement

Answer 29

K4, 28 bytes

Solution:

-1 .Q.A@f'(f:{t,x,|t:!x})25;

Explanation:

Define a function to create a palindrome range, create a palindrome range of 0..25..0, and then apply it to each in the list:

-1 .Q.A@f'(f:{t,x,|t:!x})25; / the solution
-1                         ; / print to stdout and swallow return value (-1)
          (             )    / do together
           f:{         }     / define function f as...
                     !x      / range 0..x-1
                   t:        / save as variable t
                  |          / reverse it
                x,           / join with x
              t,             / join with t
                         25  / perform f[25] => 0 1 2.. 25 24.. 1 0
        f'                   / apply f to each of these
   .Q.A@                     / apply (@) these indices to the alphabet A..Z

K4 isn't on TIO, but there's oK which is similar... Try it online!

Answer 30

Japt -R, 14 9 bytes

;Bå+ mê ê

Test it

---

Explanation

;B            :Uppercase alphabet
  å+          :Cumulatively reduce by addition
     m        :Map
      ê       :  Mirror
        ê     :Mirror
              :Implicitly join with newlines and output