Palindrome Hello, World

Question

Your task is to create a program that prints "Greetings, Planet!" exactly to the console. Seems simple enough, right? Well, here's the trick. The code must be a palindrome, meaning it reads from right to left the same as in left to right. Standard loopholes are NOT allowed.

Answer 1

///, 37 bytes

Greetings, Planet!/!tenalP ,sgniteerG

Answer 2

TI-BASIC, 67 bytes

"!tenalP ,sgniteerG"
"Greetings, Planet!"

This works because the last line of a program is displayed on the screen, while the first string is essentially treated as a comment.

Each lowercase letter is stored as 2 bytes, and the remaining characters are 1 byte. If I were to bend the rules and print in all caps, it would be 41 bytes:

"!TENALP ,SGNITEERG"
"GREETINGS, PLANET!"

Answer 3

I know this is a bit late (and a bit finicky), but...

><> (Fish), 47 45 47 Bytes (really 43 45, if I wasn't using the randomized direction)

x"!tenalP ,sgniteerG"!|o|!"Greetings, Planet!"x

These answers are a bit different to every other; there is a chance for either direction of code to be executed.

So, by "printing to console", I assumed you meant printing to stdout. This throws an error; the error is thrown to stderr AFTER the string is printed to stdout.

To prove that this worked both ways, I used the "random direction" director, "x". Fish is a two-dimensional language, so, no matter which way the director points, the code will still (eventually) be executed.

Assuming that the first director points to the right, the characters are loaded to the "stack" in reverse order, then the reverse of the reverse (or the normal text) is printed.

Assuming that both directors point to the left, the characters are, once again, loaded to the "stack" in reverse order (because the code loads it in backwards here, direction is to the left), then the reverse of the reverse (or the normal text) is printed.

If the randomized director points up or down, this won't matter - fish knows to loop to the underside or overside of the code, pointing back to the randomizer. In this way, it will continue to loop with the randomizers until it points inward, towards the code to execute.

The !|o|! bit does the following, from both sides:

• ! skips the next instruction (will always skip |)

• | is a reflector; it points inward back towards o.

• o outputs the current item of the stack to console as a character and removes it from the stack.

So, essentially, this is the "two mirrors in a bathroom pressed up together" trick, where I output until I can't anymore.

Now using a cat emoji. >o< redirects the output inward infinitely, still throwing the error, but I can get away with not using a skip into reflection.

Turns out I was right the first time - the second attempt was not palindromic, but it was reflective.

Fish (without printing to stderr), 64 Bytes (ew)

x"!tenalP ,sgniteerG"!;oooooooooooooooooo;!"Greetings, Planet!"x

This dude's a little longer.

It has the same randomized arrow function (to prove it works both ways) and does not print to stderr.

The difference here is obvious; I literally print out every item in the stack, then end execution with ;.

The !; does not end execution immediately, as ! skips the next item (end exec, in this case) and continues until it hits the other side, which acts as ;!, wherein it ends execution before it skips anything.

It follows the same randomized direction pattern as the shorter answer.

Answer 4

Bubblegum, 38 bytes

0000000: 73 2f 4a 4d 2d c9 cc 4b 2f d6 51 08 c8 49 cc 4b 2d 51 04  s/JM-..K/.Q..I.K-Q.
0000013: 04 51 2d 4b cc 49 c8 08 51 d6 2f 4b cc c9 2d 4d 4a 2f 73  .Q-K.I..Q./K..-MJ/s

Answer 5

Macaroni 0.0.2, 52 bytes

print "Greetings, Planet!""!tenalP ,sgniteerG" tnirp

A solution that doesn't use comments. (Mostly because Macaroni doesn't have comments...)

Answer 6

CJam, 41 bytes

Thanks to Dennis for the three bytes off.

"!tenalP ,sgniteerG";"Greetings, Planet!"

Answer 7

Foo, 39 bytes

"Greetings, Planet!"!tenalP ,sgniteerG"

Try it online.

Answer 8

JavaScript, 56 bytes

This can run in any browser.

alert("Greetings, Planet!")//)"!tenalP ,sgniteerG"(trela

Answer 9

GolfScript, 41 bytes

"Greetings, Planet!":"!tenalP ,sgniteerG"

Look ma, no no-ops! Try it online in Web GolfScript.

The second half of the source code stores the string in the second string.

"Greetings, Planet!":"!tenalP ,sgniteerG"
"!tenalP ,sgniteerG"

would print

Greetings, Planet!Greetings, Planet!

Answer 10

C++, 129 bytes

Trying to do this without comments led me into a deep, dark preprocessor nightmare with no way out that I could see. Instead I've just aimed to get it as short as possible.

/**/
#include<cstdio>
int main(){puts("Greetings Planet!");}//*/
/*//};)"!tenalP sgniteerG"(stup{)(niam tni
>oidtsc<edulcni#
/**/

Answer 11

Python 3, 57 bytes

print('Greetings, Planet!')#)'!tenalP ,sgniteerG'(tnirp

I fixed the issue with parenthesis.

Python 2, 53 bytes

print'Greetings, Planet!'#'!tenalP ,sgniteerG'tnirp

I used advantage of the lack of required parenthesis and spaces in Python 2, but there wasn't that big of a difference.

Answer 12

Jelly, non-competing

25 bytes This answer is non-competing, since the challenge predates the creation of Jelly.

»1ị“RsẈḄ,#ʠU“Uʠ#,ḄẈsR“ị1»

Look 'ma, no comments! Try it online!

How it works

»1ị“RsẈḄ,#ʠU“Uʠ#,ḄẈsR“ị1»  Main link. No arguments.

   “        “        “  »  Decompress all three strings; yield a list of strings.
    RsẈḄ,#ʠU               (decompresses to 'Greetings, Planet!')
             Uʠ#,ḄẈsR      (decompresses to ' WafdkmC Posited,')
                      ị1   (decompresses to 'Taarhus')

»1                         Take the maximum of the default argument (0) and 1.
  ị                        Select the string at the index to the left.

Answer 13

Stuck, 41 Bytes

"Greetings, Planet!"p"!tenalP ,sgniteerG"

Fairly similar to the CJam answer, except in Stuck if a print command is issued, automatic stack printing is suppressed.

Answer 14

Mathematica, 52 bytes

Print@"Greetings, Planet!""!tenalP ,sgniteerG"@tnirP

Also generates a Null "!tenalP ,sgniteerG"[tnirP] which doesn't get printed.

Answer 15

Fission, 45 43 bytes

Thanks to jimmy23013 for saving 2 bytes.

;"!tenalP ,sgniteerG"R"Greetings, Planet!";

Try it online!

R initialises an atom which moves to the right. " toggles string mode which simply prints the desired string to STDOUT before hitting ;, which destroys the atom and terminates the program. The first half is simply never executed.

Answer 16

05AB1E, 16 bytes

Code:

”!º¥,ÁÙ””ÙÁ,¥º!”

Explanation:

”!º¥,ÁÙ”          # Compressed string which results in "! Crm, Everywhere".
        ”ÙÁ,¥º!”  # Compressed string which results in "Greetings, Planet!".
                  # Top of stack is implicitly outputted.

Try it online!

Answer 17

TCL, 80 Bytes

proc unknown args {puts "Hello World!"}
}"!dlroW olleH" stup{ sgra nwonknu corp

explanation: TCL executes a global proc unknown when it encounters a call to an undefined command, the first line redefines that proc to a simple "hello world" program.

TCL's quoting rules are quite subtle, an open brace starts a quoted word that extends to the next matching close brace, allowing nested, quoted words. Braces are otherwise treated as normal characters. five words: }"!dlroW olleH", stup{, sgra, nwonknu and corp. No command named }"!dlroW olleH" has been defined, so the undefined proc from the first line is invoked instead.

A similar question was posted on the StackOverflow of antiquity; which has since been closed and deleted. I used my solution as a tongue in cheek TCL sample in this answer, and am now getting comments asking for an explanation, so I recreate my answer here.

Answer 18

Keg, 41 bytes

Greetings\, Planet\!#!\tenalP ,\sgniteerG

Try it online!

Answer 19

STATA, 52 bytes

di "Greetings, Planet!"//"!tenalP ,sgniteerG" id

A slightly longer (53 byte) version that doesn't use comments is:

#d
di "Greetings, Planet!";"!tenalP ,sgniteerG" id
d#

#d [something] changes the delimiter (initially a carriage return) to ; unless [something] is cr, so the first command changes the delimiter to ;, the second prints the string, and the third (which continues until the end) is apparently a nop, though I have no idea why. I would have guessed that this would throw an error (unrecognized command "!tenalP ,sgniteerG" or something), but apparently not.

Answer 20

Japt, 29 bytes

^{This programming language was made after the question was posted, but was not made for this question.}

`!t?ÓP ,?Ä>ÎG`;`GÎ>Ä?, PÓ?t!`

Try it online!

Each ? is an unprintable Unicode char: U+0082, U+000F, U+000F, and U+0082, respectively.

Fun fact: If Japt had been published a month sooner, it would have legitimately won this challenge.

Answer 21

APL, 41 bytes

'Greetings, Planet!'⍝'!tenalP ,sgniteerG'

In APL, the last value is printed and the lamp character (⍝) start a comment.

Answer 22

GolfScript, 41 bytes

"Greetings, Planet!"#"!tenalP ,sgniteerG"

Try it online !

Answer 23

Ruby, 43 bytes

p"Greetings, Planet!"#"!tenalP ,sgniteerG"p

Answer 24

Lua, 52 Bytes

print"Greetings, Planet!"--"!tenalP ,sgniteerG"tnirp

In Lua terminal, it is only 44 bytes with

="Greetings, Planet!"--"!tenalP ,sgniteerG"=

Answer 25

Vitsy, 41 Bytes

_{This programming language was made after the question was posted, but was not made for this question.}

"!tenalP ,sgniteerG"Z"Greetings, Planet!"

The Z character outputs everything in the stack to STDOUT.

Try it online!

Answer 26

Unefunge 98 - 49 bytes

"!tenalP ,sgniteerG<DC1>"k,@,k"<DC1>Greetings, Planet!"

The code above contains two unprintable characters with code 17 (device control 1) represented by <DC1>.

Answer 27

MSM, 73 bytes

GGreetings, Planet!.................,.................!tenalP ,sgniteerGG

The first half just before the middle , builds a reverse greeting string including the additional G on the very right. The middle , drops it and the rest is a canonical "Hello/Greeting/whatever" program. The additional characters on both ends are needed, because the message contains a ,. The left one is executed and drops the s. Both , and s need a replacement for the left concatenation dots, hence the Gs. The , on the right isn't executed, but build into the final string.

Answer 28

Bash, 52 48 bytes

echo Greetings, Planet!||!tenalP ,sgniteerG ohce

Also works in ksh, zsh, yash, dash. But not tcsh.

$ cat x.sh
echo Greetings, Planet!||!tenalP ,sgniteerG ohce
$ bash x.sh
Greetings, Planet!
$ ksh x.sh
Greetings, Planet!
$ zsh x.sh
Greetings, Planet!
$ yash x.sh
Greetings, Planet!
$ dash x.sh
Greetings, Planet!
$ tcsh x.sh
tenalP: Event not found.
$

Answer 29

CoffeeScript, 53 bytes

Similar to Ruby and Lua and pretty much all the variants here.

alert 'Greetings, Planet!'#'!tenalP ,sgniteerG' trela

Answer 30

Milky Way 1.5.10, 43 41 39 bytes

"Greetings, Planet!"!tenalP ,sgniteerG"

---

Explanation

"Greetings, Planet!"                       # push the string to the stack
                    !                      # output the TOS
                     tenalP ,sgniteerG"    # throws an error and exits

---

Usage

python3 milkyway.py <path-to-code>

Answer 31

jq, 44 characters

(42 charactes code + 2 character command line option.)

"Greetings, Planet!"//"!tenalP ,sgniteerG"

(Not a big deal, posted just for the sake of that operator. Yes, // is not comment, is the alternative operator: if its left operand is null or false, the right operand is returned, otherwise the left operand.)

Sample run:

bash-4.3$ jq -nr '"Greetings, Planet!"//"!tenalP ,sgniteerG"'
Greetings, Planet!

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

Answer 32

Emacs Lisp, 60 bytes

(message"Greetings, planet!");)"!tenalp , sgniteerG"egassem(

As you might have already guessed ; denotes a comment.

Answer 33

Fishing, Dock length 41

v+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  `Greetings, Planet!`P`!tenalp ,sgniteerG`

For a palindrome that also includes the dock and is measured in total bytes, this has 132 bytes.

v+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  `Greetings, Planet!`P`!tenalp ,sgniteerG`  CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC+v

---

Fishing prints the stack with P. Because the dock ends at the end of the first line, no other fish are caught or executed.

Answer 34

Golfscript, 41 bytes

"!tenalP ,sgniteerG";"Greetings, Planet!"

Pushes "!tenalP ,sgniteerG" to stack, removes top of stack (;), and pushes "Greetings, Planet!". Stack is printed at end of execution in GolfScript.

Answer 35

Self-Modifying Brainf*ck, 67 bytes

+[<[<]<[.<]-][0Greetings, Planet!0!tenalP ,sgniteerG0][-[>.]>[>]>]+

Where the 0's denote null characters.

The first <[<] moves the pointer to the beginning of the message (the last null character) And the following <[,<] reads and outputs the message until the terminating null character. This is a pretty long answer, so it probably won't stand a chance, but hey, it's pretty cool.

Answer 36

Fuzzy Octo Guacamole, 52 bytes

_{(non-competing, FOG is newer than the challenge)}

'Greetings, Planet!'X@X'!tenalP ,sgniteerG'

Pushes "Greetings, Planet!" to the stack, pop, print, and end. ('' pushes the string, _; pops and prints, and @ terminates immediately.

Without the @, it would then print 0 after the string.

Answer 37

C, 72 bytes

main(){puts("Greetings, Planet!");}//};)"!tenalP ,sgniteerG"(stup{)(niam

Answer 38

Self-modifying Brainfuck, 47 bytes

Greetings, Planet!<[.<]<.[<!tenalP ,sgniteerG

The code contains two null-bytes, shown here as 0:

Greetings, Planet0!<[.<]<.[<!0tenalP ,sgniteerG

Try it online!

Explanation

Like the other SMBF answers, this includes the required string in the source code, along with a null-byte as an end-of-string marker. Note that SMBF is like regular BF, except that the source is copied to the front of the tape and the tape head starts at the cell just after the source code.

We can save some bytes over the other answers by putting the actual string at the end, so that we don't have to skip past the actual source code. Finally, we can save one more byte by putting the ! on the other side of the null-byte which conveniently lets us reuse the <. in the mirror image to print the last character (otherwise we'd have to double the ] to avoid that <. is executed). Here is the code:

,     Read a character, which is a no-op with no input.
<     Move tape head onto the 'G'.
[.<]  In a loop, print character, move tape head left. This prints the desired
      string except for the '!'. The loop terminates when the tape head reaches
      the null byte.
<     Move the tape head left another cell onto the '!'. 
.     Print it.
[     Unmatched square bracket, terminates the program.

Answer 39

Hoon, 41 bytes

"Greetings, Planet!":"!tenalP ,sgniteerG"

In Hoon, a:b means "compute a in the context of b". To include a library, for example, you stick a rune that evaluates the rest of your program in the context of the core containing the library. This is possible because cores also contain the entire kernel and stdlib, so you can nest them and still compute.

Because a string literal is just a constant expression that doesn't depend on the context it is being evaluated in at all, we can replace the entire stdlib with just another constant expression and it will evaluate to the same thing.

Answer 40

Brachylog, 41 bytes (non-competing)

"Greetings, Planet!"w"!tenalP ,sgniteerG"

This will call w - write with "Greetings, Planet!" as input and "!tenalP ,sgniteerG" as output. w writes its input to STDOUT and does nothing with its output.

Answer 41

Pyth, 41 bytes

"Greetings, Planet!"K"!tenalP ,sgniteerG"

Prints "Greetings, Planet!", then assigns "!tenalP ,sgniteerG" to K

Answer 42

PowerShell, 41 bytes

"Greetings, Planet!"#"!tenalP ,sgniteerG"

Output is implied is PowerShell and anything after # is a comment.

Answer 43

R, 51 bytes

cat("Greetings, Planet!")#("!tenalP ,sgniteerG")tac

No really original, # indicates a commentary in R

Answer 44

Hy, 58 bytes

(print "Greetings, Planet!");;("!tenalP ,sgniteerG" tnirp)

I'm not competing.

Answer 45

AWK, 66 bytes

BEGIN{print"Greetings, Planet!"#"!tenalP, sgniteerG"tnirp{NIGEB

Could save some bytes if input were allowed, but I assume it isn't.

The input required code would save 15 bytes and be run like this:

awk '{$0="Greetings, Planet!"}1#1{"!tenalP, sgniteerG"{' <<< "arbitrary string here"

Answer 46

q/kdb+ 41 bytes

Solution:

"!tenalP ,sgniteerG";"Greetings, Planet!"

Example:

q)"!tenalP ,sgniteerG";"Greetings, Planet!"
"Greetings, Planet!"

Explanation:

This is really just two statements separated by a semicolon, "!tenalP ,sgniteerG" and "Greetings, Planet!", due to the ;, the first statement does not get printed to the console.

Answer 47

Underload, 48 bytes

)(Greetings, Planet!)S())(S)!tenalP ,sgniteerG()

Uses the fact that non-matching closing brackets don't error on the interpreter that TIO uses.

How it works

) Used to make a matching pair of brackets at the end, so it doesn't error
(Greetings, Planet!)S   Outputs 'Greetings, Planet!'
()   Used to make it so the output command doesn't run a second time, since it gets enclosed in bracket. Also, adds an element to the stack so the 'a' in the '!tenalP, sgniteerG', doesn't error, since 'a' is a command in Underload
)(S)   Pushes S to the stack
!tenalP ,sgniteerG   Reversed 'Greetings, Planet'. Every character is a no-op apart from 'a'
()   Matching pair of brackets I mentioned on the first line

Try it Online!

Answer 48

Java, 192 Bytes

public class C{public static void main(String[] args){System.out.print("Greetings, Planet!");}}//}};)"!tenalP ,sgniteerG"(tnirp.tuo.metsyS{)sgra ][gnirtS(niam diov citats cilbup{C ssalc cilbup

For the online compiler i had to change the class name from C to Main

Try it online!

Answer 49

T-SQL, 52 bytes

PRINT'Greetings, Planet!'--'!tenalP ,sgniteerG'TNIRP

Not much different from other answers, but didn't see another SQL-based solution.

-- is an in-line comment in T-SQL, PRINT is one byte shorter than SELECT.

Answer 50

Pip, 42 40 bytes

"!tenalP ,sgniteerG""Greetings, Planet!"

Try it online!

Pip prints the last expression in a file

Answer 51

Julia (1.2), 41 bytes

"!tenalP ,sgniteerG";"Greetings, Planet!"

Example

julia> print("!tenalP ,sgniteerG";"Greetings, Planet!")
"Greetings, Planet!"

Explanation

Putting a semicolon on the end of an expression makes the expression not output anything.

Answer 52

ink, 38 bytes

Greetings, Planet!//!tenalP ,sgniteerG

Try it online!

Answer 53

Dyalog APL, 43 bytes

'!tenalP ,sgniteerG'∘⊢∘'Greetings, Planet!'

or

'Greetings, Planet!'∘⊣∘'!tenalP ,sgniteerG'

Answer 54

Mouse-2002, 47 bytes

"Greetings, Planet"33!'$'!33"tenalP ,sgniteerG"

I hate that I have to print !'s charcode because using it in a string just prints \n.

things_to_fix_in_my_mouse_reboot.append("EXCLAMATION POINTS ARE THEMSELVES, NOT NEWLINES.")

Answer 55

PlatyPar, 40 bytes

"!tenalp ,sgniteerG""Greetings, planet!"

Pushes the two strings to the stack. At the end of the program, the last item of the stack is printed, so the first inverted one is ignored. I see a lot of other answers like this, except mine doesn't have something between the two strings.

Try it online!

Answer 56

Microscript, 43 bytes

"!tenalP ,sgniteerG"aha"Greetings, Planet!"

---

Microscript II, 40 bytes

Noncompeting, language postdates the question.

"!tenalP ,sgniteerG""Greetings, Planet!"

Answer 57

Pylongolf, 43 bytes

."Greetings, Planet!"~"!tenalP ,sgniteerG".

~ prints the stack nicely, . resets the stack.
"Greetings, Planet!" pushes the sentence into the stack, ~ prints it.
The rest is a blur.

EDIT: I saved 2 bytes by removing the ~ symbols on both sides.

Answer 58

Java, 170 164 bytes

interface e{static void main(String[]s){System.out.print("Greetings, Planet!");}}//}};)"!tenalP ,sgniteerG"(trinp.tuo.metsyS{)s][gnirtS(niam diov citats{e ecafretni

Answer 59

Haystack, 43 bytes

"Greetings, Planet!"o|o"!tenalP, sgniteerG"

Here's how this two-dimensional program works:

• "Greetings, Planet!" pushes a string whose content is Greetings, Planet! to the stack.
• o prints everything in the stack.
• | is the needle. The program ends because it found the needle in the haystack!
• o"!tenalP, sgniteerG" isn't executed as the needle is found before reaching there.

Hello World example(s) from shebang

Answer 60

INXW63CTMNZGS4DU, 42 bytes

"Greetings, Planet!"#"!tenalP, sgniteerG"

A trailing newline is needed at the end

The # character start a comment, and the last value is printed, so this program print "Greetings, Planet!"

Answer 61

PHP, 48 52 bytes

echo"Greetings, Planet!";//;"!tenalP ,sgniteerG"ohce

// comments out the rest of the line, leaving echo"Greetings, Planet!";.
No space is needed between echo and ", meaning this is this the shortest possible response for PHP.

Would have loved a clever excuse to use /* */, but couldn't think of one.

Answer 62

Nim, 49 bytes

echo"Greetings, Planet!"#"!tenalP ,sgniteerG"ohce

Pretty self-explanatory. Uses Nim's short echo syntax and a comment to create the palindrome.

Answer 63

Straw, 41 bytes

(Greetings, Planet!)>)!tenalP ,sgniteerG(

Try it online

(Greetings, Planet!) push a string on the stack, > print it. The rest of the program simply fill the stack with junk.