Bazı pozitif tamsayı $n$ verildiğinde , $n$ nesnenin tüm düzensizliklerini üretir .

ayrıntılar

• Bir düzensizlik, sabit bir noktası olmayan bir permütasyon. (Bu, her düzenleme numarasında $i$$i$ girdisinde olamayacağınız anlamına gelir ).
• Çıktı, sayıların $(1,2,\ldots,n)$ (veya alternatif olarak $(0,1,2,\ldots,n-1)$ ) düzensizliklerinden oluşmalıdır .
• Alternatif olarak $(n,n-1,\ldots,1)$ (veya $(n-1,n-2,\ldots,1,0)$ sırasıyla n - 1 , n - 2 , … , 1 , 0 ) ) düzensizliklerini her zaman yazdırabilirsiniz , ancak bunu belirtmeniz gerekir.
• Çıktı deterministik olmalı, yani program girdi olarak bazı $n$ ile çağrıldığında , çıktı aynı olmalıdır (düzenlemelerin sırasının aynı kalması da dahil olmak üzere) ve tam çıktı içinde yapılmalıdır. her seferinde sınırlı bir süre (olasılık 1 ile yapmak yeterli değildir).
• N ⩾ 2 olduğunu varsayabilirsiniz.$n \geqslant 2$
• Verilen bazı $n$ için ya tüm düzenlemeleri oluşturabilir ya da alternatif olarak indeks görevi gören başka bir $k$ tamsayısını alabilir ve $k$ yazdırabilirsiniz (seçtiğiniz sırayla).

Örnekler

Düzensizliklerin sırasının burada listelenenle aynı olması gerekmediğini unutmayın:

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 , bozukluk sayısını sayar.

Jöle , 6 bayt

Œ!=ÐṂR

Tamsayıların listesini veren pozitif bir tamsayıyı kabul eden monadik bir Bağlantı.

Çevrimiçi deneyin!

Nasıl?

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

⟦kpiᶠ≠ᵐhᵐ

Çevrimiçi deneyin!

Bu, [0, …, n-1]verilen bir düzensizliği çıkaran bir jeneratördür n.

Eğer bir ᶠ - findallmetaforikse sararsak, jeneratör tarafından olası tüm nesilleri alırız.

açıklama

⟦           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 bayt

Tüm 0 tabanlı düzenlemeleri basan yinelemeli işlev.

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)

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Tüm 0 tabanlı düzenlemeleri oluşturur

05AB1E , 9 bayt

Lœʒāø€Ë_P

Çevrimiçi deneyin!

açıklama

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 Dili (Mathematica) , 55 bayt

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

Çevrimiçi deneyin!

Japt , 8 bayt

0 tabanlı

o á fÈe¦

Deneyin (Altbilgi, test senaryolarıyla daha kolay karşılaştırma için tüm öğeleri artırır)

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 bayt

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

Çevrimiçi deneyin!

0 tabanlı indeksleme, tuples listesi.

Olmayan itertoolstabanlı çözüm:

Python 2 , 107 bayt

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

Çevrimiçi deneyin!

0 tabanlı indeksleme, liste satırları, tam program.

Not: Bu çözüm, itertoolskütüphaneyi içe aktarmasa bile, içe aktarılan diğerinden çok daha uzun değildir, çünkü buradaki toplu işlerin çoğu permütasyonları inşa etmektedir. Düzensizlik kontrolü gerçekten yaklaşık 7 ek bayttır! Bunun nedeni, her permütasyonun binasının bir parçası olarak kontrolün anında yapılmasıdır. Bu, itertools.permutationsişlev tarafından döndürülen her permütasyonun aslında bir düzensizlik olup olmadığını kontrol etmeniz gereken diğer çözüm için doğru değildir ve elbette, eşlemenin çok fazla bayt sürdüğünü kontrol edin.

MATL , 11 bayt

:tY@tb-!AY)

Bu, tüm düzenlemeleri sözlükbilimsel sırayla oluşturur.

Çevrimiçi deneyin!

Örnek ile açıklama

Girişi düşünün 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 bayt

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

Çevrimiçi deneyin!

Haskell , 58 bayt

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

Çevrimiçi deneyin!

60 bayt

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

Çevrimiçi deneyin!

Gaia , 10 bayt

┅f⟨:ċ=†ỵ⟩⁇

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

listTüm düzenlemeleri içeren bir döndürür . Ürettiği için son derece verimsiz$n^2\choose n$tekrarlanan zamanların boyut nkombinasyonları olarak olası değerler , daha sonra permütasyon ve düzensizlikler için filtreler ,.[1..n]n1:n%in%x1:n-x

R + gtools , 62 bayt

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

Çevrimiçi deneyin!

Çok daha verimli, matrixher sıranın düzensiz olduğu bir yer döndürür .

Python 3.8 (ön sürüm) , 96 bayt

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)

Çevrimiçi deneyin!

C ++ (gcc) , 207196 bayt

-6 bayt ceilingcat tarafından -6 bayt Roman Odaisky tarafından

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

Çevrimiçi deneyin!

C ++ (gcc) , 133 bayt

Bence bu, diğer bir başvurudan ayrı bir cevabı hak edecek kadar farklılaştı. Sonunda index[array]içten dışa sözdizimi için bir kullanım !

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

Çevrimiçi deneyin!

Haskell, 76 bayt

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

Python 2 , 82 bayt

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

Çevrimiçi deneyin!

Program olarak 88 bayt:

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

Çevrimiçi deneyin!

İtertools kullanan 93 bayt:

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

Çevrimiçi deneyin!

Perl 6 , 49 37 bayt

Edit: Phil H ile ileri geri bazı sonra, biz sadece 37 bayt aşağı whittled:

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

Çevrimiçi deneyin!

WhateverBaşında kullanarak, köşeli parantezleri önleyebiliriz (2 karakter kaydeder). Sonraki bir kullanımı Zile metaoperator -amacıyla her bir permütasyon elemanının (örneğin, 2,3,1) ve çıkartır 0,1,2 alır. Bunlardan herhangi biri 0 (yanlış) ise, tüm kavşak başarısız olur.

Orijinal çözüm ( Çevrimiçi deneyin! )

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

Kömür , 44 28 bayt

44 çarpı hala düzenli 44

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Gevşek olarak @ EricTheOutgolfer'ın itertools olmayan yanıtı temel alınmıştır. Açıklama:

Ｎθ                              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 bayt

• Sayesinde yedi bayt tasarruf Tavan kedisi tasarruf .

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

Çevrimiçi deneyin!

Pyth , 12 bayt

f*F.e-bkT.PU

Çevrimiçi deneyin!

           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

Filtre şu şekilde çalışır: eğer herhangi bir eleman orijinal yerinde ise, (eleman-endeksi) 0 olur ve tüm ürün 0 olur ve dolayısıyla falsey olur.