ได้รับแรงบันดาลใจจากคำถามที่ Stack Overflow ชื่อที่นี่เป็นความผิดทั้งหมดของฉัน

ความท้าทาย

รับรายการจำนวนเต็มบวกที่มีอย่างน้อยสองรายการแทนที่แต่ละตัวเลขด้วยจำนวนต่ำสุดของรายการทั้งหมดยกเว้นตัวเอง

กรณีทดสอบ

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

กฎระเบียบ

อัลกอริทึมควรทำงานในทางทฤษฎีสำหรับขนาดอินพุตใด ๆ (มากกว่าหนึ่ง) และค่า (จำนวนเต็มบวก) ยอมรับได้หากโปรแกรมนั้นถูก จำกัด ด้วยเวลาหน่วยความจำหรือชนิดข้อมูลและใช้งานได้กับตัวเลขที่มีค่าสูงสุดเท่านั้นหรือสำหรับขนาดอินพุตจนถึงค่าที่กำหนด

โปรแกรมหรือฟังก์ชั่นที่ได้รับอนุญาตในการเขียนโปรแกรมภาษา ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

การป้อนข้อมูลสามารถนำมาโดยใด ๆวิธีการที่เหมาะสม ; และทุกรูปแบบ เหมือนกันสำหรับผลลัพธ์ รูปแบบอินพุตและเอาต์พุตอาจแตกต่างกัน

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

เยลลี่ , 9 6 5 ไบต์

JḟЀ `ị⁸Ṃ€ 
ṙJṖ€Ṃ€
ṙJṖ« / อาร์กิวเมนต์: 1D array (z)

 J [1,2,3, ... , len (z)]
ṙหมุน z ตามจำนวนข้างต้นแต่ละรายการ (อาร์เรย์ปัจจุบันคือ 2D)
  Ṗลบอาร์เรย์สุดท้าย
   « / ลดจำนวนขั้นต่ำ [impliclitly vectorized]

ลองออนไลน์!

ตรวจสอบทั้งหมดของพวกเขาในครั้งเดียว! (แก้ไขเล็กน้อย)

ฉันค่อนข้างมั่นใจว่าเดนนิสสามารถตีกอล์ฟนี้ได้

มันทำงานอย่างไร

อัลกอริทึมค่อนข้างซับซ้อน [4,2,2,5]ให้เราสังเกตสิ่งนี้ไม่ให้

ประการแรกเราใช้จะได้รับJ [1,2,3,4]โปรดทราบว่า Jelly ใช้การจัดทำดัชนี 1 ครั้ง

ṙจากนั้นเราจะเห็น มันต้องใช้สองข้อโต้แย้ง: อาร์เรย์และจำนวนเต็ม มันจะหมุนอาร์เรย์ไปทางซ้ายตามจำนวนที่ระบุโดยจำนวนเต็ม ที่นี่ṙจะเห็น[4,2,2,5]ทางซ้ายและ[1,2,3,4]ทางขวาของมัน (เพิ่มเติมเกี่ยวกับวิธีการทำงานนี้สามารถพบได้ในการกวดวิชา ) ใน Jelly คำสั่ง vectorize โดยนัย ดังนั้นคำสั่งนี้จะถูกดำเนินการผ่านแต่ละองค์ประกอบทางด้านขวาซึ่งเป็นสาเหตุที่เราจะสร้างอาร์เรย์ 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]]

โปรดสังเกตว่าองค์ประกอบดั้งเดิมอยู่ในแถวสุดท้ายเนื่องจากในแถวนั้นเราหมุนไปทางซ้ายด้วยจำนวนเท่ากับความยาวของอาร์เรย์ซึ่งเป็นสาเหตุที่เราใช้Ṗถัดไปเพื่อลบแถวนั้นออกเพื่อให้คอลัมน์เป็นคอลเล็กชันของ องค์ประกอบของอาร์เรย์ที่ไม่ได้อยู่ที่ดัชนีปัจจุบัน:

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

การดำเนินการต่อไปนี้«/ยังค่อนข้างซับซ้อน ประการแรก«คืนค่าต่ำสุดของตัวเลขทั้งสองที่เห็นทางด้านซ้ายและด้านขวา ตัวอย่างเช่นผลตอบแทน5«3 3ทีนี้ถ้าอาร์กิวเมนต์ทั้งสองเป็นอาร์เรย์แล้วมันจะเป็นเวกเตอร์ดังที่ฉันได้กล่าวไว้ สิ่งนี้หมายถึงว่ามัน[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]

ดังนั้นถ้าเราใช้«/กับอาร์เรย์ 2 มิติที่เราเพิ่งได้รับเราจะได้:

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

ซึ่งเนื่องจาก vectorization จะเท่ากับ:

[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...ytake(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) ตามด้วยโทร recursive กับองค์ประกอบแรกเพิ่มการสะสมและb cหยุดเมื่อคุณถึงจุดสิ้นสุดของรายการอินพุต

JavaScript (ES6), 50 46 ไบต์

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

แก้ไข: บันทึกแล้ว 4 ไบต์ขอบคุณ @Arnauld

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]

ใช้วิธีการแก้ปัญหา Stewie Griffinใน R อนิจจาความคิดดั้งเดิมของฉันคือ 50% อีกต่อไป! ยังคงอ่านรายการจาก stdin แต่ตอนนี้จะคืนค่าเวกเตอร์ตัวเลขที่อ่านได้มากขึ้น

ลองออนไลน์!

การใช้งานเก่า:

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 Bytes

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

ลองมันออนไลน์

Aaaand อันนี้มีจุดบกพร่อง (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มันจะส่งกลับความจริงiและเท็จสำหรับผู้อื่นซึ่งหมายความว่าขั้นต่ำจะถูกคำนวณจากตัวเลขอื่น ๆ ทั้งหมดในรายการอินพุต

ลองมันออนไลน์

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),' ';

สกาลา, 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 ไบต์โดยใช้เอาต์พุตที่ชัดเจนแทนการสร้างอาร์เรย์ ดัชนีลงในอาร์เรย์ที่เรียงลำดับเป็นจุด 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และ implicitness ของผลตอบแทนและ 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 's งูหลาม 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 's งูหลาม 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 ไบต์

พอร์ตของคำตอบ Python 2 ของ xnor ต้องการ⎕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=§

ลองออนไลน์!

คำอธิบาย

โดยพื้นฐานแล้วเป็นพอร์ตของคำตอบ 05AB1E ของ Kevin Cruijssen แต่ฉันเสีย 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