Interpret PlusOrMinus

Question

PlusOrMinus is an esoteric programming language invented by Esolang user PythonshellDebugwindow.

Language specification

There is a wrapping byte accumulator (incrementing 255 results in 0 and decrementing 0 results in 255) in the language. The initial valus of the accumulator is 0.

There are two instructions in the language:

• +, which increments the accumulator by one.
• -, which prints the accumulator as ASCII (e.g.: A if accumulator is 65), then decrements the accumulator by one.

Characters that are neither + nor - are ignored.

Examples

Here are some examples to test your programs:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++-++++++++-+-++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++-++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-

Prints Hello, World!.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++-++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-

Prints Nope..

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------

Prints ZYXWVUTSRQPONMLKJIHGFEDCBA.

blah

Prints nothing.

+++++++++++++++++++++++++++++++++?-

Prints !.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++

Prints A.

++++++++++++++++++++++++++++++++++--

Prints "!.

Goal

This is code-golf, so your goal is to use the fewest bytes to interpret the language. The program to interpret can be from a console input, file input or string.

Answer 1

AWK -vRS=(.), 37 bytes

RT~/+/{x++}RT~/-/{printf"%c",x--%256}

Attempt This Online!

Uses a regex as a record seperator to split the input into seperate characters and matches them one-by-one.

Answer 2

Perl 5 + -p055, 24 bytes

-2 bytes thanks to @Neil!

$-+=y/+//;$_=chr$---%256

Try it online!

Explanation

Cheesing a little on the args, using -055 to split input on - and using y/+// to count the +s (ignoring other chars, thanks @Johnathan Allan!).

Answer 3

Pip, 29 25

C{i+:Dai+1%:256}M#*H:a^'-

- 4 bytes thanks to DLosc

Attempt This Online!

C{i+:Dai+1%:256}M#*H:a^'-­⁡​‎⁠⁠‎⁡⁠⁢⁢⁢‏⁠‎⁡⁠⁢⁢⁣‏⁠‎⁡⁠⁢⁢⁤‏⁠‎⁡⁠⁢⁣⁡‏⁠‎⁡⁠⁢⁣⁢‏⁠‎⁡⁠⁢⁣⁣‏⁠‎⁡⁠⁢⁣⁤‏⁠‎⁡⁠⁢⁤⁡‏‏​⁡⁠⁡‌⁢​‎⁠‎⁡⁠⁢‏⁠⁠⁠⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏⁠‎⁡⁠⁢⁡⁢‏⁠‎⁡⁠⁢⁡⁣‏⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏⁠⁠⁠‏​⁡⁠⁡‌⁣​‎⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‏​⁡⁠⁡‌⁤​‎⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠⁠⁠‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌­
                     a^'-  # ‎⁡Split input by "-"
 {             }M#*H:      # ‎⁢Map through lengths of all but last item as a...
  i+:Da                    # ‎⁣ Increment i (initialised to 0) by length of a - 1
       i+1%:256            # ‎⁤ Return i+1 mod 256
C                          # ‎⁢⁡Convert codepoints to ASCII
💎

Created with the help of Luminespire.

Answer 4

JavaScript (Node.js), 57 bytes

Expects an array of characters and returns a string.

s=>Buffer(s.flatMap(c=>c=="-"?a--:(a+=c=="+",[]),a=0))+""

Try it online!

Answer 5

Funge-98, 47 bytes

>~#<:'+w$:'U3*-3jc+1_$0
^#:w-' <j7-1_$'U3*4j6:,

Try it online!

The program never halts, so if you run it using TIO, you have to manually cancel execution in order to view the output.

Answer 6

Uiua 0.11.0, 26 bytes ^SBCS

▽:+@\0◿256\+-⬚0↻¯1,∩=@+,@-

Try on Uiua Pad!

Takes a string of + and - and returns the output string. If the input is guaranteed to only contain +-, we can save 2 bytes by replacing ∩=@+,@- with ¬.=@- (and probably more, with a completely different strategy).

Explanation

@-    # push literal character - to stack
@+,   # dup input to top and push +
∩=    # get two arrays with 1s where + and - are
,     # dup the - array to top
⬚0↻¯1 # shift 1 to the left, filling with 0 at front
-     # subtract from the + array
\+    # plus scan: cumulative sums
◿256  # mod 256
+@\0  # add literal character null, converts to ASCII
▽:    # flip the - array to top and apply mask

Answer 7

Perl 5 -p, 35 bytes

s/.*?-/$x+=$&=~y-+--;chr$x--%256/ge

Try it online!

Answer 8

05AB1E, 18 15 14 bytes

'-¡'+QO<ηO>₁%ç

-3 bytes thanks to @IvanG.
-1 byte porting @JonathanAllan's Jelly answer

I/O as a list of characters.

Try it online or verify all test cases.

Explanation:

'-¡           '# Split the (implicit) input-list of characters on "-"
   '+Q        '# Check for each inner character whether it equals "+"
      O        # Sum each inner list of 1s and 0s together
       <       # Decrease each sum by 1
        η      # Get the prefixes of this list of sums-1
         O     # Sum each prefix
          >    # Then increase each prefix-sum by 1
           ₁%  # Modulo-256
             ç # Convert each integer to a character with this codepoint
               # (after which the list of characters is output implicitly as result)

Answer 9

Vyxal 3, 14 bytes

'-sᵛ'+Cv@₇%ꜝOṪ

Try it Online!

would be 14 if vyxal didnt automatically treat + as a regex symbol

Edit-- Bug was fixed

Answer 10

Jelly, 14 bytes

ṣ”-Ṗċ€”+’Ä‘%⁹Ọ

A monadic Link that accepts a list of characters, or a full program that accepts a string argument.

Try it online! Or see the test-suite.

How?

ṣ”-Ṗċ€”+’Ä‘%⁹Ọ - Link: list of characters, Code      e.g. "---+++++--"
ṣ”-            - split {Code} at '-' characters           ["", "", "", "+++++", "", ""]
   Ṗ           - remove the (possibly empty) rightmost    ["", "", "", "+++++", ""]
    ċ€”+       - count the '+' characters in each         [0,    0,   0, 5,  0]
        ’      - decrement all values                     [-1,  -1,  -1, 4, -1]
         Ä     - cumulative sums                          [-1,  -2,  -3, 1 , 0]
          ‘    - increment all values                     [ 0,  -1,  -2, 2,  1]
           %⁹  - mod 256 all values                       [ 0, 255, 254, 2,  1]
             Ọ - convert all to characters                "\x00ÿþ\x02\x01"
               - (if running as a full program, implicitly prints to stdout)

Answer 11

Google Sheets, 93 bytes

=SORT(JOIN(,IFNA(CHAR(SCAN(,SPLIT(A1,"-",,),LAMBDA(a,c,MOD(a+LEN(c),256)))-COLUMN(A:ZZ)+1))))

Answer 12

Lua, 149b

Read a character from standard in, and look it up in a table of two functions - call empty function otherwise.

a=0;while 1 do(({["+"]=function()a=(a+1)%256;end,["-"]=function()io.write(string.char(a))a=a<1 and 255 or a-1 end})[io.read(1)]or function()end)()end

Lua, 109b

Read character from stdin, convert to an increment, decrement, or zero, from a table. If we're going to decrement, convert accumulator number to char and print it out before adding.

a=0;while 1 do c=({["+"]=1,["-"]=-1})[io.read(1)]or 0;io.write(c<0 and string.char(a)or"")a=(a+c+256)%256;end

Answer 13

Charcoal, 19 bytes

⭆⌕ＡΦＳ№+-ι-℅﹪⁻ι⊗κ²⁵⁶

Try it online! Link is to verbose version of code. Explanation:

    Ｓ               Input string
   Φ                Filtered where
      +-            Literal string `+-`
     №              Contains
        ι           Current character
 ⌕Ａ                 Find all indices of
         -          Literal string `-`
⭆                   Map over indices and join
             ι      Index of current `-`
            ⁻       Minus
               κ    Count of previous `-`s
              ⊗     Doubled
           ﹪        Modulo
                ²⁵⁶ Literal integer `256`
          ℅         Convert to character
                    Implicitly print

Answer 14

Scala 3, 123 bytes

A port of @none1's JavaScript answer in Scala.

---

Golfed version. Attempt This Online!

p=>{var o="";var x=0;for(i<-p){i match{case'+'=>x+=1;if(x==256)x=0 case'-'=>o+=x.toChar;x-=1;if(x== -1)x=255;case _ =>}};o}

Ungolfed version. Attempt This Online!

object Main {
  def plusOrMinus(program: String): String = {
    var output = ""
    var x = 0
    for (i <- program) {
      i match {
        case '+' =>
          x += 1
          if (x == 256) x = 0
        case '-' =>
          output += x.toChar
          x -= 1
          if (x == -1) x = 255
        case _ => // handle other characters if necessary
      }
    }
    output
  }

  def main(args: Array[String]): Unit = {
    val input = 
s"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++-++++++++-+-++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++-++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-"""


    println(plusOrMinus(input))
  }
}

Answer 15

Stax, 15 bytes

Ç¿₧Δ─Θî²1%≤{‼aù

Run and debug it

Answer 16

JavaScript, 125 111 109 Bytes

r=>{f="",u=0;for(n of r)"+"==n?256==++u&&(u=0):"-"==n&&(f+=String.fromCharCode(u),-1==--u)&&(u=255);return f}

Ungolfed version:

function plusorminus(program){
    var output='',x=0;
    for(let i of program){
        if(i=='+'){
            x++;if(x==256){x=0}
        }else if(i=='-'){
            output+=String.fromCharCode(x);x--;if(x==-1){x=255}
        }
    }
    return output
}

You can run the code in this snippet:

y=r=>{f="",u=0;for(n of r)"+"==n?256==++u&&(u=0):"-"==n&&(f+=String.fromCharCode(u),-1==--u)&&(u=255);return f}
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++-++++++++-+-++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++-++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-'))
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++-++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-'))
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------'))
console.log(y('blah'))
console.log(y('+++++++++++++++++++++++++++++++++?-'))
console.log(y('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++'))
console.log(y('++++++++++++++++++++++++++++++++++--'))

Answer 17

Python, 100 Bytes

lambda x:''.join(chr(x[:i].count('+')-x[:i].count('-')&255)if x[i]=='-'else''for i in range(len(x)))

Both the argument and the return value are strings.

Explanation: + and other characters don't produce any output, the value that a - outputs equals to the number of + minus the number of - before it modulo 256.

Try it online!

Answer 18

C (gcc), 49 47 46 bytes

c;f(char*s){for(;*s;)*s++%5?c++:putchar(c--);}

Pretty straightforward.

-1 byte thanks to Arnauld.

Try it online!

Answer 19

Pascal, 158 B

The implementation‑defined set of char values must correspond to ASCII and the ordinal value of the implementation‑defined constant maxChar must be greater than or equal to 255.

program P(input,output);var C:char;A:0‥255;begin
A≔0;while not EOF do begin
read(C);if C='−' then write(chr(A));A≔(A+ord(C='+')−ord(C='−'))mod 256 end end.

−3 B: If you have a processor supporting “Extended Pascal” as defined by ISO standard 10206, you may write a zero‑width string:

program P(input,output);var C:char;A:0‥255;begin
A≔0;while not EOF do begin
read(C);write(chr(A):ord(C='−'));A≔(A+ord(C='+')−ord(C='−'))mod 256 end end.

Users of the FreePascal Compiler need to insert a {$modeSwitch ISOMod+} compiler directive. This ensures an ISO‑compliant definition of the mod operator, in particular in case of negative dividends the result is still non‑negative (Euclidean‑like definition of mod).

Answer 20

Python 3, 66 bytes

v=0
for c in input():v%=256;v+=c=='+';v-='-'==c!=print(end=chr(v))

A full program that reads from stdin and prints to stdout.

Try it online! Or see the test-suite.

Answer 21

YASEPL, 76 75 59 bytes

=a=i=1'=l®1`1!r¥i,1}7,plus,2!+`2}7,minus,3!›-`3%256!i+}2,l

Answer 22

brainfuck, 65 57 bytes

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

Try it online!

Answer 23

Kotlin, 76 bytes

{fold(0){a,c->when(c){'-'->{print(a.toChar());a-1}'+'->a+1 else->a}and 255}}

Try it online!

-1 byte thanks to ceilingcat.

Answer 24

C#, 102 100 bytes

-2 thanks to @ceilingcat's suggestion to replace '+' and '-' with their ASCII codes (43 and 45)

void I(string s){byte b=0;foreach(var c in s)System.Console.Write((char)(c==43?++b-b:c==45?b--:0));}

Try it online!

Explanation:

void InterpretPlusOrMinus(string input)
{
    byte b = 0; // initialize accumulator 'b'

    foreach (var c in input)
    {
        System.Console.Write((char)( // Print the ASCII representation of:
            (c == 43)?         // If c is '+':
                 ++b - b :      //    ++b-b (increment b and return 0)
                 (c == 45)?    // Else If c is '-':
                     b-- :      //    b--
                     0          // Else: 0
        ));
    }
}

This code works in .NET 5+

Answer 25

PowerShell Core, 41 bytes

switch($args){+{$c++}-{[char]($c--%256)}}

Try it online!

Function that takes a string using splatting
Returns an array of characters

Answer 26

J, 37 bytes

[:(]#a.{~256|[:+/\[-_1|.!.0])/'+-'=/]

Shameless port of Tbw's amazing Uiua answer.

Attempt This Online!

[:(]#a.{~256|[:+/\[-_1|.!.0])/'+-'=/]
                                    ]   NB. input
                              '+-'      NB. string literal of ops
                                  =/    NB. equality table of each op and input
[:                                      NB. cap forces f(g(x)) instead of a hook
  (                         )/          NB. fold, the two table rows become left/right arg
                           ]            NB. list of chars equal to -
                    _1|.!.0             NB. shift right 1 and fill with 0
                  [                     NB. list of chars equal to +
                   -                    NB. subtract
             [:+/\                      NB. prefix sums (sum-reduce(+/) on all prefixes)
         256|                           NB. mod 256
     a.{~                               NB. index into the ascii alphabet
   ]                                    NB. list of chars equal to -
    #                                   NB. copy with boolean vector acts as a filter

Answer 27

Japt -hP, 20 bytes

q-
ÆËo+ ÅÊÃåÄ ËuG² d

Try it

q-\nÆËo+ ÅÊÃåÄ ËuG² d     :Implicit input of string U
q-                        :Split on "-"
  \n                      :Reassign to U
    Æ                     :Modify last element
     Ë                    :  Map remaining elements in U
      o+                  :    Keep only "+"s
         Å                :    Slice off first character
          Ê               :    Length
           Ã              :  End map
            å             :  Cumulatively reduce by
             Ä            :    Addition, after prepending a 1
               Ë          :  Map
                u         :    Modulo
                 G        :      16
                  ²       :      Squared
                    d     :    Character at that codepoint
                          :Implicit output of last element joined to a string

Answer 28

C (gcc), 59 bytes

char i;f(char*c){i+=*c==43;*c==45&&putchar(i--);f(c+!!*c);}

Ungolfed:

char i; // the counter
/*implicit int here */ f (char* c) {
    // increment the counter if *c is '+' (43), since == returns 1 for true
    i += *c == 43;
    // if c is not '-' (45), the condition will short circuit, otherwise putchar will run
    *c == 45 && putchar(i--);
    // if *c is the end of the string (0), !!*c will be 0, 
    // and the function will enter an infinite loop that does nothing, 
    // otherwise we will call f with a ptr to the next character.
    f(c + !!*c);
}

This handles non +/- characters properly, unlike the other C answer, however it does either hang indefinitely or overflow the stack (fixing this costs a byte). This also requires the -funsigned-char flag to run properly.

Try it online!

Answer 29

BrainChild, 97 bytes

function(int l,@int s){int a=0;int i=0;while(i<l){if(s[i]==43)a++if(s[i++]==45)putchar(a--%256)}}

Takes input as a char array

Readable

function PlusMinus(int length, @int chars){
    int acc=0;
    int i=0;
    while(i<length){
        if(chars[i]=='+')
            acc++
        if(chars[i++]=='-')
            putchar((acc--)%256)
    }
}

Try It Online!