Reconstruire un tableau rectangulaire à partir d'un coin

30

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!

code-golf  array-manipulation  matrix 
— Pavel
source
1
Je parie que le charbon de bois peut le faire en moins de 10 ans
— FantaC
1
@tbfninja chat.stackexchange.com/transcript/message/43184083#43184083 mais pourrait être plus court avec un format d'entrée différent.
— Pavel
@MagicOctopusUrn yes
— Pavel
2
@tfbninja ＷＳ⟦ι⟧‖Ｍ→↓peut-être? 5 octets pour lire l'entrée et 4 pour la refléter.
— Neil
4
Je suis sûr à 99% qu'il y a une langue qui fait ça avec ╬(ou un personnage similaire), je ne me souviens juste pas lequel: c
— Rod

Réponses:

1

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

— HyperNeutrino
source
5

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
— pizzapants184
source
5

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.

— Martin Ender
source
Cela ne ressemble à aucune saveur regex que je connais: P
— Pavel
@ Pavel Parce que Retina n'est pas seulement une expression régulière. :)
— Erik the Outgolfer
@ Pavel la seule partie de ce code qui est une expression régulière réelle est $sur la première ligne. ;) J'ajouterai une explication plus tard.
— Martin Ender
5

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.

— Urne de poulpe magique
source
— M. Xcoder
Pour faciliter l'analyse, vous pouvez supposer qu'ils sont tous compris entre 1 et 9 - Je pense donc que cela est valide. En attente de la confirmation de Pavel, je suppose
— M. Xcoder
@ Mr.Xcoder, c'était ce que j'avais au départ, puis les tableaux TIO 2D en entrée étaient bizarres ... donc j'ai dû trouver ce truc d'en-tête.
— Urne de poulpe magique
Une chaîne est un tableau de caractères, donc une liste de chaînes est toujours un tableau 2D. @ La solution de Mr.Xcoder est valide.
— Pavel
Coolio, travaille pour moi.
— Urne de poulpe magique
3

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)

— Giuseppe
source
3

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.

— Shieru Asakoto
source
3

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]}
— mmuntag
source
3
Bienvenue chez PPCG! Belle première réponse :)
— HyperNeutrino
2

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.
— M. Xcoder
source
2

APL + WIN, 11 octets

Demande un tableau 2d d'entiers.

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

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.

— récursif
source
2

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
}
— benj2240
source
2

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
— Kevin Cruijssen
source
2

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

— Adam
source
2

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.

— Giuseppe
source
Je peux voir pourquoi les gens n'utilisent plus cette langue. Cela est tellement bizarre.
— Pavel
1
@Pavel SNOBOL est vraiment un langage terrible avec lequel travailler. c'est une implémentation C plus moderne de celui-ci qui a des fonctions internes supplémentaires comme REVERSE; l'arithmétique entière uniquement prise en charge d'origine, pour autant que je sache.
— Giuseppe
2

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!

— Jonathan Frech
source
Vous pouvez économiser 3 octets en inversant les boucles. for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)
— Kevin Cruijssen
Ne remplit pas les spécifications; imprime le tableau, plutôt que de le renvoyer.
" Pour faciliter l'analyse, vous pouvez supposer qu'ils sont tous compris entre 1 et 9. ", vous pouvez donc supprimer la virgule dans le printf("%d"pour -1 octet supplémentaire.
— Kevin Cruijssen
@Rogem Je dirais que l'impression de la matrice est conforme aux E / S acceptées.
— Jonathan Frech
1
@KevinCruijssen Merci beaucoup; en utilisant la facilité d'analyse, j'ai réussi à raser un autre octet.
— Jonathan Frech
2

Fusain , 5 octets

θ‖Ｃ→↓

Essayez-le en ligne!

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

— Erik le Outgolfer
source
Je me demande si ce format d'entrée est valide, car je crains que Charcoal ne puisse pas gérer l'entrée autrement. Si ce n'est pas le cas, je supprimerai volontiers cette réponse.
— Erik the Outgolfer
Il s'agit d'E / S valides.
— Pavel
@ Pavel Je me demandais simplement parce que vous aviez dit que "votre programme recevra un tableau bidimensionnel d'entiers", alors qu'une chaîne est à 1 dimension (et non, l'extérieur []ne le fait pas exactement en 2D).
— Erik the Outgolfer
@ Charbon de bois uniquement ASCII a vraiment besoin d'une meilleure méthode d'E / S ...
— Neil
@Neil Il n'a pas été cinglé ici, mais je l'ai cinglé sur TNB. :)
— Erik the Outgolfer
1

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.

— Lyndon White
source
1

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
— DJMcMayhem
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.