양의 정수 $n$ 주어지면 $n$ 객체의 모든 배열이 생성 됩니다.

세부

• 변위는 고정 점이없는 순열입니다. (이는 모든 배치 번호에서 $i$ 가 $i$ 번째 항목에 있을 수 없음을 의미합니다 ).
• 출력은 숫자의 배열 $(1,2,\ldots,n)$ (또는 대안 적으로 $(0,1,2,\ldots,n-1)$ )로 구성되어야합니다.
• 다른 방법으로 항상 $(n,n-1,\ldots,1)$ (또는 각각 $(n-1,n-2,\ldots,1,0)$ 배열을 인쇄 할 수 있지만 반드시 지정해야합니다.
• 출력은 결정 론적 이어야합니다. 즉, 주어진 $n$ 을 입력으로 하여 프로그램을 호출 할 때마다 출력이 같아야합니다 (배열 순서가 동일하게 유지되어야 함을 포함하여). 매번 유한 한 시간 (확률 1로 충분하지 않음).
• n ⩾ 2 라고 가정 할 수 있습니다$n \geqslant 2$
• 주어진 대해 모든 배열을 생성하거나 대안 으로 인덱스 역할을하는 다른 정수 를 가져 와서 번째 배열을 선택한 순서대로 인쇄 할 수 있습니다 .$n$$k$$k$

예

배치 순서가 여기에 나열된 순서와 같을 필요는 없습니다.

n=2: (2,1)
n=3: (2,3,1),(3,1,2)
n=4: (2,1,4,3),(2,3,4,1),(2,4,1,3), (3,1,4,2),(3,4,1,2),(3,4,2,1), (4,1,2,3),(4,3,1,2),(4,3,2,1)

OEIS A000166 은 배치 수를 계산합니다.

젤리 , 6 바이트

Œ!=ÐṂR

정수 목록을 생성하는 양의 정수를 허용하는 모나드 링크.

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

어떻게?

Œ!=ÐṂR - Link: integer, n
Œ!     - all permutations of (implicit range of [1..n])
     R - range of [1..n]
   ÐṂ  - filter keep those which are minimal by:
  =    -   equals? (vectorises)
       -   ... i.e. keep only those permutations that evaluate as [0,0,0,...,0]

Brachylog , 9 바이트

⟦kpiᶠ≠ᵐhᵐ

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

이것은 [0, …, n-1]주어진 하나의 배열을 출력하는 생성기입니다 n.

우리가 그것을 포장하는 경우 ᶠ - findallmetapredicate, 우리는 발전기에 의해 교란의 가능한 모든 세대를 얻을.

설명

⟦           The range [0, …, Input]
 k          Remove the last element
  p         Take a permutation of the range [0, …, Input - 1]
   iᶠ       Take all pair of Element-index: [[Elem0, 0],…,[ElemN-1, N-1]]
     ≠ᵐ     Each pair must contain different values
       hᵐ   The output is the head of each pair

자바 스크립트 (V8) , 85 바이트

0부터 시작하는 모든 범위를 인쇄하는 재귀 함수.

f=(n,p=[],i,k=n)=>k--?f(n,p,i,k,k^i&&!p.includes(k)&&f(n,[...p,k],-~i)):i^n||print(p)

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

댓글

f = (                   // f is a recursive function taking:
  n,                    //   n   = input
  p = [],               //   p[] = current permutation
  i,                    //   i   = current position in the permutation
  k = n                 //   k   = next value to try
) =>                    //         (a decrementing counter initialized to n)
  k-- ?                 // decrement k; if it was not equal to 0:
    f(                  //   do a recursive call:
      n, p, i, k,       //     leave all parameters unchanged
      k ^ i &&          //     if k is not equal to the position
      !p.includes(k) && //     and k does not yet appear in p[]:
        f(              //       do another recursive call:
          n,            //         leave n unchanged
          [...p, k],    //         append k to p
          -~i           //         increment i
                        //         implicitly restart with k = n
        )               //       end of inner recursive call
    )                   //   end of outer recursive call
  :                     // else:
    i ^ n ||            //   if the derangement is complete:
      print(p)          //     print it

루비 , 55 바이트

->n{[*0...n].permutation.select{|x|x.all?{|i|i!=x[i]}}}

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

모든 0 기반 정렬 생성

05AB1E , 9 바이트

Lœʒāø€Ë_P

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

설명

L           # push [1 ... input]
 œ          # get all permutations of that list
  ʒ         # filter, keep only lists that satisfy
   āø       # elements zipped with their 1-based index
     €Ë_P   # are all not equal

Wolfram Language (Mathematica) , 55 바이트

Select[Permutations[s=Range@#],FreeQ[Ordering@#-s,0]&]&

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

Japt , 8 바이트

0 기반

o á fÈe¦

시험해보십시오 (Footer는 테스트 케이스와 쉽게 비교할 수 있도록 모든 요소를 ​​증가시킵니다)

o á fÈe¦     :Implicit input of integer
o            :Range [0,input)
  á          :Permutations
    f        :Filter
     È       :By passing each through this function
      e      :  Every element of the permutation
       ¦     :  Does not equal its 0-based index

파이썬 2 , 102 바이트

lambda n:[p for p in permutations(range(n))if all(i-j for i,j in enumerate(p))]
from itertools import*

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

0 기반 인덱싱, 튜플 목록.

비 itertools기반 솔루션 :

파이썬 2 , 107 바이트

n=input()
for i in range(n**n):
 t=[];c=1
 for j in range(n):c*=j!=i%n not in t;t+=[i%n];i/=n
 if c:print t

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

0 기반 색인, 행 목록, 전체 프로그램.

참고 :이 솔루션은 itertools라이브러리를 가져 오지 않더라도 가져 오는 다른 솔루션 보다 훨씬 길지 않습니다. 여기서 대부분의 대량은 순열을 작성하기 때문입니다. 정렬 검사는 실제로 약 7 추가 바이트입니다! 그 이유는 각 순열의 건물의 일부로 검사가 즉시 수행되기 때문입니다. 이것은 itertools.permutations함수가 반환 한 각 순열 이 실제로 변형인지 확인 해야하는 다른 솔루션에는 해당되지 않으며 물론 매핑 자체에 많은 바이트가 필요합니다.

MATL , 11 바이트

:tY@tb-!AY)

이것은 모든 순서를 사전 식 순서로 생성합니다.

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

예를 들어 설명

입력을 고려하십시오 3.

:     % Implicit input n. Range [1 2 ... n]
      % STACK: [1 2 3]
t     % Duplicate
      % STACK: [1 2 3], [1 2 3]
Y@    % All permutations, in lexicographical order, as rows of a matrix
      % STACK: [1 2 3], [1 2 3; 1 3 2; ··· ; 3 2 1]
t     % Duplicate
      % STACK: [1 2 3], [1 2 3; 1 3 2; ··· ; 3 2 1], [1 2 3; 1 3 2; ··· ; 3 2 1]
b     % Bubble up: moves third-topmost element in stack to the top
      % STACK: [1 2 3; 1 3 2; ··· ; 3 2 1], [1 2 3; 1 3 2; ··· ; 3 1 2; 3 2 1], [1 2 3]
-     % Subtract, element-wise with broadcast
      % STACK: [1 2 3; 1 3 2; ··· ; 3 2 1], [0 0 0; 0 1 -1; ··· ; 2 -1 -1; 2 0 -2]
!A    % True for rows containining only nonzero elements
      % STACK: [1 2 3; 1 3 2; ··· ; 3 1 2; 3 2 1], [false false ··· true false]
Y)    % Use logical mask as a row index. Implicit display
      % STACK: [2 3 1; 3 1 2]

펄 5 -MList::Util=none -n , 100 89 바이트

$"=',';@b=1..$_;map{%k=$q=0;say if none{++$q==$_||$k{$_}++}/\d+/g}glob join$",("{@b}")x@b

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

하스켈 , 58 바이트

f n|r<-[1..n]=[l|l<-mapM(\i->filter(/=i)r)r,all(`elem`l)r]

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

60 바이트

f n|r<-[1..n]=foldr(\i m->[x:l|l<-m,x<-r,all(/=x)$i:l])[[]]r

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

Gaia , 10 바이트

┅f⟨:ċ=†ỵ⟩⁇

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

┅		| push [1 2 ... n]
 f		| push permutations
  ⟨	⟩⁇	| filter where result of following is truthy
   :ċ		| dup, push [1 2 ... n]
     =†ỵ	| there is no fixed point

J , 26 바이트

i.(]#~0~:*/@(-|:))i.@!A.i.

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

i. (] #~ 0 ~: */@(- |:)) i.@! A. i.
i. (                   )            NB. 0..input
   (                   ) i.@! A. i. NB. x A. y returns the
                                    NB. x-th perm of y
                                    NB. i.@! returns 
                                    NB. 0..input!. Combined
                                    NB. it produces all perms
                                    NB. of y
    ] #~ 0 ~: */@(- |:)             NB. those 2 are passed as
                                    NB. left and right args
                                    NB. to this
    ] #~                            NB. filter the right arg ]
                                    NB. (all perms) by:
         0 ~:                       NB. where 0 is not equal to...
              */@                   NB. the product of the 
                                    NB. rows of...
                 (- |:)             NB. the left arg minus
                                    NB. the transpose of
                                    NB. the right arg, which
                                    NB. will only contain 0
                                    NB. for perms that have
                                    NB. a fixed point

R , 81 80 바이트

function(n)unique(Filter(function(x)all(1:n%in%x&1:n-x),combn(rep(1:n,n),n,,F)))

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

list$n^2\choose n$n[1..n]n1:n%in%x1:n-x

R + gtools , 62 바이트

function(n,y=gtools::permutations(n,n))y[!colSums(t(y)==1:n),]

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

훨씬 더 효율적이며 matrix각 행이 배치 된 위치를 반환합니다 .

Python 3.8 (시험판) , 96 바이트

lambda n:(p for i in range(n**n)if len({*(p:=[j for k in range(n)for j in{i//n**k%n}-{k}])})==n)

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

C ++ (GCC) , 207 (196) 바이트

천장 고양이 -5 바이트 Roman Odaisky -6 바이트

#include<regex>
#define v std::vector
auto p(int n){v<v<int>>r;v<int>m(n);int i=n;for(;m[i]=--i;);w:for(;std::next_permutation(&m[0],&m[n]);r.push_back(m))for(i=n;i--;)if(m[i]==i)goto w;return r;}

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

C ++ (gcc) , 133 바이트

나는 이것이 다른 제출과는 별도로 별도의 답변을 얻을만한 가치가 있다고 생각합니다. 마지막으로 index[array]인사이드 아웃 구문을 사용하십시오!

#include<regex>
[](int n,auto&r){int i=n;for(;i[*r]=--i;);for(;std::next_permutation(*r,*r+n);)for(i=n;i--?(r[1][i]=i[*r])-i:!++r;);}

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

하스켈, 76 바이트

n&x=[x++[i]|i<-[1..n],notElem i x,i/=length x+1]
d n=iterate(>>=(n&))[[]]!!n

파이썬 2 , 82 바이트

f=lambda n,i=0:i/n*[[]]or[[x]+l for l in f(n,i+1)for x in range(n)if~-(x in[i]+l)]

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

프로그램으로 88 바이트 :

M=[],
r=range(input())
for i in r:M=[l+[x]for l in M for x in r if~-(x in[i]+l)]
print M

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

itertools를 사용한 93 바이트 :

from itertools import*
r=range(input())
print[p for p in permutations(r)if all(map(cmp,p,r))]

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

펄 6 , 49 37 바이트

편집 : Phil H와 앞뒤로 37 바이트로 줄였습니다.

(^*).permutations.grep:{all @_ Z-^@_}

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

Whatever처음에 를 사용하면 대괄호를 피할 수 있습니다 (2 문자 절약). 다음은 사용 Z에 metaoperator -위해 각 순열의 요소 (예 : 2,3,1) 및 감산 0,1,2 걸린다한다. 이들 중 하나가 0 (거짓)이면 모든 접합이 실패합니다.

원래 솔루션은 ( 온라인으로 사용해보십시오! )

{permutations($_).grep:{none (for $_ {$++==$_})}}

숯 , 44 28 바이트

44를 넘어 여전히 여전히 44입니다

ＮθＩΦＥＸθθＥθ﹪÷ιＸθλθ⬤ι‹⁼μλ⁼¹№ιλ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. @EricTheOutgolfer의 itertools가 아닌 답변에 느슨하게 기초합니다. 설명:

Ｎθ                              Input `n`
     Ｘθθ                        `n` raised to power `n`
    Ｅ                           Mapped over implicit range
         θ                      `n`
        Ｅ                       Mapped over implicit range
            ι                   Outer loop index
           ÷                    Integer divided by
             Ｘθ                 `n` raised to power
               λ                Inner loop index
          ﹪     θ               Modulo `n`
   Φ                            Filtered where
                  ι             Current base conversion result
                 ⬤              All digits satisfy
                         №ιλ    Count of that digit
                       ⁼¹       Equals literal 1
                   ‹            And not
                    ⁼μλ         Digit equals its position
  Ｉ                             Cast to string
                                Implicitly print

C (gcc) , 187180 바이트

• ceilingcat 덕분에 7 바이트를 절약했습니다 .

*D,E;r(a,n,g,e){e=g=0;if(!a--){for(;e|=D[g]==g,g<E;g++)for(n=g;n--;)e|=D[n]==D[g];for(g*=e;g<E;)printf("%d ",D[g++]);e||puts("");}for(;g<E;r(a))D[a]=g++;}y(_){int M[E=_];D=M;r(_);}

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

Pyth , 12 바이트

f*F.e-bkT.PU

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

           UQ # [implicit Q=input] range(0,Q)
         .P  Q# [implicit Q=input] all permutations of length Q
f             # filter that on lambda T:
   .e   T     #   enumerated map over T: lambda b (=element), k (=index):
     -bk      #     b-k
 *F           # multiply all together

필터는 다음과 같이 작동합니다. 요소가 원래 위치에 있으면 (요소 색인)은 0이되고 전체 제품은 0이되어 거짓이됩니다.