[Question]
  [
Related to: [Make a ;# interpreter](https://codegolf.stackexchange.com/q/121921/68910)
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]
# [;#+](https://github.com/ConorOBrien-Foxx/shp), 61 bytes
*[Outgolfed](https://codegolf.stackexchange.com/a/122210/64121) by Conor O'Brien*
```
;;;;;;;(~;;;;;~-;-)~>:~;;;;(~;;;;;;~-;-)~>~-*((;~<#~):<#-:-*)
```
[Try it online!](https://tio.run/nexus/shp#@28NARp1YKpO11pXs87Oqg5JDCZYp6uloWFdZ6Ncp2llo6xrpaul@f@/R2pOTr5CeH5RTooiAwA ";#+ – TIO Nexus")
Note that the input has a trailing null byte.
[Answer]
# [;#+](https://github.com/ConorOBrien-Foxx/shp), 40 bytes
```
;;;;;~+++++++>~;~++++:>*(-(;~<#~):<#-*:)
```
[Try it online!](https://tio.run/nexus/shp#@28NAnXaEGBXB2Fa2Wlp6GpY19ko12la2Sjrallp/v/vkZqTk68Qnl@Uk6LIAAA ";#+ – TIO Nexus") 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]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ ~~8~~ 7 bytes
```
O”;ẋp”#
```
[Try it online!](https://tio.run/nexus/jelly#@@//qGGu9cNd3QVAWvn///8eqTk5@QA "Jelly – TIO Nexus")
```
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]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~59~~ ~~54~~ 33 bytes
-21 bytes with [KSab](https://codegolf.stackexchange.com/users/15858/ksab)'s [bfbrute](https://github.com/ksabry/bfbrute) tool.
```
+[>[+<<]>>>+>++>--<],[[>.<-]<.>,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO9ouWtvGJtbOzk7bTlvbTlfXJlYnOtpOz0Y31kbPTif2/3@P1JycfIXw/KKcFEUA "brainfuck – Try It Online")
[Answer]
# [GS2](https://github.com/nooodl/gs2), 6 bytes
```
■•;2•#
```
[Try it online!](https://tio.run/nexus/gs2#@/9o2oJHDYusjYCE8v//Hqk5Ofk6CuH5RTkpigA "GS2 – TIO Nexus")
### 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]
# 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!](https://tio.run/nexus/taxi#rZJLa8MwEIT/yuAcehP0cUqOLeTYQFoKNT6oytoWVbVCkjH99a5fSY2TulB6kISk3ZnRh5otIzJ2HCIe81wrWte4hmmH71ax0@q9cpBwMgSyBXkUrG3Rdd2X7LCv6FMMKqf92h77cTfqpCrb1zqqsit0RloklEDnsAy2BB1QSx1b5V8spX9jbbD12piT7/SwNze4Hcai2lNJeLYH8oXnyh5GuRevI/mrgAdyHHseXqQu20xCQsZZ3aLRhK84Jz7QuhlJDfezaN9ExRyj/QPGyw9/Zf7op9atw9cm@gHJWQiXiNRmq2VCF7WOVuafAS59xnl61aanrGk2qy8)
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]
# 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]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
Ç';×'#«J
```
[Try it online!](https://tio.run/nexus/05ab1e#@3@4Xd368HR15UOrvf7/90jNycnXUQjPL8pJUQQA "05AB1E – TIO Nexus")
**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]
# [Python 3](https://docs.python.org/3/), 39 bytes
```
[print(";"*ord(s)+"#")for s in input()]
```
[Try it online!](https://tio.run/nexus/python3#@x9dUJSZV6KhZK2klV@UolGsqa2krKSZll@kUKyQmQdEBaUlGpqx//97pObk5OsohOcX5aQoAgA "Python 3 – TIO Nexus")
[Answer]
## [><>](https://esolangs.org/wiki/Fish), 22 bytes
```
i:0(?;\"#"o
o1-:?!\";"
```
[Try it online](https://tio.run/nexus/fish#@59pZaBhbx2jpKyUz5VvqGtlrxijZK30/39aZnEGAA "><> – TIO Nexus"), or at the [fish playground](https://fishlanguage.com/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]
# F#, 79 bytes
```
let c i=System.String.Join("#",Seq.map(fun c->String.replicate(int c)";")i)+"#"
```
[Try it online!](https://tio.run/##ZcuxCsIwEIDh3aeIV4QE27xAsVBdxDWDc4kXOUgvMYmD4LvHDC7i@v98Lg9r4FCrxyKsoIN55YKrNiUR3/UlEEvooDf40OsSpXuysMP03QmjJ7sUlMSNKxhBkdo3UK2AM3ofenENyd@28J5iM8Ux7DJs2p6Pp/84dr@tfgA "F# (Mono) – 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]
# Python 2 - 36 bytes
```
for i in input():print';'*ord(i)+'#'
```
**[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFTITMPiApKSzQ0rQqKMvNK1K3VtfKLUjQyNbXVldX//1f3SM3JyddRCM8vyklRBwA)**
[Answer]
# 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]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 47 bytes
```
+++++++[->++++++++>+++++<<]>+++<,[[>.<-]>>.<<,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwKide2gLG0Iw8YmFsSw0YmOttOz0Y21A5I2OrH//3uk5uTk6yiE5xflpCgCAA "brainfuck – Try It Online")
See also: [ovs's answer](https://codegolf.stackexchange.com/a/122169/66421), 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]
## Mathematica, 49 bytes
```
StringRepeat[";",#]<>"#"&/@ToCharacterCode@#<>""&
```
## Explanation
[![enter image description here](https://i.stack.imgur.com/Ibq6V.png)](https://i.stack.imgur.com/Ibq6V.png)
Converts the input string to a list of character codes, then `Map`s the function `StringRepeat[";",#]<>"#"&` over the list, then `StringJoin`s the result with the empty string.
[Answer]
# JavaScript, ~~55~~ ~~54~~ ~~51~~ ~~50~~ 48 bytes
```
s=>1+[...s].map(c=>";".repeat(Buffer(c)[0])+"#")
```
[Try it online](https://tio.run/##BcHBDoIwDADQX9FyaQM2ejbjwIk/4EB2WEZnNJUuG/r7471P@Icayzsft902acm16sZHvzJz9fwNGaMb4QlcJEs4cPqlJAUjrXdPPXRALdpeTYXVXpgQZlG14bJY0e0KRO0E)
* 1 byte saved thanks to [Neil](https://codegolf.stackexchange.com/users/17602/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]
# [Aceto](https://github.com/aceto/aceto), 19 bytes
Since there's an [interpreter in Aceto](https://codegolf.stackexchange.com/a/121990/21173), 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), `p`rint the result, push a literal (`'`) `#`, `p`rint it too, and go back to the `O`rigin.
Run with `-F` if you want to see immediate results (because buffering), but it works without, too.
[Answer]
# Perl, 24 bytes
```
s/./";"x(ord$&)."#"/ges
```
Run with `perl -pe`.
Alternative solution:
```
say";"x ord,"#"for/./gs
```
Run with `perl -nE`.
[Answer]
# [Solace](https://github.com/splcurran/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]
# [Fourier](http://github.com/beta-decay/Fourier), 19 bytes
```
$(I(`;`&j)`#`0~j&i)
```
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=JChJKGA7YCZqKWAjYDB-aiZpKQ)
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]
# R, ~~59~~ 56 bytes
```
for(x in utf8ToInt(scan(,'')))cat(rep(';',x),'#',sep="")
```
[Try it online!](https://tio.run/##K/r/Py2/SKNCITNPobQkzSIk3zOvRKM4OTFPQ0ddXVNTMzmxRKMotUBD3Vpdp0JTR11ZXac4tcBWSUnzv7XyfwA "R – Try It Online")
[Answer]
# [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), ~~23~~ ~~17~~ 10 bytes
-5 bytes thanks to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king).
```
"#@~k:*k,;
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X0nZoS7bSitbx/r/f4/UnJx8HYXw/KKcFEUA "Befunge-98 (FBBI) – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 11 bytes
```
O⌠';*'#o⌡MΣ
```
[Try it online!](https://tio.run/nexus/actually#@@//qGeBurWWunL@o56FvucW//@v5JGak5OvoxCeX5SToqgEAA "Actually – TIO Nexus")
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]
# [APL (Dyalog)](https://www.dyalog.com/), 18 bytes
```
'#',¨⍨';'⍴¨⍨⎕UCS
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v@RR2wR1ZXWdQyse9a5Qt1Z/1LsFzHzUNzXUORgor6DukZqTk6@jEJ5flJOiqM6lrs4FFHR0coYxrZXVAQ "APL (Dyalog Unicode) – Try It Online")
`⎕UCS` Convert to Unicode code points
`';'⍴¨⍨` use each code point to reshape (*⍴* = *Rho* ≈ *R*; *R*eshape) a semicolon
`#',¨⍨` append a hash to each string
[Answer]
# 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]
# PHP, 54 Bytes
```
for(;$o=ord($argn[$i++]);)echo str_repeat(";",$o)."#";
```
[Try it online!](https://tio.run/nexus/php#s7EvyCjgUkksSs@zVfJIzcnJ11EIzy/KSVFUsv6fll@kYa2Sb5tflKIBVhKtkqmtHatprZmanJGvUFxSFF@UWpCaWKKhZK2ko5KvqaekDNT2HwA "PHP – TIO Nexus")
[Answer]
## [Alice](https://github.com/m-ender/alice), 12 bytes
```
'#I.h%&';d&O
```
[Try it online!](https://tio.run/nexus/alice#@6@u7KmXoaqmbp2i5v//v0dqTk6@jkJ4flFOiiIA "Alice – TIO Nexus")
### 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]
# PHP, 48 bytes
```
for(;$c?:~$c=~ord($argn[$i++]);)echo";#"[!++$c];
```
[Answer]
# 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](https://jqplay.org/s/azUJuDB8td)
[Answer]
# Pyth, 10 bytes
```
sm_+\#*\;C
```
[Try it!](https://pyth.herokuapp.com/?code=sm_%2B%5C%23%2a%5C%3BC&input=%22ABC%22&debug=0)
]