Faire des mots au carré

38

Le défi

Votre tâche consiste à créer un programme qui prend une entrée de chaîne donnée et la sort au format carré. Les chaînes vides doivent renvoyer une chaîne vide.

Exemples

Compte tenu de l'entrée:

golf

Votre programme devrait générer:

golf
o  l
l  o
flog

Contribution:

123

Sortie:

123
2 2
321

Contribution:

a

Sortie:

a

Contribution:

Hello, world!

Sortie (remarquez l’espace entre, et w - l’écart n’est pas simplement une nouvelle ligne):

Hello, world!
e           d
l           l
l           r
o           o
,           w

w           ,
o           o
r           l
l           l
d           e
!dlrow ,olleH

Notation

C'est du , donc la réponse la plus courte dans chaque langue est gagnante.

SpookyGengar
la source
@DJMcMayhem Oui, mes excuses, j'avais oublié d'ajouter cela.
SpookyGengar
2
Pas de soucis, juste une double vérification. Beau premier défi BTW! Bienvenue sur le site :)
DJMcMayhem
@SpookyGengar Souhaitez-vous ajouter un scénario de test pour une entrée d'une lettre?
musicman523
@ musicman523, je n'en ai pas déjà un? Le troisième exemple ne concerne que la lettre 'a'.
SpookyGengar
1
@SpookyGengar mon mal, je suis aveugle apparemment
musicman523

Réponses:

17

Charbon de bois , 7 à 5 octets

θ‖O↙↘

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 2 octets enregistrés grâce à @CarlosAlejo. Explication:

θ       Print the input string, making the top row
 ‖O     Reflect with overlap...
   ↙    ... down and left, to create the left side
    ↘   ... down and right, to create the bottom and right sides

(Plusieurs directions de la commande Reflect s'exécutent consécutivement plutôt que simultanément.)

Neil
la source
Wow, Jésus, je pense toujours que le charbon de bois était l'idée la plus cool d'esolang.
Magic Octopus Urn
1
Vous pouvez enregistrer deux octets si vous imprimez simplement la chaîne d'entrée et reflétez il downleftwards et downrightwards: θ‖B↙↘. Essayez-le en ligne!
Charlie
Maintenant que j'y pense, j'aurais peut-être dû utiliser ReflectOverlapplutôt que d' ReflectButterflyéviter les renversements. :-)
Charlie
1
C’est l’un des rares cas où une réponse golfée dans un langage ésotérique est plus facile à lire et à comprendre que les versions intégrales non-golfées des langages polyvalents populaires.
Caleb
Votre réponse ici fonctionne également pour 4 octets.
Oliver
10

MATL , 20 16 11 octets

otYTO6Lt&(c

Essayez-le sur MATL en ligne!

EDIT: le code fonctionne dans la version 20.2.1, antérieure au challenge. Le lien utilise cette version. (Dans 20.2.2, le code serait plus court, mais il retarde le défi).

Explication

o     % Implicitly input a string. Convert chars to ASCII codes
t     % Duplicate
YT    % 2-input Toeplitz matrix
O     % Push 0
6L    % Push predefined literal [2, -1+1j]. When used as an index, this is
      % interpreted as 2:end-1 (indexing is 1-based)
t     % Duplicate
&(    % 4-input assignment indexing. This writes 0 at the square formed by
      % rows 2:end-1 and columns 2:end-1 
c     % Convert to char. Char 0 is shown as space. Implicitly display
Luis Mendo
la source
Très impressionnant! :) Est-il possible de supprimer la ligne vide au bas de chaque sortie ou est-ce nécessaire pour la fonctionnalité?
SpookyGengar
2
@SpookyGengar C'est une requête très courante d'autoriser un simple retour à la ligne.
Jonathan Allan
@ SpookyGengar Merci! MATL affiche toujours une nouvelle ligne de fin. Comme le dit Jonathan, c'est généralement permis
Luis Mendo le
1
@LuisMendo Vous apprenez quelque chose de nouveau chaque jour. :) Merci pour la soumission - certainement le meilleur à ce jour!
SpookyGengar
6

Jelly ,  29 22  17 bytes

Charbon de bois sera trounce + d ce score ...

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY

Un lien monadique prenant et renvoyant une liste de caractères; ou un programme complet imprimant le résultat.

Essayez-le en ligne!

Comment?

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY - Link: list of characters, w     e.g. "whole"
 ⁶                - literal space character              ' '
J                 - range(length(w))                     [1,2,3,4,5]
  ẋ               - repeat                               [" ","  ","   ","    ","     "]
         Ṛ        - reverse w                            "elohw"
        "         - zip with:
       ¦          -   sparse application of:
   a              -     and (vectorises)
    0,1           -     to indexes: [0,1] (last and 1st) ["e","ll","o o","h  h","w   w"]
            $     - last two links as a monad:
          Ṛ       -   reverse                            ["w   w","h  h","o o","ll","e"]
           ;      -   concatenate                        ["w   w","h  h","o o","ll","e","e","ll","o o","h  h","w   w"]
             Ṗ    - pop (remove last entry)              ["w   w","h  h","o o","ll","e","e","ll","o o","h  h"]
              ŒḌ  - reconstruct matrix from diagonals    ["whole","h   l","o   o","l   h","elohw"]
                Y - join with newlines                   "whole\nh   l\no   o\nl   h\nelohw"
                  - if running as a full program implicit print
Jonathan Allan
la source
Très sympa! Jusqu'à présent, la solution la plus courte, mais ne fonctionne pas avec les entrées à caractère unique, et les chaînes composées de nombres, par exemple «123».
SpookyGengar
Ah, je vais devoir gérer le cas de bord à caractère unique, oui. Cela fonctionne avec les chaînes de caractères numériques, l'entrée du programme doit vraiment être citée, comme 'Hello'"Spooky's" "123", etc. (Python est utilisé pour interpréter l'entrée).
Jonathan Allan
@SpookyGengar - corrigé pour la casse à 1 caractère.
Jonathan Allan
Belle réduction de longueur!
Luis Mendo
2
Vous avez raison pour le charbon de bois.
Neil
3

C, 109 octets

i,j;f(char*s){for(i=j=printf("%s\n",s)-2;1[++s];)printf("%c%*c\n",*s,i,s[j-=2]);for(;*s*~i--;)putchar(*s--);}

Essayez-le en ligne!

Trucs remarquables:

  • Au lieu de gaspiller des octets strlen, nous saisissons simplement la longueur de la chaîne tout en imprimant simultanément la première ligne:

    i=j=printf("%s\n",s)-2

    Cela fonctionne car printfrenvoie le nombre d'octets écrits.

  • Pour les lignes du milieu, nous devons boucler la chaîne mais exclure le premier et le dernier caractère. Ceci est réalisé avec la condition

    1[++s]

    (qui est plus court que (++s)[1]), qui saute le premier caractère car il ++est dans la condition et saute le dernier en s'arrêtant lorsque le caractère passé le caractère actuel est '\0'(plutôt que de s'arrêter à '\0' ).

  • Dans le corps de la première boucle,

    printf("%c%*c\n",*s,i,s[j-=2])

    nous imprimons le caractère actuel, puis le caractère "en miroir" approprié (garder la trace de j, ce qui entre dans les négatifs, ce qui crée une situation étrange d’indexation dans une chaîne avec un nombre négatif), complétée par une longueur iavec des espaces (où iest commodément strlen(s) - 1).

  • L'impression inversée sur la dernière ligne est assez simple. le seul truc est le *s*~i--, qui est le moyen le plus court pour obtenir des i+2itérations du corps de la boucle (qui ne dépend pas de i, tout iest utilisé pour compter). La *s*partie funky veille à ce que la boucle ne s'exécute pas si *sest '\0', ce qui se produit lors d'une entrée de longueur 1.

Poignée de porte
la source
3

Octave, 40 octets

@(s,t=toeplitz(s),u=t(x=2:end-1,x)=32)t;

Essayez-le en ligne!

C’est ma réponse mais postée après la réponse de @Luis MATL

rahnema1
la source
2
Très belle réponse. Btw: votre code a écrasé la branche de développement de GNU Octave 4.3.1 (b481a9baeb61) et fait maintenant partie de la suite de tests :-) hg.savannah.gnu.org/hgweb/octave/rev/c94e9509461b
Andy
1
@Andy Merci et bienvenue à codegolf! Je suis heureux si cela peut aider à améliorer le projet Octave!
rahnema1
3

Haskell , 84 78 octets

f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]
r=reverse

Essayez-le en ligne! Utilisation: f "test". Retourne une liste de lignes.

Edit: -6 octets grâce à dianne!

Laikoni
la source
1
vous pouvez économiser quelques octets en utilisant le modèle garde en tant que garde et en définissant un synonyme pour reverse; r=reverse;f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]est 78 octets.
dianne
2

Python 2 , 89 81 88 86 octets

i=input();n=k=len(i)-2
print i
exec'print i[~k]+" "*n+i[k];k-=1;'*n
if~k:print i[::-1]

Essayez-le en ligne!

Koishore Roy
la source
Même échec pour les cordes de longueur 1 que la mienne avait.
Stephen
@StepHen a réglé le problème et a poursuivi sa progression: D
Koishore Roy
2

R , 113 octets

function(s){n=length(s<-strsplit(s,'')[[1]])
m=matrix(' ',n,n)
m[n,n:1]=m[,1]=m[1,]=m[n:1,n]=s
write(m,'',n,,'')}

Essayez-le en ligne!

Giuseppe
la source
Ma réponse au défi de la dupe est plus courte - quelle différence une année peut faire!
Giuseppe
2

05AB1E , 17 16 15 19 octets

ÂDÂø¦¨Dgú€Ás)˜»Igi¨

Essayez-le en ligne!

Explication

Exemple avec input = golf

ÂDÂ                  # bifurcate, duplicate, bifurcate
                     # STACK: 'golf', 'flog', 'flog', 'golf'
   ø                 # zip the top 2 items
                     # STACK: 'golf', 'flog', ['fg', 'lo', 'ol', 'gf']
    ¦¨               # remove the first and last element
                     # STACK: 'golf', 'flog', ['lo', 'ol']
      Dg             # get the length of the list
                     # STACK: 'golf', 'flog', ['lo', 'ol'], 2
        ú            # prepend that many spaces to each element
                     # STACK: 'golf', 'flog', ['  lo', '  ol']
         €Á          # rotate each right
                     # STACK: 'golf', 'flog', ['o  l', 'l  o']
           s         # swap the top 2 items
                     # STACK: 'golf', ['o  l', 'l  o'], 'flog'
            )˜       # wrap in a flattened list
                     # STACK: ['golf', 'o  l', 'l  o', 'flog']
              »      # join on newline
               Igi¨  # if input is length 1, remove last char

Le correctif pour la saisie d'une lettre était assez coûteux.
Je me sens comme une approche différente pourrait être mieux maintenant.

Emigna
la source
1

Python 2 , 99 88 octets

-4 octets grâce à musicman523.

lambda s:s[1:]and[s]+[s[i]+' '*(len(s)-2)+s[~i]for i in range(1,len(s)-1)]+[s[::-1]]or s

Essayez-le en ligne!

Retourne une liste de chaînes.

totalement humain
la source
Proche! La sortie n'est pas exactement ce que je demande.
SpookyGengar
1
89 octets en se déplaçant set s[::-1]dans lajoin
musicman523
Cela ne fonctionne pas très bien pour les chaînes de longueur 1
musicman523
2
Juste pour noter, tous les problèmes ont été corrigés.
totalement humain
1

Mathematica, 128 octets

(c=Column;g=Length[x=Characters@#]-1;If[g==0,#,c@{#,c@Table[""<>{x[[i]],""<>Table[" ",g-1],x[[-i]]},{i,2,g}],StringReverse@#}])&
J42161217
la source
1

C, 96 octets

i,l;f(char*s){for(i=l=puts(s)-2;--i;)printf("%c%*c\n",s[l-i],l,s[i]);for(;l+1;)putchar(s[l--]);}

Version bonus (122 octets):

x,y,i,l;f(char*s){for(i=l=puts(s)-1;++i<l*-~l;putchar(x==l?10:x%~-l*(y%~-l)?32:s[(x*y?l+l-2-x-y:x+y)%l]))x=i%-~l,y=i/-~l;}
orlp
la source
1

Rapide 3 , 215 199 octets

let s=readLine()!,c=s.characters,r:[Character]=c.reversed(),b=c.count
print(s)
if b>1{for i in 0..<b-2{print("\(r.reversed()[i+1])\(String.init(repeating:" ",count:b-2))\(r[i+1])")};print(String(r))}

Essayez-le en ligne

Mic1780
la source
1

Python 3, 88 octets

w=input();p=print;l=len(w)-2
[p(w[n+1]+' '*l+w[l-n])for n in range(l)]
l+1and p(w[::-1])
Levi
la source
1
Bienvenue chez PPCG!
Martin Ender
Bienvenue sur le site aussi! Je crois que cela l+1 andpourrait être réécrit l+1andpour sauver un octet.
Wheat Wizard
@ WheatWizard édité - merci! J'ai été surpris que cela a fonctionné ...
Levi
Cela fonctionnera sauf dans le cas 0oroù python ne parvient pas à analyser car il 0os'agit d'un préfixe octal.
Wheat Wizard
Quand je lance cela, il ne semble pas imprimer la ligne supérieure ... tio.run/##FcoxCsQgEAXQPqeYLk7EwqRL8CRiEVh3Iww/...
Coty Johnathan Saxman
1

JavaScript (ES8), 108 112 octets

let f = 

s=>(n=s.length)<2?s:(r=[...s].reverse()).slice(1,-1).reduce((a,v,i)=>a+`
`+s[i+1].padEnd(n-1)+v,s)+`
`+r.join``

o.innerHTML = f("hello folks!")
<pre id="o"></pre>

Moins golphé

s=>
   (n=s.length) < 2 ?    // record and check length
   s :                   // s has 0 or 1 char, else
   (r=[...s].reverse())  // reverse characters,
   .slice(1,-1)          // exclude 1st and last
   .reduce((a,v,i)=>     // append inner lines
      a +'\n' +s[i+1].padEnd(n-1) + v
    ,s)                  // to first line
    + '\n' +r.join("")   // append characters reversed

Merci à Justin Mariner d’avoir économisé de nombreux octets, qui ont tous été utilisés en ajoutant la vérification du caractère zéro ou un caractère nécessaire pour relever le défi. Tu comprends :-(

traktor53
la source
Vous pouvez économiser 7 octets en faisant la deuxième ligne `+s[i+1].padEnd(s.length-1)+v,s)+`et en utilisant r.join``.
Justin Mariner
Merci @JustinMariner pour les conseils concernant String.prototype.padStartles littéraux de modèles marqués. J'avais besoin de ça pour garder au minimum l'addition du contrôle de longueur :-)
traktor53
Votre espacement est un caractère trop court maintenant; vous pouvez résoudre ce problème et en économiser quelques-uns en faisant (n=s.length-1)?(r=<...>+r.join``:set en utilisant padEnd(n). Si la longueur est 1, length-1est 0(false).
Justin Mariner
L'espacement @JustinMariner est fixe, mais j'ai conservé le test de longueur. D'après ce que j'ai compris, les chaînes de longueur nulle et les chaînes d'un caractère se retournent sans retour à la ligne ni répétition de la chaîne.
traktor53
1
padEndest ES2017.
Neil
1

PHP , 118 octets

echo $s=$argv[1];$l=strlen($r=strrev($s))-1;for($i=$l-1;$l&&$i;)echo "\n".str_pad($r[$i],$l).$s[$i].(--$i?"":"\n$r");

Essayez-le en ligne!

echo $s = $argv[1];
$l = strlen($r = strrev($s)) - 1;

for ($i = $l - 1; $l && $i;)
    echo "\n" . str_pad($r[$i], $l) . $s[$i] . (--$i ? "" : "\n$r");
Marcv
la source
1

APL , 58 octets

{(' ',⍵)[x+(x←∘.{((c-1)=⍺⌈⍵)∨0=⍺⌊⍵}⍨r)×o⌊⌽⊖o←∘.⌈⍨r←⍳c←≢⍵]}

Avec ⎕IO←0.

Essayez-le en ligne!

Comment?

c←≢⍵ - longueur de la ficelle

r←⍳ - intervalle

o←∘.⌈⍨ - produit extérieur avec minimum

123
223
333

o⌊⌽⊖- minimiser avec lui-même tourné à 180 o

123  ⌊  333  =  123
223  ⌊  322  =  222
333  ⌊  321  =  321

× - multiplier avec

x←∘....⍨r - produit extérieur de la gamme avec

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - le cadre de la matrice

111  ×  123  =  123
101  ×  222  =  202
111  ×  321  =  321

x+ - ajouter le cadre

111  +  123  =  234
101  +  202  =  303
111  +  321  =  432

(' ',⍵)[...] - récupère l'index de la chaîne concaténée à l'espace

Uriel
la source
Peut ⍉⊖⍉⊖être ⌽⊖?
Zacharý
@ Zacharý merci
Uriel
0

JavaScript (ES2017), 87 octets

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

Version ES6: 93 octets

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i]+' '.repeat(l-1)+c:z.join``:s).join`
`

Moins joué au golf

s => (
  l = s.length-1,
  [...s].reverse().map( // scan string backwards
     (c, i, z) => 
     i != 0 // check if top row
     ? l-i != 0 // check if bottom row
       ? s[i].padEnd(l) + c // any middle row
       : z.join`` // bottom row: string reversed
     :s // top row: original string
  ).join`\n`
)

F=
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

function update() {
  O.textContent = F(I.value)
}

update()
<input id=I value='Hello, world!' oninput='update()'>
<pre id=O></pre>

edc65
la source
padEndest ES2017.
Neil
@Neil merci, je vais changer de cap
edc65
Vous pouvez enregistrer un octet sur votre version ES6 en utilisant l+~i, ce qui évite de soustraire 1 deux fois, mais vous pouvez soustraire 2 fois.
Neil
@Neil il devrait êtrel-~-i
edc65
Je pensais à s=>[...s].reverse(l=s.length).map((c,i,z)=>i?l+~i?s[i]+' '.repeat(l-2)+c:z.join``:s).join`\n` mais s=>[...s].reverse(l=s.length-2).map((c,i,z)=>i?i+~l?s[i]+' '.repeat(l)+c:z.join``:s).join`\n` fonctionne aussi.
Neil
0

Java, 191 octets

(s)->{PrintStream o=System.out;int l=s.lenght();o.println(s);for(int i=0;i<l;i++){o.printf("%"+"s%"+(l-1)+"s%n",s.charAt(i),s.charAt(l-1-i));for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}}};
Serverfrog
la source
(s)peut être juste s. Les boucles avec des lignes simples à l'intérieur peuvent avoir leurs accolades supprimées. Vous pouvez retourner au lieu d’imprimer si cela vous permet d’économiser des octets. Vous utilisez int idans les deux boucles, je ne peux pas dire si elles sont dans des domaines différents mais méritent d'être soulignées. L’initialisation de ces variables ensemble enregistre généralement des octets. for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}-> for(int i=0;i<l;){o.print(s.charAt(l-1-i++));}. Vous n'avez pas besoin du point-virgule final.
TheLethalCoder
Merci de le signaler;) (pas très familier avec le golf). L'optimisera plus tard!
Serverfrog
0

C # (.NET Core) , 179 161 octets

-18 octets grâce à TheLethalCoder

using System.Linq;
s=>{int l=s.Length-1,i=1;var d=s.Reverse().ToArray();while(i<l)s+="\n"+s[i]+new string(' ',l-1)+d[i++];if(l>1)s+="\n"+new string(d);return s;};

Essayez-le en ligne!

Je ne suis pas sûr des règles, si cela est nécessaire pour compter les octets ou non:

using System.Linq;

Quelqu'un s'il vous plaît corrigez-moi à ce sujet.

Ungolfed:

s =>
{
    int l = s.Length - 1, i = 1;
    var d = s.Reverse().ToArray();
    while (i < l)
        s += "\n" + s[i] + new string(' ', l - 1) + d[i++];
    if (l > 1)
        s += "\n" + new string(d);
    return s;
};
Grzegorz Puławski
la source
Bonjour et bienvenue sur PPCG! Vous utilisez Linq, vous devez donc l'inclure usingdans votre nombre d'octets. Comme vous utilisez Linq ToCharArray()peut être juste ToArray(), en avez-vous vraiment besoin avant Reverse()? Au fur et à mesure que vous utilisez, Stringvous devez soit le qualifier complètement, soit inclure l’utilisation. Toutefois, cela peut être facilement résolu en le modifiant également string. Le ifpourrait être plus court qu'un ternaire comme s+=l>1?if code:"";. Vous pouvez supprimer le i++de la boucle et l'incrémenter à d[i++].
TheLethalCoder
Initialiser iavec lcomme int l=s.Length-1,i=1;. Et je pense que ça pourrait être ça!
TheLethalCoder
@TheLethalCoder merci! J'ai ajouté vos suggestions au code. Quelques notes: j'ai totalement oublié que la chaîne a effectivement IEnumerable; String au lieu de string était un résidu de Java avec lequel je me battais encore, ternary était en fait aussi étonnamment long; et après vos modifications, j'ai changé pour (; expr;) en tant que (expr) car il semble plus joli et compte le même nombre d'octets. Merci encore.
Grzegorz Puławski
Pas de soucis! Les ternaires sont parfois plus courtes, mais valent toujours la peine d’être essayées.
TheLethalCoder
0

Retina , 106 octets

..+
$&¶$&
O$^`.(?=.*$)

\G.
$&$%'¶
r`.\G
¶$%`$&
+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2
T`p` `(?<=.¶.).*(?=.¶.)
G`.

Essayez-le en ligne! Explication:

..+
$&¶$&

S'il y a au moins deux caractères, dupliquez l'entrée.

O$^`.(?=.*$)

Inverser le doublon.

\G.
$&$%'¶
r`.\G
¶$%`$&

Turn the strings into triangles. The top triangle starts with the input and removes the first character each time, while the bottom triangle starts with the first letter of the reversed input and adds a character each time.

+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2

Join the triangles together, overlapping so that the last character forms the / diagonal.

T`p` `(?<=.¶.).*(?=.¶.)

Change all the characters to spaces, if they are at least one character away from the end on every side.

G`.

Delete any left-over blank lines.

Neil
la source
0

Python 3, 85 bytes

Using the input for the top row :)

a=input()
b=len(a)
for i in range(b-2):print(a[1+i]+" "*(b-2)+a[-2-i])
print(a[::-1])
abc123
la source
Are you sure this gives a correct answer?
Koishore Roy
0

Lua, 104 bytes

print(s);for a=2,#s-1 do print(s:sub(a,a)..(" "):rep(#s-2)..s:sub(#s-a+1,#s-a+1)) end;print(s:reverse())

Try it online!


la source
but you only used p once...
Leaky Nun
True... gonna change that.
0

Python 3, 106 bytes

A functional version...

w=input();p=print;l=len(w)-2
def f(k):p(w[k]+' '*l+w[-k-1]);l-k>0and f(k+1)
l<0 or f(1)or l<1or p(w[::-1])
Levi
la source
0

Python 2, 100 bytes

lambda a:'\n'.join([a]+(len(a)>1)*([a[i]+(len(a)-2)*' '+a[~i]for i in range(1,len(a)-1)]+[a[::-1]]))

Try it online!

officialaimm
la source
0

Mathematica, 138 91 bytes

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&

You can try it online with by pasting the following at the Wolfram Cloud Sandbox and clicking "evaluate cell" or hitting Shift+Enter or Numpad Enter:

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&@{"g","o","l","f","y"}//MatrixForm
Mark S.
la source