À mon humble avis, le texte standard est ennuyeux. Je propose donc une nouvelle norme d'écriture, des mots qui marchent!

Mots de marche

Les mots qui marchent sont des mots qui répondent à certains caractères. Pour les besoins de ce défi, les personnages déclencheurs proviennent [u, d, r, l]de up down right left.

Chaque fois que vous rencontrez un tel caractère lors de l’impression de texte, vous déplacez la direction du texte.
Par exemple, le texte abcdefentraînera:

abcd
   e
   f

Règles

• Les majuscules UDRLet les minuscules udrldevraient changer la direction, mais la casse devrait être conservée dans la sortie
• L'entrée ne contiendra que des caractères imprimables (0-9, A-Z, a-z, !@#%^&*() etc...), pas de nouvelles lignes!
• Chaque fois que le texte entrera en collision, il écrasera l'ancien caractère à cette position.
• La sortie doit être présentée à l’utilisateur sous n’importe quelle question à la mode, mais ce doit être une sortie unique (pas de tableau de lignes)
• Les nouvelles lignes suivies sont autorisées
• Les espaces de fuite sont autorisés
• Les failles standard s'appliquent

Cas de test

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
                                       !

C'est code-golf , le code le plus court en octets gagne!

Charbon de bois , 29 27 20 19 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＦＳ«

Boucle sur les caractères saisis.

Ｆ№rdlu↧ι

Si la lettre en cours est une direction ...

≔ιω

puis mettez à jour la direction de marche actuelle.

✳∨ωrι

Imprimez le personnage dans le sens de la marche actuel, par défaut à droite si aucune direction n’a encore été définie.

Dyalog APL , 63 octets

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

utilisations ⎕IO←0et fonctionnalités de v16 ( @)

n←≢s←⍞entrée brute set sa longueurn

⍴∘'',⍨2×n créer une matrice d'espaces 2n par 2n

s@(...)modifier la matrice avec les caractères de saux (paires de) index spécifiés

comment les indices sont calculés:

¯1↓s déposer le dernier caractère de s

'rdluRDLU'⍳'encoder 'r'comme 0, 'd'comme 1, etc. autres caractères comme 8

0, ajouter un 0

(8∘≠⍴¨⊢) transformez tous les 8 en une liste vide, tous les autres en une liste d'un élément

,⍨\concaténations cumulées échangées ( abcd-> a ba cba dcba)

⊃¨ d'abord de chaque

0j1* constante imaginaire i à la puissance de

+\ sommes cumulatives

11 9∘○¨partie réelle et imaginaire de chacun; obtenir des coordonnées dans la gamme -n...n

n+ les centrer sur la grande matrice

Pyth, 68 65 octets

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

Suite de tests

Cela utilise un dictionnaire, indexé par une paire de coordonnées, qui est mis à jour lorsque l'entrée est lue, puis imprimé à la fin. Il utilise également une tonne d'astuces de golf intelligentes.

Voici comment je l'ai écrit, en utilisant le -mdrapeau de l'interprète pour effacer les espaces et les commentaires avant de lancer:

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 octets

Edit: 51 octets sauvés grâce à @steenbergh

Ce n'est pas joli, mais ça marche ...

Golfé:

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

Explication:

Utilise un tableau à deux dimensions et la dvaleur pour incrémenter la position du tableau dans le sens de la correction, où les valeurs d sont les suivantes:

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

Tester:

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

Modifier J'utilisais uet tpour garder une trace de la position la plus haute et la plus à gauche, mais je me suis rendu compte que ce tn'était pas du tout nécessaire

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

Moins golfé

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
}             

Tester

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 octets

3 octets sauvés grâce à Grimy

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

Essayez-le en ligne!

Explication

ā                        # 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̶, 455, 433 octets

Éditions: 11 octets enregistrés, grâce à l'utilisateur 1000000000 10 environ, grâce à l'utilisateur2428118 Suppression de quelques points-virgules inutiles.

Je suis à peu près sûr que cela peut être joué davantage, mais je n'y suis pas parvenu. Je suis toujours nouveau, alors tout conseil est très apprécié :)

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

}

J'ai plus ou moins pris l'approche de:

• Avoir un tableau pour stocker la sortie
• Calculer la position x et y du caractère suivant dans le tableau
• Si les coordonnées étaient sur le point de se trouver en dehors du tableau, déployez le tableau dans cette direction. Soit en insérant un espace supplémentaire à la fin de cette ligne, soit en ajoutant une autre ligne.
• Faire un tableau [y] [x] = caractère actuel
• imprimer le tableau résultant

Python 3, 314 309 290 268 octets

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

J'ai essayé d'exécuter mon programme en tant qu'entrée dans mon programme avec des résultats intéressants. Hah, essayez d'interpréter cela, Python!

Rasé 5 octets - compliments à Jack Bates.

23 octets supprimés par Kundor

Note: Je pense qu'il y a eu une erreur de mesure avec mes octets à cause de l'utilisation d'éditeurs différents. Cependant, je suis à peu près sûr que le dernier en date est correct.

PHP, 238 223 205 204 octets

12 octets enregistrés par Jörg ( striposau lieu de preg_match), 1 octet + accolades en guettant au lieu de terminer la nouvelle ligne, 16 accolades jouées depuis le changement de direction, 1 de plus avec ternaire au lieu de 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]??" ";

Exécuter en pipe php -nR '<code>'ou essayer en ligne .

panne

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 octets

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 octets grâce à @Grimy .

Explication:

Essayez ici. (REMARQUE: je supprime tous les espaces finaux / nouvelles lignes pour rendre la sortie un peu plus compacte. N'hésitez pas à supprimer le .replaceAll("(m?)\\s+$","")dans la testméthode pour voir le résultat réel.)

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 octets

+3 pour -F

Les espaces ne font pas partie du code et sont fournis pour des raisons de lisibilité.

%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""
}

Comme pour ma solution au défi Fizz Buzz, je crée un hachage avec les coordonnées x, y pour chaque étape du processus, tout en conservant les maxima et minima des coordonnées x et y mémorisées, puis en boucle et imprimant le tout.

Si je suis désespéré, je pourrais peut-être transformer les trois dernières lignes de la première forboucle en une seule déclaration dégoûtante pouvant économiser un octet ou deux, mais je ne suis pas impatient de voir le résultat complètement illisible.

Excel VBA, 205 octets

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

Je suis un peu surpris de la capacité d'Excel à concurrencer les réponses existantes. Cela fonctionne parce que wet zgarde une trace de la direction.

SmileBASIC, 148 146 octets

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

Appelez la fonction avec W "text",vx,vy, où vx et vy sont la direction au début (1,0 par défaut)

Rapide 3, 283 octets

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

Attention

Une saisie plus longue nécessite un plus grand écran. La sortie ne traite pas les lignes / colonnes "vides" si j'ai bien compris que cela est acceptable selon les règles du challenge.

Rant

• Newline étant le terminateur par défaut pour print sux
• Aucun moyen simple de créer un tableau de longueur connue n'a détruit le score.