SPÉCIFICATION

Étant donné les mvariables, créez chaque combinaison dans l'ordre n. Par exemple,

Le résultat du mappage de deux variables ( aet b) à l'ordre 1serait:

• une
• b
• un B

Le résultat du mappage de deux variables ( aet b) à l'ordre 2serait:

• une
• un ²
• b
• b ²
• un B
• a ² b
• ab ²
• a ² b ²

Le résultat du mappage de deux variables ( aet b) à l'ordre 3serait:

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

La sortie de la cartographie trois variables ( a, b, et c) à l' ordre 1serait:

• une
• b
• c
• un B
• avant JC
• ac
• abc

Le résultat du mappage des mvariables à l'ordre nserait:

• etc.

CRITÈRES GAGNANTS

Sortez toutes les combinaisons possibles comme indiqué ci-dessus. L'ordre n'a pas d'importance. Peu importe où dans votre code vous imprimez à l'écran. Tout ce qui compte, c'est que ce qui apparaît dans votre sortie soit correct.

Brachylog , 6 octets

j₎o⊇ᵘb

Prend l'entrée en couple, contenant la liste des variables et l'ordre. La sortie est une liste de listes de variables, où les puissances sont représentées par des variables répétées. (par exemple, "a²b" est ["a", "a", "b"])

Essayez-le en ligne!

j₎joint la première entrée avec elle-même autant de fois que indiqué par la deuxième entrée. oordonne la liste obtenue, puis ⊇ᵘtrouve tous les sous-ensembles uniques de cette liste ordonnée. Enfin, nous supprimons le premier élément avec b, car ce sera toujours la réponse vide, qui n'est pas envisagée par le défi.

L ^A T _E X, 354 octets

Quand j'ai vu cela, je savais que cela devait être fait en latex. Les équations ont l'air si nettes et propres en Latex et je ne supporte pas d'utiliser ^de la puissance.

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

Explication

Il y a trois forces principales à l'œuvre ici, \typein ce qui nous permet de prendre des entrées à partir de la ligne de commande, le intcalcpackage qui nous permet de faire des calculs avec nos variables et l' equationenvironnement Latex .

Une fois que nous avons pris en entrée, nous commençons une boucle, nous bouclons \intcalcPow{\b+1}{\a}fois, une fois pour chaque résultat que nous voulons imprimer. À chaque boucle, nous commençons un equationenvironnement et parcourons l'alphabet en gardant une trace de \yla lettre actuelle et \idu nombre actuel de tirages. Si \iest supérieur ou égal à, \anous n'imprimons rien du tout (selon les spécifications, cela n'est pas strictement nécessaire, mais Latex débordera pour les valeurs supérieures à 1 si nous ne le faisons pas). Nous imprimons ensuite \yà notre équation et l'élever à la puissance de

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

Tout ce gâchis signifie simplement prendre le \itroisième chiffre de la \xbase \b+1. Cela garantit que les pouvoirs sont décodés correctement.

Exemple de sortie:

Voici la sortie pour 3, 2

Mathematica, 51 50 octets

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

Suppose que " mvariables données " signifie que la première entrée est une liste de variables.

Si la première entrée est un entier, 69 octets

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

Les variables sont sous la forme $<integer>(par exemple $5)

Haskell, 71 58 54 53 octets

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

Renvoie une liste de chaînes et utilise le format de sortie "aabbb"pour "a^2 b^3".

Exemple d'utilisation: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Essayez-le en ligne! .

De nombreux octets sont dépensés pour le formatage de sortie. Une sortie plus flexible, par exemple des paires de (variable, puissance) -> [('a',2),('b',3),('c',1)]pour "a^2 b^3 c^1"économiserait beaucoup.

Comment ça fonctionne

    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)

Avec une flexibilité maximale, c'est-à-dire un format de sortie sous forme de paires (variables, de puissance) et incluant des puissances entièrement nulles ( "a^0 b^0 c^0")

Haskell, 25 octets:

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

Exemple d'utilisation 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)]]

Laissant tomber tous les pouvoirs zéro coûte 5 octets pour un total de 30: f n=tail.mapM((<$>[0..n]).(,)).

Gelée , 20 17 octets

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

Un lien dyadique (fonction) qui accepte une liste de noms de variables * et l'ordre maximal (un entier) et renvoie une liste où chaque entrée est une représentation entièrement développée de la multiplication (par exemple, foo ⁰ bar ³ bof ^{2 le} serait ['bar', 'bar', 'bar', 'bof', 'bof'].

* les noms de variables peuvent être une chaîne de caractères uniques (les chaînes deviennent des listes de caractères).

Essayez-le en ligne! - le pied de page appelle le lien comme une dyade puis sépare la liste résultante des listes par des sauts de ligne et chaque entrée par des espaces pour faciliter la lecture.

Remarque: comprend la commande 0 (produit vide) une file d'attente,, Ḋpeut être inséré ici ...ŒPḊç...pour éviter cela.

Comment?

ṗ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

Version de 13 octets qui ne fonctionnera que pour une seule chaîne de caractères uniques (ou une liste de caractères uniques):

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

essayez-le

JavaScript (proposition ES), 142 octets

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

Nécessite un navigateur avec **et padStartsupport, essayez donc Firefox 52 ou Chrome 57.

Mathematica 100 octets

Il y a sûrement un moyen plus efficace d'accomplir cela!

Deux variables à commander 4:

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

Bash + sed, 60

Une approche différente et plus courte de ma réponse précédente.

L'entrée en tant que paramètres de ligne de commande - mest donnée sous la forme d'une liste de noms de variables séparés par des virgules et nsous forme d'entier:

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

Essayez-le en ligne .

Réponse précédente:

Bash + coreutils, 91

Bienvenue dans l'enfer eval-escape-brace. Parfois, shell-script donne vraiment juste le bon outil pour le travail. Ce n'est pas le cas ici, mais ça marche.

Entrée en tant que paramètres de ligne de commande - mest donnée sous la forme d'une liste de noms de variables séparés par des virgules et nsous forme d'entier. La sortie est écrite à la main - par exemple, elle a^2est réellement écrite aa. C'est acceptable selon ce commentaire .

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

Il peut y avoir des moyens plus courts de le faire.

Essayez-le en ligne .

Explication

• printf -vc {%$[$2-1]s}assigne la variable cà une chaîne comme { }, où le nombre d'espaces est l'ordre n- 1, donc si n= 1, le résultat est {}, si n= 2, le résultat est { }, etc.
• ${a[$1]}utilise mcomme index du tableau a, donc si mest 3, alors le résultat estc
• \{{a..${a[$1]}}${c// /,}\\,} est une extension de renfort en plusieurs parties:
  • \{ - un littéral {
  • {$1}est un est l'extension d'accolade de la liste m, par exemple {a,b,c}oua b c
  • ${c// /,}remplace les espaces $cpar des virgules, par exemple {,,}pour n= 3, qui est également une expansion d'accolade qui répète efficacement chaque élément de {a..c} ntemps
  • \\\,} - un littéral ,}
• Donc, pour m= "a, b" et n= 2, cela se développe pour{a,} {a,} {b,} {b,}
• L'intérieur printfsupprime les espaces à donner {a,}{a,}{b,}{b,}, ce qui est lui-même une expansion de l'orthèse
• Cela s'étend à aabb aab aab aa abb ab ab a abb ab ab a bb b b
• L'extérieur printfmet chacun de ces éléments sur sa propre ligne
• sort -u supprime les doublons
• Le tr -d {}est là pour gérer le cas lorsque n= 1. Dans ce cas, la variable csera {}qui n'est pas une expansion d'accolade, mais à la place les caractères littéraux sont insérés. Le les trsupprime.

evals et les \évasions sont placées très soigneusement pour garantir que toutes les expansions se produisent dans l'ordre nécessaire.

Röda , 49 48 46 octets

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

Essayez-le en ligne!

Je pense que c'est correct. Il n'utilise aucun séparateur entre une variable et son ordre. La version précédente était utilisée !, mais j'ai réalisé qu'elle n'était pas strictement requise.

Expliqué:

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 octets

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

Usage:

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

Production:

b
bb
a
ab
abb
aa
aab
aabb

Format plus agréable en 115 octets :

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

Sortie (même usage):

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

Encore plus agréable en 125 octets :

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

Production:

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

Les 4 derniers octets ( [1:]) au total sont destinés à supprimer le produit vide.

Ils fonctionnent à la fois en Python 2 et 3.

C ++ 14, 146 140 octets

-6 octets pour un format de sortie plus simple.

Lambda sans nom, en supposant l'entrée scomme std::stringet ocomme 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<<" ";}}

Utilisation et explication:

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

Production:

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