Dimmi come flop


29

Come scienziati informatici, probabilmente conoscerete tutti le operazioni di base dell'elenco pop e push . Queste sono semplici operazioni che modificano un elenco di elementi. Tuttavia, hai mai sentito parlare del flop dell'operazione ? (come nel flip- flop di )? È abbastanza semplice Dato un numero n , inverti i primi n elementi dell'elenco. Ecco un esempio:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a.flop(4)
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]

La cosa interessante dell'operazione flop è che puoi usarla per fare cose interessanti in un elenco, come ordinarlo . Faremo qualcosa di simile con i flop:

Dato un elenco di numeri interi, "Neighbor". In altre parole, ordinalo in modo che ogni elemento duplicato appaia consecutivamente.

Questo può essere fatto con i flop! Ad esempio, prendi il seguente elenco:

>>> a = [3, 2, 1, 4, 3, 3, 2]
>>> a.flop(4)
[4, 1, 2, 3, 3, 3, 2]
>>> a.flop(3)
[2, 1, 4, 3, 3, 3, 2]
>>> a.flop(6)
[3, 3, 3, 4, 1, 2, 2]

Questo ci porta alla definizione della sfida di oggi:

Dato un elenco di numeri interi, genera qualsiasi set di flop che comporterà la vicinanza dell'elenco.

Usando l'ultimo elenco come esempio, dovresti produrre:

4
3
6

perché floppando l'elenco di 4, quindi di 3, quindi di 6 si otterrà un elenco vicino. Tieni presente che non è necessario stampare l'elenco più breve possibile di flop che confina con un elenco. Se avessi stampato:

4
4
4
3
1
1
6
2
2

invece, questo sarebbe comunque un output valido. Tuttavia, è possibile che non venga mai emesso un numero maggiore della lunghezza dell'elenco. Questo perché per un elenco a = [1, 2, 3], la chiamata non ha a.flop(4)senso.

Ecco alcuni esempi:

#Input:
[2, 6, 0, 3, 1, 5, 5, 0, 5, 1]

#Output
[3, 7, 8, 6, 9]


#Input
[1, 2]

#Output
<any list of integers under 3, including an empty list>


#Input
[2, 6, 0, 2, 1, 4, 5, 1, 3, 2, 1, 5, 6, 4, 4, 1, 4, 6, 6, 0]

#Output
[3, 19, 17, 7, 2, 4, 11, 15, 2, 7, 13, 4, 14, 2]


#Input
[1, 1, 1, 1, 2, 2, 2, -1, 4]

#Output
[]


#Input
[4, 4, 8, 8, 15, 16, 16, 23, 23, 42, 42, 15]

#Output
[12, 7]

Tenere presente che in ciascuno di questi esempi, l'output fornito è solo un potenziale output valido. Come ho detto prima, qualsiasi set di flop che confina con la lista data è un output valido . È possibile utilizzare questo script Python per verificare se un determinato elenco di flop configura correttamente un elenco.

È possibile accettare input e output in qualsiasi formato ragionevole. Ad esempio, sono validi argomenti di funzione / valore di ritorno, STDIN / STDOUT, lettura / scrittura di un file, ecc. Come al solito, questo è , quindi fai il programma più corto che puoi e divertiti! :)


3
L'ho sentito come fl (punto di oating) op (erazione).
Weijun Zhou

3
@WeijunZhou Questa è una misura della velocità di calcolo, per contare le operazioni eseguite su un pezzo di hardware. en.wikipedia.org/wiki/FLOPS
iPhoenix

3
Gli invii devono essere deterministici o posso floppare pseudo casualmente fino a quando l'array non viene raggruppato?
Dennis,

3
È consentito apparire zero flop nell'output?
Laikoni,

4
Correlato . NB qualsiasi risposta a questa domanda sarebbe una risposta a questa, ma dal momento che l'ordinamento è una condizione più forte dell'essere "vicino", potrebbe essere possibile battere il campo in modo che questo non sia un duplicato (anche se il fatto che l'unico la risposta finora non è incoraggiante).
Peter Taylor,

Risposte:


7

Haskell , 98 71 byte

h.r
h(x:s)|(a,b)<-span(/=x)s=l b:l s:h(b++r a)
h e=e
r=reverse
l=length

Provalo online!

Spiegazione

Per un elenco di lunghezza nquesto metodo produce 2*nflop. Funziona osservando l'ultimo elemento dell'elenco, cercando lo stesso elemento nell'elenco prima e spostandolo nella penultima posizione. Quindi l'elenco con l'ultimo elemento rimosso viene ricorsivamente "vicino".

Per l'elenco [1,2,3,1,2]l'algoritmo funziona in questo modo:

[1,2,3,1,2]  flip longest prefix that ends in 2: flop 2
[2,1,3,1,2]  bring first element to second to last position: flop n-1 = flop 4
[1,3,1,2,2]  recursively work on n-1 list
[1,3,1,2]    there is no other 2: flop 0
[1,3,1,2]    flop n-1 = flop 3
[1,3,1,2]    recurse
[1,3,1]      flop 1
[1,3,1]      flop 2
[3,1,1]      recurse
[3,1]        flop 0
[3,1]        flop 1
 ...

Complessivamente questo produce i flop [2,4,0,3,1,2,0,1,0,0]e la lista dei vicini [3,1,1,2,2].


6

Wolfram Language (Mathematica) , 71 byte

If[(n=Tr[1^#])<1,{},{i=Last@Ordering@#,n,n-1,i-1}~Join~#0[#~Drop~{i}]]&

Provalo online!

Come funziona

Dato un array di lunghezza n, genera una sequenza di 4nflop che ordinano l'array in ordine crescente: in particolare, mettendo gli elementi duplicati uno accanto all'altro.

L'idea è che per ordinare un array, spostiamo il suo elemento più grande alla fine, quindi ordiniamo i primi n-1elementi dell'array. Per evitare l'implementazione dell'operazione flop, spostiamo l'elemento più grande fino alla fine in modo da non disturbare gli altri elementi:

{3, 2, 1, 5, 3, 3, 2}    starting array, with largest element in position 4
{5, 1, 2, 3, 3, 3, 2}    flop 4 to put the largest element at the beginning
{2, 3, 3, 3, 2, 1, 5}    flop 7 to put the largest element at the end
{1, 2, 3, 3, 3, 2, 5}    flop 6 (7-1) to reverse the effect of flop 7 on other elements
{3, 2, 1, 3, 3, 2, 5}    flop 3 (4-1) to reverse the effect of flop 4 on other elements

In generale, se l'elemento più grande è in posizione i, la sequenza di flop che lo sposta alla fine è i, n, n-1, i-1.


Puoi spostare l'elemento più grande fino alla fine con solo i, n. Perché allora n-1, i-1? Non è necessario un ordinamento stabile .
Peter Taylor,

@PeterTaylor Non penso che la risposta esegua effettivamente i flop, piuttosto rimuove l'elemento più grande ogni volta e produce l'equivalente di quell'operazione in termini di flop.
Neil


3

Gelatina , 19 17 byte

ỤỤạ‘Ḣ
ỤÇÐƤĖµUż’ṚF

Ordina l'elenco.

Provalo online!


Penso che il ỤŒ¿’Æ!‘ṚĖµUż’ṚFtipo inverso Œ¿sia modulo L!.
Jonathan Allan,

Per qualsiasi motivo, ciò non funziona per l'ultimo caso di test, il che probabilmente significa che il mio codice fallirà anche per qualche caso oscuro ...
Dennis

E fallisce davvero per l'input [4, 3, 2, 1, 3]. Bummer.
Dennis,

Oh, ciao; è un peccato.
Jonathan Allan,

Ụ>Ṫ$ƤSạỤĖµUż’ṚFsalvando 2 byte sostituendo il collegamento helper.
miglia

2

Pulito , 88 byte

Penso che ce ne sia uno forse più corto con le guardie, ma non l'ho ancora trovato.

import StdEnv
$[h:t]#(a,b)=span((<>)h)t
=map length[b,t]++ $(b++r a)
$e=e
r=reverse

$o r

Provalo online!

Come una funzione letterale. Funziona allo stesso modo della risposta Haskell di Laikoni , ma ha giocato a golf in modo leggermente diverso, e ovviamente anche in una lingua diversa.


1

JavaScript, 150 byte

(a,f=n=>(a=[...a.slice(0, n).reverse(),...a.slice(n)],n),l=a.length,i=0)=>a.reduce(c=>[...c,f(a.indexOf(Math.max(...a.slice(0, l-i)))+1),f(l-i++)],[])

Provalo online!

JavaScript, 151 byte

a=>{f=n=>(a=[...a.slice(0,n).reverse(),...a.slice(n)],n),r=[];for(i=a.length+1;--i>0;)r.push(f(a.indexOf(Math.max(...a.slice(0, i)))+1),f(i));return r}

Provalo online!

Entrambi fondamentalmente ordinano l'array capovolgendo il numero massimo all'inizio e quindi capovolgendolo sul retro, ripetendolo con l'array rimanente. Il primo utilizza ridurre, il secondo utilizza un ciclo for.

Ungolfed:

array => {
  let flop = n => {
    array = [...array.slice(0, n).reverse(), ...array.slice(n)]; 
    return n;
  }
  let flops = [];
  for (let i = array.length + 1; --i > 0;) 
  {
    let maxIndex = array.indexOf(Math.max(...array.slice(0, i)));
    flops.push(flop(maxIndex + 1), flop(i));
  }
  return flops;
}

0

Perl 5,10 (o superiore), 66 byte

Include +3per -n The use 5.10.0per portare la lingua al livello perl 5.10 è considerato gratuito

#!/usr/bin/perl -n
use 5.10.0;
$'>=$&or$.=s/(\S+) \G(\S+)/$2 $1/*say"$. 2 $."while$.++,/\S+ /g

Esegui con l'input come una riga su STDIN:

flop.pl <<< "1 8 3 -5 6"

Ordina l'elenco trovando ripetutamente qualsiasi inversione, facendola cadere in primo piano, quindi invertendo l'inversione e riportando tutto alla sua vecchia posizione.

È stato sorprendentemente difficile entrare nello stesso campo da baseball di Python su questo :-)


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.