ESPECIFICACIÓN

Dadas mlas variables, crean todas las combinaciones hasta el fin n. Por ejemplo,

El resultado de mapear dos variables ( ay b) por orden 1sería:

• una
• si
• ab

El resultado de mapear dos variables ( ay b) por orden 2sería:

• una
• un ²
• si
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

El resultado de mapear dos variables ( ay b) por orden 3sería:

• una
• un ²
• un ³
• si
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

La salida de la cartografía de tres variables ( a, by c) a la orden 1sería:

• una
• si
• C
• ab
• antes de Cristo
• C.A
• a B C

La salida de las mvariables de mapeo a pedido nsería:

• etc.

CRITERIOS GANADORES

Imprima todas las combinaciones posibles como se describe anteriormente. El orden no importa. No importa en qué parte del código imprima en la pantalla. Lo único que importa es que lo que aparece en su salida es correcto.

Brachylog , 6 bytes

j₎o⊇ᵘb

Toma la entrada como un par, que contiene la lista de variables y el orden. La salida es una lista de listas de variables, donde las potencias están representadas por variables repetidas. (por ejemplo, "a²b" es ["a", "a", "b"])

Pruébalo en línea!

j₎une la primera entrada consigo mismo tantas veces como lo indique la segunda entrada. oordena la lista obtenida y luego ⊇ᵘencuentra todos los subconjuntos únicos de esa lista ordenada. Finalmente, eliminamos el primer elemento con b, ya que esta siempre será la respuesta vacía, que el desafío no contempla.

L ^A T _E X, 354 bytes

Cuando vi esto, supe que tenía que hacerse en Latex. Las ecuaciones se ven tan nítidas y limpias en Latex y no puedo soportar usarlas ^para obtener potencia.

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

Explicación

Hay tres fuerzas principales en el trabajo aquí, \typein que es lo que nos permite tomar datos de la línea de comandos, el intcalcpaquete que es lo que nos permite hacer cálculos con nuestras variables y el equationentorno Latex .

Una vez que hemos recibido la entrada, comenzamos un ciclo de \intcalcPow{\b+1}{\a}tiempo de ciclo , una vez para cada resultado que queremos imprimir. Cada ciclo comenzamos un equationentorno y recorremos el alfabeto siguiendo \yla letra actual y \iel número actual de ejecuciones. Si \ies mayor o igual \aque no imprimimos nada (de acuerdo con las especificaciones, esto no es estrictamente necesario, sin embargo, Latex se desbordará para valores mayores que 1 si no hacemos esto). Luego imprimimos \ya nuestra ecuación y la elevamos al poder de

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

Todo ese desastre simplemente significa tomar el \idígito th de \xin base \b+1. Esto asegura que los poderes se decodifiquen correctamente.

Salida de ejemplo:

Aquí está la salida para 3, 2

Mathematica, 51 50 bytes

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

Asume que " mvariables dadas " significa que la primera entrada es una lista de variables.

Si la primera entrada es un entero, 69 bytes

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

Las variables están en la forma $<integer>(por ejemplo $5)

Haskell, 71 58 54 53 bytes

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

Devuelve una lista de cadenas y utiliza el formato de salida "aabbb"para "a^2 b^3".

Ejemplo de uso: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Pruébalo en línea! .

Se gastan muchos bytes para el formato de salida. Una salida más flexible, por ejemplo, pares de (variable, potencia) -> [('a',2),('b',3),('c',1)]para "a^2 b^3 c^1"ahorraría mucho.

Cómo 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)

Con la máxima flexibilidad, es decir, formato de salida como pares (variable, potencia) e incluyendo potencias cero ( "a^0 b^0 c^0") se reduce a

Haskell, 25 bytes:

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

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

Dejar caer a cero todos los poderes cuesta 5 bytes para un total de 30: f n=tail.mapM((<$>[0..n]).(,)).

Jalea , 20 17 bytes

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

Un enlace diádica (función) que acepta una lista de nombres de variables * y el orden máximo (un entero) y devuelve una lista donde cada entrada es una representación completamente expandido de la multiplicación (por ejemplo foo ⁰ bar ³ BOF ² habría ['bar', 'bar', 'bar', 'bof', 'bof'].

* los nombres de las variables pueden ser una cadena de caracteres únicos (las cadenas se convierten en listas de caracteres).

Pruébalo en línea! - el pie de página llama al enlace como una diada y luego separa la lista resultante de listas por avances de línea y cada entrada por espacios para facilitar la lectura.

Nota: incluye el pedido 0 (producto vacío) una cola Ḋ, se puede insertar aquí ...ŒPḊç...para evitar eso.

¿Cómo?

ṗ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

Versión de 13 bytes que solo funcionará para una sola cadena de caracteres únicos (o una lista de caracteres únicos):

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

intentalo

JavaScript (propuesta 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

Requiere un navegador con ambos **y padStartsoporte, así que prueba Firefox 52 o Chrome 57.

Mathematica 100 bytes

¡Seguramente hay una manera más eficiente de lograr esto!

Dos variables para ordenar 4:

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

Bash + sed, 60

Un enfoque diferente y más corto a mi respuesta anterior.

Entrada como parámetros de línea de comandos: mse proporciona como una lista separada por comas de nombres de variables y ncomo un entero:

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

Pruébalo en línea .

Respuesta previa:

Bash + coreutils, 91

Bienvenido al infierno eval-escape-brace. A veces, el script de shell realmente proporciona la herramienta adecuada para el trabajo. Esto no es el caso aquí, pero funciona.

La entrada como parámetros de línea de comandos mse proporciona como una lista separada por comas de nombres de variables y ncomo un entero. La salida se escribe a mano, por ejemplo, en a^2realidad se escribe aa. Esto es aceptable según este comentario .

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

Puede haber formas más cortas de hacer esto.

Pruébalo en línea .

Explicación

• printf -vc {%$[$2-1]s}asigna la variable ca una cadena como { }, donde el número de espacios es el orden n- 1, entonces si n= 1, el resultado es {}, si n= 2, el resultado es { }, etc.
• ${a[$1]}usa mcomo índice para la matriz a, por lo que si mes 3, entonces el resultado esc
• \{{a..${a[$1]}}${c// /,}\\,} es una expansión de llaves múltiples:
  • \{ - un literal {
  • {$1}es a es la expansión de llaves de la lista m, por ejemplo {a,b,c}oa b c
  • ${c// /,}reemplaza los espacios $ccon comas, por ejemplo, {,,}for n= 3, que también es una expansión de llaves que repite efectivamente cada elemento de {a..c} nveces
  • \\\,} - un literal ,}
• Entonces para m= "a, b" y n= 2, esto se expande a{a,} {a,} {b,} {b,}
• El interior printfelimina los espacios para dar {a,}{a,}{b,}{b,}, lo que en sí mismo es una expansión de llaves
• Esto se expande a aabb aab aab aa abb ab ab a abb ab ab a bb b b
• El exterior printfpone cada uno de estos elementos en su propia línea.
• sort -u elimina los duplicados
• The tr -d {}está allí para manejar el caso cuando n= 1. En este caso, la variable cserá la {}que no es una expansión de llaves, sino que se insertan los caracteres literales. El los trquita.

evalsy \escapes se colocan con mucho cuidado para garantizar que todas las expansiones se produzcan en el orden necesario.

Röda , 49 48 46 bytes

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

Pruébalo en línea!

Creo que es correcto No utiliza ningún separador entre una variable y su orden. La versión anterior utilizada! , pero me di cuenta de que no es estrictamente necesario.

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)

Salida:

b
bb
a
ab
abb
aa
aab
aabb

Formato más agradable en 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:]

Salida (mismo 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

Aún mejor en 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:]

Salida:

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

Los últimos 4 bytes ( [1:]) en total son para eliminar el producto vacío.

Estos funcionan tanto en Python 2 como en 3.

C ++ 14, 146 140 bytes

-6 bytes para un formato de salida más simple.

Lambda sin nombre, suponiendo entradas scomo std::stringy 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 y explicación:

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

Salida:

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