Codegolf - Я Вижу Твои Бидмас И Поднимаю Тебе Бадмис

Affiddede26

Я вижу твои БИДМАСЫ и поднимаю тебе БАДМИС

Испытание

Учитывая набор чисел с операторами между ними: «5 + 4 * 9/3 - 8», возвращайте все возможные результаты выражения для каждой перестановки порядка основных операций: [/, *, +, -].

Правила

Стандартные лазейки запрещены
ввод/вывод
- Ввод должен быть упорядочен с помощью инфиксных операций, но это проще всего (строка или массив).
- От вас не требуется поддержка унарных операторов (например, «-3 * 8 / +2»).
- Целые числа можно заменить числами с плавающей запятой для языков, которые неявно анализируют тип (например, 45 ⟶ 45.0).
- Выходные данные должны представлять собой все возможные результаты выражения, без указания формата или порядка.
Все входные данные действительны (например, не нужно иметь дело с «7 / 3 + *»). Это также означает, что вам никогда не придется делить на ноль.
Все операторы левоассоциативны, поэтому «20/4/2» = «(20/4)/2»
Это Code Golf, поэтому выигрывает наименьшее количество байтов.

Тестовые случаи (с объяснением)

"2 + 3 * 4" = [14, 20]
- 2 + (3 * 4) ⟶ 2 + (12) ⟶ 14
- (2 + 3) * 4 ⟶ (5) * 4 ⟶ 20
"18 / 3 * 2 - 1" = [11, 2, 6]
- ((18 / 3) * 2) - 1 ⟶ ((6) * 2) - 1 ⟶ (12) - 1 ⟶ 11
- (18 / 3) * (2 - 1) ⟶ (6) * (1) ⟶ 6
- (18 / (3 * 2)) - 1 ⟶ (18 / (6)) - 1 ⟶ (3) - 1 ⟶ 2
- 18 / (3 * (2 - 1)) ⟶ 18 / (3 * (1)) ⟶ 6
- 18 / ((3 * 2) - 1) ⟶ 18 / 5 ⟶ 3.6

Тестовые случаи (без объяснения)

"45 / 8 + 19 / 45 * 3" = [6.891666666666667, 18.141666666666666, 0.11111111111111113, 0.01234567901234568, 0.01234567901234568, 5.765740740740741]
"2 + 6 * 7 * 2 + 6 / 4" = [112 196 23 87.5]

#код-гольф #перестановки

Qwerty202

JavaScript (V8), 118 112 байт

Распечатывает результаты.

                    my%H;map{$H{$`.(eval$&.$1).$2}++while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=join$",keys%H;/[-+*\/]/&&redo

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

Или посмотреть дедуплицированные результаты.

N_E_O_N

C# (интерактивный компилятор Visual C#), 285 байт

my$x;map{$x.=$`.(eval$&.$1).$2.$"while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=$x;/[-+*\/]/&&redo

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

-alp ||answer||

JavaScript (Node.js), 132 байта

julia> f([18, /, 3, *, 2, -, 1])
3-element Array{Array{Array{Float64,1},1},1}:

[[11.0], [6.0]]

[[2.0], [3.6]] 

[[6.0], [6.0]]

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

Это позволяет дублировать выходные данные.

JavaScript (Node.js), 165 161 155 153 152 137 байт

f(t)=get(t,(),f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2))

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

Принимает строку с пробелами между операторами и числами.

get(t, (), ...) ||answer||

Перл 6, 92 90 88 байт

julia> f([2, +, 3, *, 4])
2-element Array{Int64,1}:

20

14

julia> f([18, /, 3, *, 2, -, 1])
6-element Array{Float64,1}:

11.0

6.0

2.0

3.6

6.0

6.0

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

Принимает строку с пробелом после любых операторов и возвращает набор чисел. В основном это работает путем замены всех экземпляров f(t)=get(t,(),[f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2)...;]) with the eval'ed result for all permutations of the operators.

Объяснение:

import re
def f(s,P=set('+-/*')):

S=[eval(s)]

for p in P:
	t=s
	while p+' 'in t:t=re.sub(r'[-\d.]+ \%s [-\d.]+'%p,lambda m:`eval(m.group())`,t,1)
	S+=f(t,P-{p})

return S

||answer||

Питон 3, 108 байт

Ḋ         | Remove first item (which will be a number)

m2       | Every 2nd item, starting with the first (i.e. the operators)

Q      | Uniquify

Œ!    | Permutations

çƒ€ | For each permuted list of operators, reduce using the helper link and with the input list as the starting point

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

Функция принимает на вход одну строку и возвращает список возможных результатов.

Негольфед

œṡ⁹                  | Split once by the right argument (the operator currently being processed)

? | If:

$  | - Following as a monad

L    |   - Length

’   |   - Decremented by 1

ʋ      | Then, following as a dyad:

¹                 | - Identity function (used because of Jelly’s ordering of dyadic links at the start of a dyadic chain)

j       ɗ        | - Join with the following as a dyad, using the original left and right arguments for this chain:

ṪḢ?€            |   - Tail of first item (popping from list) and head from second item (again popping from list); extracts the numbers that were either side of the operator, while removing them from the split list

j           |   - Joined with the operator

ŒV         |   - Evaluate as Python (rather than V because of Jelly’s handling of decimals with a leading zero)

ß        | - Recursive call to this helper link (in case there are further of the same operator)

F     | Else: Flatten

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

Cox2001

Желе, 30 байт

œṡ⁹¹jṪḢ?€jŒVɗßʋFL’$?
Ḋm2QŒ!çƒ€

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

Пара ссылок. Вторая является основной ссылкой и принимает в качестве аргумента список Jelly чисел с плавающей запятой/целых чисел с вкраплениями операторов в виде символов. Это упрощенная версия того, как Jelly принимает входные данные при запуске полной программы с аргументами командной строки. Возвращаемое значение ссылки представляет собой список списков с одним элементом, каждый из которых является возможным значением для выражения.

Объяснение

Вспомогательная ссылка

Принимает список чисел с плавающей запятой/целых чисел, чередующихся с операторами (как символами) в качестве левого аргумента и оператором в виде символа в качестве правого аргумента; возвращает список ввода после оценки чисел, разделенных соответствующим оператором, слева направо.

def get_all_eval_results(expr, operators={*"+-*/"}):

results = []

for operator in operators:

remaining_operators = operators - {operator}

# Split expression with the current operator and recursively evaluate each subexpression with remaining operators

sub_expr_results = (get_all_eval_results(sub_expr, remaining_operators) for sub_expr in expr.split(operator))

for result_group in zip(*sub_expr_results):   # Iterate over each group of subexpression evaluation outcomes

expr_to_eval = operator.join(result_group)  # Join subexpression outcomes with current operator

results.append(str(eval(expr_to_eval)))   # Evaluate and append outcome to result list of expr

return results or [expr]  # If results is empty (no operators), return [expr]

Основная ссылка

Принимает список чисел с плавающей запятой/целых чисел, чередующихся с операторами (как символы)

f=lambda e,s={*"+-*/"}:[str(eval(p.join(g)))for p in s for g in zip(*map(f,e.split(p),[s-{p}]*len(e)))]or[e]

||answer||

Питон 2, 182 172 байт

{                                                                                   }  # Anonymous code block

<* / + ->>>.&{                                    } # Map the operators to:

$^a;&{                             }  # Functions that:

S:g{                }      # Substitute all matches of:

\-?<[\d.]>+]+        # Numbers

%$a     # Joined by the operator

=$/.EVAL   # With the match EVAL'd

map {           },                                                    .permutations   # Map each of the permutations of these operators

[o](@_)        # Join the functions

($_)    # And apply it to the input

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

Принимает входные данные с целыми числами, отформатированными как числа с плавающей запятой, согласно «Целые числа могут быть заменены числами с плавающей запятой для языков, которые неявно анализируют тип».

Raramuri

Юля 1.2, 88 (82) байт

n op n

{map {[o](@_)($_)},<* / + ->>>.&{$^a;&{S:g{[\-?<[\d.]>+]+%"$a "}=$/.EVAL}}.permutations}

Берет ленту в виде вектора чисел и инфиксных функций, оценивает каждый отдельный вызов функции и рекурсивно передает каждую результирующую ленту обратно себе, пока не останется только одно число. К сожалению, a=> // Main function: Object.keys( // Return the keys of the - ( F=( // Index container (helper function): b, // Operators a // The expression )=> b // If there are operators left: ?[...b].map( // For each operator: q=> F( // Recur the helper function - b.replace(q,""), // With the operator deleted a.replace( // And all - eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`), // Expressions using the operator eval // Replaced with the evaluated result ) ) ) :F[a]=1 // Otherwise - set the result flag. )( "+-*/", // Starting with the four operators a // And the expression ) &&F ) doesn't work properly in Julia 1.0, so a newer version is needed.

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

a=>Object.keys((F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):F[a]=1)("+-*/",a)&&F)

Выход:

a=>(w=[],F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):w.push(a))("+-*/",a)&&w

||answer||

Перл 5 ( x=>{ //Lambda taking in a List<dynamic> int c=0,j,t=1,i; //A bunch of delcarations jammed together to save bytes for(;c++<25;t=c){ //Loop 24 times (amount of permutations a set of length 4 can have) var r="/+-".ToList(); //Initialize r as list of operators for(i=j=1;j++<4;t=t/j+1) //Create the Tth permutation, saving result in r, also reset i to 1 (r[j-1],r[t%j])=(r[t%j],r[j-1]); float k(float z,int p=4) { //Define local function 'k', with z as current value accumalated and p as current precedence char d;int l;float m; //Some helper variables return i<x.Count //If this is not the last number &&(l=r.IndexOf(d=x[i][0]))<p? // And the current operator's precedence is higher than the current precedence k( // Recursive call with the accumalative value as (m=k(x[(i+=2)-1],l)) // Another recursive call with the next number following the current operator as seed value, // And the next operator's precedence as the precedence value, and store that in variable 'm' 0+d<43?z*m:d<44?z+m:d<46?z-m:z/m, // And doing the appropriate operation to m and current value ('z') p) // Passing in the current precedence :z; //Else just return the current number } Print(k(x[0])); //Print the result of calling k with the first number as starting value } } ), 89 bytes

x=>{int c=0,j,t=1,i;for(;c++<25;t=c){var r="*+-/".ToList();for(i=j=1;j++<4;t=t/j+1)(r[j-1],r[t%j])=(r[t%j],r[j-1]);float k(float z,int p=4){char d;int l;float m;return i<x.Count&&(l=r.IndexOf(d=x[i][0]))<p?k((m=k(x[(i+=2)-1],l))*0+d<43?z*m:d<44?z+m:d<46?z-m:z/m,p):z;}Print(k(x[0]));}}

ТИО

или уникальные значения, 99 байт

f=(s,x='',y=x,o='+-*/')=>[...o].map(v=>f(s.split(v).join(x+v+y),x+')',y+'(',o.replace(v,'')))|print(eval(y+s+x))

Похожие темы	Дата
Ссылка текст+картинка	19.12.2024, 05:12
Математика – Маневрируйте Сеткой!	19.12.2024, 05:12
Codegolf — Сжатие Текста	19.12.2024, 05:12
Codegolf — Коллекция Из Последовательности, Образующей Идеальный Квадрат.	19.12.2024, 05:12
Царь Горы - Продавец Горячего Картофеля	19.12.2024, 05:12
Codegolf - Будь Счастлив И Зол	19.12.2024, 05:12
Codegolf - Какого Персонажа Поменять (Полицейские)	19.12.2024, 05:12
Последовательность — Ограниченные Мини-Испытания «Полицейская Нить»	19.12.2024, 05:12
Конкурс Популярности - Вычисли Наибольшее Количество Цифр Числа Пи	19.12.2024, 05:12
Codegolf — Напишите Функцию, Которая Суммирует Сумму Двух Целых Чисел С Помощью Поразрядных Операций Без Условных Операций.	19.12.2024, 05:12

Codegolf - Я Вижу Твои Бидмас И Поднимаю Тебе Бадмис

Я вижу твои БИДМАСЫ и поднимаю тебе БАДМИС

Испытание

Правила

Тестовые случаи (с объяснением)

Тестовые случаи (без объяснения)

Affiddede26

JavaScript (V8), 118 112 байт

Qwerty202

C# (интерактивный компилятор Visual C#), 285 байт

JavaScript (Node.js), 132 байта

JavaScript (Node.js), 165 161 155 153 152 137 байт

Перл 6, 92 90 88 байт

Объяснение:

Питон 3, 108 байт

Негольфед

N_E_O_N

Желе, 30 байт

Объяснение

Вспомогательная ссылка

Основная ссылка

Питон 2, 182 172 байт

Cox2001

Юля 1.2, 88 (82) байт

Raramuri

I AM

Интересно