Herausforderung

Zeigen Sie anhand einer Liste von ganzen Zahlen, wie die Schwerkraftsortierung durchgeführt wird.

Schwerkraft sortieren

Stellen Sie sich die Zahlen als Reihen von Sternchen vor. Dann fällt alles und die neuen Zeilen werden offensichtlich sortiert. Schauen wir uns ein Beispiel an:

[2, 7, 4, 6]:

**
*******
****
******
-------
**
****
*******
******
-------
**      | 2
****    | 4
******  | 6
******* | 7

Beachten Sie, dass dies so ziemlich nur eine parallelisierte Blasensortierung ist.

Genaue Angaben

Nehmen Sie bei jeder Iteration, beginnend mit der obersten Zeile, jedes Sternchen aus der Zeile, unter der sich kein Sternchen befindet, und verschieben Sie es eine Zeile nach unten. Machen Sie so lange weiter, bis die Liste sortiert ist.

Eingang

Die Eingabe ist eine Liste von streng positiven ganzen Zahlen.

Ausgabe

Für die Ausgabe müssen Sie jeden Schritt ausgeben. Sie können zwei beliebige druckbare Nicht-Whitespace-ASCII-Zeichen auswählen, eines als "Sternchen" und eines als trennende "Bindestriche". Die Sternchenreihen müssen durch eine Art Standard - Zeilenumbruch (z. B. \noder) getrennt werden\r\f . ) getrennt werden. Die Strichreihe muss mindestens der Breite der breitesten Reihe entsprechen (sonst fallen Ihre Sternchen zu weit nach unten!). Eine Reihe von Strichen ganz unten ist optional. Ein abschließender Zeilenumbruch am Ende ist zulässig. Nachgestellte Leerzeichen in jeder Zeile sind zulässig.

Testfälle

Die Eingabe wird als Liste dargestellt, und die Ausgabe wird unmittelbar darunter aufgeführt. Testfälle werden durch einen doppelten Zeilenumbruch getrennt.

[4, 3, 2, 1]
****
***
**
*
----
***
** *
* *
**
----
**
* *
** *
***
----
*
**
***
****

[6, 4, 2, 5, 3, 1]
******
****
**
*****
***
*
------
****
**  **
****
***
*  **
***
------
**
****
*** **
*  *
***
*****
------
**
***
*  *
*** **
****
*****
------
**
*
***
****
******
*****
------
*
**
***
****
*****
******

[8, 4, 2, 1]
********
****
**
*
--------
****
**  ****
* **
**
--------
**
* **
**  ****
****
--------
*
**
****
********

Bitte zögern Sie nicht, meine Testfälle zu korrigieren, wenn sie falsch sind, ich habe sie von Hand gemacht :)

Hinweis: Die sortierte Liste am Ende nicht ausgeben. :)

Wertung

Alle Ihre Programme werden übereinander geschrieben. Sie möchten nicht, dass Teile Ihres Programms herunterfallen, stellen Sie also sicher, dass Sie den kürzesten Code haben!

Pyth , 27 Bytes

jsCM.u:R"v "" v"N+R\-.t*L\v

Probieren Sie es online!

Perl 5 , 118 Bytes

115 Byte Code + -plaFlags.

\@X[$_]for@F;s%\d+ ?%Y x$&.$"x($#X-$&).$/%ge;while(/Y.{$#X} /s){print$_,_ x$#X;1while s/Y(.{$#X}) /X$1b/s;y/bX/Y /}

Probieren Sie es online!

Es scheint ein bisschen zu lang. Aber auch hier ist der Umgang mit mehrzeiligen Zeichenfolgen mit Regex normalerweise nicht einfach.

Ich benutze Ystatt *und _statt -.

Oktave, 104 Bytes

b=(1:max(L=input("")))<=L;do;disp(" *-"([b;max(b)+1]+1))until b==(b=imerode(b,k=[1;1])|imdilate(b,k)~=b)

* Benötigt Image-Paket.

Probieren Sie es online!

Erläuterung:

input = [8 ;4 ;2 ;1]

L = input('');                    %input list
b=(1:max(L))<=L;                  % generate matrix of 0s and 1s as indexes of asterisks 

b =

  1  1  1  1  1  1  1  1
  1  1  1  1  0  0  0  0
  1  1  0  0  0  0  0  0
  1  0  0  0  0  0  0  0
do;
    disp(' *-'([b;max(b)+1]+1))  %display asterisks and dashes

    E = imerode(b,k=[1;1]);      %morphological erosion
    E =

      1  1  1  1  0  0  0  0
      1  1  0  0  0  0  0  0
      1  0  0  0  0  0  0  0
      1  0  0  0  0  0  0  0

    D = imdilate(b,k);           %morphological dilation
    D =

      1  1  1  1  1  1  1  1
      1  1  1  1  1  1  1  1
      1  1  1  1  0  0  0  0
      1  1  0  0  0  0  0  0

    b_temp = E | (D~=b)          %intermediate result
    b_temp =

      1  1  1  1  0  0  0  0
      1  1  0  0  1  1  1  1
      1  0  1  1  0  0  0  0
      1  1  0  0  0  0  0  0

until b==(b=b_temp)              %loop until no change

Python, 203 199 Bytes

def k(x):
 m,j=max(x),''.join;d=[*map(lambda i:('*'*i).ljust(m),x)];f=sorted(d);print(*d,sep='\n')
 while d!=f:d=[*map(j,zip(*[x.replace('* ',' *')for x in map(j,zip(*d))]))];print('-'*m,*d,sep='\n')

Japt , 69 62 Bytes

-7 Bytes dank @Shaggy

®ç'x +SpZnUrwÃpQpUrw¹·
V
l o ®V=z d" x""x " z3ÃuW
X¯XbXgJ)Ä ·

Ich lerne Japt und wollte eine kompliziertere Herausforderung ausprobieren. Ausgabe mit xs und "s anstelle von Sternchen und Bindestrichen; Nimmt Eingaben als ein Array von Zahlen. Es wird davon ausgegangen, dass die Sortierung innerhalb von input.lengthSchritten abgeschlossen ist. korrigiere mich wenn das mal nicht der fall ist.

Probieren Sie es online!

Erläuterung

                              // implicit: U = input array
 ®   ç'x +SpZnUrwà pQpUrw¹ ·  // implicit: V = this line
UmZ{Zç'x +SpZnUrw} pQpUrw) qR // ungolfed
UmZ{             }            // U mapped by the function:
    Zç'x                      //   "x" times this item
         +SpZnUrw             //   plus " " times the max of the input array (Urw) minus this value (Z)
                   pQpUrw)    // push " (Q) times the max
                           qR // join with newlines

V                             // implicit: W = this line

 l o ®   V=z d" x""x " z3Ã uW // implicit: X = this line
Ul o mZ{ZV=z d" x""x " z3} uW // ungolfed
Ul o                          // the array of the range [0, U.length)
     mZ{Z                }    // mapped by the no-arg function:
         V=z                  //   set V to itself rotated 90deg
             d" x""x "        //   replace all " x" with "x " to "fall"
                       z3     // rotate back to normal
                           uW // add  W(the original) to the start

X¯XbXgJ)Ä ·                   // implicit: return this line
Xs0,XbXgJ)+1 qR               // ungolfed
Xs0,                          // get the substring of X from 0 to...
    XbXgJ)+1                  // the first index of the last item, plus one
             qR               // join with newlines

R , 210 205 Bytes

l=scan();w=max(l);h=sum(l|1);a=1:h;p=h+1;m=matrix(' ',w,p);m[,p]='+';for(x in a)m[l[x]:1,x]='*';f=function()write(m,'',w,sep='');f();while(any(i<-m[,a]>m[,a+1])){s=which(i);m[,a][s]=' ';m[,a][s+w]='*';f()}

Probieren Sie es online!

liest in der Liste von stdin; getrennt durch +Zeichen statt -. Es ist viel länger als ich gedacht hätte. Nutzt die Tatsache , dass der Vergleich '*'>'+'ausgewertet , FALSEsondern '*'>' 'ist TRUEzumindest auf TIO (auf meinem Rechner habe ich'=' die ein wenig besser aussah).

Hat es geschafft, 5 Bytes weniger als alle Techniken zu spielen, die ich seit dem Schreiben der ursprünglichen Antwort gelernt habe.

Probieren Sie es online!

Haskell , 213 211 208 Bytes

import Data.List
(?)=replicate
p=transpose
s l|w<-length l,i<-[n?'*'++w?' '|n<-l]=intercalate[w?'-']$i:(p<$>unfoldr f(p i))
f i|i==n=mempty|2>1=Just(n,n)where n=t<$>i
t(a:b:y)|a>b=" *"++t y|2>1=a:t(b:y);t k=k

Probieren Sie es online!

Javascript, 274 Bytes

a=>(r="",m=Math.max(...a),b=a.map(n=>Array(m).fill(0).map((_,i)=>i<n)),(k=_=>(b.map(c=>r+=c.map(v=>v?"*":" ").join``.trim()+`
`),r+="-".repeat(m)+`
`,n=0,b.map((r,i)=>(s=b[i+1])&&r.map((c,j)=>s[j]||(n|=s[j]=-(c>0),c>0&&(r[j]=0)))),b=b.map(c=>c.map(n=>n<0?1:n)),n&&k()))(),r)

Beispielcode-Snippet:

f =

a=>(r="",m=Math.max(...a),b=a.map(n=>Array(m).fill(0).map((_,i)=>i<n)),(k=_=>(b.map(c=>r+=c.map(v=>v?"*":" ").join``.trim()+`
`),r+="-".repeat(m)+`
`,n=0,b.map((r,i)=>(s=b[i+1])&&r.map((c,j)=>s[j]||(n|=s[j]=-(c>0),c>0&&(r[j]=0)))),b=b.map(c=>c.map(n=>n<0?1:n)),n&&k()))(),r)

o.innerText = f([6,4,2,5,3,1])

<pre id=o>