Разделите числа на 0

16

В какой-то момент нашей жизни нам всем сказали, что деление на 0 невозможно. И по большей части это утверждение верно. Но что, если бы был способ выполнить запрещенную операцию? Добро пожаловать в мое новейшее творение: b-numbers.

bчисла немного похожи на мнимые числа: основной пронумерованный термин представляет выражение, которое не является математически невозможным ( iпредставляет −1 ) В этом случаебудет сказано, чтоbпредставляет выражение10 . Отсюда легко определить, чтоx0 будет равно:

x0=x1⋅10=xb

Задание

Учитывая выражение, включающее деление на 0, выведите упрощенное значение в терминах b . Обратите внимание, что входные данные будут иметь вид, n/0где n - любое рациональное число или любое число bв десятичной форме. Лидирующие 0 и конечные 0 не будут включены.

Пример ввода

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

Пример вывода

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

Гол

Это код гольф, поэтому побеждает меньше байтов. Стандартные лазейки запрещены.

Leaderboards

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш счет равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать название языка ссылкой, которая затем будет отображаться в фрагменте списка лидеров:

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

Показать фрагмент кода

code-golf math number Lyxal
источник
7
Я подозреваю, что я делаю что-то не так, но если b/0 = bтогда я разделю обе части к тому bвремени 1/0 = 1. Нужно ли мне - cчисла делить, как это?
мое местоимение monicareinstate
4
@ Эрик, таким образом, b/b = 0когда это обычно (и я почти уверен, что это легко доказывается по всем различным аксиомам), ожидается, что оно будет равно 1 (в противном случае мультипликативная обратная величина b, по-видимому, не является мультипликативной обратной). Я почти уверен, что вы просто не можете сделать лазейку против деления на ноль, добавив b=1/0или что-то подобное.
мое местоимение monicareinstate
30
Там причина деления на ноль не определена ... . Таким образом, вы должны быть в состоянии упростить все примеры (за исключением третьего из 0) до простоbбзнак равно1⋅бзнак равно11⋅бзнак равно33⋅бзнак равно3⋅13⋅0знак равно30знак равно3⋅10знак равно3бб
Mostly Harmless
8
Не должен ли третий пример иметь вывод, 0bа не 0? Если эти два выражения эквивалентны , то вопрос не будет иметь предпосылки
Trichoplax
4
Предлагаемый тестовый пример:3.1b/0
jimmy23013

Ответы:

19

Malbolge Unshackled (вариант вращения 20-трит), 3,62e6 байт

Размер этого ответа превышает максимально допустимый размер программы (eh), поэтому код находится в моем репозитории GitHub (примечание: не копируйте код, используя CTRL + A и CTRL + C, просто щелкните правой кнопкой мыши и нажмите «Сохранить элемент назначения как». .. ").

Как запустить это?

Это может быть непростой задачей, потому что наивному интерпретатору Haskell понадобятся годы, чтобы запустить это. У TIO есть приличный интерпретатор Malbogle Unshackled, но, к сожалению, я не смогу его использовать (ограничения).

Лучший вариант, который я смог найти, - это фиксированный вариант ширины вращения в 20 трит, который работает очень хорошо, вычисляя (в значительной степени) мгновенно .

Чтобы сделать переводчика немного быстрее, я удалил все проверки из интерпретатора Мэттиласа Люттера «Малболж».

#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;
}

Работает!

Работает!

Кшиштоф Шевчик
источник
6
Я надеюсь, что вы не все это напечатали.
connectyourcharger
5
Когда я открыл вашу программу, Chrome попытался перевести ее с польского
Tharwen
@ Tharwen с первого взгляда, трудно сказать, польский это или просто Malbolge. К сожалению, мой язык ад на земле, чтобы учиться.
Кшиштоф Шевчик
7

PHP , 65 64 61 58 байт

-1 байт, используя bвместо ''(пустую строку). Поскольку "b" обрезаются, в этом конкретном случае это будет то же самое, что и пустая строка.

-3 байта, используя substrвместо того, explodeчтобы получить первую часть ввода.

-3 байта, используя лучшие методы для обнаружения 1и-1 .

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

Попробуйте онлайн!

тесты: попробуйте онлайн!

Если первая часть ввода перед "/" (мы называем это $n ) равна 0, печатается 0.

Остальное печатает $nсебя с любым «b» на конце, обрезанным от него, и специальными случаями -1 и 1 обрабатываются, поэтому цифра «1» не печатается. И в конце добавляется один «б». Часть обрезки должна убедиться, что мы не получаем двойной «b» в конце, как «3bb».

night2
источник
очень красиво сделано!
Lyxal
Замена $n==-1на $n>0(-2 байта), кажется, работает. Вы можете попробовать это.
Исмаэль Мигель
@IsmaelMiguel, это не работает, если вы имели в виду $n<0, это тоже не будет работать, так как у нас есть входы, как -8/0.
Ночь2
@IsmaelMiguel, но вы дали мне идею, заменить $n==-1?'-':$nс , $n+1?$n:'-'чтобы сохранить 2 байта!
Ночь2
1
: / Когда я проверял, это, казалось, работало. но хорошо, что вы нашли другой способ.
Исмаэль Мигель
4

Желе , 18 байт

Я закончил тем, что украл Эрика ṾṖ$İƑ¡ для этого (иначе у меня тоже было бы 19) ...

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

Полная программа, которая печатает результат.

Попробуйте онлайн! Или посмотрите набор тестов .

Как?

ṖṖ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
Джонатан Аллан
источник
1
Аааа, и я думал о том, как я мог бы злоупотреблять v...: D
Эрик Outgolfer
4

Perl 6 , 32 байта

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

Попробуйте онлайн!

Несколько регулярных выражений, один , чтобы проверить , если вход 0/0, а другой , чтобы заменить буксировку /0только с b(и удалить старый b, 1и / или -1)

Пояснение (старое)

{                          }  # 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
Джо Кинг
источник
3

Retina , 28 24 байта

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

Попробуйте онлайн!

Сначала попробуйте использовать Retina, чтобы, вероятно, было достаточно места для игры в гольф.

Несвязанная строка
источник
2
18 байт: попробуйте онлайн!
jimmy23013
После охоты на то , что \bделает (я что неопытный с регулярным выражением), я был немного разочарован, обнаружив , что он не может быть сокращен до непечатаемую возврата на один символ. В любом случае, спасибо
несвязанная строка
1
@UnrelatedString, конечно, его нельзя сократить до backspace, в конце концов, \bэто просто представление ASCII символа backspace в обычных строках: P
только ASCII
2

Python 3 , 68 байт

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

Попробуйте онлайн!

Казим
источник
Отличное решение! Но import reвозрастает до 64.
Movatica
1
@movatica хорошая точка зрения, новый здесь, так что не понимаю, импортное заявление было включено (хотя, конечно, это так). Ред.
Казим
Добро пожаловать! :) Вы все еще можете сохранить более короткую лямбда-версию, хотя! Это не обязательно должна быть полная программа. И оператор импорта может быть помещен после определения лямбды, так что 64 байта возможен !
Моватика
1
@ Movatica ах, приятно! Я не нашел способа заставить его работать с импортом и лямбдой. Спасибо
Казим
1

бочонок , 18Б

Вся заслуга Джоно 2906.

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

объяснение

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

a'_»
источник
1

JavaScript (ES6), 45 байт

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

Попробуйте онлайн!

комментарии

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
источник
1

С 209 203 137 байт

-66 байт благодаря функциюcatcat

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
источник
Ввод -0/0 дает -0b, но его никогда не было в вводных или тестовых примерах, поэтому это правильно.
girobuz
1

naz , 64 байта

6a8m1s2x1v2m4a2x2v1x1f1r3x1v2e3x2v3e1o1f0x1x2f2m4a1o0x1x3f1o0x1f

Пояснение (с 0xудаленными командами)

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
источник
0

Brainfuck, 25 байтов

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

объяснение

>,[>,]        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
Майкл
источник
1
b/0ожидал b, получил bb; 0/0ожидал 0, получил 0b; -1/0ожидал -b, получил -1b.
a'_»
Да, в основном это заменяет только /0для bи не принимает во внимание какие - либо из случаев , для 0b, 1b, -1bили каких - либо исходных данных , которые уже содержитb
Джо Кинг