Creare una funzione o un programma che accetta due input:

• Un elenco di numeri interi che devono essere ordinati (meno di 20 elementi)
• Un numero intero positivo N, che dice quanti confronti dovresti prendere

La funzione deve arrestarsi e produrre l'elenco risultante di numeri interi dopo i Nconfronti. Se l'elenco è completamente ordinato prima che Nvengano effettuati i confronti, è necessario generare l'elenco ordinato.

L' algoritmo Bubble sort è ben noto e immagino che molte persone lo sappiano. Il seguente pseudo-codice e animazione (entrambi dall'articolo Wikipedia collegato) dovrebbero fornire i dettagli necessari:

procedure bubbleSort( A : list of sortable items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n-1 inclusive do
       /* if this pair is out of order */
       if A[i-1] > A[i] then    
         /* swap them and remember something changed */
         swap( A[i-1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure

L'animazione in basso mostra l'avanzamento:

Un esempio (preso direttamente dall'articolo Wikipedia collegato) mostra i passaggi durante l'ordinamento dell'elenco ( 5 1 4 2 8 )::

Primo passaggio

1: ( 5 1 4 2 8 ) ->  ( 1 5 4 2 8 ) // Here, algorithm compares the first two elements, 
                                   // and swaps since 5 > 1.
2: ( 1 5 4 2 8 ) ->  ( 1 4 5 2 8 ) // Swap since 5 > 4
3: ( 1 4 5 2 8 ) ->  ( 1 4 2 5 8 ) // Swap since 5 > 2
4: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 ) // Now, since these elements are already in order 
                                   // (8 > 5), algorithm does not swap them.

Secondo passaggio

5: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 )
6: ( 1 4 2 5 8 ) ->  ( 1 2 4 5 8 ) // Swap since 4 > 2
7: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
8: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

Ora l'array è già ordinato, ma l'algoritmo non sa se è stato completato. L'algoritmo richiede un intero passaggio senza alcuno scambio per sapere che è ordinato.

Terzo passaggio

9: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
10:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
11:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
12:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

Casi test:

Formato: Number of comparisons (N): List after N comparisons

Input list:
5  1  4  2  8
Test cases: 
1: 1  5  4  2  8
2: 1  4  5  2  8
3: 1  4  2  5  8
4: 1  4  2  5  8
5: 1  4  2  5  8
6: 1  2  4  5  8
10: 1  2  4  5  8
14: 1  2  4  5  8

Input list:
0: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
Test cases:
1: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
21: -6  15  18   9  -7  -1   7  18  19  -5  19  19   5  15  -5   3  18  14  19  20
41: -6   9  -7  15  -1   7  18  18  -5  19  19   5  15  -5   3  18  14  19  19  20
60: -6  -7  -1   9   7  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
61: -6  -7  -1   7   9  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
81: -7  -6  -1   7   9  15  -5  18  18   5  15  -5   3  18  14  19  19  19  19  20
119: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
120: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
121: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
122: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
123: -7  -6  -1  -5   7   9   5  15  -5  15   3  18  14  18  18  19  19  19  19  20
201: -7  -6  -5  -1  -5   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20
221: -7  -6  -5  -5  -1   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20

• Sì, sono consentiti algoritmi di ordinamento Bubble integrati.
• No, non puoi assumere solo numeri interi positivi o interi univoci.
• L'ordinamento deve essere nell'ordine sopra descritto. Non puoi iniziare alla fine dell'elenco

Gelatina , 25 byte

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥
JḊṁ¹³W¤;ç/

Sulla base della mia risposta in J.

Provalo online!

Verifica il numero di confronti.

Spiegazione

Il collegamento helper modifica l'elenco in base all'indice [i-1, i]ordinandolo in modo da produrre lo stesso risultato del confronto ordinamento bolle.

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥  Helper link - Input: list A, index i
ḣ               Take the first i values
 ©              Save a copy of it
  ṫ-            Take the last two values
    Ṣ           Sort them
         ;      Append them to
     ®            Get the copy
      ṖṖ¤         Pop the last two values (Ṗ is pop)
          ;     Prepend it to
           ṫ      Take the last i values
            Ḋ¥    Dequeue - remove the head

JḊṁ¹³W¤;ç/  Input: list A and # of comparisons n
J           Enumerate the indices of A
 Ḋ          Dequeue - remove the head
  ṁ         Reshape it cyclically to length n
   ¹        Identity function (Just to avoid parsing rules)
       ;    Append it to
    ³         The list A
     W¤       Wrap it as an array
        ç/  Reduce from left to right using the helper link and return

JavaScript (ES6), 102 82 80 86 80 byte

Bug fix e 1 byte salvati grazie a @ edc65

(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

La ricorsione potrebbe non esserlo, sicuramente non è probabilmente l'approccio migliore, ma per ora sto seguendo un ciclo.

Provalo:

f=(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

Enter your numbers:<br>
<input id=A rows=10 value="5 1 4 2 8"><br>
Enter the number of steps:<br>
<input type="number" min=0 id=B rows=10 value="1"><br>
<button onclick="C.innerHTML=f((A.value.match(/-?\d+/g)||[]).map(Number),B.value)">Run</button><br>
<pre id=C></pre>

Haskell, 83 82 81 byte

y%x@(a:b:c)=(y++x):(y++[min a b])%(max a b:c)
y%x=[]%(y++x)
[x]!_=[x] 
x!n=[]%x!!n

Esempio di utilizzo: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

In funzione % ytiene traccia degli elementi visitati finora durante il passaggio corrente, xsono ancora quelli da esaminare. ae bsono i prossimi due, vale a dire i candidati da scambiare. Se si raggiunge la fine della lista, partiamo dal principio: y%x = []%(y++x). Tutti i passaggi sono memorizzati in un elenco in cui la funzione principale seleziona l' nelemento th.

Modifica: le versioni precedenti non funzionavano per gli elenchi di singoli elementi, per fortuna la nuova versione è ancora più breve.

Python 3, 77 74 byte

-3 byte grazie a @Maltysen (init jnella dichiarazione)

lambda l,n,j=0:exec('j*=j<len(l)-1;l[j:j+2]=sorted(l[j:j+2]);j+=1;'*n)or l

Casi di prova su ideone

Utilizza sortedogni operazione di confronto e scambio, ma sta eseguendo un ordinamento a bolle.

Imposta j=0(l'indice a sinistra), esegue quindi nconfrontare e permute di voci di elenco adiacenti, azzeramento jdi 0ogni volta che questa finestra va fuori dai limiti.

A quel punto j*=j<len(l)-1si moltiplicherà jper False(cioè 0), mentre ogni volta si moltiplicherà jper True(cioè 1).

(Funzionerà comunque anche per un elenco vuoto.)

PowerShell v2 +, 135 129 byte

param($a,$n)for($s=1;$s){($s=0)..($a.count-2)|%{if($a[$_]-gt$a[$_+1]){$a[$_],$a[$_+1]=$a[$_+1],$a[$_];$s=1}if(!--$n){$a;exit}}}$a

Così. Molti. Dollari.

( Salvati sei byte di rendersi conto che questa sfida non include il "gratis" l'ottimizzazione di saltare l'ultimo elemento (s) su ogni passaggio dato che è garantito ordinati, e invece attraversa un passaggio completo ogni volta. Questo spostato il $a.countnella forloop ed eliminato il$z variabile. )

Ordinamento della bolla verso l'alto, con un punto elegante, scambiando in un solo passaggio -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

La logica di uscita viene gestita tramite if(!--$n){$a;exit}

Casi test

(L'array viene mostrato come separato da spazio qui perché il Separatore di campi di output predefinito per la stringa di un array è uno spazio. La stringa si verifica perché ci stiamo concatenando con le etichette "$_ -> ".)

PS C:\Tools\Scripts\golfing> 1,2,3,4,5,6,10,14|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(5,1,4,2,8) $_)}
1 -> 1 5 4 2 8
2 -> 1 4 5 2 8
3 -> 1 4 2 5 8
4 -> 1 4 2 5 8
5 -> 1 4 2 5 8
6 -> 1 2 4 5 8
10 -> 1 2 4 5 8
14 -> 1 2 4 5 8

PS C:\Tools\Scripts\golfing> 1,21,41,60,61,81,119,120,121,122,123,201,221|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(15,18,-6,18,9,-7,-1,7,19,19,-5,20,19,5,15,-5,3,18,14,19) $_)}
1 -> 15 18 -6 18 9 -7 -1 7 19 19 -5 20 19 5 15 -5 3 18 14 19
21 -> -6 15 18 9 -7 -1 7 18 19 -5 19 19 5 15 -5 3 18 14 19 20
41 -> -6 9 -7 15 -1 7 18 18 -5 19 19 5 15 -5 3 18 14 19 19 20
60 -> -6 -7 -1 9 7 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
61 -> -6 -7 -1 7 9 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
81 -> -7 -6 -1 7 9 15 -5 18 18 5 15 -5 3 18 14 19 19 19 19 20
119 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
120 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
121 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
122 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
123 -> -7 -6 -1 -5 7 9 5 15 -5 15 3 18 14 18 18 19 19 19 19 20
201 -> -7 -6 -5 -1 -5 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20
221 -> -7 -6 -5 -5 -1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

R, 132 131 112 136 byte

Il programma riceve l'input come segue: prima N, quindi il vettore stesso. Ad esempio, se si desidera v = [5 1 4 2 8]e n = 1, l'input che entra in scanè 1 5 1 4 2 8. Quindi, per eseguire questo programma, esegui la prima riga , inserisci i numeri uno a uno nella console e quindi esegui il resto (questa è una risposta REPL).

Quindi il seguente codice fa il trucco:

v=scan()
s=m=0
while(!s){s=T;for(i in 3:length(v)){m=m+1
if(m>v[1]){s=T;break}
if(v[i-1]>v[i]){v[c(i-1,i)]=v[c(i,i-1)];s=F}}}
cat(v[-1])

Test:

Input: a vector with N first and the elements to be sorted next
1 5 1 4 2 8
5 5 1 4 2 8
14 5 1 4 2 8
60 15 18 -6 18  9 -7 -1  7 19 19 -5 20 19  5 15 -5  3 18 14 19

Output: 
1 5 4 2 8
1 4 2 5 8
1 2 4 5 8
-6 -7 -1  9  7 15 18 -5 18 19  5 15 -5  3 18 14 19 19 19 20

Aggiornamento: golfed 1 byte grazie a Vlo .

Pyth, 34 32 byte

AQVH=*<ZtlGZ=GsXJcG,Zh=hZ1ShtJ;G

Una traduzione della risposta Python di Jonathan Allan.

Provalo qui!

JavaScript (ES6), 82 80 79 byte

f=(a,m,n=0,_,b=a[n+1])=>1/b?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m)

Basato sulla risposta originale di @ ETHproduction. Modifica: salvato 2 byte grazie a @JonathanAllan. Salvato 1 byte grazie a @ edc65.

J , 62 60 byte

>@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)

Questo è un verbo che accetta due argomenti: il numero di confronti su LHS e l'elenco di numeri interi su RHS. Prima controlla se la lunghezza dell'elenco è maggiore di una. In caso contrario, restituisce l'elenco non modificato, altrimenti opera su di esso eseguendo il numero specificato di confronti prima di restituire il risultato.

uso

Per il primo caso di test, i comandi extra sono usati per formattare più input / output. Il secondo caso di test viene mostrato come input / output singolo.

   f =: >@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)
   1 2 3 4 5 6 10 14 ([;f)"0 1 ] 5 1 4 2 8
┌──┬─────────┐
│1 │1 5 4 2 8│
├──┼─────────┤
│2 │1 4 5 2 8│
├──┼─────────┤
│3 │1 4 2 5 8│
├──┼─────────┤
│4 │1 4 2 5 8│
├──┼─────────┤
│5 │1 4 2 5 8│
├──┼─────────┤
│6 │1 2 4 5 8│
├──┼─────────┤
│10│1 2 4 5 8│
├──┼─────────┤
│14│1 2 4 5 8│
└──┴─────────┘
   1 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
   123 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _1 _5 7 9 5 15 _5 15 3 18 14 18 18 19 19 19 19 20
   221 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _5 _5 _1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

Spiegazione

È difficile scrivere un codice conciso in J che utilizza la mutabilità, quindi converto il problema nel ridurre un elenco su una serie di indicazioni. Penso che questo codice sia disordinato, quindi illustrerò il lavoro di ogni frase anziché di ogni primitiva. La prima parte prende la lunghezza dell'elenco e produce un intervallo. Quindi, operare su ogni infisso di dimensione 2 per emulare un passaggio di confronti.

   i. # 5 1 4 2 8
0 1 2 3 4
   2 <\ i. # 5 1 4 2 8
┌───┬───┬───┬───┐
│0 1│1 2│2 3│3 4│
└───┴───┴───┴───┘
   2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┐
│0│1│2│3│
└─┴─┴─┴─┘

Queste sono le indicazioni iniziali di ogni confronto. Se vengono eseguiti 7 confronti, rimodellarlo per ottenere la quantità desiderata. J analizza da destra a sinistra, quindi si riduce da destra a sinistra, come piega a destra. Aggiungi l'elenco iniziale e invertilo.

   7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘
   |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┬─────────┐
│2│1│0│3│2│1│0│5 1 4 2 8│
└─┴─┴─┴─┴─┴─┴─┴─────────┘

In alternativa, è possibile creare l'intervallo [0, 7) e prendere ciascun valore per la lunghezza dell'elenco meno 1 per creare lo stesso intervallo.

   (<: # 5 1 4 2 8) <@| i. 7
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘

L'ultima parte è un verbo che prende un elenco su RHS e un indice su LHS che segna l'indice iniziale del confronto. Selezionare i due elementi a partire da quell'indice, ordinarli e ricollegarli all'elenco e restituirlo.

   > ({.,(2/:~@{.}.),]}.~2+[)&.>/ |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
1 2 4 5 8

Matlab, 93 91 byte

function l=f(l,m)
n=numel(l)-1;i=0;while n&m;i=mod(i,n)+1;m=m-1;l(i:i+1)=sort(l(i:i+1));end

Salva 11 byte omettendo if l(i)>l(i+1);l(i:i+1)=l([i+1,i])e invece ordina i due elementi ogni volta. Funziona con elenchi di lunghezza 1. Potrebbe salvare un byte o due usando l' m--operatore di Octave , ma non è molto.

Salva altri due byte impostando n=numel(l)-1;, perché poi posso solo fare while ninvece di while n>1e i=mod(i,n)+1invece di i=mod(i,n-1)+1.

Per la cronaca, questa risposta è stata scritta molte ore dopo la creazione della sfida.

Groovy (101 byte)

{l,n->(l.size()..0).each{i->(0..i-2).each{if(l[it]>l[it+1] && n>0 && it>-1){l.swap(it,it+1)};n--}};l}

EDIT: Non avevo bisogno di scrivere la mia chiusura di swap, Groovy aveva questo incorporato.
Provalo qui: https://groovyconsole.appspot.com/script/5104724189642752

Traccia di output di esempio:

4:[1, 5, 4, 2, 8]
3:[1, 4, 5, 2, 8]
2:[1, 4, 2, 5, 8]
1:[1, 4, 2, 5, 8]
0:[1, 4, 2, 5, 8] - Locks in the final answer.
-1:[1, 4, 2, 5, 8]
-2 (Return):[1, 4, 2, 5, 8]

Vecchia implementazione (122 byte)

m={l,n->s={x,y->t=l[x];l[x]=l[y];l[y]=t};((l.size()-2)..2).each{i->(0..i).each{if(l[it]>l[it+1] && n){s(it,it+1)};n--}};l}

Provalo qui: https://groovyconsole.appspot.com/script/6316871066320896

php, 148 145 byte

<?php for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)if($a[$i]>$a[$i+1])list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];echo substr(join(' ',$a),5);

Non sono molto contento della struttura del ciclo ma mi piace il cambio di lista e funziona, quindi lo sto postando comunque. php7.1 mi permetterebbe di salvare almeno 4 byte.

Con una formattazione migliore:

<?php 
for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)
  if($a[$i]>$a[$i+1])
    list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];
echo substr(join(' ',$a),5);

Modifica: Jörg Hülsermann mi ha ricordato di unirmi, invece di implodere.
nota: deve essere in un file con un nome file a carattere singolo.

Ruby, 52 50 byte

Aspetta ... no Ruby?

->l,n{n.times{|a|l[s=a%~-l.size,2]=l[s,2].sort};l}