# Let's make a word-search!

In this challenge, we will together create a word-search containing many programs in different languages.

I have started us off with a grid of 60-by-25 blanks (·), some of which are replaced by the characters of a Ruby program.

To answer, choose a language that was not yet used. Using your chosen language, write a program that reads a character, token, line, or all input from the console, and prints it. Then, insert your program into the word-search.

For example, suppose you choose Python 3 for your answer, and write the program print(input()). Now you have to insert that program into the grid.

···a·24··········
··z····t·········

Then you can just put your program in the second line, overlapping with the existing t:

···a·24··········
··zprint(input())

Note that you can place your program in any direction: forward, backward, upward, downward, or diagonally, as long as it's in a straight line.

But what if the existing grid looks like this:

···a·24··········
··z····q·········

There's no way to fit the print(input()) here without changing existing characters, which is forbidden. Instead, you can change the program:

print(
input())

This two-line program fits neatly:

···a·24·print(···
··z····q input())

Here you replace a blank (·) with a space (). However, a space is just like any other character, and can not be overwritten in future programs.

Just like a one-liner, a multi-line program can be placed in any direction. For example, in a larger grid, you could do the following, by rotating the program 135° clockwise.

··········
········ ·
·······i·p
······n·r·
·····p·i··
····u·n···
···t·t····
··(·(·····
·)········
)·········

## Scoring

Your score for each answer is thirty divided by the number of characters added. Do not count characters that already existed in the grid, even if you use them yourself.

Your total score is the sum of the scores for all of your answers, multiplied by the number of answers. Highest score wins.

# Rules

• Every answer must be written in a different language. Languages that differ only in version number (e.g., Python 2 and Python 3) are considered the same.
• Every answer must build off of the most recent valid answer. That is, take the grid of the most recent such answer, and insert your program into it.
• To insert your program, replace at least one of the blanks (·) with characters of your choice. You may use existing characters from the grid in your answer, but you may not change or move any of them.
• You may not insert more than 500 characters in total, across all your answers.
• All characters you insert must be part of your program.
• Your program may consist only of printable ASCII and newlines, but there may not be two or more consecutive newlines back-to-back.
• Newlines do not count towards your score.
• A full program, not just a function or snippet, is required.
• The same user may not write two consecutive answers.
• If someone's answer violates a rule, leave a comment. If the mistake is not fixed in 30 minutes, it should be deleted.

# Used language snippet

This is a Stack Snippet, made by ETHproductions, FryAmTheEggman, and Mauris, that keeps track of users' scores and the used languages. It was originally copied from Martin Büttner's amazing template.

New (experimental) version, using a modified formula:

• Eh, I would just rely on the community being cool enough not to do something that boring :) – Lynn Sep 9 '15 at 3:20
• I have a basic "leaderboard" snippet set up, copied from Martin's amazing template, that keeps track of the used languages. May I edit it into the post? – ETHproductions Sep 9 '15 at 3:24
• Alright, I've added the snippet. I only removed the unnecessary HTML portion, so feel free to shorten the CSS or JS. – ETHproductions Sep 9 '15 at 3:39
• I would suggest that the next time someone does something like this that they limit it to languages notable enough to have a Wikipedia entry, or something like that. It doesn't really feel like a real word search with dozens of one-two character entries from esoteric languages no one has ever heard of. – ThaddeusB Sep 9 '15 at 23:36
• Someone should extend the snippet to have a leaderboard listing the scores per author. – Lynn Sep 10 '15 at 2:42

# Batch file, 16 characters added (corrected)

sET /P A=
ECHO %A%

Yeah ... batch files going all diagonal on ya.

The grid is now

····························································
···········i········a·······································
··········?pio;·····l·······································
··········,u········e·······································
··········.t········r·······································
···········s········t·······································
··········· ··printf(·······································
···········g··    input('','s'))····························
···········e·····n··r·······································
·········E·s········m·······································
········C·E·········p·······································
·······H·T··········t·····················r·················
······O· ···········(·······································
····· ·/············)·······································
····%·P·············)·······································
···A· ······················································
··%·A·······················································
···=························································
····························································
····························································
····························································
····························································
····························································
····························································
• I'm not sure if this is how multi-line diagonal programs fit. In the question's example, there is space between the two lines of the diagonal program (like a checkerboard). – PhiNotPi Sep 8 '15 at 20:18
• @PhiNotPi - Edited, fixed, and undeleted. – AdmBorkBork Sep 8 '15 at 20:27
• @FryAmTheEggman No, not an issue. Batch doesn't really care about capitalization. Corrected for clarification, though. – AdmBorkBork Sep 8 '15 at 20:33
• If you want to be super-technical, the first character of the second line should be to the upper-left of the first character on the first line. (this is true in the example, but it's a bad example because the first character of the second line was a space). You could reposition the s to be the s in puts. – PhiNotPi Sep 8 '15 at 20:35
• Well, now somebody has already chained onto this, so it's probably too late to fix. – PhiNotPi Sep 8 '15 at 20:37

cat(scan(,''))

The grid is now

····························································
···········i········a·······································
··········?pio;·····l·······································
··········,u········e·······c·······························
··········.t········r·······a·······························
··········@s········t·······t·······························
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·······························
·········E·s········m·······n·······························
········C·E·········p·······(·······························
·······H·T··········t·······,·············r·················
······O· ···········(·······'·······························
····· ·/············)·······'·······························
····%·P·············)·······)·······························
···A· ······················)·······························
··%·A·······················································
···=························································
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··························································}}
····························································
····························································
····························································

grep -m1 .

The new grid:

·········v---H\·············································
·········>qir@uH····a·······································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
··········@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·········g·····················
·······))E·s········m·······n)········e·····················
········C·E·········p·······((········p·····················
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)i·······n ·····················
··%·A························(······-·.·····················
···=·························t····· ···$·d·················· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a·····················}} ·····························p·h···=························ ··································<························· ·································>·························· • but you missed the LISP answer...It should be fixed now – Gavin S. Yancey Sep 8 '15 at 23:33 # awk, 11 characters added {print;exit} The new grid: ·········v---H\············································· ·········>qir@uH····a······································· Get a chr!?pio;·····l······································· Outputs it,u········e·······c······························· and 'BZam..t········r·······a······························· ··········@s······s t=" " r t#50:20 w !,t,!················· ··········· ··printf(·······(······························· ···········g·· input('','s'))···························· ···········e·····n··r·······c·········g····················· ·······(write(read-host)····a)········r······ ·············· ·······))E·s········m·······n)········e····················· ········C·E·········p·······((·······{print;exit}····K······ ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)i·······n ····················· ··%·A························(······-·.····················· ···=·························t····· ···$·d··················
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a·····················}}
·····························p·h···=························
··································<·························
·································>··························
• :( I was about to post an awk answer – ThaddeusB Sep 8 '15 at 23:48
• Could have just used awk 1 – User112638726 Sep 9 '15 at 14:59

IaP.

The new grid:

·········v---H\·············································
·········>qir@uH···IaP.·····································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
··········@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·········g·····················
·······))E·s········m·······n)········e·····················
········C·E·········p·······((·······{print;exit}····K······
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)i·······n ·····················
··%·A························(······-·.·····················
···=·························t····· ···$·d·················· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a·····················}} ·····························p·h···=························ ··································<························· ·································>·························· # FALSE, 1 character added ^, New grid: ·········v---H\········································;···· ······,··>qir@uH···IaP.················USE: io·········>···· Get a chr!?pio;·····l··················readln··········;···· Outputs it,u········e·······c··········print(readline())···· and 'BZam..t········r·······a··········string)·········;···· ········~,@s······s t=" " r t#50:20 w !,t,!············E···· ······main( ){printf("%c", (getchar()));}·············;···· ···········g·> input('','s'))·······················P···· ···········e·····n··r·····^·c·········g················;···· ·······(write(read-host)····a)········r·input n$·······(····
·······))E·s········m·······n)········e·print n$·······;···· ········C·E·········p·······((·······{print;exit}····K·*···· ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)io······n ····················· ··%·A························(······-·.····················· ···=·························t\···· ···$·d··················
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a b c d e f g h i·····}}
·····························p·h···=b c d e f g h i·········
··································<·························
·································>··························
• I went ahead and edited this answer to fix an older program. We can revert the edit if something changes. – ETHproductions Sep 9 '15 at 2:49
• Sounds good to me! – Lynn Sep 9 '15 at 2:52

di _r(a)
di $a Take input via prompt and store in a. Print contents of a. ·········v---H\········································;···· ······,··>qir@uH···IaP.················USE: io·········>···· Get a chr!?pio;·····l··················readln··········;···· Outputs it,u········e·······c··········print(readline())···· and 'BZam..t········r·······a··········string)·········;···· ········~,@s······s t=" " r t#50:20 w !,t,!············E···· ······main( ){printf("%c", (getchar()));}·············;···· ···········g·> input('','s'))·······················P···· ···········e·····n··r·····^·c·········g················;···· ·······(write(read-host)····a)········r·input n$·······(····
·······))E·s········m·······n)········e·print n$·······;···· ········C·E·········p·······((·······{print;exit}····K·*···· ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)io······n ····················· ··%·A························(······-·.··di _r(a)··········· ···=·························t\···· ···$·di $a·············· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a b c d e f g h i·····}} ·····························p·h···=b c d e f g h i········· ··································<························· ·································>·························· # x-D, 11 characters added ;>;);E;P;(;* ;> increment ; to 1, make sure the loop is entered ;) start loop ;E read from STDIN ;P output to STDOUT ;( end loop, ends on 0 ;* end program The new grid ·········v---H\········································;···· ······,··>qir@uH···IaP.················USE: io·········>···· Get a chr!?pio;·····l··················readln··········;···· Outputs it,u········e·······c··········print(readline())···· and 'BZam..t········r·······a··························;···· ········~,@s······s t=" " r t#50:20 w !,t,!············E···· ······main( ){printf("%c", (getchar()));}·············;···· ···········g·> input('','s'))·······················P···· ···········e·····n··r·······c·········g················;···· ·······(write(read-host)····a)········r·input n········(···· ·······))E·s········m·······n)········e·print n········;···· ········C·E·········p·······((·······{print;exit}····K·*···· ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)io······n ····················· ··%·A························(······-·.····················· ···=·························t\···· ···$·d··················
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a b c d e f g h i·····}}
·····························p·h···=b c d e f g h i·········
··································<·························
·································>··························

>    input('','s')

The new grid:

·········v---H\·············································
·········>qir@uH···IaP.·····································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
········~,@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g·>    input('','s'))····························
···········e·····n··r·······c·········g·····················
·······))E·s········m·······n)········e·····················
········C·E·········p·······((·······{print;exit}····K······
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)io······n ·····················
··%·A························(······-·.·····················
·······))E·s········m·······n)········e·print n$·······;···· ········C·E·········p·······((·······{print;exit}····K·*···· ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)io······n ···················· ··%·A························(······-·.··di _r(a)··········· ···=·························t\···· ···$;di $a·············· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a b c d e f g h i·····}} ·····························p·h···=b c d e f g h i········· ··································<························· ·································>·························· # Clojure, 21 characters added (println (read-line)) The grid is now: ·········v---H\··v+C+<D_··············S·P··············;···· ·····,··>qir@uH· IaP.C·············A·USE: io·········>···· Get a chr!?pio;····Ol···············Y·Lreadln(write(···;···· Outputs it,u········e·······c······ ·L·print(readline())···· and 'BZam..t········r·······a·····ai ··string))········;···· ········~,@s······s t=" " r t#50:20 w !,t,!············E···· ······main( ){printf("%c", (getchar()));}·············;···· ···········g·> input('','s'))·······················P···· ···········e·····n··r·····^·c·········g················;···· ·······(write(read-host)····a)········r·input n$!?·····(····
·······))E·s········m·······n)········e·print n$·······;···· ········C·E·········p·······((·······{print;exit}····K·*···· ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/(println····)·······'p········m····················· ····%·P· (read-line))······)n········1····················· ···A· ······················)io······n ···················· ··%·A························(······-·.··di _r(a)··········· ·$·=·························t\···· ···$;di$a··············
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a b c d e f g h i·····}}
·····························p·h···=b c d e f g h i·········
··································<·························
·································>··························

I also missed the main requirement of the question; this has been fixed now. Sorry for the confusion.

)io

7 is a language I have been working on for a while, but unfortunately, I have not had a chance to publish it yet. i stands for input, and o for output. Pretty simple, right? ;)

The new grid:

·········v---H\·············································
·········>qir@uH···IaP.·····································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
········~,@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·········g·····················
·······))E·s········m·······n)········e·····················
········C·E·········p·······((·······{print;exit}····K······
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)io······n ·····················
··%·A························(······-·.·····················
···=·························t\···· ···$·d·················· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a b c d e f g h i·····}} ·····························p·h···=b c d e f g h i········· ··································<························· ·································>·························· • Why do you add 100 to the number read from STDIN? I'm pretty sure you're supposed to just output it. – Lynn Sep 9 '15 at 2:40 • @Mauris Oh, gosh, I skimmed over that rule somehow! Is it possible to change it now? – ETHproductions Sep 9 '15 at 2:42 • I'm not sure what to do. @Ypnypn should decide. – Lynn Sep 9 '15 at 2:43 • I'm so sorry... Perhaps I could just edit this answer and the most recent. @Ypnypn, what do you think? – ETHproductions Sep 9 '15 at 2:45 • @Ypnypn I went ahead and edited this answer and the most recent one. There's ten answers between them; should I go through and edit them all, or just leave them the way they are? – ETHproductions Sep 9 '15 at 2:54 # Burlesque, 1 character added Q The new grid: ·········v---H\··v+C+<D_··············S·P··············;···· G····,··>qir@uH· IaP.C·············A·USE: io·········>···· Get a chr!?pio;····Ol···············Y·Lreadln(write(···;···· Outputs it,u········e·······c······ ·L·print(readline())···· and 'BZam..t········r·······a·····ai ··string))··<v;···;···· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?···E···· G·····main( ){printf("%c", (getchar()));}·······pr>···;···· O·········)g·> input('','s'))·················h_····P···· a··········e·····n··r·····^·c·········g··········pd····;···· ·······(write(read-host)····a)········r·input n$!?u····(····
·······))E·s········m·······n)···KVGH·e·print n$··m····;···· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*····$'main'H·T··········t·······,t···HSMI· ···r·······(·········
\/\··O· ···········(·······'u···XIM ·-···········$········· \/· ·/(println····)·······'p···BBE1·m···········a········· \%·PQ (read-line))······)n···YLH.·1···········r········· A\ /-io-\············)io··EE 4n ··········g········· % A\-e-< |·············(···· V-·.··di _r(a)·v·········$ =      \----#·············t\···V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a b c d e f g h i·····}}
···········>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni·····<·························
···};s<<tuoc::dts;s>>nic::dts····>··························
• The homepage is here; try submitting Q as Burlesque code here. – Lynn Sep 9 '15 at 21:37
• STDIN is pushed on the stack as a string at the start of the program, like in GolfScript. Q is show, which makes it a Pretty value (an ordinary String would be printed with quotes). When the program finishes, it is printed. – Lynn Sep 9 '15 at 21:38
• Alright, the esolang page just said it was recommended that implementations do that, but since an interpreter exists where it does that, it should be fine. You should probably link one/both of those in the question body though. – FryAmTheEggman Sep 9 '15 at 21:40

,

The new grid:

·········v---H\·Iv+C+<D_··············S·P··············;····
G····,··>qir@uH·  IaP.C········LAMBDA·USE: io·········>····
and 'BZam..t········r·······a·····ai ··string))··<v;i:j;p:j·
G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:·E····
G·····main( ){printf("%c",  (getchar()));}·······pr>·:·;····
O·········)g·>    input('','s'))·················h_··)·P····
a··········e·····n··r·····^·c·········g··········pd····;····
·······(write(read-host)····a)········r·input n$!?u····(···· ·······))E·s········m·······n)···KVGH·e·print n$!·m····;····
········C·E·········p·······((···TIIA{print;exit}·pYEK·*····
$'main'H·T··········t·······,t···HSMI· ···r·······(········· \/\··O· ·········S (I\·····'u···XIM ·-···········$·········
\/· ·/(println··FO) /·····'p···BBE1·m···········a·········
A\     /-io-\············)io··EE 4n ····,·····g·········
% A\-e-<     |·············(···· V-·.··di _r(a)·v·········
$= \----#·············t\···V ···$;di $a····)········· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}} ···········>maertsoi<edulcni#p·h···=b c d e f g h i········· ····;s gnirts::dts{)(niam tni····v< o<···················· ···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;··················· # Capuirequiem, 1 character added IO The new grid: ·········v---H\OIv+C+<D_··············S·P··············;···· G····,··>qir@uH· IaP.C········LAMBDA·USE: io·········>···· Get a chr!?pio;····Ol···········ZEROY·Lreadln(write(···;···· Outputs it,u········e·······c······ ·L·print(readline())···· and 'BZam..t········r·······a·····ai ··string))··<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:·E···· G·····main( ){printf("%c", (getchar()));}·······pr>·:·;···· O·········)g·> input('','s'))·················h_··)·P···· a··········e·····n··r·····^·c·········g··········pd····;···· ·······(write(read-host)····a)········r·input n$!?u····(····
·······))E·s········m·······n)···KVGH·e·print n$!·m····;···· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*····$'main'H·TUPTUO·····t·······,t···HSMI· ···r·······(·········
\/\··O· ·TUPNI···S (I\·····'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·m···········a········· \%·PQ (read-line))······)n···YLH.·1···········r········· A\ /-io-\············)io··EE 4n ····,·····g········· % A\-e-< |·············(···· V-·.··di _r(a)·v·········$ =      \----#·············t\···V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
···········>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<····················
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;···················

EDIT: I'm just making sure this shows up on top when people sort by "active".

And the resulting grid:

·········v---H\OIv+C+<D_··············S·P··············;····
G····,··>qir@uH·  IaP.C········LAMBDA·USE: io·········>····
and 'BZam..t········r·······a·····ai ··string))··<v;i:j;p:j·
G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:·E····
G·····main( ){printf("%c",  (getchar()));}·······pr>·:·;····
O·········)g·>    input('','s'))·················h_··)·P····
a··········e·····n··r·····^·c·········g··········pd····;····
·······(write(read-host)····a)········r·input n$!?u····(···· ·······))E·s········m·······n)···KVGH·e·print n$!·m····;····
········C·E·········p·······((···TIIA{print;exit}·pYEK·*····
$'main'H·TUPTUO·····t·······,t···HSMI· ···r·······(········· \/\··O· ·TUPNI···S (I\·····'u···XIM ·-···········$·········
\/· ·/(println··FO) /·····'p···BBE1·m···········a·········
A\     /-io-\············)io··EE 4n ····,·····g·········
% A\-e-<     |·············(···· V-·.··di _r(a)·v·········
$= \----#·············t\···V ···$;di $a····)········· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}} ···········>maertsoi<edulcni#p·h···=b c d e f g h i········· ····;s gnirts::dts{)(niam tni····v< o<···················· ···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;··················· # Varsig, 3 characters added Using the shortcut symbols (_#) This translates to the full commands of PRY CLEAN EXIT CRAM Added on the 18h line backwards near the centre. The new grid. ·········v---H\OIv+C+<D_··············S·P··············;···· G····,··>qir@uH· IaP.C········LAMBDA·USE: io·········>···· Get a chr!?pio;····Ol···········ZEROY·Lreadln(write(···;···· Outputs it,u········e·······c······ ·L·print(readline())···· and 'BZam..t········r·······a·····ai ··string))··<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:·E···· G·····main( ){printf("%c", (getchar()));}·······pr>·:·;···· O·········)g·> input('','s'))·················h_··)·P···· a··········e·····n··r·····^·c·········g··········pd····;···· ·······(write(read-host)····a)········r·input n$!?u····(····
·······))E·s········m·······n)···KVGH·e·print n$!·m····;···· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*····$'main'H·TUPTUO·····t·······,t···HSMI· ···r·······(·········
\/\··O· ·TUPNI···S (I\·····'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·m···········a········· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ····,·····g········· % A\-e-< |··········)#_(···· V-·.··di _r(a)·v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
···········>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<····················
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

,.@

New grid:

·········v---H\OIv+C+<D_··············S·Psgv···········;····
G····,··>qir@uH·  IaP.C········LAMBDA·USE: io·········>····
Outputs it,u··a$ohce·······c······ ·L·print(readline())···· and 'BZam..t···a daer·······a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:·E···· G·····main( ){printf("%c", (getchar()));}·······pr>·:·;···· O·········)g·> input('','s'))·················h_··)·P···· a··········e·····n··r·····^·c·········g··········pd····;···· ·······(write(read-host)····a)········r·input n$!?u····(····
·······))E·s········m·······n)···KVGH·e·print n$!·m····;···· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*····$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(·········
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·m···········a········· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ··@.,·····g········· % A\-e-< |··········)#_(···· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
···········>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<····················
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP
• And that's the Y's done :) – MickyT Sep 10 '15 at 23:46

%:.x

I placed it vertically from the second line to the 4th, below "Include".

·········v---H\OIv+C+<D_Include C by GS·Psgv···········;····
G····,.·>qir@uH·  IaP.C.%······LAMBDA·USE: io·········>····
Outputs it,u··a$ohce····.··c······ ·L·print(readline())···· and 'BZam..t···a daer····x··a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:,Eu-·· G·····main( ){printf("%c", (getchar()));}·······pr>·:·;tg·· O·········)g·> input('','s'))(enildr ,tnirp···h_··)·P(e·· a··········e·····n··r·····^·c·········g··········pd····;Ct·· ·······(write(read-host)····a)········r·input n$!?u····()(··
·······))E·s········m·······n)···KVGH·e·print n$!·m····;.C·· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*·)··$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(······,··
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·main = interact id···· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ··@.,·····g········· % A\-e-< |··········)#_(···· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
··········;>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<····················
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

rw

Reads a single character and outputs it.

New grid:

·········v---H\OIv+C+<D_Include C by GS Psgv···········;····
G····,.·>qir@uH·  IaP.C.%······LAMBDA·USE: io·········>····
Outputs it,u··a$ohce····.··c······ ·L·print(readline())···· and 'BZam..t···a daer····x··a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:,Eu-·· G·····main( ){printf("%c", (getchar()));}·······pr>>:.;tg·· O·········)g·> input('','s'))(enildr ,tnirp···h_··)·P(e·· a··········e·····n··r·····^·c···puts [gets stdin]pd····;Ct·· ·······(write(read-host)····a)········r·input n$!?u····()(··
·······))E·s··w·····m·······n)···KVGH·e·print n$!·m····;.C·· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*·)··$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(······,··
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·main = interact id···· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ··@.,·····g········· % A\-e-< |··········)#_(o··· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
··········;>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<Ook. Ook! Ook! Ook.·
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

# GNU bc, 4 characters added

read()          # the printing is implicit

bc is a calculator language. The only input token recognized by read() is a number, an allowed limitation. A trailing newline is needed when saving the code to a file.

Run example:

bc --quiet program.bc <<< 35

New grid: my characters are added horizontally, left to right, starting from (row = 10, column = 52)

·········v---H\OIv+C+<D_Include C by GS Psgv···········;····
G····,.·>qir@uH·  IaP.C.%······LAMBDA·USE: io·········>····
Outputs it,u··a$ohce····.··c······ ·L·print(readline())···· and 'BZam..t···a daer····x··a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:,Eu-·· G·····main( ){printf("%c", (getchar()));}·······pr>>:.;tg·· O·········)g·> input('','s'))(enildr ,tnirp···h_··)·P(e·· a··········e·····n··r·····^·c···puts [gets stdin]pd····;Ct·· ·······(write(read-host)····a)········r·input n$!?uread()(··
·······))E·s··w·····m·······n)···KVGH·e·print n$!·m····;.C·· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*·)··$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(······,··
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·main = interact id···· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ··@.,·····g········· % A\-e-< |··········)#_(o··· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
··········;>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<Ook. Ook! Ook! Ook.·
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

({})

Pops and pushes the top element,so the stack ends up unchanged. Input is implicitly put on the stack, and the stack is printed afterwards. Only numbers are allowed (unless you use the argument -c).

New grid:

·········v---H\OIv+C+<D_Include C by GS Psgv···········;····
G····,.·>qir@uH·  IaP.C.%······LAMBDA·USE: io·········>····
Outputs it,u··a$ohce····.··c······ ·L·print(readline())···· and 'BZam..t···a daer····x··a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:,Eu-·· G·····main( ){printf("%c", (getchar()));}·······pr>>:.;tg·· O·········)g·> input('','s'))(enildr ,tnirp···h_··)·P(e·· a··········e·····n··r·····^·c··{puts [gets stdin]pd····;Ct·· ·······(write(read-host)····a)}·······r·input n$!?uread()(··
·······))E·s··w·····m·······n)···KVGH·e·print n$!·m····;.C·· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*·)··$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(······,··
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·main = interact id···· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io··EE 4n ··@.,·····g········· % A\-e-< |··········)#_(o··· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
··········;>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<Ook. Ook! Ook! Ook.·
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

My code (lines 8-11):

································(···························
·······························{····························
······························}·····························
·····························)······························

Code:

)io@

Run in the online interpreter!

This maps out to the following cube when executed:

)
i o @ .
.

The interpreter runs i (input a character), o (print the character), and then @ (terminate the program). In this case, ) is a no-op, simply there because )io was already on the grid, and a leading character was needed to align the grid correctly.

·········v---H\OIv+C+<D_Include C by GS Psgv···········;····
G····,.·>qir@uH·  IaP.C.%······LAMBDA·USE: io·········>····
Outputs it,u··a$ohce····.··c······ ·L·print(readline())···· and 'BZam..t···a daer····x··a·····ai ··string))·o<v;i:j;p:j· G·······~,@s······s t=" " r t#50:20 w !,t,!······?a?·:,Eu-·· G·····main( ){printf("%c", (getchar()));}·······pr>>:.;tg·· O·········)g·> input('','s'))(enildr ,tnirp···h_··)·P(e·· a··········e·····n··r·····^·c··{puts [gets stdin]pd····;Ct·· ·······(write(read-host)····a)}·······r·input n$!?uread()(··
·······))E·s··w·····m·······n)···KVGH·e·print n$!·m····;.C·· ········C·E·········p·······((···TIIA{print;exit}·pYEK·*·)··$'main'H·TUPTUO·····t·00····,t···HSMI· ···r·······(······,··
\/\I^O= ·TUPNI···S (I\\/\]]'u···XIM ·-···········$········· \/· ·/(println··FO) /·····'p···BBE1·main = interact id···· \%·PQ (read-line))······)n···YLH.·1··print(io.read())··· A\ /-io-\············)io@·EE 4n ··@.,·····g········· <-- added on this line % A\-e-< |··········)#_(o··· V-·.··di _r(a)^v·········$ =      \----#·············t\·c&V ···$;di$a····)·········
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
··[x.?10xx][x.?10xx]r··e···a b c d e f g h i·····}}
··········;>maertsoi<edulcni#p·h···=b c d e f g h i·········
····;s gnirts::dts{)(niam tni····v<   o<Ook. Ook! Ook! Ook.,
···};s<<tuoc::dts;s>>nic::dts···o>i:1+?/;][gnirtStupnI@tnirP

r

The grid is now:

····························································
····························································
··········?pio··············································
··········,u················································
··········.t················································
···········s················································
··········· ················································
···········g················································
···········e················································
········w··t················································
···········s················································
····························································
··········································r·················
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································

ip

The grid is now:

····························································
···········i················································
··········?pio··············································
··········,u················································
··········.t················································
···········s················································
··········· ················································
···········g················································
···········e················································
········w··t················································
···········s················································
····························································
··········································r·················
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································

The grid is now:

····························································
···········i········a·······································
··········?pio;·····l·······································
··········,u········e·······································
··········.t········r·······································
···········s········t·······································
··········· ········(·······································
···········g········p·······································
···········e·····n··r·······································
···········s········m·······································
····················p·······································
····················t·····················r·················
····················(·······································
····················)·······································
····················)·······································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································
····························································

A space.

The new grid:

·········v---H\·············································
·········>qir@uH····a·······································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
··········@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·······························
·······))E·s········m·······n)······························
········C·E·········p·······((······························
·······H·T··········t·······,t············r·················
······O· ···········(·······'u······························
····· ·/············)·······'p······························
····%·P·············)·······)n········1·····················
···A· ······················)i·······n······················
··%·A························(······-·······················
···=·························t····· ···$·d·················· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a·····················}} ·····························p·h···=························ ··································<························· ·································>·························· # gs2, 1 character added K. The new grid: ·········v---H\············································· ·········>qir@uH····a······································· Get a chr!?pio;·····l······································· Outputs it,u········e·······c······························· and 'BZam..t········r·······a······························· ··········@s······s t=" " r t#50:20 w !,t,!················· ··········· ··printf(·······(······························· ···········g·· input('','s'))···························· ···········e·····n··r·······c·········g····················· ·······(write(read-host)····a)········r······ ·············· ·······))E·s········m·······n)········e····················· ········C·E·········p·······((········p··············K······ ·······H·T··········t·······,t········ ···r················· ······O· ···········(·······'u········-····················· ····· ·/············)·······'p········m····················· ····%·P·············)·······)n········1····················· ···A· ······················)i·······n ····················· ··%·A························(······-·.····················· ···=·························t····· ···$·d··················
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a·····················}}
·····························p·h···=························
··································<·························
·································>··························
• It should be upper-case, my caps lock was on. – Lynn Sep 8 '15 at 23:51

~,@

The new grid:

·········v---H\·············································
·········>qir@uH···IaP.·····································
Get a chr!?pio;·····l·······································
Outputs it,u········e·······c·······························
and 'BZam..t········r·······a·······························
········~,@s······s t=" " r t#50:20 w !,t,!·················
··········· ··printf(·······(·······························
···········g··    input('','s'))····························
···········e·····n··r·······c·········g·····················
·······))E·s········m·······n)········e·····················
········C·E·········p·······((·······{print;exit}····K······
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)i·······n ·····················
··%·A························(······-·.·····················
···=·························t····· ···$·d·················· {elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc ;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS ·····························r··e···a·····················}} ·····························p·h···=························ ··································<························· ·································>·························· ## Betterave, 1 character added$;

The new grid:

·········v---H\········································;····
······,··>qir@uH···IaP.················USE: io·········>····
and 'BZam..t········r·······a··········string)·········;····
········~,@s······s t=" " r t#50:20 w !,t,!············E····
······main( ){printf("%c",  (getchar()));}·············;····
···········g·>    input('','s'))·······················P····
···········e·····n··r·····^·c·········g················;····
·······(write(read-host)····a)········r·input n$·······(···· ·······))E·s········m·······n)········e·print n$·······;····
········C·E·········p·······((·······{print;exit}····K·*····
·······H·T··········t·······,t········ ···r·················
······O· ···········(·······'u········-·····················
····· ·/············)·······'p········m·····················
····%·P·············)·······)n········1·····················
···A· ······················)io······n ·····················
··%·A························(······-·.··di _r(a)···········
···=·························t\···· ···$;di$a··············
{elbaworhT sworht )a][gnirtS(niam diov citats cilbup{C ssalc
;))(txen.)ni.metsyS(rennacS.litu.avaj wen(nltnirp.tuo.metsyS
·····························r··e···a b c d e f g h i·····}}
·····························p·h···=b c d e f g h i·········
··································<·························
·································>··························