In der Grabstätte des Königs Silo von Asturien befindet sich eine Inschrift mit der Aufschrift SILO PRINCEPS FECIT ( König Silo machte dies ).

Der erste Buchstabe befindet sich ganz in der Mitte, und von dort liest man, indem man in eine nicht-diagonale Richtung geht, die nach außen ausstrahlt. Der letzte Buchstabe befindet sich an allen vier Ecken. In dieser Herausforderung verallgemeinern Sie den Prozess, um sie zu erstellen.

Eingang

Eine Zeichenfolge ( oder ein Äquivalent ) und eine Ganzzahl. Sie können die folgenden Annahmen bezüglich der Eingabe treffen:

• Die Zeichenfolge hat eine ungerade Länge.
• Die Ganzzahl ist eine ungerade Zahl zwischen 1 und 1, weniger als die doppelte Länge der Zeichenfolge.

Ausgabe

Ein Inscriptio Labyrinthica für die Zeichenfolge, wobei die Ganzzahl für die Höhe oder Breite verwendet wird (siehe Modelle für Höhenbeispiele). Die Ausgabe sollte aus jedem Buchstaben ohne Leerzeichen bestehen. Der Zeilenumbruch ist die Standardeinstellung für Ihr System / Ihre Sprache.

Testfälle

Beachten Sie, dass eine Eingabe von 1 oder (Länge * 2 - 1) zu einem horizontalen oder vertikalen Palindrom führt.

 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^

Wertung

Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Standardlücken verboten.

J , 27 Bytes

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

Probieren Sie es online!

Ein Beispiel wird den Ansatz auf hoher Ebene verdeutlichen.

Erwägen 'ABCDE' f 3

Wir bemerken, dass wir einfach die Kreuzadditionstabelle von 1 0 1und suchen 3 2 1 0 1 2 3, die so aussieht:

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

Wir ziehen dann diese Indizes aus der ursprünglichen Zeichenfolge: [{~ .

Der ganze Rest des Codes ist nur langweilig Arithmetik und die Verwendung von i:, um die Argumente 1 0 1und zu konstruieren 3 2 1 0 1 2 3.

Gelee , 12 Bytes

Uṡṛ‘HɗŒBŒḄZY

Probieren Sie es online!

Eine dyadische Verknüpfung, bei der die Zeichenfolge als linkes und die Höhe als rechtes Argument verwendet wird. Gibt einen String mit Zeilenumbrüchen zurück. Wenn eine Liste von Zeichenfolgen für die Ausgabe akzeptabel war, kann ich die endgültige YSpeicherung eines Bytes entfernen . Interessanterweise erscheint mir das Original „SILO PRINCEPS FECIT“ als ASCII-Kunst eines 3D-Diamanten, wenn ich es auf TIO betrachte.

Erläuterung

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 dank Giuseppe. -4 Bytes durch Eingabe der Breite anstelle der Höhe, wie dies durch OP erlaubt ist.

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

Probieren Sie es online!

Nimmt die Eingabe als Vektor von Zeichen. Der Schlüsselteil ist 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

(Wir müssen dann 1 addieren, weil R 1-indiziert ist.) Die 0 in der Mitte ist die Stelle, an der der erste Buchstabe der Eingabe stehen soll.

Der Rest ist Formatierung.

Holzkohle , 25 bis 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Zeichnen Sie ein Viertel der Inschrift.

‖Ｏ←↑

Überlege, um die Inschrift zu vervollständigen.

Japt -R , 19 16 Bytes

z
ò@VÔtXUaVÊ)êÃê

Versuch es

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]&

Probieren Sie es online!

Übernimmt die Breite als Eingabe.

Japt -R , 10 Bytes

Ôã°Vz)mê ê

Nimmt Breite statt Höhe.

Versuch es

Pseudocode (U ist String, V ist Integer):

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}

Probieren Sie es online!

Python 3, 104 Bytes

Ich habe noch nicht so lange Golf gespielt ... Ich bin sicher, das könnte kürzer sein.

Einzelheiten

Dieser Code definiert eine Funktion, die zwei Argumente (die Zeichenfolge und die Höhe) akzeptiert und das Ergebnis bei der Standardausgabe ausgibt.

Der Index in der Zeichenfolge ist der Manhattan-Abstand vom Mittelpunkt des Gitters. Für ein Gitter mit einer Breite wund Höhe h, der Abstand für die Zelle bei (x, y)ISabs(x - (w - 1) / 2) + abs(v - (h - 1) / 2) .

Die Breite des Gitters muss so sein, dass der Manhattan-Abstand der Ecken (z. B. (0, 0)) um eins kürzer als die Länge der Zeichenfolge ist. Wenn (0, 0)wir das Obige ersetzen und vereinfachen, stellen wir fest, dass die Breite einfach ist 2 * len(s) - h.

Code

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

Probieren Sie es online!

05AB1E , 10 Bytes

RŒI>;ù€ûû»

Probieren Sie es online!

Pyth , 19 Bytes

L+_btbjyyM.:Q-lQ/E2

Probieren Sie es 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]

Probieren Sie es online!

Stax , 11 9 Bytes

é─C[┬«#t▒

Führen Sie es aus und debuggen Sie es

Die Breite und die ursprüngliche Zeichenfolge werden in dieser Reihenfolge verwendet.

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

Probieren Sie es online!

Längste Antwort so lange. :-) Es nutzt die Manhattan-Distanz zum Zentrum des Platzes. Es muss jedoch einen kürzeren Weg geben.

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

Probieren Sie es online!

Es scheint eine Million schlechte Möglichkeiten zu geben, um dieses Problem in TCL zu lösen. Dies ist nicht das Schlimmste von ihnen.

Mindestens 18 Byte werden durch Konvertierung in Lambda gespeichert (kann bis zu 13 weitere Bytes einsparen, wenn der Rückgabewert einer Zeilenliste akzeptabel ist)

Es wurden weitere 8 gespeichert, da der lmap-Iterator als zusätzliche Konstante diente

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

Probieren Sie es hier aus!

Canvas macht keine Teilstrings, also muss ich es wie ein Kunstobjekt behandeln und auf diese Weise einen Unterabschnitt erhalten. Ich glaube, das kostet mich 2 Bytes, aber hey, was kannst du tun?

Es sieht so aus, als würde das nicht so funktionieren, wie ich dachte: Die Palindromisierungsfunktionen von Canvas spiegeln bestimmte Zeichen (z. B. V wird vertikal gespiegelt zu ^), und das kann ich nicht genau deaktivieren ... _na ja _{, ich schätze}

Ruby , 65 Bytes

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

Probieren Sie es online!