受堆栈溢出问题的启发。这里的标题完全是我的错。

挑战

给定一个包含至少两个条目的正整数列表，请将每个数字替换为除自身以外的所有条目中的最小值。

测试用例

[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]

规则

该算法理论上应适用于任何输入大小（大于1）和值（正整数）。如果程序受时间，内存或数据类型的限制，则可以接受，因此该程序仅适用于最大给定值的数字，或最大给定值的输入大小。

允许使用任何编程语言编写程序或功能。禁止出现标准漏洞。

可以通过任何合理的方式进行输入；以及任何格式。输出相同。输入和输出格式可能不同。

以字节为单位的最短代码获胜。

果冻，9 6 5 字节

JFD€`ị⁸Ṃ€ 
RJP€中号€
ṙJṖ«/参数：1D数组（z）

 J [1,2,3，...，len（z）]
ṙ将z旋转上述每个量（当前数组为2D）
  Ṗ删除最后一个数组
   «/减少[隐式向量化]最小值

在线尝试！

一次验证所有这些！（稍作修改）

我很确定丹尼斯可以做到这一点。

这个怎么运作

该算法相当复杂。让我们观察一下这样做的结果[4,2,2,5]。

首先，我们使用J获得[1,2,3,4]。请注意，Jelly使用1索引。

然后，我们看到ṙ。它有两个参数：一个数组和一个整数。它将数组向左旋转整数指定的数量。在这里，ṙ将[4,2,2,5]在其左侧和[1,2,3,4]右侧看到（有关如何工作的更多信息，请参见本教程）。在Jelly中，命令隐式矢量化。因此，将在右侧的每个单独元素上执行此命令，这就是我们创建2D数组的原因：

因此，[4,2,2,5]ṙ[1,2,3,4]变为[[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4]，它变为：

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

请注意，原始元素位于最后一行，因为在该行中，我们向左旋转了一个等于数组长度的量，这就是为什么我们使用Ṗnext删除该行，以便这些列是不在当前索引处的数组元素：

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

下面的操作，«/也很复杂。首先，«返回在左侧和右侧看到的两个数字中的最小值。例如，5«3return 3。现在，如果两个参数是数组，那么它将如上所述向量化。该拿什么那[1,5,2,3]«[4,1,5,2]将成为[1«4,5«1,2«5,3«2]是[1,1,2,2]。现在，/is reduce，这意味着我们将对每一行进行操作直到结束。例如，[1,2,3,4]+/成为((1+2)+3)+4，它是array的总和[1,2,3,4]。

因此，如果将其应用于«/刚刚获得的2D数组，则会得到：

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

由于矢量化，其等效于：

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

它计算每个数组的最小值，而元素不位于索引处。

Python 2，41个字节

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

在线尝试！

对于每个元素，x我们检查是否x==min(l)。如果不是，则为False，0当用作的列表索引时sorted(l)，给出最小的元素。否则，它True又名1，给出第二个最小的元素，因为该元素本身最小，应该忽略。

果冻，5 个字节

=Ṃ‘ịṢ

在线尝试！

怎么样？

=Ṃ‘ịṢ - 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字节

编辑：

• -1字节感谢nimi！
• -2个字节。感谢xnor！一个人一个。

f接受一个整数列表（或任何Ord类型）并返回一个列表。

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

在线尝试！

f旋转列表时递归。x是第一个列表元素，y其余元素。由于递归是无限的，因此需要切断结果列表：这fst<$>zip...y是一种简短的说法take(length y)...。

八度，26字节

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

在使用类似的方法这个答案，这恰好是同此。

我并不是只想移植其他答案的忠实粉丝，这就是为什么我想指出我在看到其他答案之前也有类似的想法。

说明：

乔纳森·艾伦（Jonathan Allan）已经为Jelly代码提供了很好的解释，因此涵盖了八度位以及其工作原理（在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

这在MATLAB中不起作用，因为内联分配和直接索引不起作用。sort(x)(1)在MATLAB中给出错误，而不是排序向量中的第一个元素。

Haskell，41个字节

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

用法示例：([]#) [4,3,2,5]-> [2,2,3,2]。在线尝试！

从一个空的累加器开始，a然后递减输入列表。输出列表中的下一个元素是累加器的最小值，除a输入列表的第一个元素（-> c）以外的所有元素，然后是递归调用，其中第一个元素b添加到累加器和中c。到达输入列表的末尾时停止。

JavaScript（ES6），50 46字节

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

编辑：由于@Arnauld，节省了4个字节。

Brachylog，13 12字节

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

在线尝试！

感谢@ ais523，节省了一个字节。

说明

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

我们利用⊇将子集从最大到最小统一的事实。例如[1,2,3]，对于我们得到的子集按以下顺序：[1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], []。

我们可以看到子集[1,2], [1,3], [2,3]是我们想要的最小子集，但是与输入列表相比却是相反的顺序（因此↔）。我们只能通过找到第一length(Input) + 1个子集来选择这些子集，这些子集将包含所有子集+整个列表。我们用丢弃整个列表b。

实际上，13个字节

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

使用xnor也发现的相同技术。

在线尝试！

说明：

;;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字节

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

R，在R中实现Stewie Griffin的解决方案，我的最初想法要长50％！仍然从stdin中读取列表，但现在返回了更具可读性的数字矢量。

在线尝试！

旧的实现：

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

从标准输入中读取列表。负索引l[-x]将元素从列表中排除，并match(l,l)返回列表中每个元素首次出现的索引。返回列表。

Python 2，51字节

我知道已经有一个更好的Python解决方案，但是我仍然想发布我的。

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

在线尝试

Mathematica 34字节

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

PowerShell，68 59字节

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

在线尝试！

我非常有信心可以缩短它，我将继续研究它

C，85个字节

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

第一个参数是输入整数数组。第二个参数是输出整数数组。第三个参数是两个数组的元素计数。

看到它在网上工作。

Perl 6的， 26 24  19个字节

26

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

请注意，这是∖U + 2216，而不是\U + 5C

试试吧

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

试试吧

24

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

试试吧

19

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

试试吧

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
}

我使用“花哨的” unicode 运算符而不是ascii等效项，因为它们在它们之前需要一个空格，这样它们才不会在.Bag方法调用中被解析。

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
  ]
}

（24字节和19字节的高尔夫是受Jelly实现启发的）

Clojure，36 81 62 71字节

最新的（不应急着提交）：

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

在线尝试。

这个有一个错误（62字节），zipmap生成一个无序映射，因此在较大的输入上不会生成正确的序列。

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

v 实际上并没有用于任何东西，但这比 i (keys c)。

前一个字节为81个字节：

在线尝试。

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

在线尝试。

哦，该死的原始文件（36字节）在重复最小数目时不起作用，[4 2 2 5]导致[2 4 4 2]两个2s都被删除了：(

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

#{i}是仅包含的集合i，它返回truei和false，这意味着最小值是根据输入列表中的所有其他数字计算得出的。

在线尝试。

Pyth，8个 7字节

mh.-SQ]

-1字节感谢@isaacg

试试吧！

PHP，72字节

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

在线版本

PHP，47字节

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

Scala，37个字节

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

l 是Int的任何集合。

测试用例：

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)

这可能仍然可以打高尔夫球，我找不到比从列表中删除元素更短的方法 l diff Seq(l(i))

C＃，36个字节

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

取元素（i）并在没有当前项目的元素中查找最小值。

令人遗憾的是，由于我们使用原始类型，因此其他一些尝试不起作用，因此也没有带有引用的列表来比较项目。

PowerShell的，49 38字节

^{-11个字节，感谢mazzy}

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

在线尝试！

Sinusoid可爱回答的改进。通过使用显式输出而不是构建数组来节省10个字节。如果条件为真，则索引到已排序的数组中以点0（即最小值）或点1为准。

Perl 5，43个字节

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

等效于Python解决方案。sort不幸的是，Perl的数字默认值错误（需要使用显式比较器），并且min不是内置的，但它几乎可以弥补这一点，因为它sub短于lambda，map$_,短于x for x in，以及return和args列表的隐含性。

Ruby，30个字节

对于每个元素，对数组进行排序，删除当前元素，然后获取其余数组的第一个元素。

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

这是一个匿名函数，可以这样使用：

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

CJam，15个字节

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

本质上就是将xnor算法转换为CJam。

这是一个未命名的块，它从堆栈中获取一个数组并将结果保留在堆栈中。

说明：

{
  :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 个字节

{sWQè

@xnor的Python 2 Answer的端口。

在线尝试或验证所有测试用例。

说明：

{        # 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字节

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

@xnor的Python 2答案端口。

修改输入数组，而不是返回新的数组以节省字节。

在线尝试。

说明：

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扩展），7字节

xnor的Python 2答案端口。要求⎕IO←0：

∧⊇⍨⊢=⌊/

在线尝试！

说明：

∧⊇⍨⊢=⌊/  ⍝ 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个字节

这比早期的Haskell条目长得多，但这是第一个仅执行线性比较和线性附加工作量的条目。

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

在线尝试！

说明

!接受两个参数：运行中的最小值和非空列表。它返回列表中的最小值，并使用运行中的最小值返回处理给定列表的结果。

MathGolf，9 7个字节

s_╓?m=§

在线尝试！

说明

基本上是凯文·克鲁伊森（Kevin Cruijssen）的05AB1E答案的端口，但是由于必须明确地执行操作，我损失了2个字节。

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