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

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

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

• a
• б
• аб

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

• a
• ²
• б
• б ²
• аб
• а ² б
• ab ²
• а ² б ²

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

• a
• ²
• ³
• б
• б ²
• б ³
• аб
• а ² б
• а ³ б
• а ³ б ²
• ab ²
• ab ³
• а ² б ³
• а ² б ²
• а ³ б ³

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

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

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

• и т.п.

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

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

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

j₎o⊇ᵘb

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

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

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

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

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)

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]).(,)).

Желе , 20 17 байт

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

Двоичная ссылка (функция), которая принимает список имен переменных * и максимальный порядок (целое число) и возвращает список, где каждая запись является полностью расширенным представлением умножения (например, foo ⁰ bar ³ bof ² будет ['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

попробуй это

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.

Mathematica 100 байт

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

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

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

Баш + Сед, 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 и \побеги расположены очень осторожно, чтобы все расширения происходили в нужном порядке.

Рёда , 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. */
}

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.

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