Lý lịch

Một chuỗi thứ tự tăng dần của thứ tự được định nghĩa là một chuỗi các số nguyên thỏa mãn các điều sau:$N$$S_1,S_2,\cdots,S_n$

• Mỗi là một tập hợp con không trống của .$S_i$$\{1,2,\cdots,N\}$
• Với , , tức là bất kỳ hai bộ liên tiếp nào cũng không có phần tử chung.$1\le i<n$$S_i \cap S_{i+1} = \varnothing$
• Đối với , giá trị trung bình (giá trị trung bình) của hoàn toàn nhỏ hơn so với .$1\le i<n$$S_i$$S_{i+1}$

Thử thách

Cho một số nguyên dương N, xuất độ dài của chuỗi thứ tự tăng dài nhất của đơn hàng N.

Các trường hợp thử nghiệm

Chúng dựa trên kết quả của thundre người dùng Project Euler .

1 => 1 // {1}
2 => 2 // {1} {2}
3 => 3 // {1} {2} {3}
4 => 5 // {1} {2} {1,4} {3} {4}
5 => 7 // {1} {2} {1,4} {3} {2,5} {4} {5}
6 => 10 // {1} {2} {1,4} {3} {1,4,5} {2,3,6} {4} {3,6} {5} {6}
7 => 15 // {1} {2} {1,4} {3} {1,2,7} {3,4} {1,2,5,7} {4} {1,3,6,7} {4,5} {1,6,7} {5} {4,7} {6} {7}
8 => 21
9 => 29
10 => 39
11 => 49
12 => 63
13 => 79
14 => 99
15 => 121
16 => 145
17 => 171
18 => 203
19 => 237
20 => 277
21 => 321
22 => 369
23 => 419
24 => 477
25 => 537

Quy tắc

Luật golf tiêu chuẩn được áp dụng. Đệ trình hợp lệ ngắn nhất tính bằng byte thắng.

Tiền thưởng

Vấn đề này đã được thảo luận ở đây trên diễn đàn Project Euler khoảng 4 năm trước, nhưng chúng tôi đã không đưa ra được thuật toán đa thức thời gian có thể chứng minh được (về mặt N). Do đó, tôi sẽ thưởng +200 tiền thưởng cho lần gửi đầu tiên đạt được điều này, hoặc chứng minh sự bất khả thi của nó.

Brachylog , 28 byte

⟦₁⊇ᶠk⊇pSs₂ᶠ{c≠&⟨+/l⟩ᵐ<ᵈ}ᵐ∧Sl

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

Điều này thực sự rất chậm. Mất khoảng 30 giây N = 3và không hoàn thành sau 12 phút N = 4.

Giải trình

⟦₁                             Take the range [1, …, Input]
  ⊇ᶠk                          Find all ordered subsets of that range, minus the empty set
     ⊇                         Take an ordered subset of these subsets
      pS                       Take a permutation of that subset and call it S
       Ss₂ᶠ                    Find all substrings of 2 consecutive elements in S
           {           }ᵐ      Map for each of these substrings:
            c≠                   All elements from both sets must be different
              &⟨+/l⟩ᵐ            And the average of both sets (⟨xyz⟩ is a fork like in APL)
                     <ᵈ          Must be in strictly increasing order
                         ∧Sl   If all of this succeeds, the output is the length of L.

Phiên bản nhanh hơn, 39 byte

⟦₁⊇ᶠk⊇{⟨+/l⟩/₁/₁}ᵒSs₂ᶠ{c≠&⟨+/l⟩ᵐ<₁}ᵐ∧Sl

Điều này mất khoảng 50 giây trên máy tính của tôi N = 4.

Đây là cùng một chương trình ngoại trừ chúng ta sắp xếp tập hợp con của các tập hợp con theo trung bình thay vì lấy một hoán vị ngẫu nhiên. Vì vậy, chúng tôi sử dụng {⟨+/l⟩/₁/₁}ᵒthay vì p.

{         }ᵒ     Order by:
 ⟨+/l⟩             Average (fork of sum-divide-length)
      /₁/₁         Invert the average twice; this is used to get a float average

Chúng ta cần lấy trung bình thả nổi vì tôi vừa phát hiện ra một lỗi vô lý trong đó số float và số nguyên không so sánh theo giá trị mà theo loại với các vị từ đặt hàng (đây cũng là lý do tại sao tôi sử dụng <ᵈvà không <₁so sánh cả hai mức trung bình; lừa đảo ngược để làm việc).

CJam (81 byte)

{YY@#(#{{2bW%ee{)*~}%}:Z~{)Z__1b\,d/\a+}%$}%{_,1>{2ew{z~~&!\~=>}%0&!}{,}?},:,:e>}

Bản demo trực tuyến . Nó sẽ thực thi cho đầu vào 4trong một thời gian hợp lý, nhưng tôi sẽ không thử nó với đầu vào cao hơn.

Mổ xẻ

{                 e# Declare a block (anonymous function)
  YY@#(#          e# There are 2^N subsets of [0, N), but the empty subset is problematic
                  e# so we calculate 2^(2^N - 1) subsets of the non-empty subsets
  {               e# Map integer to subset of non-empty subsets:
    {             e#   Define a block to map an bitset to its set indices; e.g. 9 => [0 3]
      2bW%ee      e#     Convert to base 2, reverse, and index
      {)*~}%      e#     If the bit was set, keep the index
    }:Z           e#   Assign the block to variable Z
    ~             e#   Evaluate it
    {             e#   Map those indices to non-empty subsets of [0, N):
      )Z          e#     Increment (to skip the empty set) and apply Z
      __1b\,d/    e#     Sum one copy, take length of another, divide for average
      \a+         e#     Wrap the subset and prepend its average value
    }%
    $             e#   Sort (lexicographically, so by average value)
  }%
  {               e# Filter out subsets of subsets with conflicts:
    _,1>{         e#   If the length is greater than 1
      2ew         e#     Take each consecutive pair of subsets
      {           e#     Map:
        z~        e#       Zip and expand to get [score1 score2] [subset1 subset2]
        ~&!\      e#       No element in common => 1
        ~=        e#       Different scores => 0
        >         e#       1 iff both constraints are met
      }%
      0&!         e#     1 iff no consecutive pair failed the test
    }{
      ,           e#   Otherwise filter to those of length 1
    }?
  },
  :,:e>           e# Map to size of subset and take the greatest
}

JavaScript (ES6), 175 byte

Một tìm kiếm đệ quy ngây thơ và khá chậm. Mất khoảng 15 giây để tính 7 điều khoản đầu tiên trên TIO.

n=>(a=[...Array(n)].reduce(a=>[...a,...a.map(y=>[x,...y],x=n--)],[[]]),g=(p,b=a,n)=>a.map(a=>(m=a.map(n=>s+=++k*b.includes(n)?g:n,s=k=0)&&s/k)>p&&g(m,a,-~n),r=r>n?r:n))(r=0)|r

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

hoặc kiểm tra phiên bản sửa đổi này tạo ra chuỗi thiết lập tăng dài nhất.

Làm sao?

$\{1,2,\dots,n\}$$a$

a = [...Array(n)].reduce(a =>
  [...a, ...a.map(y => [x, ...y], x = n--)],
  [[]]
)

Phần đệ quy:

g = (                         // g = recursive function taking:
  p,                          //   p = previous mean average
  b = a,                      //   b = previous set
  n                           //   n = sequence length
) =>                          //
  a.map(a =>                  // for each set a[] in a[]:
    (m = a.map(n =>           //   for each value n in a[]:
      s +=                    //     update s:
        ++k * b.includes(n) ? //       increment k; if n exists in b[]:
          g                   //         invalidate the result (string / integer --> NaN)
        :                     //       else:
          n,                  //         add n to s
      s = k = 0)              //     start with s = k = 0; end of inner map()
      && s / k                //   m = s / k = new mean average
    ) > p                     //   if it's greater than the previous one,
    && g(m, a, -~n),          //   do a recursive call with (m, a, n + 1)
    r = r > n ? r : n         //   keep track of the greatest length in r = max(r, n)
  )                           // end of outer map()

Python 3 , 205 197 184 182 byte

• Đã lưu tám hai mươi mốt byte nhờ các lò nướng .
• Lưu hai byte nhờ trần .

f=lambda N,c=[[1]]:max([len(c)]+[f(N,c+[n])for k in range(N)for n in combinations(range(1,N+1),k+1)if not{*c[-1]}&{*n}and sum(c[-1])/len(c[-1])<sum(n)/len(n)]);from itertools import*

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