Generate ;# code

Question

Related to: Make a ;# interpreter

In the above linked challenge the task was to create an interpreter for the esoteric language ;#.

The ;# language

The language has exactly two commands: ; and # (all other characters are ignored by the interpreter):

;: Increment the accumulator

#: Modulo the accumulator by 127, print the corresponding ASCII character and reset the accumulator to 0.

Challenge

Because I am lazy but still want to test some more testcases, I need a program or function which converts plain text to ;# code.

Input

The input is a string, taken either as argument or through stdin. It will only contain printable ASCII characters and newlines.

Output

The output is the generated ;# program by returning, or printing to stdout. As long as the program is valid, it may contain excess characters other than # and ; as all other characters are ignored.

Examples

Input: Hello, World!
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ABC
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ;#
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Leaderboard

var QUESTION_ID=122139,OVERRIDE_USER=73772;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Answer 1

;#+, 61 bytes

Outgolfed by Conor O'Brien

;;;;;;;(~;;;;;~-;-)~>:~;;;;(~;;;;;;~-;-)~>~-*((;~<#~):<#-:-*)

Try it online!

Note that the input has a trailing null byte.

Answer 2

;#+, 40 bytes

;;;;;~+++++++>~;~++++:>*(-(;~<#~):<#-*:)

Try it online! Input is terminated with a null byte.

Explanation

The code is split into two parts: generation and iteration.

Generation

;;;;;~+++++++>~;~++++:>

This puts the constants ; and # into memory as such:

;;;;;~+++++++>~;~++++:>
;;;;;                     set A to 5
     ~                    swap A and B
      +++++++             add B to A 7 times
                          (A, B) = (5*7, 5) = (35, 5)
             >            write to cell 0
              ~           swap A and B
               ;          increment A
                ~         swap A and B
                          (A, B) = (35, 6)
                 ++++     add B to A 4 times
                          (A, B) = (59, 6)
                     :    increment cell pointer
                      >   write to cell 1

Iteration

*(-(;~<#~):<#-*:)
*                    read a character into A
 (            * )    while input is not a null byte:
  -                  flip Δ
   (     )           while A != 0
    ;                decrement
     ~               swap A and B
      <              read ";" into A
       #             output it
        ~            swap A and B
           :         decrement cell pointer
            <        read "#" into A
             #       output it
              -      flip Δ
               *     take another character from input
                :    increment cell pointer

Answer 3

brainfuck, 59 54 bytes

+++++[<+++++++>-]++++++[>++++++++++<-]>-<,[[>.<-]<.>,]

Try it online!

Answer 4

Jelly, 10 8 7 bytes

O”;ẋp”#

Try it online!

O”;ẋp”#  Main Link
O        Map over `ord` which gets the codepoint of every character
 ”;ẋ     Repeat ';' the required number of times
     ”#  '#'
    p    Cartesian Product; this puts a '#' at the end of each element in the array

Implicit Output shows as a single string

-2 bytes thanks to @Emigna
-1 byte thanks to @Dennis

Answer 5

GS2, 6 bytes

■•;2•#

Try it online!

Reversible hexdump (xxd)

0000000: ff 07 3b 32 07 23                                ■•;2•#

How it works

■       Map the rest of the program over  all code points C of the input.
 •;         Push ';'.
   2        Multiply; repeat ';' C times.
    •#      Push '#'.

Answer 6

Taxi, 779 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[c]Switch to plan "e" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to The Underground.Go to Writer's Depot:w 1 r.[p]; is waiting at Writer's Depot.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to The Underground:n 1 r 1 l.Switch to plan "n" if no one is waiting.Pickup a passenger going to The Underground.Go to Zoom Zoom:n 3 l 2 r.Go to Writer's Depot:w.Switch to plan "p".[n]# is waiting at Writer's Depot.Go to Writer's Depot:n 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan "c".[e]

Try it online!

Ungolfed:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[c]
Switch to plan "e" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill: north 1st left 3rd left 3rd left.
Pickup a passenger going to The Underground.
Go to Writer's Depot: west 1st right.
[p]
; is waiting at Writer's Depot.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to The Underground: north 1st right 1st left.
Switch to plan "n" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north 3rd left 2nd right.
Go to Writer's Depot: west.
Switch to plan "p".
[n]
# is waiting at Writer's Depot.
Go to Writer's Depot: north 3rd left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
Switch to plan "c".
[e]

Explanation:

Pick up stdin and split it into characters.
Covert each character to ASCII.
Print ";" as you count down from that ASCII to zero.
Print "#".
Pickup the next character and repeat until done.

Answer 7

05AB1E, 8 bytes

Ç';×'#«J

Try it online!

Explanation

Ç          # convert each input char to its ascii value
 ';×       # repeat ";" those many times
    '#«    # append a "#" to each run of semi-colons
       J   # join to string

Answer 8

Brainfuck, 43 bytes

+[+[<]>->++]--[>--<+++++++]>-<,[[<.>-]>.<,]

Null byte terminates the program.

Explanation

+[+[<]>->++]          59 (semicolon) location 5
--[>--<+++++++]>-       35 (hash) location 7
<,[                     input location 6
    [   while input byte not 0
        <.>     print semicolon
        -       decrement input byte
    ]
    >.< print hash
,]  loop while input not null

Answer 9

Python 3, 39 bytes

[print(";"*ord(s)+"#")for s in input()]

Try it online!

Answer 10

><>, 22 bytes

i:0(?;\"#"o
o1-:?!\";"

Try it online, or at the fish playground

Input is STDIN, output is STDOUT. In ><>, characters and ASCII codes are the same thing, so all we need to do is read a character, print ";" and decrement the character until it's 0, then print "#" and loop until there's no more input left.

Answer 11

F#, 79 bytes

let c i=System.String.Join("#",Seq.map(fun c->String.replicate(int c)";")i)+"#"

Try it online!

Expanded

// string -> string
let convert input =
    System.String.Join(
        "#",      // join the following char seq with "#"
        input     // replicate ";" n times where n = ASCII value of char c
        |> Seq.map (fun c-> String.replicate (int c) ";") 
    ) + "#" // and add the last "#" to the output

convert takes the input string and outputs a ;# program

Usage

convert "Hello, World!" |> printfn "%s"
convert "ABC" |> printfn "%s"
convert ";#" |> printfn "%s"

Answer 12

Python 2 - 36 bytes

for i in input():print';'*ord(i)+'#'

Try it online!

Answer 13

PowerShell, 29 27 25 bytes

$args|% t*y|%{';'*$_+'#'}

Pretty straightforward. Takes input as command-line argument. Output is a valid ;# program that prints the requested text.

Answer 14

JavaScript, 55 54 51 50 48 bytes

s=>1+[...s].map(c=>";".repeat(Buffer(c)[0])+"#")

Try it online

• 1 byte saved thanks to Neil.

---

Alternatives

If we can take input as an array of individual characters then 5 bytes can be saved.

a=>1+a.map(c=>";".repeat(Buffer(c)[0])+"#")

If we can also output as an array then 2 more bytes can be saved.

a=>a.map(c=>";".repeat(Buffer(c)[0])+"#")

Answer 15

brainfuck, 47 bytes

+++++++[->++++++++>+++++<<]>+++<,[[>.<-]>>.<<,]

Try it online!

See also: ovs's answer, which takes a similar approach, but with a different method of generating constants and a different cell layout.

---

Explanation:

This challenge lines up with the brainfuck spec pretty well, which means the solution is essentially trivial. Brainfuck takes input as ASCII values, which is exactly what ;# need to output as.

The schematic for transpiling is simple: Generate the ASCII value for ; and #, print ; equal to the ASCII value of the input character, print #, repeat for every input.

+++++++[-             7
         >++++++++       * 8 = 56
         >+++++<<        * 5 = 35 (#)
       ]>+++<                  56 + 3 = 59 (;)
,[                    Input into first cell
  [>.<-]              Print ;'s equal to ASCII input
  >>.<<,              Print one #
 ]                    End on EOF

Answer 16

Mathematica, 49 bytes

StringRepeat[";",#]<>"#"&/@ToCharacterCode@#<>""&

Explanation

Converts the input string to a list of character codes, then Maps the function StringRepeat[";",#]<>"#"& over the list, then StringJoins the result with the empty string.

Answer 17

Befunge-98 (FBBI), 23 17 10 bytes

-5 bytes thanks to Jo King.

"#@~k:*k,;

Try it online!

Answer 18

Aceto, 19 bytes

Since there's an interpreter in Aceto, I thought there outta be an Aceto answer to this challenge as well. It fits neatly in a 2rd order Hilbert curve:

\n;*
'o'p
`!#'
,dpO

First of all, we read a single character (,) and duplicate and negate it to test whether it is a newline (d!, when reading a newline, an empty character is normally pushed on the stack). I then use what I think is a pretty clever trick to handle the newline case compactly:

`'\n

If the value on the stack is True (we read a newline), that code means: do (`) put a character literal on the stack ('), which is a newline: \n.

If the value on the stack is False (we didn't read a newline), that code means: don't (`) read a character literal ('). That means the next character is executed as a command. Fortunately, a backslash escapes the next command (it makes it so that it doesn't get executed), so n doesn't print a newline (which is what n usually does).

The rest of the code is straightforward; we convert the character on the stack to the integer of its unicode codepoint (o), we push a literal semicolon (';), multiply the number with the string (*, like in Python), print the result, push a literal (') #, print it too, and go back to the Origin.

Run with -F if you want to see immediate results (because buffering), but it works without, too.

Answer 19

Perl, 24 bytes

s/./";"x(ord$&)."#"/ges

Run with perl -pe.

Alternative solution:

say";"x ord,"#"for/./gs

Run with perl -nE.

Answer 20

Fourier, 19 bytes

$(I(`;`&j)`#`0~j&i)

Try it on FourIDE!

To run, you must enclose the input string in quotation marks.

Explanation pseudocode

While i != Input length
    temp = pop first char of Input
    While j != Char code of temp
        Print ";"
        Increment j
    End While
    Print "#"
    j = 0
    Increment i
End While

Answer 21

Solace, 11 bytes

Yay, new languages.

';@jx{'#}Ep

Explanation

';           Push the code point of ';' (59).
  @j         Push the entire input as a list of code points.
    x        For each code point in the input, repeat 59 that many times.
     {  }E   For each resulting list of 59s:
      '#      Push the code point of '#' (35).
          p  Flatten and print as unicode characters.

Answer 22

Actually, 11 bytes

O⌠';*'#o⌡MΣ

Try it online!

Explanation:

O⌠';*'#o⌡MΣ
O            convert string to list of ASCII ordinals
 ⌠';*'#o⌡M   for each ordinal:
  ';*          repeat ";" that many times
     '#o       append "#"
          Σ  concatenate

Answer 23

APL (Dyalog), 18 bytes

'#',¨⍨';'⍴¨⍨⎕UCS

Try it online!

⎕UCS Convert to Unicode code points

';'⍴¨⍨ use each code point to reshape (⍴ = Rho ≈ R; Reshape) a semicolon

#',¨⍨ append a hash to each string

Answer 24

Ruby, 28 25 bytes

24 bytes, plus the -n command line switch to repeatedly operate on stdin.

$_.bytes{|b|$><<?;*b+?#}

3 bytes saved (and output corrected on newlines!) thanks to manatwork.

Answer 25

PHP, 54 Bytes

for(;$o=ord($argn[$i++]);)echo str_repeat(";",$o)."#";

Try it online!

Answer 26

Alice, 12 bytes

'#I.h%&';d&O

Try it online!

Explanation

'#    Push 35, the code point of '#'.
I     Read a code point C from STDIN. Pushes -1 at EOF.
.h%   Compute C%(C+1). For C == -1, this terminates the program due to division
      by zero. For C > -1, this just gives back C, so it does nothing.
&';   Pop C and push that many 59s (the code point of ';').
d     Push the stack depth, which is C+1.
&O    Print that many code points from the top of the stack.
      The IP wraps around to the beginning and another iteration of this
      loop processes the next character.

Answer 27

PHP, 48 bytes

for(;$c?:~$c=~ord($argn[$i++]);)echo";#"[!++$c];

Answer 28

jq, 30 characters

(26 characters code + 4 characters command line options)

explode|map(";"*.+"#")|add

Sample run:

bash-4.4$ jq -Rr 'explode|map(";"*.+"#")|add' <<< 'Hello, World!' | jq -Rrj '[scan(".*?#")|gsub("[^;]";"")|length%127]|implode'
Hello, World!

On-line test

Answer 29

Pyth, 10 bytes

sm_+\#*\;C

Try it!

Answer 30

Röda, 24 bytes

{chars|[";"*ord(_),"#"]}

Try it online!

Answer 31

Brachylog, 15 bytes

ạ{;";"j₍,"#"}ᵐc

Try it online!

ạ                   % Convert the string into its ascii codes
 {          }ᵐ      % map this over each resulting code:
  ;";"j₍            %   repeat ";" that many times
        ,"#"        %   tack on a "#" at the end of that
              c     % at the end of the map, concatenate the results of the map

Answer 32

CJam, 12 10 bytes

q{i';*'#}%

Explanation:

q           e# Read input
 {          e# For each character in the input:
  i         e#  Get code point
   ';*      e#  Repeat ';' that many times
      '#    e#  Add a '#'
        }%  e# End for
e# Implicit output

Answer 33

Japt, 10 9 bytes

c@'#i';pX

Try it

---

Explanation

     :Implicit input of string U
c@   :Map over the codepoints of characters in the string
'#   :"#"
i    :Prepend
';   :";"
p    :repeated
X    :The current codepoint times

Answer 34

PowerShell, 36 Bytes

-join([char[]]"$args"|%{';'*$_;'#'})

just prints ;s and then a #

Answer 35

Wolfram Mathematica, 69 bytes

FromCharacterCode[Flatten[{Table[59,{,#}],38}&/@ToCharacterCode[x]]]

Table[59,{,#}] is a short replacement for ConstantArray[].

Answer 36

R, 59 56 bytes

for(x in utf8ToInt(scan(,'')))cat(rep(';',x),'#',sep="")

Try it online!

Answer 37

C, 61 57 bytes

c;f(){for(;~(c=getchar());puts("#"))while(c--)puts(";");}

Hope you don't mind a newline after every character :P However, this is allowed, as it doesn't affect the program, since all bytes aside from ;# are ignored.

Answer 38

shortC, 27 bytes

c;AO;~(c=G);J"#"))Wc--)J";"

Answer 39

Cubix, 19 bytes

-5 bytes thanks to @MickyT!

i.#';UoU^!.$U@?(';o

on a cube:

    i .
    # '
; U o U ^ ! . $
U @ ? ( ' ; o .
    . .
    . .

this version is much cleverer than the prior one (my version) with moving the instruction pointer around, using U (left-hand u-turn) and the way the adjacencies on the cube to loop and produce the correct output. Explanation to follow.

Old Version, 24 bytes:

..@.;i?...>;'(/!.;o;W'.#

Try it online! and Watch it online! (the latter might be really slow)

Since this question had a relatively simple I/O scheme, I figured this would be a good fit for a Cubix solution. I still spent a few days trying to solve it, though. The breakthrough was when I tried using !, which skips the next instruction if the top of the stack is truthy (not zero, I think), enabling something like a while loop.

Cubified:

    . .
    @ .
; i ? . . . > ;
' ( / ! . ; o ;
    W '
    . #

The instruction pointer starts at the top left corner of the leftmost face, pointing east. Here's the code:

Outer loop:

; - pop the top item off the stack. does nothing at the beginning since the stack is empty.
i - read in the ascii character as an integer. Reads -1 at end of input.
? - turns right if the top of the stack is positive, and left if negative.
@ - if negative (end of input), ends the program
/ - mirrors the direction pointer (swapping S<->W and N<->E), entering the inner loop

Inner loop:

( - decrements the top of the stack (the ascii value of the input)
' - pushes the next char
; - the semicolon
o - outputs as a char
; - pops the top of the stack
! - ignores the next instruction if the top of the stack is not zero

then when the appropriate number of ; have been printed,

/ - the IP is moving W, so it now switches S
W - move the IP left
' - push the next char
# - pushes this char
o - prints #
> - points the IP east
; - pop the top of the stack

and then returns to the top of the outer loop.

Answer 40

Ly, 18 bytes

&ir[[";"o1-]"#"op]

Try it online!

Answer 41

Braingolf, 11 bytes

&([#;]##)&@

Try it online!

Ooh, moderately golfy

Answer 42

Befunge-93, 31 28 26 bytes

Edit: -2 bytes thanks to James Holderness

#;"~1+:!#@_>1#\-#,: #\_$$,

Try it Online

How it works

#;"          Adds # and ; to the stack
   ~1+:!#@_  Gets the input and dupes it. Ends if the input is eof
           >1#\-#,: #\_ Prints a semi-colon until the input byte reaches 0
                       $$, Prints the ending hash and loops back round

Answer 43

Pushy, 12 bytes

@$:59'.;35'.

Try it online!

This prints each character of the ;# code on a newline. To condense the code, simply prepend N to the program to remove the printing delimiter.

Answer 44

Minecraft Functions (18w11a, 1.13 snapshots), 861 bytes

Uses four functions

a

scoreboard objectives add a dummy
scoreboard objectives add b dummy
scoreboard objectives add c dummy
scoreboard objectives add d dummy
scoreboard objectives add e dummy
scoreboard players set x a 0
scoreboard players set x b 0
scoreboard players set x c 1000
scoreboard players set x d 0
scoreboard players set x e 1
function b
function c

b

scoreboard players operation x b = x i
scoreboard players operation x b %= x c
scoreboard players operation x a *= x c
scoreboard players operation x a += x b
scoreboard players operation x i /= x c
execute if score x i > x d run function b

c

scoreboard players operation x i = x a
scoreboard players operation x i %= x c
function d
tellraw @s "#"
scoreboard players operation x a /= x c
execute if score x a > x d run function c

d

tellraw @s ";"
scoreboard players operation x i -= x e
execute if score x i > x d run function d

"Takes input" from a scoreboard objective named i, create it with /scoreboard objectives add i dummy and then set it using /scoreboard players set x i 5. Then call the function using /function a

Limitations:

Minecraft does not really support strings, or input, or much of anything really, so due to language limitations, input is passed to the i scoreboard, as ascii values, so "ABC" would be 65066067.

However, due to another limitation, scoreboard objectives can only store numbers with 10 or less digits, so all strings must be passed in chunks of three letters. For example, "Hello, World!" must be converted to '072101108', '108111044', '032087111', '114108100', '033' and the function must be called for each of these numbers. Hope that counts as a valid input method.

This python function will convert the strings, it does not change the string in any way, other than getting the ascii representation,

def convert(string):
    line = ''.join('{:0>3}'.format(ord(c)) for c in string)
    print([line[i:i+9] for i in range(0, len(line), 9)])

Minecraft may not have been the best choice of language.

Answer 45

Canvas, 5 bytes

ｃ;×#］

Try it here!

Explanation:

{    ] map over the characters of the input
 c     convert the character to its unicode codepoint
  ;×   repeat ";" that many times
    #  push "#"

Answer 46

C (72 bytes)

main(c){while((c=getchar())!=-1){while(c--)putchar(';');putchar('#');}}

Answer 47

Gema, 28 charcters

?=@repeat{@char-int{?};\;}\#

Sample run:

bash-4.4$ gema '?=@repeat{@char-int{?};\;}\#' <<< 'Hello, World!' | gema '\A=@set{a;0};\;=@incr{a};\#=@int-char{@mod{$a;127}}@set{a;0};?='
Hello, World!

Answer 48

QBIC, 36 bytes

[_l;||[asc(_sA,a,1|)|Z=Z+@;`]Z=Z+@#`

Explanation

[_l;||        FOR a = 1 to LEN(A$) # A$ is read from the vmd line
[asc(...)     FOR b = 1 to the ASCII value of
   _sA,a,1|     The next char of A$
Z=Z+@;`       Add the increment instruction to Z$
]         NEXT increment instruction
Z=Z+@#`       When all incrementers are added, issue a print-command
              NEXT for the outer FOR loop is added inplicitly at EOF
              Z$ is printed implicitly at EOF

Answer 49

Go, 91 bytes

import(."fmt";."strings")
func f(s string){for _,c:=range s{Print(Repeat(";",int(c))+"#")}}

Try it online!

Explanation

import( . "fmt"                     // fmt import to print stuff out
        . "strings"                 // strings import for string manipulation
)                                   // the dots import into the global namespace

func transpile(str string) {        // function that takes a string argument
    for _, char := range str {      // iterate over the runes (characters) in str
        Print(                      // print x without newline where x is...
              Repeat(";",           // ...";" repeated y times where y is... 
                     int(char)) +   // ...the ASCII integer of the rune and...
              "#")                  // ..."#" to end it
    }
}

Answer 50

Bean, 48 bytes

00000000: 53d0 80c3 cf53 d080 a078 2080 7b23 8100  SÐ.ÃÏSÐ. x .{#..
00000010: 0020 8088 40a0 5f4c d3d0 80a3 8101 2080  . ..@ _LÓÐ.£.. .
00000020: b553 5080 a05f 2080 ad8b 2381 020a 3b23  µSP. _ ...#...;#

Try it online!

Equivalent JavaScript (ES6):

[..._.join("\n")].map((c)=>";".repeat(c.charCodeAt())+"#");

Explanation

Taking multiline standard input as an array of string lines in _, it first joins them with \n and spreads the resulting string into an array of characters, which is then mapped like in @Shaggy's answer.

The difference is, it outputs the raw array of ;# strings that represent each character, but because the language specification will ignore all of the following characters: []' , this is valid behavior.

Answer 51

C# 54 + 18 = 72 Bytes

using System.Linq;
s=>string.Join("",s.Select(c=>new string(';',c)+"#"));

Ungolfed full program and explanation

using System.Linq;

class P
{
    static void Main()
    {
        System.Func<string, string> f =
            s => string.Join("",       //4. Join the results separated by an empty string and implicitly return
                s.Select(c =>          //1. For each character in the input
                    new string(';', c) //2. Implicitly convert the character to an int with the ASCII-Code and create a new string with that many ;
                    + "#"));           //3. Add a #

        System.Console.WriteLine(f(";#"));
        System.Console.WriteLine(f("ABC"));
        System.Console.WriteLine(f("Hello World!"));
    }
}

Answer 52

Husk, 13 10 bytes

ṁȯ`:'#R';c

Try it online!

Ungolfed/Explained

ṁȯ          -- map function and concatenate result
         c  --   ASCII order of element times
      R';   --   repeat ';' and
  `:'#      --   append '#'

Answer 53

Haskell, 50 32 bytes

This is a direct port of my Husk answer:

((\n->(';'<$['\1'..n])++"#")=<<)

Try it online!

Thanks @Laikoni for saving me 18 bytes!

Answer 54

Python 3, 51 bytes

[print(''.join((';'*ord(i)+'#')for i in input()))] 

Try it online!

Answer 55

q/kdb+, 24 bytes

Solution:

{,["#"sv(7h$x)#'";"]"#"}

Explanation:

q is interpreted right-to left. We cast the input to it's ASCII values, thus "Hello, World!" becomes 72 101 108 108 111 44 32 87 111 114 108 100 33. We then take this many of the ; character, which gives us a list of lists. These lists are joined together with #, then we a # on the end to terminate the string.

{,["#"sv(7h$x)#'";"]"#"} / the solution
{                      } / lambda function
 ,[                ]"#"  / concatenate with "#"
              #'         / apply each-left take (#) each-right
                ";"      / the right (the character ;)
        (7h$x)           / the left (input cast to ASCII values)
   "#"sv                 / join these lists back together with "#"

Bonus:

Could save 1 byte moving the cast outside the function, but that's a bit underhand:

{,["#"sv x#'";"]"#"}7h$

Taking inspiration from the APL solution and the above yields a 22 byte solution:

{raze(x#'";"),'"#"}7h$

which becomes 20 bytes in k

{,/(x#'";"),'"#"}7h$

Answer 56

Charcoal, 8 bytes

ＦＳ⁺×;℅ι#

Try it online!

Explanation (for those too lazy to click the link)

Ｆ         For
 Ｓ        each character in next input as string
   ⁺    #  Append "#"
    × ℅ι   Multiply (repeat) by the character code of i (loop variable)
     ;     ";"

Answer 57

Common Lisp, 71 bytes

(lambda(s)(map'list(lambda(x)(format t"~v,,,v<~>#"(char-code x)#\;))s))

Try it online!

Answer 58

SNOBOL4 (CSNOBOL4), 90 bytes

	N =INPUT
T	N LEN(1) . L REM . N :F(END)
	&ALPHABET L @X
	OUTPUT =DUPL(';',X) '#' :(T)
END

Try it online!

	N =INPUT			;* read input
T	N LEN(1) . L REM . N :F(END)	;* set L to the first character, N to the REMainder, and
					;* if there is no match (N is empty), goto END
	&ALPHABET L @X			;* @ssign X with the value of the match of L inside &ALPHABET (all ASCII chars)
	OUTPUT =DUPL(';',X) '#' :(T)	;* set OUTPUT to ';' duplicated X times concatenated with '#', and a newline
					;* then goto T
END

Answer 59

Kotlin, 49 bytes

{it.map{('a'-97..it).map{print(';')}
print('#')}}

Beautified

        {
            it.map {
                ('a'-97..it).map { print(';') }
                print('#')
            }
        }

Test

import java.io.ByteArrayOutputStream
import java.io.PrintStream

/**
 * @author James Tapsell
 */
var o: (String) -> Unit =
{it.map{('a'-97..it).map{print(';')}
print('#')}}

data class Test(val input: String, val output: String)

val tests = listOf(
        Test("Hello, World!", ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"),
        Test("ABC", ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"),
        Test(";#", ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")
)

fun main(args: Array<String>) {
    tests.forEach {
        val out = ByteArrayOutputStream()
        System.setOut(PrintStream(out))
        o(it.input)
        val text = String(out.toByteArray())
        if (text != it.output) {
            throw AssertionError()
        }
    }
}

TIO

TryItOnline

Answer 60

Gol><>, 11 bytes

iEHr{R`;`#r

Try it online!

How it works

iEHr{R`;`#r

i            Input n as char
 EH          If EOF, print stack contents as chars (from top) and exit

             Stack content                     [x y z... n]
   r{        Reverse the whole stack except n  [...z y x n]
     R`;     Pop n and push that many ';'s     [...z y x ;...;]
        `#   Push '#'                          [...z y x ;...; #]
          r  Reverse stack                     [# ;...; x y z...]
             Repeat indefinitely

The r...r structure makes the invariant that the stack content is the desired string reversed.

Answer 61

J, 23 Bytes

Nothing special.

,([:,&'#'#&';')"0 u:inv

Explanation:

,([:,&'#'#&';')"0 u:inv
                  u:inv   | Convert string to code points
 (            )"0         | For each item:
  [:,&'#'#&';'            | Repeat ';' n times and append #
,                         | Ravel the resulting character array

Note that the result contains lots of whitespace, since arrays have to be rectangular.

Answer 62

Java 10, 63 bytes

c->{var s="";for(var d:c){for(;d-->0;)s+=";";s+="#";}return s;}

Try it online here.

Ungolfed version:

c -> { // lambda taking a char[] as argument and returning a String
    var s = ""; // the output String
    for(var d : c) { // iterate over all the input chars
        for(; d-- > 0 ;) // as many times as the ASCII value of the current char
            s += ";";    // append ";" to the program to compute the character
        s += "#"; // append "#" to output the character
    }
    return s; // return the finished program
}

Answer 63

Ahead, 13 bytes

~W$:ki@j";#"~

Try it online!

Answer 64

Noether, 21 bytes

I~sL(";"si/B*P"#"P!i)

Try it online!

Explanation:

I~s                   - Get input and store in the variable s
   L(               ) - Loop until the top of stack equals the length of s
     ";"              - Push the string ";"
        si/           - Return the character of string s at position i
           B          - Return the ASCII code of the character
            *P        - Multiply ";" by the ASCII code and print
              "#"P    - Push the string "#" and print
                  !i  - Increment i

Answer 65

Pascal (FPC), 94 bytes

var c:char;i:word;begin repeat read(c);for i:=1to ord(c)do write(';');write('#')until eof end.

Try it online!

Assumes non-empty input.

Answer 66

VBA (Excel) 82 Bytes

I really think this challenge should've been scored in the length of your program after it is converted into ;#. I would score 6769 characters (including newlines)

Function d(e)
  For i=1To Len(e)
    d=d &String(Asc(Mid(e,i,1)),";") &"#"
  Next
End Function

Note: the leading spaces aren't needed, just make it more read-able, not that I should be worried about that... just look at the output from this thing!!!

Un-golfed With Comments:

Function toSemiHash(translate)
    'For 1 to the length of the string
    For i = 1 To Len(translate)
        'Append a semicolon the char-code number of times along with a hash
        fromSemiHash = fromSemiHash & String(Asc(Mid(translate, i, 1)), ";") & "#"
    Next
End Function

Answer 67

PHP, 75 Bytes

This shorter then the parser I wrote for it.

Generator

function g($s){foreach(str_split($s)as$a)echo str_repeat(';',ord($a)).'#';}

You can test it like this:

$strings = [
    'Hello, World!',
    ';#',
    '!'
];

foreach($strings as $s){
    g($s); echo "\n\n";
}

function g($s){foreach(str_split($s)as$a){echo str_repeat(';',ord($a)).'#';}}

Parser (second attempt)

The one from my first attempt should work fine as well. This one is shorter, so well just use it to verify that the generator works correctly.

function f($s){foreach(split('#',$s)as$a)echo!$a?'':chr(substr_count($a,';')%127);}

You can test both like this:

//turn of warning message or set in PHP.ini
error_reporting(0);
$s = "Hello, World!";

function g($s){foreach(str_split($s)as$a)echo str_repeat(';',ord($a)).'#';}
function f($s){foreach(split('#',$s)as$a)echo!$a?'':chr(substr_count($a,';')%127);}

//output buffer the generator
ob_start();
    g($s);
$s=ob_get_clean();
f($s);

Output

 Hello, World!

Test both of them

A few things to note:

• Because neither one return information, we can capture the output by using output buffering.
  • We could also put it a file, use $argv[1] for input, remove the function calls, add the shebang #!/bin/env php and run it from the terminal. Which would cut it down to around something like 65. Then we could just pipe that into the other script. So :-P
• Because the parser is old, we have to use PHP < 7 for it. Don't worry our dev team is currently working hard on a patch to make it compatible with PHP7,(just change split to explode). They should have it done sometime in the spring after they quite code golfing and get back to work!

Lastly

My first attempt at a parser was recursive, so I thought it only fitting I make a generator that is also recursive. Unfortunately as with the first one, it's longer 89 bytes.

 function g($s,$i,$r){echo''==($a=$s[$i])?$r:g($s,++$i,$r.=str_repeat(';',ord($a)).'#');}

You can test it with the same code above:

error_reporting(0);
$s = "Hello, World!";

//function g($s){foreach(str_split($s)as$a)echo str_repeat(';',ord($a)).'#';}
function f($s){foreach(split('#',$s)as$a)echo!$a?'':chr(substr_count($a,';')%127);}

//recursive
function h($s,$i,$r){echo''==($a=$s[$i])?$r:h($s,++$i,$r.=str_repeat(';',ord($a)).'#');}

//output buffer the generator
ob_start();
   // g($s);
   h($s,0,'');
$s=ob_get_clean();
f($s);

Recursive Generator

Things that didn't make the cut

  //parser 98 bytes, strtok + do while
  function p($s){$f=strtok;$a=$f($s,'#');do{echo chr(substr_count($a,';')%127);}while($a=$f('#'));}

Answer 68

brainfuck, 48 bytes

+++++++[>+++++>++++++++<<-]>>+++>,[[-<.>]<<.>>,]

Try it online!

How it works

+++++++[>+++++>++++++++<<-]>>+++>       'write ; and # onto the tape
,[                                      'read input as ascii values and loop
    [-<.>]                              'decrement input 1 and write ; then repeat until 0
    <<.>>                               'write #
,]                                      'read input as ascii values and loop

Answer 69

J, 23 bytes

[:,[:('#',~#&';')"+3&u:

Try it online!

[:,(35,~#&59)"+&.(3&u:)

Try it online!

Posting since the existing J answer is incorrect.

How it works

[:,[:('#',~#&';')"+3&u:
                   3&u:  Convert to ASCII value
     (          )"+      Apply to each number...
           #&';'           Convert to that many ';'s
      '#',~                and add '#' to the right
   [:                    Treat the above as monadic fork
  ,                      Ravel; flatten the multidimensional array
[:                       Treat the above as monadic fork

[:,(35,~#&59)"+&.(3&u:)
              f&.g       Apply g, f, then inverse of g...
                 (3&u:)    g: convert to ASCII value
   (        )"+            f: apply to each number...
        #&59                 convert to that many 59's (charcode of ';')
    35,~                     and add 35 to the right (charcode of '#')
[:,                      Ravel the result

Both use the "+ trick to avoid numeric literal problem.

Answer 70

Whitespace, 82 bytes

[N
S S N
_Create_Label_OUTER_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][N
S S S N
_Create_Label_INNER_LOOP][S N
S _Duplicate][N
T   S T N
_If_0_Jump_to_Label_HASTAG][S S S T N
_Push_1][T  S S T   _Subtract][S S S T  T   T   S T T   N
_Push_59_;][T   N
S S _Print_as_character][N
S N
S N
_Jump_to_Label_INNER_LOOP][N
S S T   N
_Create_Label_HASHTAG][S S S T  S S S T T   N
_Push_35_#][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_OUTER_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Start OUTER_LOOP:
  Integer c = read character from STDIN
  Start INNER_LOOP:
    If(c == 0):
      Jump to function HASHTAG
    c = c - 1
    Print ";" to STDOUT
    Go to next iteration of INNER_LOOP

function HASHTAG:
  Print "#" to STDOUT
  Go to next iteration of OUTER_LOOP

Note: All characters read from STDIN in Whitespace are automatically stored in the heap as their code-point values.

Answer 71

Brain-Flak, 94 bytes

{{({}[()])<>((((((()()()){})){}{}())()){}{})<>}{}<>(((((()()()){}())){}){}{})<>}<>{({}<>)<>}<>

Try it online!

Answer 72

Backhand, 27 bytes

}o" i# :" }]@_!}|{:" [; o".

Try it online!

I'm sure a shorter solution exists, given this has 6 no-ops. This prints a null byte to begin with

Explanation:

}o       Print a null byte
    i  :  }]  ! |{     Get a character of input and check if it is EOF
                   "  ; o"   If it is not, print a ;
               }| :  [       Decrement the counter and check again
                   Once the counter hits zero exit the loop
            @_    If the value was -1 (EOF) exit
           ]  !   Otherwise execute some garbage
 o" i#  "         Print a # and get the next character of input

Answer 73

W j d, 7 bytes

The input format is [['a','b',..]]

◘Pp½h#û

Explanation

Uncompressed:

C';*'#+M

       M % For every item in the input:
C        % Convert to a character
 ';*     % Repeat ; ASCII codepoint times
    '#+  % Append a #

Flag:j   % Join without newline
```

Answer 74

GolfScript, 10 bytes

{";"*"#"}%

Try it online!

Answer 75

Burlesque, 13 bytes

m{'#j**';j.*}

Try it online!

m{      # For each char in string (implicit concat)
  '#    # Push #
  j**   # Find ord(char)
  ';j.* # That many ;
 }

Answer 76

C, 51 bytes

c;main(){for(;c||~(c=getchar());puts("#;"+!!--c));}

Outputs lots of extra newlines, and an extra ; at the end, but neither of those affect the output of the ;# program, so it should be fine.

Using puts was suggested by ais523 in a comment: Make a ;# transpiler.

~(x) is a shorter way to write (x)!=-1.

"#;"+!!--c is a pointer arithmetic equivalent of --c?";":"#;".