사양

주어진 m변수는 순서대로 모든 조합을 만듭니다 n. 예를 들어

두 변수 ( a및 b)를 순서대로 매핑 한 결과는 다음 과 1같습니다.

• ㅏ
• 비
• ab

두 변수 ( a및 b)를 순서대로 매핑 한 결과는 다음 과 2같습니다.

• ㅏ
• ²
• 비
• b ²
• ab
• ² B
• ab ²
• a ² b ²

두 변수 ( a및 b)를 순서대로 매핑 한 결과는 다음 과 3같습니다.

• ㅏ
• ²
• ³
• 비
• b ²
• b ³
• ab
• ² B
• ³ B
• ³ (B) ⁽²⁾
• ab ²
• ab ³
• ² B ³
• a ² b ²
• a ³ b ³

매핑 세 개의 변수 (의 출력 a, b및 c순서)이 1될 것이다 :

• ㅏ
• 비
• 씨
• ab
• 기원전
• ac
• 알파벳

m순서대로 매핑 변수 의 출력 n은 다음과 같습니다.

• 기타

우승 기준

위에서 설명한대로 가능한 모든 조합을 출력하십시오. 순서는 중요하지 않습니다. 코드에서 화면에 인쇄하는 것은 중요하지 않습니다. 중요한 것은 출력에 나타나는 것이 정확하다는 것입니다.

Brachylog , 6 바이트

j₎o⊇ᵘb

변수 목록과 순서를 포함하는 입력을 커플로 취합니다. 출력은 변수 목록으로, 거듭 제곱은 반복되는 변수로 표시됩니다. (예 : "a²b"는 [ "a", "a", "b"])

온라인으로 사용해보십시오!

j₎첫 번째 입력을 두 번째 입력에서 지정한 횟수만큼 자체와 결합합니다. o획득 한 목록 ⊇ᵘ을 정렬 한 다음 해당 정렬 된 목록의 모든 고유 하위 집합 을 찾습니다. 마지막으로, 우리는 첫 번째 요소를 제거합니다 b. 왜냐하면 항상 빈 답이 될 것입니다. 이것은 도전에 의해 고려되지 않습니다.

L ^A T _E X, 354 바이트

이것을보고 라텍스에서해야한다는 것을 알았습니다. 라텍스에서는 방정식이 너무 선명하고 깨끗해 보입니다 ^.

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

설명

여기 \typein 에는 명령 줄에서 입력을받을 수있는 세 가지 주요 요인 , intcalc변수를 사용하여 계산할 수 있는 패키지 및 라텍스 equation환경이 있습니다.

입력을 받으면 루프 \intcalcPow{\b+1}{\a}시간을 시작하고 인쇄하려는 각 결과마다 한 번씩 루프 시간 을 반복 합니다. 각 루프는 equation환경 을 시작 \y하고 현재 문자와 \i현재 실행 횟수를 추적하는 알파벳을 반복 합니다. 경우 \i보다 크거나 같음 \a전혀 아무것도 인쇄되지 않습니다 우리 (사양에 따라 이것은 우리가 이렇게하지 않으면 라텍스 값을 1보다 큰 오버 플로우 것이다 그러나 꼭 필요한 것은). 그런 다음 \y방정식으로 인쇄 하여

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

그 전체 엉망은 단순히 기본 \i자리의 숫자를 취하는 것을 의미 \x합니다 \b+1. 이를 통해 전원이 올바르게 디코딩됩니다.

출력 예 :

다음은 3, 2에 대한 출력입니다.

Mathematica, 51 50 바이트

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

"주어진 m변수"는 첫 번째 입력이 변수 목록임을 의미합니다.

첫 번째 입력이 정수인 경우 69 바이트

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

변수의 형태이다 $<integer>(예 $5)

하스켈, 71 58 54 53 바이트

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

문자열 목록을 반환하고에 대한 출력 형식 "aabbb"을 사용합니다 "a^2 b^3".

사용 예 : 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]. 온라인으로 사용해보십시오! .

출력 형식화에 많은 바이트가 사용됩니다. 더 유연한 출력의 예를 들어 쌍 (변수, 전력) -> [('a',2),('b',3),('c',1)]에 대한 "a^2 b^3 c^1"많은 내용을 저장합니다.

작동 원리

    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)

최대의 유연성, 즉 (가변, 전력) 쌍으로서의 출력 형식 및 0으로 만 제곱 ( "a^0 b^0 c^0")을 포함 하여

하스켈, 25 바이트 :

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

사용 예 : 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)]]

모두 0의 제곱을 제거하는 데 총 30 : 5 바이트가 소요 f n=tail.mapM((<$>[0..n]).(,))됩니다.

젤리 , 20 17 바이트

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

변수 이름 * 및 최대 순서 (정수)의 목록을 허용하고 각 항목이 곱셈의 전체 확장 표현 인 목록 (예 : foo ⁰ bar ³ bof ² 는 )을 리턴하는 2 진 링크 (함수)입니다 ['bar', 'bar', 'bar', 'bof', 'bof'].

* 변수 이름은 고유 한 문자열 일 수 있습니다 (문자열은 문자 목록이 됨).

온라인으로 사용해보십시오! -바닥 글은 링크를 dyad로 호출 한 다음 결과 목록을 줄 바꿈으로 구분하고 각 항목을 쉽게 읽을 수 있도록 공백으로 구분합니다.

참고 : 포함 0 순서 (빈 제품)는 디큐가 Ḋ여기에 삽입 할 수 있습니다 ...ŒPḊç...것을 방지하기 위해.

어떻게?

ṗ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

단일 문자열의 고유 문자 또는 고유 문자 목록에만 작동하는 13 바이트 버전 :

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

시도 해봐

자바 스크립트 (ES 제안), 142 바이트

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

모두 브라우저가 필요 **하고 padStart, 지원을 너무 파이어 폭스 (52) 또는 크롬 57을보십시오.

Mathematica 100 바이트

분명히 이것을 달성하는 더 효율적인 방법이 있습니다!

주문할 두 변수 :

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

배쉬 + sed, 60

이전 답변에 대한 짧고 다른 접근법.

명령 줄 매개 변수로 입력- m쉼표로 구분 된 변수 이름 목록과 n정수로 제공됩니다.

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

온라인으로 사용해보십시오 .

이전 답변 :

배쉬 + coreutils, 91

eval-escape-brace 지옥에 오신 것을 환영합니다. 때때로 쉘 스크립트는 실제로 작업에 적합한 도구를 제공합니다. 여기에는 해당 되지 않지만 작동합니다.

명령 행 매개 변수로 입력- m쉼표로 구분 된 변수 이름 목록과 n정수로 제공됩니다. 출력은 직접 작성됩니다 (예 : a^2실제로 작성) aa. 이 의견에 따라 허용됩니다 .

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

이렇게하는 더 짧은 방법이있을 수 있습니다.

온라인으로 사용해보십시오 .

설명

• printf -vc {%$[$2-1]s}공백 c과 같은 { }순서로 변수 를 문자열에 할당합니다 . 여기서 공백의 개수는 순서 n-1이므로 n= 1이면 결과는 {}이고, n= 2이면 결과는 { }등입니다.
• ${a[$1]}m배열에 대한 인덱스로 사용 a하므로 m3이면 결과는c
• \{{a..${a[$1]}}${c// /,}\\,} 다중 파트 괄호 확장입니다.
  • \{ -리터럴 {
  • {$1}는 목록의 중괄호 확장입니다. m예를 들어 {a,b,c}또는a b c
  • ${c// /,}상기 공간을 대체 $c예 콤마와 {,,}대 n효과적으로 각 소자 반복 브레이스 확대도 인 = 3 {a..c} n배
  • \\\,} -리터럴 ,}
• 따라서 m= "a, b"및 n= 2 인 경우{a,} {a,} {b,} {b,}
• 내부 printf공간이 수득 제거합니다 {a,}{a,}{b,}{b,}자체 중괄호 확장이며
• 이 확장 aabb aab aab aa abb ab ab a abb ab ab a bb b b
• 바깥 쪽 printf은 이러한 각 요소를 자체 줄에 넣습니다.
• sort -u 중복을 제거합니다
• 이 tr -d {}때 경우를 처리하는 n가변이 경우 1. = c것 {}중괄호 확장하지 않으며, 대신 일반 문자가 삽입되어있다. 는 tr그들을 제거합니다.

eval모든 확장이 필요한 순서대로 수행되도록 s 및 \탈출은 매우 신중하게 배치 됩니다.

로다 , 49 48 46 바이트

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

온라인으로 사용해보십시오!

나는 그것이 맞다고 생각합니다. 변수와 순서 사이에 구분 기호를 사용하지 않습니다. 이전 버전은을 사용 !했지만 엄격하게 요구되지는 않는다는 것을 깨달았습니다.

설명 :

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. */
}

파이썬, 112 바이트

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

용법:

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

산출:

b
bb
a
ab
abb
aa
aab
aabb

115 바이트의 더 좋은 형식 :

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

출력 (동일 사용법) :

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 바이트가 더 좋습니다 .

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

산출:

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

마지막 4 바이트 ( [1:])는 빈 제품을 제거하기위한 것입니다.

이것들은 파이썬 2와 3에서 작동합니다.

C ++ 14, 146140 바이트

더 간단한 출력 형식의 경우 -6 바이트

입력 가정 명명 람다 s같은 std::string과 o같이 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<<" ";}}

사용법과 설명 :

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

산출:

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