Dividir números por 0

16

Todos nos han dicho en algún momento de nuestras vidas que dividir por 0 es imposible. Y en su mayor parte, esa afirmación es cierta. Pero ¿y si no era una forma de realizar la operación prohibido? Bienvenido a mi nueva creación: b-números.

b-los números son un poco como números imaginarios: el pronumeral principal involucrado representa una expresión que no es matemáticamente imposible ( irepresenta ). En este caso , se dirá que representa la expresión . A partir de aquí, es fácil determinar a qué sería igual:−1b10x0

x0=x1⋅10=xb

La tarea

Dada una expresión que involucra una división por 0, genera el valor simplificado en términos de . Tenga en cuenta que la entrada tendrá la forma de donde n es cualquier número racional o cualquier número en forma decimal. Los ceros iniciales y los ceros finales no se incluirán.bn/0b

Entrada de ejemplo

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

Salida de ejemplo

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

Puntuación

Este es el código de golf, por lo que gana menos bytes. Las lagunas estándar están prohibidas.

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

code-golf math number Lyxal
fuente
77
Sospecho que estoy haciendo algo mal, pero si b/0 = bentonces divido ambas partes para bentonces 1/0 = 1. ¿Necesito cnúmeros para dividir así?
mi pronombre es monicareinstate el
44
@Erik de esa manera, b/b = 0cuando normalmente (y estoy bastante seguro de que se puede comprobar fácilmente a partir de todos los diferentes axiomas) se espera que sea 1 (de lo contrario, el inverso multiplicativo de b parece no ser su inverso multiplicativo). Estoy bastante seguro de que simplemente no puede hacer una escapatoria contra la división por cero agregando b=1/0o algo similar.
mi pronombre es monicareinstate el
30
Hay una razón por la que la división por cero no está definida ... . Por lo tanto, debería poder simplificar todos los ejemplos (excepto el tercero de 0) a solobsi=1⋅si=11⋅si=33⋅si=3⋅13⋅0 0=30 0=3⋅10 0=3sisi
Mayormente inofensivo el
8
¿No debería el tercer ejemplo tener salida en 0blugar de 0? Si las dos expresiones fueran equivalentes, entonces la pregunta no tendría premisa
trichoplax
44
Caso de prueba sugerido:3.1b/0
jimmy23013

Respuestas:

19

Malbolge Unshackled (variante de rotación de 20 trits), 3,62e6 bytes

El tamaño de esta respuesta excede el tamaño máximo de programa postable (eh), por lo que el código se encuentra en mi repositorio de GitHub (nota: no copie el código usando CTRL + A y CTRL + C, solo haga clic derecho y haga clic en "Guardar elemento de destino como. .. ").

¿Cómo ejecutar esto?

Esto podría ser una parte difícil, porque el ingenuo intérprete de Haskell tardará siglos en ejecutarlo. TIO tiene un intérprete decente Malbogle Unshackled, pero lamentablemente no podré usarlo (limitaciones).

La mejor que pude encontrar es la variante de ancho de rotación fija de 20 trits, que funciona muy bien, calculando (más o menos) al instante .

Para que el intérprete sea un poco más rápido, eliminé todas las comprobaciones del intérprete 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;
}

¡Esta funcionando!

¡Esta funcionando!

Krzysztof Szewczyk
fuente
66
Espero que no hayas escrito todo eso.
connectyourcharger
55
Cuando abrí su programa, Chrome intentó traducirlo del polaco
Tharwen
@Tharwen de un vistazo, es difícil decir si es polaco o simplemente Malbolge. Lamentablemente, mi idioma es un infierno en la tierra para aprender.
Krzysztof Szewczyk
7

PHP , 65 64 61 58 bytes

-1 byte usando un en blugar de ''(cadena vacía). Como las "b" se recortan, será lo mismo que una cadena vacía en este caso específico.

-3 bytes usando en substrlugar de explodeobtener la primera parte de la entrada.

-3 bytes mediante el uso de mejores métodos para detectar 1y -1.

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

Pruébalo en línea!

Pruebas: ¡ Pruébelo en línea!

Si la primera parte de la entrada antes de "/" (la llamamos $n) es 0, imprime 0.

De lo contrario, se imprime $ncon cualquier "b" en el extremo recortado y se manejan casos especiales de -1 y 1, por lo que el dígito "1" no se imprime. Y al final se agrega una sola "b". La parte de recorte es asegurarse de que no obtengamos una doble "b" al final como "3bb".

Noche2
fuente
¡muy bien hecho!
Lyxal
Reemplazar $n==-1con $n>0(-2 bytes) parece funcionar. Podrías intentar eso.
Ismael Miguel
@IsmaelMiguel, eso no funciona, si querías decir $n<0, eso tampoco funcionará, ya que tenemos entradas como -8/0.
Noche2
@IsmaelMiguel, pero me diste una idea, ¡reemplazada $n==-1?'-':$npor $n+1?$n:'-'para guardar 2 bytes!
Noche2
1
: / Cuando lo probé, parecía funcionar. pero bueno, bueno que encontraste otra manera.
Ismael Miguel
4

Jalea , 18 bytes

Terminé robando Erik's ṾṖ$İƑ¡ para este (de lo contrario, también tendría 19) ...

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

Un programa completo que imprime el resultado.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

ṖṖ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
fuente
1
Ahhh, y estaba pensando en formas en que podría abusar v...: D
Erik the Outgolfer
4

Perl 6 , 32 bytes

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

Pruébalo en línea!

Un par de expresiones regulares, uno para comprobar si la entrada es 0/0, y el otro para reemplazar el arrastre /0con sólo b(y para eliminar el viejo b, 1y / o -1)

Explicación (antigua)

{                          }  # 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
fuente
3

Retina , 28 24 bytes

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

Pruébalo en línea!

Primero intente usar Retina, por lo que probablemente haya un espacio considerable para jugar al golf.

Cadena no relacionada
fuente
2
18 bytes: ¡ Pruébelo en línea!
jimmy23013
Después de buscar lo que \bhace (soy tan inexperto con la expresión regular), me decepcionó un poco descubrir que no se puede acortar al carácter de retroceso no imprimible. De todos modos, gracias
Cadena no relacionada
1
@UnrelatedString, por supuesto, no se puede acortar a retroceso, después de todo, \bes simplemente una representación ASCII del carácter de retroceso en cadenas normales: P
Solo ASCII
2

Python 3 , 68 bytes

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

Pruébalo en línea!

Kazim
fuente
Buena solución! Pero import reaumenta el bytecount a 64.
movatica
1
Buen punto de @movatica, nuevo aquí, así que no me di cuenta de que se incluyó una declaración de importación (aunque, por supuesto, lo está). Editado
Kazim
¡Bienvenido! :) ¡Sin embargo, aún puedes conservar la versión lambda más corta! No necesita ser un programa completo. Y la declaración de importación se puede colocar después de la definición lambda, por lo que son posibles 64 bytes .
movatica
1
@movatica ah, bien! No encontré una manera de hacerlo funcionar con import y lambda. Gracias
Kazim
1

Barril , 18B

Todo el crédito es para Jono 2906.

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

Explicación

__                 # 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!

un'_'
fuente
1

JavaScript (ES6), 45 bytes

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

Pruébalo en línea!

Comentado

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
fuente
1

C, 209 203 137 bytes

-66 bytes gracias a ceilingcat

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
fuente
Poner en -0/0 da -0b, pero nunca estuvo en la entrada de ejemplo o en los casos de prueba, por lo que es correcto.
girobuz
1

naz , 64 bytes

6a8m1s2x1v2m4a2x2v1x1f1r3x1v2e3x2v3e1o1f0x1x2f2m4a1o0x1x3f1o0x1f

Explicación (con los 0xcomandos eliminados)

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
bola de espora
fuente
0

Brainfuck, 25 bytes

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

Explicación

>,[>,]        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
Miguel
fuente
1
b/0esperado b, conseguido bb; 0/0esperado 0, conseguido 0b; -1/0esperado -b, conseguido -1b.
a'_ '
Sí, básicamente, esto sólo se sustituye el /0para by no toma en cuenta ninguno de los casos de 0b, 1b, -1bo cualquier entrada que ya contienen unb
Jo Rey