64
\$\begingroup\$

I recently created a new language called ;# (pronounced "Semicolon Hash") which only has two commands:

; add one to the accumulator

# modulo the accumulator by 127, convert to ASCII character and output without a newline. After this, reset the accumulator to 0. Yes, 127 is correct.

Any other character is ignored. It has no effect on the accumulator and should do nothing.

Your task is to create an interpreter for this powerful language!

It should be either a full program or a function that will take a ;# program as input and produce the correct output.

Examples

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

Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o

Output: Fizz Buzz output
Program: link below

Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Fizz Buzz up to 100

Leaderboard

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 121921; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

\$\endgroup\$
  • 1
    \$\begingroup\$ Is it acceptable if an interpreter doesn't terminate its execution at the end of the input but instead keeps looping indefinitely without producing extra output? \$\endgroup\$ – Leo May 22 '17 at 9:26
  • 5
    \$\begingroup\$ The second example makes me wonder about a program to encode a program to produce an output... recursive compilation! \$\endgroup\$ – frarugi87 May 22 '17 at 9:29
  • \$\begingroup\$ @Leo yes that's fine \$\endgroup\$ – caird coinheringaahing May 22 '17 at 14:46
  • 1
    \$\begingroup\$ @iamnotmaynard Semicolon Hash \$\endgroup\$ – caird coinheringaahing May 23 '17 at 15:09
  • 2
    \$\begingroup\$ Maybe Wink Hash would be easier to say \$\endgroup\$ – James Waldby - jwpat7 May 23 '17 at 17:42

115 Answers 115

3
\$\begingroup\$

Perl 5 with -043paF(?!^);, 17 bytes

Golfed down a bit by dom-hastings

$_=/#/&&chr@F%127

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ It seems you're missing a %127 \$\endgroup\$ – user41805 Apr 21 at 5:49
  • \$\begingroup\$ fair point, added it \$\endgroup\$ – Krzysztof Szewczyk Apr 21 at 5:54
  • \$\begingroup\$ There's a 25 bytes answer: here just FYI :) \$\endgroup\$ – Dom Hastings Apr 21 at 12:18
  • 1
    \$\begingroup\$ Using that other one as a template and since flags count as a separate version of the language here's one for 17 bytes. \$\endgroup\$ – Dom Hastings Apr 21 at 12:29
2
\$\begingroup\$

Befunge-98, 38 bytes

v+1$>';-!#;_
>~:;|-#';#:_@
^   >$' %,

Try it online!

Note that the input is terminated with a null byte and there is an unprintable (ASCII 127) on the third line after '

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Perl 6, 49 bytes

{S:g/(<-[#]>*)(\#)?/{chr($0.comb(';')%127)x?$1}/}
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

QBIC, 48 66 57 bytes

[_l;||D=_sA,a,1|┘b=b-(D=@;`)~D=@#`|b=b%127?chr$(b)';`┘b=0

Explanation:

[    |           FOR
 _l;|              the length of the cmd line arg A$
 D=_sA,a,1|      Take the next character out of the string as D$
┘                Syntactic linebreak
b=b-(D=@;`)      If D$ == ";", this yields -1. Subtracting this from ACC reverses the sign
~D=@#`|          And if D$ == "#"
b=b%127          Do the Modulo-print thingy
?chr$(b)';`
┘b=0             And reset the acc
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Go, 104 102 bytes

Yeeeeaaaaaaaaaah, Go.

import."fmt"
func f(c string){i:=0;for _,r:=range c{if';'==r{i++};if'#'==r{Print(string(i%127));i=0}}}

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Pyth, 16 bytes

smC%/d\;127Pcw\#

Try it!

explanation

smC%/d\;127Pcw\#
            cw\#    ## split the input on '#'
           P        ## remove the last element (everything after the last #)
 m                  ## map over this list of strings (variable: d)
    /d\;            ## count the semicolons
   %    127         ## modulo 127
  C                 ## the character with that number
s                   ## concat the list of characters

imperative version I did for fun: J0FHwIqH\;=+J1)IqH\#pC%J127=J0

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

C#, 110 108 103 101 98 bytes

-2 bytes by removing braces, where unnecessary

-5 bytes by removing else, from else if

-2 bytes, thanks to TheLethalCoder

-3 bytes, thanks to Andrew Piliser

a=>{var b=0;var d="";foreach(var c in a){if(c==59)b++;if(c==35){d+=(char)(b%127);b=0;}}return d;};

Anonymous function, returns the output.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Compare c to an int to save 2 bytes. \$\endgroup\$ – TheLethalCoder May 22 '17 at 8:17
  • 1
    \$\begingroup\$ I don't think you need the +"", it works without it for me. \$\endgroup\$ – Andrew May 22 '17 at 17:54
2
\$\begingroup\$

Brainfuck, 135 bytes

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

Ungolfed

Memory layout
0   1   2   3   4   5   6   7
1   f1  f2  in  tmp acc d   acc%d   

flag1 indicates hash
flag2 indicates semicolon

+[      infinite loop
    >+      set flag1
    >>,     input
    >+++++[<------->-]<     subtract 35 (hash)

    [       not hash
        <+> set flag2
        >++++[<------>-]<   subtract 24 more (semicolon)
        [   not semicolon
            <-> clear flag2
            [-] clear input
        ]
        <   goto flag2
        [   semicolon
            >>>+<<<-    inc acc and clear flag2
        ]
        <-  clear flag1
        >>[-]   clear input
    ]
    <<      goto flag1
    [       hash
        >>>--[>>+<<--]> set d 127 and goto acc
        [>->+<[>]>[<+>-]<<[<]>-]    mod
        >[-]>       clear d and goto acc%d 
        .[-]        print and clear result
        <<<<<<- clear flag1
    ]
<]
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Chip, 179 bytes

 HGFEDCB
,\\///\/A
`--v~.
   |z^.
 ,\#xZ<
a^xx/'`.
 ,\#xZ~<
b^xx/' |
 ,\#xZ~<
c^xx/' |
 ,\#xZ~<
d^xx/' |
 ,\#xZ~<
e^xx/' |
 ,\#xZ~<
f^xx/' |
 ,\#xZ~'
g^x-/'HGFEDCB
S÷^---\\/\\\/A

(UTF8, so ÷ is \xc3\xb7)

Try it online!

The upper block with A-H and the slashes is detecting the semicolon character, and the similar lower block is detecting the hash. If other bogus characters needn't be handled, the whole thing would be somewhere around 133 bytes.

The middle block does the following:

Z's are the registers, one for each of the seven bits.

The half-adders # allow for incrementing by 1 in case of a semicolon. If not a semicolon, increment by 0.

If we get a hash, send the current register values to a-g, which outputs the desired character, and then reset the values to zero with the switches \.

If the registers are 0b1111110 (126), as determined by the right two columns, the next increment results in zero due to the switches /.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

R, 66 bytes

intToUtf8(nchar(gsub("[^;]","",el(strsplit(scan(,""),"#"))))%%127)

Test:

> intToUtf8(nchar(gsub("[^;]","",el(strsplit(scan(,""),"#"))))%%127)
1: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;... <truncated>
2: 
Read 1 item
[1] "Hello, World!"
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Cubix, 53 bytes

#..Wc.@n.!0i?\?;u...'u;.'\.U;.\w;;U.;).;'%o;c;.!;.U;

Contains one non-printable character, DEL, which is ASCII 127. If the accumulator is 0 and an ignored character is read in, an additional 0 is added to the stack so this runs the risk of stack overflow.

Try it online! and Watch it online

Cubified:

      # . .
      W c .
      @ n .
! 0 i ? \ ? ; u . . . '
u ; . ' \ . U ; . \ w ;
; U . ; ) . ; '   % o ;
      c ; .
      ! ; .
      U ; .
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

JavaScript (ES6), 91 85 bytes

ETH beat me to the punch with a variation on the Japt solution I was working on (that'll learn me to check the answers first!) so here's the JS solution I was using as the basis for it:

s=>s.split`#`.slice(0,-1).map(x=>String.fromCharCode(--x.split`;`.length%127)).join``

Try it

f=
s=>s.split`#`.slice(0,-1).map(x=>String.fromCharCode(--x.split`;`.length%127)).join``
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value=";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")
<input id=i><pre id=o>

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ You could use ~-x.split`;`.length%127 to get rid of the ||0 and the extra parens \$\endgroup\$ – ETHproductions May 22 '17 at 14:32
  • \$\begingroup\$ Good thinking, @ETHproductions; thanks. I was so focused on golfing down the Japt version, I forgot to golf this version before posting it. \$\endgroup\$ – Shaggy May 22 '17 at 14:38
  • \$\begingroup\$ You've done --x.split rather than ~-x.split. Is this intentional or a mistake? \$\endgroup\$ – caird coinheringaahing May 22 '17 at 15:04
  • \$\begingroup\$ It was a misreading of what ETH posted without my glasses on, @RandomUser, but the result is the same, as you can see in the Snippet. \$\endgroup\$ – Shaggy May 22 '17 at 15:07
  • \$\begingroup\$ Actually I can't see in the Snippet (on mobile) \$\endgroup\$ – caird coinheringaahing May 22 '17 at 15:13
2
\$\begingroup\$

SNOBOL4 (CSNOBOL4), 182 167 bytes

	S =INPUT
R	S NOTANY(';#') =	:S(R)
K	K =
T	S LEN(1) . C REM . S	:F(O)
	K =IDENT(C,';') K + 1	:S(T)
	&ALPHABET LEN(REMDR(K,127)) LEN(1) . A
	Y =Y A	:(K)
O	OUTPUT =Y
END

Try it online!

Due to size limitations in this implementation of SNOBOL, it can only read in lines of 1024 characters at a time, discarding the rest. So it only manages to print Hello, Worl. Ah well.

	S =INPUT				;*read input
R	S NOTANY(';#') =Y	:S(R)		;*recursively remove non ;# characters
K	K =0					;*counter
T	EQ(SIZE(S)) :S(O)			;*if string is empty, goto output
	S LEN(1) . C REM . S			;*set C to the first char, the REMainder to S
	K =IDENT(C,';') K + 1	:S(T)		;*if C is identical to ';', increment C and goto T
	&ALPHABET LEN(REMDR(K,127)) LEN(1) . A	;*get the K % 127th character, set it to A
	Y =Y A	:(K)				;*append A to Y
O	OUTPUT =Y				;*output Y
END
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Shakespeare Programming Language, 447 439 404 bytes

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Ford:Am I as big as the sum ofa pig twice twice the sum ofa pig a big big big big cat?If soyou be the sum ofyou a cat.Be you worse the sum ofa pig twice the cube ofa big big cat?If notyou zero.Am I as big as the sum ofa cat twice the sum ofa cat a big big big big cat?If soSpeak thy.If soYou zero.Am I nicer zero?If soLet usAct I.

Try it online!

-35 bytes thanks to Joe King!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ 404 bytes with proper termination \$\endgroup\$ – Jo King Sep 10 '18 at 0:51
  • \$\begingroup\$ Y'know, I should've thought about wrapping the accumulator manually. \$\endgroup\$ – JosiahRyanW Sep 10 '18 at 1:37
2
\$\begingroup\$

F# (.NET Core), 71 bytes

Seq.fold(fun a->function|';'->a+1|'#'->printf"%c"(a%127|>char);0|_->a)0

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Awk, 57 bytes

BEGIN{RS="#"}RT=="#"{printf("%c",gsub(";","")%127)}

Explanation:

  • BEGIN{RS="#"}: make # record delimeter
  • RT=="#": ignore the record without ending #
  • gsub(";","")%127: count ; and mod 127
  • printf("%c",_): print as ASCII
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Haskell, 70 bytes

(-7 thanks to BWO)

n#(o:p)|o==';'=(n+1)#p|o=='#'=toEnum(mod n 127):0#p|1>0=n#p
_#p=p
(0#)

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Huh, I always thought you had to use a space to call a function. \$\endgroup\$ – mrFoobles Aug 12 '18 at 16:00
  • 1
    \$\begingroup\$ n#(o:p)|o=='#'=toEnum(mod n 127):0#p|o/=';'=n#p|w<-n+1=w#p works for 69 bytes. \$\endgroup\$ – ovs Aug 12 '18 at 17:22
2
\$\begingroup\$

asm2bf, 74 bytes

Try it online!

Golfed code:

@l
in r1
ceqr1,.;
cadr2,1
ceqr1,.#
cjz%d
modr2,127
outr2
clrr2
@d
jnzr1,%l

Commented code:

; Wrap everything in a loop.
@l
; Read a character from stdin.
    in  r1
; if r1 = ';', set the condition flag.
    ceq r1,.;
; if condition flag is set, add 1 to r2
; r2 is used as an accumulator.
    cad r2,1
; if r1 = '#', set the condition flag.
    ceq r1,.#
; if condition flag is not set, jump to d
    cjz %d
; display acc%127 and clear it.
    mod r2,127
    out r2
    clr r2
@d
; loop if didn't hit an EOF
    jnz r1, %l
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

JavaScript (V8), 77 bytes

p=>([...p].map(e=>e==';'?i++:(s+=String.fromCharCode(i%127),i=0),i=0,s=''),s)

Try it online!

JavaScript (V8), 77 bytes

p=>([...p].map(e=>i+=e==';'?1:(s+=String.fromCharCode(i%127),-i),i=0,s=''),s)

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

C, 74 72 70 bytes

a;f(char*s){for(;*s;s++){if(*s==59)a++;if(*s==35)putchar(a%127),a=0;}}

Test cases:

Output: Hello, World!
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");

Output: ;#
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");

Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o");

Output: !
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

C (gcc), 66 bytes

a;f(char*c){for(a=0;*c;a+=*c==59,a=*c++==35&&putchar(a%127)?0:a);}

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

shortC, 51 bytes

a;f(C*s){O;*s;s++){F*s==59)a++;F*s==35)Pa%127),a=0;
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

J, 29 bytes

[:u:127|[:+/"1[:';'&=;.1'#',]

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The third test case outputs 2┴d{I, but I think it might be because of J's alphabet a. \$\endgroup\$ – miles May 23 '17 at 2:33
1
\$\begingroup\$

C, 56 54 bytes

a;f(char*s){a+=*s-35?*s==59:-putch(a%127);*s&&f(s+1);}

Solution is based on Dennis's one ("C (gcc), 58 bytes"), but with elimination of two characters a=

Two more symbols can be taken off with substitution putchar with putch

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ a= is required to make the function reusable; since a is global, it has to be reset to 0. \$\endgroup\$ – Dennis May 23 '17 at 4:08
  • \$\begingroup\$ putch is not standard C. \$\endgroup\$ – MD XF May 23 '17 at 21:19
1
\$\begingroup\$

Cheddar, 57 bytes

@.split("#").head(-1).map(s->@"(s.count(";")%127)).join()

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Aceto, 38 31 bytes

The program reads and processes one character at a time, so it will work with infinite ;# programs. Run with -F if you want immediate results (because buffering), but it works without it if the program is long enough.

  Ox%-12
  =_cpF7
d'#'O
,;=|xIO

, reads a character. We duplicate it and compare it with ;. If it's equal, we mirror to the right side (=|), drop (x) the duplicate, Increment the value on the stack (implicitly zero), and go back to the Origin.

If it's not equal, we compare the copy with #. If that is equal, we mirror upwards (=_; somewhere in empty space above, but the next non-nop we read will be the 2). We push a 2 and a 7, compute 2^7 (F), and substract 1 (1-). We then do a modulo operation (%) convert it to a character, print it (without a newline) and go back to the Origin.

If it's none of those characters, we drop the value on the stack (x) and go back to the Origin.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Gema, 63 characters

\A=@set{a;0}
\;=@incr{a}
\#=@int-char{@mod{$a;127}}@set{a;0}
?=

Sample run:

bash-4.4$ gema '\A=@set{a;0};\;=@incr{a};\#=@int-char{@mod{$a;127}}@set{a;0};?=' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I do so love Gema answers. \$\endgroup\$ – Jordan May 24 '17 at 2:01
1
\$\begingroup\$

APL (Dyalog) , 25 bytes

⎕UCS 127|+/¨';'='#'(≠⊂⊢)⍞

Try it online! Some of the longer test cases seem to have problems on TIO, but work fine offline.

 get text input

'#'() apply the following tacit function with hash as left argument:

 the inequality

 partitions*

 the right argument (all the semicolons and hashes)

';'= equality to semicolon

+/¨ sum each

127| mod-127

⎕UCS Convert to corresponding Unicode character


in versions up to 15.0, providing that ⎕ML←3 which is default on many systems. In version 16.0 and higher, just use .

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

PHP, 61 Bytes

for(;~$c=a^$argn[$i++];)$n+=$c^r?$c==Z:-$n*print chr($n%127);

Try it online!

PHP, 68 Bytes

for(;a&$c=$argn[$i++];)$c!=";"?$c!="#"?:$n=1-print chr($n%127):++$n;

Try it online!

| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ Doesn't work with 0. Fixed and slightly golfed: for(;~$c=a^$argn[$i++];)$c^r?$n+=$c==Z:print~$n=~chr($n%127);. \$\endgroup\$ – user63956 May 22 '17 at 6:10
  • \$\begingroup\$ @user63956 It tooks a long time to understand how this works. Nice Thank You \$\endgroup\$ – Jörg Hülsermann May 22 '17 at 10:21
  • 1
    \$\begingroup\$ Yields warnings A non-numeric value encountered in PHP 7.1. Use $n+=$c^r?$c==Z:-$n*print chr($n%127); (same length) to fix. \$\endgroup\$ – Titus May 22 '17 at 13:47
  • \$\begingroup\$ @Titus Done Thank You \$\endgroup\$ – Jörg Hülsermann May 22 '17 at 14:05
1
\$\begingroup\$

Clojure, 71 bytes

#(for[i(re-seq #"[^#]*#"%)](print(char(mod(count(filter #{\;}i))127))))

Splits into chunks by regex, counts how many ;s there are in each chunk.

| improve this answer | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.