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.