50

শিফটি চোখের ASCII ছেলেরা ASCII Iiএর স্থানান্তর করতে পছন্দ করে :

>_> <_< >_< <_>

শিফটি-গাইজের একটি স্ট্রিং দেওয়া হয়েছে, আলাদা করা বা পৃথক রেখাগুলি দেওয়া উচিত, Iiএর পাশের পাশ থেকে পাশের দিকে, পাশের দেয়ালটি এবং ডাকা আকাশকে:

Ii

স্বল্পতম শিফটার পুরস্কার জিতেছে।

বল কি?

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা এই চারটি ASCII ইমোটিকনগুলির একটি স্বেচ্ছাসেবী তালিকার একটি স্ট্রিং গ্রহণ করে, স্থান বা নিউলাইন পৃথক করা (optionচ্ছিক ট্রেলিং নিউলাইন সহ):

>_>
<_<
>_<
<_>

উদাহরণস্বরূপ, ইনপুট হতে পারে
>_> >_> <_>
অথবা
>_>
>_>
<_>
(আপনি যে পদ্ধতিটি সমর্থন করেন তা আপনার উপর নির্ভর করে))

প্রতিটি ইমোটিকন Iএবং iচরিত্রগুলিতে আলাদা ক্রিয়া সম্পাদন করে , যা সর্বদা এই জাতীয়ভাবে শুরু হয়:

Ii

>_>বদল I, একের পর ডানদিকে সম্ভব হলে, এবং তারপর বদল iএকের পর ডানদিকে।
<_<বদল Iএকের পর ছেড়ে যদি সম্ভব, এবং তারপর বদল করার i, এক দ্বারা বামে যদি সম্ভব।
>_<Iসম্ভব হলে একের পর এক ডানে স্থানান্তরিত করুন , এবং তারপরে সম্ভব iহলে বামে স্থানান্তরিত করুন ।
<_>বদল আনতে Iএকের পর ছেড়ে যদি সম্ভব, এবং তারপর বদল iএকের পর ডানদিকে।

Iএটি লাইনের বাম প্রান্তে থাকলে বাঁ দিকে স্থানান্তরিত করা যায় না (যেমন এটি প্রথমদিকে) এবং iসরাসরি ডানদিকে সরানো যায় না (যেমন এটি প্রথমদিকে) cannot

iবাম স্থানান্তরিত করা যাবে না যদি Iতার বামে সরাসরি (এটা প্রাথমিকভাবে হিসাবে), কিন্তু সবসময় সঠিক স্থানান্তরিত করা যেতে পারে।

মনে রাখবেন যে এই বিধিগুলি সহ, Iসর্বদা বাম দিকে থাকবে iএবং সমস্ত ইমোটিকনের জন্য Iস্থানান্তরিত করার চেষ্টা করা হবে i।

আপনার প্রোগ্রাম বা ফাংশনটি Iiফাঁকা স্থান ( ) বা পিরিয়ড ( .) ব্যবহার করে প্রদত্ত ক্রমে সমস্ত শিফট প্রয়োগের পরে চূড়ান্ত রেখার একটি স্ট্রিং মুদ্রণ বা ফিরতে হবে । ট্রেলিং স্পেস বা পিরিয়ড এবং একটি একক ট্রেলিং নতুন লাইনটি আউটপুটে allyচ্ছিকভাবে অনুমোদিত। স্পেস এবং পিরিয়ডগুলি মিশ্রিত করবেন না।

উদাহরণস্বরূপ, ইনপুট
>_>
>_>
<_>
আউটপুট আছে
I...i
কারণ শিফ্টগুলির মতো প্রয়োগ হয়
start  |Ii
>_>    |I.i 
>_>    |.I.i
<_>    |I...i

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। টাইব্রেকার বেশি ভোট দেওয়া উত্তর।

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

#[id number]
[space separated input]
[output]

.স্বচ্ছতার জন্য ব্যবহার করা।

#0
[empty string]
Ii

#1
>_>
I.i

#2
<_<
Ii

#3
>_<
Ii

#4
<_>
I.i

#5
>_> >_>
.I.i

#6
>_> <_<
Ii

#7
>_> >_<
.Ii

#8
>_> <_>
I..i

#9
<_< >_>
I.i

#10
<_< <_<
Ii

#11
<_< >_<
Ii

#12
<_< <_>
I.i

#13
>_< >_>
I.i

#14
>_< <_<
Ii

#15
>_< >_<
Ii

#16
>_< <_>
I.i

#17
<_> >_>
.I.i

#18
<_> <_<
Ii

#19
<_> >_<
.Ii

#20
<_> <_>
I..i

#21
>_> >_> <_>
I...i

#22
<_> >_> >_> >_> <_> <_<
.I...i

#23
<_> >_> >_> >_> <_> <_< >_< <_< >_<
..Ii

#24
>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<
...I.....i

code-golf string ascii-art

— ক্যালভিনের শখ
সূত্র

সুতরাং বিন্দুগুলি alচ্ছিক, স্থানগুলি পরিবর্তে সেখানে থাকতে পারে?

— Rɪᴋᴇʀ

আউটপুটে ট্রেলিং স্পেসগুলি কি অনুমোদিত?

— mbomb007

প্রতিটি লাইনে প্রতিটি শিফ্ট লোকের সাথে ইনপুটটি কি 2D চর অ্যারে হতে পারে?

— লুইস মেন্ডো

2

@ রিকারডাব্লু - হ্যাঁ এমবিম্ব - হ্যাঁ, এটি উল্লেখ করা হয়েছে ডন - না

— ক্যালভিনের

15

শিফ্টি আইজগুলি একটি অনিচ্ছাকৃত ভাষা হয়ে উঠুন দেখুন ...

— বিড়াল

3

সিজেম, 33 বাইট

0Xq2%{'=-_3$+[2$W]-,*@+}/S*'i+'It

0-ইনডেক্সিং ব্যতীত আমার পাইথন উত্তরের মতো একই অ্যালগরিদম ব্যবহার করে । মূলত:

কেবল ইনপুটটিতে তীরগুলি দেখুন, <-1 এবং >1 তে রূপান্তর করুন
কেবলমাত্র একটি আপডেট প্রয়োগ করুন যদি তা আমাদের অবস্থান -1 এ স্থানান্তর না করে এবং অন্যান্য চরের অবস্থানে না নিয়ে যায়
যেহেতু তীরগুলি প্রয়োগ Iএবং প্রয়োগের মধ্যে বিকল্প হয় i, তাই প্রতিটি তীরের পরে আমরা কোন অবস্থানটি আপডেট করব tern

আউটপুট স্টেপটি গল্ফ করার জন্য, 5 বাইট ছাড়িয়ে যাওয়ার জন্য @ মার্টিনব্যাটনারকে ধন্যবাদ।

অনলাইনে চেষ্টা করে দেখুন | পরীক্ষা স্যুট

0X                 Initialise the two positions a = 0, b = 1
q2%                Read input and take every second char, leaving just the arrows

{ ... }/           For each arrow in the input...
  '=-              Subtract '=, leaving -1 for '< and 1 for '>
  _3$+             Duplicate and add a. Stack looks like [a b diff a+diff]
  [2$W]-           Perform setwise subtraction, [a+diff] - [b -1]
                   The result is empty list if a+diff is either b or -1, else [a+diff]
  ,                Length, yielding 0 or 1 respectively
                   0 means we don't want to update the char, 1 means we do
  *                Multiply diff by this result
  @+               Add to a. Stack now looks like [b a'] where a' is a updated

                   After the above loop, the stack ends with [(I position) (i position)]

S*                 Create (i position) many spaces
'i+                Stick an 'i at the end - this is the right place due to 0-indexing
'It                Set (I position) to 'I

— Sp3000
সূত্র

21

পার্ল, 59 56 54 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

STDIN এ ইনপুট দিয়ে চালান, যেমন perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

s%^|<|(>)%y/iI/Ii/or$_=Ii;$1?s/i |i$/ i/:s/ i/i /%reg

ব্যাখ্যা

কন্ট্রোল স্ট্রিং বিকল্পসমূহ নির্দেশাবলী iএবং Iএবং নিয়ম তাদের উভয়ের যদি আপনি তাদের যেমন প্রণয়ন জন্য একই:

< বামদিকে কোনও স্থান থাকলে বাম দিকে সরান
> ডানদিকে কোনও স্থান বা স্ট্রিংয়ের শেষ থাকলে ডানদিকে সরান

সুতরাং আমি অদলবদল করতে যাচ্ছি iএবং Iপ্রতিটি পদক্ষেপে লক্ষ্য স্ট্রিং যাতে আমি কেবল একটি অক্ষরে নিয়ম প্রয়োগ করা প্রয়োজন। এইy/iI/Ii/

আমি কন্ট্রোল স্ট্রিংটি প্রতিস্থাপনের সন্ধান <এবং >ব্যবহার করে চলব যা চরিত্র অনুসারে কোনও চরিত্র প্রক্রিয়া করার জন্য পার্লের মধ্যে সবচেয়ে সংক্ষিপ্ততম উপায়। লিখতে না এড়াতে $var =~আমি পার্ল ডিফল্ট ভেরিয়েবলের নিয়ন্ত্রণ স্ট্রিং চাই $_। এবং আমি আলাদা একটি সহজ উপায় চান <থেকে >। এই সমস্ত ব্যবহার করে সম্পন্ন করা যেতে পারে

s%<|(>)%  code using $1 to distinguish < from > %eg

লক্ষ্যযুক্ত স্ট্রিং আমি বিকল্পগুলি ব্যবহার করেও হেরফের করতে চাই এবং একই কারণে আমি $_এটিও চাই। $_একবারে দুটি জিনিস হওয়া অসম্ভব বলে মনে হয়।

তবে আমি আমার কেক রাখতে পারি এবং এটিও খেতে পারি কারণ $_একটি প্রতিস্থাপনের শরীরের অভ্যন্তরটি বিকল্প হিসাবে থাকার মতো থাকে না $_। পার্ল একবার স্ট্রিং প্রতিস্থাপন করা শুরু করলে এই স্ট্রিংটি পরিবর্তিত হবে না এমনকি আপনি পরিবর্তনশীল পরিবর্তন করলেও আসল স্ট্রিংটি এসেছে। সুতরাং আপনি যেমন কিছু করতে পারেন:

s%<|(>)% change $_ here without disturbing the running substitution %eg

আমি মূল প্রতিস্থাপন করতে চান $_প্রাথমিক দ্বারা "Ii"(নইলে লক্ষ্য স্ট্রিং রিসেট রাখুন) শুধুমাত্র খুব প্রথমবার প্রতিকল্পন শরীর মৃত্যুদন্ড কার্যকর হয়। এই প্রতিস্থাপনটি খালি নিয়ন্ত্রণ স্ট্রিংয়ের জন্যও ঘটতে হবে, তাই খালি নিয়ন্ত্রণের স্ট্রিংয়ের জন্যও কমপক্ষে একবার শরীর সম্পাদন করা দরকার। নিয়ন্ত্রণ স্ট্রিংয়ের শুরুতে বিকল্পটি অতিরিক্ত সময় চলে কিনা তা নিশ্চিত করার জন্য (খালি নিয়ন্ত্রণের স্ট্রিংয়ের জন্যও) আমি প্রতিস্থাপনটি এখানে পরিবর্তন করি:

s%^|<|(>)% change $_ here without disturbing the running substitution %eg

আমি y/iI/Ii/প্রতিস্থাপন কোডের ভিতরে প্রথম জিনিস হিসাবে চালাব । যখন $_এখনও নিয়ন্ত্রণের স্ট্রিং রয়েছে Iiএটিতে এখনও কোনওটি থাকবে না , সুতরাং যদি লিখিত লিপি লিখিত রূপান্তরিত করে তবে কিছুই পরিবর্তিত হয়নি যা আমার ট্রিগার সূচনা $_:

y/iI/Ii/or$_=Ii

এখন আমি চিঠিগুলির প্রকৃত চলন বাস্তবায়ন করতে পারি। যেহেতু আমি অদলবদল দিয়ে শুরু করি সমস্ত পদক্ষেপগুলি চালু করা উচিত i, না I। যদি ডানদিকে $1সরানো iহয়:

s/i |i$/ i/

যদি $1সেট না করা iহয় তবে বাম দিকে সরান

s/ i/i /

লক্ষ্য করুন যে কন্ট্রোল স্ট্রিংয়ের শুরুতে যখন আমি মেলে ^ $1সেট করা হবে না, তাই এটি iপ্রাথমিক স্ট্রিংয়ের বাম দিকে যেতে চেষ্টা করে Ii। এটি কাজ করবে না কারণ সেখানে কোনও জায়গা নেই, সুতরাং অন্তর্নির্মিত স্ট্রিংটি নিরবচ্ছিন্ন থাকে (এ কারণেই আমি এর পরিবর্তে ()চারপাশে রাখি )><

কেবলমাত্র একটি সমস্যা রয়ে গেছে: প্রতিস্থাপনের দেহের অভ্যন্তরে $_আপনি যা করেছিলেন তা নির্বিশেষে বাহ্যিক প্রতিস্থাপনের শেষে বাহ্যিক প্রতিস্থাপনের ফলাফল নির্ধারণ করা হয় $_। তাই যথাযথ বসানো সঙ্গে লক্ষ্য স্ট্রিং iএবং Iহারিয়ে যায়। পুরানো পার্লগুলিতে এটি মারাত্মক ত্রুটি হবে। আরও সাম্প্রতিক পার্লগুলির rমডিফায়ার রয়েছে যার অর্থ "মূল স্ট্রিংয়ের একটি অনুলিপি তৈরি করুন, তার পরিবর্তে আপনার প্রতিস্থাপন করুন এবং ফলস্বরূপ স্ট্রিংটি (ম্যাচের সংখ্যার পরিবর্তে) ফিরিয়ে দিন"। আমি যখন এটি এখানে ব্যবহার করি ফলাফলটি হ'ল পরিবর্তিত কমান্ড স্ট্রিংটি বাতিল হয়ে যায় যখন আসলটি $_পার্ল দ্বারা বিরক্ত হয় না এবং প্রতিস্থাপনের পরে বাম হয়। তবে ধকল আমি একবার করেন $_এখনও সম্পন্ন করা হয় পরে Perl বাম $_একা। তাই শেষে$_ সঠিক লক্ষ্য স্ট্রিং হবে।

-pবিকল্প নিশ্চিত মূল স্ট্রিং করে তোলে $_এবং চূড়ান্ত ছাপে $_।

— টন হসপেল
সূত্র

1

প্রাথমিক স্ট্রিং হয় Ii, না iI।

— user48538

2

@ জাইবিন ১০১১ অতিরিক্ত ^ম্যাচের মানে আমাকে সেগুলি অদলবদল করতে হবে। সুতরাং বিপরীত সূচনাটি সঠিক।

— টন হসপেল

10

লিটললুয়া - 178 বাইট

r()l=sw(I)o=1 D='.'f q=1,#l do i l[q]:s(1,1)=='>'t i z+1~=o t z=z+1 e else i z-1>0 t z=z-1 e e i l[q]:s(3)=='>'t o=o+1 else i o-1~=z t o=o-1 e e e p(D:r(z).."I"..D:r(o-z-1)..'i')

সরাসরি এগিয়ে বাস্তবায়ন।

Ungolfed:

r()                             --call for input
l=sw(I)                         --Split input by spaces
o=1                             --Hold i position (z holds I position)
D='.'                           --Redundant character
f q=1,#l do                     --Foreach table entry
    i l[q]:s(1,1)=='>' t        --If the first eye points right
        i z+1~=o t z=z+1 e      --Verify no collision and move the I
    else
        i z-1>0 t z=z-1 e       --If it points left.. .same...
    e                           --yatta yatta...
    i l[q]:s(3)=='>' t
        o=o+1
    else
        i o-1~=z t o=o-1 e
    e
e
p(D:r(z).."I"..D:r(o-z-1)..'i')--String repeats to print correct characters.

লিটললুয়া কী?

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

লিটললুয়া একটি অতিরিক্ত মডিউল (লিটললুয়া.লুয়া) সহ একটি লুয়া 5.3.6 দোভাষী, পাশাপাশি ফাংশন এবং মডিউল নামগুলি সঙ্কুচিত। এই পরিবর্তনগুলি পরের দু'এক দিনের মধ্যে প্রসারিত হবে, যতক্ষণ না আমি খুশি, তবে এটি লিটললুয়া এবং স্ট্যান্ডার্ড লুয়া ইন্টারপ্রেটারের মধ্যে বেশ কয়েকটি বৃহত্তম পরিবর্তনগুলি হ'ল:

ফাংশন এবং মডিউলগুলি সঙ্কুচিত:

io.read() -> r() (Value stored in built in variable "I")
string -> s
string.sub -> s.s or stringvalue:s
etc.

পরিবর্তনশীল মধ্যে নির্মিত

কিছু কাজ সঙ্কুচিত করতে লিটললুয়ায় বেশ কয়েকটি ভেরিয়েবল রয়েছে:

z=0
o=10
h1="Hello, World!"
h2="Hello, World"
h3="hello, world"
h4=hello, world!"
etc.

ফাংশনে নির্মিত

বর্তমানে একটি হতাশাজনকভাবে ছোট তালিকা, তবে এটি এখানে:

d(N) -> Prints NxN identity matrix
sw(str) -> Splits string at spaces and returns table of results
sc(str) -> Splits string at commas and returns table of results
sd(str) -> Removes white space from a string (not including tabs)
ss(str,n) -> Swap N characters from beginning and end of string
sr(str,n) -> Swap N characters from beginning and end of string retaining order
sd(str) -> Split string into array of characters
co(ta) -> Concatenate table with no delimiter
co(ta, delim) -> Concatenate table with delimiter: delim

— Skyl3r
সূত্র

তাহলে এটি কি লুয়া গল্ফিং ল্যাং?

— ডাউনগোট

3

হ্যাঁ! স্পষ্টতই (আমি আশা করি) একটি কাজ চলছে। আমি অনুভব করেছি যে আমি অন্যান্য ভাষার সাথে ইনপুট নিতে, এটি বাছাই করতে, ছাঁটাতে, এটি বিভক্ত করতে এবং স্পষ্টভাবে কয়েকটি অক্ষর দিয়ে ফিরিয়ে দিতে সক্ষম হওয়ায় আমি কিছুটা অসুবিধায় পড়েছি, সুতরাং লুয়ার উত্স পেয়েছি এবং আমি হ্যাক করছি কিছুটা দূরে এই চ্যালেঞ্জটি শুরুর আগে এই নির্দিষ্ট সংস্করণটি শেষ হয়েছিল, এটি দুর্ভাগ্যজনক। তারা যা বলে তা আপনি জানেন, আপনার প্রয়োজনের পরেই অভিজ্ঞতাটি পাবেন।

— Skyl3r

বোকা প্রশ্ন - নিন বা বলুন $এবং ব্যবহার করুন endবা e- অ- A-Za-zশব্দ অক্ষরের জায়গায় তাদের চারপাশের ফাঁকের প্রয়োজন নেই, তাই না? প্রতি একটি বাইট শেভ চাই end/e

— বিড়াল

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

— স্কাইল

1

আপনি golfed ifকরতে iব্যবহার প্রতি এক বাইট সংরক্ষণ, এবং endথেকে eদুই সংরক্ষণ, কিন্তু আপনাকে ছেড়ে গেছে elseএকা? এমনকি এই সাধারণ প্রোগ্রামে (5 ifটি এবং 2 elseটি), আপনি নিজের elseচেয়ে বেশি বাইট নষ্ট করছেন if। (আমি ধরে নিচ্ছি যে এটি একটি পরিকল্পিত উন্নতি?)

— ড্যারেল হফম্যান

8

রেটিনা ,101 86

$
¶Ii
(`^¶

s`^>(.*)I( )?
$1$2I
s`^<(.*?)( )?I
$1I$2
s`^_>(.*)i
$1 i
s`^_<(.*?) ?i
$1i

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

দাভকোকে ধন্যবাদ 15 বাইট!

নিউলাইনগুলি এবং স্পেস দ্বারা পৃথক করে চোখের আউটপুট দ্বারা পৃথক করে ইনপুট নেয়।

ব্যাখ্যা:

আমি যথারীতি পর্যায়ক্রমে মঞ্চটি ব্যাখ্যা করব। এই সমস্ত পর্যায় রেটিনার প্রতিস্থাপন মোডে রয়েছে। তার মানে প্রথম লাইনটি নিয়মিত প্রকাশ এবং দ্বিতীয় লাইনটি প্রতিস্থাপনের স্ট্রিং।

$
¶Ii

ইনপুটটির Iiশেষে প্রাথমিকটি যুক্ত করুন।

( `^ ¶

ব্যাকটিক বিকল্পগুলি থেকে মঞ্চ পৃথক করে। বিকল্পের চরিত্রটি (নির্দেশ করে যে ইনপুট পরিবর্তন না করে পুরো চক্রটি সম্পন্ন না হওয়া পর্যন্ত এই পর্যায়টি বারবার সম্পাদিত হওয়া পর্যায়ের লুপের শুরু। যেহেতু এই উন্মুক্ত বন্ধনী কখনই বন্ধ হয় না, তাই সমস্ত অবশিষ্ট পর্বগুলি এই লুপের একটি অংশ।

আসল পর্যায়টি খুব সহজ, যদি স্ট্রিংয়ের প্রথম অক্ষরটি একটি নতুন লাইন হয় তবে এটি মুছুন। এটি খালি ইনপুটটি পরিচালনা করা সহজতর করতে সহায়তা করার জন্য, অন্যথায় এটি শেষ দুটি পর্যায়ে যুক্ত করা গল্ফিয়ের হতে চাই।

s`^>(.*)I( )?
$1$2I

এখানে বিকল্পটি sরেগেক্স মেটাচার্যাক্টারের .সাথে নতুন লাইনের সাথে মেলে। এই পর্যায়ে একটি >match Iচ্ছিক স্থান অনুসরণ করে তারপরে একটি শীর্ষস্থানটি মিলে যায় । তারপরে এটি সেই ম্যাচের পরিবর্তে after >চ্ছিক স্থানের পরে স্টাফগুলির সাথে প্রতিস্থাপিত করে (তাই ফাঁকা স্ট্রিংটি যদি স্থানটি মিলে না যায়) এবং তারপরে I।

s`^<(.*?)( )?I
$1I$2

এই স্তরটি পূর্বেরটির মতোই একই রকম, কেবলমাত্র optionচ্ছিক স্থানটি এর আগে Iএবং ক্রম এবং চোখ বিপরীত হয়।

s`^_>(.*)i
$1 i

হ্যান্ডলিংটি iআসলে প্রায়শই সহজ, কারণ আমাদের iসর্বদা ডান স্থানান্তর করতে পারে এমন হিসাবে optionচ্ছিকভাবে যোগ করা বা অপসারণের বিষয়ে আমাদের চিন্তা করার দরকার নেই। কেসগুলির জন্য iআমরা আন্ডারস্কোরের পাশাপাশি চিহ্নের চেয়ে বৃহত্তর / কমের সাথে মিলে যাই, তবে অন্যথায় অনুরূপ যুক্তি করি। এই এক আগে একটি স্থান যোগ করুন i।

s`^_<(.*?) ?i
$1i

উপরের মত আবার, তবে চরিত্রটি iযদি স্থানটি হয় তবে এটি অক্ষরটিকে মুছে ফেলে অন্যথায় এটি কেবল ইমোটিকনটিকে সরিয়ে দেয়।

— FryAmTheEggman
সূত্র

আপনি এটি s`^_>(.*)i( |$)?= :>> s`^_>(.*)iএবং এর প্রতিস্থাপন $1$#2$* i=> $1 iএবং s`^_<(.*?)( )?i=> s`^_<(.*?) ?iএবং এর প্রতিস্থাপন $1i$2=> দিয়ে 86 এ নামতে পারেন $1i।

— দাভকো

@ mbomb007 হ্যাঁ, আমি এটি 24 টি ইনপুট পরীক্ষা করেছি। কোনও ত্রুটি পাওয়া যায় নি।

— দাভকো

@ দাভকো ধন্যবাদ! আমি জানতাম যখন আমি দুটি মামলার মধ্যে অনুলিপি করছিলাম তখন থেকে আমার কাছে কিছু জিনিস পড়ে ছিল তবে পোস্ট করার পরে আমাকে কম্পিউটার ছেড়ে যেতে হবে। সম্পাদিত :)

— FryAmTheEggman

7

পাইথন, 142 141 134 122 121 বাইট

Xnor ধন্যবাদ 19 বাইট সংরক্ষণ করা।

def f(l,I=0,i=1):
    for a,_,b in l.split():I-=[I>0,-(i!=I+1)][a>'='];i-=[i!=I+1,-1][b>'=']
    return'.'*I+'I'+'.'*(i+~I)+'i'

উদাহরণ:

>>> assert f('<_> >_> >_> >_> <_> <_<') == '.I...i'
>>>

ব্যাখ্যা:

def f(l, I=0, i=1):
    for a, _, b in l.split():
        I-= -(i!=I+1) if a == '>' else I > 0
        i-= -1 if b == '>' else i!=I+1

    return '.'*I + 'I' + '.'*(i-I-1) + 'i'

— vaultah
সূত্র

পেস্ট থেকে আপনার বাইট গণনাটি 148 - দেখে মনে হচ্ছে আপনি উত্তরের অতিরিক্ত স্থান সহ কোডটি পেস্ট করেছেন।

— সেলো

@ সেলিও: ফাংশন বডিটির প্রতিটি লাইন 1 টি ট্যাব অক্ষরের সাথে যুক্ত হয়। আপনি "সম্পাদনা" ক্লিক করে যাচাই করতে পারেন। তবে এসই 4 টি স্পেস দ্বারা প্রতিস্থাপিত ট্যাবগুলির সাথে কোড সরবরাহ করে। যদিও 1 টি ট্যাব পরিবর্তে 1 স্পেস দিয়ে ফাংশন বডিটি ইনডেন্ট করা সম্ভব।

— ভোল্টাহ

iসবসময় এর চেয়ে বেশি থাকবেন না I?

— এক্সনোর

@ এক্সনর: বিশ্বাস করতে পারছি না যে আমি মিস করেছি :( ধন্যবাদ।

— ভল্টাহ

1

@ ভোলতাঃ আমি মনে করি এটি আপনাকে তালিকা এবং যোগদানের কোনও প্রয়োজন ছাড়াই Iবিন্দুগুলি, বিন্দুগুলির একটি স্ট্রিং কনটেনটেশনে রেখাটি সরল করতে দেয় i।

— xnor

7

GNU সেড, 81 বাইট

( -rপতাকার জন্য +1 সহ )

#!/bin/sed -rf
s!<!s/ I/I /;!g
s!>!s/I / I/;!g
s!_(.{9})!\L\1!g
s!i !i!g
s/.*/echo Ii|sed '&'/e

এটি ইনপুট থেকে একটি নতুন সেড প্রোগ্রাম তৈরি করে (যা আপনি শেষ লাইনটি সরিয়ে দিয়ে দেখতে পারেন) এবং এটি প্রারম্ভিক অবস্থানে প্রয়োগ করে Ii।

ব্যাখ্যা

প্রথম দুটি লাইন রূপান্তর করে <এবং >'বিকল্প' কমান্ডগুলিতে Iযথাক্রমে বাম এবং ডান স্থানান্তরিত করে।
তারপরে আমরা নিম্নলিখিতটির পরিবর্তে পরিবর্তে _কাজ করতে চাইiI
i কোনও ডান হাতের প্রান্তে আবদ্ধ নয়, সুতরাং এটি অনুসরণ করে স্থান যুক্ত বা গ্রাস করবেন না
অবশেষে ইনপুটটিতে তৈরি কমান্ডটি প্রয়োগ করুন Ii। s///eসর্বদা /bin/shএটির শেল হিসাবে ব্যবহার করে, তাই আমি এটি sed '&'<<<Iiযা চেয়েছিলাম তা সংক্ষিপ্ত করতে পারিনি (এটি একটি বাশ পুনঃনির্দেশ সিনট্যাক্স)।

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

$ for i in '' '>_>' '<_<' '>_<' '<_>' '>_> >_>' '>_> <_<' '>_> >_<' '>_> <_>' '<_< >_>' '<_< <_<' '<_< >_<' '<_< <_>' '>_< >_>' '>_< <_<' '>_< >_<' '>_< <_>' '<_> >_>' '<_> <_<' '<_> >_<' '<_> <_>' '>_> >_> <_>' '<_> >_> >_> >_> <_> <_<' '<_> >_> >_> >_> <_> <_< >_< <_< >_<' '>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<'
> do printf '%s => ' "$i"; ./74719.sed <<<"$i" | tr \  .; done | cat -n
     1   => Ii
     2  >_> => I.i
     3  <_< => Ii
     4  >_< => Ii
     5  <_> => I.i
     6  >_> >_> => .I.i
     7  >_> <_< => Ii
     8  >_> >_< => .Ii
     9  >_> <_> => I..i
    10  <_< >_> => I.i
    11  <_< <_< => Ii
    12  <_< >_< => Ii
    13  <_< <_> => I.i
    14  >_< >_> => I.i
    15  >_< <_< => Ii
    16  >_< >_< => Ii
    17  >_< <_> => I.i
    18  <_> >_> => .I.i
    19  <_> <_< => Ii
    20  <_> >_< => .Ii
    21  <_> <_> => I..i
    22  >_> >_> <_> => I...i
    23  <_> >_> >_> >_> <_> <_< => .I...i
    24  <_> >_> >_> >_> <_> <_< >_< <_< >_< => ..Ii
    25  >_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_< => ...I.....i

— টবির গতি
সূত্র

7

জাভাস্ক্রিপ্ট (ES6) 176 171 168 155 148 147 142 141 বাইট

//v8 - I was sure saving off math was saving a byte, thanks ETF
_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v7 - not checking first char when I can check whole string - changed how I create end string (stolen from edc65)
_=>_.split` `.map(m=>(I=m<'='?I-1||0:M.min(i-1,I+1))+(i=m[2]=='<'?M.max(I+1,i-1):i+1),i=1,I=0,M=Math)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v6 - one more byte
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)+((a=Array(i))[I]='I')&&a.join`.`+'i'

//v5 - not filling array with '.', just joining with . later
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i))[I]='I')&&a.join`.`+'i'

//v4 - realized I didn't need to split >_> on _, just use the 0th and 2nd index
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v3 - saving Math to a var (thanks @Verzio)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v2 - as a single expression! (thanks @Downgoat)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//version 1
_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

ব্যবহার

f=_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'


f(">_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<")
//"...I.....i"

ডিগল্ফড (v6, v7 এর চেয়ে আলাদা নয়)

//my solution has changed slightly, but not significantly enough to redo the below

_=>                   //take an input
  _.split` `          //split to each command <_<
   .map(              //do something for each command (each command being called m)
     m=>              
       (I=            //set I to.... 'I will be the index of the letter I'
         m[0]=='<'?   //is the first char of the command '<'?
           Math.max(0,I-1)   //yes => move I to the left (but don't move past 0)
           :
           Math.min(i-1,I+1)  //no => move I to the right one, but keep it one less than i
       )

       +              //also we need to mess with i
       (i=
        m[2]=='<'?    //is the 3rd char of the command '<'?
          Math.max(I+1,i-1)  //yes => move i to the left, but keep it one right of I
          :
          i+1         //move i to the right (no bounds on how far right i can go)
       )

       ,i=1,I=0       //set I to 0 and i to 1 initially
     )
   +                  //this just lets us chain commands into one expression, not really adding
   (
    (a=Array(i))[I]='I') //create an array of length i (will be one shorter than we really need)
                         //set element I to 'I'

   &&                    //last chained command, we know the array creation will be true
                         //so javascript will just output the next thing as the return for the function
   a.join`.`+'i'         //join the array with '.' (into a string) and append i
                         //i will always be the last element

— চার্লি উইন
সূত্র

3

=>{ ... }আপনি

— যেটি

আমি কাজের সময় ছাড়তে প্রস্তুত ছিলাম এবং জিনিসগুলিকে গুটিয়ে রাখতে চেয়েছিলাম :) আমি এ থেকে মুক্তি পাওয়ার চেষ্টা করেছি, তবে 4 এর আগে বেশিরভাগভাবে তা পেলাম না: পি আমি আরও একবার নজর দেব

— চার্লি উইন

1

ইঙ্গিত: নিজেকে একটি বাইট সংরক্ষণ করুন এবং কেবল দু'বার ম্যাথ লিখুন।

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

6

এমএটিএল , 56 55 50 49 47 বাইট

1Hj3\q4ZC"w@1)+lhX>yqhX<w@3)+yQhX>]tZ"105b(73b(

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

1           % push 1: initial position of 'I'
H           % push 2: initial position of 'i'
j           % take input as a string
4\q         % modulo 3 and subtract 1: this gives -1 for '<', 1 for '>'
4Zc         % arrange blocks of length 4 as columns of 2D array. This pads last 
            % block with a zero (because the separating space won't be there).
            % Only first and third and last rows will be used
"           % for each column
  w         %   swap: move position of 'I' to top of stack
  @1)       %   first number (+/-1) of current column: tells where the 'I' moves
  +         %   add
  lhX>      %   max with 1: 'I' cannot move left past position 1
  y         %   duplicate position of 'i'
  qhX<      %   max with that number minus 1: 'I' cannot collide with 'i'
  w         %   swap: move position of 'i' to top of stack
  @3)       %   last number (+/-1) of current column: tells where the 'i' moves
  +         %   add
  y         %   duplicate position of 'I'
  QhX>      %   max with that number plus 1: 'i' cannot collide with 'I'
]           % end for each
t           % duplicate position of 'I'. This is the output string length
Z"          % string with that many spaces
105b(       % set 'i' at its computed position in that string
73b(        % set 'I' at its computed position in that string

— লুইস মেন্ডো
সূত্র

প্যারেনের মিলের অভাব + ধনুর্বন্ধনী - এটি আমার চোখগুলি বার্ন করে

— বিড়াল

2

@ টাক হা হা। কমপক্ষে "ম্যাচ" এর উদ্ধৃতিগুলি

— লুইস মেন্ডো

5

রেটিনা, 91 86 বাইট

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

$
¶Ii
(`^¶

sr`^<_(.*)( |)I
$1I$2
s`^>_(.*)I( ?)
$1$2I
sr`^<(.*) ?i
$1i
s`^>(.*)i
$1 i

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

— mbomb007
সূত্র

1

( |)শেষ ম্যাচের লাইনের শেষে আপনার দরকার নেই , কারণ এর পরে আর কোনও জায়গা থাকবে না i। এছাড়াও, আবার শেষ ম্যাচের লাইনে, লুপের জন্য আপনার বন্ধনী বন্ধনী প্রয়োজন হবে না। আনটোনযুক্ত লুপটি রেটিনার ফাইলের শেষে স্বয়ংক্রিয়ভাবে বন্ধ।

— দাভকো

ধন্যবাদ। আমার পরে স্পেস ছিল iএবং তার পরে কিছু প্রতিস্থাপন করা হবে। সেগুলি পরিবর্তন করতে ভুলে গেছি।

— mbomb007

4

জাভাস্ক্রিপ্ট (ES6) 166 বাইট

চার্লি ওয়েনের উত্তরটি ব্যবহার করে, আমি ম্যাথ.ম্যাক্সকে এম হিসাবে সংজ্ঞায়িত করে এবং প্রতিবার তাঁর স্ক্রিপ্টটি ব্যবহার করে এম কল করে 10 বাইট সংরক্ষণ করতে সক্ষম হয়েছি

_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M=Math.max;M(0,I-1):M(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

(আমি এই গল্ফটি লিখিনি, চার্লি উইন এখানে করেছিলেন । আমি কেবল এটি সংক্ষিপ্ত করে এটিকে সংশোধন করেছি)

— Verzlo
সূত্র

4

পিপিসিজিতে আপনাকে স্বাগতম! এখানে, আমরা পোস্টগুলিতে মন্তব্য করব যা উন্নত করা যেতে পারে। আপনার যদি (মূলগতভাবে) আলাদা সমাধান না হয় তবে আপনি মূল পোস্টে গল্ফ করার পরামর্শটি মন্তব্য করতে পারেন।

— কনর ও ব্রায়ান

2

আমি করতাম তবে তা করার মতো যথেষ্ট খ্যাতি আমার নেই।

— ভার্জলো

1

এটি থাকতে পারে, তবে লোকেদের ডাউন-ভোটিং শেষ হতে পারে। দুঃখিত। আমি মনে করি এটি থাকতে পারে, তবে অন্যরা নাও থাকতে পারে।

— Rɪᴋᴇʀ

1

আমি আপনার উত্তরটি দেখার আগে আপনি যে পরিবর্তনগুলি করেছিলেন সে সম্পর্কে অন্য উত্তর সম্পর্কে মন্তব্য করতে যাচ্ছি। +1 যে উপর! তবে আপনার কোডটি SyntaxError: missing : in conditional expressionফায়ারফক্সে ছুঁড়েছে । আপনি এটি দিয়ে ঠিক করতে পারেন

_=>{I=0,i=1,M=Math.max;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):M(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

, যা একই সঠিক আকার আছে।

— ইসমাইল মিগুয়েল

1

যদিও আমি ক্রোমে একটি সিনট্যাক্স ত্রুটি পেয়েছি

— চার্লি উইন

4

জাভাস্ক্রিপ্ট (ES6), 115 118

সম্পাদনা করুন: 3 বাইট সংরক্ষিত thx চার্লিউইন

a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

pএর আগে স্পেসের সংখ্যা I; qএর মধ্যে Iএবং স্পেসের সংখ্যা i। নেতিবাচক হতে পারে না।

কম গল্ফড

a=>(
  a.split(' ').map( x=> (
    x>'='?q&&(--q,++p):p&&(--p,++q), // try to move I based on 1st char of x
    x[2]>'='?++q:q&&--q // try to move i based on 3rd char of x
  ) 
  , p=q=0), // starting values of p and q
  '.'.repeat(p)+'I' + '.'.repeat(q) +'i' // return value
)

পরীক্ষা

f=a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

console.log=x=>O.textContent+=x+'\n'

;[['','Ii'],
['>_>','I.i'],
['<_<','Ii'],
['>_<','Ii'],
['<_>','I.i'],
['>_> >_>','.I.i'],
['>_> <_<','Ii'],
['>_> >_<','.Ii'],
['>_> <_>','I..i'],
['<_< >_>','I.i'],
['<_< <_<','Ii'],
['<_< >_<','Ii'],
['<_< <_>','I.i'],
['>_< >_>','I.i'],
['>_< <_<','Ii'],
['>_< >_<','Ii'],
['>_< <_>','I.i'],
['<_> >_>','.I.i'],
['<_> <_<','Ii'],
['<_> >_<','.Ii'],
['<_> <_>','I..i'],
['>_> >_> <_>','I...i'],
['<_> >_> >_> >_> <_> <_<','.I...i'],
['<_> >_> >_> >_> <_> <_< >_< <_< >_<','..Ii'],
['>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<','...I.....i']]
.forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i +' -> '+r + (r==k?' OK':' KO (exp '+k+')'))
})

<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

আপনি যদি একটি আলাদা করতে পারেন তবে .স্প্লিট `। ম্যাপ (.replace (/ \ S + / এর পরিবর্তে), আমি সত্যিই পছন্দ করি আপনি কীভাবে i এর অবস্থানের পরিবর্তে I থেকে i এর দূরত্বটি সংরক্ষণ করছেন I আমি আমার ব্যবহারটি পরিবর্তন করতে চেয়েছিলাম এটি তবে আমি মনে করি এটি কেবল আপনার একটি আয়না হয়ে উঠবে

— চার্লি ওয়াইন

এটি 2 বাইট সঞ্চয়! thx @ চার্লিউইন .. বা 3

— এডক 65

3

রেটিনা, 61 58 বাইট

3 বাইট সংরক্ষণ করেছেন @ ফ্রাইআমডেইজিগম্যানকে ধন্যবাদ।

^
Ii 
(`( ?)I(.*i) <|I( ?)(.*i) >
$3I$1$2$4
 ?i_<
i
i_>
 i

ব্যাখ্যা একটু পরে আসে।

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

ব্যাচ পরীক্ষার সাথে সংশোধিত কোড।

— randomra
সূত্র

আহ। আই এর সামনে রেখে দেওয়া আরও

— অর্থবোধ করে

2

পাইথন 2, 96 92 বাইট

f=lambda s,I=1,i=2:s and f(s[2:],i,I+cmp(s,'=')*(0<I+cmp(s,'=')!=i))or'%*c'*2%(I,73,i-I,105)

একটি শিফটি চ্যালেঞ্জের জন্য সুন্দর শিফটি-সন্ধানের সমাধান। ইনপুট লাইক f('>_> <_>'), আউটপুট মত 'I i'।

যাচাইকরণের প্রোগ্রাম (ধরে testsনিই যে মাল্টলাইন টেস্ট কেস স্ট্রিং):

for test in zip(*[iter(tests.replace("[empty string]", "").splitlines())]*4):
    assert f(test[1]) == test[2].replace('.',' ')

প্রোগ্রামটি I=1, i=21-ভিত্তিক সূচকগুলি শুরু করে এবং ব্যবহার করে একবারে প্রতিটি তীর পড়বে। পরিবর্তনশীল নামের একটি বাচ্চা বিভ্রান্তিকর যেহেতু তারা ভূমিকা অদলবদল রয়েছে - যে গৃহস্থালির কাজ পরে Iহয়ে iএবং iহয়ে Iআপডেট করা হয়েছে। একটি চর কেবলমাত্র আপডেট করা হয় যদি তা অন্য চরের অবস্থান বা পজিশন 0-এ স্থান পরিবর্তন করে না।

উদাহরণস্বরূপ, >_> <_> >_<আমরা এর জন্য :

Char     I (= i from previous iteration)        i
-----------------------------------------------------------------------------------------
         1                                      2
>        2                                      1+1 = 2 would overlap, so remain 1
>        1                                      2+1 = 3
<        3                                      1-1 = 0 is too low, so remain 1
>        1                                      3+1 = 4
>        4                                      1+1 = 2
<        2                                      4-1 = 3

এটি ' Ii'পছন্দসই হিসাবে দেয় ।

— Sp3000
সূত্র

0

লুয়া, 104 বাইট

s='Ii'for v in(...):gmatch'%S_?'do
s=s:gsub(('>i$ i< ii>_I  I<_ II '):match(v..'(..)(%P+)'))end
print(s)

ব্যবহার:

$ lua shifter.lua "<_> >_> >_> >_> <_> <_<"
 I   i

— ডিম স্ক্রিপ্টুনফ
সূত্র

0

জাভাস্ক্রিপ্ট (ES5), 153 125 বাইট

aচলার আগে একটি ভেরিয়েবল সেট করে একটি ইনপুট নেয়

I=i=0;for(b of a.split(" "))b[0]==">"?i!=I&&I++:I>0&&I--,b[2]==">"?i++:I!=i&&i--;r=Array(i).fill(".");r[I]="I";r.join("")+"i"

কিছুটা নাড়িত:

I=i=0;
for(b of a.split(" "))
   b[0]==">" 
       ? i!=I && I++ 
       : I>0 && I--,
   b[2]==">" 
       ? i++ 
       : I!=i && i--
;
r=Array(i).fill(".");
r[I]="I";
r.join("")+"i"

— জানুয়ারী
সূত্র

0

গণিত, 125 বাইট

Fold[StringReplace,"Ii",StringCases[#,"<_"|">_"|">"|"<"]/.{"<_"->".I"->"I.",">_"->"I."->".I","<"->".i"->"i",">"->"i"->".i"}]&

প্রথম যুক্তি দিয়ে খাঁটি ফাংশন #। ধারণা যে প্রতিটি <_, >_, <, এবং >ইনপুট একটি স্ট্রিং রিপ্লেসমেন্ট নিয়ম অনুরূপ। "<_"|">_"|">"|"<"এটি একটি স্ট্রিং প্যাটার্ন যা এই চারটি অভিব্যক্তির কোনওটির সাথে মেলে। StringCases[#,"<_"|">_"|">"|"<"]এই জাতীয় সব মিল খুঁজে পাবে। তারপর আমরা প্রতিস্থাপন ( /.) প্রতিটি "<_"স্ট্রিং রিপ্লেসমেন্ট নিয়ম সঙ্গে ".I"->"I.", প্রতিটি ">_"নিয়ম সঙ্গে "I."->".I"তাই ঘোষণা, এবং। তারপরে আমি ধারাবাহিকভাবে প্রতিটি প্রতিস্থাপনের নিয়মটি স্ট্রিংয়ে প্রয়োগ করতে চাই "Ii", তবে StringReplaceকেবল স্ট্রিংয়ের অংশগুলিতে ম্যাচগুলির সন্ধান করব যা প্রতিস্থাপন করা হয়নি, তাই আমরা শুরু মান সহ প্রতিস্থাপনের নিয়মের তালিকার উপরে Foldফাংশনটি রেখে দিয়েছি ।StringReplace"Ii"

সম্ভবত এটি একটি উদাহরণ দিয়ে পরিষ্কার হবে (এখানে %পূর্ববর্তী ঘরটির আউটপুট বোঝায়):

— ngenisis
সূত্র

শিফটি আই শিফটিং আই

বল কি?

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

সিজেম, 33 বাইট

পার্ল, 59 56 54 বাইট

ব্যাখ্যা

লিটললুয়া - 178 বাইট

রেটিনা ,101 86

ব্যাখ্যা:

পাইথন, 142 141 134 122 121 বাইট

GNU সেড, 81 বাইট

ব্যাখ্যা

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

জাভাস্ক্রিপ্ট (ES6) 176 171 168 155 148 147 142 141 বাইট

এমএটিএল , 56 55 50 49 47 বাইট

রেটিনা, 91 86 বাইট

জাভাস্ক্রিপ্ট (ES6) 166 বাইট

জাভাস্ক্রিপ্ট (ES6), 115 118

রেটিনা, 61 58 বাইট

পাইথন 2, 96 92 বাইট

লুয়া, 104 বাইট

জাভাস্ক্রিপ্ট (ES5), 153 125 বাইট

গণিত, 125 বাইট