Meiner bescheidenen Meinung nach ist Standardtext langweilig. Deshalb schlage ich einen neuen Schreibstandard vor, wandelnde Worte!

Gehende Worte

Gehende Wörter sind Wörter, die auf bestimmte Zeichen reagieren. Für diese Herausforderung stammen die Auslöserzeichen [u, d, r, l]von up down right left.

Immer wenn Sie beim Drucken eines Textes auf ein solches Zeichen stoßen, verschieben Sie die Richtung des Textes.
Der Text abcdefführt zum Beispiel zu :

abcd
   e
   f

Regeln

• Sowohl Groß- UDRLals auch Kleinbuchstaben udrlsollten die Richtung ändern, Groß- und Kleinschreibung sollte jedoch in der Ausgabe beibehalten werden
• Die Eingabe enthält nur druckbare Zeichen (0-9, A-Z, a-z, !@#%^&*() etc...), keine Zeilenumbrüche!
• Immer wenn der Text kollidiert, wird das alte Zeichen an dieser Position überschrieben
• Die Ausgabe sollte dem Benutzer in jeder modischen Angelegenheit präsentiert werden, es sollte sich jedoch um eine einzelne Ausgabe handeln (keine Anordnung von Zeilen).
• Nachgestellte und führende Zeilenumbrüche sind zulässig
• Nachgestellte Leerzeichen sind erlaubt
• Es gelten Standardlücken

Testfälle

empty input => empty output or a newline

u =>
u

abc =>
abc

abcd =>
abcd

abcde =>
abcd
   e

abcdde =>
abcd
   d
   e

codegolf and programming puzzles =>
   cod
     e
     g
     o
dna fl    sel
            z
p           z
rogramming pu

ABCDELFUGHI =>
 I
AHCD
 G E
 UFL

It is in my humble opinion that standard text is boring. Therefore I propose a new writing standard, walking words! =>
dnats taht noinipo el
a                   b
rd                  m
       It is in my hu
 t
 e
 x
 t

 i
 s

 b
 o
 ring. Therefore I propose a new writing stand
                                             a
                                             rd
                                              ,

                                              w
                                              a
                                      rdw gnikl
                                       s
                                       !

Das ist Code-Golf , der kürzeste Code in Bytes gewinnt!

Kohle , 29 27 20 19 Bytes

ＦＳ«Ｆ№rdlu↧ι≔ιω✳∨ωrι

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

ＦＳ«

Schleife über die eingegebenen Zeichen.

Ｆ№rdlu↧ι

Wenn der aktuelle Buchstabe eine Richtung ist ...

≔ιω

Aktualisieren Sie dann die aktuelle Laufrichtung.

✳∨ωrι

Gibt das Zeichen in der aktuellen Laufrichtung aus, standardmäßig nach rechts, wenn noch keine Richtung festgelegt wurde.

Dyalog APL , 63 Bytes

s@(n+11 9∘○¨+\0j1*⊃¨,⍨\(8∘≠⍴¨⊢)0,'rdluRDLU'⍳¯1↓s)⍴∘'',⍨2×n←≢s←⍞

Verwendung ⎕IO←0und Funktionen von v16 ( @)

n←≢s←⍞Roheingabe sund ihre Längen

⍴∘'',⍨2×n Erstelle eine 2n mal 2n Matrix von Räumen

s@(...)Ändern Sie die Matrix mit den Zeichen sder angegebenen (Paar-) Indizes

wie die Indizes berechnet werden:

¯1↓s lass den letzten char von fallen s

'rdluRDLU'⍳'codiere 'r'als 0, 'd'als 1 usw .; andere Zeichen als 8

0, stellen Sie eine 0 voran

(8∘≠⍴¨⊢) verwandle jede 8 in eine leere Liste, alle anderen in eine 1-Element-Liste

,⍨\kumulative getauschte Verkettungen ( abcd-> a ba cba dcba)

⊃¨ zuerst von jedem

0j1* imaginäre Konstante i hoch

+\ kumulative Beträge

11 9∘○¨Real- und Imaginärteil von jedem; Koordinaten im Bereich bekommen -n...n

n+ zentriere sie auf der großen Matrix

Pyth, 68 65 Bytes

KUJ,00ImXH~+VJ=@as_BM_MBU2Kx"rdlu"rd0dzjcsm.x@Hd;*Fm=Z}hdedSMCHlZ

Testsuite

Dabei wird ein Wörterbuch verwendet, das durch ein Koordinatenpaar indiziert wird, das beim Lesen der Eingabe aktualisiert und am Ende gedruckt wird. Es verwendet auch eine Tonne von cleveren Golf-Tricks.

So habe ich es geschrieben, wobei ich das Interpreter- -mFlag verwendet habe, um das Leerzeichen und die Kommentare vor dem Ausführen zu entfernen:

KUJ,00                 ; Initialize J to [0, 0] and K to [0, 1].
                       ; J is the current location, K is the current direction.
I                      ; If the following is truthy, which will be when the input
                       ; is nonempty,
  m                    ; Map d over z, the input.
  XH                   ; Assign to H (a hash table, initially empty)
    ~+VJ               ; At location J, then update J by adding elementwise
      =@               ; K (Next variable is implicit), which is set to
        as_BM_MBU2K    ; [0, 1], bifurcated on mapped negation, then mapped on
                       ; reversal bifuraction with the old value of K appended.
                       ; e.g. [[0, 1], [1, 0], [0, -1], [-1, 0], K]
        x"rdlu"rd0     ; indexed at location equal to the index of the lowercase
                       ; of the current character into "rdlu", -1 if missing.
    d                  ; Insert the current character with that key.
  z                    ; map over z.
jc                     ; Join on newlines the result of chopping into a rectangle
  sm                   ; the concatenation of the map
    .x@Hd;             ; Lookup the character at the given location,
                       ; if none then ' '
    *Fm                ; Locations are the cartesian product of the map
      =Z}hded          ; Inclusive range from the head of each list to 
                       ; the end of each list
                       ; Saved in Z for later
      SMCH             ; Transpose the list of keys, and sort the x and y values
                       ; separately.
  lZ                   ; Width of the rectangle should equal the number of
                       ; x values, which is the length of the last entry.

C #, 525 474 Bytes

Bearbeiten: 51 Bytes dank @steenbergh gespeichert

Es ist nicht schön, aber es funktioniert ...

Golf gespielt:

string W(string s){var l=s.Length;var a=new char[2*l+1,2*l+1];int x=2*l/2;int y=2*l/2;int d=0;for(int i=0;i<l;i++){switch(char.ToUpper(s[i])){case'U':d=3;break;case'D':d=1;break;case'L':d=2;break;case'R':d=0;break;}a[y,x]=s[i];switch(d){case 0:x+=1;break;case 1:y+=1;break;case 2:x-=1;break;case 3:y-=1;break;}}string o="";for(int i=0;i<2*l+1;i++){string t="";for(int j=0;j<2*l+1;j++)t+=a[i,j]+"";o+=t==string.Join("",Enumerable.Repeat('\0',2*l+1))?"":(t+"\r\n");}return o;}

Ungolfed:

public string W(string s)
{
  var l = s.Length;
  var a = new char[2 * l + 1, 2 * l + 1];
  int x = 2 * l / 2;
  int y = 2 * l / 2;
  int d = 0;
  for (int i = 0; i < l; i++)
  {
    switch (char.ToUpper(s[i]))
    {
      case 'U':
        d = 3;
        break;
      case 'D':
        d = 1;
        break;
      case 'L':
        d = 2;
        break;
      case 'R':
        d = 0;
        break;
    }
    a[y, x] = s[i];
    switch (d)
    {
      case 0:
        x += 1;
        break;
      case 1:
        y += 1;
        break;
      case 2:
        x -= 1;
        break;
      case 3:
        y -= 1;
        break;
    }
  }
  string o = "";
  for (int i = 0; i < 2 * l + 1; i++)
  {
    string t = "";
    for (int j = 0; j < 2 * l + 1; j++)
      t += a[i, j] + "";
    o += t == string.Join("", Enumerable.Repeat('\0', 2 * l + 1)) ? "" : (t + "\r\n");
  }
  return o;
}

Erläuterung:

Verwendet ein zweidimensionales Array und den dWert, um die Position des Arrays in der Korrekturrichtung zu erhöhen. Dabei sind d-Werte:

0 => RIGHT
1 => DOWN
2 => LEFT
3 => UP

Prüfung:

var walkTheWords = new WalkTheWords();
Console.WriteLine(walkTheWords.W("codegolf and programming puzzles"));

                            cod                              
                              e                              
                              g                              
                              o                              
                         dna fl    sel                       
                                     z                       
                         p           z                       
                         rogramming pu  

JavaScript (ES6), 218 220 232

Bearbeiten Ich habe uund verwendet t, um die Position ganz oben und ganz links zu verfolgen, aber mir wurde klar, dass dies überhaupt tnicht erforderlich ist

w=>[...w].map(c=>u=(((g[y]=g[y]||[])[x]=c,n=parseInt(c,36)|0)-21&&n-27?a=n-13?n-30?a:!(b=-1):!(b=1):(b=0,a=n/3-8),y+=b,x+=a)<u?x:u,a=1,b=0,x=y=u=w.length,g=[])+g.map(r=>[...r.slice(u)].map(c=>z+=c||' ',z+=`
`),z='')&&z

Weniger golfen

w=>{
  a = 1, b = 0;
  x = y = u = w.length;
  g = [];
  [...w].map(c => (
    r = g[y]||[],
    r[x] = c,
    g[y] = r,
    n = parseInt(c,36)|0,
    n-21 && n-27 ? n-13 && n-30?0 : (a=0, b=n-13?-1:1) : (b=0, a=n/3-8),
    x += a, u = x<u? x : u,
    y += b
  ))
  z=''
  g.map(r=>[...r.slice(u)].map(c=>z += c||' ', z += '\n'))
  return z
}             

Prüfung

F=
w=>[...w].map(c=>u=(((g[y]=g[y]||[])[x]=c,n=parseInt(c,36)|0)-21&&n-27?a=n-13?n-30?a:!(b=-1):!(b=1):(b=0,a=n/3-8),y+=b,x+=a)<u?x:u,a=1,b=0,x=y=u=w.length,g=[])+g.map(r=>[...r.slice(u)].map(c=>z+=c||' ',z+=`
`),z='')&&z

function update() {
  w=I.value
  O.textContent=F(w)
}

update()

#I {width:90%}

<input id=I value='It is in my humble opinion that standard text is boring. Therefore I propose a new writing standard, walking words!' oninput='update()'>
<pre id=O></pre>

05AB1E , 27 26 25 23 22 Bytes

3 Bytes dank Grimy gespart

ā¤‹>Šε’uχ’slkDÈiV}Y}Λ

Probieren Sie es online!

Erläuterung

ā                        # push [1 ... len(input)]
 ¤‹                      # check each number if its less than the max
   >                     # increment
                         # results in a list as long as the input where each number is 2 
                         # apart from the last one, this is the lengths to draw
    Š                    # move 2 copies of the input to the top of the stack
                         # the first one is the string to draw
     ε              }    # for each char in the second copy
      ’uχ’slk           # get the chars index in "ubridal"
              D          # duplicate
               Èi }      # if the index is even
                 V       # store it in Y
                   Y     # push Y (initially 2)
                         # this gives us the list of directions
                     Λ   # draw everything on the canvas

Javascript, 4̶6̶6̶, 455433 Bytes

Änderungen: 11 Bytes gespeichert, dank Benutzer 1000000000 10 oder so gespeichert, dank Benutzer 2428118 Außerdem wurden einige unnötige Semikolons entfernt.

Ich bin mir ziemlich sicher, dass man damit weiter Golf spielen kann, aber ich konnte es nicht ganz schaffen. Ich bin noch ganz neu, also ist jeder Rat sehr willkommen :)

z=a=>{b=c=0;j=[[]];d='';a.split``.forEach(g=>{h=g.toLowerCase();if('ruld'.includes(h)){d=h}f=x=>new Array(x[0].length).fill` `;switch(d){case 'l':if(!b){j.forEach(e => e.unshift` `);++b}j[c][b--]=g;break;case 'u':if(!c){j.unshift(f(j));++c}j[c--][b]=g;break;case 'd':if(c == j.length-1){j.push(f(j))}j[c++][b]=g;break;default:if(b==(j[0].length-1)){j.forEach(row=>row.push` `)}j[c][b++] = g;break}});j.forEach(x=>console.log(x.join``))}

<input id="a"> </input>
<input type="submit" onclick="z(document.getElementById('a').value);"/>

Ungolfed:

z=a=>{
b=c=0;
j=[[]];
d='';
a.split``.forEach(g=>{
    h=g.toLowerCase();
    if('ruld'.includes(h)){d=h;}
    f=x=>new Array(x[0].length).fill` `;
    switch(d){
        case 'l':
            if(!b){
                j.forEach(e => e.unshift` `);
                ++b;
            }
            j[c][b--] = g;
            break;
        case 'u':
            if(!c){
                j.unshift(f(j));
                ++c;
            }
            j[c--][b] = g;
            break;
        case 'd':
            if(c == j.length-1){
                j.push(f(j));
            }
            j[c++][b] = g;
            break;
        default:
            if(b == (j[0].length-1)){
                j.forEach(row=>row.push` `);
            }
            j[c][b++] = g;
            break;
    }
});
j.forEach(x => console.log(x.join``));

}

Ich ging mehr oder weniger so vor:

• Haben Sie ein Array, um die Ausgabe zu speichern
• Berechnen Sie die x- und y-Position des nächsten Zeichens im Array
• Wenn die Koordinaten außerhalb des Arrays liegen sollten, erweitern Sie das Array in diese Richtung. Entweder durch Drücken und zusätzliches Leerzeichen am Ende dieser Zeile oder durch vollständiges Hinzufügen einer weiteren Zeile.
• Erstelle Array [y] [x] = aktuelles Zeichen
• Drucken Sie das resultierende Array

Python 3, 314 309 290 268 Bytes

x=y=0
d,m=(1,0),{}
q={'u':(0,-1),'d':(0,1),'l':(-1,0),'r':d}
for c in input():m[x,y]=c;d=q.get(c.lower(),d);x,y=x+d[0],y+d[1]
X,Y=zip(*m)
O,P=min(X),min(Y)
r,p=0,print
exec("t=~~O;exec(\"p(m.get((t,r+P),' '),end='');t+=1;\"*-~abs(max(X)-O));r+=1;p();"*-~abs(max(Y)-P))

Ich habe versucht, mein Programm als Eingabe für mein Programm auszuführen, mit einigen interessanten Ergebnissen. Hah, versuchen Sie das zu interpretieren, Python!

Rasiert 5 Bytes - Kompliment an Jack Bates.

23 Bytes wurden von kundor weggewischt

Hinweis: Ich glaube, es gab einen Fehler bei der Messung mit meinen Bytes, weil verschiedene Editoren verwendet wurden. Ich bin mir jedoch ziemlich sicher, dass die letzte richtig ist.

PHP, 238 223 205 204 Bytes

12 Bytes gespeichert von Jörg ( striposstatt preg_match), 1 Byte + geschweifte Klammern durch Anführen statt Nachführen von Zeilenumbrüchen, 16 + geschweifte Klammern aus der Richtungsänderung, 1 weiteres mit ternären statt if.

for($m=$d=1;$o=ord($c=$argn[$i++]);$m=min($m,$x),$n=max($n,$x))stripos(_ulrd,$r[$y+=$e][$x+=$d]=$c)?$d=($e=[1,-1][$o&11])?0:$o%4-1:0;ksort($r);foreach($r as$s)for($i=$m-print"\n";$i++<$n;)echo$s[$i]??" ";

Laufen Sie als Pipe mit php -nR '<code>'oder versuchen Sie es online .

Nervenzusammenbruch

for($m=$d=1;                    # init max index and x-offset to 1
    $o=ord($c=$argn[$i++]);     # loop through characters
    $m=min($m,$x),$n=max($n,$x))    # 3. adjust min and max x offset
    stripos(_ulrd,
        $r[$y+=$e][$x+=$d]=$c       # 1. move cursor; add character to grid
    )?                              # 2. if direction change
        $d=(
            $e=[1,-1][$o&11]            # set y direction
        )
        ?0:$o%4-1                       # set x direction
    :0;

ksort($r);              # sort rows by index
foreach($r as$s)        # loop through rows
    for($i=$m-print"\n";    # print newline, reset $i
        $i++<$n;)           # loop $i from min index to max index
        echo$s[$i]??" ";        # print character, space if empty

Java 10, 288 286 280 263 Bytes

s->{int l=s.length(),x=l,y=l,d=82,A=x,B=y;var r=new char[l+=l][l];for(var c:s.toCharArray()){A=x<A?x:A;B=y<B?y:B;r[x][y]=c;c&=~32;d="DLRU".contains(""+c)?c:d;x+=5-d/14;y+=3-(d^16)/23;}s="";for(x=A;x<l;x++,s+="\n")for(y=B;y<l;y++)s+=r[x][y]<1?32:r[x][y];return s;}

-17 Bytes dank @Grimy .

Erläuterung:

Probieren Sie es hier aus. (HINWEIS: Ich entferne alle nachgestellten Leerzeichen / Zeilenumbrüche, um die Ausgabe etwas kompakter zu gestalten. Sie können auch die .replaceAll("(m?)\\s+$","")in- Methode entfernen test, um das tatsächliche Ergebnis zu sehen.)

s->{                              // Method with String as both parameter and return-type
  int l=s.length(),               //  Length of input String
      x=l,y=l,                    //  x,y coordinates, starting at `l`,`l`
      d=82,                       //  Direction, starting towards the right
      A=x,B=y;                    //  Min x & y values to remove leading spaces at the end
  var r=new char[l+=l][l];        //  character-matrix, with size `l`+`l` by `l`+`l`
  for(var c:s.toCharArray()){     //  Loop over the characters of the input String:
    A=x<A?x:A;                    //   Adjust minimum x `A` if necessary
    B=y<B?y:B;                    //   Adjust minimum y `B` if necessary
    r[x][y]=c;                    //   Fill x,y with the current character
    c&=~32;                       //   Make character uppercase if it isn't yet
    d="DLRU".contains(""+c)?c:d;  //   Change the direction if necessary
    x+=5-d/14;                    //   Set the next x coordinate based on the direction
    y+=3-(d^16)/23;}              //   Set the next y coordinate based on the direction
  s="";                           //  After the loop: create an empty result-String
  for(x=A;x<l;x++,                //  Loop `x` in the range [`A`, `l`):
      s+="\n")                    //    And append a new-line after every iteration
    for(y=B;y<l;y++)              //   Inner loop `y` in the range [`B`, `l`):
      s+=r[x][y]<1?               //    If the cell at x,y is empty:
          32                      //     Append a space to the result-String
         :r[x][y];                //    Else: append the character to the result-String
  return s;}                      //  After the nested loop: teturn result-String

Perl, 204 + 3 = 207 Bytes

+3 für -F

Leerzeichen sind nicht Teil des Codes und dienen der Lesbarkeit.

%p=(d,1,l,2,u,3,r,$x=$y=0);
for(@F){
    $m{"$x,$y"}=$_;
    $g=$p{lc$_}if/[dlur]/i;
    $g%2?($y+=2-$g):($x+=1-$g);
    ($a>$x?$a:$b<$x?$b:$x)=$x;
    ($c>$y?$c:$d<$y?$d:$y)=$y
}
for$k($c..$d){
    print($m{"$_,$k"}||$")for$a..$b;
    say""
}

Ähnlich wie bei meiner Lösung für die Fizz Buzz-Herausforderung erstelle ich für jeden Schritt auf dem Weg einen Hash mit x, y-Koordinaten, wobei die Maximal- und Minimalwerte der gespeicherten x- und y-Koordinaten beibehalten werden. Anschließend durchlaufe ich die Datei und drucke alles aus.

Wenn ich verzweifelt bin, kann ich vielleicht die letzten drei Zeilen der ersten forSchleife in eine einzige ekelhafte Anweisung umwandeln, die vielleicht ein oder zwei Bytes spart, aber ich freue mich nicht auf das völlig unlesbare Ergebnis.

Excel VBA, 205 Byte

Sub t(a)
Z=1:x=70:y=x:For i=1 To Len(a)
s=Mid(a,i,1):Cells(y,x).Value=s:Select Case LCase(s)
Case "l":Z=-1:w=0
Case "d":Z=0:w=1
Case "r":Z=1:w=0
Case "u":Z=0:w=-1
End Select:x=x+Z:y=y+w:Next:End Sub

Ich bin ein bisschen überrascht über die Fähigkeit von Excel, mit vorhandenen Antworten zu konkurrieren. Es funktioniert, weil wund zverfolgen Sie die Richtung.

SmileBASIC, 148 146 Bytes

DEF W M,S,T
WHILE""<M
A=INSTR(@DLURdlur,M[0])*PI()/2IF A>0THEN S=COS(A)T=SIN(A)
X=CSRX+S
Y=CSRY+T?SHIFT(M);
SCROLL-!X,-!Y
LOCATE!X+X,Y+!Y
WEND
END

Rufen Sie die Funktion mit auf W "text",vx,vy, wobei vx und vy die Startrichtung sind (Standard ist 1,0)

Schnelle 3, 283 Bytes

func w(a:String){var t=a.characters,d=t.count,c=Array(repeating:Array(repeating:" ",count:d*2),count:d*2),i=d,j=d,l=["d":(1,0),"u":(-1,0),"l":(0,-1),"r":(0,1)],e=(0,1)
t.map{c[i][j]="\($0)"
e=l["\($0)".lowercased()] ?? e
i+=e.0
j+=e.1}
c.map{$0.map{print($0,terminator:"")};print()}}

Ungolfed

func w(a:String){
    var t=a.characters,d=t.count,c=Array(repeating:Array(repeating:" ",count:d*2),count:d*2),i=d,j=d,l=["d":(1,0),"u":(-1,0),"l":(0,-1),"r":(0,1)],e=(0,1)
    t.map{
        c[i][j]="\($0)"
        e=l["\($0)".lowercased()] ?? e
        i+=e.0
        j+=e.1
    }
    c.map{
        $0.map{
            print($0,terminator:"")
        };
        print()
    }
}

Warnung

Längere Eingaben erfordern einen größeren Bildschirm. Die Ausgabe hat keine Behandlung für "leere" Zeilen / Spalten, da ich verstanden habe, dass dies nach den Regeln der Challenge akzeptabel ist.

Schimpfen

• Newline ist der Standardterminator für printsux
• Keine einfache Methode zur Erstellung eines Arrays bekannter Länge hat die Partitur zerstört.