Lấy cảm hứng từ một câu hỏi tại Stack Overflow. Tiêu đề ở đây hoàn toàn là lỗi của tôi.

Các thách thức

Đưa ra một danh sách các số nguyên dương chứa ít nhất hai mục nhập, thay thế mỗi số bằng mức tối thiểu của tất cả các mục trừ chính nó.

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

[4 3 2 5]    ->  [2 2 3 2]
[4 2 2 5]    ->  [2 2 2 2]
[6 3 5 5 8]  ->  [3 5 3 3 3]
[7 1]        ->  [1 7]
[9 9]        ->  [9 9]
[9 8 9]      ->  [8 9 8]

Quy tắc

Về mặt lý thuyết, thuật toán sẽ hoạt động cho mọi kích thước đầu vào (lớn hơn một) và các giá trị (số nguyên dương). Nó được chấp nhận nếu chương trình bị giới hạn bởi thời gian, bộ nhớ hoặc loại dữ liệu và do đó chỉ hoạt động đối với các số có giá trị nhất định hoặc cho kích thước đầu vào lên đến một giá trị nhất định.

Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.

Đầu vào có thể được thực hiện bằng bất kỳ phương tiện hợp lý ; và với bất kỳ định dạng. Tương tự cho đầu ra. Định dạng đầu vào và đầu ra có thể khác nhau.

Mã ngắn nhất trong byte thắng.

Thạch , 9 6 5 byte

J € € `ị⁸Ṃ € 
JṖ € €
JṖ «/ đối số: mảng 1D (z)

 J [1,2,3, ..., len (z)]
xoay z theo từng lượng trên (mảng hiện tại là 2D)
  Xóa mảng cuối cùng
   «/ Giảm bởi [tối thiểu hóa]

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

Xác nhận tất cả chúng cùng một lúc! (sửa đổi một chút)

Tôi khá chắc chắn rằng Dennis có thể chơi golf này.

Làm thế nào nó hoạt động

Các thuật toán là khá phức tạp. Hãy để chúng tôi quan sát những gì nó làm [4,2,2,5].

Thứ nhất, chúng tôi sử dụng Jđể có được [1,2,3,4]. Lưu ý rằng Jelly sử dụng lập chỉ mục 1.

Sau đó, chúng ta thấy ṙ. Phải có hai đối số: một mảng và một số nguyên. Nó xoay mảng sang trái theo một lượng được chỉ định bởi số nguyên. Ở đây, ṙsẽ thấy [4,2,2,5]bên trái và [1,2,3,4]bên phải của nó (thêm về cách thức hoạt động này có thể được tìm thấy trong hướng dẫn ). Trong Jelly, các lệnh ngầm định vector hóa. Do đó, lệnh này sẽ được thực hiện trên từng phần tử riêng lẻ ở bên phải, đó là lý do tại sao chúng ta sẽ tạo một mảng 2D:

Do đó, [4,2,2,5]ṙ[1,2,3,4]trở thành [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], mà trở thành:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2],
 [4.2,2,5]]

Lưu ý rằng các phần tử ban đầu nằm ở hàng cuối cùng, vì trong hàng đó chúng tôi xoay sang trái một lượng bằng với độ dài của mảng, đó là lý do tại sao chúng tôi sử dụng Ṗtiếp theo để xóa hàng đó, do đó các cột là tập hợp của các phần tử của mảng không nằm trong chỉ mục hiện tại:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2]]

Các hoạt động sau đây «/, cũng khá phức tạp. Đầu tiên, «trả về mức tối thiểu của hai số mà nó nhìn thấy ở bên trái và bên phải. Ví dụ, 5«3trả về 3. Bây giờ, nếu hai đối số là mảng, thì nó sẽ vector hóa như tôi đã nói ở trên. Điều này có nghĩa là nó [1,5,2,3]«[4,1,5,2]sẽ trở thành [1«4,5«1,2«5,3«2]cái gì [1,1,2,2]. Bây giờ, /là reduce, có nghĩa là chúng tôi làm các hoạt động trên mỗi hàng cho đến khi kết thúc. Ví dụ, [1,2,3,4]+/sẽ trở thành ((1+2)+3)+4, đó là tổng của mảng [1,2,3,4].

Vì vậy, nếu chúng ta áp dụng «/cho mảng 2D mà chúng ta vừa thu được, chúng ta sẽ nhận được:

([2,2,5,4]«[2,5,4,2])«[5,4,2,2]

trong đó, do vector hóa, sẽ tương đương với:

[2«2«5,2«5«4,5«4«2,4«2«2]

tính toán tối thiểu của mỗi mảng mà không có phần tử tại chỉ mục.

Python 2 , 41 byte

lambda l:[sorted(l)[x==min(l)]for x in l]

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

Đối với mỗi yếu tố xchúng tôi kiểm tra xem x==min(l). Nếu không, đây là False, được coi như 0khi được sử dụng như một chỉ mục danh sách sorted(l), đưa ra phần tử nhỏ nhất. Mặt khác, đó là Trueaka 1, đưa ra phần tử nhỏ thứ hai, vì chính phần tử đó là nhỏ nhất và nên được bỏ qua.

Thạch , 5 byte

=Ṃ‘ịṢ

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

Làm sao?

=Ṃ‘ịṢ - Main link: list a     e.g.  [4,3,2,5]
 Ṃ    - minimum of a                2
=     - equals? (vectorises)        [0,0,1,0]
  ‘   - increment                   [1,1,2,1]
    Ṣ - sort a                      [2,3,4,5]
   ị  - index into                  [2,2,3,2]

Haskell , 42 41 39 byte

CHỈNH SỬA:

• -1 byte nhờ nimi!
• -2 byte. Một lời cảm ơn đến xnor! Và một mình tôi.

flấy một danh sách các số nguyên (hoặc bất kỳ Ordloại nào ) và trả về một danh sách.

f(x:y)=minimum y:(fst<$>zip(f$y++[x])y)

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

fđệ quy trong khi xoay danh sách. xlà thành phần danh sách đầu tiên và yphần còn lại. Vì đệ quy là vô hạn, nên danh sách kết quả cần được cắt bỏ: fst<$>zip...ylà một cách nói ngắn hơn take(length y)....

Octave, 26 byte

@(x)sort(x)((x==min(x))+1)

Một cách tiếp cận tương tự như được sử dụng trong câu trả lời này , điều này xảy ra giống như thế này .

Tôi không thực sự là một fan hâm mộ của việc chuyển các câu trả lời khác, đó là lý do tại sao tôi muốn lưu ý rằng tôi có một ý tưởng tương tự trước khi tôi nhìn thấy những câu trả lời khác.

Giải trình:

Jonathan Allan đã cung cấp một lời giải thích tốt cho mã Jelly, vì vậy điều này bao gồm Octave-bit, và tại sao nó hoạt động (và sẽ không hoạt động trong MATLAB).

@(x)                       % An unnamed anonymous function taking a vector x as input
    sort(x)                % Gives a sorted version of x
            (x==min(x))    % Checks if each element is equal to the minimum value
           ((x==min(x))+1) % Adds 1 to the boolean vector, to use as indices
@(x)sort(x)((x==min(x))+1) % Complete function

Điều này không hoạt động trong MATLAB, vì các bài tập nội tuyến và lập chỉ mục trực tiếp không hoạt động. sort(x)(1)đưa ra một lỗi trong MATLAB, không phải là phần tử đầu tiên trong vectơ được sắp xếp.

Haskell, 41 byte

a#(b:c)=minimum(a++c):(b:a)#c
a#b=b 
([]#)

Ví dụ sử dụng: ([]#) [4,3,2,5]-> [2,2,3,2]. Hãy thử trực tuyến!

Bắt đầu với một bộ tích lũy trống avà chạy xuống danh sách đầu vào. Phần tử tiếp theo trong danh sách đầu ra là mức tối thiểu của bộ tích lũy avà tất cả trừ phần tử đầu tiên của danh sách đầu vào (-> c) theo sau là một cuộc gọi đệ quy với phần tử đầu tiên bđược thêm vào bộ tích lũy và c. Dừng lại khi bạn đạt đến cuối danh sách đầu vào.

JavaScript (ES6), 50 46 byte

a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))

Chỉnh sửa: Đã lưu 4 byte nhờ @Arnauld.

Brachylog , 13 12 byte

l+₁:?⊇ᶠ⁽⌋ᵐb↔

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

Đã lưu một byte nhờ @ ais523.

Giải trình

l+₁:?            The list [length(Input) + 1, Input]
     ⊇ᶠ⁽         Find the length(Input) + 1 first subsets of the Input
        ⌋ᵐ       Get the min of each subset 
           b↔    Remove the first element and reverse

Chúng tôi khai thác thực tế là ⊇thống nhất các tập hợp con từ lớn nhất đến nhỏ nhất. Ví dụ: [1,2,3]các tập hợp con chúng tôi nhận được theo thứ tự này : [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], [].

Chúng ta có thể thấy rằng các tập hợp con [1,2], [1,3], [2,3]là những tập hợp mà chúng ta muốn tối thiểu, nhưng theo thứ tự ngược lại so với danh sách đầu vào (do đó ↔). Chúng ta chỉ có thể chọn các tập hợp con đó bằng cách tìm các length(Input) + 1tập con đầu tiên , chúng sẽ chứa tất cả chúng + toàn bộ danh sách trước. Chúng tôi loại bỏ toàn bộ danh sách với b.

Trên thực tế , 13 byte

;;S╝m╗⌠╜=╛E⌡M

Sử dụng kỹ thuật tương tự mà xnor cũng phát hiện ra .

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

Giải trình:

;;S╝m╗⌠╜=╛E⌡M
;;             make two extra copies of input list
  S╝           sort one and save it in register 1
    m╗         save the minimum of the other in register 0
      ⌠╜=╛E⌡M  for each value in list:
       ╜=╛E      return the minimum element of the input list if the value is not equal to the minimum, else return the second-smallest element

R, 46 31 byte

l=scan();sort(l)[(min(l)==l)+1]

thực hiện giải pháp Stewie Griffin trong R, than ôi, ý tưởng ban đầu của tôi dài hơn 50%! vẫn đọc danh sách từ stdin, nhưng bây giờ trả về một vectơ số dễ đọc hơn nhiều.

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

thực hiện cũ:

l=scan();Map(function(x)min(l[-x]),match(l,l))

đọc trong danh sách từ stdin. Một chỉ mục phủ định l[-x]loại trừ phần tử khỏi danh sách và match(l,l)trả về chỉ mục xuất hiện đầu tiên của mỗi phần tử của danh sách. Trả về một danh sách.

Python 2, 51 byte

Tôi biết đã có một giải pháp Python tốt hơn, nhưng tôi vẫn muốn đăng bài của tôi.

lambda L:[min(L[:i]+L[i+1:])for i in range(len(L))]

Dùng thử trực tuyến

Toán học 34 byte

Min[#~Drop~{i}]~Table~{i,Tr[1^#]}&

PowerShell , 68 59 byte

($a=$args)|%{$b+=@((($c=$a|sort)[0],$c[1])[$_-eq$c[0]])};$b

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

Tôi khá tự tin nó có thể được rút ngắn, tôi sẽ tiếp tục xem xét nó

C, 85 byte

i,j,m;f(d,o,n)int*d,*o;{for(i=n;i--;)for(m=d[!i],j=n;j;o[i]=m=--j^i&&d[j]<m?d[j]:m);}

Đối số đầu tiên là mảng số nguyên đầu vào. Đối số thứ hai là mảng số nguyên đầu ra. Đối số thứ ba là số phần tử cho cả hai mảng.

Xem nó hoạt động trực tuyến .

Perl 6 ,  26 24  19 byte

26

{.map: (.Bag∖*).min.key}

Lưu ý rằng đó là ∖U + 2216 chứ không phải \U + 5C

Thử nó

{.map: (.Bag⊖*).min.key}

Thử nó

24

{(.min X%$_)X||.sort[1]}

Thử nó

19

{.sort[.min X==$_]}

Thử nó

26

{           # bare block lambda with implicit parameter ｢$_｣

  .map:     # for each of the values in the input (implicit method call on ｢$_｣)
  (
    .Bag    # turn the block's input into a Bag
    ∖       # set-difference           ｢∖｣ U+2216 aka ｢(-)｣
    # ⊖     # symmetric-set-difference ｢⊖｣ U+2296 aka ｢(^)｣
    *       # turn expression into a WhateverCode lambda (this is the parameter)
  ).min.key # get the minimum pair from the Bag, and return its key
}

Tôi đã sử dụng các toán tử unicode "ưa thích" hơn là các tương đương ascii vì chúng sẽ yêu cầu một khoảng trắng trước chúng để chúng không bị phân tích cú pháp như một phần của lệnh .Baggọi phương thức.

24

{
  (.min X% $_) # the minimum cross modulus-ed with the input
  X||          # cross or-ed 
  .sort[1]     # with the second minimum
}

19

{
  .sort\        # sort the values
  [             # index into that
    .min X== $_ # the minimum cross compared with the input
  ]
}

(Các gôn 24 và 19 byte được lấy cảm hứng từ việc triển khai Jelly )

Clojure, 36 81 62 71 byte

Mới nhất (không thực sự gửi những thứ này vội vàng):

#(for[c[(zipmap(range)%)]i(sort(keys c))](apply min(vals(dissoc c i))))

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

Aaaand cái này có lỗi (62 byte), zipmap tạo ra một bản đồ không có thứ tự để điều này sẽ không tạo ra chuỗi chính xác trên các đầu vào lớn hơn.

#(for[c[(zipmap(range)%)][i v]c](apply min(vals(dissoc c i))))

vkhông thực sự được sử dụng cho bất cứ điều gì nhưng điều này ngắn hơn i (keys c).

Trước đó ở mức 81 byte:

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

#(let[r(range(count %))](for[i r](apply min(for[j r :when(not= i j)](nth % j)))))

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

Ôi chết tiệt, bản gốc (36 byte) không hoạt động khi số lượng tối thiểu được lặp lại, [4 2 2 5]kết quả [2 4 4 2]là cả hai 2đều bị xóa :(

#(for[i %](apply min(remove #{i}%)))

#{i}là tập hợp chỉ chứa i, nó trả về giá trị trung thực ivà giả cho những người khác, có nghĩa là mức tối thiểu được tính từ tất cả các số khác trong danh sách đầu vào.

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

Bình thường, 8 7 byte

mh.-SQ]

-1 Byte nhờ @isaacg

Thử nó!

PHP, 72 byte

<?$k=$g=$_GET;sort($k);foreach($g as&$v)$v=$k[$v==$k[0]?:0];print_r($g);

Phiên bản trực tuyến

PHP, 47 byte

while(++$i<$argc)echo@min([z,$i=>z]+$argv),' ';

Scala, 37 byte

l.indices map(i=>l diff Seq(l(i))min)

l là bất kỳ bộ sưu tập nào của Int.

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

scala> val l = List(4,3,2,5)
l: List[Int] = List(4, 3, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 3, 2)

scala> val l = List(4,2,2,5)
l: List[Int] = List(4, 2, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 2, 2)

scala> val l = List(6,3,5,5,8)
l: List[Int] = List(6, 3, 5, 5, 8)

scala> l.indices map(i=>l diff Seq(l(i))min)
res2: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 5, 3, 3, 3)

scala> val l = List(7,1)
l: List[Int] = List(7, 1)

scala> l.indices map(i=>l diff Seq(l(i))min)
res3: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 7)

scala> val l = List(9,9)
l: List[Int] = List(9, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res4: scala.collection.immutable.IndexedSeq[Int] = Vector(9, 9)

scala> val l = List(9,8,9)
l: List[Int] = List(9, 8, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res5: scala.collection.immutable.IndexedSeq[Int] = Vector(8, 9, 8)

Điều này có thể vẫn có thể được đánh gôn, tôi không thể tìm thấy một cách ngắn hơn để loại bỏ một yếu tố khỏi danh sách hơn l diff Seq(l(i))

C #, 36 byte

i.Select((x,a)=>i.Where((y,b)=>b!=a).Min())

Lấy các phần tử (i) và tìm trong các phần tử mà không có mục hiện tại cho giá trị tối thiểu.

Thật đáng buồn, một số nỗ lực khác không hoạt động, vì chúng tôi làm việc với các loại nguyên thủy, và do đó không có danh sách với các tài liệu tham khảo để so sánh các mục từ đó.

PowerShell , 49 38 byte

^{-11 byte nhờ mazzy}

($a=$args)|%{($c=$a|sort)[$_-eq$c[0]]}

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

Cải thiện câu trả lời đáng yêu của Sinusoid . Lưu 10 byte bằng cách sử dụng đầu ra rõ ràng thay vì xây dựng một mảng. Lập chỉ mục vào mảng được sắp xếp thành điểm 0 (tức là giá trị nhỏ nhất) hoặc điểm 1 nếu điều kiện là đúng.

Perl 5, 43 byte

sub{@x=sort{$a<=>$b}@_;map$x[$_==$x[0]],@_}

Tương đương với giải pháp Python. sortThật không may , Perl có mặc định sai cho các số (yêu cầu một bộ so sánh rõ ràng) và minkhông được tích hợp sẵn, nhưng nó gần như bù lại bằng cách subngắn hơn lambda, map$_,ngắn hơn x for x in, và là nhân chứng của danh sách trả về và lập luận.

Ruby, 30 byte

Đối với mỗi phần tử, sắp xếp mảng, loại bỏ phần tử hiện tại và lấy phần tử đầu tiên của mảng còn lại.

->a{a.map{|e|(a.sort-[e])[0]}}

Đây là một chức năng ẩn danh có thể được sử dụng như thế này:

f = ->a{a.map{|e|(a.sort-[e])[0]}}
p f[[6, 3, 5, 5, 8]] # => [3, 5, 3, 3, 3]

CJam, 15 byte

{:S{S:e<=S$=}%}

Về cơ bản là một bản dịch thuật toán của xnor sang CJam.

Đây là một khối không tên lấy một mảng từ ngăn xếp và để lại kết quả trên ngăn xếp.

Giải trình:

{
  :S     e# Save in S
  {      e# For X in S:
    S:e< e#   Push Min(S)
    =    e#   X == Min(S)
    S$=  e#   Sorted(S)[top of stack]
  }%     e# End
}

05AB1E , 5 byte

{sWQè

Cổng câu trả lời Python 2 của @xnor .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

{        # Sort the (implicit) input-list
         #  i.e. [4,1,3,6] → [1,3,4,6]
 s       # Swap, so the (implicit) input-list is at the top of the stack again
  W      # Get the minimum without popping from the list
         #  i.e. [4,1,3,6] → 1
   Q     # Check for each element if they are equal to this value (1/0 as truthy/falsey)
         #  i.e. [4,1,3,6] and 1 → [0,1,0,0]
    è    # Use these 0s and 1s to index in the sorted list
         #  i.e. [1,3,4,6] and [0,1,0,0] → [1,3,1,1]

Java 8, 119 byte

a->{int t[]=a.clone(),m=a[0],i=a.length;for(int x:a)m=x<m?x:m;for(java.util.Arrays.sort(t);i-->0;)a[i]=t[a[i]==m?1:0];}

Cổng câu trả lời Python 2 của @xnor .

Sửa đổi mảng đầu vào thay vì trả về một mảng mới để lưu byte.

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

Giải trình:

a->{                  // Method with integer-array parameter and no return-type
  int t[]=a.clone(),  //  Make a copy of the input-array
      m=a[0],         //  Minimum `m`, starting at the first value of the input-array
      i=a.length;     //  Index-integer, starting at the length of the input-array
  for(int x:a)        //  Loop over the input-array
    m=x<m?            //   If the current item is smaller than the current `m`
       x              //    Replace `m` with this value
      :               //   Else:
       m;             //    Leave `m` the same
  for(java.util.Arrays.sort(t);
                      //  Sort the copy we've made of the input-array
      i-->0;)         //  Loop `i` in the range (length, 0]
    a[i]=             //   Modify the item at index `i` of the input-array to:
      t[              //    The item in the sorted array at index:
        a[i]==m?      //     If the current item and the minimum are equal:
         1            //      Use index 1 in the sorted array
        :             //     Else:
         0];}         //      Use index 0 in the sorted array

APL (Dyalog mở rộng) , 7 byte

Cổng câu trả lời Python 2 của xnor. Yêu cầu ⎕IO←0:

∧⊇⍨⊢=⌊/

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

Giải trình:

∧⊇⍨⊢=⌊/  ⍝ Monadic function train
      ⌊/  ⍝ The minimum element of the input
    ⊢=    ⍝ Element-wise compare the input to the above
          ⍝ Results in a boolean vector, let's call it "X"
∧         ⍝ Sort the input
 ⊇⍨      ⍝ Index into sorted input by X

Haskell , 76 byte

Thời gian này dài hơn đáng kể so với các mục Haskell trước đó, nhưng đây là lần đầu tiên chỉ thực hiện một số lượng so sánh tuyến tính và một lượng công việc bổ sung tuyến tính.

f(x:y)|(z,w)<-x!y=z:w
a![x]=(x,[a])
a!(x:y)|(p,q)<-a#x!y=(x#p,a#p:q)
(#)=min

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

Giải trình

!có hai đối số: một danh sách tối thiểu đang chạy và một danh sách không trống. Nó trả về giá trị tối thiểu trong danh sách và kết quả xử lý danh sách đã cho bằng cách sử dụng mức tối thiểu đang chạy.

MathGolf , 9 7 byte

s_╓?m=§

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

Giải trình

Về cơ bản là một cổng của câu trả lời 05AB1E của Kevin Cruijssen, nhưng tôi mất 2 byte nhờ phải làm mọi việc một cách rõ ràng.

s         sort(array)
 _        duplicate TOS
  ╓       minimum of two elements, min of list, minimum by filter
   ?      rot3 pops input on top of stack again
    m=    explicit map to check equality
      §   get from sorted array for each