शब्द चलो!

33

यह मेरी विनम्र राय है कि मानक पाठ उबाऊ है। इसलिए मैं एक नया लेखन मानक प्रस्तावित करता हूं, शब्दों का चलना!

चलने का शब्द

चलने वाले शब्द ऐसे शब्द हैं जो कुछ वर्णों का जवाब देंगे। इस चुनौती के प्रयोजन के लिए ट्रिगर चरित्र [u, d, r, l]से up down right left।

जब भी आप पाठ को प्रिंट करते समय इस तरह के चरित्र का सामना करते हैं, तो आप पाठ की दिशा को आगे बढ़ाएंगे।
उदाहरण के लिए, पाठ abcdefमें परिणाम होगा: 

abcd
   e
   f

नियम

  • अपरकेस UDRLऔर लोअरकेस दोनों udrlको दिशा बदलनी चाहिए, लेकिन आउटपुट में मामले को संरक्षित किया जाना चाहिए
  • इनपुट में केवल मुद्रण योग्य वर्ण होंगे (0-9, A-Z, a-z, !@#%^&*() etc...), कोई नया अंक नहीं!
  • जब भी पाठ टकराएगा, वह उस स्थिति में पुराने चरित्र को अधिलेखित कर देगा
  • आउटपुट को किसी भी फैशनेबल मामले में उपयोगकर्ता को प्रस्तुत किया जाना चाहिए, लेकिन यह एक एकल आउटपुट होना चाहिए (लाइनों की कोई सरणी नहीं)
  • अनुगामी और अग्रणी नई सूचियों की अनुमति है
  • ट्रेलिंग रिक्त स्थान की अनुमति है
  • मानक खामियां लागू होती हैं

परीक्षण के मामलों

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
                                       !

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड!

code-golf  grid  printable-ascii 
— बैसड्रॉब कंबरवुबवबब
स्रोत
4
इस प्रारूप में डेटा हानि की गंभीर समस्या है ...: पी
— मुकुल कुमार
क्या प्रमुख / अनुगामी स्थानों की अनुमति है?
— Arnauld
@Arnauld जब तक वे पात्रों की स्थिति को विचलित नहीं करते वे हैं। तो सबसे अधिक संभावना सिर्फ रिक्त स्थान है
— बैसब्रांड कंबरवुबवबूब
1
शब्द का उत्पादन golfअपने आप कैसे दिखेगा?
— 16:38 पर gabe3886
2
@ gabe3886gfl
— बैसब्रांड कंबरवॉबुवब

जवाबों:

4

चारकोल , 29 27 20 19 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＦＳ«

इनपुट वर्णों पर लूप करें।

Ｆ№rdlu↧ι

यदि वर्तमान अक्षर एक दिशा है ...

≔ιω

फिर वर्तमान चलने की दिशा को अपडेट करें।

✳∨ωrι

यदि कोई दिशा अभी तक निर्धारित नहीं की गई है, तो दाईं ओर डिफ़ॉल्ट रूप से, वर्तमान वॉकिंग दिशा में वर्ण प्रिंट करें।

— नील
स्रोत
1
@Veskah ⌕माना जाता था कि ए №। उसके लिए माफ़ करना।
— नील
7

दिल्लोग एपीएल , 63 बाइट्स

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

⎕IO←0v16 से उपयोग और सुविधाएँ ( @)

n←≢s←⍞कच्चे इनपुट sऔर इसकी लंबाईn

⍴∘'',⍨2×n रिक्त स्थान के 2n मैट्रिक्स द्वारा 2n बनाएँ

s@(...)sनिर्दिष्ट (जोड़े) सूचकांकों के पात्रों के साथ मैट्रिक्स में संशोधन करें

सूचकांकों की गणना कैसे की जाती है:

¯1↓s के अंतिम चार्ट को छोड़ दें s

'rdluRDLU'⍳'एनकोड 'r'0 के रूप में, 'd'1 के रूप में, आदि; अन्य वर्ण 8 के रूप में

0, शुरू करना ०

(8∘≠⍴¨⊢) प्रत्येक 8 को एक रिक्त सूची में बदल दें, अन्य सभी को 1-तत्व सूची में शामिल करें

,⍨\संचयी अदला बदली ( abcd-> a ba cba dcba)

⊃¨ प्रत्येक से पहला

0j1* की शक्ति के लिए काल्पनिक निरंतर

+\ संचयी रकम

11 9∘○¨प्रत्येक से वास्तविक और काल्पनिक हिस्सा; रेंज में कोऑर्डर्स प्राप्त करें -n...n

n+ उन्हें बड़े मैट्रिक्स पर केन्द्रित करें

— NGN
स्रोत
3

पायथ, 68 65 बाइट्स

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

परीक्षण सूट

यह एक शब्दकोश का उपयोग करता है, निर्देशांक की एक जोड़ी द्वारा अनुक्रमित, जिसे इनपुट रीड के रूप में अपडेट किया जाता है, फिर अंत में मुद्रित किया जाता है। इसमें एक टन चालाक गोल्फ चाल का भी उपयोग किया गया है।

यहां बताया गया है कि मैंने इसे लिखा था, -mव्हॉट्सएप चलाने के लिए दुभाषिया के झंडे का उपयोग करने और दौड़ने से पहले टिप्पणी करने के लिए:

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.
— isaacg
स्रोत
3

सी #, 525 474 बाइट्स

संपादित करें: @steenbergh के लिए 51 बाइट्स धन्यवाद सहेजा गया

यह सुंदर नहीं है, लेकिन यह काम करता है ...

golfed:

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

स्पष्टीकरण:

द्वि-आयामी सरणी का उपयोग करता है और dसुधार दिशा में सरणी की स्थिति को बढ़ाने के लिए मान, जहां d मान हैं:

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

परीक्षा:

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

                            cod                              
                              e                              
                              g                              
                              o                              
                         dna fl    sel                       
                                     z                       
                         p           z                       
                         rogramming pu
— पीट आर्डेन
स्रोत
आप दूसरे स्विच को पूरी तरह से हटा सकते हैं। पहले स्विच में, जहां आप लिखते हैं d=0;, इस स्टेटमेंट को दूसरे स्विच case 0:स्टेटमेंट में स्टेटमेंट द्वारा बदलें और अन्य मामलों के समान करें और आपको दूसरे स्विच की आवश्यकता नहीं हो सकती है। और अंत में इस स्टेटमेंट को हटा दें a[y,x]=s[i]और इसे शीर्ष पर लिखें पहले स्विच का।
— मुकुल कुमार
@ मुकुलकुमार अच्छा विचार है, मैं इसे काम नहीं कर सकता। मैंने इसे शुरू में एक स्विच में करने की कोशिश की। यह वर्तमान दोहरी स्विच कॉन्फ़िगरेशन में रहने के लिए मिला है! :)
— पीट आर्डेन
क्या आपने a[y,x]=s[i]पहले स्विच से पहले लिखा था ?
— मुकुल कुमार
2
आप उपयोग कर सकते हैं switch(s[i].toLowerCase())(या क्या c # समतुल्य है ...) और फिर सभी अपरकेस मामलों को हटा दें। कुछ बाइट्स को बचाना चाहिए।
— स्टैनबर्ग
1
@steenbergh धन्यवाद, प्रमुख बचत वहाँ! नहीं, आप सीधे नहीं कर सकते ToUpper()क्योंकि यह एक charनहीं है string। विकल्प s[i].ToString().ToUpper()या तो हैं char.ToUpper(s[i])- और मुझे लगता है कि charएक थोड़ा छोटा है। चियर्स :)
— पीट आर्डेन
3

जावास्क्रिप्ट (ईएस 6), 218 220 232

संपादित करें मैं उपयोग कर रहा था uऔर tशीर्ष और सबसे बाईं स्थिति का ट्रैक रखने के लिए, लेकिन मुझे एहसास हुआ कि tइसकी बिल्कुल भी आवश्यकता नहीं है

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

कम गोल्फ वाला

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
}

परीक्षा

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>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

05AB1E , 27 26 25 23 22 बाइट्स

3 बाइट्स ग्रिम के लिए धन्यवाद बचा लिया

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

इसे ऑनलाइन आज़माएं!

व्याख्या

ā                        # 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
— Emigna
स्रोत
1
"दुल्हन" एक शब्दकोष शब्द है। -1 । संपादित करें: कि -2 करें ।
— ग्रैमी
@Grimy: मुझे आश्चर्य है कि अगर शब्दकोश यहाँ इस्तेमाल किया जा सकता है, लेकिन यह वास्तव में स्मार्ट है!
— Emigna
22
— ग्रैमी
2

जावास्क्रिप्ट, 4as6̶6̶, 455, 433 बाइट्स

संपादन: 11 बाइट्स सहेजे गए, उपयोगकर्ता के लिए धन्यवाद 1000000000 10 या तो बचाया, user2428118 के लिए धन्यवाद भी कुछ अनावश्यक अर्ध-कोलों को हटा दिया।

मुझे पूरा यकीन है कि इसे आगे बढ़ाया जा सकता है, लेकिन मैं इसे प्रबंधित नहीं कर सका। मैं अभी भी पूरी नई हूँ, इसलिए किसी भी सलाह बहुत सराहना की है :)

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

}

मैंने कम या ज्यादा का दृष्टिकोण लिया:

  • उत्पादन स्टोर करने के लिए एक सरणी है
  • सरणी में अगले वर्ण की x और y स्थिति की गणना करें
  • यदि निर्देशांक सरणी के बाहर होने वाले थे, तो उस दिशा में सरणी का विस्तार करें। या तो धक्का देकर और उस पंक्ति के अंत में अतिरिक्त स्थान या पूरी तरह से दूसरी पंक्ति जोड़कर।
  • सरणी बनाएं [y] [x] = वर्तमान चरित्र
  • परिणामी सरणी मुद्रित करें
— Jhal
स्रोत
साइट पर आपका स्वागत है! मैं जावास्क्रिप्ट में एक विशेषज्ञ नहीं हूँ, लेकिन यह बहुत अच्छा लग रहा है।
— गेहूं जादूगर
स्वागत हे! आप की जगह 11 बाइट्स बचा सकता है ['r','u','l','d']के साथ"ruld"
— 0 '
इसके अलावा आपको z=अपने कार्यक्रम की शुरुआत में ज़रूरत नहीं है
— 0 '
पारितोषिक के लिए धन्यवाद! जेएस ने मुझे सुविधा के साथ विस्मित करना कभी नहीं छोड़ा।
— झाल २
आप कुछ बाइट्स, जैसे बचाने के लिए कई स्थानों पर टेम्पलेट शाब्दिक का उपयोग कर सकते हैं a.split`` ।
— user2428118
2

पायथन 3, 314 309 290 268 बाइट्स

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

मैंने अपने कार्यक्रम को कुछ दिलचस्प परिणामों के साथ अपने कार्यक्रम के इनपुट के रूप में चलाने की कोशिश की। हाह, कोशिश है कि अजगर की व्याख्या!

शेव्ड 5 बाइट्स - जैक बेट्स की तारीफ।

23 बाइट्स कुंदर से दूर

नोट: मुझे लगता है कि विभिन्न संपादकों का उपयोग करने के कारण मेरे बाइट्स के साथ माप की कुछ त्रुटि थी। हालाँकि, मैं काफी निश्चित हूं कि नवीनतम सही है।

— भगवान रटे
स्रोत
आप की जगह 5 बाइट्स को हटा सकते हैं 'r':(1,0)के साथ 'r':dऔर कम से अंतरिक्ष को हटाने के द्वारा w[a] for। इसके अलावा यह पागल है !!! आपको यह कितना समय लगा?
@JackBates एक दिन, काम के बीच में। मैं थोड़ा जुनूनी हो जाता हूं।
— भगवान रत्न
क्या हम सब नहीं? यह कोडिंग का पूरा बिंदु है!
मेरा मानना ​​है कि आप उस पूरी X,Y=map(...)लाइन को बदल सकते हैं X,Y=zip(*m)। यहाँ काम करता है। ( *mअपनी कुंजियों की सूची से इसे अनपैक कर देता है, और जिप उन्हें दो ट्यूपल्स पर फिर से जमा करता है।)
— निक
आप चार बाइट को बचाने के लिए लूप के लिए एक लाइन पर भी रख सकते हैं।
— निक मैट्टो
2

PHP, 238 223 205 204 बाइट्स

12 बाइट्स जोर्ग (के striposबजाय preg_match) द्वारा बचाए गए , 1 बाइट + ब्रेसिज़ को पीछे छोड़ते हुए न्यूलाइन को पीछे छोड़ते हुए, 16 + ब्रेसिज़ दिशा परिवर्तन से गोल्फ हुए, 1 के बजाय टर्नरी के साथ 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]??" ";

ऑनलाइन के साथ पाइप के रूप में चलाएं php -nR '<code>'या इसे आज़माएं ।

टूट - फूट

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
— टाइटस
स्रोत
1
अगर मैं देखूं कि इस अधिकार strspn($r[$y+=$e][$x+=$d]=$c,udlruDLR)को regex, ristripos (_ulrd, $ r [$ y + = $ e] [$ x + = $ d] = $ c) का उपयोग करने के बजाय कुछ बाइट्स बचाएं, तो better e को बेहतर बनाना चाहिए क्योंकि stratn $argnsave 3 बाइट्स बचाते हैं
— जॉग हल्सरमैन
@ JörgHülsermann क्या तुम मुझे घूर रहे हो? : D आप सही हैं।
— टाइटस
आज किसी ने भी अपना पोस्ट संपादित नहीं किया है और मैंने आपका उत्तर देखा है और मैंने देखा कि आप इसे छोटा बना सकते हैं। इस बारे में खेद है कि सुधार इतना महान नहीं है कि आप जेएस के उत्तर को हरा सकें। यह खुश और गर्व करता है अगर मैं आपके जवाब में कुछ बाइट्स पा सकता हूं लेकिन मैं इस मामलों को नहीं खोज रहा हूं
— Jörg Hülsermann
@ JörgHülsermann चिंता मत करो; मुझे आपके 12 के अलावा एक और 21 बाइट्स मिलीं। मुझे फिर से बनाने के लिए धन्यवाद।
— टाइटस
10 प्रतिशत से अधिक यह अच्छा है
— Jörg Hülsermann
2

जावा 10, 288 286 280 263 बाइट्स

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 बाइट्स की बदौलत @Grimy ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (नोट: मैं आउटपुट को थोड़ा और अधिक कॉम्पैक्ट बनाने के लिए सभी अनुगामी रिक्त स्थान / न्यूलाइन्स हटाता हूं। वास्तविक परिणाम देखने के .replaceAll("(m?)\\s+$","")लिए testइनथेमोड को हटाने के लिए स्वतंत्र महसूस करें ।)

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
— केविन क्रूज़सेन
स्रोत
1
d<69?1:d>84?-1:0हो सकता है5-d/14
— ग्रिमी
1
और एक ही नस में, d==82?1:d==76?-1:0हो सकता है3-(d^16)/23
— ग्रैमी
@ ग्रैमी थैंक्स। मुझे पता था कि उन दो हिस्सों को किसी तरह से निकाला जा सकता है, लेकिन मैं उन बिटवाइज़ / अंकगणितीय परिवर्तनों पर बहुत बुरा हूं, इसलिए मैंने कोशिश करने की जहमत नहीं उठाई। -17 बाइट्स के लिए धन्यवाद! :)
— केविन क्रूज़सेन
1

पर्ल, 204 + 3 = 207 बाइट्स

+3 के लिए -F

व्हॉट्सएप कोड का हिस्सा नहीं है और यह सुपाठ्यता के लिए प्रदान किया जाता है।

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

Fizz Buzz चुनौती के मेरे समाधान के समान, मैं x के साथ एक हैश बनाता हूं, y हर तरह से कदम के लिए निर्देशांक रखता है, x- और y- निर्देशांक के मैक्सिमम और न्यूनतम संग्रह को ध्यान में रखते हुए, फिर लूप के माध्यम से और सब कुछ प्रिंट करता है।

अगर मैं हताश हूं तो मैं पहले forलूप की अंतिम तीन पंक्तियों को एक ही घृणित बयान में बदल सकता हूं जो एक बाइट या दो को बचा सकता है, लेकिन मैं पूरी तरह से अपठनीय परिणाम के लिए उत्सुक नहीं हूं।

— गेब्रियल बेनामी
स्रोत
1

एक्सेल VBA, 205 बाइट्स

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

मैं मौजूदा उत्तरों के साथ प्रतिस्पर्धा करने की एक्सेल की क्षमता पर हैरान हूं। यह काम करता है wऔर zदिशा का ट्रैक रखता है।

— steenbergh
स्रोत
70 की शुरुआती स्थिति पर्याप्त नहीं हो सकती है। इसके अलावा, प्रमुख स्थानों की अनुमति नहीं है
— edc65
1

स्माइलबेसिक, 148 146 बाइट्स

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

फ़ंक्शन को कॉल करें W "text",vx,vy, जहां vx और vy प्रारंभ में दिशा है (डिफ़ॉल्ट 1,0 है)

— 12Me21
स्रोत
क्या होता है जब X या Y 0 से कम होता है?
— edc65
अब यह सभी पाठ को स्क्रॉल करेगा जब कर्सर ऑफ़स्क्रीन जाता है।
— 12M2121
0

स्विफ्ट 3, 283 बाइट्स

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

चेतावनी

लंबे इनपुट के लिए बड़ी स्क्रीन की आवश्यकता होगी। आउटपुट में "खाली" पंक्ति / कॉलम के लिए कोई उपचार नहीं है जैसा कि मैंने समझा कि चुनौती के नियमों द्वारा स्वीकार्य है।

शेख़ी

  • न्यूलाइन printsux के लिए डिफ़ॉल्ट टर्मिनेटर है
  • ज्ञात लंबाई की एक सरणी बनाने के किसी भी सरल तरीके ने स्कोर को नष्ट नहीं किया।
— Otávio
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.