Terinspirasi oleh pertanyaan di Stack Overflow. Judul di sini sepenuhnya salah saya.

Tantangan

Diberikan daftar bilangan bulat positif yang mengandung setidaknya dua entri, ganti setiap angka dengan minimum semua entri yang tidak termasuk itu sendiri.

Uji kasus

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

Aturan

Algoritme secara teoritis harus bekerja untuk ukuran input apa saja (lebih besar dari satu) dan nilai-nilai (bilangan bulat positif). Ini diterima jika program dibatasi oleh waktu, memori atau tipe data dan hanya berfungsi untuk angka hingga nilai tertentu, atau untuk ukuran input hingga nilai tertentu.

Program atau fungsi diizinkan, dalam bahasa pemrograman apa pun . Celah standar dilarang.

Masukan dapat diambil dengan cara apa pun yang wajar ; dan dengan format apa saja. Sama untuk output. Format input dan output mungkin berbeda.

Kode terpendek dalam byte menang.

Jelly , 9 6 5 byte

JḟÐ € `ị⁸Ṃ € 
ṙJṖ € Ṃ €
ṙJṖ «/ argumen: 1D array (z)

 J [1,2,3, ..., len (z)]
ṙ putar z dengan masing-masing jumlah di atas (array saat ini adalah 2D)
  Ṗ hapus array terakhir
   «/ Kurangi dengan minimum [secara implisit vektor]

Cobalah online!

Verifikasi semuanya sekaligus! (sedikit dimodifikasi)

Saya cukup yakin Dennis bisa bermain golf di luar ini.

Bagaimana itu bekerja

Algoritma agak berbelit-belit. Mari kita amati apa yang dilakukannya [4,2,2,5].

Pertama, kita gunakan Juntuk memperoleh [1,2,3,4]. Perhatikan bahwa Jelly menggunakan pengindeksan 1.

Lalu, kita lihat ṙ. Dibutuhkan dua argumen: array dan integer. Ini memutar array ke kiri dengan jumlah yang ditentukan oleh integer. Di sini, ṙakan lihat [4,2,2,5]di sebelah kiri dan [1,2,3,4]di sebelah kanannya (lebih lanjut tentang cara kerjanya dapat ditemukan di tutorial ). Dalam Jelly, perintah secara tersamar vektor. Oleh karena itu, perintah ini akan dilakukan pada setiap elemen individu di sebelah kanan, itulah sebabnya kami akan membuat array 2D:

Oleh karena itu, [4,2,2,5]ṙ[1,2,3,4]menjadi [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], yang menjadi:

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

Perhatikan bahwa elemen asli ada di baris terakhir, karena di baris itu kita diputar ke kiri dengan jumlah yang sama dengan panjang array, itulah sebabnya kita menggunakan Ṗberikutnya untuk menghapus baris itu, sehingga kolom adalah koleksi dari elemen array yang tidak pada indeks saat ini:

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

Operasi berikut «/,, juga cukup berbelit - belit. Pertama, «mengembalikan minimum dua angka yang dilihatnya di sebelah kiri dan di sebelah kanannya. Misalnya, 5«3kembali 3. Sekarang, jika dua argumen adalah array, maka itu akan menjadi vektor seperti yang saya katakan di atas. Artinya ini yang [1,5,2,3]«[4,1,5,2]akan menjadi [1«4,5«1,2«5,3«2]apa adanya [1,1,2,2]. Sekarang, /adalah reduce, yang berarti bahwa kita melakukan operasi di setiap baris hingga akhir. Misalnya, [1,2,3,4]+/akan menjadi ((1+2)+3)+4, yang merupakan jumlah dari array [1,2,3,4].

Jadi, jika kita menerapkan «/array 2D yang baru saja kita peroleh, kita akan mendapatkan:

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

yang, karena vektorisasi, akan setara dengan:

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

yang menghitung minimum setiap array tanpa elemen pada indeks.

Python 2 , 41 byte

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

Cobalah online!

Untuk setiap elemen xkami memeriksa apakah x==min(l). Jika tidak, ini False, yang diperlakukan seperti 0ketika digunakan sebagai daftar indeks ke dalam sorted(l), memberikan elemen terkecil. Kalau tidak, itu Truealias 1, memberikan elemen terkecil kedua, karena elemen itu sendiri terkecil dan harus diabaikan.

Jelly , 5 byte

=Ṃ‘ịṢ

Cobalah online!

Bagaimana?

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

EDIT:

• -1 byte berkat nimi!
• -2 byte. Terima kasih kepada xnor! Dan satu sendiri.

fmengambil daftar bilangan bulat (atau Ordtipe apa pun ) dan mengembalikan daftar.

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

Cobalah online!

fberulang saat memutar daftar. xadalah elemen daftar pertama dan ysisanya. Karena rekursi tidak terbatas, daftar hasil perlu dipotong: fst<$>zip...yadalah cara yang lebih pendek untuk mengatakan take(length y)....

Oktaf, 26 byte

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

Pendekatan yang sama seperti yang digunakan dalam jawaban ini , yang kebetulan sama dengan ini .

Saya bukan penggemar hanya porting jawaban lain, itulah sebabnya saya ingin mencatat bahwa saya memiliki ide yang sama sebelum saya melihat yang lain.

Penjelasan:

Jonathan Allan telah memberikan penjelasan yang bagus untuk kode-Jelly, jadi ini mencakup bit-oktaf, dan mengapa itu bekerja (dan tidak akan bekerja di 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

Ini tidak berfungsi di MATLAB, karena penugasan sebaris dan pengindeksan langsung tidak berfungsi. sort(x)(1)memberikan kesalahan dalam MATLAB, bukan elemen pertama dalam vektor yang diurutkan.

Haskell, 41 byte

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

Contoh penggunaan: ([]#) [4,3,2,5]-> [2,2,3,2]. Cobalah online!

Mulailah dengan akumulator kosong adan jalankan daftar input. Elemen berikutnya dalam daftar output adalah minimum akumulator adan semua kecuali elemen pertama dari daftar input (-> c) diikuti oleh panggilan rekursif dengan elemen pertama bditambahkan ke akumulator dan c. Berhenti ketika Anda mencapai akhir daftar input.

JavaScript (ES6), 50 46 byte

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

Sunting: Disimpan 4 byte berkat @Arnauld.

Brachylog , 13 12 byte

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

Cobalah online!

Disimpan satu byte berkat @ ais523.

Penjelasan

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

Kami mengeksploitasi fakta yang ⊇menyatukan himpunan bagian dari yang terbesar hingga yang terkecil. Misalnya untuk [1,2,3], subset kita berada di urutan ini: [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], [].

Kita dapat melihat bahwa himpunan bagian [1,2], [1,3], [2,3]adalah yang kita inginkan dari minimum, tetapi berada dalam urutan terbalik dibandingkan dengan daftar input (karenanya ↔). Kami dapat memilih subset hanya dengan menemukan length(Input) + 1subset pertama , yang akan berisi semuanya + seluruh daftar terlebih dahulu. Kami membuang seluruh daftar itu dengan b.

Sebenarnya , 13 byte

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

Menggunakan teknik yang sama yang juga ditemukan .

Cobalah online!

Penjelasan:

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

mengimplementasikan solusi Stewie Griffin di R, sayangnya, ide awal saya 50% lebih lama! masih membaca daftar dari stdin, tetapi sekarang mengembalikan vektor numerik yang jauh lebih mudah dibaca.

Cobalah online!

implementasi lama:

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

membaca dalam daftar dari stdin. Indeks negatif l[-x]mengecualikan elemen dari daftar, dan match(l,l)mengembalikan indeks kemunculan pertama dari setiap elemen daftar. Mengembalikan daftar.

Python 2, 51 byte

Saya tahu sudah ada solusi Python yang lebih baik, tetapi saya masih ingin memposting milik saya.

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

Cobalah online

Mathematica 34 Bytes

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

PowerShell , 68 59 byte

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

Cobalah online!

Saya cukup yakin itu bisa dipersingkat, saya akan terus melihatnya

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

Argumen pertama adalah array integer input. Argumen kedua adalah array integer keluaran. Argumen ketiga adalah jumlah elemen untuk kedua array.

Lihat itu berfungsi online .

Perl 6 ,  26 24  19 byte

26

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

Perhatikan bahwa ∖U + 2216 bukan \U + 5C

Cobalah

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

Cobalah

24

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

Cobalah

19

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

Cobalah

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
}

Saya menggunakan operator unicode "mewah" daripada setara dengan ascii karena mereka akan membutuhkan ruang di depan mereka sehingga mereka tidak akan diuraikan sebagai bagian dari .Bagpemanggilan metode.

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

(The 24 dan 19 byte golf terinspirasi oleh implementasi Jelly )

Clojure, 36 81 62 71 byte

Terbaru (jangan terburu-buru mengirimkan ini):

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

Cobalah online .

Aaa dan yang ini memiliki bug (62 byte), zipmap menghasilkan peta yang tidak terurut sehingga ini tidak akan menghasilkan urutan yang benar pada input yang lebih besar.

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

vsebenarnya tidak digunakan untuk apa pun tetapi ini lebih pendek dari i (keys c).

Sebelumnya pada 81 byte:

Cobalah online .

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

Cobalah online .

Sialan yang asli (36 bytes) tidak berfungsi ketika jumlah minimum diulang, [4 2 2 5]menghasilkan [2 4 4 2]karena keduanya 2s dihapus :(

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

#{i}adalah himpunan yang hanya berisi i, itu mengembalikan kebenaran untuk idan palsu untuk orang lain, yang berarti bahwa minimum dihitung dari semua angka lain dalam daftar input.

Cobalah online .

Pyth, 8 7 byte

mh.-SQ]

-1 Byte terima kasih kepada @isaacg

Cobalah!

PHP, 72 Bytes

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

Versi Online

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 adalah koleksi Int.

Kasus uji:

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)

Ini mungkin masih golf, saya tidak bisa menemukan cara yang lebih singkat untuk menghapus elemen dari daftar l diff Seq(l(i))

C #, 36 Bytes

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

Mengambil elemen (i) dan melihat elemen tanpa item saat ini untuk nilai minimal.

Sangat menyedihkan, bahwa beberapa upaya lain tidak berhasil, karena kami bekerja dengan tipe primitif, dan karena itu tidak memiliki daftar dengan referensi untuk membandingkan item dari.

PowerShell , 49 38 byte

^{-11 byte berkat mazzy}

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

Cobalah online!

Peningkatan jawaban indah Sinusoid . Menghemat 10 byte dengan menggunakan output eksplisit alih-alih membangun array. Mengindeks ke dalam array yang diurutkan ke tempat 0 (yaitu nilai terkecil) atau tempat 1 jika kondisi benar.

Perl 5, 43 byte

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

Setara dengan solusi Python. sortSayangnya Perl memiliki standar yang salah untuk angka (membutuhkan pembanding eksplisit), dan mintidak built-in, tetapi hampir menebusnya dengan submenjadi lebih pendek daripada lambda, map$_,lebih pendek dari x for x in, dan implikasi dari daftar pengembalian dan args.

Ruby, 30 byte

Untuk setiap elemen, sortir array, hapus elemen saat ini dan ambil elemen pertama dari array yang tersisa.

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

Ini adalah fungsi anonim yang dapat digunakan seperti ini:

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$=}%}

Pada dasarnya terjemahan dari algoritma xnor ke dalam CJam.

Ini adalah blok tanpa nama yang mengambil array dari stack dan meninggalkan hasilnya di stack.

Penjelasan:

{
  :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è

Port jawaban @xnor dari Python 2 .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Port jawaban @xnor dari Python 2 .

Memodifikasi array input alih-alih mengembalikan yang baru untuk menghemat byte.

Cobalah online.

Penjelasan:

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 byte

Port of xnor's Python 2 menjawab. Membutuhkan ⎕IO←0:

∧⊇⍨⊢=⌊/

Cobalah online!

Penjelasan:

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

Ini jauh lebih lama daripada entri Haskell sebelumnya, tetapi ini adalah yang pertama yang hanya melakukan perbandingan jumlah linier dan jumlah pekerjaan tambahan linier.

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

Cobalah online!

Penjelasan

!membutuhkan dua argumen: daftar minimum dan daftar kosong. Ini mengembalikan nilai minimum dalam daftar dan hasil dari pemrosesan daftar yang diberikan menggunakan minimum berjalan.

MathGolf , 9 7 byte

s_╓?m=§

Cobalah online!

Penjelasan

Pada dasarnya port jawaban 05AB1E Kevin Cruijssen, tapi saya kehilangan 2 byte karena harus melakukan sesuatu secara eksplisit.

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