Fazendo palavras octogonais

14

Na última quinta-feira, o usuário @SpookyGengar nos encantou com seu primeiro desafio sobre o Making Squared Words . E se dobrarmos o número de lados?

O desafio

Pegue uma string como entrada em qualquer formato razoável necessário ( string, charmatriz ...) e produza uma representação octogonal da entrada (também em qualquer formato razoável:, stringlista de strings, charmatriz ...) como nos próximos exemplos:

Input: golf
Output:

   golf
  o    l
 l      o
f        g
l        o
o        l
g        f
 o      l
  l    o
   flog


Input: HelloWorld
Output:

         HelloWorld
        e          l
       l            r
      l              o
     o                W
    W                  o
   o                    l
  r                      l
 l                        e
d                          H
l                          e
r                          l
o                          l
W                          o
o                          W
l                          o
l                          r
e                          l
H                          d
 e                        l
  l                      r
   l                    o
    o                  W
     W                o
      o              l
       r            l
        l          e
         dlroWolleH


Input: a
Output:

a


Input: ab
Output:

 ab
b  a
a  b
 ba


Input: code golf
Output:

        code golf
       o         l
      d           o
     e             g

   g                 e
  o                   d
 l                     o
f                       c
l                       o
o                       d
g                       e

e                       g
d                       o
o                       l
c                       f
 o                     l
  d                   o
   e                 g

     g             e
      o           d
       l         o
        flog edoc

Notas

  • A entrada consistirá apenas em caracteres ASCII imprimíveis.
  • Os espaços em branco à esquerda e à direita e as novas linhas são permitidos enquanto a forma octogonal for mantida.
  • Este é o , portanto, pode ganhar o programa / função mais exigente para cada idioma!
Charlie
fonte
5
"E se dobrarmos o número de lados?" <- então o carvão ainda venceria #
Leaky Nun 24/07
Caso de teste sugerido:code golf
Leaky Nun
@LeakyNun é <Space>considerado imprimível?
V. Courtois
2
@ V.Courtois yes #
Leaky Nun
O @LeakyNun adicionou um caso de teste.
24417 Charlie

Respostas:

10

Carvão , 16 bytes (10 bytes não-concorrentes)

F⁸«✂θ⁰±¹↷¹A⮌θθ»θ

Experimente online! Link é a versão detalhada do código. Explicação:

F⁸«                 Repeat for each side of the octagon
   ✂θ⁰±    ¹        Print the input except the last character
        ↷¹          Rotate 45° clockwise
          A⮌θθ      Reverse the input string
              »θ    Print the input again, to handle the length 1 case

Correção alternativa de comprimento 1, também 16 bytes: versão detalhada.

PθF⁸«✂θ⁰±¹↷¹A⮌θθ

Uma correção de bug do Charcoal significa que o seguinte código de 10 bytes agora funciona: Versão detalhada.

F⁴«θ←↘⮌θ↖⟲
Neil
fonte
parece que deveria fazer isso. Lol
Magic Octopus Urn
1
Umm, acho que não code golffunciona?
Erik the Outgolfer
Ah, e isso é de fato 16 bytes (substitua θθθpor θθ»θ).
Erik the Outgolfer
@EriktheOutgolfer Opa, desculpe por isso, não pensei em testar minha correção para o caso 1 de comprimento ... meu registro de teste na pergunta não foi muito bom, não é?
Neil
@ Neil Mas e quanto à questão code golf? Eu acho que isso tem a ver com a maneira como o carvão vegetal recebe informações, o que, infelizmente, a desqualifica completamente desse desafio, pois isso não pode ser contornado.
Erik the Outgolfer
5

JavaScript (ES6), 156 bytes

f=
s=>[...Array((l=s.length-1)*3+1)].map((_,i,a)=>a.map((_,j)=>s[i+j-l?l*5-i-j?i+l*2-j?j+l*2-i?i%(l*3)?j%(l*3)?-1:j?i-l:l+l-i:i?l+l-j:j-l:j:l-i:l*3-i:i]||` `))
<input oninput=o.textContent=this.value?f(this.value).map(function(a){return(a.join``)}).join`\n`:``><pre id=o>

Retorna uma matriz de caracteres.

Neil
fonte
1
Parece que funciona somente com strings de comprimento 4.
Charlie
1
@CarlosAlejo Desculpe, não verifiquei o suficiente. Convenientemente, corrija 2 bytes salvos!
295 Neil
Oh meu, isso é um monte de coisas ternárias ?:!
Erik the Outgolfer
@EriktheOutgolfer coisa boa não é python ou que seria muito detalhado: P
Stephen
3

Mathematica, 247 bytes

(T=Table;k=Length[s=Characters@#];If[k==1,#,Column[Flatten@{#,T[""<>{s[[i]],T["  ",k/2-2+i],s[[-i]]},{i,2,k}],T[""<>{s[[-i]],T["  ",k+k/2-2],s[[i]]},{i,2,k}],T[""<>{s[[i]],T["  ",3k/2-1-i],s[[-i]]},{i,2,k-1}],StringReverse@#},Alignment->Center]])&
J42161217
fonte
Você não precisa Alignmente economiza bytes usando delayedset ( :=) para reduzir a repetição de , s[[i]]e s[[-i]]você obtém 224 bytes com estas idéias: (T = Tabela; q: = s [[i]]; r: = s [[- i]]; k = Comprimento [s = Caracteres @ #]; Se [k == 1, #, Coluna [Achatar @ {#, T ["" <> {q, T ["", k / 2-2 + i], r}, {i, 2, k}], T ["" <> {r, T ["", k + k / 2-2], q}, {i, 2, k}], T ["" <> {q, T ["", 3k / 2-1-i], r}, {i, 2, k-1}], StringReverse @ #}, Centro] Também tenho uma solução alternativa de apenas 145 bytes no momento deste comentário.
Mark S.
2

Pitão , 79 69 65 bytes

j++K+]+*dJtlzzm+++*;-Jd@zd*;+ytdlz@z_hdSJjL*;t*3tlztC_B_zt__MC.tK

Conjunto de teste .

Freira Furada
fonte
2

Japonês , 84 79 bytes

-5 bytes graças a @ETHproductions.


Ål
VoA{A?(UÅw +Uê)£Y¥V*2+AªY¥V-A?X:SÃ:Vç +U+Vç
Wf cU¬£V?(V*3 ç hUg~Y)+X:XÃcWz2

A nova linha líder faz parte do programa. Pega uma string como entrada e retorna uma matriz de strings.

Experimente online! com o -Rsinalizador para ingressar na matriz resultante com novas linhas.

Não é o meu trabalho mais orgulhoso, mas o baixei de ~ 100 bytes, pelo menos. Minha idéia aqui foi criar as partes superior e média e, em seguida, anexar a parte superior, girada em 180 °.

Justin Mariner
fonte
Agradável. Não vejo muitas melhorias imediatamente, mas você pode mudar Ul Épara UÅle alternar V e W para economizar mais 2 bytes: codepen.io/justinm53/full/…
ETHproductions
Além disso, AnV ?-> V-A?, e Uq £->U¬£
ETHproductions
@ETHproductions Incrível, obrigado! Não posso acreditar que eu esqueci ¬.
23717 Justin Mariner
1

Python 2 , 220 213 bytes

  • Surpreendentemente mais do que eu imaginava.
a=input()
l=len(a)
r=range(l)
print'\n'.join(p.center(l*3-2)for p in[a]+(l>1)*([a[i]+(2*i-2+l)*' '+a[~i]for i in r[1:-1]]+[a[~i]+(l*3-4)*' '+a[i]for i in r]+[a[i]+(3*l-2*i-4)*' '+a[~i]for i in r[1:-1]]+[a[::-1]]))

Experimente online!

officialaimm
fonte
1

PHP 7,1, 230 156 155 bytes

for($x=$e=strlen($s=$argn)-1;$n<9;$r[$y][$x+=$n+1&3?$n&4?-1:1:0]=$s[$i],$i+=($n+=!$i||$i==$e)&1?:-1)$r[$y+=$n-1&3?$n<6?:-1:0]=$r[$y]?:"";echo join("
",$r);

Execute como pipe -nRou experimente online .

demolir

for($x=$e=strlen($s=$argn)-1;   # import to $s, set $e to length-1, init $x
    $n<9;                       # loop through 8 repetitions of string
    $r[$y][
        $x+=$n+1&3?$n&4?-1:1:0      # 3. increment/decrement $x depending on $n
    ]=$s[$i],                       # 4. copy character to current position
    $i+=(
        $n+=!$i||$i==$e             # 5. if first or last character of string, increment $n
    )&1?:-1                         # 6. if odd repetition next, else previous character
)
    $r[
        $y+=$n-1&3?$n<6?:-1:0       # 1. increment/decrement $y depending on $n
    ]=$r[$y]?:"";                   # 2. if empty, init row to string
echo join("\n",$r);             # output
Titus
fonte
1

Mathematica, 168 166 147 127 bytes

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&

Isso pega uma lista de cadeias de caracteres de um caractere e gera uma matriz de cadeias de caracteres de um caractere.

Salvei 18 bytes, explorando a simetria de usar -le Cross/@lque leva algo como um produto cruzado de cada um dos dois únicos 2D vetores para levar {x,y}a {-y,x}. Basicamente, as duas direções iniciais são Leste (borda superior) e Sudoeste (borda superior direita). Em seguida, adicionamos rotações de 90 graus no sentido anti-horário com Cross: Norte para a borda esquerda e Sudeste para a borda inferior esquerda. Em seguida, adicionamos as outras quatro peças usando -lpara virar as quatro que cobrimos.

Você pode testá-lo na sandbox com algo como:

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&[{"H","e","l","l","o"," ","G","o","l","f"}]//MatrixForm
Mark S.
fonte