SỰ CHỈ RÕ

Đưa ra mcác biến, tạo mọi sự kết hợp theo thứ tự n. Ví dụ,

Đầu ra của ánh xạ hai biến ( avà b) theo thứ tự 1sẽ là:

• một
• b
• ab

Đầu ra của ánh xạ hai biến ( avà b) theo thứ tự 2sẽ là:

• một
• một ²
• b
• b ²
• ab
• một ² b
• ab ²
• a ² b ²

Đầu ra của ánh xạ hai biến ( avà b) theo thứ tự 3sẽ là:

• một
• một ²
• một ³
• b
• b ²
• b ³
• ab
• một ² b
• một ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

Kết quả của bản đồ ba biến ( a, bvà c) để đặt hàng 1sẽ là:

• một
• b
• c
• ab
• bc
• AC
• abc

Đầu ra của mcác biến ánh xạ để đặt hàng nsẽ là:

• Vân vân.

TIÊU CHUẨN CHIẾN THẮNG

Đầu ra mọi sự kết hợp có thể như đã nêu ở trên. Đặt hàng không quan trọng. Trường hợp trong mã của bạn, bạn in ra màn hình không quan trọng. Tất cả vấn đề là những gì hiển thị trong đầu ra của bạn là chính xác.

Brachylog , 6 byte

j₎o⊇ᵘb

Đưa đầu vào thành một cặp, chứa danh sách các biến và thứ tự. Đầu ra là một danh sách các danh sách các biến, trong đó các quyền hạn được biểu diễn bằng các biến lặp lại. (ví dụ: "a²b" là ["a", "a", "b"])

Hãy thử trực tuyến!

j₎tham gia đầu vào đầu tiên với chính nó nhiều lần như được nêu bởi đầu vào thứ hai. osắp xếp danh sách thu được, và sau đó ⊇ᵘtìm tất cả các tập hợp con duy nhất của danh sách được sắp xếp đó. Cuối cùng, chúng tôi loại bỏ phần tử đầu tiên bằng b, vì đây sẽ luôn là câu trả lời trống rỗng, không được dự tính bởi thử thách.

L ^A T _E X, 354 byte

Khi tôi thấy điều này tôi biết rằng nó phải được thực hiện trong latex. Các phương trình trông rất sắc nét và sạch sẽ trong latex và tôi không thể sử dụng ^năng lượng.

\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}

Giải trình

Có ba lực lượng chính hoạt động ở đây \typein , đó là những gì cho phép chúng ta lấy đầu vào từ dòng lệnh, intcalcgói đó là thứ cho phép chúng ta thực hiện các phép tính với các biến của mình và equationmôi trường latex .

Khi chúng tôi đã thực hiện đầu vào, chúng tôi bắt đầu một vòng lặp chúng tôi lặp lại \intcalcPow{\b+1}{\a}thời gian, một lần cho mỗi kết quả chúng tôi muốn in. Mỗi vòng lặp chúng ta bắt đầu một equationmôi trường và lặp qua bảng chữ cái theo dõi chữ cái \yhiện tại và \icho số lần chạy hiện tại. Nếu \ilớn hơn hoặc bằng \achúng tôi không in bất cứ thứ gì cả (theo thông số kỹ thuật thì điều này không thực sự cần thiết tuy nhiên latex sẽ tràn ra các giá trị lớn hơn 1 nếu chúng tôi không làm điều này). Sau đó chúng tôi in \yra phương trình của chúng tôi và nâng nó lên sức mạnh của

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

Toàn bộ mớ hỗn độn đó chỉ đơn giản là lấy \ichữ số thứ ba \xtrong cơ sở \b+1. Điều này đảm bảo rằng các quyền hạn được giải mã đúng.

Ví dụ đầu ra:

Đây là đầu ra cho 3, 2

Toán học, 51 50 byte

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

Giả sử " mcác biến đã cho " có nghĩa là đầu vào đầu tiên là danh sách các biến.

Nếu đầu vào đầu tiên là một số nguyên, 69 byte

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

Các biến có dạng $<integer>(ví dụ $5)

Haskell, 71 58 54 53 byte

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

Trả về một danh sách các chuỗi và sử dụng định dạng đầu ra "aabbb"cho "a^2 b^3".

Ví dụ sử dụng: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Hãy thử trực tuyến! .

Nhiều byte được dành cho định dạng đầu ra. Một đầu ra linh hoạt hơn, ví dụ như các cặp (biến, công suất) -> [('a',2),('b',3),('c',1)]cho "a^2 b^3 c^1"sẽ tiết kiệm rất nhiều.

Làm thế nào nó hoạt động

    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)

Với tính linh hoạt tối đa, tức là các định dạng đầu ra dưới dạng các cặp (biến, công suất) và bao gồm các lũy thừa hoàn toàn ( "a^0 b^0 c^0"), nó sẽ biến thành

Haskell, 25 byte:

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

Ví dụ sử dụng 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)]]

Giảm sức mạnh hoàn toàn bằng không tốn 5 byte cho tổng số 30 : f n=tail.mapM((<$>[0..n]).(,)).

Thạch , 20 17 byte

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

Một liên kết dyadic (hàm) chấp nhận một danh sách các tên biến * và thứ tự tối đa (một số nguyên) và trả về một danh sách trong đó mỗi mục nhập là một biểu diễn mở rộng hoàn toàn của phép nhân (ví dụ foo ⁰ bar ³ bof ² sẽ là ['bar', 'bar', 'bar', 'bof', 'bof'].

* tên biến có thể là một chuỗi các ký tự duy nhất (chuỗi trở thành danh sách các ký tự).

Hãy thử trực tuyến! - chân trang gọi liên kết dưới dạng dyad và sau đó phân tách danh sách kết quả của danh sách theo nguồn cấp dữ liệu và từng mục theo khoảng trắng để dễ đọc.

Lưu ý: bao gồm đơn đặt hàng 0 (sản phẩm trống) một dequeue Ḋ, có thể được chèn vào đây ...ŒPḊç...để tránh điều đó.

Làm sao?

ṗ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

Phiên bản 13 byte sẽ chỉ hoạt động cho một chuỗi các ký tự duy nhất (hoặc danh sách các ký tự duy nhất):

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

thử nó

JavaScript (đề xuất ES), 142 byte

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

Yêu cầu trình duyệt có cả hai **và padStarthỗ trợ, vì vậy hãy thử Firefox 52 hoặc Chrome 57.

Toán học 100 byte

Chắc chắn có một cách hiệu quả hơn để thực hiện điều này!

Hai biến để đặt hàng 4:

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

Bash + sed, 60

Một cách tiếp cận khác, ngắn hơn để trả lời trước đây của tôi.

Nhập dưới dạng tham số dòng lệnh - mđược đưa ra dưới dạng danh sách tên biến được phân tách bằng dấu phẩy và ndưới dạng số nguyên:

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

Hãy thử trực tuyến .

Trả lời trước:

Bash + coreutils, 91

Chào mừng đến với địa ngục eval-esc-brace. Đôi khi shell-script thực sự chỉ cung cấp công cụ phù hợp cho công việc. Đây không phải là trường hợp ở đây, nhưng nó hoạt động.

Nhập dưới dạng tham số dòng lệnh - mđược đưa ra dưới dạng danh sách tên biến được phân tách bằng dấu phẩy và ndưới dạng số nguyên. Đầu ra được viết ra từ lâu - ví dụ như a^2thực sự được viết aa. Điều này được chấp nhận theo nhận xét này .

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

Có thể có những cách ngắn hơn để làm điều này.

Hãy thử trực tuyến .

Giải trình

• printf -vc {%$[$2-1]s}gán biến ccho một chuỗi như { }, trong đó số khoảng trắng là thứ tự n- 1, vì vậy if n= 1, kết quả là {}, if n= 2, kết quả là { }, v.v.
• ${a[$1]}sử dụng mnhư một chỉ mục cho mảng a, vì vậy nếu mlà 3, thì kết quả làc
• \{{a..${a[$1]}}${c// /,}\\,} là một mở rộng niềng răng đa phần:
  • \{ - nghĩa đen {
  • {$1}là một mở rộng cú đúp của danh sách m, ví dụ {a,b,c}hoặca b c
  • ${c// /,}thay thế các khoảng trắng $cbằng dấu phẩy, ví dụ {,,}for n= 3, đây cũng là phần mở rộng dấu ngoặc lặp lại hiệu quả từng phần tử của{a..c} n thời gian
  • \\\,} - nghĩa đen ,}
• Vì vậy, for m= "a, b" và n= 2, điều này mở rộng thành{a,} {a,} {b,} {b,}
• Bên trong printfloại bỏ các không gian để cung cấp {a,}{a,}{b,}{b,}, mà chính nó là một mở rộng cú đúp
• Điều này mở rộng đến aabb aab aab aa abb ab ab a abb ab ab a bb b b
• Bên ngoài printfđặt mỗi yếu tố này trên dòng riêng của nó
• sort -u loại bỏ các bản sao
• Có tr -d {}để xử lý trường hợp khi n= 1. Trong trường hợp này, biến csẽ {}không phải là mở rộng dấu ngoặc, mà thay vào đó là các ký tự bằng chữ được chèn vào. Việc trloại bỏ chúng.

evals và \thoát được đặt rất cẩn thận để đảm bảo rằng tất cả các mở rộng xảy ra theo thứ tự cần thiết.

Röda , 49 48 46 byte

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

Hãy thử trực tuyến!

Tôi nghĩ đó là chính xác. Nó không sử dụng bất kỳ dấu phân cách nào giữa một biến và thứ tự của nó. Phiên bản trước được sử dụng !, nhưng tôi nhận ra rằng nó không bắt buộc.

Giải thích:

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 byte

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:]

Sử dụng:

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

Đầu ra:

b
bb
a
ab
abb
aa
aab
aabb

Định dạng Nicer trong 115 byte :

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

Đầu ra (sử dụng tương tự):

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

Thậm chí đẹp hơn trong 125 byte :

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:]

Đầu ra:

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

Tất cả 4 byte ( [1:]) cuối cùng là để loại bỏ sản phẩm trống.

Chúng hoạt động trong cả Python 2 và 3.

C ++ 14, 146 140 byte

-6 byte cho định dạng đầu ra đơn giản hơn.

Lambda chưa được đặt tên, giả sử đầu vào snhư std::stringvà onhư 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<<" ";}}

Cách sử dụng và giải thích:

#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);
}

Đầu ra:

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