Faire un interprète;

62

J'ai récemment créé un nouveau langage appelé ;#(prononcé "Semicolon Hash") qui n'a que deux commandes:

; ajouter un à l'accumulateur

#modulez l'accumulateur par 127, convertissez-le en caractère ASCII et sortez-le sans nouvelle ligne. Après cela, réinitialisez l'accumulateur à 0. Oui, 127 est correct.

Tout autre caractère est ignoré. Cela n'a aucun effet sur l'accumulateur et ne devrait rien faire.

Votre tâche est de créer un interprète pour ce langage puissant!

Ce doit être soit un programme complet, soit une fonction qui prend un ;#programme en entrée et produit le résultat correct.

Exemples

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 jusqu'à 100

caird coinheringaahing
la source
1
Est-il acceptable qu'un interprète ne termine pas son exécution à la fin de l'entrée mais continue à boucler indéfiniment sans produire de sortie supplémentaire?
Léo
5
Le deuxième exemple me fait penser à un programme pour coder un programme afin de produire une sortie ... compilation récursive!
frarugi87
@Leo oui ça va
caird coinheringaahing
1
@iamnotmaynard Semicolon Hash
caird coinheringaahing
2
Peut-être que Wink Hash serait plus facile à dire
James Waldby - jwpat7

Réponses:

17

JavaScript (ES6), 76 82 80 octets

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

Démo

Version récursive, 82 77 octets

5 octets sauvés grâce à Neil

Celui-ci est susceptible de planter pour des entrées de grande taille telles que l'exemple Fizz Buzz.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""
Arnauld
la source
Je pense que f(s,a+(c==';'))pourrait supprimer trois octets de votre version récursive.
Neil
@ Neil Il enregistre effectivement 5 octets. :-)
Arnauld
Je me sens vraiment bête maintenant. J'avais à l'origine une version boguée et soustrayais 2 octets pour corriger le bogue. Mais j'avais mal compris et la version buggy sauvait 7 octets ...
Neil
12

Retina , 336 63 67 65 66 62 59 octets

T`;#-ÿ`¯_
;{127}|;+$

(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`

Essayez-le en ligne!

Version lisible utilisant une syntaxe d'échappement hypothétique :

T`;#\x01-ÿ`\x01¯_
;{127}|;+$

(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`

N'imprime pas les octets NUL, car TIO ne les autorise pas dans le code source. Imprime également une nouvelle ligne à la fin, mais je suppose que cela ne peut pas être fait autrement. Le retour à la ligne est supprimé grâce à @Leo .

-273 (!) Octets grâce à @ETHproductions .

-2 octets grâce à @ovs .

-3 octets grâce à @Neil . Découvrez leur merveilleuse solution à 34 octets .

eush77
la source
1
Oh ma parole. Mais ne pouvez-vous pas économiser mille octets avec +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (y compris les caractères non imprimables en caractères simples, bien sûr)
ETHproductions
@ETHproductions Bien sûr, vous pouvez. Je vous remercie! :)
eush77
1
Actuellement, la dernière lettre est toujours dans la sortie, même s'il n'y a pas de fin #dans l'entrée. Vous pouvez résoudre ce problème en changeant votre deuxième étape en(;{127}|;+$)
ovs
1
Avez-vous besoin du + `sur la troisième ligne? Lorsque vous supprimez l'intégralité de la correspondance, il ne doit plus rester rien à remplacer à la deuxième itération.
ovs
1
Je pense que je peux le faire en 34 octets: T`;#\x01-ÿ`\x80\x7F_ \x80+$(ligne vide) \+T`\x7Fo`\x01-\x80_`\x80[^\x80](en utilisant des échappements hexadécimaux pour représenter des éléments non imprimables). Sorties \ x7F au lieu de NULL.
Neil
12

Java 8, 100 octets

s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};

Essayez-le en ligne!

Mas
la source
3
Bienvenue sur le site! :)
DJMcMayhem
J'ai ajouté un lien vers un interprète en ligne avec l'exemple FizzBuzz pour vous (le texte du lien était trop long pour tenir dans un commentaire)
Jonathan Allan
Java utilise UTF-16 pour ses programmes . Donc, ce ne sont pas 100 octets mais 100 caractères .
G.Broser dit: réintégrer Monica
5
@GeroldBroser Unicode est un jeu de caractères: UTF-8 et UTF-16 sont deux codages de ce jeu de caractères. La source ASCII est parfaitement valide en tant que programme Java et j’ai beaucoup de fichiers source Java codés en ASCII (qui est également valide en UTF-8, et donc aussi en codage Unicode).
1
Entièrement golfé, pour 81 octets en tant que Consumer<char[]>:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Olivier Grégoire
11

Japt , 18 octets

®è'; %# d}'# ë ¯J

Il y a un caractère \ x7f non imprimable après %#. Testez-le en ligne!

Comment ça fonctionne

®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression
ETHproductions
la source
1
D'oh, aurait dû vérifier les réponses! Je viens juste de passer un peu de temps là-dessus pour découvrir que tu m'avais battu au poing. q'# ®è'; u# dì¯Jfonctionne également pour le même score.
Shaggy
11

Python , 65 octets

Ceci est un golf de cette réponse précédente.

lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])

Essayez-le en ligne! Python2

Essayez-le en ligne! Python3

Explication

C’est une réponse assez simple: nous déterminons le nombre de ;s entre chaque #impression et imprimons le chrmod 127. La seule chose qui pourrait être un peu étrange est le [:-1]. Nous devons supprimer le dernier groupe car il n'y aura pas de #suite.

Par exemple

;;#;;;;#;;;;;#;;;

Sera divisé en

[';;',';;;;',';;;;;',';;;']

Mais nous ne voulons pas le dernier ;;;car il n’ya pas d’ #après pour imprimer la valeur.

Assistant de blé
la source
1
J'étais occupé à essayer de faire passer tous les tests dans un seul lien TIO. Était chr pour chr sauf tet x.
Jonathan Allan
9

> <> , 35 octets

>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<

Essayez-le en ligne! Remplacez par 0x7F, ^?ou "supprimer".

Boucle principale

>i:0(?;:'#'=?v      
^            <

Cela prend un caractère de input ( i), vérifie si sa valeur est inférieure à zéro, c'est-à-dire EOF ( :0() et termine le programme s'il est ( ?;). Sinon, vérifiez si l'entrée est égale à #( :'#'=). Si c'est le cas, relâchez la boucle et redémarrez la boucle ( ?v... ^ ... <).

Contre-logique

              ';'=?0
              

Vérifiez si l'entrée est égale à ;( ';'=). Si c'est le cas, appuyez sur a 0. Sinon, ne faites rien. Cela redémarre la boucle principale.

Logique d'impression

>       '#'=?v      
^   [0o%'␡'l~<

Lorsque le caractère saisi est #, supprimez-le de la pile ( ~), obtenez le nombre de membres de la pile ( l), appuyez sur 127 ( '␡') et prenez le module ( %). Ensuite, affichez-le sous forme de caractère ( o) et démarrez une nouvelle pile ( [0). Ceci "zéros" sur le comptoir. Ensuite, la boucle redémarre.

Conor O'Brien
la source
3
Mauvais> <>. C'est triste :0(:(
caird coinheringaahing
9

Python 3, 69 octets

Amélioré, grâce à @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
Mr Geek
la source
3
Bienvenue dans Programmation Puzzles et Code Golf! L'objectif ici est de rendre le code aussi court que possible (en octets). Vous devez donc inclure le nombre d'octets dans l'en-tête :).
Adnan
Merci de m'avoir expliqué, je ne le savais pas. Je vais y travailler alors.
Mr Geek
2
Vous pouvez supprimer l'espace après le :s.
Pavel
1
Je compte 74 octets. tio.run/nexus/…
Dennis
2
En outre, ';'==céconomiser un espace, mais ne pas utiliser les ifdéclarations serait encore plus court.
Dennis
9

Röda , 44 39 38 octets

5 octets sauvegardés grâce à @fergusq

{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}

Essayez-le en ligne!

Fonction anonyme qui prend l'entrée du flux.


Si les autres personnages ne doivent pas être ignorés, j'obtiens ceci:

Röda , 20 octets

{(_/`#`)|chr #_%127}
Kritixi Lithos
la source
8

Ruby, 41 35 34 caractères

( 40 34 33 caractères code + option de ligne de commande de 1 caractère)

gsub(/.*?#/){putc$&.count ?;%127}

Grâce à:

  • Jordan pour avoir suggéré de putcne pas utiliser de conversion explicite avec .chr(6 caractères)
  • Kirill L. pour avoir trouvé la parenthèse inutile (1 caractère)

Échantillon échantillon:

bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '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

Essayez-le en ligne!

homme au travail
la source
Doh. Bien que j'ai pratiqué le C dans mes premières années, j'ai complètement oublié putc(). Merci, @Jordan
manatwork
1
À ma propre surprise, vous pouvez réellement supprimer les parenthèses après le décompte pour enregistrer un octet
Kirill L.
Belle prise, @KirillL., Merci.
manatwork
7

05AB1E , 16 15 14 octets

Code:

'#¡¨ʒ';¢127%ç?

Explication:

'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline

Utilise le codage 05AB1E . Essayez-le en ligne!

Adnan
la source
7

Gelée , 13 octets

ṣ”#Ṗċ€”;%127Ọ

Essayez-le en ligne!

Comment ça fonctionne

ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)

ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.
Dennis
la source
1
Le mot semicolan'existe pas c'est semicolons.
Erik the Outgolfer
@EriktheOutgolfer fr.m.wiktionary.org/wiki/semicola
Dennis
Hmm, mot étrange.
Erik the Outgolfer
@EriktheOutgolfer Quelqu'un sur Wiktionary essayait probablement de rendre le pluriel latin valide en anglais, mais les orthographes cola et semicola devraient être proscrites.
Cœur
7

Code machine x86 sous MS-DOS - 29 octets

00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d

Assemblée commentée:

bits 16
org 100h

start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading
Matteo Italia
la source
6

05AB1E , 25 21 19 octets

-2 octets grâce à Adnan

Îvy';Q+y'#Qi127%ç?0

Explication:

Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print

Essayez-le en ligne!

Okx
la source
1
Je pense que vous pouvez remplacer i>}par +.
Adnan
6

Retina , 34 octets

T`;#-ÿ`_
\+T`o`-_`[^]|$

Essayez-le en ligne! Comprend un cas de test. Edit: 2 octets enregistrés avec l’aide de @MartinEnder. Remarque: Le code inclut les articles non imprimables et l'utilisation de &#x;codes génère des résultats incorrects car le navigateur utilise Windows-1252 au lieu de ISO-8859-1. Explication: La première ligne nettoie l'entrée: ;est changé \x80, #à \x7F( en raison des limitations TIO) et tout le reste est supprimé. Ensuite, chaque fois que nous voyons un élément différent d'un \x80autre \x80, nous le supprimons et incrémentons de manière cyclique le code de tout caractère suivant. Ceci est itéré jusqu'à ce qu'il ne reste plus de \x80caractères. Le code original qui prend en charge les octets nuls soustrait fondamentalement 1 des octets non imprimables, sauf dans la première ligne où \xFFest inchangé et \x7Fdevient\x00. Avec échappées pour plus de lisibilité:

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$
Neil
la source
Vous pouvez enregistrer un octet en combinant les deux dernières étapes de \x80([^\x80]|$)la dernière étape.
Martin Ender
@MartinEnder Merci! Ennuis, \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?ne sauve qu’un octet.
Neil
Ah, mais [^\x80]|\x80$sauve deux octets, je pense.
Neil
Ah bien, oui, le dernier fonctionne. J'avais aussi essayé le look négatif, mais sc'est ennuyeux.
Martin Ender
6

R, 97 90 86 84 octets

Une fonction:

function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}

Lorsque R commence, Fest défini comme FALSE(numérique 0).

Ungolfed:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }
Sven Hohenstein
la source
Cela ne devrait-il pas être R + pryr?
L3viathan
@ L3viathan Comme il pryrs'agit d'un package R, il s'agit toujours du code R.
Sven Hohenstein
C'est du code R, mais cela nécessite l'installation d'une bibliothèque supplémentaire.
L3viathan
@ L3viathan Pensez-vous que ma réponse est invalide? Devrais-je éviter d'utiliser des paquets supplémentaires?
Sven Hohenstein
2
@BLT Il n'y a pas de différence. À mon avis, l’utilisation de packages supplémentaires créés avant le challenge ne pose aucun problème . Ceci est vrai pour toutes les langues. En Python, vous devez utiliser importalors que dans R, vous pouvez utiliser ::pour accéder directement aux fonctions dans les packages. Vous pouvez souvent voir l'utilisation de packages supplémentaires ici (par exemple, pour Python et Java). Cependant, j'ai changé mon ancien poste parce que je ne voulais pas discuter.
Sven Hohenstein
5

Python, 82 octets

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
Uriel
la source
1
@WheatWizard puisque vous avez déjà posté cela comme réponse, je pense que la bonne chose à faire pour moi serait de la reluquer plutôt que de la mettre à jour
Uriel
4

Plain TeX, 156 octets

\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat

Lisible

\newcount\a

\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}

\catcode`;=13
\catcode35=13

\let;=\;
\let#=\#

\loop
  \read16 to \> \>
  \iftrue \repeat
Uriel
la source
Peut-il imprimer des caractères symboliquement?
eush77
4

Perl, 25 octets

$_=chr(y%;%%%127)x/#/

Run with perl -043pe(compte comme 4 octets, car perl -eest standard).

Explanation: -043définit le terminateur de ligne sur #(ASCII 043). -pitère sur les «lignes» d'entrée (en fait # chaînes délimitées, maintenant). y%;%%compte le nombre de ;dans chaque "ligne". x/#/s'assure que nous n'imprimons pas de caractère supplémentaire pour les programmes qui ne se terminent pas par # (comme le troisième cas de test). %127devrait être assez évident. $_=est le passe-partout habituel.

Grimmy
la source
Impressionnant, bien qu'il y ait un petit problème: ;;#;;;il affiche le numéro 5 au lieu du numéro 2.
manatwork
Comment avez-vous obtenu ce résultat? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdsorties correctement 00000000: 02sur ma machine. Si vous avez omis la 043, ou utilisez une page de codes où #n'est pas ASCII 043, cela pourrait expliquer votre résultat.
Grimmy
1
Oops. Désolé, j'ai eu une faute de frappe dans mon test. Votre code fonctionne parfaitement.
manatwork
4

CJam, 27 octets

0q{";#"#") 127%co0 "S/=~}%;

Explication:

0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator

Solution alternative, 18 octets

q'#/);{';e=127%c}%

Explication:

q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for
Fruit d'esolanging
la source
Business Cat qui n'ignore pas les caractères non valides.
Esolanging Fruit
pourquoi avez-vous besoin ;de supprimer l'accumulateur?
Caird coinheringaahing
@RandomUser Donc, il ne finit pas par être affiché à la fin avec la chaîne.
ETHproductions
4

F #, 79 91 93 octets

let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y

Ungolfed

let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs

Essayez-le en ligne!

Edit: traitait tout autre caractère que ';' comme '#'. Changé pour ignorer les caractères invalides.

Alternative

F #, 107 104 octets

let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]

L'utilisation de la cellule de référence enregistre 3 octets

Ungolfed

let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]

Essayez-le en ligne

Brunner
la source
4

Processing.js (version de Khanacademy), 118 octets

var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}

Essayez-le en ligne!

Comme la version de traitement utilisée ne comporte aucune méthode de saisie, l'entrée est placée dans n.

Christopher
la source
Vous pouvez techniquement créer votre propre méthode de saisie avec keyTyped=function(){ ... }: P
ETHproductions
@ETHproductions Ceci est un regard de dégoût.
Christopher
@ RandomUser yay! Je l'ai fait! J'aime répondre en traitement (vérifier mes réponses)
Christopher
2
@RandomUser Pas seulement 1000 rep .. mais 2 ^ 10 rep (° ͜ʖ °)
@Midnightas Ohhh ouais
Christopher
4

Labyrinthe , 61 à 47 octets

_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".

Essayez-le en ligne!

Explication

image codée en couleur du code de la solution

L'exécution du code commence dans le coin supérieur gauche et le premier point-virgule supprime un zéro implicite de la pile et continue vers la droite.

Orange

  • _36pousse 36 sur la pile. Ceci est pour comparer l'entrée avec#
  • } déplace le haut de la pile vers la pile secondaire
  • , pousse la valeur entière du caractère sur la pile
  • )incrémente la pile (si c'est la fin de l'entrée, cela fera la pile 0 et le déroulement du programme ira à la @sortie)
  • { déplace le haut de la pile secondaire vers le haut de la pile principale
  • -pop y, pop x, appuyez sur x - y. C'est pour comparer l'entrée avec #(35 en ascii). Si l'entrée était #le code continuera à la section violette (parce que le haut de la pile est 0, l'adresse IP continue dans la direction dans laquelle elle se déplaçait auparavant), sinon elle passera à la section verte.

Violet

  • 127 poussez 127 à la pile
  • % pop x, pop y, pousse x% y
  • . faire apparaître le haut de la pile (l'accumulateur) et le sortir sous forme de caractère

De là, le code gris nous amène dans le coin supérieur gauche du programme avec rien sur la pile.

vert

  • _24 poussez 24 sur la pile
  • -pop x, pop y, appuyez sur xy. 24 est la différence entre #et ;donc ceci vérifie si l'entrée a été ;. Si c'était ;le code continue tout droit vers le ). Sinon, il se tournera vers le #qui pousse la hauteur de la pile (toujours un nombre positif, obligeant le programme à tourner à droite à la prochaine intersection et à manquer le code qui incrémente l'accumulateur)
  • ; jeter le haut de la pile
  • ) incrémenter le haut de la pile qui est soit un zéro implicite, soit un zéro précédemment incrémenté servant d’accumulateur pour la sortie

De là, le code gris nous mène dans le coin supérieur gauche du programme avec la pile contenant uniquement l'accumulateur.

gris

Les guillemets ne sont pas des opérations, _poussent un 0 sur la pile et ;rejettent le haut de la pile. Tout ceci n’est que du code pour forcer le flux de contrôle de la bonne manière et éliminer tout élément supplémentaire du haut de la pile.

Robert Hickman
la source
Par curiosité, comment avez-vous généré l'image d'explication? L'avez-vous créé vous-même?
Stefnotch
2
@Stefnotch, j'ai utilisé un éditeur de texte pour insérer une tabulation entre chaque caractère, puis collé le code dans Microsoft Excel, ce qui a permis de placer chaque caractère dans sa propre cellule. J'ai sélectionné toutes les cellules pour leur donner une largeur et une hauteur égales. Ensuite, j'ai ajusté les couleurs et les bordures et pris une capture d'écran.
Robert Hickman
3

MATL , 29 octets

';#'&mXz!"@o?T}vn127\c&YD]]vx

L'entrée est une chaîne entre guillemets simples.

Essayez-le en ligne!

Le programme FizzBuzz est trop long pour les interprètes en ligne. le voir travailler hors ligne dans ce gif:

entrez la description de l'image ici

Explication

La valeur de l'accumulateur est implémentée en tant que nombre d'éléments dans la pile. Cela rend le programme plus lent que si la valeur de l'accumulateur était un nombre unique dans la pile, il enregistre quelques octets.

';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display
Luis Mendo
la source
3

Alice , 22 octets

I!?';-n+?h$'@u%?'#-n$O

Essayez-le en ligne!

Explication

Nous ne conservons sur la pile qu'un seul compteur du nombre que ;nous avons rencontré. Lorsque la pile est vide (par exemple au début du programme), il s'agit implicitement d'un 0.

I!?';-n+?h$'@u%?'#-n$O
I                      Push codepoint of next char from input
 !?                    store it on the tape and reload it right away
   ';-n+               add 1 to the counter if this char is a semicolon,
                       0 otherwise
        ?h$'           If the input char was -1 (EOF) execute the next command,
                       otherwise push its codepoint
            @          Terminate the program (or push 64)
             u         Set all bits up to the most significant as equal to 1
                       this turns 64 (1000000b) into 127 (1111111b)
              %        Compute modulo
               ?       reload the input char from the tape
                '#-n$O if it is a hash, pop the counter and print
                       the corresponding character
                       wrap back to the start of the line

Une version plus courte mais non-terminante de ce programme est disponible ici .

Leo
la source
Nous l'avons
Désolé pour la mauvaise mise en forme, j'ai posté cela depuis mon téléphone, je vais le réparer dès que je vais avoir la main sur un PC
Leo
Les programmes doivent se terminer, sauf indication contraire dans le défi.
Martin Ender
Vous pouvez enregistrer un octet en utilisant un littéral 0x7F au lieu de ~h.
Martin Ender
@MartinEnder l'a fait se terminer. Je ne pouvais pas réussir à insérer un 0x7F dans le code, mais je pense que cette modification alternative est plus intéressante quand même :)
Leo
3

JS (ES6), 97 92 octets

c=>(a=0,y="",c.split``.map(x=>x=="#"?(a%=127,y+=String.fromCharCode(a),a=0):x==";"?a++:0),y)

J'ai essayé d'adopter une approche différente de celle de Shaggy . Tant pis.


la source
3

; # + , 59 octets, sans compétition

La langue a été faite après ce défi.

;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)

Essayez-le en ligne! L'entrée se termine par un octet nul.

Explication

La génération est la même que celle de ma réponse Generate; # code . La seule différence ici est l'itération.

Itération

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell
Conor O'Brien
la source
3

Bash + coreutils, 46 39 octets

tr -dc \;#|sed 'y/;/1/;s/#/.ZC7%P/g'|dc

Essayez-le en ligne!

Explication

(Merci Cocks Quack pour -7 octets!)

La trpartie supprime tous les caractères superflus (je pourrais mettre cela dans sedexactement le même décompte, mais elle ne gérera pas le caractère de saut de ligne correctement, car les sedlaisse dedans et n'atteint dcque le premier saut de ligne avec ?)

sedprend le reste et construit un dcprogramme:

Les chaînes de ;deviennent des chaînes de 1(un long littéral)

#devient .ZC7%P(si cela suit une chaîne de 1, le .est un point décimal pour un non-op. Mais si c'est au début du programme, ou après un autre #, c'est un littéral 0. Ensuite, il prend la longueur du nombre, le modifie, et imprime l’ASCII correspondant.)

Sophia Lechner
la source
Vous n'avez pas besoin d'échapper à l' ;intérieur '...'et pouvez simplement changer dc -ez?pour dc. En plus de cela, au lieu d’ ;ajouter 1 à la pile, vous pouvez les regrouper et obtenir leur longueur en utilisant Zpour atteindre ce tio.run/##S0oszvj/… .
Kritixi Lithos
@ Cowsquack C'est bien, merci! (et cela dc -ez?était une conséquence de la nécessité d'un zéro supplémentaire pour démarrer le programme) Mais votre programme ajoute une sortie supplémentaire stderrdans les cas consécutifs #ou des entrées ne se terminant pas par #(dans les deux cas, je veux dire après la suppression des caractères superflus) . Je ne sais pas s’il existe un consensus, mais j’ai le sentiment que la production supplémentaire invalide la solution. J'ai cependant adapté votre idée et je me suis retrouvé à un octet de plus que votre suggestion sans dcgénérer d'erreurs!
Sophia Lechner
Selon ce paramètre, stderr peut être ignoré à moins que le défi ne le stipule explicitement, ce qui est très pratique pour dc. Notez également que cette solution actuelle échoue avec des #s consécutifs à cause Zde 0is 1, elle génère donc 0x01 au lieu de 0x00 (je suis également tombé dans le même piège, mais mon navigateur affiche les fichiers non imprimables sous forme de codes hexadécimaux, donc j’ai attrapé cela).
Kritixi Lithos
3

C 65 64 60 octets

(-2 grâce à ceilingcat)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}
hvd
la source
Vous devrez initialiser cà zéro pour rendre la fonction réutilisable .
Conor O'Brien
@ ConorO'Brien Fixe. Malheureusement, je n'ai pas réussi à trouver quoi que ce soit de plus court que d'ajouter simplement le c=0, et je ne voudrais pas tricher en copiant la réponse de Dennis.
hvd
@ceilingcat Merci encore une fois, j'ai pu supprimer trois octets supplémentaires après cela. Cela utilise un truc dans la réponse de Dennis (vérifié après l'édition), mais cette fois, il s'était passé tellement de temps que j'avais tout oublié et que je l'avais tout seul.
hvd