Diviser les nombres par 0

16

On nous a tous dit à un moment donné de notre vie qu'il était impossible de diviser par 0. Et pour la plupart, cette affirmation est vraie. Mais que faire s'il y avait un moyen d'effectuer l'opération interdite? Bienvenue dans ma dernière création: b-numéros.

b-les nombres sont un peu comme des nombres imaginaires: le pronuméral principal impliqué représente une expression qui n'est pas mathématiquement impossible ( ireprésente -1 ). Dans ce cas,bsera dit représenter l'expression10 . De là, il est facile de déterminer ce queX0 serait égal à:

X0=X1⋅10=Xb

La tâche

Étant donné une expression impliquant une division par 0, affichez la valeur simplifiée en termes de b . Notez que l'entrée sera sous la forme n/0où n est n'importe quel nombre rationnel ou n'importe quel bnombre sous forme décimale. Les 0 au début et les 0 à la fin ne seront pas inclus.

Exemple d'entrée

4/0
1/0
0/0
80/0
-8/0
1.5/0
2.03/0
-1/0
-3.14/0
b/0
3b/0
-b/0
121/0

Exemple de sortie

4b
b
0
80b
-8b
1.5b
2.03b
-b
-3.14b
b
3b
-b
121b

But

C'est le golf de code, donc le moins d'octets gagne. Les failles standard sont interdites.

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf math number Lyxal
la source
7
Je soupçonne que je fais quelque chose de mal, mais si b/0 = balors je divise les deux parties d'ici blà 1/0 = 1. cAi -je besoin de -nombre pour diviser comme ça?
mon pronom est monicareinstate
4
@Erik de cette façon, b/b = 0quand il est normalement (et je suis sûr qu'il est facilement prouvé par tous les différents axiomes) censé être 1 (sinon l'inverse multiplicatif de b ne semble pas être son inverse multiplicatif). Je suis sûr que vous ne pouvez pas échapper à la division par zéro en ajoutant b=1/0ou quelque chose de similaire.
mon pronom est monicareinstate
30
Il y a une raison pour laquelle la division par zéro n'est pas définie ... . Vous devriez donc être en mesure de simplifier tous les exemples (à l'exception du tiers de 0) pour simplementbb=1⋅b=11⋅b=33⋅b=3⋅13⋅0=30=3⋅10=3bb
Surtout inoffensif
8
Le troisième exemple ne devrait-il pas avoir une sortie 0bplutôt que 0? Si les deux expressions étaient équivalentes, la question n'aurait pas de prémisse
trichoplax
4
Cas de test suggéré:3.1b/0
jimmy23013

Réponses:

19

Malbolge Unshackled (variante de rotation de 20 trits), 3,62e6 octets

La taille de cette réponse dépasse la taille maximale du programme (eh), donc le code se trouve dans mon référentiel GitHub (remarque: ne copiez pas le code en utilisant CTRL + A et CTRL + C, faites un clic droit et cliquez sur "Enregistrer l'élément de destination sous." .. ").

Comment faire ça?

Cela pourrait être une partie délicate, car un interprète naïf de Haskell prendra des âges pour exécuter cela. TIO a un interprète Malbogle Unshackled décent, mais malheureusement je ne pourrai pas l'utiliser (limitations).

Le meilleur que j'ai pu trouver est la variante de largeur de rotation fixe de 20 trits, qui fonctionne très bien, calculant (presque) instantanément .

Pour rendre l'interprète un peu plus rapide, j'ai supprimé toutes les vérifications de l'interpréteur Malbolge Unshackled de Matthias Lutter.

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

Ça marche!

Ça marche!

Krzysztof Szewczyk
la source
6
J'espère que vous n'avez pas tapé tout ça.
connectyourcharger
5
Lorsque j'ai ouvert votre programme, Chrome a tenté de le traduire du polonais
Tharwen
@Tharwen en un coup d'œil, il est difficile de dire que c'est polonais ou simplement Malbolge. Malheureusement, ma langue est l'enfer sur terre à apprendre.
Krzysztof Szewczyk
7

PHP , 65 64 61 58 octets

-1 octet en utilisant un bau lieu de ''(chaîne vide). Puisque les "b" sont coupés, ce sera la même chose qu'une chaîne vide dans ce cas spécifique.

-3 octets en utilisant substrau lieu de explodepour obtenir la première partie de l'entrée.

-3 octets en utilisant de meilleures méthodes pour détecter 1et -1.

<?=($n=substr($argn,0,-2))?trim($n+1?$n-1?$n:b:'-',b).b:0;

Essayez-le en ligne!

Tests: Essayez-le en ligne!

Si la première partie de l'entrée avant "/" (nous l'appelons $n) est 0, imprime 0.

Sinon, il s'imprime $navec tout "b" à la fin et les cas spéciaux de -1 et 1 traités, de sorte que le chiffre "1" n'est pas imprimé. Et à la fin ajoute un seul "b". La partie de coupe est de s'assurer que nous n'obtenons pas un double "b" à la fin comme "3bb".

Nuit2
la source
très bien fait!
Lyxal
Le remplacement $n==-1par $n>0(-2 octets) semble fonctionner. Vous pouvez essayer ça.
Ismael Miguel
@IsmaelMiguel, cela ne fonctionne pas, si vous vouliez dire $n<0, cela ne fonctionnera pas aussi, car nous avons des entrées comme -8/0.
Night2
@IsmaelMiguel, mais vous m'avez donné une idée, remplacée $n==-1?'-':$npar $n+1?$n:'-'pour économiser 2 octets!
Night2
1
: / Quand j'ai testé, ça semblait marcher. mais bon, c'est une bonne chose que vous ayez trouvé un autre moyen.
Ismael Miguel
4

Gelée , 18 octets

J'ai fini par voler celui d' Erik ṾṖ$İƑ¡ pour celui-ci (sinon j'en aurais aussi 19) ...

ṖṖv0ḢṾṖ$İƑ¡,Ạ¡”boḢ

Un programme complet qui imprime le résultat.

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

ṖṖv0ḢṾṖ$İƑ¡,Ạ¡”boḢ - Main Link: list of characters S
Ṗ                  - discard right-most (of S)
 Ṗ                 - discard right-most
   0               - literal zero
  v                - evaluate as Jelly code with right argument (0)
                   - ... b is covert-to-base, so "nb0" gives [n]
    Ḣ              - head ([n]->n or n->n)
          ¡        - repeat...
         Ƒ         - ...# of times: is invariant under:
        İ          -   reciprocation (n->1/n)
       $           - ...action: last two links as a monad:
     Ṿ             -   un-evaluate (-1->"-1" or 1->"1")
      Ṗ            -   discard right-most ("-1"->"-" or "1"->"")
             ¡     - repeat...
            Ạ      - ...# of times: all?
           ,  ”b   - ...action: pair with a 'b' character
                o  - logical OR with:
                 Ḣ -   head (S)  (i.e. if we end with 0 use the 1st character of the input)
                   - implicit print
Jonathan Allan
la source
1
Ahhh, et je pensais à des façons dont je pouvais abuser v...: D
Erik the Outgolfer
4

Perl 6 , 32 octets

{~m/^0/||S/[(\-|^)1|b]?\/0/$0b/}

Essayez-le en ligne!

Quelques expressions rationnelles, un pour vérifier si l'entrée est 0/0, et l'autre pour remplacer le suivi /0avec juste b(et pour enlever le vieux b, 1et / ou -1)

Explication (ancienne)

{                          }  # Anonymous codeblock
 ~m/^0/     # Return 0 if the input starts with 0
       ||   # Otherwise
         S/             / /  # Substitute
                     \/0       # The /0
          (        )?          # Optionally starting with
           <wb>1               # 1 or -1
                |b             # Or b
                         b   # With just b
Jo King
la source
3

Rétine , 28 24 octets

b?/0
b
^0b
0
(^|-)1b
$1b

Essayez-le en ligne!

Essayez d'abord d'utiliser Retina, donc il y a probablement beaucoup de place pour le golf.

Chaîne indépendante
la source
2
18 octets: essayez-le en ligne!
jimmy23013
Après la chasse de ce \bfait (je suis que inexpérimenté avec regex), j'étais un peu déçu de constater qu'il ne peut pas être raccourci au backspace unprintable. Quoi qu'il en soit, merci
Unrelated String
1
@UnrelatedString bien sûr, il ne peut pas être raccourci en retour arrière, après tout, \bn'est qu'une représentation ASCII du caractère de retour arrière dans les chaînes normales: P
ASCII uniquement
2

Python 3 , 68 octets

import re
print(re.sub('^0b$','0',re.sub(r'(^1)?b?/0','b',input())))

Essayez-le en ligne!

Kazim
la source
Bonne solution! Mais import rele nombre augmente à 64.
movatica
1
@movatica bon point, nouveau ici, donc je ne savais pas que la déclaration d'importation était incluse (bien sûr, elle l'est). Édité.
Kazim
Bienvenue! :) Vous pouvez toujours garder la version lambda plus courte! Il n'est pas nécessaire que ce soit un programme complet. Et l'instruction import peut être placée après la définition lambda, donc 64 octets sont possibles !
movatica
1
@movatica ah, sympa! Je n'ai pas trouvé de moyen de le faire fonctionner avec import et lambda. Merci
Kazim
1

Keg , 18B

Tout crédit revient à Jono 2906.

__:b=;[b]^:\1=[_]^

Explication

__                 # Take implicit input and remove the "trash" (/0).
  :b=              # Is the last character equal to b?
     ;             # Negate(decrement) this value.
      [b]          # If the last character is not b, append b.
         ^         # Reverse the stack.
          :\1=     # Is the first character equal to 1?
              [_]  # If so, reduce the value.
                 ^ # Reverse the stack back and implicit output.

TIO!

une'_'
la source
1

JavaScript (ES6), 45 octets

s=>+(n=s.split`/`[0])?[n*n-1?n:'-'[~n]]+'b':n

Essayez-le en ligne!

Commenté

s =>                  // s = input: "numerator/0"
  +(                  //
    n = s.split`/`[0] // n = numerator, as a string
  ) ?                 // if n coerced to a Number is neither equal to 0 nor NaN:
    [ n * n - 1 ?     //   if abs(n) is not equal to 1:
        n             //     append the numerator
      :               //   else:
        '-'[~n]       //     append '-' if n = -1, or an empty string otherwise
    ] + 'b'           //   append 'b'
  :                   // else:
    n                 //   just output the numerator because it's either "0" or
                      //   an expression that already contains 'b'
Arnauld
la source
1

C, 209 203 137 octets

-66 octets grâce au plafond

char a[9];main(f){gets(a);f=strlen(a)-3;a[f+1]=0;printf((*a==55&a[1]==49&f==1?a[1]=98:*a==49&!f?*a=98:a[f]==98|*a==48&!f)?"%s":"%sb",a);}

TIO

Girobuz
la source
Mettre -0/0 donne -0b, mais ce n'était jamais dans l'exemple d'entrée ou les cas de test, donc c'est correct.
girobuz
1

naz , 64 octets

6a8m1s2x1v2m4a2x2v1x1f1r3x1v2e3x2v3e1o1f0x1x2f2m4a1o0x1x3f1o0x1f

Explication (avec 0xcommandes supprimées)

6a8m1s2x1v             # Set variable 1 equal to 47 ("/")
2m4a2x2v               # Set variable 2 equal to 98 ("b")
1x1f                   # Function 1
    1r                 # Read a byte of input
      3x1v2e           # Jump to function 2 if it equals variable 1
            3x2v3e     # Jump to function 3 if it equals variable 2
                  1o1f # Otherwise, output it and jump back to the start of the function
1x2f2m4a1o             # Function 2
                       # Set the register equal to 98 and output once
1x3f1o                 # Function 3
                       # Output once
1f                     # Call function 1
sporeball
la source
0

Brainfuck, 25 octets

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

Explication

>,[>,]        read from stdin
<[-<+>]<+++   add last two cells and add three ( ascii('/') + ascii('0') + 3 = ascii('b')
[<]>          move pointer to first char to output
[.>]          output until cell w/ value 0
Michael
la source
1
b/0attendu b, obtenu bb; 0/0attendu 0, obtenu 0b; -1/0attendu -b, obtenu -1b.
a'_ '
Ouais, en fait cela ne remplace le /0pour bet ne tient pas compte des cas pour 0b, 1b, -1bou toutes les entrées qui contiennent déjàb
Jo Roi