SPECIFICATION

ได้รับตัวแปรสร้างทุกชุดถึงการสั่งซื้อm nตัวอย่างเช่น,

ผลลัพธ์ของการแมปสองตัวแปร ( aและb) ในการสั่งซื้อ1จะเป็น:

• a
• ข
• AB

ผลลัพธ์ของการแมปสองตัวแปร ( aและb) ในการสั่งซื้อ2จะเป็น:

• a
• a ²
• ข
• ข²
• AB
• ²ข
• ab ²
• a ² b ²

ผลลัพธ์ของการแมปสองตัวแปร ( aและb) ในการสั่งซื้อ3จะเป็น:

• a
• a ²
• ³
• ข
• ข²
• ข³
• AB
• ²ข
• ³ข
• ³ข²
• ab ²
• ab ³
• ²ข³
• a ² b ²
• ³ข³

ผลลัพธ์ของการทำแผนที่สามตัวแปร ( a, bและc) การสั่งซื้อสินค้า1จะเป็น:

• a
• ข
• ค
• AB
• ก่อนคริสต์ศักราช
• ไฟฟ้ากระแสสลับ
• abc

ผลลัพธ์ของmตัวแปรการแมปตามลำดับnจะเป็น:

• เป็นต้น

เกณฑ์การชนะ

เอาต์พุตทุกชุดค่าผสมที่เป็นไปได้ตามที่ระบุไว้ข้างต้น สั่งซื้อไม่สำคัญ ในรหัสของคุณคุณพิมพ์ไปที่หน้าจอไม่สำคัญ สิ่งที่สำคัญคือสิ่งที่ปรากฏในผลลัพธ์ของคุณถูกต้อง

Brachylogขนาด 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สภาพแวดล้อมของน้ำยางข้น

เมื่อเราได้รับการป้อนข้อมูลเราจะเริ่มวนรอบเราวน\intcalcPow{\b+1}{\a}ครั้งหนึ่งครั้งสำหรับแต่ละผลลัพธ์ที่เราต้องการพิมพ์ แต่ละวงวนเราเริ่มต้นequationสภาพแวดล้อมและวนรอบตามตัวอักษรเพื่อติดตาม\yตัวอักษรปัจจุบันและ\iสำหรับจำนวนการวิ่งปัจจุบัน หาก\iมากกว่าหรือเท่ากับที่\aเราไม่พิมพ์อะไรเลย (ตามรายละเอียดสิ่งนี้ไม่จำเป็นอย่างเคร่งครัด แต่ Latex จะล้นสำหรับค่าที่มากกว่า 1 ถ้าเราไม่ทำเช่นนี้) จากนั้นเราพิมพ์\yไปที่สมการของเราและยกระดับให้เป็นพลังของ

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

นั่นระเบียบทั้งหมดเพียงแค่วิธีการใช้\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)]สำหรับ"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 ไบต์รวมเป็น f n=tail.mapM((<$>[0..n]).(,))30:

เยลลี่ , 20 17 ไบต์

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

การเชื่อมโยง dyadic (ฟังก์ชั่น) ที่ยอมรับรายชื่อตัวแปร * และการสั่งซื้อสูงสุด (จำนวนเต็ม) และผลตอบแทนที่รายการแต่ละรายการเป็นตัวแทนขยายตัวได้เต็มที่ของคูณ (เช่นfoo ⁰บาร์³ bof ²['bar', 'bar', 'bar', 'bof', 'bof']จะเป็น

* ชื่อตัวแปรอาจเป็นสตริงของอักขระที่ไม่ซ้ำกัน (สตริงกลายเป็นรายการของอักขระ)

ลองออนไลน์! - ส่วนท้ายเรียกลิงก์เป็น dyad จากนั้นแยกรายการผลลัพธ์ตามรายการตัวดึงข้อมูลบรรทัดและแต่ละรายการด้วยช่องว่างเพื่อความสะดวกในการอ่าน

หมายเหตุ:รวมคำสั่งซื้อ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

ยินดีต้อนรับสู่นรกหนี - รั้ง - บางครั้ง shell-script ให้เครื่องมือที่เหมาะสมกับงานจริงๆ นี่ไม่ใช่กรณีที่นี่ แต่ใช้งานได้

อินพุตเป็นพารามิเตอร์บรรทัดคำสั่ง - 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}คือ a คือการขยายรั้งของรายการ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ลบพวกเขา

eval\วางและหนีออกมามากอย่างรอบคอบเพื่อให้มั่นใจว่าการขยายทั้งหมดที่เกิดขึ้นในการสั่งซื้อสินค้าที่จำเป็น

Röda , 49 48 46 bytes

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