SPESIFIKASI

mVariabel yang diberikan , buat setiap kombinasi hingga sesuai pesanan n. Sebagai contoh,

Output dari pemetaan dua variabel ( adan b) sesuai pesanan 1adalah:

• Sebuah
• b
• ab

Output dari pemetaan dua variabel ( adan b) sesuai pesanan 2adalah:

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

Output dari pemetaan dua variabel ( adan b) sesuai pesanan 3adalah:

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

Output dari pemetaan tiga variabel ( a, b, dan c) untuk memesan 1akan menjadi:

• Sebuah
• b
• c
• ab
• bc
• ac
• abc

Output dari mvariabel pemetaan yang nakan dipesan adalah:

• dll.

KRITERIA PEMENANG

Keluarkan setiap kombinasi yang mungkin seperti diuraikan di atas. Urutan tidak masalah. Di mana dalam kode Anda Anda mencetak ke layar tidak masalah. Yang penting adalah apa yang muncul di output Anda sudah benar.

Brachylog , 6 byte

j₎o⊇ᵘb

Mengambil input sebagai pasangan, berisi daftar variabel dan urutan. Output adalah daftar daftar variabel, di mana kekuatan diwakili oleh variabel yang berulang. (mis. "a²b" adalah ["a", "a", "b"])

Cobalah online!

j₎bergabung dengan input pertama dengan dirinya sendiri sebanyak yang dinyatakan oleh input kedua. omemesan daftar yang diperoleh, dan kemudian ⊇ᵘmenemukan semua himpunan bagian yang unik dari daftar yang dipesan itu. Akhirnya, kami menghapus elemen pertama dengan b, karena ini akan selalu menjadi jawaban kosong, yang tidak direnungkan oleh tantangan.

L ^A T _E X, 354 byte

Ketika saya melihat ini, saya tahu itu harus dilakukan dalam Lateks. Persamaan terlihat sangat tajam dan bersih dalam Lateks dan saya tidak tahan menggunakan ^listrik.

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

Penjelasan

Ada tiga kekuatan utama yang bekerja di sini \typein yang memungkinkan kita untuk mengambil input dari baris perintah, intcalcpaket yang memungkinkan kita untuk membuat perhitungan dengan variabel kita, dan equationlingkungan Lateks .

Setelah kami memasukkan input, kami memulai satu putaran, kami mengulang \intcalcPow{\b+1}{\a}kali, satu kali untuk setiap hasil yang ingin kami cetak. Setiap loop kita memulai suatu equationlingkungan dan loop melalui alfabet melacak \yuntuk huruf saat ini dan \iuntuk jumlah berjalan saat ini. Jika \ilebih besar atau sama dengan \akita tidak mencetak apa-apa sama sekali (menurut spesifikasi ini tidak sepenuhnya diperlukan namun Lateks akan meluap untuk nilai lebih dari 1 jika kita tidak melakukan ini). Kami kemudian mencetak \yke persamaan kami dan menaikkannya ke kekuatan

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

Seluruh kekacauan itu berarti mengambil \idigit ke \xdalam basis \b+1. Ini memastikan bahwa kekuatan diterjemahkan dengan benar.

Contoh output:

Ini adalah output untuk 3, 2

Mathematica, 51 50 byte

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

Mengasumsikan " mvariabel yang diberikan " berarti input pertama adalah daftar variabel.

Jika input pertama adalah bilangan bulat, 69 byte

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

Variabel dalam bentuk $<integer>(misalnya $5)

Haskell, 71 58 54 53 byte

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

Mengembalikan daftar string dan menggunakan format output "aabbb"untuk "a^2 b^3".

Contoh penggunaan: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Cobalah online! .

Banyak byte yang dihabiskan untuk memformat output. Output yang lebih fleksibel, mis. Pasangan (variabel, daya) -> [('a',2),('b',3),('c',1)]untuk "a^2 b^3 c^1"akan menghemat banyak.

Bagaimana itu bekerja

    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)

Dengan fleksibilitas maksimum, yaitu format keluaran sebagai pasangan (variabel, daya) dan termasuk semua daya nol ( "a^0 b^0 c^0") itu bermuara pada

Haskell, 25 byte:

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

Contoh penggunaan 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)]]

Menjatuhkan semua-nol kekuasaan biaya 5 bytes untuk total 30: f n=tail.mapM((<$>[0..n]).(,)).

Jelly , 20 17 byte

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

Tautan diad (fungsi) yang menerima daftar nama variabel * dan urutan maksimal (bilangan bulat) dan mengembalikan daftar di mana setiap entri adalah representasi penuh dari perkalian (mis. Foo ⁰ bar ³ bof ² akan menjadi ['bar', 'bar', 'bar', 'bof', 'bof'].

* nama variabel dapat berupa string karakter unik (string menjadi daftar karakter).

Cobalah online! - footer menyebut tautan sebagai angka dua dan kemudian memisahkan daftar daftar yang dihasilkan oleh umpan baris dan setiap entri berdasarkan spasi untuk kemudahan membaca.

Catatan: termasuk 0 pesanan (produk kosong) dequeue Ḋ,, dapat dimasukkan di sini ...ŒPḊç...untuk menghindari itu.

Bagaimana?

ṗ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

Versi 13 byte yang hanya akan berfungsi untuk string tunggal karakter unik (atau daftar karakter unik):

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

Cobalah

JavaScript (proposal 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

Memerlukan browser dengan keduanya **dan padStartdukungan, jadi cobalah Firefox 52 atau Chrome 57.

Mathematica 100 byte

Tentunya ada cara yang lebih efisien untuk mencapai ini!

Dua variabel untuk dipesan 4:

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

Bash + sed, 60

Pendekatan berbeda, lebih pendek untuk jawaban saya sebelumnya.

Input sebagai parameter baris perintah - mdiberikan sebagai daftar nama variabel yang dipisahkan koma, dan nsebagai integer:

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

Cobalah online .

Jawaban sebelumnya:

Bash + coreutils, 91

Selamat datang di neraka eval-escape-brace. Terkadang shell-script benar-benar memberikan alat yang tepat untuk pekerjaan itu. Ini tidak terjadi di sini, tetapi berhasil.

Input sebagai parameter baris perintah - mdiberikan sebagai daftar nama variabel yang dipisahkan koma, dan nsebagai integer. Keluaran ditulis tangan - mis. a^2Sebenarnya ditulis aa. Ini dapat diterima sesuai komentar ini .

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

Mungkin ada cara yang lebih pendek untuk melakukan ini.

Cobalah online .

Penjelasan

• printf -vc {%$[$2-1]s}menugaskan variabel cke string seperti { }, di mana jumlah spasi adalah urutan n- 1, jadi jika n= 1, hasilnya adalah {}, jika n= 2, hasilnya adalah { }, dll.
• ${a[$1]}digunakan msebagai indeks ke array a, jadi jika m3, maka hasilnya adalahc
• \{{a..${a[$1]}}${c// /,}\\,} adalah ekspansi brace multi-bagian:
  • \{ - literal {
  • {$1}adalah a adalah perluasan penjepit dari daftar m, misalnya {a,b,c}ataua b c
  • ${c// /,}menggantikan spasi $cdengan koma, misalnya {,,}untuk n= 3, yang juga merupakan ekspansi penjepit yang secara efektif mengulangi setiap elemen {a..c} nkali
  • \\\,} - literal ,}
• Jadi untuk m= "a, b" dan n= 2, ini berkembang menjadi{a,} {a,} {b,} {b,}
• Bagian dalam printfmenghilangkan ruang untuk memberi {a,}{a,}{b,}{b,}, yang itu sendiri merupakan perluasan penjepit
• Ini berkembang menjadi aabb aab aab aa abb ab ab a abb ab ab a bb b b
• Bagian luar printfmenempatkan masing-masing elemen ini pada garisnya sendiri
• sort -u menghapus duplikat
• Ada di tr -d {}sana untuk menangani kasus ketika n= 1. Dalam hal ini variabel cakan {}yang bukan merupakan ekspansi penjepit, tetapi karakter literal dimasukkan. The trmenghapus mereka.

evals dan \lolos ditempatkan sangat hati-hati untuk memastikan bahwa semua ekspansi terjadi dalam urutan yang diperlukan.

Röda , 49 48 46 byte

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

Cobalah online!

Saya pikir itu benar. Itu tidak menggunakan pemisah antara variabel dan urutannya. Versi sebelumnya digunakan !, tetapi saya menyadari bahwa itu tidak sepenuhnya diperlukan.

Dijelaskan:

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

Pemakaian:

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

Keluaran:

b
bb
a
ab
abb
aa
aab
aabb

Format yang lebih bagus dalam 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:]

Output (penggunaan yang sama):

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

Bahkan lebih bagus dalam 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:]

Keluaran:

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

4 byte terakhir ( [1:]) semuanya adalah untuk menghapus produk kosong.

Ini bekerja di kedua Python 2 dan 3.

C ++ 14, 146 140 byte

-6 byte untuk format output yang lebih sederhana.

Lambda yang tidak disebutkan namanya, dengan asumsi input sseperti std::stringdan osebagai 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<<" ";}}

Penggunaan dan penjelasan:

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

Keluaran:

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