[Question]
  [
Write two triangle (i.e. pyramid) shaped programs.
The first one should be an upwards pointing text triangle with a minimum base width of three characters. So it would have a structure like
```
 X
XXX
```
or
```
  X
 XXX
XXXXX
```
or
```
   X
  XXX
 XXXXX
XXXXXXX
```
or larger. Each of the `X`'s is to be replaced with the characters of your actual code, which may be anything except [line terminators](https://en.wikipedia.org/wiki/Newline#Unicode) (so the `X`'s could be spaces). All the `X`'s must be replaced and the spaces and newlines that help form the triangle shape are required to stay as is.
The second program must have the same size and shape as the first, except that the triangle will be pointing down.
So if your first program looks like
```
  X
 XXX
XXXXX
```
then your second program would look like
```
yyyyy
 yyy
  y
```
where each `y` is a character you need to fill in with your actual code (probably different from your `X` code). The spaces and newlines must stay the same here too.
Your task is to write these programs such that they each output (to stdout or closest alternative) the title of a distinct [Beatles](https://en.wikipedia.org/wiki/The_Beatles) song, not taking any input. [This Wikipedia article](https://en.wikipedia.org/w/index.php?title=List_of_songs_recorded_by_the_Beatles&oldid=681078214) will serve as our official song list for The Beatles. The output should be one of the titles exactly as listed, e.g. `I Want You (She's So Heavy)`.
This is pretty easy, however, even with the weird triangle program requirement. So we're going to form another program from the first two that must output yet another song title.
By combining three copies of each of the two triangular programs we can create a third program shaped like a hexagon.
If the base width of your first program was three it would look like this:
```
 XyyyX
XXXyXXX
yyyXyyy
 yXXXy
```
If the base width was five it would look like this:
```
  XyyyyyX
 XXXyyyXXX
XXXXXyXXXXX
yyyyyXyyyyy
 yyyXXXyyy
  yXXXXXy
```
This program (when run with the spaces and newlines like the others) must output another Beatles song title, just like the first two programs. Also:
* Your three programs must output different song titles.
* **Only song titles eight characters in length or longer are allowed.**
* You can only choose one of `Revolution`, `Revolution 1` and `Revolution 9` because the titles are so similar.
* You must choose your three favorite Beatles songs. (Well, *try* to.)
Note that actual programs are required. Functions are not allowed. Reading your own source code in any program is also not allowed.
# Example
If your first program was
```
  A
 AAA
AAAAA
```
it could output `Across the Universe`.
Then your second program
```
bbbbb
 bbb
  b
```
could output `Revolution`.
Then combined into the hexagon program
```
  AbbbbbA
 AAAbbbAAA
AAAAAbAAAAA
bbbbbAbbbbb
 bbbAAAbbb
  bAAAAAb
```
the output might be `Get Back`.
# Scoring
The submission with the smallest triangle base width wins. In the likely case of ties the submission with the largest summed length of its three song titles wins.
  
[Answer]
# [Befunge](http://www.esolangs.org/wiki/Befunge)-93, width = 13 ~~15~~, titles = 31 ~~24~~ chars
A power outage last night prevented me from updating this when I figured it out, but I managed to reduce the triangle width **and** increase the song lengths!
## Pointing-up program: "Dig a Pony", 10 characters:
```
      v
     v> 
    v#  >
   "<     
  v <>"y"v>
 <v"Dig a P"
"^>:#,_@.>"no
```
### Explanation
I REALLY took advantage of Befunge's wrap-around trick and I picked "Dig a Pony" specifically because it had a space at the 6th position. This allows program flow to move *through* the song name. Try it in the [online interpreter](http://www.quirkster.com/iano/js/befunge.html) to see how it works.
## Pointing-down program: "If I Fell", 9 characters:
```
< v"f I Fell"
 v>"I">:#,_@
  "raC yM "
   v"Drive
       .
```
(Period is extraneous and only included to make the other lines show up.)
### Explanation
The only relevant lines here are the first two. I used the wrap-around trick (the instruction pointer is sent left immediately) to squeeze in one more character. The second line prints out the song name.
## Combined: "Drive My Car", 12 characters:
```
      v< v"f I Fell"v
     v> v>"I">:#,_@v> 
    v#  >"raC yM "v#  >
   "<     v"Drive"<     
  v <>"y"v>     v <>"y"v>
 <v"Dig a P"   <v"Dig a P"
"^>:#,_@.>"no "^>:#,_@.>"no
< v"f I Fell"v< v"f I Fell"
 v>"I">:#,_@v> v>"I">:#,_@
  "raC yM "v#  >"raC yM "
   v"Drive"<     v"Drive
         v <>"y"v>     
        <v"Dig a P"   
       "^>:#,_@.>"no 
```
Here's the same thing, but with lines added to show the hexagon and triangles.
```
       -----------------
      /v\< v"f I Fell"/v\
     /v> \v>"I">:#,_@/v> \
    /v#  >\"raC yM "/v#  >\
   /"<     \v"Drive/"<     \
  /v <>"y"v>\     /v <>"y"v>\
 /<v"Dig a P"\   /<v"Dig a P"\
/"^>:#,_@.>"no\ /"^>:#,_@.>"no\
-------------------------------
\< v"f I Fell"/v\< v"f I Fell"/
 \v>"I">:#,_@/v> \v>"I">:#,_@/
  \"raC yM "/v#  >\"raC yM "/
   \v"Drive/"<     \v"Drive/
    \     /v <>"y"v>\     /
     \   /<v"Dig a P"\   /
      \ /"^>:#,_@.>"no\ /
       -----------------
```
### Explanation
This is where the third and fourth lines of the pointing-down triangle come into play. There are several redirects at the edge of both triangles that serve to move the instruction pointer through those two lines and push "Drive My Car" onto the stack. Then it is printed out using the `>:#,_@` bit in the pointing-up triangle. Incidentally, both the left *and* the right pointing-up triangles are used.
There *might* be a way to use more of the empty space, but I think my time is better spent on other questions. :P
[Answer]
# GolfScript, width = 9 chars, titles = 33 chars
## Hexagon
```
    "Let It Be"
   }";"Yeste"}";      
  "Twi""rda""Twi"
 "st an""y""st an"
"d Shout"}"d Shout"
Let It Be"Let It Be
 "Yeste"}";"Yeste"
  "rda""Twi""rda"
   "y""st an""y"
    }"d Shout"}
```
Prints **Let It Be**. (9 characters)
[Try it online.](http://golfscript.apphb.com/?c=ICAgICJMZXQgSXQgQmUiCiAgIH0iOyJZZXN0ZSJ9IjsgICAgICAKICAiVHdpIiJyZGEiIlR3aSIKICJzdCBhbiIieSIic3QgYW4iCiJkIFNob3V0In0iZCBTaG91dCIKTGV0IEl0IEJlIkxldCBJdCBCZQogIlllc3RlIn0iOyJZZXN0ZSIKICAicmRhIiJUd2kiInJkYSIKICAgInkiInN0IGFuIiJ5IgogICAgfSJkIFNob3V0In0%3D)
### How it works
The token `"Let It Be"` on the first line pushes the string **Let It Be** on the stack.
The second line begins with `}`, an undocumented "super comment" that aborts execution immediately.
Before exiting, GolfScript prints the contents of the stack.
## X triangle
```
    "
   }";
  "Twi"
 "st an"
"d Shout"
```
Prints **Twist and Shout**. (15 characters)
[Try it online.](http://golfscript.apphb.com/?c=ICAgICIKICAgfSI7CiAgIlR3aSIKICJzdCBhbiIKImQgU2hvdXQi)
### How it works
The first two lines push the string `"\n }"`, which the command `;` discards from the stack.
The remaining lines contain the tokens `"Twi"`, `"st an"` and `"d Shout"`, which push the string **Twist and Shout** in three pieces.
Before exiting, GolfScript prints the contents of the stack.
## Y triangle
```
Let It Be
 "Yeste"
  "rda"
   "y"
    }
```
Prints **Yesterday**. (9 characters)
[Try it online.](http://golfscript.apphb.com/?c=TGV0IEl0IEJlCiAiWWVzdGUiCiAgInJkYSIKICAgInkiCiAgICB9)
### How it works
The tokens `Let`, `It` and `Be` on the first line are undefined, so they do nothing.
The three following lines contain the tokens `"Yeste"`, `"rda"` and `"y"`, which push the string **Yesterday** in three pieces.
The `}` on the last line does nothing; the program would have finished anyway.
Once more, GolfScript prints the contents of the stack before exiting.
[Answer]
# Python 2, width = 51
```
                         #print "Yellow Submarine" if id else "(Reprise)"   ##
                        #.##...............................................##.#
                       #...##.............................................##...#
                      #.....##...........................................##.....#
                     #.......##.........................................##.......#
                    #.........##.......................................##.........#
                   #...........##.....................................##...........#
                  #.............##...................................##.............#
                 #...............##.................................##...............#
                #.................##...............................##.................#
               #...................##.............................##...................#
              #.....................##...........................##.....................#
             #.......................##.........................##.......................#
            #.........................##.......................##.........................#
           #...........................##.....................##...........................#
          #.............................##...................##.............................#
         #...............................##.................##...............................#
        #.................................##...............##.................................#
       #...................................##.............##...................................#
      #.....................................##...........##.....................................#
     #.......................................##.........##.......................................#
    #.........................................##.......##.........................................#
   #...........................................##.....##...........................................#
  #.............................................##...##.............................................#
 #...............................................##.##...............................................#
print "Sgt. Pepper's Lonely Hearts Club Band",;id=0#print "Sgt. Pepper's Lonely Hearts Club Band",;id=0
print "Yellow Submarine" if id else "(Reprise)"   ##print "Yellow Submarine" if id else "(Reprise)"   #
 #...............................................##.##...............................................#
  #.............................................##...##.............................................#
   #...........................................##.....##...........................................#
    #.........................................##.......##.........................................#
     #.......................................##.........##.......................................#
      #.....................................##...........##.....................................#
       #...................................##.............##...................................#
        #.................................##...............##.................................#
         #...............................##.................##...............................#
          #.............................##...................##.............................#
           #...........................##.....................##...........................#
            #.........................##.......................##.........................#
             #.......................##.........................##.......................#
              #.....................##...........................##.....................#
               #...................##.............................##...................#
                #.................##...............................##.................#
                 #...............##.................................##...............#
                  #.............##...................................##.............#
                   #...........##.....................................##...........#
                    #.........##.......................................##.........#
                     #.......##.........................................##.......#
                      #.....##...........................................##.....#
                       #...##.............................................##...#
                        #.##...............................................##.#
                         #print "Sgt. Pepper's Lonely Hearts Club Band",;id=0#
```
Yeah, well... Python.
Python comments begin with `#`, so the majority of lines is just comments. For the upwards facing triangle, the only thing that executes is
```
print "Sgt. Pepper's Lonely Hearts Club Band",;id=0
```
which prints `Sgt. Pepper's Lonely Hearts Club Band`.
For the downwards facing triangle, we execute
```
print "Yellow Submarine" if id else "(Reprise)"
```
which prints `Yellow Submarine`, since the function `id` is truthy.
When we combine the programs however, all that happens is the above two lines in sequence. Since the end of the first line sets `id=0`, which is now falsy, the end result is that we tack a `(Reprise)` to the end, getting `Sgt. Pepper's Lonely Hearts Club Band (Reprise)` as our output (Calvin [said this is okay](https://chat.stackexchange.com/transcript/message/24175567#24175567)).
[Answer]
## [Snowman 1.0.2](https://github.com/KeyboardFire/snowman-lang/releases/tag/v1.0.2-beta), width = 13
```
      }?}///////////}
     ///"Get Back"////
    ///////////////////
   /////////////////////
  "Sun King//"[["Sun King
 "*"BirthdaysP/"*"Birthday
"]]8AaLsP[[///"]]8AaLsP[[//
?}///////////}?}///////////
 "Get Back"////"Get Back"/
  ///////////////////////
   /////////////////////
    //"[["Sun King//"[[
     sP/"*"BirthdaysP/
      /"]]8AaLsP[[///
```
**Finally!** A challenge where Snowman can thrive! :D :D
The slashes are mostly for aesthetic purposes, and the majority of them can be replaced with spaces (but that would make it look a whole lot more boring). Some slashes are necessary, for comments.
### Program A (output: `Birthday`):
```
      }
     ///
    /////
   ///////
  "Sun King
 "*"Birthday
"]]8AaLsP[[//
```
This one's pretty simple. The first character (`}`) sets up our active variables, then there's a bunch of comments / no-ops. It then stores the string `"Sun King\n "` and immediately discards it (via `*`, storing it in a permavar which we never use). Then it stores `"Birthday\n"`.
`]]` is a no-op here, since `[[ foo ]]` is a block comment in Snowman, but since there's no matching `[[` before this `]]` (within program A itself), it simply does nothing. Then `8AaL` grabs the first 8 characters of the string, `sP` prints it, and `[[` comments out the rest of the program (because again, there's no matching `]]`.
### Program B (output: `Get Back`):
```
?}///////////
 "Get Back"/
  /////////
   ///////
    //"[[
     sP/
      /
```
This one's also pretty straightforward. `?}` is equivalent to `}` (`?` simply sets all variables to inactive, which is a no-op here but again, important later). Then it stores the string `"Get Back"`, does a bunch of no-ops (`//` to end of line is always a comment), and prints via `sP`.
### Full program
Output is, you guessed it, `Sun King`1.
Let's look at this line by line:
* Line 1
```
      }?}///////////}
```
This sets our active variables, just like the previous programs (we can see now that the `?` is needed so as to not simply toggle them on and then back off with `}}`). The rest of the line is commented out.
* Lines 2-4
```
     ///"Get Back"////
    ///////////////////
   /////////////////////
```
Comments...
* Line 5
```
  "Sun King//"[["Sun King
```
Here we store the string `"Sun King//"`, and then start a block comment. This essentially skips everything until the next `]]`.
* Line 6
```
 "*"BirthdaysP/"*"Birthday
```
Still inside the block comment...
* Line 7
```
"]]8AaLsP[[///"]]8AaLsP[[//
```
Here we break out of the block comment for a short period of time, to execute the code `8AaLsP`. This is actually reused from program A. Since I chose all songs that are 8 letters long, I can simply use the same code for the combined program.
Then it gets a little tricky. The next time we emerge from the block comment, we see `8AaLsP` again. This time, however, all variables are undefined (we called `sp`, print, in consume mode, which gets rid of the variables). Since `aal` requires two arguments, and this time it only has one (`8`), it errors and leaves the variables unchanged.
Similarly, `sp` encounters the `8`, realizes it's the wrong type to be printed, and leaves the variables as is.
* Lines 8-13
```
?}///////////}?}///////////
 "Get Back"////"Get Back"/
  ///////////////////////
   /////////////////////
    //"[["Sun King//"[[
     sP/"*"BirthdaysP/
```
Still stuck in that block comment...
* Line 14
```
      /"]]8AaLsP[[///
```
Finally, we try calling that same print-first-8-chars sequence once again, and it fails once again, producing another two errors. (The `8` means that the variables are now `8 8`, which is the correct *number* of variables for `aal` now, but still not the right types.)
---
1: as well as four runtime errors (`SnowmanException`s) to STDERR, but [as per meta that doesn't matter](http://meta.codegolf.stackexchange.com/q/4780/3808).
[Answer]
# [><>](https://esolangs.org/wiki/Fish), width = 11
```
     /"yadhtri"\ /
           v"B"/   
        ?!;>ol      
  duJ yeH" /"eduJ yeH
 o   >l?!;   o   >l?!;
staC"/"klaw staC"/"klaw
"yadhtri"\ /"yadhtri"\ 
     v"B"/       v"B"/
  ?!;>ol      ?!;>ol 
   " /"eduJ yeH" /"e
       o   >l?!;   
      staC"/"klaw 
```
2D languages have a pretty good time with this challenge.
### Upwards arrow
```
     /
  duJ yeH
 o   >l?!;
staC"/"klaw
```
Program flow starts from the top-left, moving rightward. The `/` reflects up, and since ><> is toroidal we reappear from the bottom. We then hit another `/` and reflect again, and push the characters `klawstaC` one-by-one to the stack in string `""` mode. Finally, we reflect upwards and hit a `>l?!;o` loop, which is the idiomatic way of printing the entire stack in ><>.
This prints `Catswalk`.
### Downwards arrow
```
"yadhtri"\ 
     v"B"/
  ?!;>ol 
   " /"e
```
Basically the same thing, pushing the characters from the get go and using mirrors and arrows to direct program flow. This prints `Birthday`.
### Combined
```
     /
  ?!;>ol      ?!;>ol 
     /"eduJ yeH" / 
```
The relevant parts are above (I've cut out a lot of lines in the middle). Using the `/` from the upwards arrow, we reflect upwards and wrap around, but since we now have the downwards arrow underneath, part of that code is executed instead. We then push the relevant characters to the stack, and reuse the output loop from the downwards arrow.
This prints `Hey Jude`.
[Answer]
# Python 2, size 21
This program requires an ANSI-compatible terminal (DOS [ANSI.SYS](https://en.wikipedia.org/wiki/ANSI.SYS) to be specific), since I use [`\x1b[2J`](https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes) to clear the console AND move the cursor to top-left. To make this compatible with other ANSI terminals, print `\x1b[1J\x1b[H` (this can still fit in a size 21 hexagon). I wasn't able to test this part, because I don't have a terminal that prints ANSI escape codes.
I think the program looks pretty cool, similar to the radioactive symbol (though the ASCII shading implies the colors are backwards) or the icon of the sniper weapon from Metroid Prime: Hunters.
It *did* fit in size 17, but I'd forgotten `id=0` in the up arrow. I don't think I can shrink it back down, since that has to all be on one line...
Also, credit goes to Sp3000 for the idea to use `id`.
```
          #exec('print"'       ##
         ###'\x1b[2J"+(id '   ####
        #####'and"Hey Ju'    ######
       #######'de"or"Ca'    ########
      #########'tswalk'    ##########
     ###########'")')     ############
    ##############       ##############
   ################     ################
  ##################   ##################
 #################### ####################
id=0;print"Birthday"##id=0;print"Birthday"#
exec('print"'       ##exec('print"'       #
 '\x1b[2J"+(id '   ####'\x1b[2J"+(id '   #
  'and"Hey Ju'    ######'and"Hey Ju'    #
   'de"or"Ca'    ########'de"or"Ca'    #
    'tswalk'    ##########'tswalk'    #
     '")')     ############'")')     #
      #       ###############       #
       #     #################     #
        #   ###################   #
         # ##################### #
          #id=0;print"Birthday"##
```
### Up Arrow:
```
          #
         ###
        #####
       #######
      #########
     ###########
    #############
   ###############
  #################
 ###################
id=0;print"Birthday",
```
### Down Arrow:
```
exec('print"'       #
 '\x1b[2J"+(id '   #
  'and"Hey Ju'    #
   'de"or"Ca'    #
    'tswalk'    #
     '")')     #
      #       #
       #     #
        #   #
         # #
          #
```
"Hey Jude" is one of my favorite Beatles songs, but I really don't know that many. I've never heard the other two songs I'm using. It's not a genre I listen to often.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), base width = 17
## Top, "Hey Jude"
```
        s
       ;//
      s;///
     main(//
    ){puts(//
   #define T//
  s?"Michell"//
 "e":"Hey Jud"//
"e");}///////////
```
[Try it online!](https://tio.run/##S9ZNT07@/18BCoq5oAxrfX0osxjIhLJzEzPzNKAczeqC0pJiKE85JTUtMy9VIQTMLbZX8s1MzkjNyVEC8ZVSlayUPFIrFbxKU0ACQL6mda0@Avz/DwA "C (gcc) – Try It Online")
## Bottom, "Matchbox"
```
s=1;/////////////
 #ifndef T//////
  main(){puts//
   ("Matchb"//
    "ox");}//
     # endif
      /////
       //\
        ;
```
[Try it online!](https://tio.run/##S9ZNT07@/7/Y1tBaHxlwKShnpuWlpKYphMAEFHITM/M0NKsLSkuKwXwFDSXfxJLkjCQlCFdBKb9CSdO6FspTUFZIzUvJTINwFGCmQDkxMKaC9f//AA "C (gcc) – Try It Online")
## Hexagon, "Michelle"
```
        ss=1;/////////////s
       ;//#ifndef T//////;//
      s;///main(){puts//s;///
     main(//("Matchb"//main(//
    ){puts(//"ox");}//){puts(//
   #define T//# endif#define T//
  s?"Michell"///////s?"Michell"//
 "e":"Hey Jud"////\"e":"Hey Jud"//
"e");}///////////;"e");}///////////
s=1;/////////////ss=1;/////////////
 #ifndef T//////;//#ifndef T//////
  main(){puts//s;///main(){puts//
   ("Matchb"//main(//("Matchb"//
    "ox");}//){puts(//"ox");}//
     # endif#define T//# endif
      /////s?"Michell"///////
       //\"e":"Hey Jud"////\
        ;"e");}///////////;
```
[Try it online!](https://tio.run/##ZZGxDoIwEIb3PkVzLDCYxtXGuBoTNkcWLEWaIJoUEo3x2WsLByncbf3@u1z7Ve3uSjnHsaw97qWIyzKMPE5M3VW65tcp8gRDG2YepenS7PsaeuvHApnSkQuRQl72qrkBdmI8DfgTPN@QyZ8QCwl54veZToeVCdddZeqI@AZ7gtyoRrctzBeOCeOg4QBn/eGXoRpbig1h/jzuXUoSwqgWQhinejaEoYyVpBUJT6aiIjI6o6oWMimnqpDgf1FR8/0wLqi2OeRUj3TuDw "C (gcc) – Try It Online")
[Answer]
# gawk, base length 15
*Just found out it doesn't work with mawk* :/
It's not too tricky, but being grown up in the 70s, with The Beatles still omnipresent on air, I had to answer this. First I thought awk wasn't suited, but then it came to me.
Since these scripts contain BEGIN- and/or END-blocks, they need to be told that there will be no input to execute the END-block. This can be achieved by either pressing Ctrl-D after starting them, or starting them like this:
```
awk -f script.awk </dev/null
```
which I think is more convenient. `echo | awk -f script.awk` will also work, but if I would have used an empty line as input I would have done this completely different.
### Pointing up, prints [For No One](https://www.youtube.com/watch?v=OQxnIh8u8o8) (Youtube link)
```
       #
      # #
     #   #
    BEGIN {
   print n?#
  #         #
 n"So Tired":#
n="For No One"}
```
The essential code without comments is this. Since `n` isn't defined it prints "For No One" if called by itself.
```
    BEGIN {
   print n?
 n"So Tired":
n="For No One"}
```
### Pointing down, prints [Blackbird](https://www.youtube.com/watch?v=BrxZhWCAuQw)
```
END{a="Blackb"#
 a=n?_:a"ird"#
  printf a  #
   n="I'm "#
    if(a) #
     print
      } #
       #
```
The essential code is this. If `n` was defined before it doesn't print anything. I enforced the nice output with a newline after every track name, because I had the room to do that and it looks nicer in the console. `n` is defined in the process; that's needed for the Hexagon.
```
END{a="Blackb"
 a=n?_:a"ird"
  printf a
   n="I'm "
    if(a)
     print
      }
```
### Hexagon, prints [I'm So Tired](https://www.youtube.com/watch?v=-Tu2eZpA4yo)
```
       #END{a="Blackb"##
      # #a=n?_:a"ird"## #
     #   #printf a  ##   #
    BEGIN {n="I'm "#BEGIN {
   print n?#if(a) #print n?#
  #         #print#         #
 n"So Tired":#} #n"So Tired":#
n="For No One"}#n="For No One"}
END{a="Blackb"##END{a="Blackb"#
 a=n?_:a"ird"## #a=n?_:a"ird"#
  printf a  ##   #printf a  #
   n="I'm "#BEGIN {n="I'm "#
    if(a) #print n?#if(a) #
     print#         #print
      } #n"So Tired":#} #
       #n="For No One"}#
```
The essential code. Now finally that mysterious `n` is used. Because `n` is defined in the first line, the upwards pointing triangle prints the alternative output, and the downwards pointing triangle prints emptiness.
```
    BEGIN {n="I'm "
   print n?
 n"So Tired":
n="For No One"}
END{a="Blackb"
 a=n?_:a"ird"
  printf a  
   n="I'm "
    if(a) 
     print
      } 
```
]