Создайте каждую комбинацию групп переменных до порядка n

9

СПЕЦИФИКАЦИЯ

Задавая mпеременные, создавайте каждую комбинацию по порядку n. Например,

Результат отображения двух переменных ( aи b) в порядке 1будет:

  • a
  • б
  • аб

Результат отображения двух переменных ( aи b) в порядке 2будет:

  • a
  • 2
  • б
  • б 2
  • аб
  • а 2 б
  • ab 2
  • а 2 б 2

Результат отображения двух переменных ( aи b) в порядке 3будет:

  • a
  • 2
  • 3
  • б
  • б 2
  • б 3
  • аб
  • а 2 б
  • а 3 б
  • а 3 б 2
  • ab 2
  • ab 3
  • а 2 б 3
  • а 2 б 2
  • а 3 б 3

Вывод отображения трех переменных ( a, bи c) на заказ 1будет:

  • a
  • б
  • с
  • аб
  • до н.э
  • переменный ток
  • азбука

Вывод mпеременных отображения в порядок nбудет:

  • и т.п.

КРИТЕРИИ ПОБЕДЫ

Выведите каждую возможную комбинацию, как описано выше. Заказ не имеет значения. Где в вашем коде вы печатаете на экран, не имеет значения. Все, что имеет значение, это то, что то, что отображается в вашем выводе, является правильным.

user1873073
источник
1
Как мы собираемся выводить? Должны ли мы использовать ^?
Специальный охотник за
1
Можем ли мы поднять вещи до нуля или единицы (например, ^ 1)
Ad Hoc
1
Что если mбольше 26? мы должны поддерживать такие высокие ценности?
Ad Hoc
1
@ user1873073 проблема не в максимальном порядке, а в максимальном количестве имен переменных.
Мартин Эндер
1
Как переменные будут предоставлены? во многих комментариях предполагается, что входными given m variablesданными будут несколько переменных, но текст подразумевает, что будет дан список переменных. Если задано только количество переменных и 0,1,2,3..27,28,29, доведенные до степеней ^ 0, ^ 1, ^ 2 и т. Д., Являются приемлемым выводом (как я понимаю из вашего последнего комментария), он делает все проще.
Уровень River St

Ответы:

4

Брахилог , 6 байт

j₎o⊇ᵘb

Принимает ввод как пара, содержащая список переменных и порядок. Вывод представляет собой список списков переменных, в которых полномочия представлены повторяющимися переменными. (например, «a²b» - это [«a», «a», «b»])

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

j₎соединяет первый вход с самим собой столько раз, сколько указано вторым. oупорядочивает полученный список, а затем ⊇ᵘнаходит все уникальные подмножества этого упорядоченного списка. Наконец, мы удаляем первый элемент с b, так как это всегда будет пустой ответ, который не рассматривается вызовом.

Лео
источник
14

L A T E X, 354 байта

Когда я увидел это, я понял, что это должно быть сделано в латексе. Уравнения в латексе выглядят очень четкими и чистыми, и я не могу использовать их ^для власти.

\documentclass{article}\input tikz\usepackage{intcalc}\usepackage{ifthen}\begin{document}\typein[\a]{}\typein[\b]{}\foreach\x in{1,...,\intcalcPow{\b+1}{\a}}{\begin{equation}\foreach[count=\i]\y in{a,...,z}{\ifthenelse{\(\i<\a\)\OR\(\i=\a\)}{\y^\intcalcDiv{\intcalcMod{\x}{\intcalcPow{\b+1}{\i}}}{\intcalcPow{\b+1}{\i-1}}}{}}\end{equation}}\end{document}

объяснение

Здесь действуют три основные силы, \typein которые позволяют нам получать данные из командной строки, intcalcпакет, который позволяет нам производить вычисления с нашими переменными, и equationсреда Latex .


После того, как мы взяли ввод, мы начинаем цикл, который повторяем \intcalcPow{\b+1}{\a}время цикла , по одному разу для каждого результата, который мы хотим напечатать. В каждом цикле мы начинаем equationокружение и перебираем алфавит, отслеживая \yтекущую букву и \iтекущее количество прогонов. Если \iзначение больше или равно, \aмы ничего не печатаем (в соответствии со спецификациями это не является строго необходимым, однако, если значения не превышаются, Latex будет переполнен для значений больше 1). Затем мы печатаем \yнаше уравнение и поднимаем его до степени

\intcalcDiv{\intcalcMod{\x}{\intcalcPow{\b+1}{\i}}}{\intcalcPow{\b+1}{\i-1}}

Весь этот бардак просто означает взять в базу \iцифру . Это гарантирует, что полномочия декодируются правильно.\x\b+1

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

Вот выход за 3, 2

Вывод

Специальный охотник за гарфами
источник
1
Обратите внимание, что ваш вывод включает в себя ^ 0 b ^ 0 c ^ 0 = 1, а тестовые примеры - нет. При этом, я думаю, что вы правы, а контрольные примеры неправильны :)
Грег Мартин
@GregMartin Да, математически говоря, пустой набор должен быть в en.wikipedia.org/wiki/Power_set
Карл Напф
@KarlNapf Выражение, равное 1, не является пустым множеством. Также нет кортежа, содержащего 3 нуля.
jpmc26
@ jpmc26 Да, не в спецификации этого гольфа. Это похоже на powerset (для n = 3) {a, a, a, b, b, b, c, c, c} без пустого набора
Карл Напф
@KarlNapf Математически это не то же самое. Здесь нет пустого набора. Задача заключается в создании набора кортежей указанной длины.
jpmc26
5

Mathematica, 51 50 байт

Rest[1##&@@@PowerRange[1,#^#2,#]~Distribute~List]&

Предполагается, «заданные mпеременные» означает, что первый вход представляет собой список переменных.

Если первый вход является целым числом, 69 байтов

Rest[1##&@@@PowerRange[v=Unique[]~Table~#;1,v^#2,v]~Distribute~List]&

Переменные в форме $<integer>(например $5)

Юнг Хван Мин
источник
TIL PowerRangeэто вещь! Я согласен с интерпретацией вашего первого представления между прочим
Грег Мартин
4

Haskell, 71 58 54 53 байта

n#m=tail$concat<$>mapM(\x->(\i->x<$[1..i])<$>[0..n])m

Возвращает список строк и использует выходной формат "aabbb"для "a^2 b^3".

Пример использования: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Попробуйте онлайн! ,

Многие байты расходуются на форматирование вывода. Более гибкий вывод, например, пары (переменная, мощность) -> [('a',2),('b',3),('c',1)]для "a^2 b^3 c^1"сэкономит много.

Как это работает

    mapM(\x->    )m      -- for each variable x in the input list m
      \i->x<$[1..i]      -- make i copies of x
             <$>[0..n]   -- for all numbers from 0 to n
                         -- in fact mapM makes all possible combinations hereof, i.e.
                         -- [["",""], ["", "b"], ["", "bb"] ... ["a",""], ["a","b"], ...]
  concat<$>              -- join all inner lists 
                         --    e.g ["aa","bbb"]  -> "aabbb"
tail                     -- drop the first (all powers = ^0)

С максимальной гибкостью, т. Е. Форматом вывода в виде пар (переменная, мощность) и включая все нулевые мощности ( "a^0 b^0 c^0"), он сводится к

Haskell, 25 байт:

f n=mapM((<$>[0..n]).(,))

Пример использования f 2 "ab"::

[[('a',0),('b',0)],
 [('a',0),('b',1)],
 [('a',0),('b',2)],
 [('a',1),('b',0)],
 [('a',1),('b',1)],
 [('a',1),('b',2)],
 [('a',2),('b',0)],
 [('a',2),('b',1)],
 [('a',2),('b',2)]]

Бросив все нулевой силы стоит 5 байт в общей сложности 30: f n=tail.mapM((<$>[0..n]).(,)).

Ними
источник
Для вашего второго кода [('a',0),('b',0)]не должно быть в выводе ...
JungHwan Мин
@JungHwanMin: мое 25-байтовое решение не должно быть ответом. Это примечание, чтобы показать, что комбинаторная часть задачи требует наименьшего количества байтов - по крайней мере, в Haskell. Сброс a^0 b^0стоит 5 байт. Я добавлю еще одну заметку.
Nimi
4

Желе , 20 17 байт

ṗj€“”Ṣ€
ŒPçЀj“”Q

Двоичная ссылка (функция), которая принимает список имен переменных * и максимальный порядок (целое число) и возвращает список, где каждая запись является полностью расширенным представлением умножения (например, foo 0 bar 3 bof 2 будет ['bar', 'bar', 'bar', 'bof', 'bof'].

* имена переменных могут быть строкой уникальных символов (строки становятся списками символов).

Попробуйте онлайн! - нижний колонтитул вызывает ссылку как диаду, а затем разделяет результирующий список списков по переводам строк и каждой записи по пробелам для удобства чтения.

Примечание: включает в 0 заказ (пустой продукт) а Dequeue, могут быть вставлены здесь , ...ŒPḊç...чтобы избежать этого.

Как?

ṗj€“”Ṣ€ - Link 1, sorted results of a Cartesian power: elements, power
ṗ       - Cartesian power of elements with given power
 j€“”   - join €ach with "" (flatten each by one level)
     Ṣ€ - sort €ach

ŒPçЀj“”Q - Main link: variableNames, maximalOrder
ŒP        - power-set of variableNames (e.g for ['a','b','c'] this would be ['','a','b','c','ab','ac','bc','abc'])
   Ѐ     - for €ach mapped over right argument (i.e. over the range [1,2,...,maximalOrder])
  ç       -     call the last link (1) as a dyad (i.e. power-set results are the elements and one of the range values is the power)
     j“”  - join with "" (flatten by one level)
        Q - unique values

13-байтовая версия, которая будет работать только для одной строки уникальных символов (или списка уникальных символов):

ŒPṗЀj“”F€Ṣ€Q

попробуй это

Джонатан Аллан
источник
3

JavaScript (предложение ES), 142 байта

f=
(v,n)=>[...Array(++v**n)].map((_,i)=>i.toString(v).padStart(n,0).replace(/./g,(c,j)=>(+c?(10+j).toString(36):``)+(c>1?c.sup():``))).join`<br>`
<div oninput=o.innerHTML=f(v.value,n.value)><input id=v type=number min=1 value=1><input id=n type=number min=1 value=1><span id=o><br>a

Требуется браузер с поддержкой **и padStartподдержкой, поэтому попробуйте Firefox 52 или Chrome 57.

Нил
источник
3

Mathematica 100 байт

Конечно, есть более эффективный способ сделать это!

Две переменные на порядок 4:

(Times@@@(MapThread[Power,#]&/@Outer[List,{Alphabet[][[1;;#]]},Rest@Tuples[Range[0,#2],#],1][[1]])) &

рисунок

DavidC
источник
3

Баш + Сед, 60

Другой, более короткий подход к моему предыдущему ответу.

Ввод в качестве параметров командной строки - mзадается в виде списка имен переменных, разделенных запятыми, и nв виде целого числа:

p=eval\ printf
$p -vc %s {$1}^\\{0..$2}
$p '%s\\n' $c|sed 1d

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


Предыдущий ответ:

Bash + coreutils, 91

Добро пожаловать в ад eval-escape-brace. Иногда shell-скрипт действительно дает правильный инструмент для работы. Это не тот случай, но это работает.

Ввод в качестве параметров командной строки - mзадается в виде списка имен переменных, разделенных запятыми, и nв виде целого числа. Вывод записывается от руки - например, a^2на самом деле написано aa. Это приемлемо согласно этому комментарию .

p=eval\ printf
$p -vc {%$[$2-1]s}
$p '%s\\n' $($p %s \{{$1}${c// /,}\\\,})|tr -d {}|sort -u

Там могут быть более короткие способы сделать это.

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

объяснение

  • printf -vc {%$[$2-1]s}присваивает переменную cтакой строке { }, где количество пробелов - это порядок n- 1, поэтому, если n= 1, результат будет {}, если n= 2, результат будет { }и т. д.
  • ${a[$1]}использует mв качестве индекса для массива a, поэтому, если mравен 3, то результатc
  • \{{a..${a[$1]}}${c// /,}\\,} это расширение из нескольких частей:
    • \{ - буквальный {
    • {$1}является расширением списка m, например, {a,b,c}илиa b c
    • ${c// /,}заменяет пробелы в $cзапятых, например, {,,}для n= 3, который также является расширением скобки, которое эффективно повторяет каждый элемент {a..c} nраз
    • \\\,} - буквальный ,}
  • Так что для m= "a, b" и n= 2 это расширяется до{a,} {a,} {b,} {b,}
  • Внутреннее printfудаляет пробелы, чтобы дать {a,}{a,}{b,}{b,}, который сам является расширением скобки
  • Это расширяется до aabb aab aab aa abb ab ab a abb ab ab a bb b b
  • Внешний printfпомещает каждый из этих элементов на отдельной линии
  • sort -u удаляет дубликаты
  • Здесь tr -d {}есть, чтобы обрабатывать случай, когда n= 1. В этом случае cбудет переменная , {}которая не является расширением скобки, но вместо этого вставляются литеральные символы. trУдаляет их.

evals и \побеги расположены очень осторожно, чтобы все расширения происходили в нужном порядке.

Цифровая травма
источник
3

Рёда , 49 48 46 байт

f n{r=[""]{|v|r=r...[seq(0,n)|[v.._]]}_;r[1:]}

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

Я думаю, что это правильно. Он не использует разделитель между переменной и ее порядком. Использовалась предыдущая версия !, но я понял, что она не обязательна.

Разъяснение:

function f(n) {
    r := [""] /* r is a list with one empty string. */
    /* Loops over the variable names in the stream. */
    for var do
        /* Concatenates every element in r to */
        /* every element in the list that contains orders of */
        /* variable var. */
        r = r...[
            push(var..x) for x in [seq(0, n)]
        ]
    done
    r[1:] /* Return elements of r not counting the first. */
}
fergusq
источник
1

Python, 112 байт

import itertools as t
f=lambda n,v:[''.join(map(str.__mul__,v,I))for I in t.product(range(n),repeat=len(v))][1:]

Применение:

for x in f(3, 'ab'):
    print(x)

Вывод:

b
bb
a
ab
abb
aa
aab
aabb

Более хороший формат в 115 байтов :

import itertools as t
f=lambda n,v:[''.join(map('{}^{}'.format,v,I))for I in t.product(range(n),repeat=len(v))][1:]

Выход (такое же использование):

a^0b^1
a^0b^2
a^1b^0
a^1b^1
a^1b^2
a^2b^0
a^2b^1
a^2b^2

Еще лучше в 125 байтах :

import itertools as t
f=lambda n,v:[''.join(c+'^%s'%i for c,i in zip(v,I)if i)for I in t.product(range(n),repeat=len(v))][1:]

Вывод:

b^1
b^2
a^1
a^1b^1
a^1b^2
a^2
a^2b^1
a^2b^2

Последние 4 байта ( [1:]) для удаления пустого продукта.

Они работают в Python 2 и 3.

Алекс Холл
источник
0

C ++ 14, 146 140 байт

-6 байт для более простого формата вывода.

Безымянная лямбда, при условии ввода sкак std::stringи oкак std::ostream:

[](auto s,int n,auto&o){int l=s.size(),k,c,*p=new int[l]{1};while(!c){for(c=1,k=0;k<l;o<<s[k]<<"^"<<p[k],p[k++]*=!(c=(p[k]+=c)>n));o<<" ";}}

Использование и объяснение:

#include<iostream>
#include<string>

auto f=
[](auto s, int n, auto&o){
 int l=s.size(),              //string length
     k,                       //running variable for l
     c,                       //carry for the increment
    *p=new int[l]{1};         //init array with first elem 1
 while(!c){                   //if carry was leftover, break
  for(
   k=0,c=1;                   //always start with carry                  
   k<l;                       
    o<<s[k]<<"^"<<p[k],       //output
    p[k++]*=!(c=(p[k]+=c)>n)  
//               p[k]+=c      //inc p[k]  
//            c=(p[k]+=c)>n   //if value is greater than order  
//  p[k++]*=!(c=(p[k]+=c)>n)  //set p[k] to 0 and inc k
  );
  o<<" ";                     
 }
}
;

main(){
 f(std::string("ab"),3,std::cout);
 std::cout << "\n";
 f(std::string("abc"),2,std::cout);
}

Вывод:

a^1b^0 a^2b^0 a^3b^0 a^0b^1 a^1b^1 a^2b^1 a^3b^1 a^0b^2 a^1b^2 a^2b^2 a^3b^2 a^0b^3 a^1b^3 a^2b^3 a^3b^3 
a^1b^0c^0 a^0b^1c^0 a^1b^1c^0 a^0b^0c^1 a^1b^0c^1 a^0b^1c^1 a^1b^1c^1 
Карл Напф
источник