仕様

与えられたm変数は、次までのすべての組み合わせを作成しますn。例えば、

2つの変数（aおよびb）を順序にマッピングする出力は次の1ようになります。

• a
• b
• ab

2つの変数（aおよびb）を順序にマッピングする出力は次の2ようになります。

• a
• a ²
• b
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

2つの変数（aおよびb）を順序にマッピングする出力は次の3ようになります。

• a
• a ²
• a ³
• b
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

マッピング三つの変数（の出力a、bおよびc順序には）1次のようになります。

• a
• b
• c
• ab
• 紀元前
• 交流
• ABC

m変数を順序にマッピングする出力は次のnようになります。

• 等

受賞基準

上記のように、可能なすべての組み合わせを出力します。順序は関係ありません。コードのどこに画面に出力してもかまいません。重要なのは、出力に表示されるものが正しいことです。

Brachylog、6バイト

j₎o⊇ᵘb

入力をカップルとして受け取り、変数のリストと順序を含みます。出力は変数のリストのリストであり、累乗は繰り返される変数によって表されます。（例 "a²b"は["a"、 "a"、 "b"]です）

オンラインでお試しください！

j₎2番目の入力で指定された回数だけ最初の入力をそれ自体と結合します。o取得したリスト⊇ᵘを並べ替え、その並べ替えられたリストのすべての一意のサブセットを見つけます。最後に、最初の要素をで削除しbます。これは常に空の答えになるため、チャレンジでは想定されていません。

L ^A T _E X、354バイト

これを見たとき、ラテックスで行わなければならないことを知っていました。方程式は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 では、コマンドラインから入力を取得できるようにする3つの主要な力intcalc、変数を使用して計算を行うことができるパッケージ、およびLatex equation環境があります。

入力を取り込んだら、ループを開始します。ループする\intcalcPow{\b+1}{\a}時間は、出力する結果ごとに1回です。各ループでequation環境を開始\yし、現在の文字と\i現在の実行回数を追跡するアルファベットをループします。場合\iである以上に等しい\a我々は（仕様に応じて、これは我々がこれをしない場合にはラテックスが1以上の値のためにオーバーフローするしかし厳密には必要ではない）まったく何も印刷されません。次に\y、方程式に出力して、それを

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

全体の混乱とは、単にbaseの\ith桁を取ることを意味します。これにより、パワーが適切にデコードされます。\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)]for "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)]]

すべて0の累乗を削除すると、5バイトで合計30になりますf n=tail.mapM((<$>[0..n]).(,))。

ゼリー、20 17 バイト

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

変数名*と最大次数（整数）のリストを受け入れ、各エントリが乗算の完全に拡張された表現であるリストを返す2項リンク（関数）（例：foo ⁰ bar ³ bof ²は）['bar', 'bar', 'bar', 'bof', 'bof']。

*変数名は一意の文字列にすることができます（文字列は文字のリストになります）。

オンラインでお試しください！-フッターはリンクを2つ組として呼び出し、結果のリストのリストを改行で区切り、各エントリを読みやすくするためにスペースで区切ります。

注含む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バイト

確かにこれを達成するためのより効率的な方法があります！

順序付けする2つの変数4：

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

バッシュ+ 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 hellへようこそ。時々シェルスクリプトは本当に仕事にぴったりのツールを提供します。これはここでは当てはまりませんが、機能します。

コマンドラインパラメーターとして入力- 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ため、m3の場合、結果はc
• \{{a..${a[$1]}}${c// /,}\\,} マルチパートのブレース展開です：
  • \{ -リテラル {
  • {$1}is aは、リストのブレース展開ですm。例：{a,b,c}ora b c
  • ${c// /,}スペース$cをコンマで置き換えます。たとえば{,,}、n= 3の場合は、ブレース展開でもあり、{a..c} n時間の各要素を効果的に繰り返します
  • \\\,} -リテラル ,}
• だから、用m=「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