text:
Raindrops are falling on my... glasses?
I live in the UK, where it rains. A lot. I also have the unfortunate necessity to need to wear glasses to see, which means that when it rains (as it is now), I can barely see out of them. This challenge is so that you can all experience the same!
Task
Output ASCII art glasses with a drop of water added each second.
Input
None
Output
A pair of glasses with drops of water on them.
Glasses
 ________________________
|          /__\          |
|         /    \         |
|        /      \        |
\_______/        \_______/

Raindrops
A raindrop is denoted by a .. A raindrop is randomly placed on the glasses' lenses. So when a raindrop is placed, the glasses might look like this
 ________________________
|          /__\          |
|    .    /    \         |
|        /      \        |
\_______/        \_______/

If it is placed on a blank space (), an . is placed on the image. If it is placed on a square which already has a raindrop, the drop graduates.
The steps on drops are

no drops placed:
1 drop placed: .
2 drops placed: o
3 drops placed: O
4+ drops placed: @

Rules

The image should look as though it stays in place. This means that you can either clear the screen or print enough newlines to "clear" the screen. You cannot return a list of steps. Sorry about this, but you should be able to work around that.
When outputting newlines to "clear" the screen, you must have at least 3 newlines between the glasses.
The code runs until the glasses are full of fully graduated drops i.e. until the output looks like this:

     ________________________
    |@@@@@@@@@@/__\@@@@@@@@@@|
    |@@@@@@@@@/    \@@@@@@@@@|
    |@@@@@@@@/      \@@@@@@@@|
    \_______/        \_______/

Shortest code in bytes wins.

"The code runs until the glasses are full of fully graduated drops" Perhaps specify an approximate sleep/wait time? Like 150 or 250 ms?

Does the code have to stop when the glasses look like the final output or can it keep running but just not affect anything?

@TheLethalCoder I would imagine until the glasses are full, as written in the spec :v

Droplet's random fall does have to fall randomly on lenses even on part of the bits of the lens that are @, right?

@TheLethalCoder it should terminate after all have graduated

@KevinCruijssen sleep time can be anything above or equal to 1ms

@RandomUser Okay and sleep time doesn't matter does this mean you don't need to sleep at all?

JavaScript (ES6), 269 267 265 bytes

document.write('
')
a=[...` _8_8_8
| 9 /__\\  9|
| 9/ 4\\ 9|
| 8/ 6\\ 8|
\\_7/ 8\\_7/`.replace(/.\d/g,s=>s[0].repeat(s[1]))]
s=" .oO@@"
g=_=>o.innerHTML=a.join``
f=(i=s.indexOf(a[j=Math.random()*a.length|0])+1)=>i?g(a[j]=s[i]):f()
g()
setInterval(f,1e3)

Edit: Saved 2 4 bytes thanks to @Shaggy.

something goes wrong at the upper left corner

-1 because it's bugged (see Jenny's comment)

@DestructibleLemon Sorry about that, I got bitten by a "feature" of Firefox's clipboard... should be OK now.

Save a couple of bytes with innerText instead of textContent and search instead of indexOf. And a few more by just using
i?g(a[j]=s[i]):f() work, for a 2 byte saving?

@Shaggy Great find, thanks!

Java 8, 449 421 420 bytes
v->{String q="########",g=" ________________________\n|##"+q+"/__\\##"+q+"|\n|#"+q+"/    \\#"+q+"|\n|"+q+"/      \\"+q+"|\n\\_______/        \\_______/\n\n\n";for(int t=0,n,x;g.matches("(?s).*[#\\.oO].*");Thread.sleep(150)){for(;(x=g.charAt(n=(int)(Math.random()*g.length())))!=35&x!=46&x!=111&x!=79;);g=t++>0?g.substring(0,n)+(x<36?".":x<47?"o":x<80?"@":"O")+g.substring(n+1):g;System.out.println(g.replace('#',' '));}}

-1 byte thanks to @ceilingcat.
Explanation:
Try it here. (Thread.sleep is removed so you instantly see the result.)
v->(){                      // Method without empty unused parameter and no return-type
  String q="########",g=" ________________________\n|##"+q+"/__\\##"+q+"|\n|#"+q+"/    \\#"+q+"|\n|"+q+"/      \\"+q+"|\n\\_______/        \\_______/\n\n\n";
                            //  The glasses (with inner spaces replaced by '#')
  for(int t=0,n,x;          //  Index integers
      g.matches("(?s).*[#\\.oO].*");
                            //   Loop (1) as long as the glasses still contain "#.oO"
      Thread.sleep(150)){   //   And sleep 150ms after each iteration to give the animation
    for(;                   //   Inner loop (2)
         (x=g.charAt(n=(int)(Math.random()*g.length())))!=35&x!=46&x!=111&x!=79;
                            //    To find the next '#', '.', 'o' or 'O' randomly
    );                      //   End of inner loop (2)
    g=t++>0??               //   Flag so it prints the initial glasses without a raindrop
      g.substring(0,n)+(x<36?".":x<47?"o":x<80?"@":"O")+g.substring(n+1):g;
                            //    Add a raindrop on this random position
    System.out.println(g    //   And print the glasses
        .replace('#',' ')); //   After we've replaced '#' with spaces
  }                         //  End of loop (1)
}                           // End of method

Output:
NOTE: The dots are a bit weird in the gif, but that's a problem in my ScreenToGif.exe..

You know what is dazzling me about, those weird dots (same applies to scaled-down ") really look like there is a real water drop on top of my screen

This does not account for the possibility of a drop falling on an @ :v

@Jenkar that is the second time you have said that on answers. Please explain what you mean.

@RandomUser Basicly, the current code in this answer looks for a spot that is not yet an @ to fall on, rather than falling on the lenses randomly, even if it is an at. The "4+" in requirements seems to indicate that this is not the case to go, but instead one should fall on the lens randomly, including an @. Is this not the correct interpretation?

@Jenkar It doesn't matter how it does it, just that it does it without violating any rules or standard loopholes. I never said "It must have a uniform random distribution" in the question so this answer is fine.

@Jenkar Hmm you're indeed right. Missed the 4+ part. But I guess RandomUser thinks it's fine like this. Personally I think it's better this way, otherwise it might take a very long time before the entire glasses are filled near the end. But well-spotted, nonetheless.

Python 2, 365 328 bytes
That's a bit better...
import time,random
g=' '+'_'*24+r"""
|xxX/__\Xxx|
|xX/    \Xx|
|X/      \X|
\_______/        \_______/""".replace('X','x'*8)
while 1:
 print'\n'*3+g.replace('x',' ')
 s='x.oO@@'
 if all(c not in g for c in s[:-2]):exit()
 i,c=random.choice([(i,s[s.index(j)+1])for i,j in enumerate(g)if j in s])
 g=g[:i]+c+g[i+1:]
 time.sleep(1)

Try it online
The above link uses 30 lines instead of 3, but you can see it with 3 if you resize your browser window to be small enough vertically. Change time.sleep(1) to time.sleep(.1) for 10x speed.

F#, non-recursive 379 414 404 bytes
open System
let z=String.replicate
let mutable s,d=z 54" ",new Random()
while Seq.exists((<>)'@')s do printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"(z 24"_")(s.[..9])(s.[10..19])(s.[20..28])(s.[29..37])(s.[38..45])"\\"(s.[46..53])"\\";Threading.Thread.Sleep(1000);d.Next54|>fun i->s<-(s.[i]|>function|' '->"."|'.'->"o"|'o'->"O"|_->"@")|>(fun c->s.Remove(i,1).Insert(i,c))

Try it online!

-7 bytes thanks to @vzwick

by aliasing String.replicate
by opening System instead of referencing it every time

-3 bytes by reducing the while loop to one line

I love the premise of this challenge :)
And thanks for the earworm.
F#, 406 441 438 437 423 bytes
open System
let z=String.replicate
let s,d=z 54" ",new Random()
let rec(!)s=s="";printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"(z 24"_")(s.[..9])(s.[10..19])(s.[20..28])(s.[29..37])(s.[38..45])"\\"(s.[46..53])"\\";Threading.Thread.Sleep(1000);if Seq.exists((<>)'@')s then d.Next 54|>fun i-> !((s.[i]|>function|' '->"."|'.'->"o"|'o'->"O"|_->"@")|>(fun c->s.Remove(i,1).Insert(i,c)))else()
!s

Try it online!

-3 bytes by constraining s to string by comparing it with string
-1 byte, function name is now "!" saving a single space when calling it
-7 bytes thanks to @vzwick

by aliasing String.replicate
by opening System instead of referencing it every time

-1 byte, no need for parenthesis when calling d.Next
-6 bytes, function is now one line

Explanation
open System
let z = String.replicate    // define alias
let s, d = z 54 " ", new Random() // s holds a flat representation of the glasses.. glasses
let rec(!) s =
    s=""; // type s to string
    printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"
        (z 24 "_")     // top of the glasses
        (s.[..9])      // slice
        (s.[10..19])   // and
        (s.[20..28])   // dice
        (s.[29..37])   // the
        (s.[38..45])   // glasses
        "\\"           // \ gets prepended with 6 spaces thanks to %7s
        (s.[46..53])
        "\\";          // same deal, just 8 spaces this time
    Threading.Thread.Sleep(1000);
    if Seq.exists((<>)'@') s then // if not everything's totally covered
        d.Next 54                 // get new random int < 54 (string has indices 0-53)
        |> fun i->                // passing is shorter than a let binding, saves two spaces and a new line
            !(                    // call the function again with new drop on glasses
              (s.[i]              // get part of the glasses drop fell on
              |>function
              |' '->"."           // promote drop
              |'.'->"o"
              |'o'->"O"
              |_->"@")
              |>(fun c-> s.Remove(i,1).Insert(i,c))) // and insert this in the string
    else ()
!s

You can save 1 char by open System and removing System from the Random() and Threading.Thread.Sleep() calls ;)

A few more characters shaved: https://tio.run/##TZDfa4NADMff/SvCgXgHbaqtri2d0te9bFD3NosUjaugZ@fdtq74v7tTO1gg5PPND0JSqHndyKbvmwtJiH@UptqqSMMtjHVbynds6VKV2UnTmFazPLxB4DNgM0nfcDjJvKm5GIstZdCCCi3jjO0uZl4XkoGtEtnZapGmSWKrbhJg7J@012rkJEknW9hb9YcmLRm/wdJnKRNc4Rvi9jiC5yJ6d14aXm7uvEVcrSdebRD94ChYkrBB@w@IwWrSu9dzS6d8uHQijCuiC/dc1xUWlAXE9IF0LZVWnD9Gwtk7QoE@k7QAhqvLMMdnumoe@GYAhgXlsYuKT5npspGdA848Ysg6BwdoDDQDvLAuNWHPRBdx0w3ZPFJ4oLr5Il7OPIFPUlGrDWfC9LQWUKXI/Nr8uO9/AQ

@vzwick thanks :) found another few bytes as I was editig

Ruby, 237 224 228 218 206 198 197 bytes
g=" #{?_*24}
|x##/__ax##|
|x#/    ax#|
|x/      ax|
a#{u=?_*7}/xa#{u}/

".gsub ?x,?#*8;217.times{|t|puts g.tr('#a',' \\');()while t<216&&g[x=rand*106]!~/[#.oO]/;g[x]=g[x].tr '#.oO','.oO@';sleep 1}

Try it online!
Previous answer was wrong, it did not take into account a raindrop falling on a @. Apparently not a requirement. Some bytes saved.
This terminates with an error thrown, but this definitely terminates as soon as the full glasses are printed.

Saved 13 bytes by putting the printing into a lambda, and changing the assignment to use tr (duh)
8 bytes loss with the 1 second requirement.
10 bytes gain by using the gsub trick instead of interpolation (seen & adapted from mbomb007's Python answer).
12 bytes gain by removing the lambda printing now that the print is written only once >.>
1 byte gain by making all the \\ be a, then changing back inside the tr
7 byte gain by putting the changing the spaces on the last line with another x (duh). In case some of you guys are wondering why this doesn't affect the main loop : the main loop doesn't consider the last line to determine its x.
1 byte gain by removing the  at the end of the top of the glasses

Yay < 200 bytes :D
Gif :

For future reference you can edit your previous answer to one that works instead of deleting it and adding a new one.

Could you add in a gif of this running?

@RandomUser Done.

C, 313 309 305 304 bytes
Needs to be golfed down quite a bit;
c;f(r,q){for(char*m=" ________________________\n|**********/__\\**********|\n|*********/    \\*********|\n|********/      \\********|\n\\_______/        \\_______/\n";c<216;r=rand()%144,m-=135)for(system("clear");*m++;putchar(*m^42?*m:32))q=--r?*m:*m^42?*m^46?*m^111?*m^79?*m:64:79:111:46,c+=q!=*m,*m=q;}

I run it with the following test stub
main()
{
    srand(time(0));
    f();
}

Mathematica, 438 bytes
f=Flatten;p=Print;z=32;q=95;l=124;t=Table;v=z~t~8;s={f@{z,q~t~24,z},f@{124,z~t~10,47,q,q,92,z~t~10,l},f@{l,z~t~9,47,z~t~4,92,z~t~9,l},f@{l,v,47,z~t~6,92,v,l},f@{92,q~t~7,47,v,92,q~t~7,47}};c=0;Monitor[While[c<54,a=s[[i=RandomInteger@{2,4},j=RandomChoice[Range[2,13-i]~Join~Range[14+i,25]]]];If[a==z,s[[i,j]]=46,If[a==46,s[[i,j]]=111,If[a==111,s[[i,j]]=48,If[a==48,s[[i,j]]=64]]]];c=Count[Flatten@s,64];Pause@1],Column@FromCharacterCode@s]

here is a 10x speed result gif

Never used Mathematica but could you assign to Table, 95 and 32?

As in t=Table x = 32 and y = 95?

yes of course. I golfed it a lot since yesterday

You might be able to remove 6 bytes by replacing the last Flatten with f?

Bash, 576 510 429 416 Bytes
j()(IFS=
printf "$*")
for i in {53..0};{ a[$i]=
b[$i]=@;}
while(($i == 0));do clear
echo  " ________________________
|`j ${a[@]::10}`/__\\`j ${a[@]:10:10}`|
|`j ${a[@]:20:9}`/    \\`j ${a[@]:29:9}`|
|`j ${a[@]:38:8}`/      \\`j ${a[@]:46}`|
\_______/        \_______/"
[ `j ${a[@]}` = `j ${b[@]}` ]&&{
i=1
}
sleep 1
d=`shuf -i0-53 -n1`
c=${a[$d]}
case $c in  )a[$d]=.;;.)a[$d]=o;;o)a[$d]=0;;0)a[$d]=@;esac
done

Wow, golfed a lot. If anyone have any idea for further golfing, I'm open to suggestions
Try it yourself! It has the sleep commented because of the 60 seconds limit
Here is the gif:

Perl, 167 bytes
Note that \x1b is a literal escape character.
$_="\x1bc 24_
|10X/__\\10X|
|9X/4 \\9X|
|8X/6 \\8X|
\\7_/8 \\7_/
";s/\d+(.)/$1x$&/ge;do{$a[rand 54]++,sleep print s/X/($",".",o,O)[$a[$-++%54]]||"@"/ger}while grep$_<4,@a

See it online!

PHP, 262 254 bytes
for($t=" 8_8_8_
|Y9Y/__\Y9Y|
|9Y/4 \9Y|
|8Y/6 \8Y|
\\7_/8 \\7_/";$c=$t[$i++];)$s.=$c<1?$c:str_repeat($t[$i++],$c);for(;$c=$s[++$k];)$c!=Y?:$s[$m[]=$k]=" ";for(;$u<216;print str_pad($s,999,"
",sleep(1)))$u+=($c=".oO@"[$a[$p=rand(0,53)]++])&&$s[$m[$p]]=$c;

Run with -nR or try it online.
breakdown
# prep 1: generate template from packed string
for($t=" 8_8_8_\n|Y9Y/__\Y9Y|\n|9Y/4 \9Y|\n|8Y/6 \8Y|\n\\7_/8 \\7_/";
    $c=$t[$i++];)$s.=$c<1?$c:str_repeat($t[$i++],$c);
# prep 2: map substituted spaces and replace with real spaces
for(;$c=$s[++$k];)$c!=Y?:$s[$m[]=$k]=" ";
# loop until glasses are fully wet:
for(;$u<216;
    # 4. print glasses prepended with 865 newlines
    print str_pad($s,999,"\n",
    # 3. wait 1 second
        sleep(1)))
    $u+=($c=".oO@"[
        $a[$p=rand(0,53)    # 1. pick random position
        ]++])               # 2. and increment
        &&$s[$m[$p]]=$c         # if not fully wet, graduate drop
    ;                           # and increment drop count ($u+=)


text:
;# without resetting
;# is a very simple language. It has 2 commands:

; will increment the accumulator
# outputs the accumulator modulo 127, and then resets the accumulator

;$ is also very simple and is very similar (and also does not yet exist). It has 2 commands:

; will increment the accumulator
$ outputs the accumulator modulo 127. However, it does not reset the accumulator.

Challenge
Create a program that will convert ;# code to ;$ code. That is, given input a using standard methods, output he shortest b such that a in ;# outputs the same thing as b in ;$. The input will only contain the characters ';' and '#'. The input will not have trailing semicolons. That is, it will match the regex (;*#)+. This also means input will not be blank. Note that ;;;;## is possible (equivalent to ord(4) ord(0)).
Examples
;# code -> ;$ code
;;;;;;;;;;#;;;;;;;;;;;;# -> ;;;;;;;;;;$;;$
;;;;;;;;;;;;;;#;;;# -> ;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;# -> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;$$;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;$;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;$ (Hello, World!)

I'm downvoting this, because there are too many ;# questions going around. They're not very interesting.

@isaacg Ah. Thanks for your input. I'll try to keep my challenges more original next time though do note that this was one of the earlier ;# challenges; it was the first one after the compiler and the transpiler IIRC.

Is the ;# input shortest one?

Jelly, 18 bytes
ṣ”#L€ṙ-I%127”;ẋp”$

Try it online!
How it works
ṣ”#L€ṙ-I%127”;ẋp”$  Main link. Argument: s (string)

ṣ”#L€               Split s at hashes. Take the length of each resulting chunk.
     ṙ-             Rotate the result -1 units to the left / 1 unit to the right.
                    Since s won't have trailing semicola, the length of the last
                    chunk will be 0. Rotating moves this 0 to the beginning.
       I            Increments; take all forward differences. Because of the 0 we
                    removed to the beginning, the first forward difference will be
                    the length of the first chunk.
        %127        Take the differences modulo 127. In Python, `n % d' is either 0
                    or has the same sign as d, so this reports how many semicola
                    are needed to get from one code point to the next one.
            ”;ẋ     Repeat ';' k times, for each modulus k.
               p”$  Take the Cartesian product with "$", appending '$' to each run
                    of semicola.

JavaScript (ES6), 68 bytes
s=>s.replace(/;*#/g,s=>';'.repeat((127-a+(a=s.length))%127)+'$',a=1)

Examples

let f =

s=>s.replace(/;*#/g,s=>';'.repeat((127-a+(a=s.length))%127)+'$',a=1)

console.log(f(";;;;;;;;;;#;;;;;;;;;;;;#"))
console.log(f(";;;;;;;;;;;;;;#;;;#"))
console.log(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"))

PHP, 99 bytes
while(~$c=a^$argn[$p++])j^$c?r^$c?:$a=-$b*$b=print str_repeat(";",(127+$a%127)%127)."$":$b+=!!++$a;

J, 37 bytes
[:;';$'<@#~1,.~127|2-~/\0,=&'#'#;._2]

Try it online!

Python, 101 100 97 85 bytes
1 bytes saved thanks to @WheatWizard
def t(c,s=0):
 for x in map(len,c.split('#')[:-1]):print(end=';'*((x-s)%127)+'$');s=x

You can drop the space between ) and for

@WheatWizard thanks

Retina, 52 bytes
^
##
#
127$*;$
^;+\$;+\$|(;+)(?<=\$\1(;{127})?\$\1)

Try it online! Includes test suite. Explanation: 127 is added to each # to make the subtraction modulo 127 easier; the #s are changed to $ at the same time. The subtraction itself is handled by the lookbehind (?<=\$\1(;{127})?\$\1) which ensures that we subtract either the number of ;s between the previous two #s (which handles the case when there are more ;s) or 127 fewer than that number (which handles the case when there are fewer ;s and they need to wrap past 127). A lookbehind is used so that all the replacements can be calculated in one pass. In order for there always to be two previous #s, two extra #s are temporarily prefixed.

Perl 5 -p, 65 bytes
s/(;*)#/$b=($q+$b)%127;';'x($q+=(($q=length$1)<$b)*127-$b).'$'/ge

Try it online!

source: Stack Exchange

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

sort: votes


text:
Compress a maximal discrepancy-2 sequence
Output this binary sequence of length 1160:
-++-+--++-++-+--+--++-+--+--++-+--++-++-+-++--++-+---+-++-+--+--++++--+--++-+--++-++----++-++-+-++--++-+-+---++-+--++-++-+--++-+--+---+-++-+--++-++-+--+--++-++-+--++-+--+++-+-+----+++-+--+--+++---++-++-+--+--+++--+-+-+--+-+++-++-+--+--++-+--++-++-+--+--++--+++---+++-+---++-+--++--+-+--+-+++-+--++-++-+--++-+--+--++-+--++--+-++-+-+--+-+-++-+--++-+--+--++-+-+-++-+-+-++---+-+--++++--+---++-+-++-+--++-+--+--++-+--++++--+---+-++++--+--++-++-+--++-+--+--++-+--++-++-+--++-+--+--++-++-+----+++-+--++--+++---+-++-+--+-++---+-++-++-+--+--++--++++-+--+--+--++++--+--+++---++-++-+--++--+-+--+--++-++-+--+--+-+++-++-+--+--++--+-++-++-+--+--+--++-++-+--+++---++-+--++-++---+++---++-++----+++--+-++-+--+--++-+--++-++-+-++--++--++----+++-++--++----++-+++--++---+++----+-+-++-++-++-+-+----+++--++-+--++-++-+--+--+--++-+--++-++-+--++--+-+--+-+-+-++++---+-+-++--+--+-+-+-++-+-+++--+-+--+--+-+++--+-+++---++-+--+--++-++--++---++-+-++--++-+---+-++-+--+-++--++-+--++-+--+-+++-+--++--+-+-+++--+-+--++-++-+--+--+-++---+-++-+-++--++-+--+++-+----++--+-++-+-++--++-+--++-+-++--++-+---+-++-+--+++----+-+-++--++-+--++-++-++-+--+--+--++++---++---+-+-++-+-+++--+-++--+-+--+-+-++---+++-++

The sequence
This finite sequence is tightly structured in a way that I hope lends to unique methods for compression. It arises from the Erdős discrepancy problem, which was featured in a previous challenge.
Treating the terms as +1 and -1, this is a maximal-length sequence of discrepancy 2, which means that:

For every positive step size d, if you take every d'th term (starting with the dth term), the running sum of the resulting sequence remains between -2 and 2 inclusive.

If you think of each + to mean a step right and - to mean a step left, this means that the walk of every dth instruction never travels more than 2 steps away from the start position.
For example, for d=3, taking every 3rd term gives the sequence +-++--+--+-..., whose running sums are [1,0,1,2,1,0,1,0,-1,0,1,...], which never hit -3 or 3.
-++-+--++-++-+--+--++-+--+--++-+--+...
  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^
  +  -  +  +  -  -  +  -  -  +  -
   1  0  1  2  1  0  1  0 -1  0  -1  ...

This sequence was found in 2014 via a computer search. See this paper, where the sequence is reproduced in Appendix B. The search proves that 1160 is the maximum length of a discrepancy-2 sequence, though there is more than one sequence of that length. The Erdős discrepancy problem, proven in 2015, says that any such sequence must have finite length for any maximum discrepancy c in place of 2.
Time requirement
Your code should finish within 5 seconds. This is to limit brute-forcing.
Output format
You can use any two fixed distinct characters or values for + and - in any list-like or string-like format. The format should be one where the 1160 bit-values can be directly read off, not for example encoded as a number via its binary representation or a string via character values. For string output, a trailing newline is allowed.
Leaderboard

var QUESTION_ID=122304,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/122304/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

most common substrings of length 1-16 if anyone wants to know

I feel like it will be very hard to beat compression...

Jelly, 149 bytes
“×GOẈ*m¬¿3d{ẋạ⁻@Ɓ]ZĊỵINBƬḊṿẊ*N¹Ẹ÷ƲẋɼoṬḳ£®⁾ƙŒọ¡[P1&ạ€ẊʠNỌXḢṖėÐß⁹Ụṗ¬⁹E#ụḷḌṁżżR=ƊÑ³ıɲ-ṭỌṾɲẎĿỴ⁶€ḋtɦÐ\ỵƒ⁾ƒụṫṡĊKpƭẏkaṪ,Ẋȧ⁻ḅMɓ%YḷsƲƭl¤æĊbṬ9D6ẎƘẓ^Œ⁷Ɲḷḷ€ḟ1g’B

There is some pattern, for example only 81 of the 256 length 8 binary strings are present if one chops the sequence into eights, but I have not (at least yet) noticed any way to utilise any to reduce byte count from this straight forward base 250 compression converted to a binary list.
Try it online! (the footer formats the binary list to a string for easier direct comparison).

JavaScript (ES6), 263 253 252 bytes
I tried to use as less payload data as possible. Sadly -- but not surprisingly -- this requires quite a lot of decompression code.
Breakdown:

payload data: 75 bytes, encoded as a 100-character Base64 string
code: 163 153 152 bytes

Below is a formatted version without the data. The raw code is in the demo snippet.
f = (a = Array(264).fill(n = p = 0)) =>
  n++ < 1160 ?
    '+/-'[
      p += !a.some((v, i) =>
        n % i | v * v - 4 ?
          0
        :
          r = v / 2,
        r = atob`...`.charCodeAt(p / 8) >> p % 8 & 1 || -1
      ),
      r + 1
    ] +
    f(a.map((v, i) => n % i ? v : v - r))
  :
    ''

How?
We keep track of the running sums a[i] of every i-th terms. Each time one these sums hit the lower bound -2, we know that the next term must be a +. The same logic applies to the upper bound. This is helpful up to i = 264 and doesn't save any extra byte beyond that.
This leaves us with 599 terms that cannot be guessed. We store them as ⌈599 / 8⌉ = 75 bytes, encoded in a 100-character Base64 string.
Demo

f=(a=Array(264).fill(n=p=0))=>n++<1160?'+/-'[p+=!a.some((v,i)=>n%i|v*v-4?0:r=v/2,r=atob`aaLpW0oUDbs8lXXhj5IqpM3ctZD1Q6qtrJKqXmbBRkoZh3o1zCL1WhUo2Yu9KkU2q0CGI33SUzvb5wW+KgnZrZfUY/UhMtnBdEk8`.charCodeAt(p/8)>>p%8&1||-1),r+1]+f(a.map((v,i)=>n%i?v:v-r)):''

o.innerHTML = f()

Python 2, 269 259 256 247 245 243 bytes
r=[1]
c=int('bmqnh8j8rdo4mirjos6uxbfthu8t39pjy6up43axryzwbwcu5d528nsakitjwqbo6dnnozy0oybhk6jduaoc53lqkzdb04opj5t50a24w9he5y7qbgd2',36)
while c:t=sum(sum(r[::-k])/3for k in range(1,264)if len(r)%k<1);r[-1:]=cmp(0,t)or c%2*2-1,1;c>>=t==0
print r

Try it online!

Jelly, 110 109 107 bytes
;1mS€:3o/Nȯ®Ṫṭḷ
“ĖṄẋ{Xṛ-İIṗ®6⁼Ḟ2a⁻!Ċẉȥ+¡Ƒ¥mvrẓsṘ×⁴ç&$nỴỤ)M7?ẊẎḅ=ṠƈTṙḌȥụẋXḌ⁵Ḣ⁺ḲL÷æTƥĿv€%ḟ¢®!Ė’BḤ’©ṛ⁽¡ɠÆD€Nç/

This takes too long on TIO, but it finishes in under 3 seconds on my desktop computer.
Try it online!

Jelly, 135 133 130 129 105 104 bytes
42“I=İėZP*ðEḄẈṆ'mBƝėŻƝ6®Ṇɼḥ[bȦėṡV£(6ṘɱX)Ṅẹ6~K7°ȤÄỴ¥ƝÇ5prḳġŻ£ƭṗṄFṾḃ{©@ɼ’ḃÄċL
L+Ø.ÆDm@NÇ¡§§No¥/Ṡo-ṭ
Ç⁽¡ɠ¡Ḋ

Based on the previous elements of the sequence, the algorithm makes an educated guess what the next element could be. This works for all but 99 elements, whose indices are hardcoded so the corresponding elements can be swapped.
Try it online!

MATL, 224 bytes
862:o'$Te]BQHoHxkw!-CEjv(j=zGp.8_C{\?wkH{t&%W.:ja#7=+>"/,=0wDJ+"2BREtgh9_2I%1>+99T3kPrknzlJ}&8kUR(S!pX]C]05u{"6MHA7"gg(M6\5Vp.k.18Y(c~m&wroTrN)sf" |>\,Lg80C:nUez|l;<h~m(%]4xx6?`=qGtZ):d"*"@~1M.T}jJ)Bl7>Ns >9$8R1MlkG'F3:qZaY"

The ouput is of the form 1 0 0 1 0 ..., where 1 corresponds to '-' and 0 corresponds to '+'.
Try it online!
Explanation
The sequence has been run-length encoded. All 720 runs have lengths 1, 2, 3 or 4, with 3 or 4 being less common. So each 3 has been replaced by 2, 0, 1 (a run of 2, then a run of 0 of the other symbol, then a run of 1 again) and similarly each 4 has been replaced by 2, 0, 2. This gives a ternary array of length 862.
This array is converted to base-94 encoding, and is the long string shown in the code ('$Te...kG'). Base 94 encoding uses all 95 printable ASCII chars except for the single quote (which would have to be escaped).
The code converts that string from base 94 to base 3, and uses the result to run-length decode the symbols [1 0 1 0 ... 0] (array of length 862).

Jelly, 95 bytes
“qạʂṅs⁽fØʋZ%BÞġı½.m0&u⁺TsƝȧAuỴż⁶3uÞ$+ȷ@4Ṣ’BḤC©µmLÆD$§SṠȯ®ṪNLḟ“⁶ .£µ+£gÐ9Ð¦.ñ×µ¥¤®‘ÄḤ¤ɗ}¡ṭø⁽¡ɠ¡Ḋ

A middle point between my two previous approaches.
The code attempts to guess 842 elements of the sequence and hardcodes the remaining 318 ones. 19 of the guesses are incorrect and have to be reverted via a list of hardcoded indices.
Try it online!
How it works
“qạʂṅs⁽fØʋZ%BÞġı½.m0&u⁺TsƝȧAuỴż⁶3uÞ$+ȷ@4Ṣ’

This is a bijective base 250 literal that uses Jelly's code page for digits and encodes the integer \$\scriptsize 380009100940380065412452185545474826295694594854898450166594167299196720639075810827320738450934\$, which © stores in the register.
BḤC©

B converts the integer to binary, Ḥ unhalves/doubles the resulting bits, then C subtracts the results from \$1\$. The result is a list of 318 copies of \$\pm1\$.
µmLÆD$§SṠȯ®ṪNLḟ“⁶ .£µ+£gÐ9Ð¦.ñ×µ¥¤®‘ÄḤ¤ɗ}¡ṭ

This monadic chain takes a prefix of the desired output (with a prepended \$0\$) and appends the next element of the output. The chain works as follows:
mLÆD$§SṠȯ®ṪNLḟ“⁶ .£µ+£gÐ9Ð¦.ñ×µ¥¤®‘ÄḤ¤ɗ}¡ṭ  Monadic chain. Arument: A (array)

 LÆÐ$                                       Compute all divisors of the length of A.
m                                           For each divisor d, generate the subarray
                                            of each d-th element.
     §                                      Take the sum of each subarray.
      S                                     Take the sum of the sums.
       Ṡ                                    Take the sign of the sum.
        ȯ®                                  If the result is 0, replace it with the
                                            array in the register.
          Ṫ                                 Tail; pop and yield the last element,
                                            modifying the register for a zero sum.
                                            This is a no-op for a non-zero sum.
              “⁶ .£µ+£gÐ9Ð¦.ñ×µ¥¤®‘ÄḤ¤      Yield all indices of incorrect guesses.
           NLḟ                        ɗ¡    If the length of A doesn't appear among
                                            the indices, negate the result.
                                        ṭ   Append the result to A.

ø⁽¡ɠ¡Ḋ

This niladic chain resets the return value to \$0\$, calls the monadic link from above 1160 times (⁽¡ɠ encodes the integer \$1160\$), then removes the first element (\$0\$) with Ḋ.

Seems like arithmetic encoding would be simpler than manually changing some entries; have you tried that or is Jelly unsuited for it?

There are only 19 entries that have to be changed, which are encoded in 23 bytes. I think an arithmetic decoder would be longer than that, at least with the associated data.

Charcoal, 150 bytes
”a∧∨~℅¹÷Ｏμ6fＣC⁼∕⁵^;Ÿ‘«·T:∕Ｄ_=v§AＨŒ,—<Ｐr¢E!◨±Ｌ^|.τ"ＮO“šþŽ∧<n`bÞＥ÷β$+Ｚ⟦5⁶⁻.λ‹ζd⧴X>w,⊞?‹⟧⌈⪪-h÷³N“Ｋ⁺L¿>ρ@Ｐ⟲↘3νηKx÷?>™Ž¿•:8Ｖ¦£œεＧ↧x℅7¶	NＲü"m”⟦)&¶bＥ“Ｙv”

Try it online!
Makes use of Charcoal's builtin string compression. Uses . for - and ! for +.

Python 3, 236 232 bytes
Thanks to Mego for saving 4 bytes
#coding:437
print(bin(int.from_bytes('ûKe▓╔L║[\rûO%2╣d▓▌,û╔eè±lr[\x1a┤KeÆ┘Ä.Y¡\x16K-ûiZû[*Tδ\r╩Yl░▌\rÆ╦eÆ╦d╝YÄû¥%│\x0bl69,╓╔m\x12┘ñ╢╔cûN9<il▓S3─╧#8⌡$»\x19d╢╦%Ü╒\x0eª╒(╓╤úû╔£ª]-2╦EÜìd╢¥)û/4ªYL║X⌡2╔-░τRì5⌐─'.encode('437'),'big'))[2:])

Try it online!
Uses the CP-437 encoding. Thanks to Dennis for pointing out an error.

437 is an alias for cp437, so you can shave off 4 bytes by getting rid of the cp bits both times they occur.

CJam, 153 bytes
"Ke²ÉLº[
O%2¹d²Ý,Éeñlr[´KeÙ.YK-iZ[*Të
ÊYl°Ý
ËeËd¼Y%³l69,ÖÉmÙ¤¶ÉcN9<il²S3ÄÏ#8õ$¯d¶Ë%Õ¦Õ(ÖÑ£É¦]-2ËEd¶)/4¦YLºXõ2É-°çR5©Ä"256b2b

Uses 1 for -, and 0 for +.
Contains unprintables. Try it online!
This is pretty simple. Converts a long sequence from base 256 to base 2.

C (gcc), 284 275 273 bytes
f(i){for(i=1160;i--;)putchar(L"嘻狊᢭퉏촶꜊덅妦탋황䥢犛멥촴ꋒ捙椶⹜휩太⫱䤴윊ボ찻䶬隓웃榱㚜孉㚒팩짆楢꙱魃洴㒚伢ꚓꬔꓕꕩ榖듒勩톦♱驭䮴ꓥ鎍甎㚚퍩䴢䚛榰ꓲ덅䴶뒚i"[i/16]>>i%16&1|48);}

Try it online!
Just an array lookup.
Edit: -2 and bugfix thanks to @S.S.Anne

125/273

You have a bug: part of your sequence is 100011100001010110110100101 but it's supposed to be 100011100001010110110110101.

Python 2, 364 250 bytes
Thanks to Jonathan Allan for saving 114 bytes.
print bin(int('28x0lphxjx8ze4uuhtdzo0oebr25amtmuxm62cbit0ibdwjm2sf50clh2ejq0a73ndseo5tove8uqca6nf66bo4abbkg867woh2b435at0o3pddvqmsqp29b6as5bd4eo28xgwkkj607gp66icba1q4n9fc13dltp45j340mpzbc56wsrbb3oejnczsbzfgh82xdi8aku8m4wlmwuxkgy4yaew7pu4p1g',36))[2:]

Try it online!

C#, 385 bytes

Data

Input none
Output String The pretended result.

Golfed
()=>{var s="i´\u009aM6³E¤òi°ÚÍF\u009bM\"Ói6\u009au\u000e\u0093\u008d¤åK´\u009am&qÑ¦Ré´Òi\u0096¥i¤Õ«\u0014ò5¦\u0093O\"òm4\u009am4\u009bC¦qibÚLô\u0093ÉÆÓ)6\u0092í&[I6\u009ci±ÆÃ\u0096\u0093M¬Ì;0ÜÇ\nÛPæ\u009bI4Úe*ñY*×).\\i6cY¢ÒÍ4ºer\u009bIbÖiÐËY¦³E§\nÍ6ÒO\u0018rÊV;";var o="";foreach(var c in s)foreach(var b in Convert.ToString(c,2).PadLeft(8,'0'))o+=(char)(43+(49-(int)b)*2);return o;};

Ungolfed
() => {
    var s = "i´\u009aM6³E¤òi°ÚÍF\u009bM\"Ói6\u009au\u000e\u0093\u008d¤åK´\u009am&qÑ¦Ré´Òi\u0096¥i¤Õ«\u0014ò5¦\u0093O\"òm4\u009am4\u009bC¦qibÚLô\u0093ÉÆÓ)6\u0092í&[I6\u009ci±ÆÃ\u0096\u0093M¬Ì;0ÜÇ\nÛPæ\u009bI4Úe*ñY*×).\\i6cY¢ÒÍ4ºer\u009bIbÖiÐËY¦³E§\nÍ6ÒO\u0018rÊV;";
    var o = "";

    foreach( var c in s )
        foreach( var b in Convert.ToString( c, 2 ).PadLeft( 8, '0' ) )
            o += (char) ( 43 + ( 49 - (int) b ) * 2 );

    return o;
};

Full code
using System;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
        Func<String> f = () => {
            var s = "i´\u009aM6³E¤òi°ÚÍF\u009bM\"Ói6\u009au\u000e\u0093\u008d¤åK´\u009am&qÑ¦Ré´Òi\u0096¥i¤Õ«\u0014ò5¦\u0093O\"òm4\u009am4\u009bC¦qibÚLô\u0093ÉÆÓ)6\u0092í&[I6\u009ci±ÆÃ\u0096\u0093M¬Ì;0ÜÇ\nÛPæ\u009bI4Úe*ñY*×).\\i6cY¢ÒÍ4ºer\u009bIbÖiÐËY¦³E§\nÍ6ÒO\u0018rÊV;";
            var o = "";

            foreach( var c in s )
                foreach( var b in Convert.ToString( c, 2 ).PadLeft( 8, '0' ) )
                    o += (char) ( 43 + ( 49 - (int) b ) * 2 );

            return o;
        };

        Console.WriteLine( $" Input: <none>\nOutput: {f()}\n" );

        Console.ReadLine();
      }
   }
}

Releases

v1.0 - 385 bytes - Initial solution.

Notes

None

05AB1E, 149 bytes
•19GÈRÕŸ
pт6½÷Ü;вVåΔĀÈ₄¤Ü³Aʒм5[¦PŠÅøœ^‚₆è³¦ìóV“LÛ'ßq;αÎΩªî»(2∍©däf×5 V5Ú”gÜ/\^(Ã∊Ƶ!3šÍ3°(§AÎ„ǝ₂È₅ç£6óàÖCsa*zƒÚ¥Î\ªD¹,n∊ðˆ.ëçPαǝƒ.É∍¯ü₂³Λ‘g∍Θþ“‚œΔи‹•b

Super boring. Just a compressed number. Uses 1 for - and 0 for +.
Try it online!

PHP, 276 Bytes
<?=gzinflate(base64_decode("dVJRFgMgCDoQj/tfb2+boqj9VJohQgQI8rv+D1yHuIIytGLsYh6vwAlYIMS62mVCiWMm56vfHiGOuTwjiMHQEC7OVlkNzzK0LZFTN8l0gavGdX4wOfJDsZpXZS0csig0l13wEsoRlvKzhYHMv+F9MnxaCXHWrC2Kx4UqQ8o4qmgNcsjbzA5lZG7LE6LdNMlt2sRKFpNhk/sL59N6DSMKp4No7vP2QcP0c2XWb6nPblqYfJBfHw=="));

Try it online!

Ruby, 245 bytes
puts"%b"%"28x0lphxjx8ze4uuhtdzo0oebr25amtmuxm62cbit0ibdwjm2sf50clh2ejq0a73ndseo5tove8uqca6nf66bo4abbkg867woh2b435at0o3pddvqmsqp29b6as5bd4eo28xgwkkj607gp66icba1q4n9fc13dltp45j340mpzbc56wsrbb3oejnczsbzfgh82xdi8aku8m4wlmwuxkgy4yaew7pu4p1g".to_i(36)

Output 0 for + and 1 for -.
Try it online!

Perl, 164 bytes
print unpack'b*','-Y²lÍ¢%O
[³bÙ²DËlY®pÉ±%§Ò-Y¶deJ-Ki¥%«Õ(O¬eÉòDO¶,Y¶,ÙÂeF[2/ÉcËlI·dÚl9cÃiÉ²53Ü;ãPÛ
gÙ,[¦TTët:lÆEK³,]¦NÙFkÓeÍ¢åP³lKòµNSjÜ'

Hexdump:
00000000: 7072 696e 7420 756e 7061 636b 2762 2a27  print unpack'b*'
00000010: 2c27 962d 59b2 6ccd a225 4f96 0d5b b362  ,'.-Y.l..%O..[.b
00000020: d9b2 44cb 966c 59ae 70c9 b125 a7d2 2d59  ..D..lY.p..%..-Y
00000030: b664 8e8b 654a 972d 4b96 69a5 9625 abd5  .d..eJ.-K.i..%..
00000040: 284f ac65 c9f2 444f b62c 59b6 2cd9 c265  (O.e..DO.,Y.,..e
00000050: 8e96 465b 322f c993 63cb 946c 49b7 64da  ..F[2/..c..lI.d.
00000060: 926c 3996 8d63 c369 c9b2 3533 dc0c 3be3  .l9..c.i..53..;.
00000070: 50db 0a67 d992 2c5b a654 8f9a 54eb 9474  P..g..,[.T..T..t
00000080: 3a96 6cc6 9a45 4bb3 2c5d a64e d992 466b  :.l..EK.,].N..Fk
00000090: 960b d39a 65cd a2e5 50b3 6c4b f218 b54e  ....e...P.lK...N
000000a0: 536a dc27                                Sj.'

The obvious, boring solution: just put all the bits in a binary string, 8 bits per byte. Uses 0 for - and 1 for +. I’ll try to golf this some more.

Retina, 333 bytes

ADG-RMCGHQFDLEM+-FAG-CADGPAKBBLHBCH-EGHJBORGEH-HB-FJOBPRCA+JAG-A+A+NJHQLIB-R+Q-OQPRAGP-HBEH-CGNCDGEH+BCCHQH-PDJCEGOGECDGCPK-FNH-EDLHCRIEELHDELEKE-HLJDDA+LHFGCFADJJBK+-JDCJBI+JCOOLGEDELMCGNAGKBEJKJEGCNCIF+BLECMMCAKLJDFDGCH+-E-JIQDJJNHD¶
R
GF
Q
+C
P
EA
O
CK
N
D-
M
I-A
L
--
K
D+
J
CB
I
A++
H
E+
G
AB
F
-AD
E
C+
D
B+
C
-B
B
-+
A
-++-+-

Try it online!

C (gcc), 416 bytes
f(i){for(i=1160;i--;)putchar(L"\x72ca563b\xd24f18ad\xa70acd36\x59a6b345\xd669d0cb\x729b4962\xcd34ba65\x6359a2d2\x2e5c6936\x592ad729\xda652af1\xe69b4934\xc70adb50\xcc3b30dc\x96934dac\x69b1c6c3\x5b49369c\x3692ed26\xc9c6d329\xda4cf493\xa6716962\x6d349b43\xf26d349a\xa6934f22\xab14f235\xa569a4d5\xb4d26996\xd1a652e9\x9a6d2671\xa4e54bb4\x750e938d\xd369369a\x469b4d22\x69b0dacd\xb345a4f2\xb49a4d36i"[i/32]>>i%32&1?43:45);}

Try it online!

Deadfish~, 2609 bytes
{iiii}iiiiicddcciicddciiccddcciicddcciicddciiccddciiccddcciicddciiccddciiccddcciicddciiccddcciicddcciicddciicddcciiccddcciicddciicccddciicddcciicddciiccddciiccddcccciiccddciiccddcciicddciiccddcciicddcciiccccddcciicddcciicddciicddcciiccddcciicddciicddciicccddcciicddciiccddcciicddcciicddciiccddcciicddciiccddciicccddciicddcciicddciiccddcciicddcciicddciiccddciiccddcciicddcciicddciiccddcciicddciiccddccciicddciicddciiccccddccciicddciiccddciiccddccciicccddcciicddcciicddciiccddciiccddccciiccddciicddciicddciiccddciicddccciicddcciicddciiccddciiccddcciicddciiccddcciicddcciicddciiccddciiccddcciiccddccciicccddccciicddciicccddcciicddciiccddcciiccddciicddciiccddciicddccciicddciiccddcciicddcciicddciiccddcciicddciiccddciiccddcciicddciiccddcciiccddciicddcciicddciicddciiccddciicddciicddcciicddciiccddcciicddciiccddciiccddcciicddciicddciicddcciicddciicddciicddcciicccddciicddciiccddcccciiccddciicccddcciicddciicddcciicddciiccddcciicddciiccddciiccddcciicddciiccddcccciiccddciicccddciicddcccciiccddciiccddcciicddcciicddciiccddcciicddciiccddciiccddcciicddciiccddcciicddcciicddciiccddcciicddciiccddciiccddcciicddcciicddciiccccddccciicddciiccddcciiccddccciicccddciicddcciicddciiccddciicddcciicccddciicddcciicddcciicddciiccddciiccddcciiccddcccciicddciiccddciiccddciiccddcccciiccddciiccddccciicccddcciicddcciicddciiccddcciiccddciicddciiccddciiccddcciicddcciicddciiccddciiccddciicddccciicddcciicddciiccddciiccddcciiccddciicddcciicddcciicddciiccddciiccddciiccddcciicddcciicddciiccddccciicccddcciicddciiccddcciicddcciicccddccciicccddcciicddcciiccccddccciiccddciicddcciicddciiccddciiccddcciicddciiccddcciicddcciicddciicddcciiccddcciiccddcciiccccddccciicddcciiccddcciiccccddcciicddccciiccddcciicccddccciiccccddciicddciicddcciicddcciicddcciicddciicddciiccccddccciiccddcciicddciiccddcciicddcciicddciiccddciiccddciiccddcciicddciiccddcciicddcciicddciiccddcciiccddciicddciiccddciicddciicddciicddcccciicccddciicddciicddcciiccddciiccddciicddciicddciicddcciicddciicddccciiccddciicddciiccddciiccddciicddccciiccddciicddccciicccddcciicddciiccddciiccddcciicddcciiccddcciicccddcciicddciicddcciiccddcciicddciicccddciicddcciicddciiccddciicddcciiccddcciicddciiccddcciicddciiccddciicddccciicddciiccddcciiccddciicddciicddccciiccddciicddciiccddcciicddcciicddciiccddciiccddciicddcciicccddciicddcciicddciicddcciiccddcciicddciiccddccciicddciiccccddcciiccddciicddcciicddciicddcciiccddcciicddciiccddcciicddciicddcciiccddcciicddciicccddciicddcciicddciiccddccciiccccddciicddciicddcciiccddcciicddciiccddcciicddcciicddcciicddciiccddciiccddciiccddcccciicccddcciicccddciicddciicddcciicddciicddccciiccddciicddcciiccddciicddciiccddciicddciicddcciicccddccciicddcc

Try it online!
Do I care that there's a sensible way to do this? No.

all_licenses: 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/


text:
Let's play POKE!
Poke is a really simple incomplete-information game. It's like "Poker", but simpler. At the start of every round, each player is dealt a hand. To simplify things, a hand is a uniformly distributed random number between 0 and 1. Each player only knows their own hand. The player that wins the round is the one whose hand has the greatest value.
Every turn, all the players who are still in the round make a bet that they're the player with the best hand. Each player has to decide whether or not to match the largest bet. If they match it, that amount is added to the pot from their account. If they choose not to match it, they drop out of the round. Even if they had the best hand, they can't win once they drop out, and they lose everything they had in the pot. At the end of the round, the player with the best hand out of those that haven't dropped wins. (Each player knows how many turns are gonna be in the round since the start of the round).
The winner is the one that makes the most money after a large number of rounds (hundreds, or thousands). In order to compete, write a struct that inherits from this "player" class:
class player
{
private:
    double _hand;
    game* _owner = 0;
public:
    //You must provide
    bool set_new_owner(game* current, game* new_owner) {
    if(current == _owner) { _owner = new_owner; return true; }
    return false;
    }
    bool set_new_hand(game* current, double new_hand) {
    if(current == _owner) { _hand = new_hand; return true; }
    return false;
    }
    double hand() const { return _hand; }
    virtual double bet(const round_info&) = 0;
    virtual bool take_bet(const round_info&) = 0;
    virtual std::string name() { return typeid(*this).name(); }
    virtual ~player() {}
};

All you need to do is specialize the "bet" function (which determines how much your player bets each turn), and the "take_bet" function (which determines whether or not to take the bet. Here are some examples:
struct grog : player
{
    //Always bets the minimum amount
    double bet(const round_info&) { return 1.0; }
    //Takes any bet
    bool take_bet(const round_info&) { return true; }
    string name() { return "Grog"; }
};
struct bob : player
{
    //Bet the minimum amount
    double bet(const round_info&) { return 1.0; }
    //Only take bets when you have a good hand
    bool take_bet(const round_info&) { return hand() > 0.95; }
    string name() { return "Bob"; }
};
struct james : player
{
    //Raise the bet a lot if you have a *really* good hand
    double bet(const round_info&) {
        if(hand() > 0.99) return 1000.0;
        else return 1.0;
    }
    //Only take bets when you have a *really* good hand
    bool take_bet(const round_info&) { return hand() > 0.99; }
    string name() { return "James"; }
};
struct rainman : player
{
    //Play it safe
    double bet(const round_info&) { return 1.0; }
    bool take_bet(const round_info& r)
    {
        double cost = r.current_max_bet();
        double winnings = r.winnings() + r.current_max_bet() * r.n_active_players();
        int players = r.n_players();
        double hand = this->hand();
        double p_win = pow(hand,players - 1);
        double p_loss = 1 - p_win;
        double gain = -(cost * p_loss) + p_win * winnings;
        if(gain > 0) return true;
        return false;
    }
    string name() { return "Rainman"; }
};

If all four people are playing, then over a few thousand games, James will be the winner and Rainman will do worse than anyone but Grog. But if only Bob, Grog, and Rainman are playing, Rainman will clean the floor with the  other players (and win tons of money).
Edit: Here is the code for round_info and for the class that will manage the game. https://github.com/Artifexian/PokeGame
Edit 2: If you submit something not in C++, I can try to translate it into C++ for you. If you want me to, I will edit your answer and append my translated version.
Edit 3: I will work to write a wrapper for non-c++ languages. Your solution must include 2 functions: something to determine how much to bet (which should return a floating point value), and something to determine whether or not to stay in the round (which should return true or false).  Contact me about your preferring input format. I will write something to translate "round_info" into text. The data provided as text will be the same data provided to everyone else. It will include:

The current turn number
The maximum number of turns (when the round ends)
The number of players
The number of players who haven't dropped out
The history of what each player has bet
A list of which players haven't dropped out
The size of the pot
The current maximum bet amount (what you have to put down to stay in the game)
Your hand

Edit 4: Any bets made by players will be clipped to be between 1 and 10^6

Could you make this not exclusive to C++? I know C++ can run system shell commands, could you change this to allow any programs that output to STDOUT, and take input from STDIN? I am interested in this challenge, but I only know javascript and node.js.

Write something in Javascript, and I'll translate it into it into C++ :)

what about other languages? java? python?

I know java and python, so I can also translate for those. Java is exceedingly similar to c++, and python is close enough.

Please do consider writing a wrapper, this challenge would be incredibly interesting if it was open to anyone.

Is the random number [0-1] uniform or gaussian?

It's Uniform! Sorry!

If I understood it correctly, you begin with 0 points and can bet any amout you want. So you could get negative without any problem.

ping @Poke ? Are you there?

Frequent Folder
The more players there are, the lower the odds of winning.  Thus, this player only takes bets when he thinks his hand is high, using the starting number of players as a guideline.
struct frequent_folder : player
{
    //Bets fairly heavily under same conditions a bet is taken
    //Bet varies based on how good hand is
    double bet(const round_info& r) {
        double numer = hand() - (1 - (1/r.n_players)), denom = 1 - (1 - (1/r.n_players));
        double qty = 250 * (numer/denom);
        return qty > 1 ? qty : 1.0;
    }

    //Take bet only if likely to have highest hand
    //e.g. 2 players -> 0.5+, 3 players -> 0.67+, 4 players -> 0.75+
    bool take_bet(const round_info& r) { return(hand() >= 1 - (1/r.n_players())); }

    string name() { return "Frequent Folder"; }
};

Bluffer
Where the Frequent Folder plays a very conservative strategy, the Bluffer lives on the edge.  He bets heavily with a hand he thinks can win... or a hand he knows will lose.  He takes favorable bets more often than he bluffs, hoping this will mean net gain, but the probability of a bluff is high enough that strategies analyzing previous bets may be thrown off by the Bluffer's erratic behavior.
struct bluffer : player
{
    //Bets hard with an excellent hand... or a very poor one!  Small bet otherwise
    double bet(const round_info&) { (return hand() > 0.9 || hand() < 0.05) ? 500.0 : 1.0; }

    //Take bet with an excellent hand... or a very poor one!
    bool take_bet(const round_info& r) { return(hand() > 0.9 || hand() < 0.05; }

    string name() { return "Bluffer"; }
};

These are my first entries on KotH as well as SE as a whole.  I hope everyone finds them up to snuff.

Gambling Russian
Simulates a person who is also playing Russian Roulette. There is a 1 in 6 chance he dies playing Russian Roulette, thus he will stop making bets once he has died. Every time he survives he gets so excited he bets as much as he possibly can because he believes he is on a good luck streak. If there is something smelly about my code let me know.
struct gambling_russian : player
{
  bool alive = true;

  double bet(const round_info&) { return DBL_MAX; };

  bool take_bet(const round_info&)
  {
    if(hand < (1.0/6.0)){
      alive = false;
    }
    return alive;
  }

  string name() { return "Gambling Russian"; }
}

I'll get this started with a simple player, who will randomly take bets based on the quality of his hand.
struct ronald : player
{
  double bet(const round_info&) { return fmax( 1.0, hand()*2 ); };

  bool take_bet(const round_info&)
  {
    double p = (double)rand() / RAND_MAX;
    return hand()>p;
  }

  string name() { return "Ronald"; }
}

The Thinker
struct theThinker: player
{
    //Raise the bet depending on hand value, but less if the pot has a lot already
    double bet(const round_info&) {
        double b = hand() * hand() * 1000.0 - round_info.winnings() / 10.0;
        return b > 1.0 ? b : 1.0;
    }
    //Take bets when the pot and hand look better than the amount you may loose
    bool take_bet(const round_info&) {
        return hand() * (round_info.winnings() + 1000.0) > current_max_bet();
    }
    string name() { return "The Thinker"; }
};


text:
Check if a given string is valid romaji
Your program is given a string consisting entirely of lowercase letters at STDIN (or closest alternative). The program must then output a truthy or falsey value, depending on whether the input is valid romaji.
Rules:

It must be possible to divide the entire string into a sequence of kana without any leftover characters.
Each kana can be a single vowel (aeiou)
Each kana can also be a consonant p, g, z, b, d, k, s, t, n, h, m, or r followed by a vowel. For example, ka and te are valid kana, but qa is not.
The exceptions to the above rule are that zi, di, du, si, ti, and tu are not valid kana.
The following are also valid kana: n, wa, wo, ya, yu, yo, ji, vu, fu, chi, shi, tsu.
If a particular consonant is valid before an i (i.e ki, pi), the i can be replaced by a ya, yu, or yo and still be valid (i.e kya, kyu, kyo)
Exceptions to the above rule are chi and shi, for which the y has to be dropped too (i.e cha, chu, cho, sha, shu, sho)
It is also valid to double consonants if they are the first character of a kana (kka is valid but chhi is not)
Shortest answer wins. All regular loopholes are disallowed.

List of all valid kana:
Can have double consonant:

ba, bu, be, bo, bi
ga, gu, ge, go, gi
ha, hu, he, ho, hi
ka, ku, ke, ko, ki
ma, mu, me, mo, mi
na, nu, ne, no, ni
pa, pu, pe, po, pi
ra, ru, re, ro, ri
sa, su, se, so,
za, zu, ze, zo,
da,     de, do,
ta,     te, to,
wa,         wo,
ya, yu,     yo,
    fu,
    vu
                ji

Can not have double consonant:

a, i, u, e, o,
    tsu,
chi, cha, cho, chu,
shi, sha, sho, shu,
n

Test cases
Pass:
kyoto
watashi
tsunami
bunpu
yappari

Fail:
yi
chhi
zhi
kyi

How do we win? Is this a code golf?

Need test cases. Also could do with a list of all valid kana instead of the rules

@RobertFraser both is preferred - test cases are not rules

If pa pi pu pe po are valid kana, then can't you simply group p with the other consonants?

I added all the kana, I think. Please tell me if I missed some.

@ValueInk good point, that makes it easier to understand

"If a particular consonant is valid before an i (i.e ki, pi), the i can be replaced by a ya, yu, or yo and still be valid (i.e kya, kyu, kyo)" The list seems to be missing these for "h", and "p"

The list is missing all doubled consonant variants. Is chchi valid or not (i.e. is ch considered a character)?

I've updated list of valid kana, but n needs clarification

n cannot be doubled. I know enough about the Japanese alphabets to say that. If n was doubled, it would need to have a vowel after, but then it wouldn't be n. So if kanna was a word (just making it up), it'd actually be ka n na.

You know, I wanted to make a solution using unicodedata, but it'll definitely be longer than a regex solution. Partial program

@mbomb007 Does it output vowels twice intended?

@DeadPossum This isn't a solution. If I were going to use it, I'd be checking if the list contains something.

Ruby, 96 149 bytes
Regex solution to match all the valid kana. Interestingly, "ecchi" is not valid according to the current rules, but perhaps it's for the best.
->s{s.gsub(/(?![dt]u)(sh|ch|([gbknhmrp])\2?y?|([zdst])\3?)?[auo]|(\g<2>)?\4?[ie]|(\g<3>)\5?e|ww?[ao]|n|tsu|([fv])\6?u|jj?i|j?y?[aou]|yy[aou]/){}==""}

Try it online! feat. Cruel Angel's Thesis

It failes on simple tests zi and zye

@DeadPossum fixed.

Python 2, 166 bytes
Long regex solution
Try it online
I think that f-strings from 3.[something] python can help to shorten it by replacing repeated [auo and {1,2}.
Unfortunatetly I can't check it by myself now :c
import re
lambda x:re.sub('[bghkmnpr]~([auoei]|y[auo])|[sz]~[auoe]|[dt]~[aeo]|w~[ao]|([fv]~|ts)u|(j~|[cs]h)(i|y[auo])|y~[auo]|[auoien]'.replace('~','{1,2}'),'',x)==''

re.sub('~','{1,2}',(your regex) is shorter than (your regex).replace('~','{1,2}') by 1 byte.

Your regex is also failing on a simple test case: bku. Doubled consonants have to be the same consonant.


text:
Who has a comma for a middle name?
Your challenge is to take a name (string) as input, like
Albert Einstein

and output:
Einstein, Albert

Pseudocode:
set in to input
set arr to in split by " "
set last to the last element of arr
remove the last element of arr
set out to arr joined with " "
prepend ", " to out
prepend last to out
output out

More test cases:
John Fitzgerald Kennedy => Kennedy, John Fitzgerald
Abraham Lincoln => Lincoln, Abraham

Rules

The input will always match the regex ^([A-Z][a-z]+ )+([A-Z][a-z]+)$.
You don't need to handle weird names, even if the output is technically incorrect it is fine here.
Trailing whitespace / newline is OK.
Any questions? Comment below!

Are trailing spaces allowed?

I closed as dupe because solutions can pretty much siply replace le with , and you have this question

@Downgoat That challenge specifies two words, whereas solutions to this have to work for arbitrarily many words. As far as I can tell, of the answers with TIO links, only the Seriously solution gives the correct answer for this question substituting le with ,.

@Downgoat that one has -4. At least close that one as a dupe of this.

Are trailing spaces ok?

@TomCarpenter yes, they are.

@ngenisis that's not how duplicates work. These two questions are a textbook example of duplicates. I can drop in one more thing but they are still basically just the same challenge. Being duplicate isn't bad thing at all ether

Possible duplicate of Convert phrases to reverse style

@WheatWizard https://codegolf.stackexchange.com/questions/122322/who-has-a-comma-for-a-middle-name?noredirect=1#comment300099_122322

I still believe that it's a duplicate, however this challenge is better written and better received, so I have closed the old challenge as a duplicate of this one.

"The general rule is to keep the question with the best collection of answers, and close the other one as a duplicate."

Can we assume last names have at least 2 characters?

@Kevin yes, otherwise it wouldn't match the regex.

Ah yes, didn't notice the regex.

Johnny Comma Lately?

05AB1E, 7 bytes
Code:
',ì#Áðý

Uses the 05AB1E encoding. Try it online!
Explanation:
',ì         # Prepend the input to ","
   #        # Split on spaces
    Á       # Rotate every element one position to the right (wrapping)
     ðý     # Join the array by spaces

Prepend! I knew there had to be a way to do it in listform.

JavaScript (ES6), 34 bytes
s=>s.replace(/(.+) (.+)/,'$2, $1')

Demo:

let f = s=>s.replace(/(.+) (.+)/,'$2, $1')

;[ 'Albert Einstein', 'John Fitzgerald Kennedy', 'Abraham Lincoln' ].forEach(
  s => console.log(`${s} => ${f(s)}`)
)

Retina, 19 17 16 bytes
Edit: Thanks to Riker for saving 3 bytes
(.+) (.+)
$2, $1

Try it online!

hold up, (.+) works too for both.

I don't understand why you were using \w in the first place

@theonlygusti I'm more familiar with pattern matching in Mathematica, which uses lazy matching rather than greedy.

V / vim, 9 8 bytes
$bD0Pa,

Try it online!
Saved one Byte thanks to
Note there is a trailing space character. Leaves a trailing space, which is allowed per the rules.
Explanation:
$       " move the cursor to the end of the line
 b      " move the cursor to the beginning of the current word
  D     " delete to the end of the line
   0    " move the cursor to the start of the line
    P   " paste in front of the cursor.
     a  " append (enter insert mode with the cursor one character forward)
      , " Literal text, ", "

Nice one! Good thinking putting the insert mode at the end to avoid needing <esc>. You can save one byte by doing $bD instead of $diw. :)

Thanks. $bD doesn't handle one-character names though, I've asked OP if that's allowed.

Looks like it is, so updating.

Jelly, 7 bytes
;”,Ḳṙ-K

Try it online!
I don't know Jelly very well, but reading other answers it looked like they didn't use an optimal algorithm... so here it is:
Explanation
;”,Ḳṙ-K
;”,        Append a comma to the end of the string
   Ḳ       Split on spaces
    ṙ-     Rotate the array by -1 (1 time towards the right)
      K    Join with spaces

Mathematica, 52 40 bytes
StringReplace[x__~~" "~~y__:>y<>", "<>x]

Python 2, 39 bytes
f,l=input().rsplit(' ',1);print l+',',f

Try it online!
Yup, rsplit.

@UbdusSamad We allow Python's input instead of raw_input for golfing - see this meta post

Vim, 10 bytes/keystrokes
v$F dA, <esc>p

Try it online!

Nice one, but I struggled to get it working, <esc> doesn't show up in your code. For notice to others who want to try: This assumes that the name is written in the editor and that you're currently at the beginning of the file in normal mode.

C, 45 bytes
EDIT: I just now noticed the requirement for the input possibly having more than two words. I'll leave it as-is with a note that this only works for two words.
EDIT: removed \n. Add 2 bytes if you consider it necessary.
main(a,b)int**b;{printf("%s, %s",b[2],b[1]);}

Compiles with gcc name.c, GCC 6.3.1. Ignore warnings. Usage:
$./a.out Albert Einstein
Einstein, Albert

Abuse of language:

Implicit return type int of main and nothing returned.
Implicit declaration of printf. GCC will include it anyway.
Wrong type of b. Doesn't matter with %s

Thanks to @Khaled.K for the tips on using main(a,b)int**b; rather than main(int a, int **b).

Nice first golf, welcome to the website, also main(a,**b){printf("%s, %s",b[2],b[1]);} is 40 bytes

Thanks :) I actually thought about omitting the types completely, but for some reason it wouldn't compile.

This works main(a,b)int**b;{printf("%s, %s\n",b[2],b[1]);}

><>, 27 bytes
i:0(?v
" ,"~<^r/
=" ":}o!/?

Try it online!

Ruby, 22 bytes
->s{s[/\w+$/]+", #$`"}

Try it online!

C, 68 bytes
Hope it's not wrong to add another post but here's a slightly different solution than my previously posted C solution. This one accepts any number of names.
main(a,b)int**b;{for(printf("%s,",b[--a]);--a;printf(" %s",*++b));}

Compile with gcc name.c (GCC 6.3.1) and ignore warnings. Usage:
$./a.out John Fitzgerald Kennedy
Kennedy, John Fitzgerald

Thanks to @Khaled.K for the tips on main(a,b)int**b;
Thanks for the tip on the for loop to @Alkano.

you can gain 2 bytes, by using for instead of while
main(a,b)int**b;{for(printf("%s,",b[--a]);++b,--a;printf(" %s",*b));}

This sounds crazy, but you can do this main(a,b)int**b;{a&&printf("%s,"b[a-1])&&main(a-1,b);}

Very nice tricks :) I never thought about calling main recursively. But it doesn't quite work. It's output was "Kennedy,Fitzgerald,John,./a.out," A partial solution would be main(a,b)int**b;{--a&&printf("%s, ",b[a])&&main(a,b);}. It's 2 bytes shorter, and it makes sure you don't print the program name, but it still uses comma between each name.

sed, 19 + 1 for -E = 20 bytes
s/(.*) (.*)/\2, \1/

Must use -r (GNU) or -E (BSD, recent GNUs) to avoid having to escape the grouping parenthesis.
If written on the command-line, must be enclosed in quotes to avoid being parsed as multiple tokens by the shell :
sed -E 's/(.*) (.*)/\2, \1/'

Mathematica, 45 bytes
#/.{a__,s=" ",b__}/;{b}~FreeQ~s->{b,",",s,a}&

Saved a few bytes over ngenisis's answer by taking input as a list of characters rather than as a string. Pure function that uses a pattern-replacement rule.
Mathematica, 49 bytes
#~Join~{","," "}~RotateLeft~Last@Position[#," "]&

Another pure function taking a list of characters as input and returning a list of characters. This one appends "," and " " to the input and then rotates the list of characters until the last space is at the end. (Thus the output has a trailing space, unlike the first function above.)

#/.{a__,s=" ",b:Except@s..}->{b,",",s,a}& is 4 bytes shorter, but I found out that the Except is unnecessary for string patterns, saving me 12 bytes.

ah, does it automatically choose the longest x in your answer?

Yep, string pattern matching is greedy but regular pattern matching is lazy.

nice

C#, 76 72 bytes
s=>System.Text.RegularExpressions.Regex.Replace(s,"(.+) (.+)","$2, $1");

Saved 4 bytes with the help of @KevinCruijssen
Old version using substrings for 76 bytes:
s=>s.Substring(s.LastIndexOf(' ')+1)+", "+s.Substring(0,s.LastIndexOf(' '));

Too bad System.Text.RegularExpressions.Regex is so damn long in C#.. s=>new System.Text.RegularExpressions.Regex("(.+) (.+)").Replace(s,"$2, $1"); is just one byte more.

@KevinCruijssen True but I can use the static method on Regex to save 4 bytes

Awk, 18 characters
{$1=$NF", "$1}NF--

Sample run:
bash-4.4$ awk '{$1=$NF", "$1}NF--' <<< 'John Fitzgerald Kennedy'
Kennedy, John Fitzgerald

Try it online!

JS (ES6), 52 44 bytes
i=>(i=i.split` `,l=i.pop(),l+", "+i.join` `)

Jelly, 8 bytes
Ḳ©Ṫ”,⁶®K

Try it online!

Damnit, Ninja'd and outgolfed.

@ATaco gg :) and that is a pretty big ninja.

(I was golfing, shhh)

Jelly, 9 bytes
ḲµṪ;⁾, ;K

Explained, ish:
ḲµṪ;⁾, ;K
Ḳ           # Split the input by spaces
 µ          # Separate the link into two chains. Essentially calls the right half with the split string monadically.
  Ṫ         # The last element, (The last name), modifying the array.
   ;        # Concatenated with...
    ⁾,      # The string literal; ", "
       ;    # Concatenated with...
        K   # The rest of the array, joined at spaces.

Try it online!
Try on all test cases.

Java, 110 62 bytes
String d(String s){return s.replaceAll("(.+) (.+)","$2, $1");}

Non-static method.
-48 bytes thanks to Kevin Cruijssen

String c(String s){int i=s.lastIndexOf(' ');return s.substring(i+1)+", "+s.substring(0,i);} is shorter (91 bytes).

And String d(String s){return s.replaceAll("(.+) (.+)","$2, $1");} is even shorter (62 bytes).

@KevinCruijssen Oh geez nice. Thanks! I should learn to use regex better :P

05AB1E, 9 bytes
#`',«.Áðý

Try it online!
Explanation
#           # split input on spaces
 `          # push each name separately to stack
  ',«       # concatenate a comma to the last name
     .Á     # rotate stack right
       ðý   # join stack by spaces

Yeah, I should probably make a join by space command :p

@Adnan: Would be nice seeing how often it's used :)

PHP, 62 59 bytes

-3 bytes, thanks Jörg
$a=explode(' ',$argn);echo array_pop($a).', '.join(' ',$a);

Try it online!
Old solution, 63 Bytes
Doesn't work if the person has 3 repeating names.
<?=($a=strrchr($argv[1]," ")).", ".str_replace($a,'',$argv[1]);

Try it online

You can use $argn instead of $argv[1]

MATLAB/Octave, 37 bytes
@(a)regexprep(a,'(.+) (.+)','$2, $1')

Try it online!
Based on @ngenisis' Retina answer, we can also play the regex game in both Octave and MATLAB, saving a fair few bytes over my previous answer.

Old Answer:
I'm going to leave this answer here as well considering it is a more unique way of doing it compared to a simple regex.
Octave, 49 47 bytes
@(a)[a((b=find(a==32)(end))+1:end) ', ' a(1:b)]

Old try it online!
An anonymous function to generate the output.
Basically the code first finds the last space in the string using b=find(a==32)(end). Then It takes the end part of the string (after the space) using a(b+1:end), where b is the output of finding the last space. It also takes the start of the string with a(1:b-1), and concatenates both together with a ', ' in between.
I've already saved a few bytes vs the typical find(a==32,1,'last'). Not quite sure there is much more to save.

PHP, 45 Bytes
<?=preg_filter("#(.*) (.+)#","$2, $1",$argn);

Try it online!

Why \pL+ instead of .+?

@KevinCruijssen You are right the first part of the regex is greedy so it does not matter to use . or \pL

Pyth, 11 bytes
jd.>c+z\,d1

Explanation:
jd.>c+z\,d1
     +z\,      Append the "," to the input
    c+z\,d     Split the string on " "
  .>c+z\,d1    Rotate the array one element right
jd.>c+z\,d1    Join the array on " "

Test it online!

Python 3, 52 bytes
lambda s:s.split()[-1]+", "+" ".join(s.split()[:-1])

Very simple, could use golfing help. Just puts the last word at the front and joins them with ", ".
Testcase:
>>> f=lambda s:s.split()[-1]+", "+" ".join(s.split()[:-1])
>>> f("Monty Python")
'Python, Monty'
>>> f("Albus Percival Wulfric Brian Dumbledore")
'Dumbledore, Albus Percival Wulfric Brian'

Bash, 26 bytes
echo ${!#}, ${@:1:$[$#-1]}

Try it online!

Excel, 174 170 168 bytes
Saved 2 bytes thanks to Wernisch
=MID(A1,FIND("^",SUBSTITUTE(A1," ","^",LEN(A1)-LEN(SUBSTITUTE(A1," ",""))))+1,LEN(A1))&", "&LEFT(A1,FIND("^",SUBSTITUTE(A1," ","^",LEN(A1)-LEN(SUBSTITUTE(A1," ","")))))

This is not fancy or clever. It's a fairly basic method. It feels like there should be a shorter way with array formulas but I can't find one that works.

Solution only works for cases where there three names.  Does not handle "Albert Einstein" for example.

@Wernisch Thanks! It should work now.

Trailing whitespace is allowed according to question.  Think you can save 2 bytes by leaving out the the -1 in the LEFT function.

Japt, 14 bytes
U+', q'  é q'

A port of @programmer5000's JavaScript answer.
Try it online!

Perl 18+1=19 bytes
perl -pe '/\S+$/;$_="$&, $`"'

+1 for -p

Vim, 6 keystrokes
i<C-p>, <End><C-w>

Leaves a trailing space character, which is allowed by the rules

Explanation:

i      Enter insert mode
<C-p>  Autocomplete with last word
,      Write ", "
<End>  Move the cursor to the end of the line
<C-w>  Delete the word behind the cursor

Thunno 2 Ṡ, 5 bytes
',+OṾ

Try it online!
Explanation
',+OṾ  '# Implicit input
',+    '# Append a ","
   O    # Split on spaces
    Ṿ   # Rotate right
        # Join by spaces
        # Implicit output

Nibbles, 7.5 bytes
*" "::`(\%$~","\

Attempt This Online!

Vyxal S, 38 bitsv1, 4.75 bytes
\,+⌈ǔ

Try it Online!
I do not have a comma for a middle name. Ports Thunno 2 but with a range coder.
\,+⌈ǔ
\,+    # Append a comma
   ⌈   # Split on spaces
    ǔ  # Rotate right once
# The S flag joins on spaces

Created with the help of Luminespire.

Python 3, 52 51 bytes:
k=input().split()
print(k[-1]+',',' '.join(k[:-1]))

-1 byte thanks to ovs

Ruby, 26+1 = 27 bytes
Uses the -p flag for +1 byte. Probably can be redone shorter in Retina. And it was!
-1 byte from Kevin Cruijssen.
gsub /(.+) (.+)/,'\2, \1'

Try it online!

gsub /(.+) (.+)/,'\2, \1' is one byte shorter.

MATL, 10 bytes
44hYb1YSZc

Try it online!
Explanation
44h    % Implicitly input a string. Postpend a comma
       % STACK: 'John Fitzgerald Kennedy,'
Yb     % Split on spaces
       % STACK: {'John', 'Fitzgerald', 'Kennedy,'}
1YS    % Circularly shift 1 step to the right
       % STACK: {'Kennedy,', 'John', 'Fitzgerald'}
Zc     % Join with spaces between. Implicitly display
       % STACK: 'Kennedy, John Fitzgerald'

R, 90 bytes
function(s){b=el(strsplit(s,' '))
l=length(b)
paste0(b[l],', ',paste(b[-l],collapse=' '))}

Anonymous function. Takes the string, splits it, outputs the last name, a comma, and the rest of the names from the beginning. Would love to see something better, I'm not too good at manipulating strings in R.

SNOBOL4, 77 bytes
begin
 input arb . f span(&lcase &ucase) . l rpos(0)
 output = l ', ' f
end

This is a pretty straightforward case of pattern matching.

Read a line of input, then match it against:
arbitrary characters (which we'll assign to f), followed by
a span of upper- and lower-case letters (which we'll assign to l) which
matches to the end of the input (rpos(0)).

Having matched those, we write out l, comma and space, f.

Gema, 23 characters
* =@append{s; *}
\Z=,$s

The only remarkable thing here is how the challenge managed to hit the weakness of the Gema patterns non-greediness.
Sample run:
bash-4.4$ echo -n 'John Fitzgerald Kennedy' | gema '* =@append{s; *};\Z=,$s'
Kennedy, John Fitzgerald

jq, 39 38 characters
(35 34 characters code + 4 characters command line options)
./" "|last+", "+(.[:-1]|join(" "))

Sample run:
bash-4.4$ jq -Rr './" "|last+", "+(.[:-1]|join(" "))' <<< 'John Fitzgerald Kennedy'
Kennedy, John Fitzgerald

Try in jq‣play
jq, 43 characters
(39 characters code + 4 characters command line options)
sub("(?<f>.+) (?<l>.+)";"\(.l), \(.f)")

Just a curiosity: jq only captures named groups, which helps readability, but nothing else.
Sample run:
bash-4.4$ jq -Rr 'sub("(?<f>.+) (?<l>.+)";"\(.l), \(.f)")' <<< 'John Fitzgerald Kennedy'
Kennedy, John Fitzgerald

Try in jq‣play

Scala, 65 bytes
(s:String)=>{val n=s.split(' ');n.last+", "+n.init.mkString(" ")}

Carrot, 56 bytes
#^//\w+$|^.+(?= )/gS";"^ ^*1//;.+(?=;)/S0-1//^\w+| .+$/g

Try it online!
Explanation
Carrot has several global variables, one for each type: string, float and array. The program starts in string-mode, where all the operators will affect the global string variable. And I call these variables the "stack".
Example input is John Fitzgerald Kennedy.
#^                       Set stack-string to the value of the input string
/                        Operator, get matches of this regex on the stack-string and store the matches in stack-array
 /\w+$|^.+(?= )/g        The last name or the first names
S";"                     Convert to string-mode by joining on ";"
                         stack-string = "John Fitzgerald;Kennedy"
^ ^                      Append a space to the stack-string
*1                       Append one copy of the stack-string to itself
                         stack-string = "John Fitzgerald;Kennedy John Fitzgerald;Kennedy "
/                        The match operator
 /;.+(?=;)/              Anything bounded by ";"s except for the last ";"
S0                       Since we are guaranteed to get one match, we can join with any literal, it does not matter. Here we are joining using a 0.
-1                       Remove the first character in the stack-string (the first ";")
                         stack-string = "Kennedy John Fitzgerald"
/                        The match operator
 /^\w+| .+$/g            The first word or the last ones
                         stack-array = ["Kennedy", " John Fitzgerald"]

Luckily for us, the interpreter is bad and displays the result as just Kennedy, John Fitzgerald.

PowerShell, 35 Bytes
simple regex solution, not too interesting:
"$args"-replace'(.+) (.+)','$2, $1'

Aceto, 21 17 bytes
,p p
'@'p
pQ$d
r-

I'm sure we can fit this into a 4x4, but I just couldn't do it..
Reads a value, splits it on whitespace, "unqueues" it (a b c -> c a b), prints the first element, prints a comma, sets a catchmark.
Prints a space and the next element (i.e. the first given name). Duplicate the top stack element (a zero if we're done, otherwise the next given name). If that value is truthy (i.e. not 0), jump to the catch mark.

PHP, 49+1 bytes
<?=preg_replace("#^(.*) (\w+)$#","$2, $1",$argn);

Run as pipe with -nF.


text:
Simulate Rocket League Quick Chat
In Rocket League, there are controls assigned to quick chat. For PC, they are
1, 2, 3, and 4. To use a quick chat, you must press two controls. For example, the first option would be 1, 1.
You will be simulating the Rocket League client. You will be given a non-empty list composed only of four characters of your choosing. The length of the list will always be even and <= 8. I will be using 1, 2, 3, 4 for the examples. If you modify the input domain, you must specify how your input maps to 1, 2, 3, 4.
The first character in each couplet specifies the section, the second the item in the section. Below are all sections, with their default chat:
1
 1 I got it!
 2 Need boost!
 3 Take the shot!
 4 Defending...

2
 1 Nice shot!
 2 Great pass!
 3 Thanks!
 4 What a save!

3
 1 OMG!
 2 Noooo!
 3 Wow!
 4 Close one!

4
 1 $#@%!
 2 No problem.
 3 Whoops...
 4 Sorry!

The above are case sensitive. So, 1 1 would be I got it!, and 3 3 would be Wow!.
In addition, after three quick chats come through rapidly, the game shots you down. You get a message back: Chat disabled for 2 seconds.. If you continue trying, you get one more chance, and then Chat disabled for 4 seconds.. Our challenge will not deal with time, or any further chats.
However, after three chats (6 input characters), you must output Chat disabled for 2 seconds.. After four chats (8 input characters), you must output Chat disabled for 4 seconds.. Since 8 is the maximum input length, that would be your final output, if they are 8 input characters.
Input
First, chose your four characters, and map them to 1, 2, 3, 4.
Your input will be non-empty, contain an even number of items, and only contain up to eight items.
Output
You will output the matching quick chats in order, plus any chat disabled warnings (in the correct location). Output is case sensitive. It must be delimited - suggested delimiters are \n (pretty delimiter) or ,, and you cannot use any delimiters in any of the possible outputs.
Test Cases
In these, input is in the form of a JSON list and can be 1, 2, 3, 4, and the output delimiter is ,.
[1, 1, 1, 1] => I got it!,I got it!
[2, 4, 4, 4] => What a save!,Sorry!
[3, 3] => Wow!
[1, 4, 2, 3, 4, 1, 4, 4] => Defending...,Thanks!,$#@%!,Chat disabled for 2 seconds.,Sorry!,Chat disabled for 4 seconds.

Invalid (out of scope) inputs:
[] //empty
[1, 3, 1] //odd length
[5, 4] //character out of input domain
[1, 2, 3, 4, 1, 2, 3, 4, 1] //length > 8

To ensure the point is made: you are not taking these in real time, like in the game. You are just receiving a (short) list of numbers.

Possible duplicate, though I am in favor of closing the old one as a duplicate of this.

@ConorO'Brien oh, didn't see that. They are kinda different, since mine is multiple inputs. We'll see what the community thinks. Guess I shoulda posted this to Sandbox after all :/

It's fine. I personally like this challenge better (being the writer of the aforementioned challenge). The concept is essentially the same, with the only difference being multiple inputs and the lack of a bonus. The latter, at least, is good.

@StephenS opps sorry. Forgot I had insta edit

@Christopher oh right, no problem. I have to get used to that too :)

Shouldn't 4 3 be Whoops... not Wow!?

Is the input limited to a list of characters, i.e. a string? Or may it be a list of integers? Everything looks like integers, but you say characters.

@musicman523 I've edited the input of this example

@JonathanAllan you can do whatever you want. I say characters because you can change the input domain if you want. You can accept a string list or an int list.

Jelly, 153 150 bytes
⁶;j@“Kẋ3ŒK!D“¿ṁxṁị»Wḣ
J_2ḤÇ€
s2ḅ4ị“w eɲEƓṫ:⁾ṆƙḅƙḣḊṗṠ,`ė)®=Œf°Ẇŀ#ḍḤḌCṭ8v⁻$ʠṄṾŻYtṫʠßR>ĊḷḊc8Þ@Zq8-@⁻⁺ ḃḊĿ`ÆYƒðḤ|3ƓULẇẇŻịỵ1²ṄE'Cṣ\{ṣ{ḃ⁵ḳpẸz.4<»Ỵ¤µżÇ;/ȦÐfY

Input is a list of integers, where 0, 1, 2, and 3 represent 1, 2, 3, and 4 respectively.
Output is a newline separated print out.
Try it online!
How?
There is a compressed string taking up 105 bytes:
“w eɲEƓṫ:⁾ṆƙḅƙḣḊṗṠ,`ė)®=Œf°Ẇŀ#ḍḤḌCṭ8v⁻$ʠṄṾŻYtṫʠßR>ĊḷḊc8Þ@Zq8-@⁻⁺ ḃḊĿ`ÆYƒðḤ|3ƓULẇẇŻịỵ1²ṄE'Cṣ\{ṣ{ḃ⁵ḳpẸz.4<»
= "Need boost!\nTake the shot!\nDefending...\nNice shot!\nGreat pass!\nThanks!\nWhat a save!\nOMG!\nNoooo!\nWow!\nClose one!\n$#@%!\nNo problem.\nWhoops...\nSorry!\nI got it!"

(Somewhat shockingly 1 byte was saved by including all the ! rather than inserting them via code.)
The program then works as follows
⁶;j@“Kẋ3ŒK!D“¿ṁxṁị»Wḣ - Link 1, get a disabled string: number, seconds
⁶                     - space character
 ;                    - concatenate with seconds (e.g. " 4")
    “Kẋ3ŒK!D“¿ṁxṁị»   - compressed list of strings ["Chat disabled for"," seconds"]
  j@                  - join (swap @arguments)  (e.g. "Chat disabled for 4 seconds"
                   W  - wrap in a list
                    ḣ - head to seconds (for -2 and 0 gives an empty list, for 2 and 4 give the string wrapped in a list)

J_2ḤÇ€ - Link 2, get disabled strings: list of chat strings
J      - range of length (e.g. for 4 chat strings [1,2,3,4])
 _2    - subtract 2      (...[-1,0,1,2])
   Ḥ   - double          (...[-2,0,2,4])
    Ç€ - call last link (1) as a monad for €ach

s2ḅ4ị“...»Ỵ¤µżÇ;/ȦÐfY - Main link: list of characters
s2                    - split into twos
  ḅ4                  - convert from base four (vectorises)
           ¤          - nilad followed by link(s) as a nilad:
     “...»            -   compressed string described in code-block above
          Ỵ           -   split on newlines
    ị                 - index into (use the base four representation to get the chat strings)
            µ         - monadic chain separation (call that x)
              Ç       - call last link (2) as a monad
             ż        - zip
               ;/     - flatten list by one level
                  Ðf  - filter keep if:
                 Ȧ    -   any and all (false for empty results, i.e. the empty results from link 2)
                    Y - join with newlines
                      - implicit print

List of ints is allowed.

JavaScript, 264 bytes
f=([x,y,...z],n=.5)=>"I got it!,Need boost!,Take the shot!,Defending...,Nice shot!,Great pass!,Thanks!,What a save!,OMG!,Noooo!,Wow!,Close one!,$#@%!,No problem.,Whoops...,Sorry!".split`,`[x*4+y-5]+(n>1?`,Chat disabled for ${n} seconds.`:'')+(z[0]?','+f(z,n*2):'')


text:
Make a +-#$%! interpreter
Because we haven't had enough of these, let's do another weird language!

+ increments the accumulator
- decrements the accumulator
# outputs the character with the codepoint of the accumulator modulo 127, and then resets the accumulator
$ is like # but it doesn't reset the accumulator
% reads a single character of input and then set the accumulator to that. If it is EOF, exit the program
! sets the accumulator to 0

At the end of the program, if the accumulator is 0, exit, otherwise, start again from the beginning, preserving the accumulator state.
Note that this language has no implementation so it is defined by this post.
Challenge
Given a valid +-#$%! program (containing only those characters) and the program input (containing only printable ASCII characters), return its output.
Examples
program, input -> output // comments
%$, hello -> hello // CAT program
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#++++++++++++++++++++++++++++++++#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#, -> Hi there
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$+++++++++++++++++++++++++++++++++$++++++++++++++++++++++++++++++++++++++++++++++++++++++$++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$+++++++++++++$++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++$!, -> Hi there

I promise you this is the last similar challenge you'll see from me for a long time.

so many "languages" even w/o turing complete...

Shouldn't the + be a ;?

Also it's so great that all three ;# challenges are in the HNQ at the same time

Can we take the input for the program as list of characters?

Next time, at least add some kind of control flow statements.

Please rename this to 'Make a +-#$%! interpreter' to keep consistent. :P

I'm kinda getting tired of these...

If your going to make a language, make it Turing Complete.

@tsh Just meant to be simple :)

@RandomUser In the original one it was but now it's not :p

@ovs Sure, you may.

@Sanchises I've decided to not make a next time because people (cc programmer5000) are getting tired of these.

@totallyhuman Okay sure :P

@programmer5000 Okay sorry. I promise this is the last of these from me. No guarantees about other people :P

@mbomb007 Again, just meant to be simple, but I am currently making a language that will hopefully be TC :P

@HyperNeutrino oh come on! People can't be getting tired of this already, I'm nearly ready to release my new language, +p!  :)

><>, 112 bytes
You may be thinking "Is ><> really the best language to write an interpreter in?", to which my answer is "no, but let's try anyway!"
i:}b(?v
0(?;v0<o}\.24;!?:}\    /}~51. /}1-32./}1+32./}~i:
6*bb< o:}\?="#":  \?(b:\?="!":\?="-":\?="+":\?="%":$%+

Try it online, or at the fish pond!
Takes input from STDIN: first the +-#$%! code, then optionally a newline and any extra input.
This could do with some explanation.

The first loop is i:}b(?v. This reads from STDIN to the stack until it hits a character less than b = 11, which means either a newline (charcode 10) or EOF (charcode -1).
Once that's done, the fish swims down…
  v
v0<
<

…into the main loop, adding a 0 to the stack to use as the accumulator.
First, the fish sees bb*6+% — this computes 127 = 11*11+6 and takes the modulus of the accumulator. Then $ brings forward the first character from the stack.
Now, we get to the bulk of the code — reading the character. There are seven branches in this bit of the code. (I think I've tetrissed the branches as much as I can, but there might be more blank space that can be removed here.)
0(?;                                       /}~i:
                                           \?="%":

Note that the fish starts from the bottom right, moving left, and wraps when it hits the side of the code. If the character is a literal "%", we shift it to the back of the stack for safekeeping, delete the accumulator, replace it with the first character in STDIN, check if that's EOF (that is, if its charcode is negative), and end the program if so. We then hit the start of the main loop again.
                             /}1-32./}1+32.
                             \?="-":\?="+":

If the character is "+", we put it on the back of the stack again, add 1 to the accumulator, and jump to the start of the main loop. The "-" case is similar.
                      /}~51.
                      \?="!":

If the character is "!", delete the accumulator and jump to just before the start of the main loop, where we first created the accumulator by adding a 0 to the stack.
         .24;!?:}\
                 \?(b:

If the character is EOF or newline, check if the accumulator is 0, and terminate the program if so; otherwise, jump back to the start of the main loop. We kept all the used characters on the stack, so now we're back at the start of the program anyway.
      o}\
        \?="#":

If the character is "#", output the accumulator as a character. We're then conveniently back just before the main loop, where we created the accumulator with a 0.

     o:}

If we've reached this branch, the character can only be "$", since the stack only contained the characters +-#$%! and EOF or linefeed. Therefore we print a copy of the accumulator, and we're back at the start of the main loop.

why is 'fish playground' not called 'fish pond' instead?

@Orangesandlemons: I don't know, but I'm going to call it that anyway!

Well this somehow beats the Python answer. Nice.

Python 2, 186 bytes
p,i=input()
a=0;f=1;r=''
while a^f:
 f=0
 for c in p:
	if c in'#$':r+=chr(a%127);a=a*(c>'#')
	if'%'==c:
	 if i:a=ord(i[0]);i=i[1:]
	 else:a=0;break
	a+=(c=='+')-(c>'+')-a*(c<'"')
print r

Try it online!

Well, it seems that you don't need f.

@EriktheOutgolfer this will break when the accumulator gets negative

why not a*=c<'#'?

Pyth, 89 bytes
KwJ1WJ=J0FHKIqH\+=+J1)IqH\-=-J1)IqH\#pC%J127=J0)IqH\$pC%J127)IqH\!=J0)IqH\%IqzkB=JChz=ztz

Takes the input in the first line and the output in the second. It's just a simple for loop over the input with some ifs. I'm sure it could be much shorter, but i don't care enough right now.
Try it!
Python code it compiles to:
assign('z',input())
assign("K",input())
assign("J",1)
while J:
 assign('J',0)
 for H in num_to_range(K):
  if equal(H,"+"):
   assign('J',plus(J,1))
  if equal(H,"-"):
   assign('J',minus(J,1))
  if equal(H,"#"):
   Pprint(Pchr(mod(J,127)))
   assign('J',0)
  if equal(H,"$"):
   Pprint(Pchr(mod(J,127)))
  if equal(H,"!"):
   assign('J',0)
  if equal(H,"%"):
   if equal(z,k):
    break
   assign('J',Pchr(head(z)))
   assign('z',tail(z))

Java 8, 225 194 187 183 bytes
s->d(s,0);void d(char[]s,int n){for(int c:s){n+=c>44?-1:c/43;System.out.print(c>34&c<37?(char)(n%127):c==37?new java.util.Scanner(System.in).nextLine():"");n=c<36?0:n;}if(n>0)d(s,n);}

-15 bytes by converting Java 7 to Java 8.
-14 bytes thanks to @Zacharý by replacing String input with char-array input.
-2 bytes by some small fixes
-11 bytes thanks to @ceilingcat
Explanation:
Try it here: first test case with user-input.
Try it here: other two test-cases.
s->                           // Method (1) with char-array parameter and no return-type
  d(s,0);                     //  Call another method with the char-array and 0

void d(char[]s,int n){        // Method (2) with character-array and integer parameters
  for(int c:s){               //  Loop over the characters of the input
    n+=c>44?                  //   If the character is '-':
        -1                    //    Decrease `n` by 1
       :c/43;                 //   Else if the character is '+':
                              //    Increase `n` by 1
                              //   Else:
                              //    Leave `n` the same (by increasing with 0)
  System.out.print(c>34&c<37? //   If the character is '#' or '$':
    (char)(n%127)             //    Print the `n modulo 127` as character
   :c==37?                    //   Else-if the character is '%':
    new java.util.Scanner(System.in).nextLine()
                              //    Read & output the user-input
   :                          //   Else:
    "");                      //    Output nothing
  n=c<36?                     //   Then, if the character is '#' or '!':
     0                        //    Reset `n` to 0
    :                         //   Else:
     n;}                      //    Leave `n` the same
  if(n>0)                     //  If `n` is now larger than 0:
    d(s,n);}                  //   Do a recursive-call while leaving `n` as is

Is it possible to accept the argument s of c as a char array?

@Zacharý Thanks. I've also converted it to Java 8, answer golfed two more small things.

Bash/gcc, 184 172
This first reads the program on stdin, then after an EOF, reads program input. Looks valid to me.
gcc -x c -<<<"a;main(){do{$(sed -e's/#/$!/g' -e's/./&;/g' -e's/[+-]/a&&/g' -es/!/a=0/g -e's,%,a=getchar();if(a==-1)exit(0),g' -e's/\$/putchar(a%127)/g')}while(a);}"
./a.out

If you didn't already notice, I'm just constructing, compiling and running a C program on the fly. Note: your compiler might complain loudly about the horrible code generated, but I believe we were allowed extra output on stderr.
Before I began, I expected this to be shorter than it turned out; I'm really unhappy with the % handling. Suggestions welcome :)

Python 3, 121 bytes
x,i=0,int
for c in input():
 if c in'$#':print(end=chr(x%128))
 x+=i(c=='+')-i(c=='-')-i(c in'!#')*x
 if'%'==c:x=input()

Welcome to PPCG, amazing first golf!

If you reach the end and the accumulator isn't 0, you need to restart from the beginning

C, 170 bytes
main(int c,char **v){for(int A=0,i=0;c=v[1][i++];A+1)A=c==0?i=0,A?A:-1:c=='+'?A+1:c=='-'?A-1:c=='!'?0:c=='$'?putchar(A%127),A:c=='#'?putchar(A%127),0:c=='%'?getchar():A;}

Ungolfed
main(int c,char **v){
    for(int A=0,i=0;c=v[1][i++];A+1)
        A=
            c==0 ? i=0, A?A:-1:    // EOF == -1
            c=='+' ? A+1:
            c=='-' ? A-1:
            c=='!' ? 0:
            c=='$' ? putchar(A%127),A:
            c=='#' ? putchar(A%127),0:
            c=='%' ? getchar():
            A;
}

6 bytes can be saved by replacing +-!$#% with decimal equivalents, but that would obfuscate the code. 9 bytes can be saved when using a K&R compatible compiler by moving the declaration int A=0,i=0 to the start of main, A,i,main(... However I only posted code that I could test.
Corrected in response to comments by Dave. Also switched to using the value of EOF (-1) instead of "EOF".

You can test such C code online, here

char **v => char**v.

124 bytes

JavaScript (ES6), 197 bytes
(s,i="")=>(i=[...i].map(c=>c.charCodeAt()),a=0,o="",u=_=>{[...s].map(c=>eval(["a++","a--",p="o+=a?String.fromCharCode(a%127):''",r="a=0",p+","+r,"a=i.shift()"]["+-$!#%".indexOf(c)])),a&&u()},u(),o)

Cleaned up
(s, i="") => (
    i = [...i].map(c=>c.charCodeAt()),
    a = 0,
    o = "",
    u = _ => {
        [...s].map(c => eval(
            ["a++", "a--", p="o+=a?String.fromCharCode(a%127):''", r="a=0", p+","+r, "a=i.shift()"][ "+-$!#%".indexOf(c) ]
        )),
        a && u()
    },
    u(),
    o
)

Test Snippet

f=
(s,i="")=>(i=[...i].map(c=>c.charCodeAt()),a=0,o="",u=_=>{[...s].map(c=>eval(["a++","a--",p="o+=a?String.fromCharCode(a%127):''",r="a=0",p+","+r,"a=i.shift()"]["+-$!#%".indexOf(c)])),a&&u()},u(),o)

Code:
<textarea id="C" rows="2" cols="50"></textarea>

Input: <input id="I">

<button onclick="O.innerHTML=f(C.value, I.value)">Run</button>

Ruby, 143 149 146 bytes
First line of STDIN is the code, the rest is the input.
Whoops, getc doesn't actually exist directly.
a=0
e=i=gets
i.chars{|c|eval Hash["+a+=1 -a-=1 #P;a=0 $P %a=$<.getc||exit !a=0".gsub(?P,"$><<(a%127).chr").scan /(\S)(\S+)/][c]||"";e=a}while e!=0

Try it online!

C, 145 139 bytes
c,a;f(){for(;~c;c=getchar())c==43?a++:c==45?a--:c==35?putchar(a%127),a=0:c==36?putchar(a%127):c==37?!~(a=getchar())?exit(0):0:c==33?a=0:0;}

That was easy. I definitely recommend compiling with all warnings off (-w). Will golf.

shortC, 95 bytes
c,a;AO;~c;c=G)c==43?a++:c==45?a--:c==35?Pa%127),a=0:c==36?Pa%127:c==37?!~(a=G)?T0:0:c==33?a=0:0;

OCaml, 202 bytes
let c c=print_char(char_of_int(c mod 127))
let rec f a p=match Array.fold_left(fun a->function '+'->a+1|'-'->a-1|'#'->c
a;0|'$'->c a;a|'%'->Scanf.scanf"%c"int_of_char|'!'->0|_->a)a p with
0->()|a->f a p

Takes the program as an array of char because OCaml does not have String.fold*
Try it online!

APL (Dyalog Unicode), 112 bytes
a←0
f←⎕UCS 127|⊢
{⍎¨('∆'(≠⊆⊢)'a+←1∆a-←1∆⍞←f a⋄a←0∆⍞←f a∆a←⎕UCS{×≢⍵:⊃⍵⋄⎕UCS 0}i⋄i←1↓i∆a←0')['+-#$%!'⍳⍞]}⍣{a=0}i←⍞

Try it online!
maps each instruction to a string, then executes it.
Inputs are taken in reverse, output is given in the debug window.