Inspiriert von einer Frage bei Stack Overflow. Der Titel hier ist ganz und gar meine Schuld.

Die Herausforderung

Ersetzen Sie bei einer Liste positiver Ganzzahlen mit mindestens zwei Einträgen jede Zahl durch das Minimum aller Einträge, die sich selbst ausschließen.

Testfälle

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

Regeln

Der Algorithmus sollte theoretisch für alle Eingabegrößen (größer als eins) und Werte (positive ganze Zahlen) funktionieren. Es wird akzeptiert, wenn das Programm durch Zeit, Speicher oder Datentypen begrenzt ist und daher nur für Zahlen bis zu einem bestimmten Wert oder für Eingabegrößen bis zu einem bestimmten Wert funktioniert.

Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.

Die Eingabe kann auf jede vernünftige Weise erfolgen . und mit jedem Format. Gleiches gilt für die Ausgabe. Eingabe- und Ausgabeformate können unterschiedlich sein.

Kürzester Code in Bytes gewinnt.

Jelly , 9 6 5 Bytes

J € `ị⁸Ṃ € 
ṙJṙ € Ṃ €
ṙJṙ «/ Argument: 1D-Array (z)

 J [1,2,3, ..., len (z)]
ṙ Drehe z um jeden der oben genannten Beträge (aktuelles Array ist 2D)
  Ṗ Entfernen Sie das letzte Array
   «/ Um ein [implizit vektorisiertes] Minimum reduzieren

Probieren Sie es online!

Überprüfen Sie alle auf einmal! (leicht verändert)

Ich bin mir ziemlich sicher, dass Dennis das übertreiben kann.

Wie es funktioniert

Der Algorithmus ist ziemlich kompliziert. Beobachten wir, was dies bewirkt [4,2,2,5].

Erstens verwenden wir Jzu erhalten [1,2,3,4]. Beachten Sie, dass Jelly die 1-Indexierung verwendet.

Dann sehen wir ṙ. Es werden zwei Argumente benötigt: ein Array und eine Ganzzahl. Das Array wird um den durch die Ganzzahl angegebenen Betrag nach links gedreht. Hier ṙsehen Sie [4,2,2,5]links und [1,2,3,4]rechts (mehr dazu im Tutorial ). In Jelly werden Befehle implizit vektorisiert. Daher wird dieser Befehl für jedes einzelne Element auf der rechten Seite ausgeführt, weshalb wir ein 2D-Array erstellen würden:

Daher [4,2,2,5]ṙ[1,2,3,4]wird [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], was wird:

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

Beachten Sie, dass sich die ursprünglichen Elemente in der letzten Zeile befinden, da wir in dieser Zeile um einen Betrag nach links gedreht haben, der der Länge des Arrays entspricht. Aus diesem Grund Ṗentfernen wir als Nächstes diese Zeile, sodass die Spalten die Auflistungen von sind Die Elemente des Arrays, die sich nicht am aktuellen Index befinden:

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

Die folgende Operation «/ist ebenfalls ziemlich kompliziert. Erstens wird «das Minimum der beiden links und rechts angezeigten Zahlen zurückgegeben. Zum Beispiel 5«3kehrt zurück 3. Wenn nun die beiden Argumente Arrays sind, würde es vektorisieren, wie ich oben gesagt habe. Was das heißt es [1,5,2,3]«[4,1,5,2]würde das werden [1«4,5«1,2«5,3«2]was ist [1,1,2,2]. Nun /ist reduce, was bedeutet , dass wir den Betrieb über jede Zeile bis zum Ende tun. Zum Beispiel [1,2,3,4]+/würde werden ((1+2)+3)+4, was die Summe des Arrays ist [1,2,3,4].

Wenn wir also «/auf das gerade erhaltene 2D-Array anwenden , erhalten wir:

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

was aufgrund der Vektorisierung äquivalent wäre zu:

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

Dies berechnet das Minimum jedes Arrays ohne das Element am Index.

Python 2 , 41 Bytes

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

Probieren Sie es online!

Für jedes Element xprüfen wir, ob x==min(l). Wenn nicht, wird Falsedies so behandelt, als würde 0es als Listenindex verwendet sorted(l), um das kleinste Element zu erhalten. Ansonsten ist es Trueauch bekannt als 1das zweitkleinste Element geben, denn das Element selbst kleinste ist und sollte ignoriert werden.

Gelee , 5 Bytes

=Ṃ‘ịṢ

Probieren Sie es online!

Wie?

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

BEARBEITEN:

• -1 Byte danke an nimi!
• -2 Bytes. Ein Dank an xnor! Und einer von mir.

fNimmt eine Liste von ganzen Zahlen (oder einen beliebigen OrdTyp) und gibt eine Liste zurück.

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

Probieren Sie es online!

frekursiv beim Drehen der Liste. xist das erste Listenelement und yder Rest. Da die Rekursion unendlich ist, zu die Ergbnisse Bedürfnisse abgeschnitten werden: fst<$>zip...yist eine kürzere Art zu sagen take(length y)....

Oktave, 26 Bytes

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

Ein ähnlicher Ansatz wie in verwendet diese Antwort , die die gleiche wie sein geschieht dies .

Ich bin nicht wirklich ein Fan davon, nur andere Antworten zu portieren. Deshalb möchte ich bemerken, dass ich eine ähnliche Idee hatte, bevor ich die anderen sah.

Erläuterung:

Jonathan Allan hat bereits eine gute Erklärung für den Jelly-Code geliefert, daher wird hier das Octave-Bit behandelt und warum es funktioniert (und in MATLAB nicht funktioniert).

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

Dies funktioniert in MATLAB nicht, da Inline-Zuweisungen und direkte Indizierung nicht funktionieren. sort(x)(1)gibt einen Fehler in MATLAB aus, nicht das erste Element im sortierten Vektor.

Haskell, 41 Bytes

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

Anwendungsbeispiel: ([]#) [4,3,2,5]-> [2,2,3,2]. Probieren Sie es online!

Beginnen Sie mit einem leeren Akku aund durchsuchen Sie die Eingabeliste. Das nächste Element in der Ausgabeliste ist das Minimum des Akkumulators aund alle bis auf das erste Element der Eingabeliste (-> c), gefolgt von einem rekursiven Aufruf, wobei das erste Element bzum Akkumulator und hinzugefügt wird c. Stoppen Sie, wenn Sie das Ende der Eingabeliste erreicht haben.

JavaScript (ES6), 50 46 Bytes

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

Bearbeiten: 4 Bytes dank @Arnauld gespeichert.

Brachylog , 13 12 Bytes

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

Probieren Sie es online!

1 Byte dank @ ais523 gespeichert.

Erläuterung

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

Wir nutzen die Tatsache, dass ⊇Teilmengen von den größten zu den kleinsten vereinheitlicht werden. Zum Beispiel für [1,2,3]sind die Untergruppen erhalten wir in dieser Reihenfolge: [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], [].

Wir können sehen, dass es sich bei den Teilmengen [1,2], [1,3], [2,3]um die handelt, von denen wir das Minimum wollen, sie sind jedoch in umgekehrter Reihenfolge im Vergleich zur Eingabeliste (daher die ↔). Wir können diese Untergruppen nur auswählen, indem wir die ersten length(Input) + 1Untergruppen suchen , die alle + die gesamte Liste zuerst enthalten. Wir verwerfen die gesamte Liste mit b.

Eigentlich 13 Bytes

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

Verwendet die gleiche Technik, die auch xnor entdeckt hat .

Probieren Sie es online!

Erläuterung:

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

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

implementiert Stewie Griffins Lösung in R, leider ist meine ursprüngliche Idee 50% länger! Liest immer noch die Liste von stdin, gibt aber jetzt einen viel besser lesbaren numerischen Vektor zurück.

Probieren Sie es online!

alte Implementierung:

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

liest in der liste von stdin. Ein negativer Index l[-x]schließt das Element aus der Liste aus und match(l,l)gibt den Index des ersten Vorkommens jedes Elements der Liste zurück. Gibt eine Liste zurück.

Python 2, 51 Bytes

Ich weiß, dass es bereits eine bessere Python-Lösung gibt, aber ich möchte noch meine veröffentlichen.

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

Probieren Sie es online aus

Mathematica 34 Bytes

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

PowerShell , 68 bis 59 Byte

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

Probieren Sie es online!

Ich bin ziemlich zuversichtlich, dass es verkürzt werden kann, ich werde es weiter untersuchen

C 85 Bytes

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

Das erste Argument ist das ganzzahlige Eingabearray. Das zweite Argument ist das Ausgabe-Integer-Array. Das dritte Argument ist die Anzahl der Elemente für beide Arrays.

Sehen Sie , wie es online funktioniert .

Perl 6 ,  26 24  19 Bytes

26

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

Beachten Sie, dass ∖U + 2216 nicht \U + 5C ist

Versuch es

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

Versuch es

24

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

Versuch es

19

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

Versuch es

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
}

Ich habe die "ausgefallenen" Unicode- Operatoren anstelle der ASCII-Entsprechungen verwendet, da sie vor sich ein Leerzeichen benötigt hätten, damit sie nicht als Teil des .BagMethodenaufrufs analysiert würden .

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

(Die 24- und 19-Byte-Golfplätze wurden von einer Jelly- Implementierung inspiriert. )

Clojure, 36 81 62 71 Bytes

Neueste (sollte nicht wirklich in Eile einreichen):

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

Probieren Sie es online aus .

Aaaund dieses hat einen Fehler (62 Bytes), zipmap erzeugt eine ungeordnete Karte, so dass dies bei größeren Eingaben nicht die richtige Reihenfolge ergibt.

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

vwird eigentlich für nichts verwendet, ist aber kürzer als i (keys c).

Vorher bei 81 Bytes:

Probieren Sie es online aus .

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

Probieren Sie es online aus .

Oh Teufel mit dem Original (36 Bytes) funktioniert nicht, wenn die minimale Anzahl wiederholt wird, [4 2 2 5]ergibt sich , [2 4 4 2]da beide 2s entfernt werden :(

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

#{i}ist die Menge, die nur enthält i. Sie gibt ifür andere die Wahrheit und für andere die Falschheit zurück, was bedeutet, dass das Minimum aus allen anderen Zahlen in der Eingabeliste berechnet wird.

Probieren Sie es online aus .

Pyth, 8 7 Bytes

mh.-SQ]

-1 Byte dank @isaacg

Versuch es!

PHP, 72 Bytes

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

Online Version

PHP, 47 Bytes

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

Scala, 37 Bytes

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

l ist eine Sammlung von Int.

Testfälle:

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)

Dies kann wahrscheinlich immer noch gespielt werden. Ich konnte keinen kürzeren Weg finden, um ein Element aus einer Liste zu entfernen als l diff Seq(l(i))

C #, 36 Bytes

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

Nimmt die Elemente (i) und sucht in den Elementen ohne das aktuelle Element nach dem Minimalwert.

Es ist irgendwie traurig, dass einige andere Versuche nicht funktionieren, da wir mit primitiven Typen arbeiten und daher keine Listen mit Referenzen zum Vergleichen der Elemente von haben.

PowerShell , 49 38 Bytes

^{-11 bytes dank mazzy}

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

Probieren Sie es online!

Verbesserung der schönen Antwort von Sinusoid . Spart 10 Bytes, indem explizite Ausgaben verwendet werden, anstatt ein Array zu erstellen. Indiziert in das sortierte Array entweder Punkt 0 (dh kleinster Wert) oder Punkt 1, wenn die Bedingung wahr ist.

Perl 5, 43 Bytes

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

Entspricht der Python-Lösung. Perls hat sortleider die falsche Standardeinstellung für Zahlen (die einen expliziten Komparator erfordert) und minist nicht integriert, macht dies aber fast wett, indem subes kürzer als lambda, map$_,kürzer als x for x inund implizit aus Return- und Args-Listen besteht.

Ruby, 30 Bytes

Sortieren Sie für jedes Element das Array, entfernen Sie das aktuelle Element und greifen Sie auf das erste Element des verbleibenden Arrays zu.

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

Es ist eine anonyme Funktion, die folgendermaßen verwendet werden kann:

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

CJam, 15 Bytes

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

Im Wesentlichen eine Übersetzung von xnors Algorithmus in CJam.

Dies ist ein unbenannter Block, der ein Array aus dem Stapel entnimmt und das Ergebnis im Stapel belässt.

Erläuterung:

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

{sWQè

Port von @xnors Python 2 Antwort .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

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 von @xnors Python 2 Antwort .

Ändert das Eingabe-Array, anstatt ein neues zurückzugeben, um Bytes zu sparen.

Probieren Sie es online aus.

Erläuterung:

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 Bytes

Port of Xnors Python 2 Antwort. Benötigt ⎕IO←0:

∧⊇⍨⊢=⌊/

Probieren Sie es online!

Erläuterung:

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

Dies ist erheblich länger als die früheren Haskell-Einträge, aber es ist das erste, das nur eine lineare Anzahl von Vergleichen und eine lineare Menge zusätzlicher Arbeit ausführt.

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

Probieren Sie es online!

Erläuterung

!benötigt zwei Argumente: ein laufendes Minimum und eine nicht leere Liste. Es gibt den Mindestwert in der Liste und das Ergebnis der Verarbeitung der angegebenen Liste unter Verwendung des laufenden Mindestwerts zurück.

MathGolf , 9 7 Bytes

s_╓?m=§

Probieren Sie es online!

Erläuterung

Im Grunde genommen eine Portierung von Kevin Cruijssens 05AB1E-Antwort, aber ich verliere 2 Bytes, weil ich Dinge explizit tun muss.

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