Scambia i due indici indicati


31

Dato un array di numeri interi positivi e due distinti indici validi, restituisce l'array con i due elementi corrispondenti ai due indici scambiati.

Puoi scegliere di utilizzare 0-indicizzazione o 1-indicizzazione, ma i seguenti test saranno 0-indicizzati.

array        m n output
[1,2,3,4]    0 1 [2,1,3,4]
[5,8,9]      0 2 [9,8,5]
[11,13,15,3] 1 2 [11,15,13,3]
[11,13,15,3] 2 1 [11,15,13,3]
[11,15,15,3] 2 1 [11,15,15,3]

Questo è . Vince la risposta più breve in byte. Si applicano scappatoie standard .



1
Eh, questo potrebbe essere un compito con cui molte lingue del golf hanno difficoltà ma le lingue più pratiche trovano facile. (Le liste con elementi mutabili non sono una cosa comune per le lingue del golf.) In tal caso, sarà piuttosto interessante. (Le lingue del golf probabilmente vinceranno comunque, perché sono molto più complesse da riuscire a cavarsela con un algoritmo più complesso.)

7
Sorpreso, questo probabilmente non è un inganno, ma questa sfida è in realtà creativa, poiché è una vera sfida per molte lingue del golf.
Erik the Outgolfer,

@LeakyNun Ho ottenuto voti bassi (e persino cancellare voti) in quel modo in passato, non preoccuparti troppo ...
Erik the Outgolfer,

Può me nessere preso come un array?
Okx,

Risposte:


17

C/ C ++, 53 50 39 byte

f(a,m,n)int*a;{a[m]^=a[n]^=a[m]^=a[n];}

Provalo online

Salvato 11 byte grazie a @Dennis


10

Operazione linguaggio di scripting Flashpoint , 98 95 byte

f={t=_this;a=t select 0;b=+a;m=t select 1;n=t select 2;a set[m,b select n];a set[n,b select m]}

Modifica direttamente l'array.

Spiegazione:

t=_this;                   // Give a shorter name for the array of arguments.

a=t select 0;              // Let 'a' be a pointer to the array that we modify.
                           // (The language doesn't have a concept of pointers really,
                           // yet its array variables are pointers to the actual array.)

b=+a;                      // Make a copy of the original array and save a pointer to it
                           // in the variable 'b'. This saves a few bytes later.

m=t select 1;              // Read the index arguments from the input array and save them
n=t select 2;              // to their respective variables.

a set[m,b select n];       // Do the swapping by reading the values from the copy and
a set[n,b select m]        // writing them to the original array. The last semicolon can
                           // be omitted because there are no more statements following 
                           // the last statement.

Chiama con:

array = [1,2,3,4];
str = format["%1", array];
[array, 0, 1] call f;
hint format["%1\n%2", str, array];

Produzione:

inserisci qui la descrizione dell'immagine


7

JavaScript ES6, 36 32 byte

Guarda, mamma, nessuna variabile temporanea!

(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]

Provalo

Immettere un elenco separato da virgole di elementi per ae 2 numeri interi per m& n.

f=
(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]
oninput=_=>o.innerText=(f(b=i.value.split`,`,+j.value,+k.value),b);o.innerText=(f(b=(i.value="5,8,9").split`,`,j.value=0,k.value=2),b)
*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}
<label for=i>a: </label><input id=i><label for=j>m: </label><input id=j type=number><label for=k>n: </label><input id=k type=number><pre id=o>


2
Tali istruzioni modificano l'array, il che significa che è consentito non restituire l'array, il che consente di risparmiare qualche byte.
Neil,

@Neil: Stai dicendo di usare solo (a,m,n)=>[a[m],a[n]]=[a[n],a[m]]? Ciò produrrebbe solo i 2 elementi scambiati senza il resto dell'array (ad es. [5,8,9],0,2-> [9,5]).
Shaggy,

@Neil: Giusto, ecco perché aalla fine abbiamo bisogno di darci l'array completo e modificato. O mi manca completamente quello che stai cercando di dire?
Shaggy,

@Neil: Hmm ... OK, penso di vedere quello che stai ottenendo ora (mi dispiace, sto provando a fare troppe cose allo stesso tempo oggi). Grazie per il consiglio. C'è un consenso al riguardo e, in tal caso, avresti un link a portata di mano prima che io vada a cercarlo da solo?
Shaggy,



5

Gelatina , 7 byte

Ṛ,ḷyJ}ị

Provalo online!

Come funziona

Ṛ,ḷyJ}ị  Main link. Left argument: [i, j]. Right argument: A (array)

Ṛ        Reverse; yield [j, i].
  ḷ      Left; yield [i, j].
 ,       Pair; yield [[j, i], [i, j]].
    J}   Indices right; yield all indices of A.
   y     Transliterate; replace j with i and i with j.
      ị  Index into A.

perché il wrapper è lungo quasi quanto il programma ...
Leaky Nun,

Non ho mai saputo dell'esistenza diy
Leaky Nun il

Lo sapevo y, ma non pensavo di usarlo qui. Questa è una risposta abbastanza intelligente.

Questo mi ha fatto pensare ... è un Jellycodice Jelly valido?
M.Herzkamp,

@ M.Herzkamp Lo è. Dubito che sia eccezionalmente utile.
Dennis,


4

MATL , 7 6 byte

yyP)w(

Gli indici sono basati su 1.

Provalo online!

Spiegazione

Considerate ingressi [11 13 15 3], [2 3].

yy   % Take two inputs implicitly. Duplicate them
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [2 3]
P    % Flip
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [3 2]
)    % Reference indexing (pick indexed entries)
     % STACK: [11 13 15 3], [2 3], [15 13]
w    % Swap
     % STACK: [11 13 15 3], [15 13], [2 3]
(    % Assignment indexing (write values into indexed entries). Implicitly display
     % STACK: [11 15 13 3]

4

C # (.NET Core) , 48 43 31 byte

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])

Provalo online!

Scambia i numeri nell'array originale, senza utilizzare variabili temporanee. Tuttavia non posso prendermi il merito per questa risposta poiché è stata un'idea di Neil .


@LeakyNun non sembra funzionare, in quanto lascia un [m] con un valore di 0. Provalo tu stesso!
Charlie,

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])sembra funzionare però.
Neil,

(Queste risposte sono tutte valide anche in JavaScript ES6, no?)
Neil,


3

Javascript ES6, 36 34 byte

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)
  • -2 byte perché la funzione sta modificando l'array. Non è necessario restituire l'array. Grazie a @Neil

dimostrazione


1
Tali istruzioni modificano l'array, il che significa che è consentito non restituire l'array, il che consente di risparmiare qualche byte.
Neil,


2

Java 8 , 48 byte

(a,b,c)->{int t=a[b];a[b]=a[c];a[c]=t;return a;}

Ingresso:

int[] a
int b
int c

Come si fa a lambdas con tre argomenti in Java?
Leaky Nun,

1
Tali istruzioni modificano l'array, il che significa che è consentito non restituire l'array, il che consente di risparmiare qualche byte.
Neil,

1
@LeakyNun Non sono Okx , ma ecco un esempio Provalo ora con la risposta attuale e l'interfaccia personalizzata di Okx .
Kevin Cruijssen,

1
E sulla base della sorprendente risposta C # di Carlos Alejo (con l'aiuto di @ Neil) , puoi renderlo ancora più breve eliminando la variabile temporanea: (a,b,c)->a[b]+=a[c]-(a[c]=a[b])( 31 byte )
Kevin Cruijssen

1
tosse la tosse Collections::swap è di 17 byte ... almeno supponendo che questo valga per questa sfida ...
Socratic Phoenix


2

Ottava , 28 byte

@(a,n){a(n)=a(flip(n)),a}{2}

Provalo online!

Abbastanza soddisfatto di questo in realtà :)

Accetta input nel modulo f([1,2,3,4],[1,2]):, 1 indicizzato.

Spiegazione:

@(a,n)                         % Anonymous function that takes two 1-dimensional
                               % arrays as input
      {               , }      % Create a cell with two elements
       a(n)=a(flip(n))         % One element are the two number at indices given by
                               % the second input array. This will be a 1x2 array
      {a(n)=a(flip(n)),a}      % Place those two in a cell together with the entire array a
                               % a is now updated, thanks to Octave's inline assignment
      {a(n)=a(flip(n)),a}{2}   % Return the second element

2

Medusa , 7 byte

p
ZRi
i

Prende un elenco e una coppia di indici. Provalo online!

Spiegazione

Le meduse hanno una funzione di "modifica degli oggetti negli indici" Z, che fa esattamente ciò di cui abbiamo bisogno. I due iafferrano gli input da STDIN. Zprende come argomenti il ​​secondo input, la funzione di inversione Re l'elenco. Quindi Zesegue la modifica e pstampa il risultato.


2

R, 38 byte

function(x,a,b){x[c(a,b)]=x[c(b,a)];x}

Sembra piuttosto lungo, ma non riesco a farlo molto più breve. Purtroppo richiede l'esplicito ritorno x, che richiede {}attorno al corpo della funzione. pryr::f()non riconosce la necessità xcome argomento della funzione, quindi non funziona: /.


Penso function(x,i)replace(x,i,rev(i))che funzionerebbe, anche con la sintassi del pryr.
Giuseppe,

@Giuseppe Ah, stavo cercando una comoda funzione per fare lo scambio, ma cercavo con termini sbagliati. Sentiti libero di pubblicarlo come risposta personale.
JAD,

@Giuseppe Penso che devi fare replace(x,i,x[rev(i)]), altrimenti posizionerai gli indici invece dei loro valori.
JAD,

2

I / O di Shenzhen, 735 byte

23 ¥, 810 Potenza, 48 righe di codice

[traces] 
......................
......................
......................
......................
......................
......................
.14.14.14.............
.94.14.14.............
.A........1C..........
.3554..95556..........
.9554.16..............
.A....................
.2....................
......................

[chip] 
[type] UC6
[x] 4
[y] 2
[code] 
  slx x0
  mov x1 acc
  mov x1 dat
  mov acc x3
  mov dat x3
  mov acc x3
  mov dat x3

[chip] 
[type] UC6
[x] 8
[y] 5
[code] 
  slx x2
  mov x2 x1
  mov x0 dat
  mov x2 x1
  mov x0 acc
  mov x2 x1
  mov dat 

[chip] 
[type] UC4X
[x] 2
[y] 6
[code] 
  slx x0
  mov 0 x3
j:  mov x0 acc
  mov acc x2
  teq acc 0
- jmp j
  mov -999 x1

[chip] 
[type] RAM
[x] 5
[y] 6

SIO

NOTA BENE: le matrici sono terminate con 0 in questo. Le matrici sono un dolore nel culo con cui lavorare a Shenzhen I / O altrimenti.

In realtà ho creato un livello di vapore per questo gioco. Puoi giocarci qui.

EDIT: Aaand ho appena capito che ho detto che l'array è stato ordinato. Heck.


Benvenuti nel sito Questo è davvero fantastico! pensi che potresti essere in grado di rimuovere parte degli spazi bianchi nel file e fare in modo che Shenzhen IO accetti il ​​file? Non so quanto ne abbia giocherellato, ma dovresti provare a vedere quanto sia flessibile il formato.
Mago del grano,

Non ci ho giocato! D'altra parte, sto eliminando l'intestazione del puzzle che contiene il nome del puzzle e il nome della soluzione, quindi non so se dovrei preoccuparmi.
Junkmail

1

Swift, 111 65 byte (0 indicizzato)

Swift è già noto per essere uno dei peggiori linguaggi del code-golf, ma qui è una funzione che utilizza espressioni ternarie :

func t(l:[Int],m:Int,n:Int){var r=l;r[m]=l[n];r[n]=l[m];print(r)}

Controlla! - Uso: t(l:[1,2,3],m:0,n:1) .


L'uso di un parametro predefinito per r ti farebbe risparmiare byte e puoi anche solo mutare l'array passato (l'array rapido AFAIK è passato per valore)
Downgoat

Parametro predefinito in Swift? Come lo posso fare?
Mr. Xcoder,

E i parametri sono costanti in Swift @Downgoat
Mr. Xcoder il

1

k ( kona ), 13 byte

{x[y]:x@|y;x}

Abbastanza semplice, ma funziona. Ex:

k){x[y]:x@|y;x}[1 2 3 4; 0 1]
2 1 3 4

1

Perl 5 , 32 byte

-3 byte grazie a @Dom Hastings !

30 byte di codice + -paflag.

@F[pop@p,@p]=@F[@p=<>];$_="@F"

Provalo online!

Abbastanza semplice, usando le sezioni di array.


Ehi, ehi, ho armeggiato un po 'con questo e sono riuscito a salvare 3 byte! @F[pop@p,@p]=@F[@p=<>];$_="@F".
Dom Hastings,

@DomHastings Hmm, bello, come sempre! Grazie :)
Dada,

1

Mathematica, 32 byte

(a=#;a[[{##2}]]=a[[{#3,#2}]];a)&

3
a[[{##2}]]==a[[{#3,#2}]]dovrebbe essere a[[{##2}]]=a[[{#3,#2}]](usando Set, non Equals)
JungHwan Min

1

C, 42 byte

Modifica l'array in atto con un valore temporaneo.

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}

C, 60 58 byte

Un po 'più interessante, non usando alcun valore temporaneo ...

f(a,m,n)int*a;{a[m]+=a[n];a[n]-=a[m];a[n]*=-1;a[m]-=a[n];}

C, 49 byte

Usando XOR

f(a,m,n)int*a;{a[m]^=a[n];a[n]^=a[m];a[m]^=a[n];}

Heh, stavo per pubblicare un post f(x,i,j,t)int*x;{t=x[i];x[i]=x[j];x[j]=t;}.
Dennis,

@Dennis mi hai salvato due byte sull'altra soluzione, grazie!
Cleblanc,

La seconda soluzione non sarebbe più breve (e più sicura) con ^?
Dennis,

-1 per la versione XOR che utilizza una funzione di definizione invece di una#define X(x,y,z)x[y]^=x[z],x[z]^=x[y],x[y]^=x[z]
Giacomo Garabello,

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}è rotto: SIGSEGV.
Bodo Thiesen,

1

Pyth , 17 8 byte

Risparmiato 9 byte grazie a Leaky Num.

@LQ.rUQE

Provalo online!

Questo è 0-indicizzato, e gli indici sono forniti come una tupla: (n, m).

spiegazioni

@LQ.rUQE

     UQ     # Generate [0, 1, 2, ..., len(input)]
       E    # Get the indices as the tuple (1, 2)
   .r       # Translate each element of UQ to its cyclic successor in E
            # Now the indices are permuted (e.g. [0, 2, 1, ..., len(input)]
@LQ         # For each index, get it's value. Implicit print


@LeakyNun È così diverso penso che tu possa pubblicarlo da solo!
Jim,

Sono l'OP; Non inserisco la mia sfida.
Leaky Nun,

1

Mathematica, 20 byte

#~Permute~Cycles@#2&

Funzione pura che accetta due argomenti nel seguente formato 1 indicizzato (e possibilmente abusivo): il secondo caso di test [5,8,9]; 0 2; [9,8,5]verrebbe chiamato come

#~Permute~Cycles@#2& [ {5,8,9} , {{1,3}} ]

(gli spazi sono estranei e solo per l'analisi visibile). Permuteè la funzione incorporata che applica una permutazione a un elenco e Cycles[{{a,b}}]rappresenta la permutazione che scambia il ath e bth elementi di un elenco e ignora il resto.


Cosa ~fanno?
Cyoce,

~è la notazione infix di Mathematica per una funzione binaria: x~f~ysignifica la stessa cosa di f[x,y].
Greg Martin,

1

Codice macchina x86, 10 byte

8B 04 8B 87 04 93 89 04 8B C3

Questa è una funzione scritta nel codice macchina x86 a 32 bit che scambia i valori agli indici specificati in un determinato array. L'array viene modificato sul posto e la funzione non restituisce un valore.

Viene utilizzata una convenzione di chiamata personalizzata, che richiede che i parametri della funzione siano passati nei registri :

  • L'indirizzo dell'array (puntatore al suo primo elemento) viene passato in EBX registro.
  • L'indice in base zero dell'elemento A viene passato nel ECXregistro.
    (Si presume che sia un indice valido.)
  • L'indice in base zero dell'elemento B viene passato nel EDXregistro.
    (Si presume che sia un indice valido.)

Ciò riduce le dimensioni e soddisfa tutti i requisiti formali, ma significa che la funzione non può essere facilmente richiamata da altre lingue come C. Dovresti chiamarla da un altro programma in linguaggio assembly. (È possibile riscriverlo per utilizzare qualsiasi registro di input, tuttavia, senza influire sul conteggio dei byte; non c'è nulla di magico in quelli che ho scelto.)

Ungolfed:

8B 04 8B     mov  eax, DWORD PTR [ebx+ecx*4]   ; get value of element A
87 04 93     xchg eax, DWORD PTR [ebx+edx*4]   ; swap element A and element B
89 04 8B     mov  DWORD PTR [ebx+ecx*4], eax   ; store new value for element A
C3           ret                               ; return, with array modified in-place


1

Java 8 + InverseY , 27 byte

java.util.Collections::swap

Chiama solo la funzione di scambio ... questo è un riferimento di metodo del tipo Consumer3<List, Integer, Integer>.

Provalo online! (intestazione e piè di pagina per boilerplate e copia Consumer3dell'interfaccia)


Non è necessario aggiungere "+ InverseY". È valido in vaniglia Java 8.
Olivier Grégoire il

1

JavaScript (ES2015), 66 57 49 byte

Un approccio diverso (ahimè, più lungo) rispetto alle precedenti risposte JavaScript

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))

fonte

const swap = (arr, a, b, splice) => {
  splice(a, 1, ...splice(arr[b], 1, arr[a]))
}

1
(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))49 byte
Patrick Roberts,

Dimenticato loro args predefiniti. Grazie!
sshow,

0

awk, 31 byte

{c=$a;$a=$b;$b=c;a=$1;b=$2}NR>1

Provalo online!

Accetta input nel formato

1 2
1 2 3 4

e produce come

2 1 3 4

(1-indicizzati).

Spiegazione

L'intero programma è un modello mancante con un'azione seguito da un modello con un'azione mancante.

Poiché un pattern mancante viene eseguito su ciascuna riga, il codice all'interno delle parentesi graffe viene eseguito per entrambe le righe di input. La c=$a;$a=$b;$b=c;parte scambia i due valori negli indici ae b(attraverso la variabile temporanea c). Ciò ha effetto solo sulla seconda riga, poiché sulla prima riga ae bnon sono ancora definiti. La a=$1;b=$2parte definisce ail primo campo e bil secondo campo, che imposta i valori appropriati per la prima parte da eseguire sulla seconda riga.

Poiché un'azione mancante equivale a {print}, il modello stampa ogni riga corrispondente. Questo modello in particolare è NR>1: cioè stampa ogni volta che il numero di riga è maggiore di 1, che risulta essere la riga 2. Ciò viene eseguito dopo lo scambio di valori, completando così l'attività.


0

q / kdb +, 17 byte

Soluzione:

{@[x;(|)y;:;x y]}

Esempio:

q){@[x;(|)y;:;x y]}[1 2 3 4;0 1]
2 1 3 4

Spiegazione:

Una versione q della risposta k di Simon. Applicare la :funzione di assegnazione a x negli indici inversi-y con il valore di x indicizzato in y. Ripartiti puoi vedere più chiaramente:

q)x:1 2 3 4
q)y:0 1
q)x y
1 2
q)(|)y
1 0
q)x(|)y
2 1
q)@[x;(|)y;:;x y]
2 1 3 4
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.