Zainspirowany pytaniem w Stack Overflow. Tytuł tutaj jest całkowicie moją winą.

Wyzwanie

Biorąc pod uwagę listę dodatnich liczb całkowitych zawierających co najmniej dwa wpisy, zamień każdą liczbę na minimum wszystkich wpisów oprócz samego siebie.

Przypadki testowe

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

Zasady

Algorytm powinien teoretycznie działać dla dowolnego rozmiaru wejściowego (większego niż jeden) i wartości (dodatnie liczby całkowite). Jest to akceptowane, jeśli program jest ograniczony czasem, pamięcią lub typami danych i dlatego działa tylko dla liczb do określonej wartości lub dla wielkości wejściowej do określonej wartości.

Programy lub funkcje są dozwolone w dowolnym języku programowania . Standardowe luki są zabronione.

Dane wejściowe można przyjmować dowolnymi rozsądnymi środkami ; i w dowolnym formacie. To samo dla wyniku. Formaty wejściowe i wyjściowe mogą być różne.

Najkrótszy kod w bajtach wygrywa.

Galaretka , 9 6 5 bajtów

J ị⁸Ṃ € 
ṙ JṖ € Ṃ €
ṙJṖ «/ argument: tablica 1D (z)

 J [1,2,3, ..., len (z)]
ṙ obróć z o każdą z powyższych wartości (bieżąca tablica to 2D)
  Ṗ usuń ostatnią tablicę
   «/ Redukuj o minimum [implicitely vectorized]

Wypróbuj online!

Zweryfikuj je wszystkie naraz! (lekko zmieniony)

Jestem prawie pewien, że Dennis może to prześcignąć w golfa.

Jak to działa

Algorytm jest raczej skomplikowany. Zauważmy, co to robi [4,2,2,5].

Po pierwsze, używamy Jdo uzyskania [1,2,3,4]. Zauważ, że Jelly używa indeksowania 1.

Potem widzimy ṙ. Wymaga dwóch argumentów: tablicy i liczby całkowitej. Obraca tablicę w lewo o wartość określoną przez liczbę całkowitą. Tutaj ṙzobaczysz [4,2,2,5]po lewej i [1,2,3,4]po prawej stronie (więcej o tym, jak to działa, można znaleźć w samouczku ). W Galaretce polecenia domyślnie wektoryzują. Dlatego to polecenie zostanie wykonane na każdym pojedynczym elemencie po prawej stronie, dlatego utworzymy tablicę 2D:

Dlatego [4,2,2,5]ṙ[1,2,3,4]staje się [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], co staje się:

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

Zauważ, że oryginalne elementy znajdują się w ostatnim rzędzie, ponieważ w tym rzędzie obróciliśmy w lewo o kwotę równą długości tablicy, dlatego używamy Ṗobok, aby usunąć ten wiersz, aby kolumny były kolekcjami elementy tablicy, które nie są w bieżącym indeksie:

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

Następująca operacja «/jest również dość skomplikowana. Po pierwsze, «zwraca minimum dwóch liczb, które widzi po lewej i po prawej stronie. Na przykład 5«3zwraca 3. Teraz, jeśli dwa argumenty są tablicami, wówczas wektoryzowałby, jak powiedziałem powyżej. Co to oznacza, że [1,5,2,3]«[4,1,5,2]stanie się, [1«4,5«1,2«5,3«2]co jest [1,1,2,2]. Teraz /jest reduce, co oznacza, że ​​wykonujemy operację nad każdym rzędem do końca. Na przykład [1,2,3,4]+/stałoby się ((1+2)+3)+4, co jest sumą tablicy [1,2,3,4].

Tak więc, jeśli zastosujemy się «/do otrzymanej właśnie tablicy 2D, otrzymalibyśmy:

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

co z powodu wektoryzacji byłoby równoważne z:

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

która oblicza minimum każdej tablicy bez elementu w indeksie.

Python 2 , 41 bajtów

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

Wypróbuj online!

Dla każdego elementu xsprawdzamy, czy x==min(l). Jeśli nie, to jest Falseto traktowane tak, jakby było 0używane jako indeks listy do sorted(l), dając najmniejszy element. W przeciwnym razie jest to Trueaka 1, podając drugi najmniejszy element, ponieważ sam ten element jest najmniejszy i należy go zignorować.

Galaretka , 5 bajtów

=Ṃ‘ịṢ

Wypróbuj online!

W jaki sposób?

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

EDYTOWAĆ:

• -1 bajt dzięki dzięki!
• -2 bajty. Jedno dzięki xnor! I jeden sam.

fpobiera listę liczb całkowitych (lub dowolnego Ordtypu) i zwraca listę.

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

Wypróbuj online!

fpowtarza się podczas obracania listy. xjest pierwszym elementem listy i yresztą. Ponieważ rekurencja jest nieskończona, lista wyników musi zostać odcięta: fst<$>zip...yjest to krótszy sposób powiedzenia take(length y)....

Oktawa, 26 bajtów

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

Podobne podejście stosowane w tej odpowiedzi , co zdarza się być taka sama, jak ta .

Naprawdę nie jestem fanem tylko przenoszenia innych odpowiedzi, dlatego chciałbym zauważyć, że miałem podobny pomysł, zanim zobaczyłem inne.

Wyjaśnienie:

Jonathan Allan przedstawił już dobre wyjaśnienie kodu Jelly, więc obejmuje on bit Octave i dlaczego działa (i nie działa w 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

Nie działa to w MATLAB, ponieważ przypisania wbudowane i bezpośrednie indeksowanie nie działają. sort(x)(1)podaje błąd w MATLAB, a nie pierwszy element w posortowanym wektorze.

Haskell, 41 bajtów

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

Przykład użycia: ([]#) [4,3,2,5]-> [2,2,3,2]. Wypróbuj online!

Zacznij od pustego akumulatora ai spuść listę wejść. Kolejnym elementem na liście wyjściowej jest minimum akumulatora ai wszystkie oprócz pierwszego elementu listy wejściowej (-> c), a następnie wywołanie rekurencyjne z pierwszym elementem bdodanym do akumulatora i c. Zatrzymaj się, gdy dojdziesz do końca listy wprowadzania.

JavaScript (ES6), 50 46 bajtów

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

Edycja: Zapisano 4 bajty dzięki @Arnauld.

Brachylog , 13 12 bajtów

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

Wypróbuj online!

Zapisano jeden bajt dzięki @ ais523.

Wyjaśnienie

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

Wykorzystujemy fakt, że ⊇łączy podzbiory od największych do najmniejszych. Na przykład [1,2,3], możemy uzyskać te podzbiory są w następującej kolejności: [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], [].

Widzimy, że podzbiory [1,2], [1,3], [2,3]są tymi, od których chcemy minimum, ale są w odwrotnej kolejności niż lista wejściowa (stąd ↔). Możemy wybrać te podzbiory tylko poprzez znalezienie pierwszych length(Input) + 1podzbiorów, które będą zawierały wszystkie z nich + najpierw całą listę. Odrzucamy całą listę za pomocą b.

Właściwie 13 bajtów

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

Używa tej samej techniki, którą odkrył także Xnor .

Wypróbuj online!

Wyjaśnienie:

;;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 bajtów

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

wdraża rozwiązanie Stewie Griffin w R, niestety mój oryginalny pomysł jest o 50% dłuższy! nadal czyta listę ze standardowego wejścia, ale teraz zwraca znacznie czytelniejszy wektor numeryczny.

Wypróbuj online!

stara implementacja:

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

czyta na liście ze standardowego wejścia. Indeks ujemny l[-x]wyklucza element z listy i match(l,l)zwraca indeks pierwszego wystąpienia każdego elementu listy. Zwraca listę.

Python 2, 51 bajtów

Wiem, że istnieje już lepsze rozwiązanie w języku Python, ale nadal chcę publikować moje.

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

Wypróbuj online

Mathematica 34 bajtów

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

PowerShell , 68 59 bajtów

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

Wypróbuj online!

Jestem pewien, że można go skrócić, będę nadal na niego patrzeć

C, 85 bajtów

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

Pierwszym argumentem jest wejściowa tablica liczb całkowitych. Drugi argument to wyjściowa tablica liczb całkowitych. Trzecim argumentem jest liczba elementów dla obu tablic.

Zobacz, jak działa online .

Perl 6 ,  26 24  19 bajtów

26

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

Pamiętaj, że to ∖U + 2216, a nie \U + 5C

Spróbuj

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

Spróbuj

24

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

Spróbuj

19

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

Spróbuj

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
}

Użyłem „fantazyjnych” operatorów Unicode zamiast ekwiwalentów ascii, ponieważ wymagałyby spacji przed nimi, aby nie zostały przeanalizowane jako część .Bagwywołania metody.

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 i 19-bajtowe golfy zostały zainspirowane wdrożeniem Jelly )

Clojure, 36 81 62 71 bajtów

Najnowszy (nie powinien tak naprawdę przesyłać ich w pośpiechu):

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

Wypróbuj online .

Aaa, a ten ma błąd (62 bajty), zipmap tworzy nieuporządkowaną mapę, więc nie będzie generować prawidłowej sekwencji przy większych wejściach.

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

vnie jest właściwie używany do niczego, ale jest to krótszy niż i (keys c).

Poprzednio w 81 bajtach:

Wypróbuj online .

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

Wypróbuj online .

Cholera, oryginalny (36 bajtów) nie działa, gdy minimalna liczba jest powtarzana, [4 2 2 5]powoduje to, [2 4 4 2]że oba 2s są usuwane :(

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

#{i}jest zbiorem, który zawiera tylko i, zwraca prawdę dla ii fałsz dla innych, co oznacza, że ​​minimum jest obliczane na podstawie wszystkich innych liczb na liście danych wejściowych.

Wypróbuj online .

Pyth, 8 7 bajtów

mh.-SQ]

-1 bajtów dzięki @isaacg

Spróbuj!

PHP, 72 bajty

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

Wersja online

PHP, 47 bajtów

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

Scala, 37 bajtów

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

l jest dowolną kolekcją Int.

Przypadki testowe:

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)

Prawdopodobnie można to jeszcze pograć w golfa, nie mogłem znaleźć krótszego sposobu na usunięcie elementu z listy niż l diff Seq(l(i))

C #, 36 bajtów

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

Bierze elementy (i) i przegląda elementy bez bieżącego elementu pod kątem minimalnej wartości.

To trochę smutne, że niektóre inne próby nie działają, ponieważ pracujemy z prymitywnymi typami, a zatem nie mamy list z referencjami do porównania elementów.

PowerShell , 49 38 bajtów

^{-11 bajtów dzięki mazzy}

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

Wypróbuj online!

Poprawiona piękna odpowiedź Sinusoidy . Zapisuje 10 bajtów, używając jawnego wyjścia zamiast budowania tablicy. Indeksuje do posortowanej tablicy w celu znalezienia 0 (tj. Najmniejszej wartości) lub 1, jeśli warunek jest prawdziwy.

Perl 5, 43 bajtów

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

Odpowiednik rozwiązania Python. sortNiestety , Perl ma niewłaściwe ustawienie domyślne liczb (wymagające jawnego komparatora) i minnie jest wbudowane, ale prawie to subrekompensuje, będąc krótszym niż lambda, map$_,będąc krótszym niż x for x in, oraz niejawnością list powrotu i argumentów.

Rubinowy, 30 bajtów

Dla każdego elementu posortuj tablicę, usuń bieżący element i chwyć pierwszy element pozostałej tablicy.

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

Jest to anonimowa funkcja, której można użyć w następujący sposób:

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

CJam, 15 bajtów

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

Zasadniczo tłumaczenie algorytmu xnor na CJam.

Jest to nienazwany blok, który pobiera tablicę ze stosu i pozostawia wynik na stosie.

Wyjaśnienie:

{
  :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 bajtów

{sWQè

Port odpowiedzi @xnor na Python 2 .

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

{        # 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 bajtów

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 odpowiedzi @xnor na Python 2 .

Zmienia tablicę wejściową zamiast zwracać nową, aby zapisać bajty.

Wypróbuj online.

Wyjaśnienie:

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 bajtów

Odpowiedź portu Python 2 na port xnor. Wymaga ⎕IO←0:

∧⊇⍨⊢=⌊/

Wypróbuj online!

Wyjaśnienie:

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

Jest to znacznie dłużej niż wcześniejsze wpisy Haskella, ale jest to pierwszy, który wykonuje tylko liniową liczbę porównań i liniową ilość dodatkowej pracy.

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

Wypróbuj online!

Wyjaśnienie

!przyjmuje dwa argumenty: bieżące minimum i niepustą listę. Zwraca minimalną wartość z listy i wynik przetwarzania podanej listy przy użyciu działającego minimum.

MathGolf , 9 7 bajtów

s_╓?m=§

Wypróbuj online!

Wyjaśnienie

Zasadniczo port odpowiedzi 05AB1E Kevina Cruijssena, ale tracę 2 bajty, ponieważ muszę robić rzeczy wyraźnie.

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