स्पेसशिप कहाँ जाता है?

15

जरगब द्वारा सुझाए गए एक विचार के आधार पर ।

एक अंतरिक्ष यान एक नियमित 3 डी ग्रिड के आसपास घूम रहा है। ग्रिड की कोशिकाओं को एक दाहिने हाथ के समन्वय प्रणाली में पूर्णांक के साथ अनुक्रमित किया जाता है, xyz । स्पेसशिप की शुरुआत मूल पर होती है, जो पॉजिटिव x एक्सिस की ओर इशारा करता है , पॉजिटिव Z एक्सिस ऊपर की ओर इशारा करता है।

अंतरिक्ष यान आंदोलनों के एक गैर-खाली अनुक्रम द्वारा परिभाषित प्रक्षेपवक्र के साथ उड़ जाएगा। प्रत्येक आंदोलन या तो F(ओरवर्ड) होता है जो स्पेसशिप को एक सेल को उसके सामने की दिशा में या छह घुमावों में से एक में स्थानांतरित करता है UDLRlr। ये पिच, यव और रोल के अनुरूप हैं:

PYR
चित्र बनाने के लिए ज़गरब को धन्यवाद।

  • Uपी और D खुद ही स्पेसशिप की पिच को 90 डिग्री तक बदल देता है (जहां दिशा स्पेसशिप की नाक के मूवमेंट से मेल खाती है)।
  • Left और Right 90 डिग्री से अंतरिक्ष यान के जबड़े को बदलते हैं। वे सिर्फ नियमित रूप से बाएं और दाएं मुड़ते हैं।
  • lईफ़्ट और right 90 डिग्री रोलिंग मूवमेंट हैं, जहां दिशा इंगित करती है कि कौन सी विंग नीचे की ओर बढ़ती है।

ध्यान दें कि ये हमेशा अंतरिक्ष यान के सापेक्ष व्याख्या की जानी चाहिए ताकि संबंधित अक्ष इसके साथ-साथ घूमते रहें।

गणितीय संदर्भ में, अंतरिक्ष यान की स्थिति में शुरू में है (0, 0, 0)साथ ओर इशारा करते हुए, (1, 0, 0), वेक्टर के साथ (0, 0, 1)ऊपर की तरफ इशारा करते हुए। समन्वय प्रणाली पर लागू निम्नलिखित मैट्रिसेस के अनुरूप हैं:

U = ( 0  0 -1     D = ( 0  0  1
      0  1  0           0  1  0
      1  0  0 )        -1  0  0 )

L = ( 0 -1  0     R = ( 0  1  0
      1  0  0          -1  0  0
      0  0  1 )         0  0  1 )

l = ( 1  0  0     r = ( 1  0  0
      0  0  1           0  0 -1
      0 -1  0 )         0  1  0 )

आपको अंतरिक्ष यान की अंतिम स्थिति को तीन पूर्णांक x , y के रूप में आउटपुट करना चाहिए , z के । आउटपुट तीन अलग-अलग पूर्णांक या एक सूची या स्ट्रिंग हो सकता है। जब तक आप इसे निर्दिष्ट करते हैं, तब तक वे किसी भी सुसंगत क्रम में हो सकते हैं।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

F                                                   => (1, 0, 0)
FDDF                                                => (0, 0, 0)
FDDDF                                               => (1, 0, 1)
LrDDlURRrr                                          => (0, 0, 0)
UFLrRFLRLR                                          => (1, 0, 1)
FFrlFULULF                                          => (3, 0, -1)
LLFRLFDFFD                                          => (-2, 0, -2)
FrrLFLFrDLRFrLLFrFrRRFFFLRlFFLFFRFFLFlFFFlUFDFDrFF  => (1, 5, 7)
FUrRLDDlUDDlFlFFFDFrDrLrlUUrFlFFllRLlLlFFLrUFlRlFF  => (8, 2, 2)
FFLrlFLRFFFRFrFFFRFFRrFFFDDLFFURlrRFFFlrRFFlDlFFFU  => (1, 2, -2)
FLULFLFDURDUFFFLUlFlUFLFRrlDRFFFLFUFrFllFULUFFDRFF  => (-3, -2, -3)

काम का उदाहरण

यहाँ UFLrRFLRLRपरीक्षण मामले के मध्यवर्ती चरण हैं । यहां, सभी मध्यवर्ती निर्देशांक और दिशा वैक्टर प्रारंभिक, वैश्विक समन्वय प्रणाली में दिए गए हैं (जैसा कि एक स्थानीय से अंतरिक्ष यान के विपरीत है:

Cmd.  Position    Forward     Up
      ( 0, 0, 0)  ( 1, 0, 0)  ( 0, 0, 1)
U     ( 0, 0, 0)  ( 0, 0, 1)  (-1, 0, 0)
F     ( 0, 0, 1)  ( 0, 0, 1)  (-1, 0, 0)
L     ( 0, 0, 1)  ( 0, 1, 0)  (-1, 0, 0)
r     ( 0, 0, 1)  ( 0, 1, 0)  ( 0, 0, 1)
R     ( 0, 0, 1)  ( 1, 0, 0)  ( 0, 0, 1)
F     ( 1, 0, 1)  ( 1, 0, 0)  ( 0, 0, 1)
L     ( 1, 0, 1)  ( 0, 1, 0)  ( 0, 0, 1)
R     ( 1, 0, 1)  ( 1, 0, 0)  ( 0, 0, 1)
L     ( 1, 0, 1)  ( 0, 1, 0)  ( 0, 0, 1)
R     ( 1, 0, 1)  ( 1, 0, 0)  ( 0, 0, 1)
code-golf  geometry  grid 
— मार्टिन एंडर
स्रोत
इस चुनौती का एक 3 डी सामान्यीकरण है इस एक , शून्य से चौराहे हिस्सा।
— orlp
!! क्यों 2 = 2, 3 = -1, 4 = 0 = -4, 1 = -3!
— username.ak
@ username.ak मुझे नहीं लगता कि मैं इस सवाल को समझता हूं। आप क्या बात कर रहे हैं?
— मार्टिन एंडर
@ मर्टिन बट्टनर, मैं कहता हूं कि क्यों 180 डिग्री रोटेशन -180 के समान नहीं है, 270 -90 आदि के समान नहीं है।
— username.ak
@ username.ak यह नहीं है?
— मार्टिन एंडर

जवाबों:

3

MATL , 76 75 बाइट्स

FFF!3Xyj"FFT_FTFv4BvtFT_YStTF_YS3:"3$y!]6$Xh@'ULlDRr'4#mt?X)Y*}xxt1Z)b+w]]x

यह भाषा के वर्तमान संस्करण (12.1.1) में काम करता है।

संपादित करें (4 अप्रैल, 2016): vभाषा के रिलीज के 15.0.0 में फ़ंक्शन का व्यवहार बदल गया है। उपरोक्त कोड को चलाने के लिए, पहले को हटा दें vऔर दूसरे को बदल दें 3$v। निम्न लिंक में यह संशोधन शामिल है।

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

व्याख्या

जहाज की स्थिति को दो चर के संदर्भ में वर्णित किया जा सकता है:

  • स्थिति: 3x1 वेक्टर
  • अभिविन्यास: संचित रोटेशन के साथ 3x3 मैट्रिक्स , जहां "संचित" का अर्थ है दोहराया मैट्रिक्स उत्पाद।

एक तीसरा चर वह दिशा होगी जिसमें जहाज का सामना करना पड़ रहा है, लेकिन इसकी आवश्यकता नहीं है, क्योंकि इसे प्रारंभिक दिशा (स्तंभ) के रूप में प्राप्त किया जा सकता है1;0;0] वर्तमान ) बार ; यह अभिविन्यास का पहला स्तंभ है।

ये दो राज्य चर स्टैक पर रखे जाते हैं, और प्रत्येक अक्षर के साथ अपडेट किए जाते हैं। प्रत्येक अक्षरULlDRr अभिविन्यास को अद्यतन करने के लिए छह रोटेशन मेट्रिसेस में से एक द्वारा अभिविन्यास मैट्रिक्स को गुणा करता है। पत्रF वर्तमान स्थिति और अभिविन्यास मैट्रिक्स के पहले स्तंभ को जोड़ता है।

छह रोटेशन मैट्रीस निम्नानुसार बनाए जाते हैं: पहले सीधे पेश किया जाता है; दूसरे और तीसरे पिछले एक के परिपत्र बदलाव हैं; और बाकी तीनों को दूसरों के ट्रांसपोंड संस्करण दिए गए हैं।

FFF!             % 3x1 vector [0;0;0]: initial position
3Xy              % 3x3 identity matrix: initial orientation
j                % input string
"                % for-each character in that string
  FFT_FTFv4Bv    %   rotation matrix for U: defined directly
  tFT_YS         %   rotation matrix for L: U circularly shifted to the left
  tTF_YS         %   rotation matrix for l: L circularly shifted down
  3:"            %   repeat three times
    3$y!         %     copy third matrix from top and transpose
  ]              %   end loop. This creates rotation matrices for D, R, r
  6$Xh           %   pack the 6 matrices in a cell array
  @              %   push current character from the input string
  'ULlDRr'4#m    %   this gives an index 0 for F, 1 for U, 2 for L, ..., 6 for r
  t?             %   if non-zero: update orientation
    X)           %     pick corresponding rotation matrix
    Y*           %     matrix product
  }              %   else: update position
    xx           %     delete twice (index and rotation matrix are not used here)
    t1Z)         %     duplicate orientation matrix and take its first column
    b+           %     move position vector to top and add
    w            %     swap the two top-most elements in stack
  ]              %   end if
]                % end for-each
x                % delete orientation matrix
                 % implicitly display position vector
— लुइस मेंडो
स्रोत
1

ऑक्टेव, 175 बाइट्स

function p=s(i)m.U=[0,0,-1;0,1,0;1,0,0];m.D=m.U';m.L=[0,-1,0;1,0,0;0,0,1];m.R=m.L';m.l=flip(flip(m.L),2);m.r=m.l';a=m.F=eye(3);p=[0;0;0];for c=i p+=(a*=m.(c))*[c=='F';0;0];end

पठनीय संस्करण:

function p=s(i)
  m.U=[0,0,-1;0,1,0;1,0,0];
  m.D=m.U';
  m.L=[0,-1,0;1,0,0;0,0,1];
  m.R=m.L';
  m.l=flip(flip(m.L),2);
  m.r=m.l';
  a=m.F=eye(3);
  p=[0;0;0];
  for c=i p+=(a*=m.(c))*[c=='F';0;0];
end
— रेनर पी।
स्रोत
गतिशील क्षेत्र के नामों का अच्छा उपयोग!
— लुइस मेंडो
2
"पठनीय संस्करण [उद्धरण वांछित]";)
— ट्राइकोप्लाक्स
0

ईएस 6, 265 259 बाइट्स

s=>[...s.replace(/F/g,"f$`s")].reverse().map(e=>d={U:(x,y,z)=>[-z,y,x],D:(x,y,z)=>[z,y,-x],L:(x,y,z)=>[-y,x,z],R:(x,y,z)=>[y,-x,z],r:(x,y,z)=>[x,-z,y],l:(x,y,z)=>[x,z,-y],F:(...d)=>d,f:(x,y,z)=>[a+=x,b+=y,c+=z]),s:_=>[1,0,0]}[e](...d),d=[1,0,a=b=c=0])&&[a,b,c]

स्पष्टीकरण: आम तौर पर अंतरिक्ष यान की दिशा की गणना करने के लिए आप सभी घुमावों की एक साथ रचना करेंगे, और फिर प्रत्येक चाल के लिए आप इकाई वेक्टर को परिणाम की रचना करेंगे F = (1, 0, 0)(या अधिक केवल मैट्रिक्स के पहले स्तंभ को निकालेंगे)। उदाहरण के लिए, FFrlFULULF => F + F + r⋅l⋅F + r⋅l⋅U⋅L⋅L⋅L⋅F। चूंकि मैट्रिक्स गुणन साहचर्य है, इसलिए अंतर्निहित मैट्रिक्स गुणन वाली भाषाएँ स्पष्ट रूप से आंशिक उत्पाद की गणना कर सकती हैं r⋅l⋅U⋅L⋅L⋅Lक्योंकि वे साथ चलते हैं, इसलिए गुणा करके मुझे सूची में प्रत्येक शब्द के प्रारंभ और अंत को भी चिह्नित करना होगा ताकि मैं बाकी चीजों को अनदेखा कर सकूं डोर। थोड़ा अपराजित:F वाली शर्तों का उत्पादन करने के लिए आवश्यक रूप से करते हैं। दुर्भाग्य से मेरे पास वह लक्जरी नहीं है, इसलिए सबसे सस्ता विकल्प ऊपर की अभिव्यक्ति में प्रत्येक शब्द को अलग-अलग गणना करना है, जिसके साथ शुरू करना Fऔर वापस काम करना है। उसके लिए, मुझे प्रत्येक के होने वाली घटनाओं के लिए एक सूची चाहिएF उस बिंदु तक सभी घुमावों से । मैं यह प्रयोग कर रहा हूँreplaceइसके साथ$`

s=>[... // split the string into separate operations
    s.replace(/F/g,"f$`s")] // For each 'F', wrap the operations up to that point
  .reverse() // Play all the operations in reverse order
  .map(e=>d= // Update the direction for each operation
    { // set of operations
      U:(x,y,z)=>[-z,y,x], // Up
      D:(x,y,z)=>[z,y,-x], // Down
      L:(x,y,z)=>[-y,x,z], // Left turn
      R:(x,y,z)=>[y,-x,z], // Right turn
      r:(x,y,z)=>[x,-z,y], // right roll
      l:(x,y,z)=>[x,z,-y], // left roll
      F:(...d)=>d, // does nothing, `s` and `f` do the work now
      f:(x,y,z)=>[a+=x,b+=y,c+=z], // do the move
      s:_=>[1,0,0] // back to start
    }[e](...d), // apply the operation to the current direction
    d=[1,0,a=b=c=0] // initialise variables
  )&&[a,b,c] // return result
— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.