Nel luogo di sepoltura del re Silo delle Asturie c'è un'iscrizione che recita SILO PRINCEPS FECIT (il re Silo ha realizzato questo ).

La prima lettera si trova nel mezzo, e da lì si legge andando in qualsiasi direzione non diagonale che si irradia verso l'esterno. La lettera finale si trova su tutti e quattro gli angoli. In questa sfida, generalizzerai il processo per realizzarli.

Ingresso

Una stringa ( o equivalente ) e un numero intero. È possibile formulare le seguenti ipotesi sull'input:

• La stringa avrà una lunghezza dispari.
• L'intero sarà un numero dispari compreso tra 1 e uno in meno del doppio della lunghezza della stringa.

Produzione

Un inscriptio labyrinthica per la stringa, usando il numero intero per l'altezza o la larghezza (vedi modelli per esempi di altezza). L'output dovrebbe essere ogni lettera senza spazi, interruzione di riga come impostazione predefinita per il sistema / lingua.

Casi test

Notare che un input di 1 o (lunghezza * 2 - 1) si tradurrà in un palindromo orizzontale o verticale.

 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^

punteggio

Questo è code-golf, quindi la risposta più breve in byte vince. Scappatoie standard vietate.

J , 27 byte

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

Provalo online!

Un esempio chiarirà l'approccio di alto livello.

Ritenere 'ABCDE' f 3

Notiamo che quello che cerchiamo è semplicemente la tabella "addizione incrociata" di 1 0 1e 3 2 1 0 1 2 3, che assomiglia a questo:

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

Abbiamo poi tirare tali indici dalla stringa originale: [{~.

Tutto il resto del codice è solo noiosa aritmetica e l'uso di i:per costruire gli argomenti 1 0 1e 3 2 1 0 1 2 3.

Gelatina , 12 byte

Uṡṛ‘HɗŒBŒḄZY

Provalo online!

Un collegamento diadico che prende la stringa come sinistra e l'altezza come argomento destro. Restituisce una stringa con interruzioni di riga. Se un elenco di stringhe fosse accettabile per l'output, posso rimuovere il Ysalvataggio finale di un byte. È interessante notare che l'originale "SILO PRINCEPS FECIT" mi sembra l'arte ASCII di un diamante 3D quando lo guardo su TIO.

Spiegazione

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 byte

-2 byte grazie a Giuseppe. -4 byte inserendo la larghezza anziché l'altezza, come consentito da OP.

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

Provalo online!

Accetta input come vettore di caratteri. La parte chiave è 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

(dobbiamo quindi aggiungere 1 perché R è indicizzato 1). Lo 0 al centro è dove dovrebbe andare la prima lettera dell'input.

Il resto sta formattando.

Carbone , 25 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Disegna un quarto dell'iscrizione.

‖Ｏ←↑

Rifletti per completare l'iscrizione.

Japt -R , 19 16 byte

z
ò@VÔtXUaVÊ)êÃê

Provalo

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 byte

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

Provalo online!

Accetta la larghezza come input.

Japt -R , 10 byte

Ôã°Vz)mê ê

Accetta larghezza anziché altezza.

Provalo

Pseudocodice (U è stringa, V è intero):

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

Perl 6 , 68 67 byte

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

Provalo online!

Python 3, 104 byte

Non gioco a golf da così tanto tempo ... Sono sicuro che potrebbe essere più breve.

Dettagli

Questo codice definisce una funzione che accetta due argomenti (la stringa e l'altezza) e fornisce il risultato sull'output standard.

L'indice nella stringa è la distanza di Manhattan dal centro della griglia. Per una griglia di larghezza we altezza h, la distanza per la cella (x, y)è abs(x - (w - 1) / 2) + abs(v - (h - 1) / 2).

La larghezza della griglia deve essere tale che la distanza di Manhattan degli angoli (diciamo, (0, 0)) sia inferiore alla lunghezza della corda. Sostituendo (0, 0)quanto sopra e semplificando, scopriamo che la larghezza è semplicemente 2 * len(s) - h.

Codice

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

Provalo online!

05AB1E , 10 byte

RŒI>;ù€ûû»

Provalo online!

Pyth , 19 byte

L+_btbjyyM.:Q-lQ/E2

Provalo 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 byte

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]

Provalo online!

Stax , 11 9 byte

é─C[┬«#t▒

Esegui ed esegui il debug

Prende la larghezza e la stringa originale, in questo ordine.

C # (.NET Core) , 146 byte

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

Provalo online!

La risposta più lunga così a lungo. :-) Usa la distanza di Manhattan dal centro della piazza. Tuttavia, ci deve essere un modo più breve.

Tcl , 188 170 162 byte

{{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

Provalo online!

Sembra che ci siano un milione di modi sbagliati per golfare questo problema in TCL. Questo non è il peggiore.

Risparmiato almeno 18 byte convertendo in lambda (è possibile salvare fino a 13 in più se il valore di ritorno di un elenco di righe è accettabile)

Ne sono stati salvati altri 8 poiché l'iteratore lmap ha funzionato come costante aggiuntiva

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

Provalo qui!

Canvas non esegue sottostringhe, quindi ho bisogno di trattarlo come un oggetto d'arte e ottenere una sottosezione in quel modo. Sento che questo mi costa 2 byte, ma hey, cosa puoi fare.

Sembra che in realtà non funzioni come pensavo: le funzioni palindromize di Canvas rispecchiano determinati caratteri (ad es. V specchiata verticalmente diventa ^), e non riesco proprio a disabilitarlo ... _{vabbè, immagino}

Rubino , 65 byte

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

Provalo online!