Stack Overflow'taki bir sorudan ilham aldı. Buradaki başlık tamamen benim hatam.

Meydan okuma

En az iki giriş içeren pozitif tamsayıların bir listesi göz önüne alındığında, her sayıyı kendisi hariç tüm girişlerin minimum değeriyle değiştirin.

Test durumları

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

kurallar

Algoritma teorik olarak herhangi bir giriş boyutu (birden fazla) ve değerler (pozitif tamsayılar) için çalışmalıdır. Programın zaman, hafıza veya veri türleriyle sınırlı olması ve bu nedenle yalnızca belirli bir değere kadar olan numaralar için veya belirli bir değere kadar giriş boyutu için geçerli olması durumunda kabul edilir.

Herhangi bir programlama dilinde programlara veya fonksiyonlara izin verilir . Standart boşluklar yasaktır.

Giriş herhangi bir makul yoldan alınabilir ; ve herhangi bir formatta. Çıktı için aynı. Giriş ve çıkış formatları farklı olabilir.

Bayt cinsinden en kısa kod kazanır.

Jöle , 9 6 5 bayt

JḟÐ € `ị⁸Ṃ € 
ṙJṖ € Ṃ €
ṙJṖ «/ bağımsız değişken: 1D array (z)

 J [1,2,3, ..., len (z)]
amount z'yi yukarıdaki miktarların her birine göre döndür
  Array son diziyi kaldır
   «/ Azaltma [dolaylı olarak vectorized] minimum

Çevrimiçi deneyin!

Hepsini bir kerede doğrulayın! (biraz değiştirilmiş)

Eminim Dennis bunun dışında golf oynayabilir.

Nasıl çalışır

Algoritma oldukça karmaşık. Bunun ne yaptığını gözlemleyelim [4,2,2,5].

İlk olarak, Jelde etmek için kullanırız [1,2,3,4]. Jelly'in 1 indeksleme kullandığını unutmayın.

O zaman görüyoruz ṙ. İki argüman alır: bir dizi ve bir tamsayı. Diziyi, tamsayı tarafından belirtilen bir miktarda sola döndürür. Burada, solunda ve sağında ṙgöreceksiniz (bu çalışmaların eğitimde nasıl bulunabileceği hakkında daha fazla bilgi ). Jelly'te komutlar dolaylı olarak vektörleşir. Bu nedenle, bu komut sağdaki her bir öğe üzerinde gerçekleştirilecektir, bu yüzden 2D dizi oluşturalım:[4,2,2,5][1,2,3,4]

Bu nedenle, [4,2,2,5]ṙ[1,2,3,4]haline [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4]haline gelir:

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

Orijinal öğelerin son satırda olduğuna dikkat edin, çünkü o satırda sola döndükten sonra dizinin uzunluğuna eşit bir miktar döndürdük, bu nedenle Ṗbu satırın kaldırılmasında kullandığımız bu yüzden sütunlar dizinin geçerli dizinde olmayan öğeleri:

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

Aşağıdaki işlem, «/ayrıca oldukça kıvrımlıdır. İlk önce, «solda ve sağda gördüğü iki sayının asgari değerini döndürür. Örneğin, 5«3geri döner 3. Şimdi, eğer iki argüman diziler ise, o zaman yukarıda söylediğim gibi vektörleşecek. O Bu ne anlama geliyor [1,5,2,3]«[4,1,5,2]olacak [1«4,5«1,2«5,3«2]olan [1,1,2,2]. Şimdi, /bu reduce, işlemi her satıra sonuna kadar yapacağımız anlamına geliyor. Örneğin, [1,2,3,4]+/olacak ((1+2)+3)+4dizisinin toplamı olan, [1,2,3,4].

Yani, «/yeni elde ettiğimiz 2D dizisine başvurursak , şunları elde ederiz:

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

vektörizasyon nedeniyle aşağıdakilere eşdeğer olacaktır:

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

Bu, dizideki element olmadan her dizinin minimumunu hesaplar.

Python 2,41 bayt

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

Çevrimiçi deneyin!

Her eleman xiçin olup olmadığını kontrol ederiz x==min(l). Olmazsa, bu liste indeksi olarak kullanıldığında olduğu gibi Falseele alınır , en küçük elemanı verir. Aksi takdirde, aka , en küçük ikinci elemanı verir, çünkü o elemanın kendisi en küçüktür ve göz ardı edilmek zorundadır.0sorted(l)True1

Jöle , 5 bayt

=Ṃ‘ịṢ

Çevrimiçi deneyin!

Nasıl?

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

DÜZENLE:

• Nimi sayesinde -1 bayt!
• -2 bayt. Xnor'a bir teşekkür! Ve tek başıma.

ftamsayıların listesini (veya herhangi bir Ordtürde) alır ve bir liste döndürür.

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

Çevrimiçi deneyin!

fListeyi döndürürken recurses. xilk liste elemanı ve ykalanıdır. Özyinelemenin sonsuz olması nedeniyle, sonuç listesinin kesilmesi gerekiyor: fst<$>zip...ybu daha kısa bir ifade şeklidir take(length y)....

Octave, 26 bayt

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

Kullanılan benzer bir yaklaşım bu cevap , hangi ile aynı olur bu .

Gerçekten sadece diğer cevapları vermenin hayranı değilim, bu yüzden diğerlerini görmeden önce benzer bir fikrim olduğunu belirtmek isterim.

Açıklama:

Jonathan Allan, Jelly kodu için zaten iyi bir açıklama yapmıştır, bu yüzden bu Octave-bit'i ve neden çalıştığını (ve MATLAB'da çalışmadığını) kapsar.

@(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

Bu, MATLAB'da çalışmaz, çünkü satır içi atamalar ve doğrudan dizin oluşturma çalışmaz. sort(x)(1)sıralanmış vektördeki ilk öğe değil MATLAB'da bir hata verir.

Haskell, 41 bayt

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

Kullanım örneği: ([]#) [4,3,2,5]-> [2,2,3,2]. Çevrimiçi deneyin!

Boş bir akü ile başlayın ave giriş listesini çalıştırın. Çıkış listesindeki bir sonraki eleman, akümülatörün minimum ave giriş listesinin ilk elemanı (-> c) hariç, tümü akümülatöre beklenen ilk eleman ile tekrarlamalı bir çağrıdır ve c. Giriş listesinin sonuna ulaştığınızda durun.

JavaScript (ES6), 50 46 bayt

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

Düzenleme: @Arnauld sayesinde 4 bayt kaydedildi.

Brachylog , 13 12 bayt

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

Çevrimiçi deneyin!

@ Ais523 sayesinde bir bayt kaydedildi.

açıklama

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

⊇Alt kümeleri en büyüğünden en küçüğüne birleştiren gerçeğinden yararlanıyoruz . Örneğin [1,2,3], aldığımız alt kümeler şu sıradadır:[1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], [] .

Alt kümelerin [1,2], [1,3], [2,3]minimum olmasını istediklerimiz olduğunu, ancak giriş listesine kıyasla ters sırada olduğunu görebiliriz (dolayısıyla ↔). Bu altkümeleri yalnızca length(Input) + 1hepsini içerecek ilk altkümeleri bularak seçebiliriz - önce tüm listeyi. Tüm listeyi ile atıyoruz b.

Aslında , 13 bayt

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

Xnor'ın da keşfettiği aynı tekniği kullanır .

Çevrimiçi deneyin!

Açıklama:

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

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

Stewie Griffin'nin R, ne yazık ki çözümünü uyguladı , benim orijinal fikrim% 50 daha uzun! yine de listeyi stdin'den okur, ancak şimdi çok daha okunaklı bir sayısal vektör döndürür.

Çevrimiçi deneyin!

eski uygulama:

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

stdin'den gelen listede okur. Negatif bir dizin l[-x], öğeyi listeden çıkarır ve listedeki match(l,l)her öğenin ilk oluşumunun dizinini döndürür. Bir liste döndürür.

Python 2, 51 bayt

Daha iyi bir Python çözümü olduğunu biliyorum, ama yine de benimkini göndermek istiyorum.

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

Çevrimiçi deneyin

Mathematica 34 Bayt

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

PowerShell , 68 59 bayt

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

Çevrimiçi deneyin!

Kısaltılabileceğine oldukça eminim, bakmaya devam edeceğim

C, 85 bayt

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

İlk argüman giriş tamsayı dizisidir. İkinci argüman çıkış tamsayı dizisidir. Üçüncü argüman her iki dizi için element sayısıdır.

Çevrimiçi çalıştığını görün .

Perl 6 ,  26 24  19 bayt

26

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

Not ∖U + 2216 değil\ U + 5C

Dene

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

Dene

24

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

Dene

19

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

Dene

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
}

"Fantezi" unicode operatörlerini kullandımAscii eşdeğerleri yerine çünkü önlerinde bir boşluğa ihtiyaç duyuyorlardı, böylece .Bagyöntem çağrısının bir parçası olarak ayrıştırılmayacaklardı .

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 ve 19 bayt golf bir Jelly uygulamasından ilham almıştır )

Clojure, 36 81 62 71 bayt

En yeni (bunları gerçekten aceleyle göndermemelisiniz):

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

Çevrimiçi deneyin .

Aaa ve bunun bir böceği (62 bayt) var, zipmap sıralanmamış bir harita oluşturur, böylece daha büyük girdilerde doğru sırayı üretmez.

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

vaslında hiçbir şey için kullanılmaz, ancak bu daha kısadır i (keys c).

81 byte'ta önceki:

Çevrimiçi deneyin .

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

Çevrimiçi deneyin .

Ah lanet orijinal (36 bayt) en az sayıda tekrarlanır zaman çalışmaz [4 2 2 5]sonuçları [2 4 4 2]hem de 2in kaldırılır :(

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

#{i}sadece içeren settir, başkaları iiçin aldatma ive sahte olur, yani asgari giriş listesindeki diğer tüm numaralardan hesaplanır.

Çevrimiçi deneyin .

Pyth, 8 7 bayt

mh.-SQ]

@İsaacg sayesinde -1 Bayt

Dene!

PHP, 72 Bayt

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

Çevrimiçi sürüm

PHP, 47 bayt

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

Scala, 37 bayt

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

l Int herhangi bir koleksiyonudur.

Test durumları:

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)

Bu muhtemelen hala golf olabilir, bir öğeyi listeden çıkarmak için daha kısa bir yol bulamadım. l diff Seq(l(i))

C #, 36 Bayt

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

Elemanları (i) alır ve minimum değer için mevcut öğeye sahip olmayan elemanlara bakar.

İlkel türlerle çalıştığımız için bazı diğer girişimlerin işe yaramaması ve bu nedenle öğeleri karşılaştırmak için referansları olan listelerin olmaması biraz üzücü.

PowerShell , 49 38 bayt

^{Mazzy sayesinde -11 bayt}

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

Çevrimiçi deneyin!

Sinusoid'in güzel cevabının iyileştirilmesi . Bir dizi oluşturmak yerine açık çıktı kullanarak 10 bayt kazandırır. Sıralı diziye, koşullu doğruysa spot 0 (yani en küçük değer) veya spot 1 olarak dizine ekler.

Perl 5, 43 bayt

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

Python çözümüne eşdeğerdir. Perl sortne yazık ki sayılar için yanlış bir varsayılan değere sahiptir (açık bir karşılaştırıcı gerektirir) ve minyerleşik değildir, ancak geri dönüş ve argüman listelerinin ima edilmesinden daha kısa , subkısa olmak ve sonuçlandırmak için neredeyse telafi eder.lambdamap$_,x for x in

Yakut, 30 bayt

Her öğe için diziyi sıralayın, geçerli öğeyi kaldırın ve kalan dizinin ilk öğesini alın.

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

Bu şekilde kullanılabilecek isimsiz bir fonksiyondur:

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

CJam, 15 bayt

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

Temel olarak xnor algoritmasının CJam'a çevrilmesi.

Bu, bir diziyi yığından alan ve sonucu yığında bırakan adsız bir bloktur.

Açıklama:

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

{sWQè

Limanı @xnor 'Python 2 cevap s .

Çevrimiçi deneyin ya da tüm test durumlarını doğrulayın .

Açıklama:

{        # 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 bayt

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 @xnor 'Python 2 cevap s .

Girdileri kaydetmek için yenisini döndürmek yerine girdi dizisini değiştirir.

Çevrimiçi deneyin.

Açıklama:

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 Genişletilmiş) , 7 bayt

Xnor'ın Python 2 cevabı limanı. Gerektirir ⎕IO←0:

∧⊇⍨⊢=⌊/

Çevrimiçi deneyin!

Açıklama:

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

Bu, önceki Haskell girişlerinden çok daha uzundur, ancak yalnızca doğrusal sayıda karşılaştırma ve doğrusal miktarda ek iş yapan ilk kişidir.

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

Çevrimiçi deneyin!

açıklama

!iki argüman alır: çalışan bir asgari ve boş bir liste. Listedeki en düşük değeri ve verilen en düşük değeri kullanarak verilen listenin işlenmesinin sonucunu döndürür.

MathGolf , 9 7 bayt

s_╓?m=§

Çevrimiçi deneyin!

açıklama

Temelde Kevin Cruijssen'in 05AB1E cevabının limanı, ancak her şeyi açıkça yapmak zorunda kaldığım için 2 bayt kaybediyorum.

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