বিন্দুগুলি ঘোরান

Question

প্রচলন

একটি 2 × n বুলিয়ান ম্যাট্রিক্স চারটি অক্ষরের একটি স্ট্রিং হিসাবে উপস্থাপিত হতে পারে . ':। স্ট্রিংটিতে একটি "উপরের সারি" এবং একটি "নিম্ন সারি" রয়েছে, যার মধ্যে বিন্দু 1 টি প্রতিনিধিত্ব করে এবং ফাঁকা স্থান 0 টি প্রতিনিধিত্ব করে। উদাহরণস্বরূপ, 2 × 6 ম্যাট্রিক্স

1 0 1 0 0 1
0 0 0 1 0 1

হিসাবে প্রতিনিধিত্ব করা যেতে পারে ' '. :। আপনার কাজটি হ'ল এই "সংকুচিত আকারে" ম্যাট্রিক্স নেওয়া এবং তার এন্ট্রিগুলি কনভেয়ার বেল্টের মতো এক ধাপ ঘড়ির কাঁটার দিকে ঘোরানো।

ইনপুট

আপনার ইনপুটটি অক্ষরের উপরে একক স্ট্রিং . ':। এর দৈর্ঘ্য কমপক্ষে 2 হওয়ার নিশ্চয়তা রয়েছে।

আউটপুট

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

উদাহরণ

ইনপুট স্ট্রিংটি বিবেচনা করুন :..:'.যা 2 × 6 ম্যাট্রিক্সের সাথে মিলে যায়

1 0 0 1 1 0
1 1 1 1 0 1

এই ম্যাট্রিক্সের আবর্তিত সংস্করণটি হ'ল

1 1 0 0 1 1
1 1 1 0 1 0

যা স্ট্রিংয়ের সাথে মিলে যায় ::. :'।

বিধি এবং স্কোরিং

আপনি একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়। ইনপুট এবং আউটপুট উদ্ধৃতিতে আবদ্ধ আছে কিনা তা আপনি সিদ্ধান্ত নিতে পারেন এবং একটি অনুবর্তনযোগ্য নতুন লাইন উভয় ক্ষেত্রে গ্রহণযোগ্য।

পরীক্ষার মামলা

এই পরীক্ষার কেসগুলি ডাবল কোটে সংযুক্ত থাকে।

"  " -> "  "
" ." -> ". "
". " -> "' "
"' " -> " '"
" '" -> " ."
": " -> "''"
"''" -> " :"
":." -> ":'"
":.'" -> ":'."
"..." -> ":. "
": :" -> "':."
"':." -> ".:'"
".:'" -> ": :"
"    " -> "    "
"::::" -> "::::"
":..:'." -> "::. :'"
" :  .:'" -> ". '.. :"
": ''. :" -> "'' :'.."
"........" -> ":...... "
"::::    " -> ":::''   "
"    ::::" -> "   ..:::"
" : : : : " -> ". : : : '"
".'.'.'.'.'" -> "'.'.'.'.'."
".. ::  '.' :." -> ": ..'' .' :.'"
".'  '.::  :.'. . ::.'  '. . .::'  :.'." -> "' ' .:.''..'.'. ..:' ' .'. ...'''..'.'"

Answer 1

জাভাস্ক্রিপ্ট (ES6), 100 97 93 বাইট

@ Edc65 ধন্যবাদ 4 বাইট সংরক্ষণ করা

s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])

কিভাবে এটা কাজ করে

এটি বর্তমানের আগে এবং পরে অক্ষরে কিছু গণনা সম্পাদন করে আমাদের যে চরিত্রটি সন্নিবেশ করা দরকার তা সিদ্ধান্ত নিয়েছে। আমাদের যোগফল:

• যদি এটি প্রথম চর হয়, এবং এর নীচে একটি বিন্দু রয়েছে, 2;
• অন্যথায়, এর আগে একটির উপরে যদি বিন্দু থাকে, 2।
• যদি এটি শেষ চর হয়, এবং এটির উপরে একটি বিন্দু রয়েছে, 1;
• অন্যথায়, এর পরে যদি নীচে একটি বিন্দু থাকে, 1।

এই স্থান, 1 জন্য 0 চমত্কারভাবে অঙ্কের ', 2 .এবং 3 এর জন্য :।

পরীক্ষার স্নিপেট

f=s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])

Try it out:
<input id=A type="text" value=".'  '.::  :.'. . ::.'  '. . .::'  :.'.">
<button onclick="B.innerHTML=f(A.value)">Run</button>
<pre id=B></pre>

Comments

সাবাশ. 4 সংরক্ষণ করুন: s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])(2 অংশগুলি ফ্লিপ করুন যাতে আমি i, কম রেজিএক্সপ্যাক এবং আরও সাধারণ পরীক্ষা বাড়িয়ে তুলতে পারি, সি সি

— এপ্রি

@ edc65 টিপটির জন্য ধন্যবাদ!

— ইটিএইচ প্রডাকশনগুলি

Answer 2

পার্ল, 70 69 64 63 61 60 বাইট

জন্য +2 অন্তর্ভুক্ত -lp

STDIN এ ইনপুট স্ট্রিং সহ চালান, যেমন

perl -lp rotatedots.pl <<< ":..:'."

rotatedots.pl:

y/'.:/02/r=~/./;y/.':/01/;$_=$'.2*chop|$&/2 .$_;y;0-3; '.:

ব্যাখ্যা

y/'.:/02/r                                        Construct bottom row but
                                                  with 2's instead of 1's
                                                  Return constructed value
                                                  (for now assume space
                                                  becomes 0 too)
          =~/./                                   Match first digit on bottom
                                                  row into $&. $' contains
                                                  the rest of the bottom row
                y/.':/01/                         Convert $_ to top row
                                                  (again assume space
                                                  becomes 0 too)
                             $'.2*chop            Remove last digit from
                                                  the top row, multiply by 2
                                                  and append to bottom row
                                       $&/2 .$_   Divide removed digit by
                                                  2 and prepend it to the
                                                  top row
                          $_=         |           "or" the top and bottom
                                                  row together. The ASCII
                                                  values of 0,1,2,3 have
                                                  00,01,10,11 as their last
                                                  two bits.

y;0-3; '.:                  Convert the smashed together top and bottom rows
                            to the corresponding representation characters.
                            Drop the final ; since it is provided by -p
                            (after a newline which doesn't matter here)

উপরের কোডে স্থান রূপান্তরিত হয় না। গণনাগুলির জন্য /2এবং *2এটি আচরণ করবে এবং হয়ে উঠবে 0। অন্যান্য অবস্থানগুলিতে এটি "বা" এর অংশ হবে, তবে স্থানের 1 বিট হ'ল এক বিটের একটি উপসেট এবং এটির কোনও 0প্রভাব 0সহকারে বা এডের মতো একই প্রভাব ফেলবে । কেবলমাত্র এটির চরিত্রটি বা এডের সাথে একটি স্থান থাকলে এটি একটি হয়ে ওঠার পরিবর্তে একটি স্থান থেকে যায় 0। তবে এটি ঠিক আছে যেহেতু 0যেভাবেই হোক মহাকাশে রূপান্তরিত হত।

Answer 3

রেটিনা , 66

• 2 বাইট সংরক্ষণ করেছেন @ দাভকোকে ধন্যবাদ to
• @ রেন্ডোমাকে ধন্যবাদ 4 বাইট সংরক্ষণ করা হয়েছে

:
1e
\।
1F
'
0e

0f
T`h`Rh` ^ |।। $
(।) (\ ঘ)
$ 2 $ 1
E1
:
E0
'
f0

F1
।

ব্যাখ্যা

ইনপুট দিয়ে শুরু:

: ''. :

প্রথম 4 পর্যায়ে ম্যাট্রিক্স গঠন করা ব্যবহার 1/ eসত্য এবং 0/ fমিথ্যা শীর্ষ / নীচে সারির যথাক্রমে। শীর্ষ এবং নীচের সারিগুলি একসাথে একত্রিত করা হয়। এর ফলে একটি স্ট্রিং পাওয়া যাবে:

e1f0e0e0f1f0e1

যাইহোক, এই 4 টি পর্যায়গুলি কেবলমাত্র অক্ষর এবং অঙ্কগুলির ক্রমকে বিপরীত করে নীচের সারিটি 1 টি বামে কার্যকরভাবে সরিয়ে দেয়:

1e0f0e0e1f0f1e

Tপ্রথম ও শেষ অক্ষরের জন্য ransliteration পর্যায় উল্টিয়ে হেক্স সংখ্যার শুধুমাত্র অর্থাত প্রতিস্থাপন 0-9a-fসঙ্গে f-a9-0। এটি নীচে-বাম অক্ষরটিকে উপরের সারিতে এবং উপরের-ডান অক্ষরটিকে নীচের সারিতে উপরে নিয়ে যাওয়ার প্রভাব ফেলে:

ee0f0e0e1f0f11

পরবর্তী পর্যায়ে তারপরে প্রতিটি অক্ষর-অঙ্কের জুটি অদলবদল করে, এর ফলে উপরের সারিটি 1 টি ডান দিকে সরানো হবে। পূর্বে এটি ছিল (\D)(\d)তবে এটি (.)(\d)যথেষ্ট প্রমাণিত হয়েছে কারণ প্রতিস্থাপনগুলি সর্বদা বাম থেকে ডানে ঘটে এবং তাই চূড়ান্ত দুটি সংখ্যা ভুলভাবে মিলে যায় না কারণ পেনাল্টিমেট চরিত্রটি ইতিমধ্যে প্রতিস্থাপিত হয়ে থাকবে। প্রয়োজনীয় হিসাবে ম্যাট্রিক্স এখন পুরোপুরি ঘোরানো হয়েছে:

e0e0f0e1e0f1f1

চূড়ান্ত 4 স্তরগুলি আবার মূল বিন্যাসে ফিরে অনুবাদ করুন:

'' :'..

এটি অনলাইনে চেষ্টা করুন।

সকল testcases, প্রতি লাইনে একটি , mযোগ করা Tলাইন প্রতিটি ইনপুট লাইনের পৃথক চিকিত্সা অনুমতি দেয়।

Answer 4

জেলি, 32 30 29 বাইট

,Ṛe€"“':“.:”µṪ€;"ṚU1¦ZḄị“'.: 

পেছনের স্থানটি নোট করুন। এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

পটভূমি

আমরা ইনপুট স্ট্রিং (উদাঃ :..:'.) এবং এর বিপরীতে বিবেচনা করে শুরু করি ।

:..:'.
.':..:

উপরের সারির প্রতিটি অক্ষরের জন্য, আমরা এটির কিনা এটি ':এবং নীচের সারির প্রতিটি বর্ণচিহ্নের জন্য এটি পরীক্ষা করে দেখুন .:। এটি বুলিয়ান্সের 2D অ্যারে দেয়

100110
101111

বিপরীত নীচের সারি সহ যা প্রশ্ন থেকে ম্যাট্রিক্স।

আমরা প্রতিটি সারির শেষ বুলিয়ান মুছে ফেলি, সারিগুলির ক্রমটি বিপরীত করি, বুলিয়ানগুলি তাদের মূল ক্রমে প্রেন্ডেন্ড করি এবং শেষ পর্যন্ত উপরের সারিতে বিপরীত করি।

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

এটি প্রশ্ন থেকে ঘোরানো ম্যাট্রিক্স দেয়।

অবশেষে, আমরা বুলিয়ান্সের প্রতিটি কলামকে একটি বাইনারি সংখ্যা এবং সূচি বিবেচনা করি '.: যথাযথ অক্ষরগুলি পেতে বিবেচনা করি।

332031    ::. :'

কিভাবে এটা কাজ করে

,Ṛe€"“':“.:”µṪ€;"ṚU1¦ZḄ‘ị“'.:   Main link. Argument: S (string)

 Ṛ                              Reverse S.
,                               Form a pair of S and S reversed.
     “':“.:”                    Yield ["':" ".:"].
  e€"                           For each character in S / S reversed, check if it
                                is an element of "':" / ".:".
                                Yield the corresponding 2D array of Booleans.

            µ                   Begin a new, monadic chain.
                                Argument: A (2D array of Booleans)
             Ṫ€                 Pop the last Boolean of each list.
                 Ṛ              Yield the reversed array of popped list.
               ;"               Prepend the popped items to the popped lists.
                  U1¦           Reverse the first list.
                     Z          Zip to turn top and bottom rows into pairs.
                      Ḅ         Convert each pair from base 2 to integer.
                        “'.:    Yield "'.: ".
                       ị        Retrieve the characters at the corr. indices.

Answer 5

Pyth, 38 36

L,hb_ebsXCyc2.>syCXzJ" .':"K.DR2T1KJ

2 বাইট জাকুবে ধন্যবাদ!

এখানে এটি ব্যবহার করে দেখুন বা টেস্ট স্যুটটি চালান ।

ব্যাখ্যা:

L,hb_eb         ##  Redefine the function y to take two lists
                ##  and return them but with the second one reversed
                ##  Uses W to apply a function only if it's first argument is truthy
XzJ" .':"K.DR2T ##  Does a translation from the string " .':" to
                ##  .DR2T which is [0,1,2,3...,9] mapped to divmod by 2
                ##  (which is [0,0],[0,1],[1,0],[1,1], then some extra, unused values)
                ##  we also store the string and the list for later use in J and K
.>syC ... 1     ##  zip the lists to get the bits on top and below as two separate lists
                ##  apply the function y from before, flatten and rotate right by 1
Cyc2            ##  split the list into 2 equal parts again, then apply y and zip again
sX ... KJ       ##  apply the list to string transformation from above but in reverse
                ##  then flatten into a string

Comments

দেখে মনে হচ্ছে যে আমি এটি খুব জটিল করেছিলাম ^^ আপনি কোনও ব্যাখ্যা যুক্ত করতে আপত্তি করবেন?

— ডেনকার

@ ডেনারএফএফ একটি যুক্ত করার মাঝখানে ছিল :) যুক্ত হয়েছে!

— FryAmTheEggman

আপনার মত একই পন্থা। দুটি জিনিস আমি লক্ষ্য করেছি: এই ল্যাম্বদাটি L,hb_ebএকটি বাইট সংক্ষিপ্ত এবং .DR2Tকার্টেসিয়ান পণ্য এবং আরও কয়েকটি জোড়া তৈরি করে, তবে এটি একটি সংখ্যায় এবং একটি স্থান সংরক্ষণে সহায়তা করে।

— জাকুবে

@ জাকুব ধন্যবাদ, .Dকৌশলটি দুর্দান্ত!

— FryAmTheEggman

Answer 6

পাইথন 3, 145 141 130 বাইট

def f(s):a=[i in"':"for i in s]+[i in".:"for i in s][::-1];return''.join(" '.:"[i+2*j]for i,j in zip([a[-1]]+a,a[-2:len(s)-2:-1]))

ব্যাখ্যা

গল্ফযুক্ত দ্রবণগুলি নিম্নলিখিত পিনের সম্পত্তি ব্যবহার করে: zip('ABCD', 'xy') --> Ax By তাই zip(a[:l],a[l:])দ্বারা প্রতিস্থাপন করা যেতে পারে zip(a,a[l:])এবং এটি এর সংজ্ঞাটি সরাতে দেয়l

def f(s):
 l=len(s)-1
 #                ┌───── unfold input string :  123  -> 123456
 #                │                             654
 #  ──────────────┴──────────────────────────────
 a=[i in"':"for i in s]+[i in".:"for i in s][::-1]
 # ─────────┬─────────   ────────────┬───────────
 #          │                        └──── generate the second row and reverse it
 #          └─────────── generate the first row 

 return''.join(" '.:"[i+2*j]for i,j in zip([a[-1]]+a[:l],a[l:-1][::-1]))
 #             ──────┬──────           ─┬    ────────────┬───────────
 #                   │                  │                └──── rotate and create first/second new row :  123456  -> 612345  -> 612
 #                   │                  │                                                                                      543
 #                   │                  └ group pair of the first and second row : 612 -> (6,5),(1,4),(2,3)
 #                   │                                                             543
 #                   └─────────── replace pair by symbol 

ফলাফল

>>> f(".'  '.::  :.'. . ::.'  '. . .::'  :.'.")
"' ' .:.''..'.'. ..:' ' .'. ...'''..'.'"
>>> f(".....''''''")
":...  '''':"

Comments

আপনি সেমিকোলন দ্বারা পৃথক পৃথক তিনটি রেখা এক লাইনে রেখে কয়েকটি বাইট সংরক্ষণ করতে পারেন।

— mbomb007

Answer 7

পাইথ, 66 বাইট

KlQJ.nCm@[,1Z,Z1,ZZ,1 1)%Cd5Qjkm@" .':"id2Ccs[:JKhK<JtK>JhK:JtKK)K

এখানে চেষ্টা করুন!

ব্যাখ্যা

এটি 3 ভাগে বিভক্ত করা যেতে পারে:

• ইনপুটটিকে ফ্ল্যাট অ্যারে এবং জিরোতে রূপান্তর করুন।
• আবর্তন করুন।
• এএসসিআইআইতে এটি আবার রূপান্তর করুন।

ইনপুট রূপান্তর করুন

এটি মোটামুটি তুচ্ছ। প্রতিটি চরিত্র নিম্নলিখিত উপায়ে ম্যাপ করা হয়:

  -> (0,0)
। -> (0,1)
'-> (1,0)
: -> (1,0)

প্রথমটি হল একটি সাদা জায়গা।
আমরা 2-টিউপলগুলির একটি তালিকা পেয়েছি যা আমরা ম্যাট্রিক্সের 2 সারি পাওয়ার জন্য স্থানান্তর করি যা পরে সমতল হয়।

কোড

KlQJ.nCm @ [, 1 জেড, জেড 1, জেডজেড, 1 1)% সিডি 5 কিউ # কিউ = ইনপুট

কেএলকিউ # কে-তে ম্যাট্রিক্সের প্রস্থ সংরক্ষণ করুন (পরে ব্যবহৃত হবে)
       m প্রশ্ন # প্রতিটি চরিত্রের মানচিত্র d
                        % সিডি 5 # এএসসিআইআই কোডের ডি মডিউল 5
        @ [, 1 জেড, জেড 1, জেডজেড, 1 1) # এটিকে অনুসন্ধানের তালিকায় সূচক হিসাবে ব্যবহার করুন
   জেএনসি # স্থানান্তর, সমতল এবং জেকে নিয়োগ করুন

ঘুরান

আমাদের ফ্ল্যাট অ্যারে হিসাবে ম্যাট্রিক্স এবং ম্যাট্রিক্সের Jপ্রস্থ ইন K। ঘূর্ণনটি বর্ণনা করা যেতে পারে:

J[K] + J[:K-1] + J[K+1:] + J[K-1]

কোড

s [: JKhKJhK: JtKK) # জে = ফ্ল্যাট অ্যারে, কে = ম্যাট্রিক্সের প্রস্থ

s [) # এই তালিকার সমস্ত ফলাফল কনক্যাট
  : জে কে কে কে # জে [কে]
       জেএইচকে # জে [কে + 1:]
               : জেটিকে # জে [কে -১]

এটি আবার রূপান্তর করুন

jkm @ "। ':" id2Cc [) কে # [) = উপরের পদক্ষেপের ফলাফল

              সি [) কে # 2 টি সারি বিভক্ত করুন
             সি # স্থানান্তর 2-টিপলস ফিরে পেতে
  মি # ম্যাপ প্রতিটি 2-টিপল d
          আইডি 2 # দ্বি বাইনারি হিসাবে ব্যাখ্যা এবং দশমিক রূপান্তর
   @ "। ':" # সঠিক চর পেতে সন্ধানের স্ট্রিংয়ের সূচক হিসাবে এটি ব্যবহার করুন
জে কে # একটি স্ট্রিংয়ে যোগ দিন

Answer 8

পাইথন 3, 166 154 153 150 146 138 137 135 132 127 বাইট

সম্পাদনা: আমি ব্যবহার ধার করে থাকেন zipথেকে Erwan এর পাইথন উত্তর ফাংশন শেষে। এবং তাদের [::-1]বিপরীতগুলি ব্যবহার করার ধারণা , যদিও আমি আমার নিজের টুইস্টটি রেখেছি। দেখা যাচ্ছে, আমার ফাংশনটির জন্য বিপরীতগুলি ভাল ধারণা ছিল না। আমি formatআরও গল্ফ করার জন্য আমার ব্যবহার পরিবর্তন করেছি । সরানো হয়েছে aএবং bসরাসরি মধ্যে zipআরও golfing জন্য (কারণ বিচ্ছেদ অপরিবর্তিত রয়ে ungolfing aএবং bআমার ব্যাখ্যায় গোলমাল এড়ানো মধ্যে জন্য দরকারী)

সম্পাদনা: ধার করা (some number)>>(n)&(2**something-1)থেকে গান ব্যবধান সমাধানকারী চ্যালেঞ্জ xnor দ্বারা এই উত্তর । গোলমাল হয় যে zip(*[divmod(et cetera, 2) for i in input()])সম্ভবত ভাল golfed করা যেতে পারে, যদিও আমি যুক্তিযুক্ততা এটিকে দুটি tuples ব্যবহার থেকে মঞ্জুর পছন্দ করি tএবং v।

t,v=zip(*[divmod(708>>2*(ord(i)%5)&3,2)for i in input()])
print("".join(" '.:"[i+j*2]for i,j in zip((v[0],*t),(*v[1:],t[-1]))))

Ungolfed:

def rotate_dots(s):
    # dots to 2 by len(s) matrix of 0s and 1s (but transposed)
    t = []
    v = []
    for i in s:
        m = divmod(708 >> 2*(ord(i)%5) & 3, 2)
            # ord(i)%5 of each char in . :' is in range(1,5)
            # so 708>>2 * ord & 3 puts all length-2 01-strings as a number in range(0,4)
            # e.g. ord(":") % 5 == 58 % 5 == 3
            # 708 >> 2*3 & 3 == 0b1011000100 >> 6 & 3 == 0b1011 == 11
            # divmod(11 & 3, 2) == divmod(3, 2) == (1, 1)
            # so, ":" -> (1, 1)
        t.append(m[0])
        v.append(m[1])

    # transposing the matrix and doing the rotations
    a = (v[0], *t)          # a tuple of the first char of the second row 
                            # and every char of the first row except the last char
    b = (v[1:], t[-1])      # and a tuple of every char of the second row except the first
                            # and the last char of the first row

    # matrix to dots
    z = ""
    for i, j in zip(a, b):
        z += " '.:"[i + j*2]    # since the dots are binary
                                # we take " '.:"[their binary value]
    return z

Answer 9

রুবি, 166 163 বাইট

->s{a=s.tr(f=" .':",t='0-3').chars.map{|x|sprintf('%02b',x).chars}.transpose;a[1]+=[a[0].pop];a[0]=[a[1].shift]+a[0];a.transpose.map{|x|x.join.to_i 2}.join.tr t,f}

ইয়াক ... transposeঅনেক দীর্ঘ

এখানে ব্যবহৃত কৌশলগুলি:

• sprintf('%02b',x)রূপান্তর করতে "0", "1", "2", "3"মধ্যে "00", "01", "10", এবং "11"যথাক্রমে। আশ্চর্যের বিষয় হল, দ্বিতীয় যুক্তিকে প্রথমে পূর্ণসংখ্যায় রূপান্তর করতে হবে না ।

• ঘূর্ণনটি এর মাধ্যমে করা হয় a[1].push a[0].pop;a[0].unshift a[1].shift;, যা আমি ভেবেছিলাম কমপক্ষে একটু চালাক (যদি রুবিতে অতিরিক্ত ভার্বোস না হয়)। প্রতিসাম্যটি নান্দনিকভাবে সুন্দর, যাইহোক: পি

Comments

আমি কি একটু গল্ফ দেওয়ার পরামর্শ দিতে পারি? ->s{a=s.tr(f=" .':",'001').chars;b=s.tr(f,'0101').chars;b<<a.pop;([b.shift]+a).zip(b).map{|x|x.join.to_i 2}.join.tr'0-3',f}

— manatwork

অবশেষে its এর প্রভাব তৈরি করে। সারা সকাল এই জন্য সন্ধান .map{|x|x.join.to_i 2}.join.tr'0-3',f.map{|x|f[x.join.to_i 2]}*''

— করছিল

Answer 10

জাভাস্ক্রিপ্ট ES6 125 বাইট

q=>(n=[...q].map(a=>(S=` .':`).indexOf(a))).map((a,i)=>(i?n[i-1]&2:n[0]&1&&2)|((I=n[i+1])>-1?I&1:n[i]&2&&1)).map(a=>S[a]).join``

---

আমি প্রতিটি অক্ষরকে দুটি অঙ্কের বাইনারি সমতুল্য মানচিত্র করি

 : becomes 3   11
 ' becomes 2   10
 . becomes 1   01
   becomes 0   00

এবং আমি তাদের একে অপরের উপরে হিসাবে ভাবছি

3212021 becomes
1101010
1010001

আমি এন এ সেভ করি

এন এর প্রতিটি চরিত্রের জন্য (০-৩) আমি প্রতিবেশী যাচাই করি এবং বাম প্রতিবেশীর সর্বাধিক অর্ডার বিটকে ডান প্রতিবেশীর সর্বনিম্ন অর্ডার বিটে যুক্ত করি। যদি i == 0 (প্রথম চরিত্র) আমি বাম প্রতিবেশীর উচ্চতর অর্ডার বিটের পরিবর্তে এটির নিজস্ব নিম্ন অর্ডার বিট ব্যবহার করি।

যদি এন [i + 1]> - 1 এর অর্থ আমরা 0,1,2,3 পেয়েছি তাই যখন এটি মিথ্যা হয় আমরা শেষ উপাদানটিকে আঘাত করি।

যখন এটি হয় আমি ডান প্রতিবেশীর নীচের বিটের পরিবর্তে চরিত্রটির নিজস্ব সর্বোচ্চ অর্ডার বিটটি ব্যবহার করি

মানচিত্র যে ফিরে .':অবতরণ এবং ফিরে অ্যারে একসাথে যোগদান

Answer 11

এমএটিএল , 40 39 বাইট

' ''.:'tjw4#mqBGnXKq:QKEh1Kq:K+hv!)XBQ)

এটি অনলাইন চেষ্টা করুন! এই উত্তর পোস্ট হওয়ার পরে ভাষায় পরিবর্তিত হওয়ার কারণে লিঙ্কিত সংস্করণটি আবার vগতিবেগ &vকরেছে ।

' ''.:'               % pattern string. Will indexed into, twice: first for reading 
                      % the input and then for generating the ouput
t                     % duplicate this string
j                     % input string
w                     % swap
4#m                   % index of ocurrences of input chars in the pattern string
qB                    % subtract 1 and convert to binay. Gives 2-row logical array
GnXKq:QKEh1Kq:K+hv!   % (painfully) build two-column index for rotation
)                     % index into logical array to perform the rotation
XBQ                   % transform each row into 1, 2, 3 or 4
)                     % index into patter string. Implicitly display

Answer 12

জাভাস্ক্রিপ্ট, 311 বাইট

সম্ভবত অনেক উন্নতি করা যেতে পারে:

a=(s=prompt()).length-1;o=s[0]==":"||s[0]=="."?s[1]==":"||s[1]=="."?":":"'":s[1]==":"||s[1]=="."?".":" ";for(i=1;i<a;i++)o+=s[i-1]=="'"||s[i-1]==":"?s[i+1]=="."||s[i+1]==":"?":":"'":s[i+1]=="."||s[i+1]==":"?".":" ";alert(o+=s[a]==":"||s[a]=="'"?s[a-1]==":"||s[a-1]=="'"?":":"'":s[a-1]==":"||s[a-1]=="'"?".":" ")

Comments

কিছু সেট করতে পারে s[i-1]? এটি কিছু বাইট সংরক্ষণ করতে পারে।

— আর

একই সাথে s[i+1]।

— আর

ES6 তীর ফাংশন এবং একটি অনুসন্ধান ব্যবহার করে চেষ্টা করুন, এর <পরিবর্তে ব্যবহার করে ==আপনাকে বেশ কয়েকটি বাইট সংরক্ষণ করতে পারে। এছাড়াও আপনি চেকআউট করতে পারেন জাতীয় মধ্যে golfing জন্য টিপস এবং ES6 মধ্যে golfing জন্য টিপস

— Downgoat

@Downgoat কিভাবে আপনি ব্যবহার করতে পারেন <পরিবর্তে==

— জেনস উপস্থাপন করে

Answer 13

জাভাস্ক্রিপ্ট (ES6), 237 210 204 188 182 178 বাইট

188-বাইট পুনর্বিবেচনায় 16 বাইট সংরক্ষণ করার জন্য @ ডাউনগোটকে ক্রেডিট

আপডেট: আমার একটি ব্রেইনওয়েভ ছিল এবং প্রথম অপারেশনটি দুটি পৃথকের পরিবর্তে sএকক mapকলে হ্রাস পেয়েছে

s=>(r=" .':",a=[],s=[...s].map(c=>(t=('00'+r.indexOf(c).toString(2)).slice(-2),a.push(t[0]),t[1])),a.splice(0,0,s.shift()),s.push(a.pop()),a.map((v,i)=>r[+('0b'+v+s[i])]).join``)

বেশিরভাগ মুদ্রণ ও ব্যাখ্যা

s => (
  r = " .':", // Map of characters to their (numerical) binary representations (e.g. r[0b10] = "'")
  a = [],     // extra array needed
  // Spread `s` into an array
  s = [...s].map(c => (
    // Map each character to a `0`-padded string representation of a binary number, storing in `t`
    t = ('00' + r.indexOf(c).toString(2)).slice(-2)),
    // Put the first character of `t` into `a`
    a.push(t[0]),
    // Keep the second character for `s`
    t[1]
  )),
  // Put the first character of `s` in the first index of `a`
  a.splice(0,0,s.shift()),
  // Append the last character of `a` to `s`
  s.push(a.pop(),
  // Rejoin the characters, alternating from `a` to `s`, representing the rotated matrix, and map them back to their string representation
  // Use implicit conversion of a binary number string using +'0b<num>'
  a.map((v,i) => r[+('0b' + v + s[i])]).join``
)

Comments

না: s=>(r=" .':",a=[],s=[...s].map(c=>('00'+r.indexOf(c).toString(2)).slice(-2)).map(n=>(a.push(n[0]),n[1]),a.splice(0,0,s.shift()),s.push(a.pop()),a.map((v,i)=>r[parseInt(v+s[i],2)]).join``)কাজ?

— ডাউনগোট

এর আগে জবাব না দেওয়ার জন্য দুঃখিত, বিজ্ঞপ্তিটি দেখেনি - আমার বিকাশকারী সরঞ্জামগুলি আমাকে "অবৈধ চরিত্র" ব্যতিক্রম

— দিচ্ছে

আপনি এটি যেমন রেখেছিলেন তেমন কাজ করতে পেরেছেন - স্পষ্টতই যখন আমি এটি অনুলিপি করেছি তখন এতে কিছু অতিরিক্ত অদৃশ্য অক্ষর ছিল যা ব্রাউজার বিকাশকারী সরঞ্জামগুলিতে প্রদর্শিত হয়নি।

— রেভানপ্রডিজালকাইট

Answer 14

পার্ল, 144 142 137 131 বাইট

y/.':/1-3/;s/./sprintf'%02b ',$&/ge;@a=/\b\d/g;@b=(/\d\b/g,pop@a);@a=(shift@b,@a);say map{substr" .':",oct"0b$a[$_]$b[$_]",1}0..@a

-nপতাকার জন্য বাইট যুক্ত করা হয়েছে ।

আমার রুবি উত্তর হিসাবে খুব একই একই অ্যালগোরিদম , শুধু খাটো, কারণ ... পার্ল।

y/.':/1-3/;                         # transliterate [ .':] to [0123]
s/./sprintf'%02b ',$&/ge;           # convert each digit to 2-digit binary
@a=/\b\d/g;                         # grab the 1st digit of each pair
@b=(/\d\b/g,                        # 2nd digit of each pair
pop@a);                             # push the last element of a to b
@a=(shift@b,@a);                    # unshift the first element of b to a
say                                 # output...
map{                                # map over indices of a/b
substr" .':",oct"0b$a[$_]$b[$_]",1  # convert back from binary, find right char
}0..@a                              # @a is length of a

দু: খজনকভাবে, এর @a=(shift@b,@a)চেয়ে খাটো unshift@a,shift@b।

হায়, এগুলি একই দৈর্ঘ্য:

y/ .':/0-3/;s/./sprintf'%02b ',$&/ge;
s/./sprintf'%02b ',index" .':",$&/ge;

টন হসপেলকে 5 বাইট এবং এমএস 210 বাইটের জন্য ধন্যবাদ !

Comments

আপনি কি ..@aপরিবর্তে ব্যবহার করতে পারেন ..$#a? (সম্ভবত octমারা যায় বা 0 বা কিছু ফেরত দেয় I আমি এটি চেষ্টা করি নি

— have

স্থান 0 এ রূপান্তর করার দরকার নেই এটি যাইহোক স্প্রিন্টফের জন্য 0 হিসাবে মূল্যায়ন করবে। রেগেক্সে প্রথম বন্ধনী থেকে মুক্তি পান। কোনও ক্যাপচার না থাকলে পুরো ম্যাচটি একটি//g

— টন হসপেল

@ msh210 এটি কার্যকরভাবে কাজ করে; ধন্যবাদ!

— ডুরকনব

@ টনহোস্পেল ধন্যবাদ, তাদের উত্তরে তাদের অন্তর্ভুক্ত করা হয়েছে (যদিও স্পষ্টতই আপনার এখনও পানির বাইরে আমার পুরোপুরি ফুঁসে উঠেছে)।

— ডুরকনব

এটা sprintfখুব দীর্ঘ। map$_%2,/./gএবং map$_/2|0,//gপ্রায় খাটো হতে হবে (

— স্বাক্ষরিত

Answer 15

পাইথন 3, 294 287 283 বাইট

ওয়ায়াyyইয়্যি অনেক দীর্ঘ, তবে আমি কিছু বাইট গল্ফ দেওয়ার চেষ্টা করব:

z=input()
x=len(z)
M=[0,1,2,3]
for Q in M:z=z.replace(":'. "[Q],"11100100"[Q*2:Q*2+2])
a=[]
b=[]
for X in range(x):a+=[z[X*2]];b+=[z[X*2+1]]
b=b[1:]+[a.pop()]
c=[b[0]]+a
z=""
for X in range(len(c)):
 y=c[X]+b[X]
 for Q in M:y=y.replace("11100100"[Q*2:Q*2+2],":'. "[Q])
 z+=y
print(z)

Answer 16

লুয়া, 139 বাইট

print(((...):gsub(".",{[" "]="NN@",["."]="YN@",["'"]="NY@",[":"]="YY@"}):gsub("(.)@(.?)","%2%1"):gsub("..",{NN=" ",NY=".",YN="'",YY=":"})))

ব্যবহার:

$ lua conveyor.lua ".'  '.::  :.'. . ::.'  '. . .::'  :.'."
' ' .:.''..'.'. ..:' ' .'. ...'''..'.'