СПЕЦИФІКАЦІЯ

Дані mзмінні створюйте кожну комбінацію на замовлення n. Наприклад,

Виведення відображення двох змінних ( aі b) на замовлення 1буде:

• а
• б
• аб

Виведення відображення двох змінних ( aі b) на замовлення 2буде:

• а
• a ²
• б
• b ²
• аб
• a ² b
• ab ²
• a ² b ²

Виведення відображення двох змінних ( aі b) на замовлення 3буде:

• а
• a ²
• a ³
• б
• b ²
• б ³
• аб
• a ² b
• a ³ б
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

Висновок відображення трьох змінних ( a, bі c) на замовлення 1буде:

• а
• б
• c
• аб
• до н.е.
• змінного струму
• абс

Виведення mзмінних відображення на замовлення nбуде:

• тощо.

КРИТЕРІЇ ПЕРЕМОГИ

Виведіть кожну можливу комбінацію, як зазначено вище. Порядок не має значення. Де в коді ви друкуєте на екран, значення не має. Важливо лише те, що те, що відображається у ваших результатах, є правильним.

Брахілог , 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середовище Latex .

Після того, як ми взяли введення, ми починаємо цикл, який циклікуємо \intcalcPow{\b+1}{\a}раз, раз для кожного результату, який ми хочемо надрукувати. Кожен цикл ми починаємо equationсередовище і перебираємо через алфавіт, відслідковуючи \yпоточну букву та \iпоточну кількість прогонів. Якщо \iбільше або дорівнює, \aми взагалі нічого не друкуємо (відповідно до специфікацій, це не обов'язково, проте латекс буде переповнено для значень, більших за 1, якщо ми цього не зробимо). Потім ми друкуємо \yдо нашого рівняння і піднімаємо його під силу

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

Весь цей безлад просто означає взяти цю \iцифру \xв основу \b+1. Це забезпечує правильне декодування повноважень.

Приклад виводу:

Ось вихід для 3, 2

Математика, 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 байт в цілому 30: 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. Іноді оболонка-скрипт справді дає лише потрібний інструмент для роботи. Тут це не так, але це працює.

Введення як параметрів командного рядка - 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комами, наприклад, {,,}для 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Видаляє їх.

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. */
}

Пітон, 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