2048 पहेली की तरह टेक्स्ट ग्रैविटी बदलें

Question

खेल 2048 में, आपके पास एक ग्रिड है, और आप तत्वों को चार दिशाओं में स्थानांतरित कर सकते हैं। वे सभी उस दिशा में आगे बढ़ते हैं जहाँ तक वे कर सकते हैं। इस चुनौती के लिए, आपको एक गद्देदार, चौकोर 2 डी स्ट्रिंग दिया जाएगा (या तो नई लाइनों के साथ, या तार की एक सूची), जैसे:

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       

या

['ab cd e ', ' f ghij ', '      kl', 'mno p   ', ' q r st ', 'u      v', ' w x  y ', 'z       ']

चार संचालन कर रहे हैं left, right, up, और down। उपरोक्त इनपुट पर प्रत्येक का परिणाम:

बाएं:

abcde   
fghij   
kl      
mnop    
qrst    
uv      
wxy     
z       

या

['abcde   ', 'fghij   ', 'kl      ', 'mnop    ', 'qrst    ', 'uv      ', 'wxy     ', 'z       ']

सही:

   abcde
   fghij
      kl
    mnop
    qrst
      uv
     wxy
       z

या

['   abcde', '   fghij', '      kl', '    mnop', '    qrst', '      uv', '     wxy', '       z']

यूपी:

abocdiel
mf ghsjv
un rp k 
zq x  t 
 w    y 


        

या

['abocdiel', 'mf ghsjv', 'un rp k ', 'zq x  t ', ' w    y ', '        ', '        ', '        ']

डाउन:

        


 b    e 
af c  j 
mn gd k 
uq rhitl
zwoxpsyv

या

['        ', '        ', '        ', ' b    e ', 'af c  j ', 'mn gd k ', 'uq rhitl', 'zwoxpsyv']

---

आपका लक्ष्य यह है कि किस ऑपरेशन को प्रत्येक पुनरावृत्ति को निष्पादित करना है, उन्हें इनपुट nसमय पर निष्पादित करना है। इसलिए यदि आपका आदेश है URDL, और इनपुट के साथ शुरू करने के लिए कहते हैं D( 2,, 0-अनुक्रमित), और आपको 5संचालन की आवश्यकता है D-L-U-R-D, तो आप प्रदर्शन करते हैं , फिर प्रिंट करें।

इनपुट:

• ऊपर की तरह एक प्रारूप में एक स्ट्रिंग
  • ट्रेलिंग रिक्त स्थान की आवश्यकता नहीं है (लेकिन वे शायद सहायक हैं)
  • यह कम से कम 2x2 होगा
  • केवल मुद्रण योग्य ASCII और रिक्त स्थान शामिल होंगे (और आपके इनपुट प्रारूप के अनुसार नए अंक)
  • आपको सैद्धांतिक रूप से किसी भी लम्बाई का समर्थन करना चाहिए, लेकिन मेमोरी की कमी ठीक है
• nनिष्पादित किए जाने वाले कार्यों की संख्या के लिए एक गैर-नकारात्मक पूर्णांक
• एक पूर्णांक 0-3या 1-4, या एक पत्र UDLR, जिसके साथ ऑपरेशन शुरू करने का वर्णन है।
  • तो आपका प्रोग्राम किसी भी ऑपरेशन के साथ शुरू या समाप्त करने में सक्षम होना चाहिए
  • आप उन्हें शुरुआती उद्देश्यों के लिए किसी भी क्रम में परिभाषित कर सकते हैं, लेकिन यह एक सुसंगत क्रम होना चाहिए, इसलिए Uकभी-कभी पालन नहीं कर सकता है Rऔर कभी-कभी पालन भी कर सकता है L।
• संचालन गैर-तुच्छ तरीके से किया जाना चाहिए
  • आप LDRUबार-बार (बाएं, नीचे, दाएं, ऊपर) क्रम में ऑपरेशन कर सकते हैं , लेकिन ( DLRUया जैसा है , वैसा ही करते हैं और जैसा करते हैं वैसा ही करते हैं ।)UDLRUDDLRR

आउटपुट:

• चार संचालन nसमय के बाद स्ट्रिंग
• आउटपुट प्रारूप आपके इनपुट प्रारूप के समान होना चाहिए
• ट्रेलिंग रिक्त स्थान की आवश्यकता नहीं है (लेकिन वे शायद सहायक हैं)

उदाहरण:

यह उदाहरण आदेश का उपयोग करता है URDL।

इनपुट:

10  (number of times operations are applied)
0   (starts with Up)

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       

N = 0-5 के लिए आउटपुट: (अंतिम परिणाम प्रिंट करें)

ab cd e 
 f ghij 
      kl
mno p   
 q r st 
u      v
 w x  y 
z       
---------------
abocdiel
mf ghsjv
un rp k 
zq x  t 
 w    y 



---------------
abocdiel
 mfghsjv
   unrpk
    zqxt
      wy



---------------



      el
    dijv
   chspk
 bognrxt
amfuzqwy
---------------



el      
dijv    
chspk   
bognrxt 
amfuzqwy
---------------
eljvkxty
disprqw 
chgnz   
bofu    
am      


        

मेरा सुंदर, असम्बद्ध कार्यान्वयन

Comments

संबंधित , लेकिन अलग-अलग, क्योंकि किसी के पास "नक्शा बंद करना" अक्षर हो सकते हैं।

— mbomb007

संबंधित

— लकोनी

केवल अंतिम परिणाम, या मध्यवर्ती चरणों को भी प्रिंट करना चाहिए? इसके अलावा, एक बार में सभी चार ऑपरेशन किए जाने के बाद क्या परिणाम सिर्फ चक्रीय नहीं है? (निश्चित नहीं, सिर्फ अनुमान लगाते हुए)

— लुइस मेंडू

बस अंतिम परिणाम। और मैंने पुष्टि की कि यह चक्रीय नहीं है ।

— mbomb007

केवल चार ऑपरेशनों के बाद चक्रीय नहीं, अर्थात्। अवधि बहुत लंबी होगी।

— mbomb007

Answer 1

जेली , 23 बाइट्स

UZ
Ç¡=⁶$Þ€Ç$⁴¡ZU$⁵+⁴¤¡Y

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

मैं थोड़ा असंतुष्ट हूं, लेकिन MATL को कुछ प्रतिस्पर्धा की जरूरत है। : पी

आदेश का उपयोग करता है URDL। इनपुट:

• गद्देदार लाइनों के एक सरणी के रूप में इनपुट सरणी
• दोहराव की संख्या
• (1 = U, 2 = R, 3 = D, 4 = L) से शुरू करने के लिए कदम

व्याख्या

UZ       Helper link. Argument: A (the 2D array)
U        Reverse each line and...
 Z       ...transpose. Rotates 90° CCW.

Ç¡=⁶$Þ€Ç$⁴¡ZU$⁵+⁴¤¡Y    Main link. Arguments: A, n (2D array, repetitions)
Ç                       Rotate 90° CCW...
 ¡                      ...m times. (m = which move to start on)

     Þ                  Sort...
      €                 ...each line of the array...
  =⁶                    ...based on the characters' equality to " ".
       Ç                Rotate 90° CCW.
        $               Combine the sort and rotate to one action.
         ⁴¡             Do that n times. (n = repetition count)

           Z            Transpose and...
            U           ...reverse each line. Rotates 90° CW.
             $          Combine the transpose and reverse to one action.
                  ¡     Do that...
              ⁵+⁴¤      ...m + n times.

                   Y    Join the array by newlines.

Answer 2

जावास्क्रिप्ट (ईएस 6), 168 बाइट्स

(n,d,s,t=s.replace([RegExp(`( )([^]{${l=s.search`
`}})(\\w)`),/(.)(\b)( )/,RegExp(`(\\w)([^]{${l}})( )`),/( )(\b)(.)/][d%4],`$3$2$1`))=>n?t!=s?f(n,d,t):f(n-1,d+1,s):s

Ungolfed:

function gravity(count, direction, string) {
    let width = string.indexOf('\n');
    let up = new RegExp('( )([^]{' + width + '})(\\w)');
    let down = new RegExp('(\\w)([^]{' + width + '})( )');
    while (count--) {
        let regexp = [up, /(.)(\b)( )/, down, /( )(\b)(.)/][direction++ % 4];
        while (regexp.test(string)) string = string.replace(regexp, '$3$2$1');
    }
    return string;
}

dदिशाओं में प्रारंभिक सूचकांक है जो हैं URDL।

Answer 3

पायथन 2 , 226 224 204 193 बाइट्स

^{-1 बाइट थ्रेडेज़वीर के लिए धन्यवाद}

x,s,n=input()
j=''.join
g=lambda x,i:[eval("j(_.split(' ')).%sjust(len(_))"%'lr'[i%2])for _ in x]
for i in([0,3,1,2]*n)[s:s+n]:x=[map(j,zip(*g(map(j,zip(*x)),i))),g(x,i)][i>1];print'\n'.join(x)

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

फ़ंक्शन जो सूची में प्रत्येक तत्व के सभी रिक्त स्थान को हटाते हैं और बाईं या दाईं ओर रिक्त स्थान के साथ पूरा करते हैं।

g=lambda x,i:[eval("''.join(_.split(' ')).%sjust(len(_))"%'lr'[i%2])for _ in x]

यह (घुमाने 90 º) स्थानांतरित करने के लिए जब इनपुट है 0या 1( Uया D) और लागूg

x=[map(''.join,zip(*g(map(''.join,zip(*x)),i))),g(x,i)][i>1]

Comments

में अतिरिक्त स्थान for i in (...)।

— १

यह मूल रूप से मेरे कार्यान्वयन का एक गोल्फ संस्करण है (मैंने इसे कभी भी बहुत परेशान नहीं किया)।

— mbomb007

Answer 4

MATL , 24 23 बाइट्स

:+"@X!XJ_JXzJ32>S(c@_X!

आदेश है URDL, 1-बेड। तो 1यू ,2 isR` आदि

इनपुट्स हैं: समय की संख्या, प्रारंभिक दिशा, चार मैट्रिक्स ( ;पंक्ति विभाजक के रूप में उपयोग )।

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

Comments

मैं बाद में दिन में एक स्पष्टीकरण

— जोड़ूंगा