Cho một số nguyên dương tạo ra tất cả các biến số của đối tượng.$n$$n$

Chi tiết

• Một sự loạn trí là một hoán vị không có điểm cố định. (Điều này có nghĩa là trong mọi số lần loạn không thể có trong mục thứ ).$i$$i$
• Đầu ra phải bao gồm các biến số của các số (hoặc cách khác ).$(1,2,\ldots,n)$$(0,1,2,\ldots,n-1)$
• Thay vào đó, bạn luôn có thể in các dẫn xuất của (hoặc tương ứng) nhưng bạn phải chỉ định như vậy.$(n,n-1,\ldots,1)$$(n-1,n-2,\ldots,1,0)$
• Đầu ra phải có tính xác định, đó là bất cứ khi nào chương trình được gọi với một số cho là đầu vào, thì đầu ra phải giống nhau (bao gồm thứ tự của các biến đổi phải giữ nguyên) và đầu ra hoàn chỉnh phải được thực hiện trong một lượng thời gian hữu hạn mỗi lần (không đủ để làm như vậy với xác suất 1).$n$
• Bạn có thể giả sử rằng$n \geqslant 2$
• Đối với một số $n$ cho, bạn có thể tạo tất cả các biến động hoặc thay vào đó, bạn có thể lấy một số nguyên $k$ khác dùng làm chỉ mục và in ra biến dạng thứ $k$ (theo thứ tự bạn đã chọn).

Ví dụ

Lưu ý rằng thứ tự của các biến động không nhất thiết phải giống như được liệt kê ở đây:

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 đếm số lần loạn.

Thạch , 6 byte

Œ!=ÐṂR

Một liên kết đơn nguyên chấp nhận một số nguyên dương mang lại một danh sách các danh sách các số nguyên.

Hãy thử trực tuyến!

Làm sao?

Œ!=ÐṂ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 byte

⟦kpiᶠ≠ᵐhᵐ

Hãy thử trực tuyến!

Đây là một máy phát điện tạo ra một sự biến dạng [0, …, n-1]nhất định n.

Nếu chúng ta bọc nó trong một ᶠ - findallphép ẩn dụ, chúng ta sẽ có được tất cả các thế hệ gây nhiễu bởi máy phát điện.

Giải trình

⟦           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

JavaScript (V8) , 85 byte

Một hàm đệ quy in tất cả các biến động dựa trên 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)

Hãy thử trực tuyến!

Đã bình luận

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

Ruby , 55 byte

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

Hãy thử trực tuyến!

Tạo tất cả các biến động dựa trên 0

05AB1E , 9 byte

Lœʒāø€Ë_P

Hãy thử trực tuyến!

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 55 byte

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

Hãy thử trực tuyến!

Japt , 8 byte

Dựa trên 0

o á fÈe¦

Hãy dùng thử (Footer tăng tất cả các yếu tố để so sánh dễ dàng hơn với các trường hợp thử nghiệm)

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

Python 2 , 102 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên 0, danh sách các bộ dữ liệu.

itertoolsGiải pháp không dựa trên:

Python 2 , 107 byte

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

Hãy thử trực tuyến!

Lập chỉ mục dựa trên 0, dòng danh sách, chương trình đầy đủ.

Lưu ý: Giải pháp này, mặc dù nó không nhập itertoolsthư viện, nhưng không dài hơn giải pháp khác, vì phần lớn số lượng ở đây đang xây dựng các hoán vị. Kiểm tra loạn trí thực sự là khoảng 7 byte bổ sung! Lý do là việc kiểm tra được thực hiện một cách nhanh chóng như là một phần của việc xây dựng mỗi hoán vị. Điều này không đúng với giải pháp khác, trong đó bạn phải kiểm tra xem mỗi hoán vị được itertools.permutationshàm trả về có thực sự là một sự biến dạng hay không, và dĩ nhiên, bản đồ ánh xạ cần rất nhiều byte.

MATL , 11 byte

:tY@tb-!AY)

Điều này tạo ra tất cả các loạn trí theo thứ tự từ điển.

Hãy thử trực tuyến!

Giải thích với ví dụ

Xem xét đầu vào 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]

Perl 5 -MList::Util=none -n , 100 89 byte

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

Hãy thử trực tuyến!

Haskell , 58 byte

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

Hãy thử trực tuyến!

60 byte

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

Hãy thử trực tuyến!

Gaia , 10 byte

┅f⟨:ċ=†ỵ⟩⁇

Hãy thử trực tuyến!

┅		| 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 byte

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

Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

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

R + gtools , 62 byte

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

Hãy thử trực tuyến!

Hiệu quả hơn nhiều, trả về một matrixnơi mà mỗi hàng là một sự hư hỏng.

Python 3.8 (tiền phát hành) , 96 byte

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)

Hãy thử trực tuyến!

C ++ (gcc) , 207 196 byte

-5 byte bởi Barecat -6 byte bởi Roman Odaisky

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

Hãy thử trực tuyến!

C ++ (gcc) , 133 byte

Tôi nghĩ rằng điều này đã phát triển đủ khác với trình khác để xứng đáng với một câu trả lời riêng biệt. Cuối cùng, sử dụng index[array]cú pháp từ trong ra ngoài!

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

Hãy thử trực tuyến!

Haskell, 76 byte

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

Python 2 , 82 byte

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

Hãy thử trực tuyến!

88 byte là chương trình:

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

Hãy thử trực tuyến!

93 byte sử dụng itertools:

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

Hãy thử trực tuyến!

Perl 6 , 49 37 byte

Chỉnh sửa: Sau vài lần qua lại với Phil H, chúng tôi đã giảm xuống chỉ còn 37 byte:

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

Hãy thử trực tuyến!

Bằng cách sử dụng Whateverở đầu, chúng ta có thể tránh được dấu ngoặc (lưu 2 ký tự). Tiếp theo, sử dụng một Zmetaoperator với -mỗi phần tử hoán vị (ví dụ 2,3,1) và trừ 0,1,2 theo thứ tự. Nếu bất kỳ trong số chúng là 0 (giả) thì tất cả các điểm nối đều thất bại.

Giải pháp ban đầu là ( Dùng thử trực tuyến! )

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

Than , 44 28 byte

gạch bỏ 44 vẫn là thường xuyên 44

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Dựa vào câu trả lời không phải là itertools của @ EricTheOutgolfer. Giải trình:

Ｎθ                              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) , 187 180 byte

• Đã lưu bảy byte nhờ trần .

*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(_);}

Hãy thử trực tuyến!

Bình thường , 12 byte

f*F.e-bkT.PU

Hãy thử trực tuyến!

           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

Bộ lọc hoạt động như thế này: nếu bất kỳ phần tử nào ở vị trí ban đầu, (chỉ mục phần tử) sẽ là 0 và toàn bộ sản phẩm sẽ là 0, và do đó falsey.