SPECIFICHE

Date le mvariabili, crea ogni combinazione fino all'ordine n. Per esempio,

L'output della mappatura di due variabili ( ae b) da ordinare 1sarebbe:

• un'
• B
• ab

L'output della mappatura di due variabili ( ae b) da ordinare 2sarebbe:

• un'
• a ²
• B
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

L'output della mappatura di due variabili ( ae b) da ordinare 3sarebbe:

• un'
• a ²
• a ³
• B
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

L'uscita di mappatura tre variabili ( a, b, e c) per ordine 1sarebbe:

• un'
• B
• c
• ab
• avanti Cristo
• AC
• abc

L'output delle mvariabili di mappatura da ordinare nsarebbe:

• eccetera.

CRITERI VINCENTI

Stampa ogni possibile combinazione come indicato sopra. L'ordine non ha importanza. Non importa dove nel tuo codice stampi sullo schermo. Tutto ciò che conta è che ciò che appare nel tuo output sia corretto.

Brachylog , 6 byte

j₎o⊇ᵘb

Accetta input come coppia, contenente l'elenco di variabili e l'ordine. L'output è un elenco di elenchi di variabili, in cui i poteri sono rappresentati da variabili ripetute. (ad esempio "a²b" è ["a", "a", "b"])

Provalo online!

j₎unisce il primo input con se stesso tante volte quante sono indicate dal secondo input. oordina l'elenco ottenuto, quindi ⊇ᵘtrova tutti i sottoinsiemi univoci di tale elenco ordinato. Infine, rimuoviamo il primo elemento con b, poiché questa sarà sempre la risposta vuota, che non è contemplata dalla sfida.

L ^A T _E X, 354 byte

Quando l'ho visto ho capito che doveva essere fatto in Latex. Le equazioni sembrano così nitide e pulite in Latex e non sopporto il ^potere.

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

Spiegazione

Ci sono tre forze principali al lavoro qui \typein che è ciò che ci consente di prendere input dalla riga di comando, il intcalcpacchetto che è ciò che ci permette di fare calcoli con le nostre variabili e l' equationambiente in lattice .

Una volta che abbiamo inserito l'input, iniziamo un ciclo che ripetiamo i \intcalcPow{\b+1}{\a}tempi, una volta per ogni risultato che vogliamo stampare. Ad ogni ciclo iniziamo un equationambiente e attraversiamo l'alfabeto tenendo traccia della \ylettera corrente e \idel numero corrente di corse. Se \iè maggiore o uguale a \anon stampiamo nulla (secondo le specifiche, ciò non è strettamente necessario, tuttavia Latex trabocca per valori maggiori di 1 se non lo facciamo). Quindi stampiamo \ysulla nostra equazione e la eleviamo al potere di

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

Tutto quel casino significa semplicemente prendere la \iterza cifra di \xin base \b+1. Questo assicura che i poteri siano decodificati correttamente.

Esempio di output:

Ecco l'output per 3, 2

Mathematica, 51 50 byte

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

Suppone che " mvariabili date " significhi che il primo input è un elenco di variabili.

Se il primo input è un numero intero, 69 byte

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

Le variabili sono nella forma $<integer>(ad es. $5)

Haskell, 71 58 54 53 byte

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

Restituisce un elenco di stringhe e utilizza il formato di output "aabbb"per "a^2 b^3".

Esempio di utilizzo: 3 # "ab"->["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"] . Provalo online! .

Vengono spesi molti byte per la formattazione dell'output. Un'uscita più flessibile, ad es. Coppie di (variabile, potenza) ->[('a',2),('b',3),('c',1)] per "a^2 b^3 c^1", risparmierebbe molto.

Come funziona

    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)

Con la massima flessibilità, ovvero il formato di output come coppie (variabili, di potenza) e includendo potenze a zero ("a^0 b^0 c^0" ) si riduce a

Haskell, 25 byte:

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

Esempio di utilizzo 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)]]

Cadere tutti zero potenze costa 5 byte per un totale di 30: f n=tail.mapM((<$>[0..n]).(,)).

Gelatina , 20 17 byte

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

Un collegamento diadico (funzione) che accetta un elenco di nomi di variabili * e l'ordine massimo (un numero intero) e restituisce un elenco in cui ogni voce è una rappresentazione completamente estesa della moltiplicazione (ad esempio foo ⁰ bar ³ bof ² sarebbe ['bar', 'bar', 'bar', 'bof', 'bof'].

* i nomi delle variabili possono essere una stringa di caratteri univoci (le stringhe diventano elenchi di caratteri).

Provalo online! - il piè di pagina chiama il collegamento come diade e quindi separa l'elenco risultante di elenchi per feed di riga e ogni voce per spazi per facilitare la lettura.

Nota: include l' ordine 0 (prodotto vuoto) un dequeue Ḋ, può essere inserito qui ...ŒPḊç...per evitarlo.

Come?

ṗ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

Versione a 13 byte che funzionerà solo per una singola stringa di caratteri univoci (o un elenco di caratteri univoci):

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

Provalo

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

Richiede un browser con entrambi **e padStartsupporto, quindi prova Firefox 52 o Chrome 57.

Mathematica 100 byte

Sicuramente esiste un modo più efficiente per ottenere questo risultato!

Due variabili per ordinare 4:

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

Bash + sed, 60

Un approccio diverso e più breve alla mia risposta precedente.

Input come parametri della riga di comando: mviene fornito come un elenco separato da virgole di nomi di variabili e ncome numero intero:

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

Provalo online .

Risposta precedente:

Bash + coreutils, 91

Benvenuti all'inferno di eval-escape-brace. A volte shell-script offre davvero lo strumento giusto per il lavoro. Questo non è il caso qui, ma funziona.

Input come parametri della riga di comando: mviene fornito come un elenco separato da virgole di nomi di variabili e ncome numero intero. L'output è scritto a mano, ad es. a^2È effettivamente scritto aa. Questo è accettabile come da questo commento .

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

Potrebbero esserci modi più brevi per farlo.

Provalo online .

Spiegazione

• printf -vc {%$[$2-1]s}assegna la variabile ca una stringa come { }, dove il numero di spazi è l'ordine n- 1, quindi se n= 1, il risultato è {}, se n= 2, il risultato è { }, ecc.
• ${a[$1]}utilizza mcome indice l'array a, quindi se mè 3, il risultato èc
• \{{a..${a[$1]}}${c// /,}\\,} è un'espansione in più parti:
  • \{ - un letterale {
  • {$1}è a è l'espansione di parentesi graffe dell'elenco m, ad esempio {a,b,c}oa b c
  • ${c// /,}sostituisce gli spazi $ccon virgole, ad esempio {,,}per n= 3, che è anche un'espansione di parentesi graffe che ripete efficacemente ogni elemento dei {a..c} ntempi
  • \\\,} - un letterale ,}
• Quindi per m= "a, b" e n= 2, questo si espande in{a,} {a,} {b,} {b,}
• L'interno printfrimuove gli spazi da dare {a,}{a,}{b,}{b,}, che a sua volta è un'espansione di parentesi graffe
• Questo si espande a aabb aab aab aa abb ab ab a abb ab ab a bb b b
• L'esterno printfmette ciascuno di questi elementi sulla propria linea
• sort -u rimuove i duplicati
• L' tr -d {}è lì per gestire il caso quando n= 1. In questo caso la variabile csarà {}che non è un'espansione tutore, ma invece vengono inseriti i caratteri letterali. Il trloro rimuove.

evalse e le \fughe vengono posizionate con molta attenzione per garantire che tutte le espansioni avvengano nell'ordine necessario.

Röda , 49 48 46 byte

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

Provalo online!

Penso che sia corretto Non utilizza alcun separatore tra una variabile e il suo ordine. La versione precedente è stata utilizzata !, ma mi sono reso conto che non è strettamente necessario.

Ha spiegato:

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 byte

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

Uso:

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

Produzione:

b
bb
a
ab
abb
aa
aab
aabb

Formato migliore in 115 byte :

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

Output (stesso utilizzo):

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

Ancora più bello in 125 byte :

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

Produzione:

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

Gli ultimi 4 byte ( [1:]) in tutto sono per la rimozione del prodotto vuoto.

Funzionano in Python 2 e 3.

C ++ 14, 146 140 byte

-6 byte per un formato di output più semplice.

Lambda senza nome, assumendo input scome std::stringe ocome 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<<" ";}}

Uso e spiegazione:

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

Produzione:

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