विलम्बित व्युत्पन्न

Question

कुछ सकारात्मक पूर्णांक को देखते हुए $n$ के सभी अपविन्यास उत्पन्न $n$ वस्तुओं।

विवरण

• एक विचलन एक निश्चित बिंदु के साथ एक क्रमपरिवर्तन है। (इसका मतलब है कि हर गड़बड़ी संख्या में $i$ में नहीं हो सकता $i$ -th प्रविष्टि )।
• आउटपुट में संख्याओं $(1,2,\ldots,n)$ के व्युत्क्रम शामिल होंगे (या वैकल्पिक रूप से $(0,1,2,\ldots,n-1)$ )।
• आप वैकल्पिक रूप से हमेशा $(n,n-1,\ldots,1)$ (या ( n - 1 , n - 2 , … , 1 , 0 ) के व्युत्पन्न प्रिंट कर सकते हैं$(n-1,n-2,\ldots,1,0)$ क्रमशः) के लेकिन आपको इसे निर्दिष्ट करना होगा।
• आउटपुट को नियतात्मक होना चाहिए, जब भी प्रोग्राम को इनपुट के रूप में कुछ दिए गए $n$ साथ बुलाया जाता है , तो आउटपुट समान होना चाहिए (जिसमें यह शामिल है कि डिरेंजमेंट का क्रम समान रहना चाहिए), और पूरा आउटपुट भीतर होना चाहिए हर बार एक परिमित राशि (संभावना 1 के साथ ऐसा करने के लिए पर्याप्त नहीं है)।
• $n \geqslant 2$
• कुछ दिए गए आप या तो सभी derangements उत्पन्न कर सकते हैं या वैकल्पिक रूप से आप एक और पूर्णांक ले सकते हैं जो इंडेक्स के रूप में कार्य करता है और -th derangement (आपके द्वारा चुने गए क्रम में) को प्रिंट करता है ।$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 डिरेंजमेंट की संख्या को गिनाता है ।

Comments

क्या हम एक जनरेटर जमा कर सकते हैं?

— 11

@Fatalize हाँ मुझे लगता है कि यह अन्य दो उल्लिखित विधियों के समान होगा (या क्या आपको लगता है कि इसके खिलाफ एक मजबूत तर्क है?)।

— flawr

@ फ़ेटलाइज़ करें वास्तव में ऐसा लगता है कि डिफ़ॉल्ट रूप से

— दोष

Answer 1

जेली , 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]

Answer 2

ब्रेकीलॉग , 9 बाइट्स

⟦kpiᶠ≠ᵐhᵐ

इसे ऑनलाइन आज़माएं!

यह एक जनरेटर है जो [0, …, n-1]दिए के एक व्युत्पन्न को आउटपुट करता है n।

यदि हम इसे एक ᶠ - findallमेटाप्रिडिकेट में लपेटते हैं, तो हमें जनरेटर द्वारा व्युत्पन्न की सभी संभव पीढ़ी मिलती है।

व्याख्या

⟦           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

Answer 3

जावास्क्रिप्ट (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

Answer 4

रूबी , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सभी 0-आधारित व्युत्पन्न उत्पन्न करता है

Answer 5

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

Answer 6

वोल्फ्राम भाषा (गणितज्ञ) , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 7

जाप , 8 बाइट्स

0-आधारित

o á fÈe¦

इसे आज़माएं (परीक्षण मामलों की आसान तुलना के लिए पाद लेख सभी तत्वों को बढ़ाता है)

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

Answer 8

पायथन 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फ़ंक्शन द्वारा लौटाए गए प्रत्येक क्रमपरिवर्तन वास्तव में एक अपमान है, और, ज़ाहिर है, मैपिंग स्वयं बहुत सारे बाइट्स लेता है।

Answer 9

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]

Answer 10

पर्ल 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

इसे ऑनलाइन आज़माएं!

Answer 11

हास्केल , 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

इसे ऑनलाइन आज़माएं!

Answer 12

गैया , 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

Answer 13

जे , 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

Answer 14

आर , 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जहां प्रत्येक पंक्ति एक विचलन है।

Answer 15

पायथन 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)

इसे ऑनलाइन आज़माएं!

Answer 16

C ++ (gcc) , 207 196 बाइट्स

रोमन Odaisky द्वारा छत बाइट्स -6 बाइट्स -5 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

यदि आप किसी आउटपुट पैरामीटर का उपयोग करते हैं, तो आप बहुत बेहतर कर सकते हैं, खासकर अगर यह एक std :: सरणी है तो यह पूर्व-आकार है - 145 बाइट्स

— रोमन Odaisky

@ रोमेनोइस्की: अच्छा विचार है, लेकिन मैं कैसे कोड गोल्फ के नियमों को समझता हूं, आपको प्रचार कोड को अपनी बाइट की संख्या में लेना होगा।

— ०

@movatica एक ग्रे क्षेत्र, मुझे लगता है कि कोड अमान्य होने की तुलना में अधिक मान्य है। यह कहीं न कहीं सही परिणाम को खुशी से लिखेगा , और यह आउटपुट पढ़ने की कॉलर की जिम्मेदारी है। ध्यान दें कि एसटीएल एल्गोरिदम जैसे std::copyकि आउटपुट के लिए पर्याप्त स्थान प्रदान करने के साथ कॉलर को सौंपते हैं।

— रोमन ओडिसी

@ रोमनोदिस्की: एसटीएल व्यवहार वास्तव में एक वैध तर्क है।

— --४

Answer 17

सी ++ (जीसीसी) , 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;);}

इसे ऑनलाइन आज़माएं!

Answer 18

हास्केल, 76 बाइट्स

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

Answer 19

पायथन 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))]

इसे ऑनलाइन आज़माएं!

Answer 20

पर्ल 6 , 49 37 बाइट्स

संपादित करें: फिल एच के साथ कुछ आगे-पीछे होने के बाद, हमने इसे केवल 37 बाइट्स तक नीचे गिरा दिया है:

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

इसे ऑनलाइन आज़माएं!

Whateverशुरुआत में उपयोग करके , हम कोष्ठक (2 वर्णों को बचाता है) से बच सकते हैं। अगला एक Zमेटाऑपरेटर का उपयोग करें जिसके साथ -क्रमचय के प्रत्येक तत्व (जैसे 2,3,1) और क्रम में 0,1,2 घटाते हैं। यदि उनमें से कोई भी 0 (मिथ्या) है तो सभी जंक्शन विफल हो जाते हैं।

---

मूल समाधान था ( इसे ऑनलाइन आज़माएं! )

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

Comments

अच्छी शुरुआत, आप जेड ऑन के साथ फिल्टर को छोटा बना सकते हैं! = -7 बाइट्स के लिए: tio.run/##K0gtyjH7n1upoJamYKvwv7ogtSi3tCSxJJDM-…

— फिल एच

@PhilH मुझे पता था कि जिप ऑपरेटर को एकीकृत करने का एक तरीका होना चाहिए, लेकिन मैं इसे समझ नहीं पाया। अच्छा

— user0721090601

उस रणनीति का उपयोग करते हुए फिलह, कोष्ठकों को मारकर अभी भी 3 और दस्तक दे सकता है: tio.run/##K0gtyjH7n1upoJamYKvwv7ogtSi3tCSxJDM/ ...

— user0721090601

PhilH कि पिछले एक काम नहीं करता है। सभी के लिए, लेकिन n = 2 से अधिक केवल एक तत्व को अस्वीकार कर दिया जाएगा

— user0721090601

बेशक, आवश्यकता को भूल गए ... हटा दिया

— फिल एच

Answer 21

चारकोल , 44 28 बाइट्स

पार किया गया 44 अभी भी नियमित 44 है

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। व्यापक रूप से @ EricTheOutgolfer के गैर-इटर्टूलस उत्तर पर आधारित है। स्पष्टीकरण:

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

Answer 22

सी (जीसीसी) , 187 180 बाइट्स

• सेविंग के लिए सात बाइट्स धन्यवाद ।

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

इसे ऑनलाइन आज़माएं!

Comments

@ceilingcat धन्यवाद।

— जोनाथन फ्रीच

Answer 23

पायथ , 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 होगा, और इस प्रकार फ़ॉसी।