Write a piece of code that takes a string as input, and outputs a piece of code in the same language that, when run, will output the initial input string.
It must be able to handle any combination of characters A-Z, a-z, and 0-9.
Example in Python:
import sys
print "print('" + sys.argv[1] + "')"
Given the input of testing123, it will return print('testing123').
Since this is code-golf, the shortest answer in bytes will win.
'":v
~\#[
<v">:#,_""#
<>4k,'@,
This prints a program in the form "...ihgfedcba">:#,_@, which prints abcdefghi...
The code boils down to:
'":v Push 2 quotation marks
~\#[ Get input and swap the top 2 items until EOF.
Because every time we put a new value from input on the stack we also swap,
the second quotation mark will float to the top, surrounding the input.
>:#,_ A standard "print until the top is 0" loop
""# Pushes a space, which is fine, since we control how much we print later
<v">:#,_" When the IP gets reversed, we actually push the loop backwards onto
the stack. This lets us print it later, instead of having to hardcode it.
>4k,'@, Prints 5 characters, being the printing loop from before, along with a @
< @, Prints an extra space, but it doesn't matter, and ends the program
'"drsJJp'pp
'" push a quote character
d duplicate
r get input
s swap top stack items, so the input is between the two quotes
JJ Join top two items, 2x
p p print
'p push literal:p
Uses eval to make a new function from the input string.
a=>eval(`a=>'${a}'`)
uneval
.echo.echo $u0
Input is taken by setting the fixed name alias $u0 (so that input can be either a string or number).
Running this will print:
.echo {value_of_$u0}
Which when executed prints the input.
Example:
$$ set input
r$.u0=testing123
$$ run code
.echo.echo $u0
$$output: .echo testing123
$$ run output
.echo testing123
$$output: testing123
How it works:
.echo $$ print the rest of the statement
.echo $$ part of the string that gets printed
$u0 $$ automatically expands to the value of the fixed name alias,
$$ the expanded alias is printed
$$ because only a-zA-Z0-9 needs to be handled, no special logic around the
$$ alias expansion with regard to spaces, ", or ; interfering with the
$$ next .echo needs to be done
How the output works:
.echo $$ print the rest of the statement
{string} $$ the string that gets printed, guaranteed to be one statement because
$$ it can't contain ; or " and can't start with a space
SELECT'PRINT'''+s+''''FROM t
An input table is allowed per our IO rules, so I simply create a PRINT statement with the appropriate quotation marks.
An input of FooBarBaz109481 in the input table t will result in the following output:
PRINT'FooBarBaz109481'
Which will output the original string.
The original question says the string will only contain alphanumerics, so we won't have to handle any quote marks in the input itself.
console.log('console.log("'+process.argv[2]+'")')
Takes input through argv[2], the first argument in TIO (May be different depending on where it is tested), and prints in the console.log("YOUR_MESSAGE") format. Requires a string without quotes (unless escaped with \) with available characters A-Z, a-z, and 0-9.
console.log( // Log the output (open the outer log statement)
'console.log("' // Take console.log with opening parenthesis and quote
+ process.argv[2] // Add the command-line argument after the quote (the input)
+ '")' // Add the closing quote and parenthesis
) // Close the outer log statement
cat("cat(",scan(,""),")",sep="\"")
Non-functional answer - longer than the functional one
Thanks to JayCe for contributing the one-byte answer!
There are a number of short R programs that would ...
take a string as input, and output a piece of code in the same language that, when run, will output the initial input string
. Some of these are listed below, one on each row, in descending order of length:
identity # 8 bytes
force # 5 bytes
print
eval # 4 bytes
c # 1 byte
# 0 bytes
This is inspired by NoOneIsHere's 1-byte answer in Pyth which is said to "just evaluate the input". This is exactly what force and identity do. eval and c achieve the same result in different ways. But why stop here? When you feed a string into R, it will be evaluated (to itself) and printed in quotes. A quoted string is a valid R program. That's the idea of the 0-byte answer.
Uniquely, the same program works identically in R and Python:
> "yo ho ho and a bottle of rum"
[1] "yo ho ho and a bottle of rum"
>>> 'yo ho ho and a bottle of rum'
'yo ho ho and a bottle of rum'
c
\$\endgroup\$
An anonymous function that outputs an anonymous function that prints the value of cell A1.
?"?"""[A1]
Given that cell [A1] that is populated with One
?"?"""[A1]
?"One
One
An anonymous function that takes input, S$ as a string and outputs a function that outputs S$ to the console.
This relies on the fact that the Input Call will print a ? character to the console as a prompt when no explicit prompt is provided
Input S$
?"\""+S$+"\""
.. ... ..
\$\endgroup\$
println(s"""object x{def main(a:Array[String])=println("${args.mkString}")}""")
"asdf",10 doesn't work, 2. you don't have to support that. so just change it to letters and numbers only
\$\endgroup\$
Input needs to be enclosed in double quotes: ""
|a|print!("||print!({a})")
