ŞARTNAME

Verilen mdeğişkenler, her kombinasyonu siparişe göre oluşturun n. Örneğin,

İki değişkeni ( ave b) sırayla eşleme çıktısı 1şöyle olur:

• bir
• b
• ab

İki değişkeni ( ave b) sırayla eşleme çıktısı 2şöyle olur:

• bir
• a ²
• b
• b ²
• ab
• a ² b
• ab ²
• a ² b ²

İki değişkeni ( ave b) sırayla eşleme çıktısı 3şöyle olur:

• bir
• a ²
• a ³
• b
• b ²
• b ³
• ab
• a ² b
• a ³ b
• a ³ b ²
• ab ²
• ab ³
• a ² b ³
• a ² b ²
• a ³ b ³

Haritalama üç değişken (çıkış a, bve cdüzene) 1olacaktır:

• bir
• b
• c
• ab
• M.Ö
• AC
• ABC

Eşleme mdeğişkenlerinin siparişe çıkışı nşöyle olur:

• vb.

KAZANAN KRİTERLER

Yukarıda belirtilen tüm olası kombinasyonları çıktılayın. Düzen önemli değil. Kodunuzda ekranın neresine yazdırdığınız önemli değildir. Önemli olan tek şey çıktınızda görünen şeyin doğru olmasıdır.

Brachylog , 6 bayt

j₎o⊇ᵘb

Girdiyi değişkenler listesini ve sırasını içeren bir çift olarak alır. Çıktı, güçlerin tekrarlanan değişkenlerle gösterildiği değişken listelerinin bir listesidir. (örneğin "a²b" ["a", "a", "b"])

Çevrimiçi deneyin!

j₎birinci girdiye, ikinci girdinin belirttiği kadar kez katılır. oalınan listeyi sıralar ve sipariş edilen listenin ⊇ᵘtüm benzersiz alt kümelerini bulur. Son olarak, ilk öğeyi kaldırıyoruz b, çünkü bu her zaman meydan okuma tarafından tasarlanmayan boş cevap olacaktır.

L ^A T _E X, 354 bayt

Bunu görünce Lateks'de yapılması gerektiğini biliyordum. Denklemler Lateks'te çok net ve temiz görünüyor ve ^güç için dayanamıyorum .

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

açıklama

Burada işleyen üç ana güç var: \typein Komut satırından girdi intcalcalmamıza izin veren şey, değişkenlerimizle hesaplamalar yapmamıza izin veren paket ve Lateks equationortamı.

Girdiye girdikten sonra \intcalcPow{\b+1}{\a}, döngü sürelerine başlıyoruz , yazdırmak istediğimiz her sonuç için bir kez. Her döngü bir equationortama başlar \yve geçerli harf ve \igeçerli koşu sayısını takip eden alfabe ile döngü yaparız . Daha \ibüyük veya ona eşitse, \ahiçbir şey yazdırmıyoruz (özelliklere göre bu kesinlikle gerekli değildir, ancak bunu yapmazsak Lateks 1'den büyük değerler için taşacaktır). Daha sonra \ydenklemimize yazdırır ve

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

Bütün bu karmaşa sadece üssün \ith basamağını almak anlamına gelir . Bu, güçlerin doğru şekilde çözülmesini sağlar.\x\b+1

Örnek çıktı:

İşte 3, 2 için çıktı

Mathematica, 51 50 bayt

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

"Verilen mdeğişkenlerin" ilk girdinin değişkenlerin bir listesi olduğu varsayılır .

İlk giriş bir tamsayı ise 69 bayt

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

Değişkenler biçimindedir $<integer>(örneğin $5)

Haskell, 71 58 54 53 bayt

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

Dizeleri listesini döndürür ve çıkış biçimi kullanır "aabbb"için "a^2 b^3".

Kullanım örneği: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. Çevrimiçi deneyin! .

Çıktı biçimlendirmesi için birçok bayt harcanır. Daha esnek bir çıkış, örneğin çiftleri (değişken güç) -> [('a',2),('b',3),('c',1)]için "a^2 b^3 c^1"bir tasarrufu olur.

Nasıl çalışır

    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)

Maksimum esneklikle, yani çıkış biçimi (değişken, güç) çiftleri olarak ve tamamen sıfır güçler ( "a^0 b^0 c^0") dahil olmak üzere kaynar

Haskell, 25 bayt:

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

Kullanım örneği 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)]]

Hepsi sıfır güçlerini Damlama 30 olmak üzere toplam 5 bayt maliyeti: f n=tail.mapM((<$>[0..n]).(,)).

Jöle , 20 17 bayt

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

Değişken adları * ve maksimum sıra (tamsayı) listesini kabul eden ve her girişin çarpmanın tamamen genişletilmiş bir temsili olduğu bir liste döndüren bir ikili bağlantı (işlev) (örneğin foo ⁰ bar ³ bof ² olur) ['bar', 'bar', 'bar', 'bof', 'bof'].

* değişken adları benzersiz karakterlerden oluşan bir dize olabilir (dizeler karakter listelerine dönüşür).

Çevrimiçi deneyin! - altbilgi bağlantıyı bir dyad olarak çağırır ve sonuçta elde edilen liste listesini satır beslemelerine ve her girişi okuma kolaylığı için boşluklara ayırır.

Not: kapsar 0 sırası (boş ürün) dequeue, Ḋburada sokulabilir ...ŒPḊç...önlemek için.

Nasıl?

ṗ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

Yalnızca tek bir benzersiz karakter dizisi (veya benzersiz karakterlerin bir listesi) için çalışacak 13 baytlık sürüm:

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

dene

JavaScript (ES teklifi), 142 bayt

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

Her ikisi **ve padStartdesteği olan bir tarayıcı gerektirir , bu nedenle Firefox 52 veya Chrome 57'yi deneyin.

Mathematica 100 bayt

Elbette bunu başarmanın daha etkili bir yolu var!

Sipariş 4 için iki değişken:

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

Bash + sed, 60

Önceki cevabım için farklı, daha kısa bir yaklaşım.

Komut satırı parametreleri olarak giriş - mdeğişken adlarının virgülle ayrılmış bir listesi ve nbir tamsayı olarak verilir:

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

Çevrimiçi deneyin .

Önceki Cevap:

Bash + coreutils, 91

Eval-escape-brace cehenneme hoş geldiniz. Bazen shell-script gerçekten iş için doğru aracı verir. Bu değil durum burada, ama işe yarıyor.

Komut satırı parametreleri olarak giriş - mdeğişken adlarının virgülle ayrılmış bir listesi ve nbir tamsayı olarak verilir. Çıktı uzun el ile yazılır - örneğin a^2, aslında yazılır aa. Bu yoruma göre kabul edilebilir .

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

Bunu yapmanın daha kısa yolları olabilir.

Çevrimiçi deneyin .

açıklama

• printf -vc {%$[$2-1]s}atar değişken cbir dizeye { }boşlukların sayısı sırası, n- bu durumda, 1 n= 1, sonuç {}, eğer n= 2, sonuç { }, vs.
• ${a[$1]}mdiziye bir dizin olarak kullanır a, bu nedenle m3 ise , sonuçc
• \{{a..${a[$1]}}${c// /,}\\,} çok parçalı küme genişletmesi:
  • \{ - gerçek {
  • {$1}Bir liste ayracı genişleme olduğunu m, örneğin {a,b,c}veyaa b c
  • ${c// /,}boşluk yerini $cörneğin virgül ile {,,}için netkili bir her öğe tekrar bir bağ genişleme aynı zamanda, hangi = 3 {a..c} nkez
  • \\\,} - gerçek ,}
• Yani m= "a, b" ve n= 2 için, bu{a,} {a,} {b,} {b,}
• İç kısım printf, verilecek boşlukları kaldırır {a,}{a,}{b,}{b,}, ki bu da bir küme ayracı genişlemesi
• Bu, aabb aab aab aa abb ab ab a abb ab ab a bb b b
• Dış printfbu elemanların her birini kendi hattına koyar
• sort -u kopyaları kaldırır
• tr -d {}Ne zaman dava orada işlemek için olan ndeğişken Bu durumda 1. = colacak {}bir bağ genişleme değil, ama bunun yerine değişmez karakter eklenir hangi. trOnları kaldırır.

evalTüm genişlemelerin gerekli sırada gerçekleşmesini sağlamak için s ve \çıkışlar çok dikkatli bir şekilde yerleştirilir .

Röda , 49 48 46 bayt

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

Çevrimiçi deneyin!

Bence doğru. Değişken ve sırası arasında herhangi bir ayırıcı kullanmaz. Önceki sürüm kullanıldı !, ancak kesinlikle gerekli olmadığını fark ettim.

Açıklaması:

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 bayt

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

Kullanımı:

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

Çıktı:

b
bb
a
ab
abb
aa
aab
aabb

115 baytlık daha güzel biçim :

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

Çıktı (aynı kullanım):

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

125 baytta daha da güzel :

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

Çıktı:

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

Son 4 bayt ( [1:]) boş ürünü çıkarmak içindir.

Bunlar hem Python 2 hem de 3'te çalışır.

C ++ 14, 146140 bayt

Daha basit çıktı formatı için -6 bayt.

Giriş varsayılarak Adsız lambda sgibi std::stringve oşekilde 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<<" ";}}

Kullanım ve açıklama:

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

Çıktı:

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