J'ai eu une fois un magnifique tableau rectangulaire. C'était très symétrique, mais malheureusement il s'est effondré et maintenant je n'ai que le coin supérieur gauche. Votre tâche consistera à reconstruire la baie d'origine.

Votre programme recevra un tableau bidimensionnel d'entiers. Pour faciliter l'analyse, vous pouvez supposer qu'ils sont tous compris entre 1 et 9. Votre tâche consiste à inverser les colonnes du tableau, ses lignes et les deux, à assembler les coins résultants et à renvoyer le tableau résultant.

Vous pouvez supposer que les dimensions du tableau seront au moins 1x1.

Cas de 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

C'est le code-golf , le moins d'octets gagne!

Proton , 29 octets

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

Essayez-le en ligne!

Il existe cependant quelques autres approches intéressantes:

Proton , 29 octets

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

Essayez-le en ligne!

Vous pouvez définir la sous-fonction miroir gen ligne, car Proton. Ce n'est pas plus court cependant.

Proton , 36 octets

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

Essayez-le en ligne!

Cela devrait être (a=>zip(*(a+a[by-1])))*224 octets, mais la fonction zip est complètement rompue. Fondamentalement, vous le mettez en miroir et le zip, puis faites cela deux fois (vous pouvez multiplier une fonction par un entier positif pour appliquer la fonction plusieurs fois).

Toile , 1 octet

╬

Essayez-le ici!

Sorties sous forme de chaîne multiligne

Haskell, 25 24 octets

r=(++)<*>reverse
r.map r

Essayez-le en ligne!

Python 3, 38 octets

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

Essayez-le en ligne!

Prend une liste de listes et renvoie une liste de listes.

Explication:

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

Husk ,  7  6 octets

Par coïncidence, Erik avait affiché le même code exact dans le salon de discussion Husk environ une minute avant de le publier.

‼oTS+↔

Essayez-le en ligne!

Version perméable, 7 octets :

mS+↔S+↔

Rétine , 13 octets

\%`$
$^$`
Vs`

Essayez-le en ligne!

Explication

\%`$
$^$`

Sur chaque ligne ( %), faites correspondre la fin de la ligne ( $), insérez l'inverse ( $^) de la ligne entière ( $`) et imprimez le résultat avec un saut de ligne ( \). Cela fait la réflexion le long de l'axe vertical et imprime la première moitié de la sortie.

Vs`

Cela inverse simplement la chaîne entière, ce qui équivaut à une rotation à 180 °, ou dans notre cas (en raison de la symétrie horizontale) une réflexion le long de l'axe horizontal. De cette façon, cela fonctionne, c'est que Vl'expression régulière (inverse) est (?m:^.*$), qui correspond normalement à chaque ligne de la chaîne. Cependant, nous activons l'option singleline s, qui fait également .correspondre les sauts de ligne et donc cette expression régulière par défaut correspond en fait à la chaîne entière.

Le résultat est imprimé automatiquement à la fin du programme, nous donnant la seconde moitié de la sortie.

05AB1E , 2 octets

∞∊

Essayez-le en ligne!

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

Crédit pour M. Xcoder indiquant que les tableaux de chaîne peuvent compter comme des tableaux 2D et Pavel pour confirmer.

Gelée , 5 octets

m€0m0

Essayez-le en ligne!

MATL , 5 octets

,tPv!

Essayez-le en ligne!

Explication:

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

Octave ,  33  29 octets

Merci à @Giuseppe d'avoir joué quatre octets au golf!

@(A)[B=[A;flip(A)] fliplr(B)]

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Parce Array.prototype.reverse()qu'inverse le tableau en place, je dois d'abord faire une copie peu profonde quelque part. A=>(j=x=>[...x,...x.reverse()])(A).map(j)ne marche pas.

J , 12 octets

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

Essayez-le en ligne!

Explication

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

awk, 88 octets

{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]}

Triangularité , 31 octets

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

Essayez-le en ligne!

Explication

En supprimant les caractères qui composent le remplissage, voici ce que fait le programme:

)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.

R , 57 octets

function(m)rbind(N<-cbind(m,m[,ncol(m):1]),N[nrow(N):1,])

Essayez-le en ligne!

APL + WIN, 11 octets

Demande un tableau 2d d'entiers.

m⍪⊖m←m,⌽m←⎕

Stax , 5 octets

:mm:m

Exécutez-le et déboguez-le en ligne

:msignifie miroir, ce qui est input.concat(reverse(input)). m, dans ce contexte signifie sortir chaque ligne après avoir appliqué ...

Donc, mettez en miroir le tableau de lignes, puis mettez en miroir chaque ligne et chaque sortie.

Japt , 6 octets

mê1 ê1

Essayez-le ici

Explication

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

Mathematica , 29 octets

(g=#~Join~Reverse@#&)@*Map[g]

Essayez-le en ligne!

SOGL V0.12 , 2 octets

-1 octet grâce à dzaima.

╬ø

Essayez-le ici!

APL (Dyalog Classic) , 7 octets

⍪∘⊖⍨⊢,⌽

Essayez-le en ligne!

Rubis , 35 octets

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

Essayez-le en ligne!

Un lambda acceptant un tableau 2D et renvoyant un tableau 2D. C'est simple, mais voici la version non golfée de toute façon:

->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
}

Java 8, 140 131 octets

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;}

Explication:

Essayez-le en ligne.

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

J , 11 octets

Fonction de préfixe tacite anonyme.

|:@(,|.)^:2

Essayez-le en ligne!

|: transposer

@(…) Le résultat de:

 , l'argument suivi de

 |. son revers

^:2 et tout cela fait deux fois

SNOBOL4 (CSNOBOL4) , 119 113 octets

	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	

Essayez-le en ligne!

Prend l'entrée sous forme de chaînes sur STDIN, sans espaces. Cela ne fonctionne que parce que les chiffres sont 1-9et échoueraient autrement.

C (gcc) , 114 111 octets

• Enregistré trois octets grâce à Kevin Cruijssen ; inverser les boucles.

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)]);}

Essayez-le en ligne!

C (gcc) , 109 octets (abus de la facilité d'analyse)

• Merci à Kevin Cruijssen d' avoir suggéré de n'autoriser que les entiers à un chiffre; enregistré deux octets.

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);}

Essayez-le en ligne!

Fusain , 5 octets

θ‖Ｃ→↓

Essayez-le en ligne!

Merci à ASCII uniquement pour un meilleur format d'entrée.

Ajouter ++ , 30 octets

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

Essayez-le en ligne!

Le pied de page transforme simplement le tableau imbriqué dans le format de la question. Définit une fonction f, qui attend une matrice (tableau imbriqué) comme argument.

Julia 0,6 , 55 49 octets

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

Essayez-le en ligne!

~(i)est une fonction pour créer une tranche de ibas en haut 1. Donne
donc ~endla trancheend:-1:1

!(x) est la fonction permettant de reconstruire le tableau.

V , 12 octets

yGæGPÎy$æ_|P

Essayez-le en ligne!

Explication:

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