Ordinamento di base, con fastidioso bug

28

Il tuo input è un elenco / sequenza / vettore / array di 5-255 numeri interi positivi, non necessariamente univoci. Si può presumere qualunque sia il formato di input più adatto e che ciascun numero intero (così come la quantità di numeri interi) sia scelto in modo uniforme a caso nell'intervallo 5-255.

L'obiettivo è produrre lo stesso elenco, nello stesso formato (o equivalente), ma ordinato in ordine crescente (non decrescente). Un esercizio precoce comune nell'apprendimento di una lingua. Argomenti da includere:

  1. Una risposta che funzioni correttamente e raggiunga l'obiettivo; e

  2. Una seconda risposta che contiene un fastidioso bug. Tra l'1% e il 10% delle volte, l'output deve essere un elenco nel formato corretto e contenente gli elementi corretti, ma nell'ordine sbagliato (qualsiasi ordine eccetto quelli ordinati correttamente). Il resto del tempo, il programma deve funzionare correttamente e raggiungere l'obiettivo.

Le due risposte devono avere Levenshtein distanza una; vale a dire, possiamo ottenere l'uno dall'altro eliminando un byte o aggiungendo un byte o modificando un byte.

Punteggio come al solito nel code-golf (basato sulla più breve delle due risposte), con le solite scappatoie vietate.

Bonus del 10% (diminuisci per segnare) se il fastidioso bug è indipendente dall'input, ovvero l'uso di nuovo dello stesso input non riproduce il bug (tranne tra l'1% e il 10% delle volte).

code-golf  array-manipulation  random  integer 
— Vadim Ponomarenko
fonte
9
Benvenuti in PPCG! Suggerisco di rimuovere il bonus, non è davvero una buona pratica.
— Mr. Xcoder
2
Non è chiaro quale sia la probabilità di ogni possibile lunghezza di input.
— user202729
12
Qualora le specifiche tra 1% e il 10% del tempo da soddisfare per ciascun ingresso o semplicemente generale per il set di possibili ingressi? Per alcuni input come [5,5,5]è impossibile produrre un ordine sbagliato
— Luis Mendo il
4
C'è una sottigliezza per quanto riguarda i nostri formati IO predefiniti . Se il nostro codice definisce una funzione, va bene se ha qualche possibilità di definire la funzione in modo coerente buggy, al contrario di definire una funzione che ha qualche possibilità di essere buggy?
— xnor
1
@VadimPonomarenko Su questo sito le persone sono autorizzate a fornire funzioni e programmi completi. xnor chiede se è consentita una funzione che, dall'1% al 10% delle volte in cui viene creata, è una funzione con bug che avrà sempre un bug. Tenendo alla lettera della tua domanda la risposta è probabilmente no , ma sarebbe più divertente se fosse sì .
— wizzwizz4,

Risposte:

9

Python 3 , 36 byte

Versione senza errori, 37 byte

lambda l:sorted(l,reverse=l[-9:]==[])

Provalo online!

Versione fastidiosa, 36 byte

lambda l:sorted(l,reverse=l[9:]==[])

Provalo online!

Questo dipende dall'input e quindi non è idoneo per il bonus.
Ha una probabilità di fallire di circa il 2%. Non riesce quando la lunghezza dell'ingresso è inferiore a 10.

In combinazione con la risposta di LyricLy, questo ottiene 34 byte:

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]
— OVS
fonte
Non penso che tu abbia bisogno di spazio nella versione senza bug.
— wizzwizz4,
@wizzwizz4 senza lo spazio or1verrà interpretato come un nome di variabile e genera un errore di sintassi.
— Ov
9

05AB1E , 5 * 0.9 = 4.5 byte

Soluzione di lavoro

{TLΩi

Provalo online!

Spiegazione

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

Soluzione contenente il bug

Fornisce la soluzione sbagliata il 10% delle volte (indipendentemente dall'input).

{TLΩiR

Provalo online!

Spiegazione

Come la soluzione funzionante, tranne per il fatto che inverte l'elenco se il numero selezionato è vero.

— Emigna
fonte
Seriamente, ehi. L'output non è nemmeno della cardinalità corretta.
— Giosuè il
@Joshua Che vuoi dire?
— Erik the Outgolfer,
Provalo online lo mostra in uscita un elenco di elenchi.
— Giosuè,
4
@Joshua Il link TiO include un'intestazione 100Fe un piè di pagina },che ci aiutano a visualizzare più volte il risultato della funzione chiamata sull'input. Questo ci mostra che la soluzione di lavoro restituisce sempre risultati corretti, mentre quella con errori ha un output difettoso.
— Mr. Xcoder,
Per favore, qualcuno, spiega l'algoritmo. Presto accetterò la proposta più votata (o una delle proposte più votate). Non posso accettare alcuna soluzione che non capisco.
— Vadim Ponomarenko,
7

Gelatina , 7 * (100% - 10%) = 6,3 byte

Ṣ¹⁵X:¤¡

Provalo online!

Versione buggy:

ṢẊ⁵X:¤¡

Provalo online!

In entrambi i collegamenti è presente un cablaggio di test che eseguirà il codice 100 volte, ogni volta con l'elenco fornito come argomento, quindi restituirà i risultati.

La probabilità di ogni lunghezza di input è:

0.1 - 0.1/(length!)

Quindi per la lunghezza 1 c'è una probabilità dello 0%, per la lunghezza 2 5%, per la lunghezza 3 8,83̅%, per la lunghezza 4 9,583̅% ecc. Fino alla lunghezza ∞ che ha una probabilità del 10%.

— Erik the Outgolfer
fonte
Dovrebbe essere 0.1 - 0.1/(length!).
— user202729
@ user202729 sicuro
— Erik the Outgolfer
Ṣ⁵X’¤¡e Ṣ⁵X¤¡dovrebbe funzionare anche: la versione con bug restituisce la lista non ordinata <10% delle volte, e dato che l'input è scelto in modo uniforme casuale, dovrebbe funzionare, risparmiando 2 byte.
— user202729
Se non ti piace quella soluzione, puoi semplicemente eliminare il ¹per salvare 1 byte (il numero di conteggi del byte = quello più corto); inoltre c'è una linea di combinazione esterna dopo il secondo 6in 6.6̅%.
— user202729
@ user202729 Sfortunatamente allora non sarà più indipendente dall'input, e no non posso "semplicemente rimuovere ¹" perché non ordinerebbe affatto il 10% delle volte.
— Erik the Outgolfer,
6

Python 3, punteggio 58 57 - 10% = 51.3

Salvataggio di un byte grazie a ovs.

Versione senza bug, 57 byte

lambda m:sorted(m)[::random()>.1or 1]
from random import*

Provalo online!

Versione con errori, 57 byte

lambda m:sorted(m)[::random()>.1or-1]
from random import*

Provalo online!

Ho deciso di provare una soluzione che utilizza il bonus. Non batte l'altra risposta di Python, ma mi sono divertito a pensarci.

— LyricLy
fonte
5

C, 71 * 0,9 = 63,9 byte

Bug-free:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

Provalo online!

buggy:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

Provalo online!

— Steadybox
fonte
+1 per% 1 (oh, andiamo altri 6, mi stai prendendo in giro)
— Joshua,
4

Groovy , 31 byte

Soluzione errata:

{a->a.sort()[a[9]?0..-1:-1..0]}

Soluzione di lavoro:

{a->a.sort()[a[0]?0..-1:-1..0]}

L'operatore del pedice Groovy (il getAtmetodo) restituisce null per gli elenchi se l'indice è più grande della dimensione. Quindi, se c'è un nono elemento, rimarrà lo stesso della lista ordinata, ma in caso contrario (probabilità 1.99203187%) verrà invertito. Comunque ci sarà sempre un primo elemento perché la dimensione della lista è sempre maggiore o uguale a 5. Quindi lo 0 in a[0]potrebbe essere scambiato con 1, 2, 3 o 4.

— Hlaaftana
fonte
1
Benvenuti nel sito e bel primo post!
— caird coinheringaahing il
3

PHP, 70 byte

Versione senza errori, 70 byte

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

Provalo online!

Versione con errori, 70 byte

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

Provalo online!

La versione con errori ordina in ordine inverso il 10% delle volte (in base a un generatore di numeri casuali).

— Jo.
fonte
non è necessario il tag con -r(-2 byte). unisci per sottolineatura; quello dovrebbe essere equivalente (-2 byte). usa asortinvece di sort(-1 byte).
— Tito
... o usa l'intera parola invece del prefisso (o no): unset($argv[0]);(rand(1,9)?sort:rsort)($argv);echo join(_,$argv);(anche 65 byte)
— Tito
3

Python 2 , 26 byte

buggy:

lambda l:l[9:]and l.sort()

Provalo online!

Emette modificando l'elenco di input . Ordina l'elenco solo se la sua lunghezza è almeno 10. La versione non buggy sostituisce 9con a0 per ordinare sempre.

Lavoro:

lambda l:l[0:]and l.sort()

Provalo online!

È possibile modificare la funzione per restituire l'elenco al costo di 4 byte, per un totale di 30 byte:

lambda l:l[9:]and l.sort()or l

Provalo online!

25 byte con alcuni tratti delle regole:

[list,sorted][id(0)%17>0]

Provalo online!

Emette una funzione letterale che ordina o è l'identità, usando id(0)come fonte casuale. Passare >a >=correggere o 0a ~0.

— XNOR
fonte
3

buccia , 6 byte

Versione buggy:

?OIV¦9

Provalo online!

Versione corretta:

?OIVK9

Provalo online!

Spiegazione

Questi programmi sono completamente deterministici. In effetti, Husk non ha attualmente alcun supporto per numeri casuali.

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

Sostengo che l'output del programma buggy non è ordinato con una probabilità tra l'1% e il 2%. Indica con N = 251 il numero di possibili valori degli elementi. La probabilità che un elenco casuale di lunghezza L non contenga multipli di 9 è ((NK) / N) ^ L , dove K è il numero di valori divisibili per 9 (nel nostro caso K = 28 ). La probabilità totale è la media di questo per 5 ≤ L ≤ 255 , che è circa l'1,98%. Alcuni di questi elenchi sono falsi positivi, poiché sono già ordinati. La probabilità di un elenco casuale di lunghezza L da ordinare è al massimo ⌊L / 2⌋ ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : se suddividiamo l'elenco in blocchi di lunghezza 2, ciascuno deii pezzi devono essere ordinati. La probabilità totale di un elenco ordinato è limitata dalla media di quanto sopra per 5 ≤ L ≤ 255 , che è di circa lo 0,30%. Pertanto, la probabilità che la funzione restituisca un elenco non ordinato è compresa tra 1,67% e 1,98%.

— Zgarb
fonte
divisibile per 9 offre circa l'11% di probabilità di fallimento. e non l'ordinamento non garantisce che l'elenco non sia ordinato.
— Tito
1
@Titus Mi rivolgo a questo nell'analisi. Il mancato ordinamento si verifica solo se l'elenco non contiene elementi divisibili per 9. La probabilità di ciò è di circa l'1,98%. Ed è vero che se l'elenco è già ordinato, non fare nulla fornirà anche un elenco ordinato. Tuttavia, la probabilità che l'elenco sia già ordinato è al massimo dello 0,30%, il che è abbastanza basso che la probabilità totale di produrre un elenco non ordinato è superiore all'1%.
— Zgarb
vero ... e l'input che viene ordinato non modifica il bug.
— Titus
Potresti forse usare al ↓9posto di V¦9e abbreviarlo solo 9per la versione corretta? Ciò farebbe sempre fallire gli input brevi e funzionerebbe sempre correttamente su quelli più lunghi, ma poiché la lunghezza dell'input segue una distribuzione casuale dovrebbe essere comunque una risposta valida
— Leone
3

bash , 26 byte

Versione corretta

s=n
sort -${s:RANDOM%20<0}

Provalo online! o controlla le probabilità .

Versione con errori

s=n
sort -${s:RANDOM%20<1}

Provalo online! o controlla le probabilità .

Accetta input come numeri separati da nuova riga. Utilizza la variabile incorporata RANDOM, che restituisce sempre un numero (pseudo) casuale nell'intervallo 0 - 32767 . L'uso di %20risultati comporta un tasso di fallimento di circa il 5% (grazie a @Titus per chiarire i problemi con%10 ).

Questa casualità indica che il tasso di errore è indipendente dall'input, ma ciò richiede che l'array di input includa almeno un numero con più di una cifra, poiché l'output del fallimento è ordinato lessicograficamente.

Versione alternativa, 27 byte

((RANDOM+20))||cat&&sort -n

La versione con errori sostituisce la +con a %. Provalo online o provalo .

— Justin Mariner
fonte
centesimo raccolta: %10ha una maggiore probabilità di tornare 0al 7rispetto 8o 9, quindi la possibilità per il fallimento è superiore al 10%;)
— Titus
@Titus Grazie, mi sono dimenticato di questo fatto. Aggiornato per usare %20come fa la tua risposta.
— Justin Mariner,
3

Pyth , punteggio 8 * 0.9 = 7.2

Primo frammento (uno corretto):

h.uSNT.S

Provalo qui!

Secondo frammento (con un bug):

O.uSNT.S

Provalo qui!

Salvato due byte (e 1,8 punteggio) grazie a isaacg !

— Mr. Xcoder
fonte
Penso che 9 piuttosto che 10 nuove copie andrebbero bene. La possibilità di .Srestituire l'input invariato significa che in quei (rari) casi, le nostre possibilità di ottenere una risposta sbagliata scendono dal 10% allo 0%, quindi in media è ancora nell'intervallo corretto. Naturalmente, anche 10 copie vanno bene.
— Misha Lavrov,
@MishaLavrov Ho fatto un errore nella mia spiegazione, ora risolto. Ho detto che .Spotrebbe anche restituire l'input stesso (il che non sarebbe un problema), ma intendevo .Sanche restituire l'elenco ordinato .
— Mr. Xcoder,
Bene, è quello che volevo dire anche io.
— Misha Lavrov,
Stessa idea, ma più breve:O.uSNT.S
— isaacg
2

JavaScript (ES6), 24 byte

Versione senza errori (almeno per numeri interi compresi nell'intervallo 0-2147483647, quindi qualsiasi cosa nell'intervallo indicato):

a=>a.sort((a,b)=>a-b>>0)

Versione buggy:

a=>a.sort((a,b)=>a-b>>1)

Dipende da a) l'algoritmo di ordinamento del motore eb) l'elenco di input contenente due valori nell'ordine sbagliato che differiscono di 1. (Se la probabilità che ciò si rivelasse troppo bassa, allora 1può essere aumentata, ma quando si ottiene ad 8esso semplicemente non ordinare nulla nella gamma 5-255.)

— Neil
fonte
2

PHP, 62 byte

ispirato dalla soluzione di Jo (e ho appena notato: è un porto di Justin Mariner ):

funzionante (ordinamento crescente):

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

buggy (circa il 5% di possibilità di ordine discendente):

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

Corri con -nr

— Titus
fonte
2

troppo intraprendente , 9 byte - 10% = 8.1

Soluzione difettosa:

g0TUn?};_

Provalo online!

Soluzione di lavoro:

g1TUn?};_

Provalo online!

Il codice errato procede come segue:

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

Il codice fisso cambia semplicemente 0in 1. Come random(1, 10)non sarà mai 0, l'istruzione if non verrà mai eseguita.

— FlipTack
fonte
2

MATL , 7 * 0.9 = 6.3 6 * 0.9 = 5.4 byte

Versione buggy:

Gr.9<?S

Provalo online!

Spiegazione:

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

Versione senza bug:

Gr9<?S

Provalo online!

Spiegazione:

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output
— Stewie Griffin
fonte
1

Jq 1,5 , 42 byte

passeggino

sort|if length%13<=0then reverse else. end

Funzionante (elimina il =)

sort|if length%13<0then reverse else. end

Supponendo che le lunghezze delle linee siano uniformi nell'intervallo [5.255], circa il 7% attiverà il bug

Provalo online!

— jq170727
fonte
1

J, 22,5 byte (25 byte - 10%)

con bug:

[:]`(1&A.)@.(0.1>?@0:)/:~

senza bug:

[:]`(0&A.)@.(0.1>?@0:)/:~

Provalo online!

— Giona
fonte
1

R , 30 * .9 = 27 byte

(Buggy)

function(l)sort(l,runif(1)<.1)

Provalo online!

(non buggy)

function(l)sort(l,runif(1)<.0)

La versione buggy ordina nel decreasing=T10% delle volte, campionando da una distribuzione uniforme (0,1). La versione non buggy è sempredecreasing=F

— Giuseppe
fonte
1

Röda , 42 byte - 10% = 37,8

Bug-free:

{sort key={|i|currentTime|[_%20//19*0+i]}}

buggy:

{sort key={|i|currentTime|[_%20//19*i+i]}}

Provalo online!

Questo utilizza la currentTimefunzione per creare numeri casuali. Sembra che la loro distribuzione vari leggermente tra le macchine. Il rapporto 20//19può essere regolato per ottenere risultati diversi senza penalità di byte (a meno che non sia inferiore a 99//98).

— fergusq
fonte
1

Java 8, 45 34,2 ( 50 38-10%) byte

Versione normale:

a->{if(Math.random()>0.)a.sort(null);}

Spiegazione:

Provalo qui.

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

Versione con errori ( 51 39 byte):

a->{if(Math.random()>0.1)a.sort(null);}

LD di 1: 1aggiunto.

Spiegazione:

Provalo qui.

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method
— Kevin Cruijssen
fonte
0

JavaScript, 25 * 0.9 = 22.5

new Date%25?x:x.sort()

input x

— l4m2
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.