ESPECIFICAÇÃO

Dadas as mvariáveis, crie todas as combinações conforme a ordem n. Por exemplo,

A saída do mapeamento de duas variáveis ​​( ae b) para ordenar 1seria:

• uma
• b
• ab

A saída do mapeamento de duas variáveis ​​( ae b) para ordenar 2seria:

• uma
• a ²
• b
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

A saída do mapeamento de duas variáveis ​​( ae b) para ordenar 3seria:

• uma
• a ²
• a ³
• b
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

A saída de mapeamento três variáveis ( a, b, e c) a fim 1seria:

• uma
• b
• c
• ab
• bc
• ac
• abc

A saída das mvariáveis de mapeamento para ordenar nseria:

• etc.

CRITÉRIOS GANHADORES

Saída de todas as combinações possíveis, conforme descrito acima. Ordem não importa. Onde no seu código você imprime na tela não importa. Tudo o que importa é que o que aparece na sua saída esteja correto.

Braquilog , 6 bytes

j₎o⊇ᵘb

Recebe entrada como um casal, contendo a lista de variáveis ​​e a ordem. Saída é uma lista de listas de variáveis, em que os poderes são representados por variáveis ​​repetidas. (por exemplo, "a²b" é ["a", "a", "b"])

Experimente online!

j₎une a primeira entrada consigo mesma quantas vezes for declarado pela segunda entrada. oordena a lista obtida e ⊇ᵘlocaliza todos os subconjuntos exclusivos dessa lista ordenada. Por fim, removemos o primeiro elemento com b, pois essa sempre será a resposta vazia, que não é contemplada pelo desafio.

L ^A T _E X, 354 bytes

Quando vi isso, sabia que tinha que ser feito em látex. As equações parecem tão nítidas e limpas no látex e não suporto usar o ^poder.

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

Explicação

Existem três forças principais em ação aqui, \typein que é o que nos permite obter informações da linha de comando, o intcalcpacote que é o que nos permite fazer cálculos com nossas variáveis ​​e o equationambiente Latex .

Depois de recebermos a entrada, iniciamos um loop, repetimos os \intcalcPow{\b+1}{\a}tempos, uma vez para cada resultado que queremos imprimir. A cada loop, iniciamos um equationambiente e percorremos o alfabeto, acompanhando \ya letra atual e \io número atual de execuções. Se \ifor maior que ou igual a \a, não imprimimos nada (de acordo com as especificações, isso não é estritamente necessário; no entanto, o látex excederá valores maiores que 1 se não fizermos isso). Em seguida, imprimimos \yem nossa equação e aumentamos para o poder de

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

Essa bagunça toda significa simplesmente pegar o \idécimo dígito da \xbase \b+1. Isso garante que os poderes sejam decodificados corretamente.

Exemplo de saída:

Aqui está a saída para 3, 2

Mathematica, 51 50 bytes

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

Assume que "determinadas mvariáveis" significam que a primeira entrada é uma lista de variáveis.

Se a primeira entrada for um número inteiro, 69 bytes

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

As variáveis ​​estão no formato $<integer>(por exemplo $5)

Haskell, 71 58 54 53 bytes

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

Retorna uma lista de strings e usa o formato de saída "aabbb"para "a^2 b^3".

Exemplo de uso: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Experimente online! .

Muitos bytes são gastos para formatação de saída. Uma saída mais flexível, por exemplo, pares de (variável, potência) -> [('a',2),('b',3),('c',1)]para "a^2 b^3 c^1"economizaria muito.

Como funciona

    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)

Com flexibilidade máxima, ou seja, o formato de saída como pares (variável, potência) e incluindo potências com zero ( "a^0 b^0 c^0"), tudo se resume a

Haskell, 25 bytes:

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

Exemplo de uso 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)]]

Descartando todas de zero poderes custa 5 bytes para um total de 30: f n=tail.mapM((<$>[0..n]).(,)).

Geléia , 20 17 bytes

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

Um link diádico (função) que aceita uma lista de nomes de variáveis ​​* e a ordem máxima (um número inteiro) e retorna uma lista em que cada entrada é uma representação totalmente expandida da multiplicação (por exemplo, foo ⁰ bar ³ bof ² seria ['bar', 'bar', 'bar', 'bof', 'bof'].

* os nomes das variáveis ​​podem ser uma sequência de caracteres únicos (as sequências tornam-se listas de caracteres).

Experimente online! - o rodapé chama o link como díade e depois separa a lista resultante de listas por feeds de linha e cada entrada por espaços para facilitar a leitura.

Nota: inclui o pedido 0 (produto vazio) e uma desenfileiramento Ḋ, pode ser inserida aqui ...ŒPḊç...para evitar isso.

Como?

ṗ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

Versão de 13 bytes que funcionará apenas para uma única sequência de caracteres únicos (ou uma lista de caracteres únicos):

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

tente

JavaScript (proposta de ES), 142 bytes

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

Requer um navegador com suporte **e ambos padStart, então tente o Firefox 52 ou Chrome 57.

Mathematica 100 bytes

Certamente, existe uma maneira mais eficiente de conseguir isso!

Duas variáveis ​​para pedir 4:

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

Bash + sed, 60

Uma abordagem diferente e mais curta da minha resposta anterior.

Entrada como parâmetros da linha de comando - mé fornecida como uma lista separada por vírgula de nomes de variáveis ​​e ncomo um número inteiro:

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

Experimente online .

Resposta anterior:

Bash + coreutils, 91

Bem-vindo ao inferno da eval-escape-brace. Às vezes, o shell-script realmente oferece a ferramenta certa para o trabalho. Este não é o caso aqui, mas funciona.

Entrada como parâmetros da linha de comando - mé fornecida como uma lista separada por vírgula de nomes de variáveis ​​e ncomo um número inteiro. A saída é gravada à mão - por exemplo, a^2é realmente gravada aa. Isso é aceitável conforme este comentário .

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

Pode haver maneiras mais curtas de fazer isso.

Experimente online .

Explicação

• printf -vc {%$[$2-1]s}atribui a variável ca uma string como { }, onde o número de espaços é a ordem n- 1, então se n= 1, o resultado é {}, se n= 2, o resultado é { }etc.
• ${a[$1]}usa mcomo um índice para a matriz a, então, se mfor 3, o resultado serác
• \{{a..${a[$1]}}${c// /,}\\,} é uma expansão de braçadeira de várias partes:
  • \{ - um literal {
  • {$1}é a é a expansão entre chaves da lista m, por exemplo, {a,b,c}oua b c
  • ${c// /,}substitui os espaços $cpor vírgulas, por exemplo, {,,}para n= 3, que também é uma expansão de chaves que repete efetivamente cada elemento de {a..c} nvezes
  • \\\,} - um literal ,}
• Portanto, para m= "a, b" e n= 2, isso se expande para{a,} {a,} {b,} {b,}
• O interior printfremove os espaços para dar {a,}{a,}{b,}{b,}, o que em si é uma expansão de cinta
• Isso se expande para aabb aab aab aa abb ab ab a abb ab ab a bb b b
• O externo printfcoloca cada um desses elementos em sua própria linha
• sort -u remove as duplicatas
• A tr -d {}está lá para tratar o caso quando n= 1. No presente caso, a variável cserá {}que não é uma expansão cinta, mas em vez disso são inseridos os caracteres literais. Os trremove.

evalse \escapes são colocados com muito cuidado para garantir que todas as expansões ocorram na ordem necessária.

Röda , 49 48 46 bytes

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

Experimente online!

Eu acho que está correto. Ele não usa nenhum separador entre uma variável e sua ordem. A versão anterior foi usada !, mas percebi que não é estritamente necessária.

Explicado:

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

Uso:

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

Resultado:

b
bb
a
ab
abb
aa
aab
aabb

Melhor formato em 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:]

Saída (mesmo uso):

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

Ainda melhor em 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:]

Resultado:

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

Os últimos 4 bytes ( [1:]) ao todo são para remover o produto vazio.

Eles funcionam no Python 2 e 3.

C ++ 14, 146 140 bytes

-6 bytes para um formato de saída mais simples.

Lambda sem nome, assumindo entradas scomo std::stringe ocomo 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 explicaçã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);
}

Resultado:

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