SPECYFIKACJA

Biorąc pod uwagę mzmienne, utwórz każdą kombinację według kolejności n. Na przykład,

Dane wyjściowe mapowania dwóch zmiennych ( ai b) na kolejność 1byłyby następujące:

• za
• b
• ab

Dane wyjściowe mapowania dwóch zmiennych ( ai b) na kolejność 2byłyby następujące:

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

Dane wyjściowe mapowania dwóch zmiennych ( ai b) na kolejność 3byłyby następujące:

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

Wyjście odwzorowania trzy zmienne ( a, bi c), w celu 1to:

• za
• b
• do
• ab
• pne
• ac
• ABC

Dane wyjściowe mzmiennych odwzorowujących na zamówienie nto:

• itp.

WYGRANE KRYTERIA

Wyprowadzaj każdą możliwą kombinację, jak opisano powyżej. Porządek nie ma znaczenia. Gdzie w kodzie drukujesz na ekranie, nie ma to znaczenia. Liczy się tylko to, co pojawia się w twoich wynikach.

Brachylog , 6 bajtów

j₎o⊇ᵘb

Pobiera dane wejściowe jako para, zawierające listę zmiennych i kolejność. Dane wyjściowe to lista list zmiennych, w których moc reprezentowana jest przez zmienne powtarzane. (np. „a²b” to [„a”, „a”, „b”])

Wypróbuj online!

j₎łączy się z pierwszym wejściem tyle razy, ile wskazuje drugie wejście. oporządkuje uzyskaną listę, a następnie ⊇ᵘwyszukuje wszystkie unikalne podzbiory tej uporządkowanej listy. Wreszcie usuwamy pierwszy element za pomocą b, ponieważ zawsze będzie to pusta odpowiedź, która nie jest rozważana przez wyzwanie.

L ^A T _E X, 354 bajtów

Kiedy to zobaczyłem, wiedziałem, że trzeba to zrobić w lateksie. Równania po prostu wyglądają tak ostro i czysto w lateksie i nie mogę znieść używania ^mocy.

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

Wyjaśnienie

Działają tutaj trzy główne siły, \typein co pozwala nam pobierać dane z wiersza poleceń, intcalcpakiet, który pozwala nam wykonywać obliczenia na podstawie naszych zmiennych oraz equationśrodowisko lateksowe .

Po wprowadzeniu danych zaczynamy pętlę \intcalcPow{\b+1}{\a}razy, zapętlamy raz dla każdego wyniku, który chcemy wydrukować. W każdej pętli uruchamiamy equationśrodowisko i przeglądamy alfabet, śledząc \ybieżącą literę i \ibieżącą liczbę przebiegów. Jeśli \ijest większy lub równy \a, w ogóle nic nie drukujemy (zgodnie ze specyfikacją nie jest to absolutnie konieczne, jednak Latex przepełni się dla wartości większych niż 1, jeśli tego nie zrobimy). Następnie drukujemy \ydo naszego równania i podnosimy je do potęgi

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

Cały ten bałagan oznacza po prostu zabranie \icyfry th \xw bazie \b+1. Zapewnia to prawidłowe dekodowanie mocy.

Przykładowe dane wyjściowe:

Oto wynik dla 3, 2

Mathematica, 51 50 bajtów

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

Zakłada, że ​​„podane mzmienne” oznaczają, że pierwszym wejściem jest lista zmiennych.

Jeśli pierwszym wejściem jest liczba całkowita, 69 bajtów

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

Zmienne są w formie $<integer>(np. $5)

Haskell, 71 58 54 53 bajtów

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

Zwraca listę ciągów znaków i używa formatu wyjściowego "aabbb"dla "a^2 b^3".

Przykład użycia: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Wypróbuj online! .

Wiele bajtów jest wydawanych na formatowanie wyjściowe. Bardziej elastyczny wynik, np. Pary (zmienna, moc) -> [('a',2),('b',3),('c',1)]dla, "a^2 b^3 c^1"znacznie by zaoszczędził.

Jak to działa

    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)

Z maksymalną elastycznością, tzn. Formatem wyjściowym jako pary (zmienna, moc) i obejmującym moce zerowe ( "a^0 b^0 c^0"), sprowadza się do

Haskell, 25 bajtów:

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

Przykład użycia 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)]]

Upuszczenie wszystkie zera uprawnień kosztuje 5 bajtów dla w sumie 30: f n=tail.mapM((<$>[0..n]).(,)).

Galaretka , 20 17 bajtów

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

Dwójkowym związek (funkcja), które przyjmuje się listę nazwy zmiennych * oraz w celu maksymalnej (całkowita) i zwraca listy, na której każda pozycja jest w pełni rozszerzona przedstawienie mnożenia (np bla ⁰ pasek ³ BOF ² byłoby ['bar', 'bar', 'bar', 'bof', 'bof'].

* nazwy zmiennych mogą być ciągiem unikatowych znaków (ciągi stają się listami znaków).

Wypróbuj online! - stopka wywołuje łącze jako diadę, a następnie oddziela wynikową listę list według linii i każdego wpisu spacjami, aby ułatwić czytanie.

Uwaga: zawiera zamówienie 0 (pusty produkt) Ḋ, można tutaj wstawić dequeue, ...ŒPḊç...aby tego uniknąć.

W jaki sposób?

ṗ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-bajtowa wersja, która będzie działać tylko dla jednego ciągu unikatowych znaków (lub listy unikalnych znaków):

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

Spróbuj

JavaScript (propozycja ES), 142 bajty

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

Wymaga przeglądarki z obsługą obu **i padStart, więc wypróbuj Firefox 52 lub Chrome 57.

Matematyka 100 bajtów

Z pewnością istnieje bardziej skuteczny sposób na osiągnięcie tego!

Dwie zmienne do zamówienia 4:

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

Bash + sed, 60

Inne, krótsze podejście do mojej poprzedniej odpowiedzi.

Dane wejściowe jako parametry wiersza polecenia - mpodano jako listę nazw zmiennych oddzieloną przecinkami oraz njako liczbę całkowitą:

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

Wypróbuj online .

Poprzednia odpowiedź:

Bash + coreutils, 91

Witamy w piekle eval-escape-brace. Czasami skrypt powłoki naprawdę daje właściwe narzędzie do pracy. W tym przypadku tak nie jest , ale działa.

Dane wejściowe jako parametry wiersza polecenia - mpodano jako listę nazw zmiennych oddzieloną przecinkami i njako liczbę całkowitą. Dane wyjściowe są zapisywane ręcznie - np. a^2Faktycznie są zapisywane aa. Jest to dopuszczalne zgodnie z tym komentarzem .

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

Mogą to być krótsze sposoby.

Wypróbuj online .

Wyjaśnienie

• printf -vc {%$[$2-1]s}przypisuje zmienną cdo łańcucha, np. { }gdzie liczba spacji jest rzędu n- 1, więc jeśli n= 1, wynikiem jest {}, jeśli n= 2, wynikiem jest { }itd.
• ${a[$1]}używa mjako indeksu do tablicy a, więc jeśli mwynosi 3, to wynikiem jestc
• \{{a..${a[$1]}}${c// /,}\\,} to wieloczęściowe rozszerzenie nawiasu klamrowego:
  • \{ - dosłowny {
  • {$1}to a to nawias klamrowy listy m, np. {a,b,c}luba b c
  • ${c// /,}zastępuje spacje $cprzecinkami, np. {,,}dla n= 3, co jest również rozwinięciem nawiasu, który skutecznie powtarza każdy element {a..c} nrazy
  • \\\,} - dosłowny ,}
• Więc dla m= "a, b" i n= 2, to rozwija się do{a,} {a,} {b,} {b,}
• Wewnętrzne printfusuwa przestrzenie {a,}{a,}{b,}{b,}, które dają , co samo w sobie jest rozszerzeniem nawiasu klamrowego
• To rozwija się do aabb aab aab aa abb ab ab a abb ab ab a bb b b
• Zewnętrzne printfstawia każdy z tych elementów na osobnej linii
• sort -u usuwa duplikaty
• tr -d {}Ma na sobie sprawę, gdy n= 1. W tym przypadku, zmienna cbędzie {}nie jest ekspansja klamra, lecz dosłownym znaki są włożone. trUsuwa je.

evals i \ucieczki są umieszczane bardzo ostrożnie, aby zapewnić, że wszystkie rozszerzenia występują w niezbędnej kolejności.

Röda , 49 48 46 bajtów

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

Wypróbuj online!

Myślę, że to prawda. Nie używa żadnego separatora między zmienną a jej kolejnością. Poprzednia wersja była używana !, ale zdałem sobie sprawę, że nie jest to absolutnie wymagane.

Wyjaśnione:

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 bajtów

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

Stosowanie:

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

Wynik:

b
bb
a
ab
abb
aa
aab
aabb

Ładniejszy format w 115 bajtach :

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

Wyjście (to samo użycie):

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

Jeszcze ładniej w 125 bajtach :

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

Wynik:

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

Ostatnie 4 bajty ( [1:]) służą do usunięcia pustego produktu.

Działa to zarówno w Pythonie 2, jak i 3.

C ++ 14, 146 140 bajtów

-6 bajtów dla prostszego formatu wyjściowego.

Nienazwana lambda, przy założeniu, że dane wejściowe stakie jak std::stringi ojako 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<<" ";}}

Użycie i wyjaśnienie:

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

Wynik:

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