In dieser Herausforderung ist gefälschter Laufschrifttext ein Text, der Teil für Teil scrollend angezeigt wird.

Einige Beispiele:

testing 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g


hello 2

 h
he
el
ll
lo
o


foobarz 3

  f
 fo
foo
oob
oba
bar
arz
rz
z


Something a bit longer 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r


small 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l


aaa 3

  a
 aa
aaa
aa
a


brace yourself 6

     b
    br
   bra
  brac
 brace
brace 
race y
ace yo
ce you
e your
 yours
yourse
oursel
urself
rself
self
elf
lf
f

Sie müssen ein Programm oder eine Funktion schreiben, die zwei Eingaben aufnimmt und die Ausgabe wie oben beschrieben druckt. Sie können nachfolgende Leerzeichen in Ihrer Ausgabe ausgeben oder nicht. Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

Wenn Ihr Programm eigenständig ist (dh, wenn es ausgeführt wird, werden die Zeilen gedruckt) (die Eingabe kann fest codiert, aber leicht geändert werden) und zwischen den einzelnen Ausgabezeilen eine Pause einlegt, erhalten Sie einen Bonus von -10.

CJam, 12 11 Bytes

1 Byte von Dennis gespeichert.

,Sf*\f+$zN*

Ich verwende "Eingaben können fest codiert, aber einfach geändert werden": Dies setzt voraus, dass die Eingaben bereits im Stapel vorhanden sind, sodass Sie "testing" 4zum Beispiel den obigen voranstellen können .

Teste es hier.

Erläuterung

Beachten Sie, dass die Transponierung der gewünschten Ausgabe viel einfacher ist:

   testing
  testing
 testing
testing

Wir müssen also nur nLinien erstellen und iLeerzeichen voranstellen für ivon n-1unten nach 0. Das macht der Code:

,            e# Turn n into a range [0 1 .. n-1]
 Sf*         e# Turn each i into a string of i spaces.
    \f+      e# Swap this array with the input string and append it to each of the
             e# strings of spaces.
       $     e# Sort the array to have the string with n-1 spaces first.
        z    e# Transpose the grid.
         N*  e# Join the lines with newline characters.

19 - 10 = 9 & le;

Ich finde den Bonus "Schlaf ein bisschen zwischen jeder Zeile" etwas vage und zwielichtig, aber hier ist eine 19-Byte-Version, die einfach nach jeder Zeile anhält, indem sie alle Permutationen des Arrays berechnet [0 1 .. 7]. Im Online-Interpreter führt dies einfach dazu, dass das endgültige Ergebnis etwas später angezeigt wird. Wenn Sie jedoch den Java-Interpreter verwenden, wird jede Zeile nach "ein bisschen schlafen" gedruckt:

,Sf*\f+$z{oNo8e!;}/

C 69 Bytes

printf Magie!

f(s,n,i)char*s;{for(i=n;*s;i?i--:s++)printf("%*s%.*s\n",i,"",n-i,s);}

Erweiterte Version mit einigen Erklärungen:

f(s,n,i)char*s;{       /* s is the string, n is the width of the grid. */
  for(i=n;             /* i is the number of preceding spaces. */
      *s;              /* Stop once we reach the end of the string. */
      i?i--:s++)       /* Decrease the number of spaces, and when there's 
                          none left start truncating the string itself. */
  printf("%*s          /* The first argument is the minimum width to print the 
                          string (left padded with spaces) and the second 
                          argument is the string to print. We use the empty 
                          string just to print the i spaces. */
    %.*s              /* The third argument is the maximum number of 
                         characters from the string (which is the fourth 
                         argument) to print. */
    \n",i,"",n-i,s);
}

Und hier ist ein Beispiel:

$ ./Marquee Stackoverflow 12

           s
          st
         sta
        stac
       Stapel
      stacko
     stackov
    Stackove
   Stackover
  stackoverf
 Stapelüberfl
stackoverflo
Tackoverflow
Ackoverflow
ckoverflow
Koverflow
Überlauf
verflow
erflow
rflow
fließen
niedrig
ow
w

Pyth, 13 Bytes

jb.:++K*dQzKQ

Probieren Sie es online aus: Pyth Compiler / Executor

Erläuterung

                 implicit: z = input string, Q = input number
      K*dQ       K = " " * Q
    ++K   zK     K + z + K
  .:        Q    all substrings of length Q
jb               join by newlines and print

Python 65 63

s=lambda t,s:'\n'.join((' '*s+t)[i:s+i]for i in range(len(t)+s))

Dies wurde tatsächlich verwendet, um die Beispiele zu schreiben. Basislösung.

>>> print(s("foobarz", 3))

  f
 fo
foo
oob
oba
bar
arz
rz
z

Javascript ( ES7-Entwurf ), 61 Byte

f=(s,l)=>[x.substr(i,l)for(i in x=' '.repeat(l)+s)].join(`
`)

<input id="str" value="Some String" />
<input id="num" value="5" />
<button onclick="out.innerHTML=f(str.value, +num.value)">Run</button>
<br /><pre id="out"></pre>

Javascript ( ES6 ) Hardcoded Inputs, 47 Bytes

Angenommen, fest codierte Eingaben in Variablen s(Zeichenfolge) und l(Länge) können auf 47 Byte reduziert werden, wobei für jede Zeile eine Warnung ausgegeben wird:

for(i in x=' '.repeat(l)+s)alert(x.substr(i,l))

K, 19 Bytes

{x#'![1]\(x#" "),y}

Setzen Sie xLeerzeichen ( x#" ") an den Anfang der Zeichenfolge y. Verwenden Sie dann das Formular "Festpunktscan" des Operators \, um den Satz gedrehter Zeichenfolgen zu erstellen. Ein fester Punkt in K stoppt die Iteration, wenn das Ergebnis der Anwendung der Funktion ein wiederholtes Ergebnis zurückgibt oder wenn die ursprüngliche Eingabe erneut aufgerufen wird. Da ![1]eine Saite schrittweise gedreht wird, ![1]\ist dies eine schöne Redewendung für zyklische Permutationen. Dann schneiden wir die Ergebnisse einfach mit x#'.

Ein Probelauf:

  {x#'![1]\(x#" "),y}[4;"some text"]
("    "
 "   s"
 "  so"
 " som"
 "some"
 "ome "
 "me t"
 "e te"
 " tex"
 "text"
 "ext "
 "xt  "
 "t   ")

J (22)

Dies endete länger als ich erwartet hatte, aber ich denke es ist nicht so schlimm.

[{."0 1[:]\.(' '#~[),]

Witzige Tatsache: keine der [und ]sind tatsächlich aufeinander abgestimmt oder haben irgendetwas miteinander zu tun.

Julia, 75 Bytes

(s,n)->(n-=1;print(join([(" "^n*s*" "^n)[i:n+i]for i=1:length(s)+n],"\n")))

Dadurch wird eine unbenannte Funktion erstellt, die eine Zeichenfolge und eine Ganzzahl als Eingabe akzeptiert und die Ausgabe druckt. Um es zu nennen, geben Sie ihm einen Namen, z f=(s,n)->(...).

Ungolfed + Erklärung:

function f(s, n)
    # Decrement n by 1
    n -= 1

    # Construct the lines as an array using comprehension by repeatedly
    # extracting subsets of the input string padded with spaces
    lines = [(" "^n * s * " "^n)[i:n+i] for i = 1:length(s)+n]

    # Print the array elements separated by a newline
    print(join(lines, "\n"))
end

Beispiele:

julia> f("banana", 3)
  b
 ba
ban
ana
nan
ana
na 
a

julia> f("Julia", 6)
     J
    Ju
   Jul
  Juli
 Julia
Julia 
ulia  
lia   
ia    
a     

Beachten Sie, dass diese Lösung 66 Byte umfasst, wenn das Programm bereits vorhanden ist sund dies nangenommen wird.

QBasic, 56 - 10 = 46

Dies wird QBasic golfed - die autoformatter erweitern ?in PRINTund einige Räume hinzufügen. Getestet mit QB64 , obwohl es hier nichts geben sollte, das mit DOS QBasic nicht funktioniert.

s=SPACE$(n)+s
FOR i=1TO LEN(s)
?MID$(s,i,n)
SLEEP 1
NEXT

QBasic ist in der Regel nicht mit String - Operationen gut, aber es sehr bequem ist eine Funktion , dass die Rendite eine bestimmte Anzahl von Räumen!

Unter einige Freiheiten mit diesem Code „Eingabe kann hart codiert sein“ erwartet die Variable szu sein DIM‚d AS STRING, um das zu vermeiden $Typsuffix, sowie die Zeichenfolge zugeordnet wird sund die Anzahl an n.

Beispiel Präambel:

DIM s AS STRING
s="string"
n=4

Ausgabe:

   s
  st
 str
stri
Trin
Ring
ing
ng
G

Die oberste leere Zeile kann durch Starten der FORSchleife bei 2 anstelle von 1 entfernt werden.

Bonus: Hinzufügen CLSRecht vor NEXTfür ein dürftigen vier Bytes verwandelt sich diese in ... ein echtes Festzelt !

Ich PRINT CHR$(3)QBasic. : ^ D

Ruby, 68 , 55 Bytes

a=" "*$*[1].to_i+$*[0]+" ";a.size.times{|b|puts a[b...b+$*[1].to_i]}

Nach einem Update von @blutorange:

a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}

Ausgabe:

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer 
t longer 
 longer 
longer 
onger 
nger 
ger 
er 
r 

ruby marquee.rb "Something a bit longer" 10

Erste Einreichung so um Kritik bitten.

Haskell, 61 59 54 Bytes

m n=unlines.scanr((take n.).(:))[].(replicate n ' '++)

Anwendungsbeispiel:

*Main> putStr $ m 6 "stackoverflow"

     s
    st
   sta
  stac
 stack
stacko
tackov
ackove
ckover
koverf
overfl
verflo
erflow
rflow
flow
low
ow
w

*Main> 

Bearbeiten: Eine Leerzeile am Anfang / Ende ist erlaubt

Bash, 109 - 10 = 99 Bytes

Ich sehe, dass ich in der Zeit, die ich zum Schreiben meiner Lösung benötigte, geschlagen worden bin. Trotzdem habe ich es zu lange geschrieben, um es nicht zu posten ...

Außerdem verfügt es über einige einzigartige Funktionen, wie die Zeit zwischen dem Drucken von Zeilen, die vom Benutzer angepasst werden kann, je nachdem, wie viel sich im aktuellen Verzeichnis befindet! (Auch etwas inkonsistent, abhängig davon, wie sich Ihre Festplatte anfühlt.)

l=${#1};s=$1;for j in `seq 1 $2`;do s=" $s";done;for i in `seq 0 $((l+$2))`;do echo "${s:i:$2}";find 1>2;done

Beispiel:

cd <some directory in which you own everything recursively>
Marquee.sh "Test Case" 4

   T
  Te
 Tes
Test
est 
st C
t Ca
 Cas
Case
ase
se
e

Ungolfed und kommentiert:

l=${#1} #Length of the incoming string
s=$1 #Can't reassign to the parameter variables, so give it another name
for j in `seq 1 $2`; do
    s=" $s" # Put on the padding spaces
done

for i in `seq 0 $((l+$2))`; do
    #Cut the string and print it. I wish I could lose "padding" that easily!
    echo "${s:i:$2}" #Format is ${string:index:length}, so always the same
    # length, with the index moving into the string as the loop advances
    find 1>2  #Wait "a bit". From ~/, about 6 minutes per line on my junky 
    # computer with a huge home directory. Probably in the <1 sec range for
    # most people.
    #This actually has the same character count as sleep(X), but is much
    # more fun!
done

Ich habe das noch nie wirklich versucht. Vorschläge und Kommentare sind willkommen!

Pure Bash, 61 Bytes

printf -vs %$2s"$1"
for((;++i<${#1}+$2;)){
echo "${s:i:$2}"
}

Ausgabe:

$ ./marquee.sh testing 4
   t
  te
 tes
test
esti
stin
ting
ing
ng
g
$ 

Perl, 50

$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)

57Zeichen +3für -i, -nund -l. -10Zeichen für den Schlaf.

-iwird für die numerische Eingabe verwendet, die in gespeichert ist $^I. Grundsätzlich fügen wir iLeerzeichen am Anfang und Ende der Eingabe ein, suchen dann nach allen iZeichen und durchlaufen sie mit while. sayBequeme Rückgabe, in 1die wir etwas eingeben können sleep.

echo "testing" | perl -i4 -nlE'$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)'

POSIX-Shell, 94

[ $3 ]||set "`printf "%${2}s"`$1" $2 t
[ "$1" ]&&printf "%-.${2}s" "$1" "
"&&$0 "${1#?}" $2 t

Ich weiß, es sieht näher an Perl aus, aber das ist wirklich Shell!

Die erste Zeile fügt die erforderlichen führenden Leerzeichen nur beim ersten Durchlauf der Schleife hinzu. Es setzt $ 3, um anzuzeigen, dass dies geschehen ist.

Die zweite Zeile (NB embedded newline) wird so lange wiederholt, bis die Eingabe erschöpft ist. Dabei werden die ersten n Zeichen der Zeichenfolge gedruckt und das erste Zeichen aus $ 1 entfernt.

Getestet mit Debian /bin/dash- Beispielausgaben folgen:

./Zelt "testen" 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./Zelt "Etwas länger" 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r

./Zelt "klein" 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l

Python 2, 51 Bytes / 37 Bytes

Ohne fest codierte Eingabe (51 Bytes):

def f(s,n):
 s=" "*n+s
 while s:print s[:n];s=s[1:]

Rufen Sie gerne an f("testing", 4).

Mit fest codierter Eingabe (37 Bytes):

s="testing";n=4

s=" "*n+s
while s:print s[:n];s=s[1:]

Beide Versionen geben eine erste Zeile mit Leerzeichen aus.

Python 2 (54 Byte - 10 = 44) 64 62 60 46

(Ich nahm an, dass die Zeile für die hartcodierte Eingabe nicht zur Byteanzahl beiträgt.)

Ich habe noch kein Programm gesehen, das tatsächlich zwischen Druckzeilen schläft, also habe ich ein Programm erstellt, das dies tut, da es auf diese Weise eher wie ein Festzelt aussieht. Dieses Programm ist 2 weitere Bytes in Python 3.

EDIT: Das Programm führt nun eine Berechnung durch, anstatt zu schlafen. Ich habe iin der Berechnung verwendet, damit das Programm es nicht als Konstante speichert, sondern jedes Mal berechnen muss.

Probieren Sie hier Python 3 aus (die Python 2-Repl ist fehlerhaft)

i=0
while s[i-n:]:print((' '*n+s)[i:n+i]);i+=1;i**7**7

Pyth, 12 Bytes

jb.:X*dyQQzQ

Demonstration.

Pyth, 17 - 10 = 7 Bytes

FN.:X*dyQQzQ&.p9N

Diese Version verwendet eine Verzögerung zwischen Zeilendrucken. Dies ist auf dem Kommandozeilen-Compiler zu sehen, den Sie hier erhalten .

Führen Sie Folgendes aus:

pyth -c 'FN.:X*dyQQzQ&.p9N' <<< 'testing
4'

Dies hat eine Verzögerung von ca. 0,3 Sekunden vor jedem Druck. Wenn Sie eine längere Verzögerung bevorzugen, können Sie Folgendes verwenden:

FN.:X*dyQQzQ&.pTN

Dies hat eine Verzögerung von ca. 4 Sekunden.

Java, 133, 119, 115

int i;void f(String s,int n){for(;++i<n;)s=" "+s+" ";for(;i<=s.length();)System.out.println(s.substring(i-n,i++));}

Lange Version:

int i;
void f(String s, int n) {
    for(; ++i < n;)
        s = " " + s + " ";
    for(; i<=s.length();)
        System.out.println(s.substring(i-n, i++));
}

Das Auffüllen wird auf die Zeichenfolge angewendet, und dann werden Teilzeichenfolgen der aufgefüllten Zeichenfolge auf die Konsole gedruckt.

-4 Bytes dank @KevinCruijssen.

Matlab, 95

Wie immer handelt es sich um eine Manipulation von Matrizen. Der Kern hier ist der Befehl, mit spdiagsdem Sie ganz einfach Diagonalmatrizen erstellen können.

t=input('');
n=numel(t);
k=input('');
flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))

Mit 71 Bytes Hardcoding (erwarteter String gespeichert in tund die Nummer in k)

n=numel(t);flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))

APL, 50 - 10 = 40 Zeichen

Ich bin sicher, es könnte kürzer sein. 50 ist die Länge des Programms ohne die beiden Konstanten.

{⍵≡⍬:⍬⋄⎕←↑⍵⋄⎕DL 99⋄∇1↓⍵}⊂[0]⊖s⍴⍨n,¯1+⍴s←'brace yourself',' '⍴⍨n←6

Erläuterung:

                               ' '⍴⍨n←6   call the number 'n' and make n spaces
            s←'brace yourself',           append them to the string and call it 's'
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
                             s⍴⍨n,¯1+⍴s   make a len(s)-1 by n matrix by repeating s 
                        ⊂[0]⊖             reflect the matrix and extract the columns
{                      }                  pass the list of columns to this function
 ⍵≡⍬:⍬⋄                                   return if the list is empty
       ⎕←↑⍵⋄                              print the first column (as a row)
            ⎕DL 99⋄                       wait for 99ms
                   ∇1↓⍵                   recurse with the rest of the columns

Entwickelt für ngn APL am Terminal.

Powershell - 85 83 Bytes

Es ist spät, es wird nicht gewinnen :-) Aber ich dachte, ich würde der Vollständigkeit halber eine Powershell einwerfen:

function m($s,$n){1..$($n+$s.length)|%{-join(" "*$n+$s+" "*$n)[$_-1..$($n+$_-1)]}}

Cobra - 60

def f(n,s)
    s=' '.repeat(n)+s
    while''<s,print (s=s[1:])[:n]

Groovy - 82

n=args[1]as int;t=" "*n+args[0]+" "*n;(0..t.size()-n).each{println t[it..it+n-1]}

Lua, 79 Bytes

r=io.read;t=r()w=r()s=" "t=s:rep(w)..t;for i=1,t:len()do print(t:sub(i,i+w))end

C #, 112 Bytes

s=>n=>{var r=new string(' ',n-1);s=r+s+r;r="";for(int i=0;i<s.Length-n+1;)r+=s.Substring(i++,n)+"\n";return r;};

Volles Programm mit ungolfed Methode und Testfällen:

using System;

namespace FakeMarqueeText
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,Func<int,string>>f= s=>n=>
            {
                var r=new string(' ',n-1);
                s=r+s+r;
                r="";
                for(int i=0;i<s.Length-n+1;)
                    r+=s.Substring(i++,n)+"\n";

                return r;
            };

            // test cases:
            Console.WriteLine(f("testing")(4));
            Console.WriteLine(f("hello")(2));
            Console.WriteLine(f("foobarz")(3));
            Console.WriteLine(f("Something a bit longer")(10));
            Console.WriteLine(f("small")(15));
            Console.WriteLine(f("aaa")(3));
            Console.WriteLine(f("brace yourself")(6));

        }
    }
}

Jelly , 15 Bytes - 10 = 5 ( nicht konkurrierend ?)

ḶṚ⁶ẋ;€⁹ZṄœS$€ṛ“

Probieren Sie es online!

Schlaf für eine Sekunde zwischen jeder Zeile. Gibt eine nachgestellte Zeile aus, falls dies akzeptabel ist.

^{yay Gelee schlägt Holzkohle}

PHP4.1, 85-10 = 75 Bytes

Ja, dies ist eine sehr alte Version, aber sie hat eine Funktionalität, die ich brauche.
Sie können es immer noch in neueren Versionen von PHP ausführen, aber Sie müssen die Variablen selbst festlegen, bevor Sie den folgenden Code ausführen.

Das hilft mir, die Größe meines Codes erheblich zu reduzieren!

Es ist wirklich grundlegend:

<?for($s=str_repeat(' ',$n).$s;$i++<strlen($s)+$n;sleep(1))echo substr($s,$i,$n),'
';

Ich lief für den Bonus aus diesem Grund und zitierte OP:

Wenn Ihr Programm eigenständig ist (dh, wenn es ausgeführt wird, werden die Zeilen gedruckt) (die Eingabe kann fest codiert, aber leicht geändert werden) und zwischen den einzelnen Ausgabezeilen eine Pause einlegt, erhalten Sie einen Bonus von -10.

Wie Sie offensichtlich sehen können, hat es einen Schlaf.

Dies setzt voraus, dass Sie register_globalsstandardmäßig aktiviert haben. Dies waren die Standardeinstellungen für diese Version.

Mit können Sie ganz einfach in Ihrem Browser testen minimal einige Veränderungen:

//detects if it is running in js or php
//true for js, false for php
if('\0'=="\0")
{
	function strlen($s){
		return $s.length;
	}
	
	function str_repeat($s,$n){
		return Array($n+1).join($s);
	}
	
	function substr($s,$n,$m){
		return $s.substr($n,$m);
	}
	
	function printf($s){
		document.write($s);
	}
	
	function concat($a,$b){
		return $a+$b;
	}
}
else
{
	function concat($a,$b){
		return $a.$b;
	}
}

//sets the variables, not required for PHP if you pass the values by GET or POST
$i=0;
$s='example';
$n=6;



for($s=concat(str_repeat('-',$n),$s);$i++<strlen($s)+$n;)printf(concat(substr($s,$i,$n),'<br>'));

*{font-family:monospace}

Der obige Code ist mehrsprachig und Sie können ihn in Ihrem Browser oder in einem PHP-Interpreter ausführen. Sollte ich dafür keinen Preis bekommen? Ein Keks vielleicht?

Liste der Änderungen:

• Entfernte die sleep(1)in diesem Test
• Erstellt 2 Versionen der Funktion concat
  Das Ziel ist es, PHP und JS Unterschiede bei der Verkettung von Strings zu überwinden.
• Anstelle eines Leerzeichens wird a -verwendet, um das Leerzeichen zu füllen
• Statt echo, printfAnwendungen sind statt (PHP Begrenzung)
• Stattdessen oder eine "echte" Newline, <br>wird stattdessen verwendet

J , 15 14 Bytes

,.~/@(' '&,~<)

Probieren Sie es online!

APL (Dyalog) , 17 Bytes

⌽⍉↑(⎕,⍨' '/⍨⊢)¨⍳⎕

Probieren Sie es online!

(Das Programm geht ⎕IO←0davon aus, dass es auf vielen Rechnern Standard ist.)

Erläuterung

⍳⎕               Create a range 0 .. input-1
¨                For each element in this range do:
 ' '/⍨⊢           A space duplicated right argument (which is the element in  the range) times
 ⎕,⍨              Concatenated with the input string to its right
⌽⍉               Transpose and reflect horizontally