SPEZIFIKATION

mErstellen Sie bei gegebenen Variablen jede Kombination bis zur Reihenfolge n. Beispielsweise,

Die Ausgabe der Zuordnung von zwei Variablen ( aund b) zur Reihenfolge 1wäre:

• ein
• b
• ab

Die Ausgabe der Zuordnung von zwei Variablen ( aund b) zur Reihenfolge 2wäre:

• ein
• a ²
• b
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

Die Ausgabe der Zuordnung von zwei Variablen ( aund b) zur Reihenfolge 3wäre:

• ein
• a ²
• a ³
• b
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

Das Ausgangssignal des Mapping drei Variablen ( a, b, und c) , um zu bestellen 1wäre:

• ein
• b
• c
• ab
• bc
• ac
• ABC

Die Ausgabe der Zuordnungsvariablen mzur Reihenfolge nwäre:

• etc.

GEWINNKRITERIEN

Geben Sie jede mögliche Kombination wie oben beschrieben aus. Bestellung spielt keine Rolle. Wo in Ihrem Code Sie auf dem Bildschirm drucken, spielt keine Rolle. Alles was zählt ist, dass das, was in Ihrer Ausgabe angezeigt wird, korrekt ist.

Brachylog , 6 Bytes

j₎o⊇ᵘb

Nimmt die Eingabe als Paar entgegen und enthält die Liste der Variablen und die Reihenfolge. Die Ausgabe ist eine Liste von Variablenlisten, in denen Potenzen durch wiederholte Variablen dargestellt werden. (zB "a²b" ist ["a", "a", "b"])

Probieren Sie es online aus!

j₎verbindet den ersten Eingang so oft mit sich selbst, wie der zweite Eingang angibt. oordnet die erhaltene Liste an und ⊇ᵘfindet dann alle eindeutigen Teilmengen dieser geordneten Liste. Schließlich entfernen wir das erste Element mit b, da dies immer die leere Antwort ist, die von der Herausforderung nicht berücksichtigt wird.

L ^A T _E X, 354 Bytes

Als ich das sah, wusste ich, dass es in Latex gemacht werden musste. Gleichungen sehen in Latex einfach so klar und sauber aus, und ich kann es nicht ertragen, sie ^für Strom zu verwenden.

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

Erläuterung

Hier wirken drei Hauptkräfte, \typein die es uns ermöglichen, Eingaben über die Befehlszeile intcalcvorzunehmen , das Paket, mit dem wir Berechnungen mit unseren Variablen durchführen können, und die Latexumgebung equation.

Sobald wir die Eingabe eingegeben haben, beginnen wir eine Schleife, die wir einmal wiederholen \intcalcPow{\b+1}{\a}, einmal für jedes Ergebnis, das wir drucken möchten. In jeder Schleife beginnen wir eine equationUmgebung und durchlaufen das Alphabet, wobei wir \yden aktuellen Buchstaben und \idie aktuelle Anzahl der Läufe verfolgen . Wenn \igrößer oder gleich ist, \adrucken wir überhaupt nichts (gemäß den Spezifikationen ist dies nicht unbedingt erforderlich, aber Latex läuft bei Werten größer als 1 über, wenn wir dies nicht tun). Wir drucken dann \ynach unserer Gleichung und erhöhen sie auf die Potenz von

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

Dieses ganze Durcheinander bedeutet einfach, die \idritte Ziffer \xin der Basis zu nehmen \b+1. Dies stellt sicher, dass die Kräfte richtig dekodiert werden.

Beispielausgabe:

Hier ist die Ausgabe für 3, 2

Mathematica, 51 50 Bytes

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

Angenommen, "gegebene mVariablen" bedeutet, dass die erste Eingabe eine Liste von Variablen ist.

Wenn die erste Eingabe eine Ganzzahl ist, 69 Bytes

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

Die Variablen haben die Form $<integer>(zB $5)

Haskell, 71 58 54 53 Bytes

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

Gibt eine Liste von Zeichenfolgen zurück und verwendet das Ausgabeformat "aabbb"für "a^2 b^3".

Anwendungsbeispiel: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Probieren Sie es online aus! .

Viele Bytes werden für die Ausgabeformatierung ausgegeben. Eine flexiblere Ausgabe, zB Paare von (variabel, Leistung) -> [('a',2),('b',3),('c',1)]für "a^2 b^3 c^1"würde viel sparen.

Wie es funktioniert

    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)

Mit maximaler Flexibilität, dh Ausgabeformat als (variable, Leistungs-) Paare und einschließlich Null-Potenzen ( "a^0 b^0 c^0"), läuft es darauf hinaus

Haskell, 25 Bytes:

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

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

Das Löschen von Nullen kostet 5 Bytes für insgesamt 30 : f n=tail.mapM((<$>[0..n]).(,)).

Gelee , 20 17 Bytes

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

A dyadischen Link (Funktion) , die eine Liste von Variablennamen * und der maximale Ordnung (eine ganze Zahl) und gibt eine Liste akzeptiert , wobei jeder Eintrag eine vollständig expandierte Darstellung der Multiplikation ist (zB foo ⁰ bar ³ BOF ² wäre ['bar', 'bar', 'bar', 'bof', 'bof'].

* Die Variablennamen können eine Zeichenfolge aus eindeutigen Zeichen sein (Zeichenfolgen werden zu Listen von Zeichen).

Probieren Sie es online aus! - Die Fußzeile ruft den Link als Dyade auf und trennt dann die resultierende Liste der Listen nach Zeilenvorschüben und jeden Eintrag nach Leerzeichen, um das Lesen zu erleichtern.

Hinweis: Enthält die 0- Bestellung (leeres Produkt) eine Warteschlange Ḋ, kann hier eingefügt werden ...ŒPḊç..., um dies zu vermeiden.

Wie?

ṗ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-Byte-Version, die nur für eine einzelne Zeichenfolge eindeutiger Zeichen (oder eine Liste eindeutiger Zeichen) funktioniert:

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

Versuch es

JavaScript (ES-Vorschlag), 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

Benötigt einen Browser mit beidem **und padStartUnterstützung, versuchen Sie es also mit Firefox 52 oder Chrome 57.

Mathematica 100 Bytes

Sicher gibt es einen effizienteren Weg, dies zu erreichen!

Zwei Variablen zur Bestellung 4:

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

Bash + sed, 60

Ein anderer, kürzerer Ansatz für meine vorherige Antwort.

Eingabe als Befehlszeilenparameter - mwird als durch Kommas getrennte Liste von Variablennamen und nals Ganzzahl angegeben:

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

Probieren Sie es online aus .

Vorherige Antwort:

Bash + Coreutils, 91

Willkommen in der Hölle der Eval-Escape-Brace. Manchmal bietet das Shell-Skript wirklich genau das richtige Werkzeug für den Job. Dies ist hier nicht der Fall, aber es funktioniert.

Eingabe als Befehlszeilenparameter - mwird als durch Kommas getrennte Liste von Variablennamen und nals Ganzzahl angegeben. Die Ausgabe wird in Langschrift ausgeschrieben - zB a^2tatsächlich geschrieben aa. Dies ist gemäß diesem Kommentar akzeptabel .

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

Möglicherweise gibt es dafür kürzere Möglichkeiten.

Probieren Sie es online aus .

Erläuterung

• printf -vc {%$[$2-1]s}Weist die Variable ceiner Zeichenfolge zu { }, bei der die Anzahl der Leerzeichen in der Reihenfolge n1 liegt. Wenn also n= 1, ist das Ergebnis {}, wenn n= 2, ist das Ergebnis { }usw.
• ${a[$1]}wird mals Index für das Array verwendet a. Wenn malso 3 ist, ist das Ergebnisc
• \{{a..${a[$1]}}${c// /,}\\,} ist eine mehrteilige Zahnspangenerweiterung:
  • \{ - ein wörtliches {
  • {$1}ist a ist die Klammererweiterung der Liste m, zB {a,b,c}odera b c
  • ${c// /,}Ersetzt die Leerzeichen $cdurch Kommas, z. B. {,,}für n= 3, was auch eine Klammererweiterung ist, die jedes Element der {a..c} nZeit effektiv wiederholt
  • \\\,} - ein wörtliches ,}
• Für m= "a, b" und n= 2 wird dies auf erweitert{a,} {a,} {b,} {b,}
• Das Innere printfentfernt die Räume, um zu geben {a,}{a,}{b,}{b,}, was selbst eine Klammererweiterung ist
• Dies erweitert sich auf aabb aab aab aa abb ab ab a abb ab ab a bb b b
• Das Äußere printfsetzt jedes dieser Elemente in eine eigene Linie
• sort -u entfernt die Duplikate
• Das tr -d {}ist der Fall zu handhaben, als n1. In diesem Fall = die Variable csein wird , {}die nicht eine Verstrebung Expansion ist, sondern die Literal - Zeichen eingefügt sind. Das trentfernt sie.

evals und \Fluchtwege werden sehr sorgfältig platziert, um sicherzustellen, dass alle Erweiterungen in der erforderlichen Reihenfolge erfolgen.

Röda , 49 48 46 Bytes

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

Probieren Sie es online aus!

Ich denke es ist richtig. Es wird kein Trennzeichen zwischen einer Variablen und ihrer Reihenfolge verwendet. Die vorherige Version verwendet !, aber ich erkannte, dass es nicht unbedingt erforderlich ist.

Erklärt:

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 Bytes

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

Verwendungszweck:

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

Ausgabe:

b
bb
a
ab
abb
aa
aab
aabb

Schöneres Format in 115 Bytes :

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

Ausgabe (gleiche Verwendung):

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

Noch schöner in 125 Bytes :

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

Ausgabe:

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

Die letzten 4 Bytes ( [1:]) dienen zum Entfernen des leeren Produkts.

Diese funktionieren sowohl in Python 2 als auch in Python 3.

C ++ 14, 146 140 Bytes

-6 Byte für einfacheres Ausgabeformat.

Unbenanntes Lambda, unter der Annahme von Eingaben swie std::stringund oals 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<<" ";}}

Verwendung und Erklärung:

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

Ausgabe:

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