No cemitério do rei Silo das Astúrias, há uma inscrição que diz SILO PRINCEPS FECIT (o rei Silo fez isso ).

A primeira letra é encontrada bem no meio, e a partir daí se lê indo em qualquer direção não diagonal, irradiando para fora. A letra final é encontrada nos quatro cantos. Neste desafio, você generalizará o processo para fazê-los.

Entrada

Uma sequência ( ou equivalente ) e um número inteiro. Você pode fazer as seguintes suposições sobre a entrada:

• A cadeia terá um comprimento ímpar.
• O número inteiro será um número ímpar entre 1 e um menos que o dobro do comprimento da sequência.

Saída

Um inscriptio labyrinthica para a string, usando o número inteiro para a altura ou largura (consulte os modelos para obter exemplos de altura). A saída deve ser cada letra sem espaços, com quebra de linha como padrão no seu sistema / idioma.

Casos de teste

Observe que uma entrada de 1 ou (comprimento * 2 - 1) resultará em um palíndromo horizontal ou vertical.

 Input: FOO, 3    Input: BAR, 1    Input: BAR, 3    Input: BAR, 5

Output: OOO      Output: RABAR    Output: RAR       Output: R
        OFO                               ABA               A
        OOO                               RAR               B
                                                            A
                                                            R

 Input: ABCDE, 5   Input: ABCDE, 3   Input: *<>v^, 5

Output: EDCDE     Output: EDCBCDE           ^v>v^
        DCBCD             DCBABCD           v><>v
        CBABC             EDCBCDE           ><*<>
        DCBCD                               v><>v
        EDCDE                               ^v>v^

Pontuação

Este é o código-golfe, pelo que a resposta mais curta em bytes vence. Falhas padrão proibidas.

J , 27 bytes

([{~]+/&(|@i:)#@[-1+])-:@<:

Experimente online!

Um exemplo esclarecerá a abordagem de alto nível.

Considerar 'ABCDE' f 3

Percebemos que o que buscamos é simplesmente a tabela "adição cruzada" de 1 0 1e 3 2 1 0 1 2 3, que se parece com isso:

4 3 2 1 2 3 4
3 2 1 0 1 2 3
4 3 2 1 2 3 4

Em seguida, puxe esses índices da string original: [{~.

Todo o resto do código é apenas aritmética chata e o uso de i:para construir os argumentos 1 0 1e 3 2 1 0 1 2 3.

Gelatina , 12 bytes

Uṡṛ‘HɗŒBŒḄZY

Experimente online!

Um link diádico que toma a string como esquerda e a altura como argumento correto. Retorna uma string com quebras de linha. Se uma lista de strings for aceitável para saída, eu posso remover o finalY salvamento de um byte. Curiosamente, o original "SILO PRINCEPS FECIT" me parece a arte ASCII de um diamante 3D quando olho para ele no TIO.

Explicação

U            | Reverse input
 ṡ   ɗ       | All overlapping substrings of the length given by:
  ṛ          | - The right argument
   ‘         | - Incremented by 1
    H        | - Halved
      ŒB     | Concatenate to the reverse, keeping a single copy of the last character (so creating a palindrome)
        ŒḄ   | Do the same, but this time using the lists of characters generated by the last atom
          Z  | Transpose
           Y | Join with newlines

R , 93 91 87 bytes

-2 bytes graças a Giuseppe. -4 bytes inserindo a largura em vez da altura, conforme permitido pelo OP.

function(s,W,w=W%/%2,h=length(s)-w-1)write(s[1+outer(abs(-w:w),abs(-h:h),`+`)],1,W,,"")

Experimente online!

Recebe entrada como um vetor de caracteres. A parte principal é s[1+outer(abs(-w:w),abs(-h:h),'+')].

$w$$h$$(2w+1)\times(2h+1)$

$(i,j)$$1+|i-h|+|j-w|$abs(-w:w)abs(-h:h)abs(-h:h)$[h, h-1, h-2, \ldots, 2, 1, 0, 1, 2, \ldots, h-1, h]$outer(abs(-2:2), abs(-1:1), '+')

32123
21012
32123

(precisamos adicionar 1 porque R é indexado em 1). O 0 no centro é o local onde deve ir a primeira letra da entrada.

O resto está formatando.

Carvão , 25 19 bytes

Ｅ⊘⊕η✂θι⁺ι⁻Ｌθ⊘⊖η‖Ｏ←↑

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

Ｅ⊘⊕η✂θι⁺ι⁻Ｌθ⊘⊖η

Desenhe um quarto da inscrição.

‖Ｏ←↑

Reflita para completar a inscrição.

Japonês -R , 19 16 bytes

z
ò@VÔtXUaVÊ)êÃê

Tente

z\nò@VÔtXUaVÊ)êÃê     :Implicit input of integer U & string V
z                     :Floor divide U by 2
 \n                   :Reassign result to U
   ò                  :Range [0,U]
    @                 :Map each X
     VÔ               :  Reverse V
       tX             :  Substring from index X to index ...
         Ua           :    Absolute difference between U and ...
           VÊ         :    Length of V
             )        :  End substring
              ê       :  Palindromise
               Ã      :End map
                ê     :Palindromise
                      :Implicit output, joined by newlines

Wolfram Language (Mathematica) , 57 54 bytes

(g=Reverse@Rest@#~Join~#&)@BlockMap[g,#,⌈#2/2⌉,1]&

Experimente online!

Toma a largura como entrada.

Japonês -R , 10 bytes

Ôã°Vz)mê ê

Toma largura em vez de altura.

Tente

Pseudocódigo (U é sequência, V é inteiro):

U.Reverse().AllSubstringsOfLength(++V / 2).Map(Palindromize).Palindromize

Perl 6 , 68 67 bytes

{say |$^a.comb[{$_...0...$_}($a.comb-$^b+>1-1)X+.abs]for ^$b-$b+>1}

Experimente online!

Python 3, 104 bytes

Não jogo há tanto tempo ... Tenho certeza que isso pode ser mais curto.

Detalhes

Este código define uma função que recebe dois argumentos (a sequência e a altura) e fornece o resultado na saída padrão.

O índice da string é a distância de Manhattan do centro da grade. Para uma grade de largura we altura h, a distância da célula em (x, y)éabs(x - (w - 1) / 2) + abs(v - (h - 1) / 2) .

A largura da grade deve ser tal que a distância dos cantos de Manhattan (digamos (0, 0)) seja uma menor que o comprimento da corda. Substituindo (0, 0)o acima e simplificando, descobrimos que a largura é simples 2 * len(s) - h.

Código

def b(s,h):
 w=2*len(s)-h
 for y in range(h):print(''.join(s[abs(x-w//2)+abs(y-h//2)]for x in range(w)))

Experimente online!

05AB1E , 10 bytes

RŒI>;ù€ûû»

Experimente online!

Pitão , 19 bytes

L+_btbjyyM.:Q-lQ/E2

Experimente online!

L+_btbjyyM.:Q-lQ/E2   Implicit: Q=string, E=height
L                     Define a function, y(b):
  _b                    Reverse b
 +  tb                  Append all be first element of b
                      y is now a palindromisation function
              lQ      Length of Q
             -  /E2   Subtract floored division of E by 2
          .:Q         All substrings of Q with the above length
        yM            Palindromise each substring
       y              Palindromise the set
      j               Join on newlines, implicit print

Python 2 , 95 bytes

def f(s,n):
 y=len(s);n//=2
 for i in range(n+1)+range(n)[::-1]:print s[y+~i:n-i:-1]+s[n-i:y-i]

Experimente online!

Stax , 11 9 bytes

é─C[┬«#t▒

Execute e depure

Leva a largura e a sequência original, nessa ordem.

C # (.NET Core) , 146 bytes

s=>n=>{int w=s.Length*2-n,i=0,j;var r=new char[n,w];for(;i<n;i++)for(j=0;j<w;)r[i,j]=s[System.Math.Abs(n/2-i)+System.Math.Abs(w/2-j++)];return r;}

Experimente online!

Resposta mais longa por tanto tempo. :-) Utiliza a distância de Manhattan até o centro da praça. Deve haver uma maneira mais curta, no entanto.

Tcl , 188 170 162 bytes

{{w s} {join [lmap C [lrepeat $w string] {join [$C reverse [set y [$C range $s [set x [expr abs($w/2+1-[incr i])]] end-[expr $w/2-$x]]]][$C range $y 1 end]}] \n}} bytes

Experimente online!

Parece haver um milhão de maneiras ruins de resolver esse problema no TCL. Este não é o pior deles.

Salva no mínimo 18 bytes convertendo para lambda (pode economizar até 13 a mais se o valor de retorno de uma lista de linhas for aceitável)

Economizou 8 adicionais, já que o iterador lmap serviu como uma constante extra

±Ｘ↕┌Ｌ╵┌－Ｙ｛ｘ；１ｙ１＠］┼

Experimente aqui!

A tela não cria substrings, então eu preciso tratá-la como um objeto de arte e obter uma subseção dessa maneira. Eu sinto que isso me custa 2 bytes, mas ei, o que você pode fazer.

Parece que isso realmente não funciona como eu pensava: as funções palindromize do Canvas espelham certos caracteres (por exemplo, o V espelhado verticalmente se torna ^), e eu não posso exatamente desabilitar isso ... _{bem, eu acho}

Ruby , 65 bytes

->s,h{(-(h/=2)..h).map{|y|(z=s[(w=y.abs)..w+~h]).reverse.chop+z}}

Experimente online!