规格

给定m变量，按order创建每个组合n。例如，

将两个变量（a和b）映射到顺序的输出为1：

• 一个
• b
• b

将两个变量（a和b）映射到顺序的输出为2：

• 一个
• 一个²
• b
• b ²
• b
• 一个² b
• 抗体²
• a ² b ²

将两个变量（a和b）映射到顺序的输出为3：

• 一个
• 一个²
• 一个³
• b
• b ²
• b ³
• b
• 一个² b
• 一个³ b
• a ³ b ²
• 抗体²
• 腹³
• a ² b ³
• a ² b ²
• a ³ b ³

映射三个变量（的输出a，b和c），以顺序1将是：

• 一个
• b
• C
• b
• 公元前
• 交流电
• abc

m按顺序映射变量的输出为n：

• 等等

获奖标准

输出上述所有可能的组合。顺序无所谓。在代码中的什么位置打印到屏幕都没有关系。重要的是输出中显示的内容是正确的。

Brachylog，6个字节

j₎o⊇ᵘb

将输入作为一对，包含变量列表和顺序。输出是变量列表的列表，其中幂由重复的变量表示。（例如，“a²b”是[“ a”，“ a”，“ b”]）

在线尝试！

j₎将第一个输入与自身连接的次数与第二个输入所述的次数相同。o对获得的列表进行排序，然后⊇ᵘ找到该排序列表的所有唯一子集。最后，我们用删除第一个元素b，因为这将始终是空答案，这是挑战所没有考虑的。

L ^A T _E X，354个字节

当我看到这个时，我知道它必须在Latex中完成。在Latex中，方程式看起来是如此简洁明快，我无法忍受使用^。

\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，是使我们可以使用变量进行计算的程序包，以及Latex equation环境。

接受输入后，我们开始循环，循环\intcalcPow{\b+1}{\a}一次，对于每个要打印的结果一次。每个循环我们都开始一个equation环境，并循环遍历字母，跟踪\y当前字母和\i当前运行次数。如果\i大于或等于\a我们根本不打印任何内容（根据规范，这不是严格必需的，但是如果我们不这样做，则对于大于1的值，Latex会溢出）。然后\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)]]

删除所有零权力费用共计30 5个字节：f n=tail.mapM((<$>[0..n]).(,))。

果冻，20 17 字节

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

双向链接（函数），它接受变量名*和最大顺序（整数）的列表，并返回一个列表，其中每个条目都是乘法的完全展开表示形式（例如foo ⁰ bar ³ bof ²将是）['bar', 'bar', 'bar', 'bof', 'bof']。

*变量名可以是一串唯一的字符（字符串成为字符列表）。

在线尝试！-页脚将链接称为二元组，然后按换行符分隔列表的结果列表，并按空格分隔每个条目，以方便阅读。

注意：包括0订单（空产品）的出队Ḋ，可以在此处插入...Œ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]])) &

Bash + sed，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用逗号替换空格，例如{,,}for 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删除。

eval和\转义符的放置非常仔细，以确保所有扩展都按必要的顺序进行。

Röda，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、146140字节

-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