Erstellen Sie jede Kombination von Variablengruppen bis zur Reihenfolge n

9

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 2
  • b
  • b 2
  • ab
  • a 2 b
  • ab 2
  • a 2 b 2

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

  • ein
  • a 2
  • a 3
  • b
  • b 2
  • b 3
  • ab
  • a 2 b
  • a 3 b
  • a 3 b 2
  • ab 2
  • ab 3
  • a 2 b 3
  • a 2 b 2
  • a 3 b 3

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.

user1873073
quelle
1
Wie sollen wir ausgeben? Sollen wir verwenden ^?
Ad-hoc-Garf-Jäger
1
Können wir die Dinge auf Null oder Eins bringen (zB a ^ 1)
Ad-hoc-Garf-Jäger
1
Was ist, wenn mgrößer als 26 ist? Müssen wir so hohe Werte unterstützen?
Ad-hoc-Garf-Jäger
1
@ user1873073 Das Problem ist nicht die maximale Reihenfolge, sondern die maximale Anzahl von Variablennamen.
Martin Ender
1
Wie werden die Variablen angegeben? In vielen Kommentaren wird davon ausgegangen, dass es sich bei der Eingabe um eine Reihe von Variablen handelt. Der Text given m variablesimpliziert jedoch, dass eine Liste von Variablen angegeben wird. Wenn nur die Anzahl der Variablen angegeben und 0,1,2,3..27,28,29 auf Potenzen ^ 0, ^ 1, ^ 2 usw. angehoben wird, ist dies eine akzeptable Ausgabe (wie ich aus Ihrem letzten Kommentar schließe) Dinge einfacher.
Level River St

Antworten:

4

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öwe
quelle
14

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

Ausgabe

Ad-hoc-Garf-Jäger
quelle
1
Beachten Sie, dass Ihre Ausgabe a ^ 0 b ^ 0 c ^ 0 = 1 enthält, während dies in den Testfällen nicht der Fall ist. Davon abgesehen denke ich, dass Sie Recht haben und die Testfälle falsch sind :)
Greg Martin
@ GregMartin Ja, mathematisch gesehen sollte die leere Menge in der en.wikipedia.org/wiki/Power_set
Karl Napf
@KarlNapf Ein Ausdruck gleich 1 ist nicht die leere Menge. Ein Tupel enthält auch keine 3 Nullen.
jpmc26
@ jpmc26 Ja, nicht in der Spezifikation dieses Golfs. Es ist wie das Powerset von (für n = 3) {a, a, a, b, b, b, c, c, c} ohne die leere Menge
Karl Napf
@KarlNapf Es ist mathematisch nicht dasselbe. Hier ist kein leerer Satz beteiligt. Die Herausforderung besteht darin, eine Reihe von Tupeln mit einer bestimmten Länge zu generieren.
jpmc26
5

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)

JungHwan min
quelle
Bis PowerRangeist eine Sache! Ich bin mit der Interpretation Ihrer ersten Einreichung übrigens einverstanden
Greg Martin
4

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]).(,)).

Nimi
quelle
Für Ihren zweiten Code [('a',0),('b',0)]sollte nicht in der Ausgabe sein ...
JungHwan Min
@JungHwanMin: Meine 25-Byte-Lösung ist keine Antwort. Es ist ein Hinweis, der zeigt, dass der kombinatorische Teil der Herausforderung die geringste Anzahl von Bytes benötigt - zumindest in Haskell. Das Löschen a^0 b^0kostet 5 Bytes. Ich werde eine weitere Notiz hinzufügen.
Nimi
4

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 0 bar 3 BOF 2 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

Jonathan Allan
quelle
3

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.

Neil
quelle
3

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]])) &

Bild

DavidC
quelle
3

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.

Digitales Trauma
quelle
3

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

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.

Alex Hall
quelle
0

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 
Karl Napf
quelle