Bewegliches bescheidenes Minimum

40

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.

Luis Mendo
quelle
Was soll [4 3 2 2 5]ausgegeben werden?
Kritixi Lithos
@KritixiLithos hat der zweite Testfall dies nicht abgedeckt?
Undichte Nonne
@KritixiLithos Für die Eingabe wäre [4 3 2 2 5]die Ausgabe [2 2 2 2 2](dies ist ähnlich wie im zweiten Testfall)
Luis Mendo
Oh, ich habe den zweiten Testfall verpasst. Aber jetzt verstehe ich, wie es funktioniert
Kritixi Lithos
@ LuisMendo Sie haben "Ganzzahl" in "Eingabegröße und Werte beliebig" geändert. Bedeutet das, dass wir alle reellen Zahlen berücksichtigen müssen?
Undichte Nonne

Antworten:

19

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.

Undichte Nonne
quelle
1
Oh, deine Bearbeitung ... du bist zuerst dort angekommen.
Jonathan Allan
1
@ JonathanAllan Es tut mir leid.
Undichte Nonne
40

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.

xnor
quelle
2
Es fällt mir schwer zu glauben, dass dies funktioniert.
Undichte Nonne
2
Toller Ansatz!
Luis Mendo
Könnten Sie eine Erklärung hinzufügen? Es wäre nicht sehr kompliziert, aber der Trick "Jede Zahl wird das Minimum sein, mit Ausnahme derjenigen, die das Minimum ist, das das zweitkleinste sein wird" und die Tatsache, dass Falsekonvertiert wird 0und Truekonvertiert wird, 1sind wirklich cool und sollte prahlen über ^ W ^ Wexplained
Nic Hartley
18

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]
Jonathan Allan
quelle
4
@LeakyNun Dies ist kein Port, es ist nur die gleiche Methode, ich suche immer noch nach weniger ... Ich habe diese Antwort jetzt auch upvoted :)
Jonathan Allan
5
@LeakyNun Ich bin neu hier, aber bist du immer so feindlich? Es ist nicht so, dass es Unmengen einzigartiger Möglichkeiten gibt, dies zu erreichen. Auch wenn er es portiert hat, hat er immer noch die kürzere Antwort.
Grayson Kent
3
@GraysonKent Ich entschuldige mich für meine empfundene Feindseligkeit.
Undichte Nonne
1
@GraysonKent Willkommen bei PPCG!
Luis Mendo
1
@LeakyNun Dies geschieht häufig bei einfacheren Herausforderungen. Man kann nicht wirklich sagen, dass jede Antwort ein Port für jeden anderen ist
ASCII-
12

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

Ørjan Johansen
quelle
1
Sie können über durch die Benennung der gesamten Eingabeliste ein Byte speichern @und die Listen Flip sein Reißverschluss: f l@(x:y)=fst<$>zip(minimum...)l.
Nimi
1
f(h:t)=minimum t:(fst<$>zip(f(t++[h]))t)
Xnor
9

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.

Stewie Griffin
quelle
8

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.

nimi
quelle
7

JavaScript (ES6), 50 46 Bytes

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

Bearbeiten: 4 Bytes dank @Arnauld gespeichert.

Neil
quelle
a=>a.map(x=>Math.min(...a.filter(y=>x!=y)))für 43 Bytes.
Shaggy
@ Shaggy Ich glaube nicht, dass das für einen Eingang wie3,3,3,3
Arnauld
D'oh! Nein, es funktioniert nicht, wenn der Mindestwert zwei oder mehr Mal vorkommt.
Shaggy
1
Sie können jedoch a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))für 46 tun .
Arnauld
@ Arnauld Sehr schlau, danke!
Neil
7

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.

Tödlich
quelle
1
Sie können ein Byte speichern, indem Sie Ihre "findall subset + minimum" in "findall subset" und "map minimum" aufteilen. (Ich muss dies dem Thread mit den Brachylog-Tipps hinzufügen, jetzt hast du mich daran erinnert.)
1
@ ais523 Danke, ich vergesse immer diesen Trick ...
Fatalize
6

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
Mego
quelle
1
Sie haben uns immer noch nicht erlaubt, den globalen Stapel innerhalb des temporären Stapels zu betrachten?
Undichte Nonne
1
@LeakyNun Noch nicht. In dem gegenwärtigen Zustand, in dem sich der Dolmetschercode befindet, wäre das sehr schwierig. Nachdem ich das große Refactoring abgeschlossen habe, an dem ich arbeite, werde ich diese Funktionalität hinzufügen.
Mego
1
Wann haben Sie mit dem großen Refactoring begonnen?
Undichte Nonne
6

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.

Giuseppe
quelle
5

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

mbomb007
quelle
5

Mathematica 34 Bytes

Min[#~Drop~{i}]~Table~{i,Tr[1^#]}&
Kelly Lowder
quelle
5

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

Sinusoid
quelle
4

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 .

2501
quelle
3

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

Brad Gilbert b2gills
quelle
3

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 .

NikoNyrh
quelle
3

Pyth, 8 7 Bytes

mh.-SQ]

-1 Byte dank @isaacg

Versuch es!

KarlKastor
quelle
Sie können das dam Ende entfernen - es ist implizit ausgefüllt.
isaacg
@isaacg danke, wusste nicht, dass
KarlKastor
2

PHP, 72 Bytes

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

Online Version

Jörg Hülsermann
quelle
2

PHP, 47 Bytes

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

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

da ist farfetchd
quelle
2

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.

MetaColon
quelle
2

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.

Veskah
quelle
1
Es ist schlau. Sparen Sie mehr :) Probieren Sie es online!
mazzy
1
@mazzy Gut gemacht. Jetzt ist es offensichtlich, dass ich es sehe, aber das hätte ich nie zusammengefügt.
Veskah
1
Gute Arbeit! Ihre ist schöner :)
Sinusoid
1

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.

hobbs
quelle
1

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]
daniero
quelle
1

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
}
Esolanging Fruit
quelle
1
@ LuisMendo Whoops - Ich habe vergessen, das Array tatsächlich zu sortieren. Es sollte jetzt funktionieren.
Esolanging Fruit
1

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]
Kevin Cruijssen
quelle
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
Kevin Cruijssen
quelle
1

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
voidhawk
quelle
1

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.

dfeuer
quelle
1

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
maxb
quelle