text:
Generate ;# code
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="
"+e.body.replace(OVERRIDE_REG,"")+"
")});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;/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}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Brilliant! Glad to see ;# is getting attention!

You can test your output here, as ;#+ is a superset of ;#.

@Adám I'll be damned, it's already on TIO

Can the output contain additional character? ;# ignores all other characters, so the generated program would still work.

@Dennis Yes it can

When the input contains a newline, do you need the output to contain 13 ; and a #?

@Chowlett Well, depends on what newline sequence was used in the input. \n should be 10 ; and \r should be 13 ;.

Uh, yes. I meant 10. <.<;

None of the answers implement the modulus you've aksed (and I think you meant % 128).

@Benoît: The modulus is irrelevant when generating code, since it's always easier to generate code that uses the minimum number of ;. Secondly, 127 is correct, as stated in the linked question that contains the specification of the ;# language.

Can you edit the fact that the output may contain additional characters other than ; and # into the question, please? A few people, myself included, may be able to save some bytes with that knowledge.

@Shaggy: But that is part of the question; you're supposed to output valid ;# code and in ;# code anything except ; or # is simply ignored. Thus you can have other characters in it, as they don't change the validity of the ;# program.

@Joey, the fact that "all other characters are ignored" is mentioned in the intro doesn't necessarily explicitly permit any other characters in the output.

This isn't really transpiling. "Generate #; code" is a better title. I'm going to change it to that.

Can we take input as an array of individual characters?

@Shaggy Sorry for the (very) late answer. The input should be taken as a string, I will clarify this.

May we include a trailing ;;;;;;;;;;# in the output?

@Shaggy This challenge is so old, it's hard to reinterpret the rules... but I'd say no, because that would generate trailing spaces in the program's output. So unless your input contains a trailing space, the output of your generated program shouldn't either.

That's OK, I was expecting that answer. It'd be a trailing newline, though, not a trailing space.

;#+, 61 bytes
Outgolfed by Conor O'Brien
;;;;;;;(~;;;;;~-;-)~>:~;;;;(~;;;;;;~-;-)~>~-*((;~<#~):<#-:-*)

Try it online!
Note that the input has a trailing null byte.

Points for style.

I approve of this answer :D definitely the right language for the job

;#+, 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

All this from a joke language I made when I was bored. I'm flattered.

@RandomUser :D it's a fun concept to play around with

huh. What if I want the program to print out a null byte in ;#?

# @tuskiomi. Try it online!

@ConorO'Brien how would I input that into your program?

@tuskiomi With this program, you can't It is not needed, however, since we are guaranteed that "It will only contain printable ASCII characters and newlines."

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

Could you do O”;ẋ;€”# instead?

@Emigna Ah, yes, thanks. I don't quite get how that works but I kind of understand it. Thanks!

;€ can become p.

@Dennis Oh now I understand how that works. Thanks! :)

brainfuck, 59 54 33 bytes
-21 bytes with KSab's bfbrute tool.
+[>[+<<]>>>+>++>--<],[[>.<-]<.>,]

Try it online!

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 '#'.

■ = what the heck?

2 is the multiplication command? GS2 is weird :P

@EriktheOutgolfer executes the code for each of the input's character's code point o_O

@EriktheOutgolfer That sounds fancier than it is. ■ is just map, and GS2 implements strings as lists of integers.

@ETHproductions GS2 isn't character-based; it interprets the source code as a raw byte stream, and there's usually no connection between the instruction and the CP-437 character the byte encodes. In x86_64 byte code, 2 is XOR...

Considering that the program is usually non-printing, wouldn't it be easier to just paste a hexdump? ■ seems to be 0xFE and • seems to be 0x7 (in CP437), but took me a while to figure that out.

@Joey Added a hexdump. Unfortunately, the interpreter on TIO (only) takes CP-437 encoded source code, for reasons I no longer remember. Hexdumps would have indeed been a better choice.

@Dennis Ooh so GS2's strings are like GolfScript's (where to get a char at a specific index you do 1/= and even \1/= sometimes) in a sense.

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.

+1 I just love languages such as this and Mornington Crescent, the code is just so beautiful!

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

That's impressively small for Brainf*ck.

almost competes with the python answer. Impressive.

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

-1 without Ç by taking input as a list of codepoints.

Python 3, 39 bytes
[print(";"*ord(s)+"#")for s in input()]

Try it online!

for s in input():print(";"*ord(s)+"#") is one byte shorter.

@ovs that moment when you assume a list comprehension is shorter.

That doesn't accept a string with a newline does it?

><>, 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.

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"

We need more F# answer

@aloisdg I'll do my best :)

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.

It need to join result strings.

@mazzy: From the task description: »As long as the program is valid, it may contain excess characters other than # and ; as all other characters are ignored.«

as you wish :-)

quotation marks can be removed. $args is enough.

Unless the argument is numeric.

?! rule: The input is a string.... But as you wish ;-)

Ah, good point.

Python 2 - 36 bytes
for i in input():print';'*ord(i)+'#'

Try it online!

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])+"#")

\n should becomes ;;;;;;;;;;#.

Hmm ... that's strange. Guess I'll have to roll back to the longer solution, so. Thank, @Neil.

I think you could change . to [^], which would still leave it a byte shorter than map/join?

Yup, that did the job, @Neil :)

Just a heads up, the join() in your previous answer was unnecessary given the specification for ;#, and you can also declare that the input for your function is an array of characters, though the second suggestion is a bit of a stretch. Either way, that brings you down to at most 48 bytes.

Doesn't it have to be a full function declaration like f=x=>x**x?

@Ausername, no, if the function isn't recursive then we do not count the variable assignment (e.g., f=) in our byte count.

@Shaggy Ok, thanks for that! I have some answers to shorten...

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

-2 Bytes Only -1 if you’re avoiding negative cells

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.

Why do you need the <>""?

@CalculatorFeline Without it I would be left with a list of strings for each character. StringJoining (<>) the empty string concatenates each string.

Forgot about that :P

Befunge-98 (FBBI), 23 17 10 bytes
-5 bytes thanks to Jo King.
"#@~k:*k,;

Try it online!

@JoKing Thanks a lot. I was able to golf two bytes more off. This now on par with Pyth, Husk and CJam!

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.

Perl, 24 bytes
s/./";"x(ord$&)."#"/ges

Run with perl -pe.
Alternative solution:
say";"x ord,"#"for/./gs

Run with perl -nE.

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

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.

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

Try it online!

After 3 years, I've finally managed to find a shorter approach...

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

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

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.

You could avoid the use of .ord by working directly with character codes: $_.bytes{|b|$><<?;*b+?#}. There is difference: this one also encodes the newline in the input. Not sure what the question owner intends to say by “It will only contain printable ASCII characters and newlines.”, but to me sounds like newlines should be encoded too.

Your Ruby-fu exceeds mine, @manatwork - I'd forgotten about bytes. I've asked OP about newlines up top and will edit this afterwards.

Pyth, 10 bytes
sm_+\#*\;C

Try it!

Röda, 24 bytes
{chars|[";"*ord(_),"#"]}

Try it online!

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

Try it online!

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.

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

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

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.

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

Brain-Flak, 94 bytes
{{({}[()])<>((((((()()()){})){}{}())()){}{})<>}{}<>(((((()()()){}())){}){}{})<>}<>{({}<>)<>}<>

Try it online!

R, 48 bytes
cat(strrep(';',utf8ToInt(scan(,''))),'',sep='#')

Try it online!
Outputs 'pure' ;# code with no other characters.

R, 43 bytes
paste(strrep(';',utf8ToInt(scan(,''))),'#')

Try it online!
Outputs 'dirty' ;# code with various other characters ([,],0-9, ,") that are all ignored.

Rockstar, 216 201 191 175 bytes
This started out a lot shorter until I remembered that we had to handle line breaks in the input - each line in Rockstar is a separate input - and then discovered, in what I can only assume to be a bug, that the space character passes equality tests with the empty string \t, \n & 0.
listen to S
O's""
while S
X's0
while S at X
Y's31
C's-1
until C is S at X
build Y up
cast Y into C

let O be+";"*Y+"#"
build X up

listen to S
if S
let O be+";"*10+"#"

say O

Try it here (Code will need to be pasted in)
This 151 byte version includes a newline after each #, which, although being valid in ;# as they're simply ignored, would fail when passed back to my Rockstar interpreter.
listen to S
while S
X's0
while S at X
Y's31
C's-1
until C is S at X
build Y up
cast Y into C

say ";"*Y+"#"
build X up

listen to S
if S
say ";"*10+"#"

A0A0, 103 057 102 945 bytes
https://gist.github.com/stefvanschie/a32e23f45553fc19b79b9cb7159c7e04
(I think putting that many characters into a codebox here is a bit too much.)
Yes, I'm serious. A0A0 has loops, but this solution would require nested loops (a loop for reading a character and within that a loop for printing the right amount of semicolons). I'm not even certain if nested loops are possible at all. I have a solution that can display the correct code for a single character, since that doesn't require any nested loops in only 143 bytes. If anyone knows how to do this, please let me know. The code for a single character is also on the gist.
The reason this is still possible is by using a dirty work-around: write code for every single character, then jump to that spot for the right character. Since there are only a finite amount of printable ASCII characters and you can't go above character 126 because of the modulo 127, this is possible. This is where the byte count comes from. I generated almost 600 lines of code that does exactly that.
The important part is at the top
A0A0
A0C3G1G1G1G1A0
A0I1D8M5V0G0A0
A0A1G-3G-3G-3G-3A0
G-3

Most of this serves as an infinite loop, but the code in between A0 on the third line is actual important code.
I1D8M5V0G0
I1         ; reads a character and stores it on the next operand as its ascii value
  D8       ; subtracts 8 from the operand
    M5     ; multiply the operand by 5
      V0   ; the operand, value is put on the next instruction
        G0 ; set by the operand, jumps this amount of lines down

On every correct line you can find a loop with the right amount of prints for each semicolon P59 and hash tag P35, as well as another jump to jump back to this input loop.
Rev: Improved positioning of the character prints

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

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

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

just prints ;s and then a #

You can compact it: -join($args|% t*y|%{';'*$_+'#'}) 32 bytes ))

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.

How do you run this? I'm trying to execute this and it doesn't terminate. Is it not supposed to?

@PatrickRoberts It's waiting for input. See the getchar()?

Yes, but after I provide input, it prints, and still doesn't terminate. That's what I mean.

@PatrickRoberts It terminates upon EOF.

Ah, got it. I had to use echo 'Hello, World!' | ./test rather than typing it during execution.

@PatrickRoberts You can type it during execution, just hit Ctrl+D at the end (assuming you're on Linux).

shortC, 27 bytes
c;AO;~(c=G);J"#"))Wc--)J";"

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.

I have had a crack at remove some of the no-ops in your code.  I managed to trim of a few bytes for i.#';UoU^!.$U@?(';o.  It gets a bit messy in there, but it works

I must admit, I'm impressed! I'll have to take these ideas into consideration for future cubix submissions.

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

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

Ly, 18 bytes
&ir[[";"o1-]"#"op]

Try it online!

Unfortunately your language seems to be newer than the challenge post. You should mark it as "non competing". Great answer though!

@kalsowerus I believe we have a consensus against this.

@LirycLy Oh, I must have missed that. Thanks for the update.

Braingolf, 11 bytes
&([#;]##)&@

Try it online!
Ooh, moderately golfy

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

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.

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

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 "#"

Add++, 18 bytes
L^,€O59C€*"#"€Ω+BF

Try it online!

Stax, 7 6 bytes
ç`5≡Tf

Run and debug it

Vyxal Ks, 8 7 6 bytes
-1 -2 thanks to Aaron Miller
\;*\#+

Try it Online!
\;*\#+    # Full program
          # Vectorized: Replace each...
          # (K flag) ordinal character in (implicit) input...
\;        # with the character `;`...
  *       # repeated that many times, and...
   \#+    # add the character `#`
          # (s flag) Concatenate results and output

7 bytes

6 bytes because vectorising

Excel, 56 bytes
=CONCAT(REPT(";",CODE(MID(A1,SEQUENCE(LEN(A1)),1)))&"#")

Could be 8 bytes shorter to output an array of cells ending with #.
VBA (immediate window), 73 bytes
d="":for i=1to len([a1]):d=d &string(asc(mid([a1],i,1)),";") &"#":next:?d

You can get the VBA version down to 70 bytes as d="":for i=1to[len(a1)]:d=d+string(asc(mid([a1],i,1)),";")+"#":next:?d

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

You could probably write >-1 rather than !=-1 to save a byte. Also, printf is shorter than putchar (and puts would be shorter still; you'd put a lot of stray newlines in the output, but those are specified as ignored).

Why community wiki?

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!

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

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.

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!"));
    }
}

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
    }
}

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 '#'

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!

Python 3, 51 bytes
[print(''.join((';'*ord(i)+'#')for i in input()))]

Try it online!

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$

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

Try it online!

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)
     ;     ";"

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

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.

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.

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
}

Ahead, 13 bytes
~W$:ki@j";#"~

Try it online!

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

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.

You do not need to declare and use an additional integer variable. You can re‑use your char variable: var c:char;begin repeat read(c);for c:=^Ato c do write(';');write('#')until eof end.

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

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('#'));}

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

37 bytes

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.

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.

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

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
```

GolfScript, 10 bytes
{";"*"#"}%

Try it online!

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 ;
 }

Raku, 44 bytes
say $*IN.slurp.ords.map(';'x*).join('#'),'#'

Try it online!

AWK, 52 49 + 8 = 57 bytes
-lordchr command-line parameter to import the ORDCHR extension.
BEGIN{RS=".|"}{for(;i++<ord(RT);)s=s";"}i=$0=s"#"

Try it online!
This code roams the input one character at a time, and prints as many ; as needed, and a # between characters. To print everything in one line, just put ORS="" inside the brackets of the BEGIN pattern.

Lua, 57 bytes
(...):gsub('.',load'print((";"):rep((...):byte()).."#")')

Try it online!
Essentially grabs the byte value of each character and repeats ; that many times, followed by a # and a newline.

Thunno 2 J, 7 bytes
C';×'#+

Attempt This Online!
Explanation
C';×'#+  # Implicit input
C        # Cast to ordinals
 ';×     # Repeat ";" that many times
    '#+  # Append "#" to each
         # Implicit output, joined

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?";":"#;".

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Golf you an anagram for great good!
The Task
In this challenge, your task is to write some code which outputs one of its anagrams chosen randomly with uniform distribution but it should never output itself.

Elaboration
Given no input, your program should output any one of the anagrams of its source code. Your program should never output its own source as it is, i.e. it should never be a quine.

Input
Your program must not take any input. However, if your language requires input as a necessity, you may assume that it will be given lowercase a. You must not use the input in any way, though.

Output
Your program can output in any way except writing it to a variable. Writing to file, console, screen, etc. is allowed. Function return is allowed as well.

Additional Rules

Your program's source code must have at least 3 chars (not 3 bytes).

Your program's source code must have at least 3 possible anagrams (excluding itself). For example, aab does not count as a valid submission as aab only has two anagrams other than aab (baa and aba).

Your program must not produce any error.

Your program should output its anagrams exactly.

Standard Loopholes and Standard quine rules apply.

Example
Suppose your program's source code is abc. It should randomly output any one of the following (with uniform distribution):

acb
bca
bac
cba
cab

And, it should never output abc.

Winning Criterion
This is code-golf, so the shortest code in bytes wins! In case of a tie, the solution which was posted earlier wins!

Related.

Does it need to guarantee that it behaviors correctly, or just with probability 1?

@PyRulez In this challenge, your task is to write some code which outputs one of its anagram chosen randomly with uniform distribution... (First sentence (below The Task))

@Arjun so is a 0% chance of failure fine?

@PyRulez Failure? The code is supposed to output one of it's anagram (except itself) chosen randomly with equal chances of any of its anagram being outputted. I don't know what you mean with "Failure".

@Arjun going into an infinite loop, for example. The top answer has a 0% of never outputting anything.

@PyRulez 0% chance of failure is not only fine but necessary!

@Arjun okay, because there are two types of 0% probability events: ones that never occur and those that almost never occur.

Jelly, 15 bytes
“v0¡µṾ;ḢŒ!QḊX”v

Just to get things started; this is almost certainly beatable. This is basically just a combination of a universal quine constructor and a "pick a random permutation other than the input" function; the latter may be improvable, the former almost certainly is.
Explanation
Universal quine constructor
“v0¡µṾ;Ḣ”v
“       ”v   Evaluate the following, given {itself} as argument:
 v0¡µ          No-op (which starts with "v")
     Ṿ         Escape string
      ;Ḣ       Append first character of {the argument}

This can be seen to be a quine if run by itself. It's also a proper quine by most definitions I know of; it doesn't read its own source (rather, it contains a literal that's "eval"ed, and is given a copy of itself as an argument), it can carry a payload (as seen here!), and the v outside the string literal is encoded by the v inside.
Pick a random anagram
Œ!QḊX
Œ!     All permutations
  Q    Discard duplicates
   Ḋ   Discard the first (i.e. the string itself)
    X  Choose random element

This is really inefficient on a string this long, so I haven't been able to test the program as a whole, but I've tested it on shorter strings and it appears to function correctly.

Why doesn't thins work on TIO?

@Mr.Xcoder It probably bypasses the 60s time limit.

Oh, yes, you are right.

While you have it in your byte count your code misses the necessary Q. However I think you can change this "all permutations" method with a "shuffle" one using Ẋ⁼¿, saving a byte while also allowing it to work on TIO.

Python 2, 117 bytes
Surprisingly this solution is shorter than I expected. Shuffles source code, until it differs from the original.
-2 bytes, thanks to @mbomb007
-3 bytes, thanks to @Wondercricket
Try it online
s=r"""from random import*;R='s=r\"""'+s+'\"""'+';exec s';L=R
while L==R:L=''.join(sample(R,len(R)))
print L""";exec s

This is one of the basic quines in python, that I've modified
s = r"print 's = r\"' + s + '\"' + '\nexec(s)'"
exec(s)

Generating anagram is done by random module
L=R
while L==R:L=''.join(sample(L,len(L)))

Where R contains sourcecode
s=...
R='s=r\"""'+s+'\"""'+'\nexec s'

Triple quotes were needed as I was forced to keep actual lineseparators in code. Anagrams will have 3 lines anyway.

exec s instead of exec(s)

Since a str is immutable, you can save a bytes by doing L=R and using sample on L rather than using  shuffle on the list. repl.it. The idea is taken from this Stackoverflow

@Wondercricket Sample returns list of characters, so comparing it's results with R will always returns False. But some rearranging helps, thank s for the idea!

CJam, 17 bytes
{`"_~"+m!(a-mR}_~

This isn't going to finish any time soon, so no TIO link this time.
As a consolation, here is a 20 byte solution that does terminate very quickly:
{`"_~"+:S{mr_S=}h}_~

Try it online!
Explanation
{`"_~"+   e# Standard quine framework, leaves a string equal to the source
          e# code on the stack.
  m!      e# Get all permutations. The first one will always be the original order.
  (a      e# Remove that copy of the source code and wrap it in a new list.
  -       e# Remove all copies of the source code from the list of permutations.
  mR      e# Pick a random permutation.
}_~

The 20 byte solution instead shuffles the source code until its different from the original.

Java 7, 376 428 426 428 bytes
import java.util.*;class M{public static void main(String[]a){String s="import java.util.*;class M{public static void main(String[]a){String s=%c%s%1$c,x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(%1$c%1$c));x.equals(s);s=s.join(%1$c%1$c,l))Collections.shuffle(l);System.out.print(s);}}",x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(""));x.equals(s);s=s.join("",l))Collections.shuffle(l);System.out.print(s);}}

+52 and +2 bytes for two bug-fixes.. I wasn't checking (correctly) if the randomly generating String was equal to the original source-code. The chances of this are astronomical small considering the amount of characters involved, but I have to validate it regardless to comply to the challenge rules.
My first quine answer in Java..
Try it here.
You can remove both Collections.shuffle(l) and add ! in front of both the x.equals(s) to verify that the output indeed equals the program:
Try it here.
Explanation:

The String s contains the unformatted source code.
%s is used to input this String into itself with the s.format(...).
%c, %1$c and the 34 are used to format the double-quotes.
s.format(s,34,s) puts it all together

And this part of the code is responsible for outputting a random anagram:
// Strings `s` and `x` now both contain the source-code:
x=s=s.format(s,34,s);

// Create a list with the characters of this source-code-String and loop
for(List l=Arrays.asList(x.split(""));
    // as long as String `x` equals String `s`
    x.equals(s);
    // Shuffle the list, and set it to `s` in every iteration of the loop:
    s=s.join("",l))Collections.shuffle(l);
// End of loop (implicit / single-line body)

// And then print the random anagram to STDOUT:
System.out.print(x);

Vyxal D, 14 bytes
`q‛:Ė+:Ṗ$o℅`:Ė

Try it Online!
For a version that doesn't require ~1.2TB of RAM:
Vyxal D, 16 bytes
`q‛:Ė+D{|Þ℅~=`:Ė

Try it Online!
Both of these use a fairly generic quine structure combined with some "generate some permutation other than the input" code.
Generic quine structure
`        `:Ė # Evaluate the previous code on itself
 q.          # Uneval
     +       # Append
  ‛:Ė        # ":Ė"
      ...    # Apply some transformation

 Ṗ    # Get all permutations of the input
: $o  # Remove the original string
    ℅ # Choose a random element

 {      # While
D |  ~= # The current string equals the input
   Þ℅   # Shuffle it

Javascript (ES6), 128 bytes
!function a(){b="!"+a+"()",c=b.split(""),c.sort(()=>Math.round(Math.random())-.5),c!=b.split("")?console.log(c.join("")):a()}();

Uses sort() returning random -1,0, or 1 to shuffle the output.

05AB1E, 22 bytes
"34çìDJœ¦.R"34çìDJœ¦.R

This creates a list that is too big for TIO, so the link uses a smaller string, but the idea is the same.
Try it online!
"34çìDJœ¦.R"           # Push this string
            34ç        # Push "
               ì       # Prepend
                DJ     # Duplicate and join
                  œ¦   # Push all permutations except the original
                    .R # Pick a random element

PowerShell Core, 72 bytes
&($f={for(;$r-eq$o){$r=-join(($o="&(`$f={$f})")|% t*y|Random -c 72)}$r})

Try it online!
This is a variation of the quine &($f={"&(`$f={$f})"})
&($f={for(;$r-eq$o){$r=-join(($o="&(`$f={$f})")|% t*y|Random -c 72)}$r})
                             ($o="&(`$f={$f})")                          # Stores the original quine in $o
                    $r=-join(                  |% t*y|Random -c 72)      # Shuffles the characters and store it in $r
      for(;$r-eq$o){                                               }$r   # Exit the while loop and print when the shuffled quine is not the same as the origin quine
&($f={                                                                }) # Quine structure, to create a function and run it automatically

A 74 bytes recursive approach

Bash, 27 96 bytes
i=`cat $0`&&e=`fold -w1 $0|shuf|tr -d '\n'`&&while [ "$e" = "$i" ]; do `$0`; exit; done&&echo $e

fold divides the code in lines, shuf shuffles the lines, and tr put the code back together
fixed the issue of it outputing itself, now it will never output itself
Try it Online!

Does it have chance to output the code itself, without changes?

It also seems to only shuffle the lines, so not all permutations are possible, in particular since the program only has a single line...

All permutations are possible, test it. I am fixing the problem of it maybe ouputing itself

That $0 looks like a violation of “Your program must not take any input.”

I'm pretty sure that's just the filename. Therefore, even if it wasn't input, this is a cheating quine :(

Does $0 count as an input? the user never input anything, as @CalculatorFeline says it is the filename which can be anithing, and wont affect the result or show in it. Why it is a cheating quine?

@DrnglVrgs, that is how the code that reads its own sourse is called according to Wikipedia. We had such challenge too and we enjoyed it. But here the requirement not seems to ask for cheating quine.

One trick to shorten it anyway: cat $0 → <$0.

Thank you @manatwork you are right, I had not read the part of the quine rules that says that it must not acess it own code

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Help Jarl Olaf in his raids
Jarl Olaf lives in a beautiful village, Stackholm. In every year he is thinking about raiding a place to get some golden jewelery, food and programmers woman slaves.
He is a good person but not the brightest one, so you need to help him decide the next target. He has three targets in his mind: Jarl Burg, England and Paris.
Jarl Burg is the closest, he lives In Norway, Olaf can sail there all year.
England is a longer journey, it will took him 2 months, but he wants to settle down a bit, so he must start his journey three month before winter and he also won't start it in winter.
Paris is far-far away, to sail there will took 3 months, need more man, more time to settle down, so 5 months before winter they need to be on the sea, but won't start in winter.
Challenge
Your task is to get the starting month as an input (string or number you decide) and decide where to sail. If more possible targets crossing each other then decide randomly where to go.
Your output will be the army of the ships. (3-6-9 ships)
Help
Olaf need only 3 ships to Jarl Burg, 6 to England and 9 to Paris.
1 ship is 2 tab long, the arragement of the ships are provided in the test cases for all three possibilities.
The second ships starts where the first ends, the third one start in the middle of the first and there is a new line between the second and the third ships.
The direction of the oars are significant.
Winter month are January (1), February (2), December (12).
Test cases
Input:
6
Output:
  / / /                           / / /
<■■■■■■»                        <■■■■■■»
  \ \ \                           \ \ \
          / / /                           / / /
        <■■■■■■»                        <■■■■■■»
          \ \ \                           \ \ \
                  / / /
     \ \ \      <■■■■■■»             \ \ \
    <■■■■■■»      \ \ \             <■■■■■■»
     / / /                / / /      / / /
                        <■■■■■■»
                          \ \ \

                     \ \ \
                    <■■■■■■»
                     / / /

Input:
December
Output:
  / / /
<■■■■■■»
  \ \ \
          / / /
        <■■■■■■»
          \ \ \

     \ \ \
    <■■■■■■»
     / / /

Input:
8
Output:
  / / /
<■■■■■■»
  \ \ \
          / / /
        <■■■■■■»
          \ \ \
                  / / /
     \ \ \      <■■■■■■»
    <■■■■■■»      \ \ \
     / / /                / / /
                        <■■■■■■»
                          \ \ \

                     \ \ \
                    <■■■■■■»
                     / / /

This is code-golf challenge, so the answer with the fewest bytes wins.

How do we determine how many ships to output? Is the direction of the oars significant? What months are considered winter? Is the placement of the ships significant?

I just edit my question to answer you.

Do we need to handle the input month as a number and as text, or can we choose one?

The input type is in the question, but it can be both number and text.

Can you just provide us with each month's output numbers, or possible output numbers?


text:
Sum my Fibonaccified divisors!
The famous Fibonacci sequence is F(0) = 0; F(1) = 1; F(N+1) = F(N) + F(N-1) (for this challenge we are beginning with 0).
Your challenge: Given n, output the sum of all the dth Fibonacci numbers for all divisors d of the nth Fibonacci number. If you prefer more formal notation,

Input: a positive integer n
Output: the sum
For example, consider n=4. F(4) = 3The divisors of 3 are 1 and 3, so the output should be F(1) + F(3) = 1 + 2 = 3.
For n=6, F(6) = 8, and the divisors of 8 are 1, 2, 4, 8, so the output is F(1) + F(2) + F(4) + F(8) = 1 + 1 + 3 + 21 = 26.
Test Cases:
1 => 1
2 => 1
3 => 2
4 => 3
5 => 6
6 => 26

This is code-golf, shortest answer in bytes wins. Standard loopholes apply.

Actually, 5 bytes
F÷♂FΣ

Try it online!
How it works
       (implicit) Read n from STDIN.
F      Compute F(n).
 ÷     Get F(n)'s divisors.
  ♂F   Map F over the divisors.
    Σ  Take the sum.

The name of the language makes it seem passive aggressive, is that intended?

I doubt it. The first version of the language was called Seriously because of this comment. For the second version, the author chose to keep using adjectives.

Jelly, 7 bytes
ÆḞÆDÆḞS

Try it online!
Explanation:
ÆḞÆDÆḞS Main link (Arguments: z)
ÆḞ      zth Fibonacci number's
  ÆD                           divisors'
    ÆḞ                                   Fibonacci numbers'
      S                                                     sum

Absolutely outrageous! I don't know any of these exotic languages, but it seems supernatural to me how you can write a whole algorithm with a few characters.

@BogdanAlexandru You can see that most of the builtins used here each consume 2 bytes, since they didn't fit in 1 byte. See Dennis's Actually answer for even fewer chars. Also, Jelly is a "golfing language", a language made specifically for [tag:code-golf], and it's one of the most efficient ones here (although there isn't one "most efficient" language).

Are you saying that these languages aren't used in practice and they're only meant for challenges?

Mathematica, 29 bytes
f=Fibonacci;f@#~DivisorSum~f&

Mathematica Simplified, 14 bytes
Fi@#~Div9`~Fi&

Oh well, this ended up being identical to @MartinEnder's solution...

Well... Using a shorter version of the same language... I guess that works.

There are no single letter function names in Mathematica, right? Could you not match all two character strings formed from a leading upper case letter plus a single byte? If so you'd have 26*256=6656 simplified 2-byte function names, enough for the 6356 11.1.1 names with 300 to spare.

@JonathanAllan Good idea. (but there are single name functions, like N)

Japt, 11 bytes
MgU â x@MgX

Try it online!

Gah! You beat me to it again!

@Shaggy you have to get faster ;)

Alice, 38 36 bytes
Thanks to Leo for saving 2 bytes.
/ow;B1dt&w;31J
\i@/01dt,t&w.2,+k;d&+

Try it online!
Almost certainly not optimal. The control flow is fairly elaborate and while I'm quite happy with how many bytes that saved over previous versions, I have a feeling that I'm overcomplicating things that there might be a simpler and shorter solution.
Explanation
First, I need to elaborate a bit on Alice's return address stack (RAS). Like many other fungeoids, Alice has a command to jump around in the code. However, it also has commands to return to where you came from, which lets you implement subroutines quite conveniently. Of course, this being a 2D language, subroutines really only exist by convention. There's nothing stopping you from entering or leaving a subroutine through other means than a return command (or at any point in the subroutine), and depending on how you use the RAS, there might not be a clean jump/return hierarchy anyway.
In general, this is implemented by having the jump command j push the current IP address to the RAS before jumping. The return command k then pops an address of the RAS and jumps there. If the RAS is empty, k does nothing at all.
There are also other ways to manipulate the RAS. Two of these are relevant for this program:

w pushes the current IP address to the RAS without jumping anywhere. If you repeat this command you can write simple loops quite conveniently as &w...k, which I've already done in past answers.
J is like j but doesn't remember the current IP address on the RAS.

It's also important to note that the RAS stores no information about the direction of the IP. So returning to an address with k will always preserve the current IP direction (and therefore also whether we're in Cardinal or Ordinal mode) regardless of how we passed through the j or w that pushed the IP address in the first place.
With that out the way, let's start by looking into the subroutine in the above program:
01dt,t&w.2,+k

This subroutine pulls the bottom element of the stack, n, to the top and then computes the Fibonacci numbers F(n) and F(n+1) (leaving them on top of the stack). We never need F(n+1), but it will be discarded outside the subroutine, due to how &w...k loops interact with the RAS (which sort of requires these loops to be at the end of a subroutine). The reason we're taking elements from the bottom instead of the top is that this lets us treat the stack more like a queue, which means we can compute all the Fibonacci numbers in one go without having to store them elsewhere.
Here is how this subroutine works:
                                                          Stack
01    Push 0 and 1, to initialise Fibonacci sequence.     [n ... 0 1]
dt,   Pull bottom element n to top.                       [... 0 1 n]
t&w   Run this loop n times...                            [... F(i-2) F(i-1)]

  .     Duplicate F(i-1).                                 [... F(i-2) F(i-1) F(i-1)]
  2,    Pull up F(i-2).                                   [... F(i-1) F(i-1) F(i-2)]
  +     Add them together to get F(i).                    [... F(i-1) F(i)]

k     End of loop.

The end of the loop is a bit tricky. As long as there's a copy of the 'w' address on the stack, this starts the next iteration. Once those are depleted, the result depends on how the subroutine was invoked. If the subroutine was called with 'j', the last 'k' returns there, so the loop end doubles as the subroutine's return. If the subroutine was called with 'J', and there's still an address from earlier on the stack, we jump there. This means if the subroutine was called in an outer loop itself, this 'k' returns to the beginning of that outer loop. If the subroutine was called with 'J' but the RAS is empty now, then this 'k' does nothing and the IP simply keeps moving after the loop. We'll use all three of these cases in the program.
Finally, on to the program itself.
/o....
\i@...

These are just two quick excursions into Ordinal mode to read and print decimal integers.
After the i, there's a w which remembers the current position before passing into the subroutine, due to the second /. This first invocation of the subroutine computes F(n) and F(n+1) on the input n. Afterwards we jump back here, but we're moving east now, so the remainder of the program operators in Cardinal mode. The main program looks like this:
;B1dt&w;31J;d&+
        ^^^

Here, 31J is another call to the subroutine and therefore computes a Fibonacci number.
                                              Stack
                                              [F(n) F(n+1)]
;     Discard F(n+1).                         [F(n)]
B     Push all divisors of F(n).              [d_1 d_2 ... d_p]
1     Push 1. This value is arbitrary.        [d_1 d_2 ... d_p 1]
      The reason we need it is due to
      the fact that we don't want to run
      any code after our nested loops, so
      the upcoming outer loop over all
      divisors will *start* with ';' to
      discard F(d+1). But on the first
      iteration we haven't called the
      subroutine yet, so we need some
      dummy value we can discard.
dt&w  Run this loop once for each element     [d_1 d_2 ... d_p 1]
      in the stack. Note that this is once    OR
      more than we have divisors. But since   [d_i d_(i+1) ... F(d_(i-1)) F(d_(i-1)+1)]
      we're treating the stack as a queue,
      the last iteration will process the
      first divisor for a second time.
      Luckily, the first divisor is always
      1 and F(1) = 1, so it doesn't matter
      how often we process this one.

  ;     Discard the dummy value on the        [d_1 d_2 ... d_p]
        first iteration and F(d+1) of         OR
        the previous divisor on subsequent    [d_i d_(i+1) ... F(d_(i-1))]
        iterations.
  31J   Call the subroutine without pushing   [d_(i+1) ... F(d_i) F(d_i+1)]
        the current address on the RAS.
        Thereby, this doubles as our outer
        loop end. As long as there's an
        address left from the 'w', the end
        of the subroutine will jump there
        and start another iteration for the
        next divisor. Once that's done, the
        'k' at the end of the subroutine will
        simply do nothing and we'll continue
        after it.

;     Discard the final F(d_i+1).
d&+   Get the stack depth D and add the top   [final result]
      D+2 values. Of course that's two more
      than we have divisors, but the stack is
      implicitly padded with zeros, so that
      doesn't matter.

R, 77 bytes
F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)

Makes use of the 'gmp' library.  This has a builtin Fibonacci function and provides the ability to do large numbers.  It caused a few issues with seqs and applys, though it is still smaller than creating my own Fibonacci function.
Explanation
F=gmp::fibnum;               # Set F as fibnum function
N=F(scan());                 # get input and set N to the fibonacci number of that index
i=n=N-N;                     # set i and n to 0 with data type bigz
while(i<N)                   # loop while i < N
   if(N%%(i=i+1)<1)          # if incremented i is divisor of N
       n=n+F(i);             # add F(i) to rolling sum
print(n)                     # output final result

Test
> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 6
2:
Read 1 item
Big Integer ('bigz') :
[1] 26
> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 10
2:
Read 1 item
Big Integer ('bigz') :
[1] 139583862540
> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 15
2:
Read 1 item
Big Integer ('bigz') :
[1] 13582369791278266616906284494806735565776939502107183075612628411498802812823029319917411196081011510136735503204397274473084444

Without using gmp
81 bytes, Recursive function that is hopelessly slow when large (9+) numbers are picked
F=function(n)`if`(n<2,n,F(n-1)+F(n-2));sum(sapply(which((N=F(scan()))%%1:N<1),F))

88 bytes, Binet's formula that will work reasonably well with larger numbers, but still hits integer limit quite quickly
F=function(n)round(((5+5^.5)/10)*((1+5^.5)/2)^(n-1));sum(F(which(F(N<-scan())%%1:N<1)))

05AB1E, 11 bytes
!ÅFDI<èÑ<èO

Try it online!
Explanation
!            # factorial of input
 ÅF          # get the list of fibonacci numbers (starting at 1)
             # smaller than or equal to this
   D         # duplicate list of fibonacci number
    I<è      # get the element at index (input-1)
       Ñ     # get the list of its divisors
        <    # decrement each
         è   # get the fibonacci numbers at those indices
          O  # sum

Haskell, 54 bytes
f=0:scanl(+)1f
g x=sum[f!!d|d<-[1..f!!x],mod(f!!x)d<1]

Usage example: g 6 -> 26. Try it online!

Axiom, 68 bytes
g==>fibonacci;f(x:NNI):NNI==(x<3=>1;reduce(+,map(g,divisors(g(x)))))

some test
(46) -> [[i,f(i)] for i in [0,1,2,3,4,5,6,10,15] ]
   (46)
   [[0,1], [1,1], [2,1], [3,2], [4,3], [5,6], [6,26], [10,139583862540],
     [15,
      135823697912782666169062844948067355657769395021071830756126284114988028_
       12823029319917411196081011510136735503204397274473084444
     ]
   ]
                                       Type: List List NonNegativeInteger

Pari/GP, 34 bytes
n->sumdiv((f=fibonacci)(n),x,f(x))

Try it online!

Python 2, 89 84 bytes
-5 bytes thanks to ovs

lambda n:sum(f(i)for i in range(1,f(n)+1)if f(n)%i<1)
f=lambda x:x<3or f(x-1)+f(x-2)

Try it online!

Perl 6, 49 bytes
{my \f=0,1,*+*...*;sum f[grep f[$_]%%*,1..f[$_]]}

C (gcc), 93 90 80 bytes
F(n){n=n<2?n:F(n-1)+F(n-2);}i,s;f(n){for(s=0,i=F(n);i;i--)s+=F(n)%i?0:F(i);n=s;}

Try it online!

JavaScript (ES6), 105 104 103 101 97 bytes
i=>[...Array((g=(n,x=0,y=1)=>n--?g(n,y,x+y):x)(i)+1)].map((_,y)=>s+=g((z=g(i)/y)%1?0:z|0),s=0)&&s

Try it

f=
i=>[...Array((g=(n,x=0,y=1)=>n--?g(n,y,x+y):x)(i)+1)].map((_,y)=>s+=g((z=g(i)/y)%1?0:z|0),s=0)&&s
o.innerText=f(j.value=4)
oninput=_=>o.innerText=f(+j.value)
<input id=j type=number><pre id=o>

I think you can change (z=g(i)/y)>~~z to (z=g(i)/y)%1, if you're just checking that z is an integer.

@ETHproductions, that creates an overflow that can be solved by changing g(z) to g(z|0) but brings us back up to the same byte count.

CJam, 26 bytes
qi_[XY@{_2$+}*]_@\f%:!.*:+

Try it online!
I'm sure it can be done better. Explanation:
The idea is to have an array of Fibonacci numbers and dot product it with an array with 1s and 0s if that number is or is not a divisor of the input.
qi                                 Read the input (n)
   [XY        ]                    Array starting with [1,2,...]
  _   @{_2$+}*                     Append n times the sum of the previous two
               _                   Duplicate the array
                @\f%               Modulo each item with n (0 if divisor, a number otherwise)
                    :!             Logical NOT everything (1 if divisor, 0 otherwise)
                      .*:+         Dot product those two arrays

JavaScript (ES6), 76 65 bytes
f=(n,i=k=(F=n=>n>1?F(n-1)+F(n-2):n)(n))=>i&&(k%i?0:F(i))+f(n,i-1)

Test cases

f=(n,i=k=(F=n=>n>1?F(n-1)+F(n-2):n)(n))=>i&&(k%i?0:F(i))+f(n,i-1)

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))

Q, 75 bytes
{f:{$[x<2;x;.z.s[x-1]+.z.s[x-2]]};sum f each m where(~)b mod m:1+til b:f x}

Add++, 89 bytes
D,f,@@@@*,V$2D+G1+dAppp=0$Qp{f}p
D,r,@,¿1=,1,bM¿
D,g,@,¿1_,1_001${f},1¿{r}
D,d,@,{g}dF€gs

Try it online!

Husk, 8 bytes
ṁ!İfḊ!İf

Try it online!