ইউলেরিয়ান নম্বর গণনা করুন

Question

Eulerian সংখ্যা A(n, m) এর একাধিক বিন্যাসন হয় [1, 2, ..., n]যা ঠিক mউপাদানের পূর্ববর্তী উপাদান তার চেয়ে অনেক বেশী হয়। এগুলিকে রাইজও বলা হয় । উদাহরণস্বরূপ, যদিn = 3 , 3 আছে! = 6 এর অনুমতি[1, 2, 3]

1 2 3
 < <  2 elements are greater than the previous

1 3 2
 < >  1 ...

2 1 3
 > <  1 ...

2 3 1
 < >  1 ...

3 1 2
 > <  1 ...

3 2 1
 > >  0 ...

ইন A(3, m)জন্য আউটপুটm[0, 1, 2, 3] হবে

A(3, 0) = 1
A(3, 1) = 4
A(3, 2) = 1
A(3, 3) = 0

এছাড়াও, এটি OEIS ক্রম A173018 ।

বিধি

• এটি কোড-গল্ফ তাই সংক্ষিপ্ততম কোড জিততে পারে।
• ইনপুটটি nএকটি নন-নেগেটিভ পূর্ণসংখ্যার mহবে এবং এটি পরিসরে একটি পূর্ণসংখ্যা হবে [0, 1, ..., n]।

পরীক্ষার মামলা

n   m   A(n, m)
0   0   1
1   0   1
1   1   0
2   0   1
2   1   1
2   2   0
3   0   1
3   1   4
3   2   1
3   3   0
4   0   1
4   1   11
4   2   11
4   3   1
4   4   0
5   1   26
7   4   1191
9   5   88234
10  5   1310354
10  7   47840
10  10  0
12  2   478271
15  6   311387598411
17  1   131054
20  16  1026509354985
42  42  0

Comments

কোন সীমা আছে n, m?

— লুভজো

সীমাবদ্ধতা নেই, তবে এটির প্রয়োজন নেই যে আপনার জমাটি একটি নির্দিষ্ট সময়ের মধ্যে একটি পরীক্ষার কেস সম্পূর্ণরূপে কার্যকর করতে সক্ষম হবে, কেবলমাত্র সঠিক যুক্তি রয়েছে। অগ্রাধিকার হিসাবে, আমি 20 টি পর্যন্ত মানগুলি হ্যান্ডেল করার জন্য সাবমিশনগুলি চাই, তবে কেবলমাত্র কার্যকর হতে পারে এমন ব্রুট-ফোর্স সমাধানের অনুমতি দেওয়ার জন্য আমি কোনও পারফরমেন্সের প্রয়োজনীয়তা ছাড়াই এটি ছেড়ে দিয়েছি n = 10।

— মাইল 15

ইনপুটটিতে m> = n, n> 0 থাকতে পারে?

— feersum

উচিত হবে না, "এম" পরিসীমাটির পূর্ণসংখ্যা হবে [0, 1, ..., n] "হতে" ... [0, 1, ..., এন -1] "?

— জোনাথন অ্যালান

@ ফেয়ারসাম আপনার সমাধানটি ইচ্ছে করলে যে কোনওটিকে সমর্থন করতে পারে m, তবে আমার কেবল এটি প্রয়োজন যে এটি 0 <= m <= n এর সাথে 0 <= n সহ বৈধ হওয়া উচিত ।

— মাইল 15

Answer 1

জেলি , 8 বাইট

Œ!Z>2\Sċ

এটি অনলাইন চেষ্টা করুন! (কিছুক্ষণ সময় নেয়) বা ছোট পরীক্ষার কেসগুলি যাচাই করুন ।

কিভাবে এটা কাজ করে

Œ!Z>2\Sċ  Main link. Arguments: n, m

Œ!        Generate the matrix of all permutations of [1, ..., n].
  Z       Zip/transpose, placing the permutations in the columns.
   >2\    Compare columns pairwise with vectorizing greater-than.
          This generates a 1 in the column for each rise in that permutation.
      S   Compute the vectorizing sum of the columns, counting the number of rises.
       ċ  Count how many times m appears in the computed counts.

Answer 2

জাভাস্ক্রিপ্ট (ES6), 50 46 45 বাইট

f=(n,m,d=n-m)=>m?d&&f(--n,m)*++m+f(n,m-2)*d:1

পুনরাবৃত্তির সূত্রের ভিত্তিতে:

A(n, m) = (n - m)A(n - 1, m - 1) + (m + 1)A(n - 1, m)    

পরীক্ষার মামলা

f=(n,m,d=n-m)=>m?d&&f(--n,m)*++m+f(n,m-2)*d:1

console.log(f( 0,  0));  // 1
console.log(f( 1,  0));  // 1
console.log(f( 1,  1));  // 0
console.log(f( 2,  0));  // 1
console.log(f( 2,  1));  // 1
console.log(f( 2,  2));  // 0
console.log(f( 3,  0));  // 1
console.log(f( 3,  1));  // 4
console.log(f( 3,  2));  // 1
console.log(f( 3,  3));  // 0
console.log(f( 4,  0));  // 1
console.log(f( 4,  1));  // 11
console.log(f( 4,  2));  // 11
console.log(f( 4,  3));  // 1
console.log(f( 4,  4));  // 0
console.log(f( 5,  1));  // 26
console.log(f( 7,  4));  // 1191
console.log(f( 9,  5));  // 88234
console.log(f(10,  5));  // 1310354
console.log(f(10,  7));  // 47840
console.log(f(10, 10));  // 0
console.log(f(12,  2));  // 478271
console.log(f(15,  6));  // 311387598411
console.log(f(17,  1));  // 131054
console.log(f(20, 16));  // 1026509354985
console.log(f(42, 42));  // 0

Answer 3

এমএটিএল , 10 বাইট

:Y@!d0>s=s

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

ব্যাখ্যা

একটি উদাহরণ ইনপুট হিসাবে বিবেচনা করুন n=3,m=1 । আপনি %সেই বিন্দু থেকে কোডটি মন্তব্য করার জন্য একটি প্রতীক স্থাপন করতে পারেন এবং এইভাবে মধ্যবর্তী ফলাফলগুলি দেখতে পারেন। উদাহরণস্বরূপ, লিঙ্কটি প্রথম পদক্ষেপের পরে স্ট্যাকটি দেখায়।

:      % Input n implicitly. Push [1 2 ... n]
       % STACK: [1 2 ... n]
Y@     % Matrix of all permutations, one on each row
       % STACK: [1 2 3; 1 3 2; 2 1 3; 2 3 1; 3 1 2; 3 2 1]
!      % Transpose
       % STACK: [1 1 2 2 3 3; 2 3 1 3 1 2; 3 2 3 1 2 1]
d      % Consecutive differences along each column
       % STACK: [1 2 -1 1 -2 -1; 1 -1 2 -2 1 -1]
0>     % True for positive entries
       % STACK: [1 1 0 1 0 0; 1 0 1 0 1 0]
s      % Sum of each column
       % STACK: [2 1 1 1 1 0]
=      % Input m implicitly. Test each entry for equality with m
       % STACK: [0 1 1 1 1 0]
s      % Sum. Implicitly display
       % STACK: 4

Answer 4

সিজেএম ( 21 19 বাইট - বা 18 টি যদি আর্গুমেন্ট অর্ডার বিনামূল্যে থাকে)

{\e!f{2ew::>1b=}1b}

এটি একটি বেনাম ব্লক (ফাংশন) যা n mস্ট্যাকটি গ্রহণ করে। (যদি m nস্ট্যাকটি ধরে রাখার অনুমতি দেওয়া হয় তবে \তা সংরক্ষণ করা যায়)। এটি সমস্ত অনুমতি এবং ফিল্টারগুলি গণনা করে, তাই অনলাইন টেস্ট স্যুট বরং সীমাবদ্ধ করতে হবে।

কাছাকাছি দিক নির্দেশ করার জন্য মার্টিনকে ধন্যবাদ filter-with-parameter।

ব্যবচ্ছেদ

{        e# Define a block. Stack: n m
  \      e#   Flip the stack to give m n
  e!f{   e#   Generate permutations of [0 .. n-1] and map with parameter m
    2ew  e#     Stack: m perm; generate the list of n-1 pairs of consecutive
         e#     elements of perm
    ::>  e#     Map each pair to 1 if it's a rise and 0 if it's a fall
    1b   e#     Count the falls
    =    e#     Map to 1 if there are m falls and 0 otherwise
  }
  1b     e#   Count the permutations with m falls
}

মনে রাখবেন যে ইউলরিয়ান সংখ্যাগুলি প্রতিসাম্যপূর্ণ: E(n, m) = E(n, n-m)তাই আপনি ফলপ্রসূ বা উত্থান গণনা করেন কিনা তা অপ্রাসঙ্গিক।

দক্ষতার সাথে: 32 বাইট

{1a@{0\+_ee::*(;\W%ee::*W%.+}*=}

অনলাইন পরীক্ষা স্যুট ।

এটি পুরো সারিগুলিতে পুনরাবৃত্তিটি প্রয়োগ করে।

{          e# Define a block. Stack: n m
  1a@      e#   Push the row for n=0: [1]; and rotate n to top of stack
  {        e#   Repeat n times:
           e#     Stack: m previous-row
    0\+_   e#     Prepend a 0 to the row and duplicate
    ee::*  e#     Multiply each element by its index
           e#     This gives A[j] = j * E(i-1, j-1)
    (;     e#     Pop the first element, so that A[j] = (j+1) * E(i-1, j)
    \W%    e#     Get the other copy of the previous row and reverse it
    ee::*  e#     Multiply each element by its index
           e#     This gives B[j] = j * E(i-1, i-1-j)
    W%     e#     Reverse again, giving B[j] = (i-j) * E(i-1, j-1)
    .+     e#     Pointwise addition
  }*
  =        e#   Extract the element at index j
}

Comments

এটা একটা মানচিত্র ব্যবহার করে পরিবর্তনশীল এড়াতে খাটো আছে: {e!f{2ew::>1b=}1e=}। বা কেবল মজাদার জন্য:{e!f{2ew::>+:-}0e=}

— মার্টিন ইন্ডার

এটা অবশ্যই বোকা ছিল। 1e=প্রথম সমাধান হতে পারে 1b।

— মার্টিন ইন্ডার

আপনি নিজের যুক্তির আদেশটি ব্যবহারের অনুমতি পেয়েছেন

— মাইল

Answer 5

পাইথন, 55 56 বাইট

a=lambda n,m:n>=m>0and(n-m)*a(n-1,m-1)-~m*a(n-1,m)or m<1

Repl.it এ সমস্ত পরীক্ষা

ওইআইএস-এ পুনরাবৃত্ত সূত্র প্রয়োগ করে। গল্ফ করা হয়
যে নোট । (বুলিয়ান প্রতিনিধিত্ব করতে মান ফেরত দিতে পারেন বা । রিটার্নস যখন বা ।)+(m+1)*a(n-1,m)-~m*a(n-1,m)
10Truen<0 and m<=0m<0

Comments

প্রান্তের কেসগুলি পরিচালনা করার জন্য অন্যান্য বিভিন্ন উপায় রয়েছে। এটি হ্যান্ডেল যথেষ্ট m<1 ? 1 : m==n ? 0 : formula, সমতুল্য m%n<1 ? (m<1) : formula; বা বিকল্পভাবে m<1 ? (n>=0) : formula।

— পিটার টেলর

আমি পেয়েছি, কেবল ধন্যবাদ আপডেট করে

— জোনাথন অ্যালান

যেহেতু আমাদের উত্তরগুলি খুব অনুরূপ, এবং আপনার পোস্ট করা হয়েছিল প্রথমে (এবং আরও ছোট), আমি এগিয়ে গিয়ে আমার মুছে ফেলব।

— লুভজো

@ লভজো কিছুটা ভৌতিক টুইট করার পরেও :( আপনি যেভাবেই হোক আমার কাছ থেকে একটি ভোট পেয়েছেন!

— জনাথন অ্যালান

Answer 6

গণিত, 59 56 বাইট

_~f~0=1
n_~f~m_:=If[m>n,0,(n-m)f[n-1,m-1]+(m+1)f[n-1,m]]

এবং এখানে একটি 59 বাইট সংস্করণ আরও সংক্ষিপ্তভাবে সংজ্ঞাটি প্রয়োগ করছে:

Count[Count@1/@Sign/@Differences/@Permutations@Range@#,#2]&

Comments

কেন শুধু f[n_,m_]:=...49 এর জন্য নয় ?

— জনাথন অ্যালান

@ জোনাথান অ্যালান আমি নিশ্চিত যে আমি বুঝতে পেরেছি না। কিভাবে এটি বেস কেস পরিচালনা করে?

— মার্টিন ইন্ডার

ঠিক আছে, কিছু ক্যাশে করা হয়েছিল - এটি কেবলমাত্র একটি নতুন কার্যপত্রক এ করেছে এবং এটি পুনরাবৃত্তি সীমাতে ব্যর্থ হয়েছিল। :)

— জোনাথন অ্যালান

এছাড়াও সূত্রটি রয়েছে যা 46 বাইট ব্যবহার করে Sum[Binomial[#+1,k](#2+1-k)^#(-1)^k,{k,0,#2}]&যা আরও গল্ফ পাওয়া সম্ভব হতে পারে

— মাইল

Answer 7

পাইথন, 53 বাইট

t=lambda n,k:n and(n-k)*t(n-1,k-1)-~k*t(n-1,k)or k==0

ওইআইএস থেকে পুনরাবৃত্তি। আউটপুটস বুলিয়ান Trueহিসাবে 1যখন n==k।

Answer 8

ম্যাটল্যাব / অষ্টাভে, 40 বাইট

@(n,m)sum(sum(diff((perms(1:n))')>0)==m)

এটি একটি বেনাম ফাংশন আকারে, আমার এমএটিএল উত্তরের একটি বন্দর। এটি হিসাবে কল করুন ans(7,4)।

Ideone এ ব্যবহার করে দেখুন ।

Answer 9

গেমমেকার ল্যাঙ্গুয়েজ, 62 বাইট

এটি A@ আরনোল্ডের সূত্রের ভিত্তিতে পুনরাবৃত্ত স্ক্রিপ্ট ।

n=argument0;m=argument1;return (n-m)*A(n-1,m-1)+(m+1)*A(n-1,m)

Comments

কিছুক্ষণ দেখা হয়নি!

— টমসডিং

Answer 10

পার্ল, 98 বাইট

sub a{my($b,$c)=@_;return$c?$c>$b?0:($b-$c)*a($b-1,$c-1)+($c+1)*a($b-1,$c):1;}print a(@ARGV[0,1]);

আরনাউল্ডের উত্তর হিসাবে একই সম্পত্তি উপর ভিত্তি করে।

Answer 11

আর, 72 বাইট

OEIS এ যুক্তি অনুসরণ করে পুনরাবৃত্তি ফাংশন।

A=function(n,m)if(!m)1 else if(m-n)0 else(n-m)*A(n-1,m-1)+(m+1)*A(n-1,m)

এই চ্যালেঞ্জটি আমার চেষ্টা করা বিভিন্ন পদ্ধতির মধ্যে বেশ কাছাকাছি ছিল। উদাহরণস্বরূপ, উইকিপিডিয়া সূত্রটি ব্যবহার করে এবং যোগফলের লুপিংয়ের ফলে 92 বাইট তৈরি হয়েছিল:

function(n,m){s=0;if(!n)1 else for(k in -1:m+1)s=c(s,(-1)^k*choose(n+1,k)*(m+1-k)^n);sum(s)}

বা 87 টি বাইটের জন্য ভেক্টরাইজড সংস্করণ:

function(n,m)if(!m)1 else sum(sapply(-1:m+1,function(k)(-1)^k*choose(n+1,k)*(m+1-k)^n))

এবং অবশেষে ব্রুট ফোর্স সলিউশন (103 বাইট) যা permuteপ্যাকেজ এবং ফাংশনটি ব্যবহার করে সমস্ত অনুমতির ম্যাট্রিক্স উত্পন্ন করে allPerms। এই পদ্ধতির শুধুমাত্র n<8যদিও আপ কাজ করে ।

function(n,m){if(!m)1 else sum(apply(rbind(1:n,permute:::allPerms(n)),1,function(x)sum(diff(x)>0))==m)}

Answer 12

র‌্যাকেট 141 বাইট

(count(λ(x)(= x m))(for/list((t(permutations(range 1(+ 1 n)))))(count
(λ(x)x)(for/list((i(sub1 n)))(>(list-ref t(+ 1 i))(list-ref t i))))))

Ungolfed:

(define (f n m)
  (let* ((l (range 1 (add1 n)))                ; create a list till n
         (pl (permutations l))                 ; get all permutations
         (enl (for/list ((t pl))               ; check each permutation; 
                (define rl
                  (for/list ((i (sub1 n)))     ; check if an element is a 'rise'
                    (> (list-ref t (add1 i))
                       (list-ref t i))))
                (count (lambda(x)x) rl))))     ; how many numbers are 'rises'
    (count (lambda(x) (= x m)) enl)))          ; how many permutations had m rises
                                               ; i.e. Eulerian number

পরীক্ষামূলক:

(f 3 0)
(f 3 1)
(f 3 2)
(f 3 3)
(f 4 2)
(f 5 1)
(f 7 4)

আউটপুট:

1
4
1
0
11
26
1191

Answer 13

আসলে , 21 19 বাইট

এই উত্তরটি ডেনিসের জেলি উত্তরে যেভাবে ব্যবহার করেছে তার অনুরূপ একটি অ্যালগরিদম ব্যবহার করে । <আমার সংখ্যার সময় আসল সংজ্ঞা গণনা করা হয় >। এটি শেষ পর্যন্ত সমতুল্য হয়ে যায়। গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

;R╨`;\ZdX"i>"£MΣ`Mc

Ungolfing

         Implicit input m, then n.
;        Duplicate n. Stack: n, n, m
R        Push range [1..n].
╨        Push all n-length permutations of the range.
`...`M   Map the following function over each permutation p.
  ;\       Duplicate and rotate p so that we have a list of the next elements of p.
  Z        Zip rot_p and p.
           (order of operands here means the next element is first,
            so we need to use > later)
  dX       Remove the last pair as we don't compare the last and first elements of the list.
  "i>"£    Create a function that will flatten a list and check for a rise.
  M        Map that function over all the pairs.
  Σ        Count how many rises there are in each permutation.
c        Using the result of the map and the remaining m, 
          count how many permutations have m rises.
         Implicit return.

Answer 14

সুইফট 3 , 8288 বাইট

func A(_ n:Int,_ m:Int)->Int{return m<1 ?1:n>m ?(n-m)*A(n-1,m-1)+(m+1)*A(n-1,m):0}

কোনও ভাষায় ঠিক একই পুনরাবৃত্তির সূত্র যা অবশ্যই গল্ফের জন্য নয়

Answer 15

জে, 28 বাইট

+/@((!>:)~*(^~#\.)*_1^])i.,]

সূত্র ব্যবহার করে

ব্যবহার

   f =: +/@((!>:)~*(^~#\.)*_1^])i.,]
   0 f 0
1
   1 f 0
1
   1 f 1
0
   (f"+i.,]) 6
1 57 302 302 57 1 0
   20x f 16x
1026509354985

ব্যাখ্যা

+/@((!>:)~*(^~#\.)*_1^])i.,]  Input: n (LHS), m (RHS)
                        i.    Range [0, 1, ..., m-1]
                           ]  Get m
                          ,   Join to get k = [0, 1, ..., m]
                      ]       Get k
                   _1^        Raise -1 to each in k
              #\.               Get the length of each suffix of k
                                Forms the range [m+1, m, ..., 2, 1]
            ^~                  Raise each value by n
                  *           Multiply elementwise with (-1)^k
    (   )~                      Commute operators
      >:                        Increment n
     !                          Binomial coefficient, C(n+1, k)
          *                   Multiply elementwise
+/@                           Reduce by addition to get the sum and return