Riflessione di array di stringhe intermedie

16

Cominciamo ridefinendo un riflesso di un personaggio in una matrice 2-d di caratteri:

Data una matrice quadrata di caratteri 2D con lettere alfabetiche minuscole distinte, definisci il riflesso di una lettera nella matrice come scambiandola con il personaggio direttamente di fronte ad essa attraverso il centro della piazza.

Quindi, un riflesso della lettera cin

abcde
fghij
klmno
pqrst
uvwxy

comporterebbe la configurazione

abwde
fghij
klmno
pqrst
uvcxy

perché il ce il wsono stati cambiati.

Alcuni altri esempi (con la stessa configurazione originale di cui sopra):

Riflettendo il personaggio esi formerebbe

 abcdu
 fghij
 klmno
 pqrst
 evwxy

Riflettendo il personaggio msarebbe

 abcde
 fghij
 klmno
 pqrst
 uvwxy

Riflettendo il personaggio bsi formerebbe

 axcde
 fghij
 klmno
 pqrst
 uvwby

La sfida

Dato un array 2-d di caratteri con lettere minuscole distinte, passa attraverso ogni carattere in una determinata stringa e "riflettilo" nella matrice.

Chiarimenti: le lettere nella stringa provengono da a-z, le lettere sono uniche e l'array è almeno 1x1 e al massimo 5x5 (ovviamente, poiché l'alfabeto inglese contiene solo 26 caratteri). I caratteri nella stringa sono garantiti come nell'array 2-d. La stringa è lunga al massimo 100 caratteri.

Ingresso

Una stringa s, un numero intero Ne quindi aNxN matrice di caratteri.

Esempio

Ingresso: 

ac
2
ab
cd

Produzione:

dc
ba

* Motivo: in primo luogo, riflettere il acon il d. Quindi, rifletti ccon il bperché cè la seconda lettera nella stringa di input.

punteggio

  • L'output può essere fornito con qualsiasi metodo conveniente .
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Scappatoie standardSono vietate le .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Vincitore attuale

Mostra snippet di codice

code-golf  string 
— NL628
fonte
9
Mezz'ora non è davvero abbastanza tempo per ottenere un uso significativo dalla sandbox.
— Post Rock Garf Hunter,
3
Nessun problema, sembra buono.
— user202729
1
(anche noi abbiamo una classifica dello snippet dello stack )
— user202729
6
50 ore sono un po 'troppo brevi per accettare un vincitore; in genere dovresti aspettare una settimana circa. Tuttavia, su PPCG, è pratica comune non accettare alcuna risposta perché ciò scoraggia le risposte future e vogliamo mantenere le sfide aperte per sempre.
— HyperNeutrino,
2
Tutti voi esempi avete i caratteri in ordine alfabetico. Presumo che non sia un presupposto che possiamo fare? Inoltre, dobbiamo dobbiamo prendere Ncome un input se non abbiamo bisogno di esso?
— Stewie Griffin,

Risposte:

3

Ottava , 85 68 66 byte

Usando eval, con un loop al suo interno ha salvato molti byte! Ho preso l'ispirazione da questa risposta di Luis Mendo !

@(c,N,A)eval"for C=c,A(flip(k))=A(k=[x=find(A==C),N^2+1-x]);end,A"

Provalo online!

Spiegazione:

f=@(c,N,A)          % Anonymous function that takes the three input variables
eval"...          % Evaluate the string and run it:
 for C=c,          % Loop over the character list 'c'
  .. x=find(A==C)   % Find the index where the character C is in A, and store it as 'x'
  .. k=[x,N^2+1-x]  % Create a vector with the index of C, and the index of its reflection
   A(flip(k))=A(k)  % Swap the elements in these positions
  end               % End loop
  A"                % Display the new 'A'
— Stewie Griffin
fonte
2

Python 2 , 76 byte

lambda s,a:[a[[i,~i][(s.count(c)+s.count(a[~i]))%2]]for i,c in enumerate(a)]

Provalo online!

Accetta input:

  • s: corda
  • N: ignorato
  • a: stringa di caratteri unita

Restituisce un elenco semplice di caratteri

Se io devo prendere l'array come un elenco:

Python 2 , 111 108 107 104 byte

lambda s,n,a:[[x[sum(map(s.count,x))%2]for i in range(n)for x in[[a[j][i],a[~j][~i]]]]for j in range(n)]

Provalo online!

Accetta input:

  • s: corda
  • n: int
  • a: Elenchi 2D di caratteri

Restituisce un elenco 2D di caratteri

— TFeld
fonte
1

Java 10, 126 123 116 byte

(s,n,m)->{for(var c:s)for(int N=n*n,i,j;N-->0;)if(m[i=N/n][j=N%n]==c){m[i][j]=m[n+~i][n+~j];m[n+~i][n+~j]=c;break;}}

Modifica la matrice di caratteri di input invece di restituirne una nuova per salvare i byte.

Provalo online.

Spiegazione:

(s,n,m)->{        // Method with the three parameters and no return-type
  for(var c:s)    //  Loop over the characters given
    for(int N=n*n,i,j;N-->0;)
                  //   Inner loop over the matrix
      if(m[i=N/n][j=N%n]==c){
                  //    If the current character and matrix-value are equals:
        m[i][j]=m[n+~i][n+~j];m[n+~i][n+~j]=c;
                  //     Swap the values in the matrix at indices [i, j] and [n-i-1, n-j-1]
        break;}}  //     Stop the inner loop (go to next iteration of the outer loop)
— Kevin Cruijssen
fonte
Dang, coding in java! ??!?! +1 Def
— NL628
1

Python 3 , 122 111 byte

lambda l,n,A:[[[A[a][b],A[~b][~a]][sum(map(l.count,[A[a][b],A[~b][~a]]))%2]for b in range(n)]for a in range(n)]

Provalo online!

Restituisce un array 2D di caratteri.

— Jo King
fonte
Dovresti essere in grado di giocare a golf ulteriormente. In nessun modo modificare la matrice di input è più breve in Java che in Python ..; p Per iniziare (e renderlo più corto di 1 byte anziché 1 byte in più rispetto alla mia risposta Java): Rimozione la ae bed utilizzando n+~xe n+~ysalva direttamente 2 byte: a,b=n+~x,n+~y;A[x][y],A[a][b]=A[a][b],A[x][y]aA[x][y],A[n+~x][n+~y]=A[n+~x][n+~y],A[x][y]
— Kevin Cruijssen
1

R , 74 61 byte

-13 byte grazie a Giuseppe.

function(s,n,m){for(x in s)m[v]=rev(m[v<-(i=x==m)|rev(i)]);m}

Provalo online!

Immette un vettore di caratteri da cercare come s, dimensione della matrice come ne matrice stessa come m. Se è assolutamente necessario prendere il primo argomento come stringa , ciò rovinerebbe il divertimento.

— Kirill L.
fonte
Usando indici logici piuttosto che numerici, ho golfato fino a 61 byte
— Giuseppe,
Wow, questo è un notevole miglioramento, grazie mille.
— Kirill L.,
0

Gelatina , 15 14 byte

FW;Ṛi,C$¥¦/ṁḷY

Provalo online!

Programma completo.

Spiegazione:

FW; Ṛi, C $ ¥ ¦ / ṁḷY Link principale. Input: ['ab', 'cd'] (a sinistra), 'ac' (a destra).
FW                    F latten e W rap in un elenco. Valore corrente = ['abcd'].
  ; Concatenalo con la giusta argomentazione. [ 'Abcd', 'a', 'c']
          / Riduci da sinistra:
   Ṛ ¦ Applica Ṛ everse a ...
    i ¥ l'indice (dell'argomento destro nell'argomento sinistro) ...
     , C $ e il suo indice di complemento.

L'ultima operazione richiede ulteriori spiegazioni. Indica f = Ṛi,C$¥¦, quindi per il valore ['abcd','a','c']viene calcolato ('abcd' f 'a') f 'c', che si espande in:

,I, C $ ¥ ¦ Funzione f . Assumi argomento a sinistra = 'abcd' e argomento a destra = 'a'
Ṛ Innanzitutto, calcolare il contrario. Ottieni "dcba".
 i ¥ Per calcolare gli indici a cui applicare, prima l'indice di 'a' in 'abcd'
             is ('abcd' i 'a') = 1. (primo indice)
  , C $ Quindi accoppiare con (1 C) = 0. (ultimo indice)
      ¦ Applicare 'dcba' su 'abcd' agli indici 0 e 1:

              a bc d
               d cb a
              ^ 1 ^ 0
              ====
              dbca
— user202729
fonte
0

Retina 0.8.2 , 96 byte

+`^(.)(.*¶(.|¶)*)((.)((.|¶)*))?\1(?(4)|(((.|¶)*)(.))?)((?<-3>.|¶)*$(?(3).))
$2$11$9$1$6$5$12
1A`

Provalo online! Prende la stringa se l'array di caratteri come stringa delimitata da nuova riga senza il numero intero N. Spiegazione: Ogni carattere cdi sviene elaborato a sua volta. La regex corrisponde a due posizioni equidistanti dalle estremità dell'array, di cui una è ce l'altra è il suo specchio m. Questi personaggi vengono scambiati e cvengono rimossi s.

+`

Elabora ogni personaggio di sa turno.

^(.)

$1cattura c.

(.*¶(.|¶)*)

$3cattura una pila di caratteri nell'array che precede uno di co m. $2cattura il resto di spiù tutti questi personaggi.

((.)((.|¶)*))?

Se mprecede c, $4ha un valore, $5acquisisce me $6cattura i caratteri tra me c. $7cattura $6come una pila ma il suo valore non viene utilizzato.

\1

c è ora abbinato nell'array stesso.

(?(4)|(((.|¶)*)(.))?)

Se mnon è già stato abbinato, $8acquisisce facoltativamente un valore, nel qual caso $9cattura i personaggi da ca m, $10acquisisce $9come una pila che non viene utilizzata e $11acquisisce m. Il valore è facoltativo nel caso ce mabbiano lo stesso carattere.

((?<-3>.|¶)*$(?(3).))

$12cattura i caratteri suffissi l'altro di ce m. Un gruppo di bilanciamento viene utilizzato per garantire che $12sia lungo quanto in $3profondità, ovvero il prefisso e il suffisso hanno la stessa lunghezza.

$2$11$9$1$6$5$12

I pezzi vengono poi rimessi insieme - prima il resto sed il prefisso della matrice, quindi se cpreceduto mquindi mpoi al centro, poi c, allora se mpreceduto cquindi mezzo poi m, quindi il suffisso.

1A`

Ora che sè vuoto, viene eliminato.

— Neil
fonte
0

JavaScript, 85 byte

Accetta stringa Se un array Acome stringa unita.

([...S],[...A])=>S.map(c=>[A[j],A[i]]=[A[i=A.indexOf(c)],A[j=A.length+~i]])&&A.join``

Mostra snippet di codice

— darrylyeo
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.