ডিয়ারমেন্টস গণনা করুন

Question

কিছু ধনাত্মক পূর্ণসংখ্যার $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)$ ) এর derangements মুদ্রণ করতে পারেন তবে আপনাকে এটি নির্দিষ্ট করতে হবে।
• আউটপুটটি নিয়ন্ত্রক হতে হবে, এটি যখনই প্রোগ্রামটিকে কিছু নির্দিষ্ট $n$ দিয়ে ইনপুট হিসাবে ডাকা হয় তখন আউটপুট একই হওয়া উচিত (এর মধ্যে রয়েছে ডিঞ্জেন্টের ক্রম একই থাকতে হবে), এবং সম্পূর্ণ আউটপুটটি অবশ্যই এর মধ্যে করা উচিত প্রতিবার একটি সীমাবদ্ধ পরিমাণ (সম্ভাব্যতা 1 এর সাথে এটি করা যথেষ্ট নয়)।
• আপনি যে এন ⩾ 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 বিযুক্তির সংখ্যা গণনা করে।

Comments

আমরা কি জেনারেটর জমা দিতে পারি?

— সময়সীকরণ করুন

@ ফ্যাটালাইজ হ্যাঁ আমি মনে করি এটি অন্য দুটি উল্লিখিত পদ্ধতির মতোই যথেষ্ট (অথবা আপনি কি মনে করেন যে এর বিরুদ্ধে কোনও শক্ত যুক্তি রয়েছে?)।

— flawr

@ ফ্যাটালাইজ করুন বাস্তবে মনে হয় কোনও ডিফল্ট

— 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

জাভাস্ক্রিপ্ট (ভি 8) , 85 বাইট

সমস্ত 0-ভিত্তিক derangements মুদ্রণ একটি পুনরাবৃত্ত ফাংশন।

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

05 এ বি 1 ই , 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ফাংশনটি দিয়ে ফিরে আসা প্রতিটি অনুক্রমটি আসলেই একটি ডিঞ্জারমেন্ট, এবং অবশ্যই ম্যাপিং নিজেই প্রচুর বাইট নেয় takes

Answer 9

এমএটিএল , 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সব derangements হয় ধারণকারী। এটি অত্যন্ত উত্ক্রিয় হিসাবে তৈরি হয়$n^2\choose n$পুনরাবৃত্ত সময়ের আকারের nসংমিশ্রণ হিসাবে সম্ভাব্য মানগুলি , তারপরে অনুমতি এবং ডিআরজেন্টের জন্য ফিল্টার করা হয় ।[1..n]n1:n%in%x1:n-x

আর + গিটলস , 62 বাইট

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

এটি অনলাইন চেষ্টা করুন!

আরও বেশি দক্ষ, matrixযেখানে প্রতিটি সারিটি হ'ল ডিজেনেন্স returns

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

সি ++ (জিসিসি) , 207 196 বাইট

-5 বাইট সিলিংক্যাট দ্বারা -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;}

এটি অনলাইন চেষ্টা করুন!

Comments

আপনি যদি একটি আউটপুট প্যারামিটার ব্যবহার করেন তবে আপনি আরও ভাল করতে পারেন, বিশেষত যদি এটি একটি স্ট্যান্ড :: অ্যারে তাই প্রাক আকারের - 145 বাইট

— রোমান ওডাইস্কি

@ রোমানওডাইস্কি: দুর্দান্ত ধারণা, তবে আমি কোড গল্ফের নিয়মগুলি কীভাবে বুঝি, আপনাকে নিজের বাইট গণনায় প্রিলোকেশন কোডটি নিতে হবে।

— মোভাটিকা

@ মোভ্যাটিকা একটি ধূসর অঞ্চল, আমি মনে করি কোডটি অবৈধের চেয়ে বেশি বৈধ। এটি আনন্দের সাথে কোথাও সঠিক ফলাফল লিখবে , এবং আউটপুটটি পড়ার দায়বদ্ধতার দায়িত্ব। নোট করুন যে এসটিএল অ্যালগরিদম যেমন 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

এটি অনলাইন চেষ্টা করুন!

ইয়ারটুলগুলি ব্যবহার করে 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শুরুতে ব্যবহার করে আমরা বন্ধনীগুলি এড়াতে পারি (২ টি অক্ষর বাঁচায়)। এরপরে একটি Zমেটাওপ্রেটার ব্যবহার করুন -যা ক্রমান্বরের প্রতিটি উপাদান নেয় (উদাহরণস্বরূপ 2,3,1) এবং 0,1,2 যথাক্রমে বিয়োগ করে। তাদের মধ্যে যদি 0 (মিথ্যা) হয় তবে সমস্ত জংশন ব্যর্থ হয়।

---

আসল সমাধানটি ছিল ( এটি অনলাইনে চেষ্টা করুন! )

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

Comments

ভাল শুরু, আপনি জেড দিয়ে ফিল্টার খাটো করতে পারেন = জন্য -7 বাইট: tio.run/##K0gtyjH7n1upoJamYKvwv7ogtSi3tCSxJDM/...

— ফিল এইচ

@ ফিলিফ আমি জানতাম জিপ অপারেটরকে সংহত করার জন্য একটি উপায় থাকতে হবে তবে আমি এটি যথেষ্টভাবে জানতে পারি না। ভাল

— ব্যবহারকারী 0721090601

ফিলিএইচ কৌশলটি ব্যবহার করে এখনও বন্ধনী মেরে আরও 3 টি নক করতে পারে: tio.run/##K0gtyjH7n1upoJamYKvwv7ogtSi3tCSxJDM/…

— user0721090601

ফিল্ম যে শেষ এক কাজ করে না। সবার জন্য এন = ২ ছাড়া কেবল একটি উপাদানকেই প্রত্যাখ্যান করা হবে

— ব্যবহারকারী 0721090601

অবশ্যই, প্রয়োজনীয়তাটি ভুলে গেছেন ... সরানো হয়েছে

— ফিল এইচ

Answer 21

কাঠকয়লা , 44 28 বাইট

ক্রস আউট 44 এখনও নিয়মিত 44

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। আলগাভাবে @ এরিকআউটগলফারের নন-ইটারটোলেস উত্তরের উপর ভিত্তি করে। ব্যাখ্যা:

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

আপনাকে ধন্যবাদ

— জোনাথন ফ্রেচ

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 হবে এবং এভাবে মিথ্যা।