6 clarify version

# Befunge 98, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge 98, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program
5 typo pointed by @wizzwizz4

# Befunge, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello , World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello , World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 1919 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello , World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 19 Bytes

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

# Befunge, 19 18 Bytes

"ck,@!dlroW ,olleH


## Explanation

• " starts string mode
• Everything that follows is pushed to the stack. The stack is now Hello , World!@,kc
• After hitting the end, interpreter go back to the start
• It encounters " again, ending string mode
• 12 is pushed to the stack (c)
• k takes the top value of stack and executes the next command the instruction pointer can see that many times
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

"!dlroW ,olleH"ck,@


This works for funge and befunge 98

## Explanation

• Everything between "" is pushed to the stack. ('H' is now on top.)
• c (12) is pushed to the stack
• k takes the top value of stack and executes the next command the instruction pointer can see that many times.
• , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
• @ ends the program
3 deleted 44 characters in body
2 Removed an incorrect statement
1