Ricostruire una matrice rettangolare da un angolo

30

Una volta avevo un bellissimo array rettangolare. Era molto simmetrico, ma sfortunatamente è caduto a pezzi e ora ho solo l'angolo in alto a sinistra. Il tuo compito sarà ricostruire l'array originale.

Il tuo programma riceverà un array bidimensionale di numeri interi. Per facilitare l'analisi, si può presumere che siano tutti compresi tra 1 e 9. Il tuo compito è di invertire le colonne dell'array, le sue righe ed entrambi, unire gli angoli risultanti e restituire l'array risultante.

Puoi supporre che le dimensioni dell'array siano almeno 1x1.

Casi test:

Input:
1 2 3
4 5 6

Output:
1 2 3 3 2 1
4 5 6 6 5 4
4 5 6 6 5 4
1 2 3 3 2 1

Input:
1

Output:
1 1
1 1

Input:
9
9
9

Output:
9 9
9 9
9 9
9 9
9 9
9 9

Questo è code-golf , vince meno byte!

code-golf  array-manipulation  matrix 
— Pavel
fonte
1
Scommetto che il carbone può farlo in meno di 10
— FantaC
1
@tbfninja chat.stackexchange.com/transcript/message/43184083#43184083 ma potrebbe essere più breve con un formato di input diverso.
— Pavel
@MagicOctopusUrn sì
— Pavel
2
@tfbninja ＷＳ⟦ι⟧‖Ｍ→↓forse? 5 byte per leggere l'input e 4 per riflettere.
— Neil
4
Sono sicuro al 99% che esiste un lang che lo fa con ╬(o qualche personaggio simile) ma non ricordo quale: c
— Rod

Risposte:

1

Proton , 29 byte

a=>[b+b[by-1]for b:a+a[by-1]]

Provalo online!

Ci sono alcuni altri approcci interessanti però:

Proton , 29 byte

a=>map(g,(g=x=>x+x[by-1])(a))

Provalo online!

È possibile definire la funzione secondaria mirror gin linea, perché Proton. Non è più breve però.

Proton , 36 byte

(a=>[x[0]for x:zip(*(a+a[by-1]))])*2

Provalo online!

Questo dovrebbe essere di (a=>zip(*(a+a[by-1])))*224 byte, ma la funzione zip è completamente rotta. Fondamentalmente, esegui il mirroring e zip, quindi lo fai due volte (puoi moltiplicare una funzione per un numero intero positivo per applicare la funzione più volte).

— HyperNeutrino
fonte
5

Python 3, 38 byte

lambda a:[b+b[::-1]for b in a+a[::-1]]

Provalo online!

Prende un elenco di elenchi e restituisce un elenco di elenchi.

Spiegazione: 

lambda a:                              # anonymous lambda function
                   for b in a+a[::-1]  # for each row in the array and the upside-down array
          b+b[::-1]                    # the row with its reverse appended
         [                           ] # return in a list
— pizzapants184
fonte
5

Retina , 13 byte

\%`$
$^$`
Vs`

Provalo online!

Spiegazione

\%`$
$^$`

Su ogni riga ( %), abbina la fine della riga ( $), inserisci il retro ( $^) dell'intera riga ( $`) e stampa il risultato con un avanzamento riga finale ( \). Questo fa il riflesso lungo l'asse verticale e stampa la prima metà dell'output.

Vs`

Ciò inverte semplicemente l'intera stringa, che equivale a una rotazione di 180 °, o nel nostro caso (a causa della simmetria orizzontale) una riflessione lungo l'asse orizzontale. In questo modo funziona è la Vregex di default (inversa) (?m:^.*$), che normalmente corrisponde a ciascuna riga della stringa. Tuttavia, attiviamo l'opzione singleline s, che fa .corrispondere anche i linefeed e quindi questa regex predefinita corrisponde effettivamente all'intera stringa.

Il risultato di questo viene stampato automaticamente alla fine del programma, dandoci la seconda metà dell'output.

— Martin Ender
fonte
Questo non sembra alcun sapore regex che conosco: P
— Pavel
@Pavel Perché Retina non è solo regex. :)
— Erik the Outgolfer
@Pavel l'unica parte di quel codice che è una regex reale è $la prima riga. ;) Aggiungerò una spiegazione più tardi.
— Martin Ender,
5

05AB1E , 2 byte

∞∊

Provalo online!

   # Input:Array of String | ['12','34']
---#-----------------------+------------------------------------------
∞  # Mirror horizontally.  | [12,34]       -> [1221,3443]
 ∊ # Mirror vertically.    | [1221,3443]   -> [1221\n3443\n3443\n1221]

Ringraziamo Mr. Xcoder che sottolinea che gli array di stringhe possono essere considerati array 2D e Pavel per averlo confermato.

— Urna di polpo magico
fonte
— Mr. Xcoder
Per facilità di analisi, puoi presumere che siano tutti compresi tra 1 e 9 - Quindi penso che questo sia valido. In attesa della conferma di Pavel, immagino
— Mr. Xcoder il
@ Mr.Xcoder era quello che avevo inizialmente, quindi gli array TIO 2D come input erano strani ... quindi ho dovuto inventare quella roba dell'intestazione.
— Magic Octopus Urn
Una stringa è un array di caratteri, quindi un elenco di stringhe è ancora un array 2d. @ La soluzione di Mr.Xcoder è valida.
— Pavel
Coolio, lavora per me.
— Magic Octopus Urn
3

MATL , 5 byte

,tPv!

Provalo online!

Spiegazione:

(implicit input)
,               # do twice:
 t              # dup top of stack
 P              # flip vertically
 v              # vertically concatenate
 !              # transpose
(implicit output)

— Giuseppe
fonte
3

JavaScript (Node.js) , 62 55 49 46 byte

A=>(j=x=>[...x,...[...x].reverse()])(A).map(j)

Provalo online!

Perché Array.prototype.reverse()inverte l'array in posizione, devo prima fare una copia superficiale da qualche parte. A=>(j=x=>[...x,...x.reverse()])(A).map(j)non funziona.

— Shieru Asakoto
fonte
3

J , 12 byte

(,|.)@,.|."1

Provalo online!

Spiegazione

         |."1 - reverse each row
       ,.     - and stitch them to the input
 (   )@       - and 
  ,|.         - append the rows in reversed order
— Galen Ivanov
fonte
3

awk, 88 byte

{s="";for(i=NF;i>0;i--)s=" "$i s" "$i;a[FNR]=s;print s}END{for(i=NR;i>0;i--)print a[i]}
— mmuntag
fonte
3
Benvenuti in PPCG! Bella prima risposta :)
— HyperNeutrino
2

Triangolarità , 31 byte

...)...
..IEM..
.DRs+}.
DRs+...

Provalo online!

Spiegazione

Rimozione dei caratteri che compongono il riempimento, ecco cosa fa il programma:

)IEMDRs+}DRs+ – Full program. Takes a matrix as a 2D list from STDIN.
)             – Push a 0 onto the stack.
 I            – Take the input at that index.
  E           – Evaluate it.
   M    }     – For each row...
    DR        – Duplicate and replace the second copy by its reverse.
      s+      – Swap and append.
         DR   – Duplicate the result and replace the second copy by its reverse.
           s+ – Swap and append.
— Mr. Xcoder
fonte
2

APL + WIN, 11 byte

Richiede una matrice 2d di numeri interi.

m⍪⊖m←m,⌽m←⎕
— Graham
fonte
2

Stax , 5 byte

:mm:m

Esegui ed esegui il debug online

:msignifica specchio, che è input.concat(reverse(input)). m, in questo contesto significa output ogni riga dopo l'applicazione ...

Quindi, rispecchia l'array di righe, quindi rispecchia ogni riga e output.

— ricorsivo
fonte
2

Japt , 6 byte

mê1 ê1

Provalo qui

Spiegazione

           :Implicit input of 2D array
m          :Map
 ê1        :  Mirror sub array
    ê1     :Mirror main array
— ispido
fonte
2

Rubino , 35 byte

->a{r=->b{b+b.reverse}
r[a].map &r}

Provalo online!

Un lambda che accetta un array 2D e restituisce un array 2D. È semplice, ma ecco comunque la versione non golfata:

->a{
  r=->b{ b+b.reverse } # r is a lambda that returns the argument and its reverse
  r[a].map &r          # Add the array's reverse, then add each row's reverse
}
— benj2240
fonte
2

Java 8, 140 131 byte

m->{String r="";for(int a=m.length,b=m[0].length,i=a+a,j;i-->0;r+="\n")for(j=b+b;j-->0;)r+=m[i<a?i:a+a+~i][j<b?j:b+b+~j];return r;}

Spiegazione:

Provalo online.

m->{                      // Method with integer-matrix parameter and String return-type
  String r="";            //  Result-String, starting empty
  for(int a=m.length,     //  Amount of rows of the input-matrix
          b=m[0].length,  //  Amount of columns of the input-matrix
          i=a+a,j;        //  Index integers
      i-->0;              //  Loop over double the rows
      r+="\n")            //    After every iteration: append a new-line to the result
     for(j=b+b;j-->0;)    //   Inner loop over double the columns
       r+=                //    Append the result with:
          m[i<a?          //     If `i` is smaller than the amount of rows
             i            //      Use `i` as index in the input-matrix
            :             //     Else:
             a+a+~i]      //      Use `a+a+i-1` as index instead
           [j<b?          //     If `j` is smaller than the amount of columns
             j            //      Use `j` as index in the input-matrix
            :             //     Else:
             b+b+~j];     //      Use `b+b+j-1` as index instead
  return r;}              //  Return the result-String
— Kevin Cruijssen
fonte
2

J , 11 byte

Funzione prefisso tacito anonimo.

|:@(,|.)^:2

Provalo online!

|: trasporre

@(…) il risultato di:

 , l'argomento seguito da

 |. il suo rovescio

^:2 e tutto ciò fatto due volte

— Adamo
fonte
2

SNOBOL4 (CSNOBOL4) , 119 113 byte

	T =TABLE()
I	X =X + 1
	I =INPUT	:F(D)
	OUTPUT =T<X> =I REVERSE(I)	:(I)
D	X =X - 1
	OUTPUT =GT(X) T<X>	:S(D)
END

Provalo online!

Accetta input come stringhe su STDIN, senza spazi. Questo funziona solo perché le cifre sono 1-9e altrimenti fallirebbero.

— Giuseppe
fonte
Posso capire perché le persone non usano più questa lingua. Questo è così strano.
— Pavel
1
@Pavel SNOBOL è davvero un linguaggio terribile con cui lavorare. questa è un'implementazione C più moderna di essa che ha funzioni incorporate aggiuntive come REVERSE; l'originale supportava anche l'aritmetica dei numeri interi, per quanto ne so.
— Giuseppe
2

C (gcc) , 114 111 byte

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)printf("%d,",A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]);}

Provalo online!

C (gcc) , 109 byte (abuso della facilità di analisi)

  • Grazie a Kevin Cruijssen per aver suggerito di consentire solo numeri interi di input a una cifra; salvato due byte.
j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)putchar(A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]+48);}

Provalo online!

— Jonathan Frech
fonte
È possibile salvare 3 byte invertendo i loop. for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)
— Kevin Cruijssen,
Non soddisfa le specifiche; stampa l'array anziché restituirlo.
" Per facilitare l'analisi, si può presumere che siano tutti compresi tra 1 e 9. ", quindi è possibile rimuovere la virgola in printf("%d"per un ulteriore -1 byte.
— Kevin Cruijssen,
@Rogem Direi che la stampa dell'array rientra negli I / O accettati.
— Jonathan Frech,
1
@KevinCruijssen Grazie mille; usando la facilità di analisi sono riuscito a radere via un altro byte.
— Jonathan Frech,
2

Carbone , 5 byte

θ‖Ｃ→↓

Provalo online!

Grazie solo a ASCII per un formato di input migliore.

— Erik the Outgolfer
fonte
Mi chiedo se questo formato di input sia valido, poiché temo che il carbone non possa gestire l'input altrimenti. In caso contrario, eliminerò felicemente questa risposta.
— Erik the Outgolfer
Questo è I / o valido.
— Pavel
@Pavel Mi chiedevo solo perché avevi detto che "Il tuo programma riceverà una matrice di numeri interi 2", mentre una stringa è monodimensionale (e no, l'esterno []non la rende esattamente 2D).
— Erik the Outgolfer
@ Il solo carbone ASCII ha davvero bisogno di un metodo I / O migliore ...
— Neil
@Neil Non è stato eseguito il ping qui, ma l'ho chiamato su TNB. :)
— Erik the Outgolfer
2

Aggiungi ++ , 30 byte

D,f,@,bU€{r}B]{r}
D,r,@,dbR+

Provalo online!

Il piè di pagina trasforma semplicemente l'array nidificato nel formato nella domanda. Definisce una funzione f, che prevede una matrice (matrice nidificata) come argomento.

— caird coinheringaahing
fonte
1

Julia 0.6 , 55 49 byte

~i=i:-1:1
!x=[x x[:,~end];x[~end,:] x[~end,~end]]

Provalo online!

~(i)è una funzione per creare sezioni da igiù a1 .
Quindi ~enddà la fettaend:-1:1

!(x) è la funzione per eseguire la ricostruzione dell'array.

— Lyndon White
fonte
1

V , 12 byte

yGæGPÎy$æ_|P

Provalo online!

Spiegazione:

yG              " Yank every line
  æG            " Reverse the order of the lines
    P           " Paste what we yanked
     Î          " On every line:
      y$        "   Yank the whole line
        æ_      "   Reverse the whole line
          |     "   Move to the beginning of the line
           P    "   Paste what we yanked
— DJMcMayhem
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.