Cree todas las combinaciones de grupos variables hasta el orden n

9

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

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

  • una
  • un 2
  • un 3
  • si
  • 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

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.

usuario1873073
fuente
1
¿Cómo estamos destinados a la salida? ¿Deberíamos usar ^?
Ad Hoc Garf Hunter
1
¿Podemos elevar las cosas a cero o uno (por ejemplo, a ^ 1)
Ad Hoc Garf Hunter
1
¿Qué pasa si mes mayor que 26? ¿Tenemos que apoyar valores tan altos?
Ad Hoc Garf Hunter
1
@ user1873073 el problema no es el orden máximo sino el número máximo de nombres de variables.
Martin Ender
1
¿Cómo se darán las variables? Muchos de los comentarios asumen que la entrada será una serie de variables, pero el texto given m variablesimplica que se dará una lista de variables. Si solo se da el número de variables y 0,1,2,3..27,28,29 elevado a las potencias ^ 0, ^ 1, ^ 2, etc. es un resultado aceptable (como infiero de su último comentario) Cosas más fáciles.
Level River St

Respuestas:

4

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.

León
fuente
14

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

Salida

Ad Hoc Garf Hunter
fuente
1
Tenga en cuenta que su salida incluye a ^ 0 b ^ 0 c ^ 0 = 1, mientras que los casos de prueba no. Dicho esto, creo que tienes razón y los casos de prueba están mal :)
Greg Martin
@GregMartin Sí, matemáticamente hablando, el conjunto vacío debe estar en en.wikipedia.org/wiki/Power_set
Karl Napf
@KarlNapf Una expresión igual a 1 no es el conjunto vacío. Tampoco es una tupla que contiene 3 ceros.
jpmc26
@ jpmc26 Sí, no en la especificación de este golf. Es como el conjunto de poder de (para n = 3) {a, a, a, b, b, b, c, c, c} sin el conjunto vacío
Karl Napf
@KarlNapf Matemáticamente no es lo mismo. No hay un conjunto vacío involucrado aquí. El desafío consiste en generar un conjunto de tuplas de longitud especificada.
jpmc26
5

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)

JungHwan Min
fuente
¡TIL PowerRangees una cosa! Estoy de acuerdo con la interpretación de su primera presentación por cierto
Greg Martin
4

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

nimi
fuente
Para su segundo código, [('a',0),('b',0)]no debería estar en la salida ...
JungHwan Min
@JungHwanMin: mi solución de 25 bytes no pretende ser una respuesta. Es una nota para mostrar que la parte combinatoria del desafío necesita el menor número de bytes, al menos en Haskell. La caída a^0 b^0cuesta 5 bytes. Agregaré otra nota.
nimi
4

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

Jonathan Allan
fuente
3

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.

Neil
fuente
3

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

imagen

DavidC
fuente
3

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.

Trauma digital
fuente
3

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. */
}
fergusq
fuente
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:]

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.

Alex Hall
fuente
0

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