Stack Overflowでの質問に触発されました。ここのタイトルは完全に私のせいです。

チャレンジ

少なくとも2つのエントリを含む正の整数のリストが与えられた場合、それ自体を除くすべてのエントリの最小値で各数値を置き換えます。

テストケース

[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 バイト

JḟЀ `ị⁸Ṃ€ 
ṙJṖ€ṂṂ€
ṙJṖ«/引数：1D配列（z）

 J [1,2,3、...、len（z）]
z上記の各量だけzを回転します（現在の配列は2Dです）
  last最後の配列を削除
   «/ [暗黙的にベクトル化]最小値で削減

オンラインでお試しください！

すべてを一度に確認してください！（わずかに変更）

私はデニスがこれをゴルフアウトできると確信しています。

使い方

アルゴリズムはかなり複雑です。これが何をするのか観察しましょう[4,2,2,5]。

まず、をJ取得するために使用し[1,2,3,4]ます。Jellyは1インデックスを使用することに注意してください。

次に、表示されṙます。配列と整数の2つの引数を取ります。整数で指定された量だけ配列を左に回転します。ここでṙは[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]]

次の操作«/も非常に複雑です。まず、«左側と右側に表示される2つの数値の最小値を返します。たとえば、を5«3返します3。ここで、2つの引数が配列の場合、上記のようにベクトル化されます。これがどういう[1,5,2,3]«[4,1,5,2]ことになるの[1«4,5«1,2«5,3«2]か[1,1,2,2]。ここで、/はreduce、最後まで各行に対して操作を行うことを意味します。例えば[1,2,3,4]+/なる((1+2)+3)+4アレイの和です、[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で、2番目に小さい要素を提供します。その要素自体は最小であり、無視する必要があるためです。

ゼリー、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バイト

編集：

• nimiのおかげで-1バイト！
• -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-codeの良い説明を提供しているので、これはOctave-bitとそれがなぜ機能するのか（そして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のおかげで1バイト節約されました。

説明

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にStewie Griffinのソリューションを実装しています。まだリストを標準入力から読み取りますが、より読みやすい数値ベクトルを返すようになりました。

オンラインでお試しください！

古い実装：

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

stdinからリストを読み取ります。負のインデックス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);}

最初の引数は入力整数配列です。2番目の引数は、出力整数配列です。3番目の引数は、両方の配列の要素数です。

オンラインでご覧ください。

Perl 6の、 26の24  19バイト

26

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

U + 5C ∖ではなく\U + 2216であることに注意してください

それを試してみてください

{.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
}

メソッドの呼び出しの一部として解析されないように、それらの前にスペースが必要だったので、私は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バイトのゴルフはゼリーの実装に触発されました）

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

オンラインでお試しください。

OH気オリジナル（36バイト）の最小数は、繰り返されたときに動作しない[4 2 2 5]で結果を[2 4 4 2]両方として2Sが除去さ:(

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

#{i}のみを含むセットですi、それがためにtruthyを返し、i最小値が入力リスト内の他のすべての数字から計算されることを意味し、falsy他人のために。

オンラインでお試しください。

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バイト}

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

オンラインでお試しください！

Sinusoidの素敵な答えの改善。配列を作成する代わりに、明示的な出力を使用して10バイトを節約します。条件がtrueの場合、スポット0（つまり最小値）またはスポット1のいずれかにソートされた配列にインデックスを付けます。

Perl 5、43バイト

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

Pythonソリューションと同等です。Perlのはsort、残念ながら（明示的なコンパレータを必要とする）番号の間違ったデフォルトを持ち、minビルトインされていないが、それはほとんどで、それを補うsubよりも短いlambda、map$_,より短いことx for x in、およびリターンとargsリストのimplicitness。

ルビー、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回答のポート。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

{        # 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 Extended）、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

オンラインでお試しください！

説明

!実行中の最小リストと空でないリストの2つの引数を取ります。リスト内の最小値と、実行中の最小値を使用して特定のリストを処理した結果を返します。

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