Sfida

Dato un elenco di numeri interi, mostra come sarebbe fatto l'ordinamento per gravità.

Ordinamento per gravità

In ordine di gravità, immagina i numeri come file di asterischi. Quindi, tutto cade e le nuove righe saranno ovviamente ordinate. Diamo un'occhiata a un esempio:

[2, 7, 4, 6]:

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

Si noti che questo è praticamente solo un ordinamento a bolle parallelizzato.

Specifiche esatte

Ad ogni iterazione, partendo dalla riga superiore, prendi ogni asterisco dalla riga che non ha un asterisco sotto di esso e spostalo in basso di una riga. Continua fino a quando l'elenco non viene ordinato.

Ingresso

L'input sarà un elenco di numeri interi assolutamente positivi.

Produzione

Per l'output, è necessario emettere ogni passaggio. È possibile scegliere due caratteri ASCII stampabili non bianchi, uno come "asterischi" e uno come "trattini" separati. Le file di asterischi devono essere separate con una nuova riga standard di qualche tipo (es. \nO \r\f). La fila di trattini deve essere almeno la larghezza della fila più larga (altrimenti i tuoi asterischi cadranno troppo in basso!). Una riga di trattini in fondo è facoltativa. È consentita una nuova riga finale alla fine. Sono consentiti spazi finali su ciascuna riga.

Casi test

l'input verrà rappresentato come un elenco, quindi l'output verrà elencato immediatamente di seguito. I casi di test sono separati da una doppia riga.

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

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

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

Sentiti libero di correggere i miei casi di test se sono sbagliati, li ho fatti a mano :)

Nota: non visualizzare l'elenco ordinato alla fine. :)

punteggio

Tutti i tuoi programmi saranno scritti uno sopra l'altro. Non vorrai che parti del tuo programma cadessero, quindi assicurati di avere il codice più corto!

Pyth , 27 byte

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

Provalo online!

Perl 5 , 118 byte

115 byte di codice + -plaflag.

\@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 /}

Provalo online!

Sembra un po 'troppo lungo. Ma ancora una volta, trattare con stringhe multilinea con regex non è di solito facile.

Sto usando Yinvece di *e _invece di -.

Ottava, 104 byte

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)

* Richiede pacchetto di immagini.

Provalo online!

Spiegazione:

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 byte

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 byte

-7 byte grazie a @Shaggy

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

Imparando Japt e volevo provare una sfida più complicata. Output con xs e "s invece di asterischi e trattini; accetta input come una matrice di numeri. Presuppone che l'ordinamento sarà completo in pochi input.lengthpassaggi; correggimi se non è così.

Provalo online!

Spiegazione

                              // 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 byte

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

Provalo online!

legge nell'elenco da stdin; separati da +caratteri anziché -. È molto più lungo di quanto avrei pensato. Approfitta del fatto che il confronto '*'>'+'valuta FALSEma '*'>' 'è TRUE, almeno su TIO (sulla mia macchina che ho usato '='che sembrava un po 'meglio).

Gestito a golf 5 byte in giù da tutte le tecniche che ho imparato da quando ho scritto la risposta originale.

Provalo online!

Haskell , 213 211 208 byte

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

Provalo online!

Javascript, 274 byte

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)

Esempio di frammento di codice:

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>