স্পেসশিপ কোথায় যায়?

15

জগারব প্রস্তাবিত একটি ধারণার ভিত্তিতে ।

একটি স্পেসশিপ নিয়মিত 3 ডি গ্রিডের আশেপাশে চলছে। গ্রিডের ঘরগুলি ডান-হাত সমন্বয় ব্যবস্থা, জাইজেড -এ পূর্ণসংখ্যার সাথে সূচিযুক্ত হয় । স্পেসশিপটি ইতিবাচক x অক্ষ বরাবর পয়েন্ট করে ধীরে ধীরে z অক্ষটি উপরের দিকে নির্দেশ করে শুরুতে শুরু হয় ।

স্পেসশিপটি নন-খালি চলাচলের ক্রম দ্বারা সংজ্ঞায়িত একটি ট্র্যাজেক্টোরির সাথে উড়ে যাবে। প্রতিটি চলন হয় হয় F(অগ্রগামী) যা স্পেসশিপটি একটি কক্ষকে তার মুখের দিকে বা ছয়টি আবর্তনের একটির দিকে নিয়ে যায় UDLRlr। এগুলি পিচ, ইয়াও এবং রোলের সাথে মিলে যায়:

PYR
চিত্রটি তৈরি করার জন্য জগারবকে ধন্যবাদ।

  • Uপি এবং Dনিজস্ব স্পেসশিপটির পিচটি 90 ডিগ্রি (যেখানে দিকটি স্পেসশিপের নাকের চলাচলের সাথে মিলে যায়) দ্বারা পরিবর্তন করে।
  • Left এবং ight R90 ডিগ্রি দ্বারা স্পেসশিপের ইয়াবা পরিবর্তন করে। এগুলি কেবল নিয়মিত বাম এবং ডানদিকে ঘুরছে।
  • left এবং ight হ'ল r90 ডিগ্রি রোলিং মুভমেন্ট, যেখানে দিকটি নির্দেশ করে যে কোন ডানা নীচের দিকে চলে moves

নোট করুন যে এগুলি সর্বদা স্পেসশিপের তুলনায় ব্যাখ্যা করা উচিত যাতে প্রাসঙ্গিক অক্ষগুলি এটির সাথে ঘোরানো হয়।

গাণিতিক ভাষায়, স্পেসশিপটি প্রথমে ভেক্টর (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
— ব্যবহারকারীর নাম
@ ব্যবহারকারীর নাম .ক আমি মনে করি না আমি প্রশ্নটি বুঝতে পেরেছি। আপনার নির্দেশনা কি?
— মার্টিন এন্ডার
@ মার্টিন বাটনার, আমি বলছি কেন 180 ডিগ্রি ঘূর্ণন -180 এর মতো নয়, 270 -90 ইত্যাদির মতো নয়
— ব্যবহারকারীর নাম
@ ব্যবহারকারীর নাম .ক না?
— মার্টিন এন্ডার

উত্তর:

3

এমএটিএল , 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

ES6, 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
— নিল
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.