Fazendo palavras ao quadrado

38

O desafio

Sua tarefa é criar um programa que aceite qualquer entrada de sequência de caracteres e produza a entrada em um formato quadrado. Cadeias vazias devem retornar uma cadeia vazia.

Exemplos

Dada a entrada:

golf

Seu programa deve gerar:

golf
o  l
l  o
flog

Entrada:

123

Saída:

123
2 2
321

Entrada:

a

Saída:

a

Entrada:

Hello, world!

Saída (observe o espaço entre, ew - a diferença não é apenas uma nova linha):

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

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

Pontuação

Isso é , então a resposta mais curta em cada idioma vence.

SpookyGengar
fonte
@DJMcMayhem Sim, minhas desculpas por me esquecer de acrescentar isso.
SpookyGengar
2
Não se preocupe, apenas verifique. Bom primeiro desafio BTW! Bem-vindo ao site :)
DJMcMayhem
@SpookyGengar Você adicionaria um caso de teste para uma entrada de uma letra?
precisa
@ musicman523 já não tenho um? O terceiro exemplo, envolvendo apenas a letra 'a'.
SpookyGengar
1
@SpookyGengar meu mau, eu sou cego aparentemente
musicman523

Respostas:

17

Carvão , 7 5 bytes

θ‖O↙↘

Experimente online! Link é a versão detalhada do código. Editar: salvou 2 bytes graças a @CarlosAlejo. Explicação:

θ       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

(Várias direções para o comando Reflect são executadas consecutivamente e não simultaneamente.)

Neil
fonte
Uau, Jesus, eu ainda acho que o carvão foi a idéia mais legal do esolang.
Magic Octopus Urn
1
Você pode salvar dois bytes se você só imprimir a cadeia de entrada e refleti-la downleftwards e downrightwards: θ‖B↙↘. Experimente online!
21717 Charlie
Agora que penso nisso, talvez eu devesse ter usado em ReflectOverlapvez de ReflectButterflyevitar virar caracteres. :-)
Charlie
1
Este é um dos raros casos em que uma resposta em golfe em um idioma esotérico é mais fácil de ler e entender do que as versões completas e não-golfadas de idiomas populares de uso geral.
Caleb
Sua resposta aqui também funciona para 4 bytes.
Oliver
10

MATL , 20 16 11 bytes

otYTO6Lt&(c

Experimente no MATL online!

EDIT: O código funciona na versão 20.2.1, que antecede o desafio. O link usa essa versão. (No 20.2.2, o código seria mais curto, mas pós-datado o desafio).

Explicação

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
fonte
Muito impressionante! :) É possível remover a linha em branco na parte inferior de cada saída ou isso é necessário para a funcionalidade?
SpookyGengar
2
@SpookyGengar É uma solicitação muito comum permitir uma única nova linha à direita.
Jonathan Allan
@SpookyGengar Thanks! MATL sempre exibe uma nova linha à direita. Como Jonathan diz, isso geralmente é permitido
Luis Mendo
1
@LuisMendo Você aprende algo novo todos os dias. :) Obrigado pela submissão - definitivamente o melhor até agora!
SpookyGengar
6

Geléia ,  29 22  17 bytes

Carvão irá marcar + d esta pontuação ...

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

Um link monádico recebendo e retornando uma lista de caracteres; ou um programa completo imprimindo o resultado.

Experimente online!

Quão?

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
fonte
Muito legal! Até agora, a solução mais curta, mas não funciona com entradas de caractere único e cadeias de caracteres que consistem em números, ou seja, '123'.
SpookyGengar
Ah, vou ter que lidar com o caso de borda de caractere único, sim. Ele funciona com cadeias de caracteres de dígitos, a entrada do programa realmente deve ser citada, como 'Hello'"Spooky" "123", etc. (Python é usado para interpretar a entrada).
22617 Jonathan Allan
@ SpookyGengar - corrigido para o caso de 1 caractere.
Jonathan Allan
Nice redução de comprimento!
Luis Mendo
2
Você está certo sobre carvão.
Neil
3

C, 109 bytes

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

Experimente online!

Truques dignos de nota:

  • Em vez de desperdiçar bytes strlen, simplesmente pegamos o comprimento da string enquanto imprimimos simultaneamente a primeira linha:

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

    Isso funciona porque printfretorna o número de bytes gravados.

  • Para as linhas do meio, precisamos fazer um loop sobre a string, mas excluir o primeiro e o último caractere. Isso é alcançado com a condição

    1[++s]

    (que é mais curto que (++s)[1]), que pula o primeiro caractere devido à ++condição dele e pula o último, parando quando o personagem que está além do caractere atual está '\0'(em vez de parar em '\0' ).

  • No corpo do primeiro loop,

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

    imprimimos o caractere atual e, em seguida, o caractere "espelhado" apropriado (acompanhando j, que entra nos negativos, resultando na situação ímpar de indexar em uma string com um número negativo) preenchido com um comprimento de iespaços (onde iestá convenientemente strlen(s) - 1).

  • A impressão invertida na última linha é bastante direta; o único truque é o *s*~i--, que é a maneira mais curta de obter i+2iterações do corpo do loop (que não depende i; tudo o que ié usado é contar). O funk *s*parte garante que o laço não é executado se *sé '\0', que acontece no comprimento-1 de entrada.

Maçaneta
fonte
3

Oitava, 40 bytes

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

Experimente online!

É a minha resposta, mas postada após a resposta @Luis MATL

rahnema1
fonte
2
Resposta muito boa. Btw: seu código travou o ramo de desenvolvimento GNU Octave 4.3.1 (b481a9baeb61) e agora faz parte do conjunto de testes :-) hg.savannah.gnu.org/hgweb/octave/rev/c94e9509461b
Andy
1
@ Andy Obrigado e bem-vindo ao codegolf! Fico feliz se isso pode ajudar a melhorar o projeto Octave!
rahnema1
3

Haskell , 84 78 bytes

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

Experimente online! Uso: f "test". Retorna uma lista de linhas.

Edit: -6 bytes graças a dianne!

Laikoni
fonte
1
você pode salvar alguns bytes usando a proteção de padrão como proteção e definindo um sinônimo para reverse; r=reverse;f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]tem 78 bytes.
22717 dianne
2

Python 2 , 89 81 88 86 bytes

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

Experimente online!

Koishore Roy
fonte
A mesma falha para as cordas de comprimento 1 que a minha tinha.
Stephen
@StepHen consertou e ainda
jogou golfe
2

R , 113 bytes

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,,'')}

Experimente online!

Giuseppe
fonte
Minha resposta para o desafio dos bobos é mais curta - que diferença um ano pode fazer!
Giuseppe
2

05AB1E , 17 16 15 19 bytes

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

Experimente online!

Explicação

Exemplo com 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

A correção para entrada de uma letra era bastante cara.
Sinto que uma abordagem diferente pode ser melhor agora.

Emigna
fonte
1

Python 2 , 99 88 bytes

-4 bytes graças ao 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

Experimente online!

Retorna uma lista de strings.

totalmente humano
fonte
Fechar! A saída não é exatamente o que estou pedindo.
SpookyGengar
1
89 bytes por movimento se s[::-1]para ojoin
musicman523
Isso não funciona muito bem para o comprimento 1-cordas
musicman523
2
Apenas para observar, todos os problemas foram corrigidos.
totallyhuman
1

Mathematica, 128 bytes

(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
fonte
1

C, 96 bytes

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

Versão bônus (122 bytes):

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
fonte
1

Swift 3 , 215 199 bytes

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

Experimente online

Mic1780
fonte
1

Python 3, 88 bytes

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
fonte
1
Bem-vindo ao PPCG!
Martin Ender
Bem-vindo ao site também! Acredito que isso l+1 andpossa ser reescrito l+1andpara salvar um byte.
Assistente de trigo
@WheatWizard editado - obrigado! Fiquei surpreso que funcionou ...
Levi
Ele funcionará, exceto no caso de 0or, onde python falha ao analisar porque 0oé um prefixo octal.
Assistente de trigo
Quando eu executo isso, não parece para imprimir a linha de topo ... tio.run/##FcoxCsQgEAXQPqeYLk7EwqRL8CRiEVh3Iww/...
Coty Johnathan Saxman
1

JavaScript (ES8), 108 112 bytes

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>

Menos golphed

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

Agradecemos a Justin Mariner por economizar muitos bytes, que se acostumaram a adicionar a verificação de zero ou único caractere necessária para cumprir o desafio. Você entende que :-(

traktor53
fonte
Você pode salvar 7 bytes criando a segunda linha `+s[i+1].padEnd(s.length-1)+v,s)+`e usando r.join``.
23617 Justin Mariner
Obrigado @JustinMariner pelas dicas String.prototype.padStarte etiquetou os literais dos modelos. Eu precisava que a ajuda para manter a adição da verificação do comprimento a um mínimo :-)
traktor53
Seu espaçamento é de um caractere muito curto agora; você pode consertar isso e economizar mais alguns fazendo (n=s.length-1)?(r=<...>+r.join``:se usando padEnd(n). Se o comprimento for 1, length-1é 0(falso).
23717 Justin Mariner
O espaçamento do @JustinMariner é fixo, mas eu mantive o teste de comprimento - pelo que entendi, tanto as seqüências de comprimento zero quanto as de um caractere se retornam sem retorno de carro ou repetição da sequência.
traktor53
1
padEndé ES2017.
Neil
1

PHP , 118 bytes

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

Experimente online!

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
fonte
1

APL , 58 bytes

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

Com ⎕IO←0.

Experimente online!

Quão?

c←≢⍵ - comprimento da corda

r←⍳ - alcance

o←∘.⌈⍨ - produto exterior com um mínimo

123
223
333

o⌊⌽⊖- minimizar com ele próprio girado 180 o

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

× - multiplique com

x←∘....⍨r - produto externo da gama com

    ((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - o quadro da matriz

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

x+ - adicione o quadro

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

(' ',⍵)[...] - obtém pelo índice da string concatenada para o espaço

Uriel
fonte
Pode ⍉⊖⍉⊖ser ⌽⊖?
Zacharý
@ Zachary graças
Uriel
0

JavaScript (ES2017), 87 bytes

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

Versão ES6: 93 bytes

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

Menos golfe

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
fonte
padEndé ES2017.
Neil
@Neil obrigado eu vou mudar o meu título
edc65
Você pode salvar um byte na sua versão do ES6 usando l+~i, evitando subtrair 1 duas vezes, em vez de subtrair 2 uma vez.
Neil
@Neil it should bel-~-i
edc65
Eu estava pensando, s=>[...s].reverse(l=s.length).map((c,i,z)=>i?l+~i?s[i]+' '.repeat(l-2)+c:z.join``:s).join`\n` mas s=>[...s].reverse(l=s.length-2).map((c,i,z)=>i?i+~l?s[i]+' '.repeat(l)+c:z.join``:s).join`\n` também funciona.
Neil
0

Java, 191 bytes

(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
fonte
(s)pode ser justo s. Os loops com linhas únicas no interior podem ter seus chavetas removidas. Você pode retornar em vez de imprimir, se você economizar algum bytes. Você usa int inos dois loops, não sei dizer se eles estão em escopos diferentes, mas vale a pena apontar. Inicializar como variáveis ​​juntas normalmente salva bytes. 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++));}. Você não precisa do ponto e vírgula à direita.
TheLethalCoder
Obrigado por apontar;) (não muito familiarizado com golfe). O otimizará mais tarde!
Serverfrog
0

C # (.NET Core) , 179 161 bytes

-18 bytes graças a 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;};

Experimente online!

Não tenho certeza sobre as regras, se isso for necessário para contagem de bytes ou não:

using System.Linq;

Alguém por favor me corrija sobre isso.

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
fonte
Olá e bem-vindo ao PPCG! Você está usando o Linq, portanto, inclua o valor usingna contagem de bytes. Como você está usando o Linq ToCharArray()pode ser justo ToArray(), você realmente precisa dele antes Reverse()? Como você está usando, Stringvocê precisa qualificá-lo totalmente ou incluir o uso, no entanto, isso pode ser facilmente corrigido alterando-o também string. O ifpode ser mais curto como um ternário s+=l>1?if code:"";. Você pode remover o i++do loop e incrementá-lo após d[i++].
TheLethalCoder
Inicialize icom o llike int l=s.Length-1,i=1;. E acho que pode ser isso!
TheLethalCoder
@TheLethalCoder obrigado! Eu adicionei suas sugestões ao código. Algumas notas: esqueci totalmente que a string realmente possui IEnumerable; String em vez de string era um resíduo de Java com o qual eu ainda luto; o ternário era, de fato, exatamente o mesmo tempo surpreendentemente; e depois das alterações, mudei para (; expr;) para while (expr), pois parece melhor e é a mesma contagem de bytes. Mais uma vez obrigado.
Grzegorz Puławski
Não se preocupe! Os ternários às vezes são, mas geralmente saem mais curtos, portanto vale sempre a pena experimentá-los.
TheLethalCoder
0

Retina , 106 bytes

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

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

Experimente online! Explicação:

..+
$&¶$&

Se houver pelo menos dois caracteres, duplique a entrada.

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

Inverta a duplicata.

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

Transforme as cordas em triângulos. O triângulo superior começa com a entrada e remove o primeiro caractere de cada vez, enquanto o triângulo inferior começa com a primeira letra da entrada invertida e adiciona um caractere a cada vez.

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

Junte os triângulos, sobrepostos, para que o último caractere forme a /diagonal.

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

Mude todos os caracteres para espaços, se eles estiverem a pelo menos um caractere do final de cada lado.

G`.

Exclua as linhas em branco restantes.

Neil
fonte
0

Python 3, 85 bytes

Usando a entrada para a linha superior :)

a=input()
b=len(a)
for i in range(b-2):print(a[1+i]+" "*(b-2)+a[-2-i])
print(a[::-1])
abc123
fonte
Tem certeza de que isso fornece uma resposta correta?
precisa saber é o seguinte
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())

Experimente online!


fonte
mas você só usado puma vez ...
Leaky Nun
É verdade ... vai mudar isso.
0

Python 3, 106 bytes

Uma versão funcional ...

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
fonte
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]]))

Experimente online!

officialaimm
fonte
0

Mathematica, 138 91 bytes

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

Você pode experimentá-lo online colando o seguinte na Wolfram Cloud Sandbox e clicando em "avaliar célula" ou pressionando Shift + Enter ou 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.
fonte