50

Shifty- आंखें ASCII लोग ASCII का बदलाव करना पसंद करते हैं Ii:

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

अलग-अलग या अलग-अलग पंक्तियों में, अलग-अलग पंक्तियों की एक स्ट्रिंग को देखते हुए, Iiपक्ष को किनारे पर छोड़ दें, दीवार को छोड़ दें और आसमान को सही करें:

Ii

सबसे छोटा शिफ्टर पुरस्कार जीतता है।

क्या कहना?

एक प्रोग्राम या फ़ंक्शन लिखें जो इन चार ASCII इमोटिकॉन्स की एक मनमानी सूची में लेता है, या तो स्थान या न्यूलाइन अलग (एक वैकल्पिक अनुगामी न्यूलाइन के साथ):

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

उदाहरण के लिए, इनपुट हो सकता है
>_> >_> <_>
या
>_>
>_>
<_>
(आपके द्वारा समर्थित विधि आपके ऊपर है)

प्रत्येक इमोटिकॉन Iऔर iपात्रों पर एक अलग कार्रवाई करता है , जो हमेशा इस तरह से शुरू होता है:

Ii

>_>बदलाव I, एक के बाद सही करने के लिए यदि संभव हो तो, और फिर बदलाव iएक के बाद सही करने के लिए।
<_<बदलाव Iएक के बाद छोड़ दिया है, यदि संभव हो तो, और फिर बदलाव करने के लिए i, एक के बाद छोड़ दिया करने के लिए यदि संभव हो तो।
>_<Iयदि संभव हो तो दाईं ओर शिफ्ट करें, और यदि संभव हो तो एक के बाद iएक बाईं ओर शिफ्ट करें।
<_>बदलाव Iएक के बाद छोड़ दिया है, यदि संभव हो तो, और उसके बाद करने के लिए बदलाव iएक के बाद सही करने के लिए।

Iछोड़ दिया नहीं जा सकता है अगर यह रेखा के बाएं किनारे पर है (जैसा कि यह शुरू में है), और अगर iइसे सीधे अपने दाईं ओर स्थानांतरित नहीं किया जा सकता है (जैसा कि यह शुरू में है)।

iअगर Iइसकी बाईं ओर सीधे (जैसे कि यह शुरू में है) बाईं ओर स्थानांतरित नहीं किया जा सकता है , लेकिन हमेशा दाएं स्थानांतरित किया जा सकता है।

ध्यान दें कि इन नियमों के साथ, Iहमेशा बाईं ओर रहेगा i, और सभी इमोटिकॉन्स के लिए Iपहले स्थानांतरित करने का प्रयास किया जाता है i।

खाली जगह के लिए रिक्त Iiस्थान ( ) या अवधि ( .) का उपयोग करके दिए गए आदेश में सभी पारियों को लागू करने के बाद आपके कार्यक्रम या फ़ंक्शन को अंतिम पंक्ति के एक स्ट्रिंग को प्रिंट या वापस करने की आवश्यकता होती है। ट्रेलिंग स्पेस या पीरियड्स और सिंगल ट्रेलिंग न्यूलाइन आउटपुट में वैकल्पिक रूप से अनुमत हैं। रिक्त स्थान और अवधि न मिलाएं।

उदाहरण के लिए, इनपुट
>_>
>_>
<_>
आउटपुट है
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

— केल्विन के शौक
स्रोत

तो डॉट्स वैकल्पिक हैं, इसके बजाय रिक्त स्थान हो सकते हैं?

— R

क्या आउटपुट में अनुगामी रिक्त स्थान की अनुमति है?

— mbomb007

क्या इनपुट एक 2 डी चार सरणी हो सकता है, एक पंक्ति में प्रत्येक चमकदार आदमी के साथ?

— लुइस मेन्डो

2

@RikerW - हाँ। mbomb - हां, यह उल्लेख किया गया है। डॉन - नहीं

— केल्विन के

15

देखो शिफ्टी आंखें एक गूढ़ भाषा बन जाती हैं ...

— बिल्ली

3

CJam, 33 बाइट्स

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

0-अनुक्रमण को छोड़कर, मेरे पायथन उत्तर के समान एल्गोरिथ्म का उपयोग करता है । अनिवार्य रूप से:

केवल इनपुट में तीर को देखें, <-1 और >1 में परिवर्तित
केवल एक अपडेट लागू करें यदि यह हमें स्थिति -1 में नहीं ले जाता है और हमें दूसरे चार्ट की स्थिति में नहीं ले जाता है
चूंकि तीर आवेदन करने Iऔर आवेदन करने के बीच वैकल्पिक हैं i, इसलिए हम वैकल्पिक करते हैं कि हम प्रत्येक तीर के बाद किस स्थिति को अपडेट करते हैं

आउटपुट बाइट को बढ़ाने के लिए @ मार्टिनबटनर को धन्यवाद, 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संशोधक है जिसका अर्थ है "मूल स्ट्रिंग की एक प्रति बनाएं, उस पर अपना प्रतिस्थापन करें और परिणामी स्ट्रिंग (मैचों की संख्या के बजाय) वापस करें"। जब मैं इसका उपयोग करता हूं तो इसका परिणाम यह होता है कि संशोधित कमांड स्ट्रिंग को छोड़ दिया जाता है, जबकि मूल $_को गड़बड़ी से परेशान नहीं किया जाता है और प्रतिस्थापन के बाद छोड़ दिया जाता है। हालाँकि जो गड़बड़ी मैंने की है $_वह अभी भी $_अकेले छोड़ दिए जाने के बाद की गई है । तो अंत में$_ उचित लक्ष्य स्ट्रिंग होगी।

-pविकल्प यकीन है कि मूल स्ट्रिंग में है बनाता है $_और यह भी अंतिम प्रिंट $_।

— टन हास्पेल
स्रोत

1

प्रारंभिक स्ट्रिंग है Ii, नहीं iI।

— user48538 16

2

@ zyabin101 अतिरिक्त ^मैच का मतलब है कि मुझे उन्हें स्वैप करना है। इसलिए रिवर्स इनिशियलाइज़ेशन सही है।

— टन हास्पेल

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.

लिटलुआ क्या है?

लिटिलुआ इन चुनौतियों और गूढ़ भाषाओं के लिए मेरी पसंद की भाषा के बीच खेल के मैदानों को समतल करने की कोशिश करने के लिए प्रगति पर एक काम है जिसमें अक्सर बेहद शक्तिशाली अंतर्निहित इन्स होते हैं।

LittleLua एक अतिरिक्त मॉड्यूल (LittleLua.Lua) के साथ एक Lua 5.3.6 दुभाषिया है, साथ ही साथ फंक्शन और मॉड्यूल लुटेरा भी है। जब तक मैं खुश हूं, तब तक ये परिवर्तन अगले या दो दिनों में विस्तारित हो जाएंगे, लेकिन जैसा कि यह लिटिलुआ और एक मानक लुआ दुभाषिया के बीच कई सबसे बड़े बदलाव हैं:

कार्य और मॉड्यूल सिकुड़ रहे हैं:

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

चरों में निर्मित

LittleLua ने कुछ कार्यों को छोटा करने के लिए कई चर बनाए हैं:

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 बाइट्स डेकोको धन्यवाद!

रिक्त स्थान द्वारा अलग की गई आँखों के साथ newlines और आउटपुट द्वारा अलग किए गए इनपुट लेता है।

स्पष्टीकरण:

मैं स्टेज को हमेशा की तरह समझाऊंगा। ये सभी चरण रेटिना के रिप्लेसमेंट मोड में हैं। इसका मतलब है कि पहली पंक्ति एक नियमित अभिव्यक्ति है और दूसरी पंक्ति एक प्रतिस्थापन स्ट्रिंग है।

$
¶Ii

Iiइनपुट के अंत में प्रारंभिक जोड़ें ।

( `^ ¶

बैकटिक विकल्प से चरण को अलग करता है। विकल्प का चरित्र (इंगित करता है कि यह चरण इनपुट को बदलने के बिना एक पूर्ण चक्र पूरा होने तक क्रम में बार-बार निष्पादित होने के लिए लूप की शुरुआत है। चूंकि यह खुला कोष्ठक कभी बंद नहीं होता है, शेष सभी चरण इस लूप का एक हिस्सा हैं।

वास्तविक चरण बहुत सरल है, यदि स्ट्रिंग का पहला वर्ण एक नई रेखा है तो इसे हटा दें। यह केवल खाली इनपुट को आसान बनाने में मदद करने के लिए है, अन्यथा इसे दो अंतिम चरणों में जोड़ने के लिए गोल्फर होगा।

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

यहां, विकल्प sरेगेक्स मेटाचैकर .को नई संख्याओं से मिलान करने का कारण बनता है। यह चरण एक अग्रणी स्थान को वैकल्पिक स्थान >से मिलाने का कारण बनता Iहै। फिर यह उस जगह के साथ सामान के साथ मेल खाता है >, उसके बाद वैकल्पिक स्थान (इसलिए खाली स्ट्रिंग यदि स्थान का मिलान नहीं किया जा सकता है), और फिर I।

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

यह चरण पिछले एक के समान है, केवल वैकल्पिक स्थान से पहले है I, और क्रम और आंख उलट है।

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

की हैंडलिंग iवास्तव में अक्सर सरल होती है, क्योंकि हमें वैकल्पिक रूप से जोड़ने या हटाने के बारे में चिंता करने की ज़रूरत नहीं है क्योंकि iहमेशा सही तरीके से आगे बढ़ सकते हैं। के लिए iमामलों में हम अंडरस्कोर के साथ-साथ अधिक से अधिक / समान तर्क संकेत की तुलना में कम है, लेकिन अन्यथा दूर से मेल खाते हैं। यह पहले एक स्थान जोड़ता है i।

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

उपरोक्त के समान फिर से, लेकिन यह चरित्र को हटाता है iयदि इससे पहले कि चरित्र एक स्थान है, अन्यथा यह केवल इमोटिकॉन को हटा देता है।

— FryAmTheEggman
स्रोत

आप इसे नीचे 86 के साथ प्राप्त कर सकते हैं: s`^_>(.*)i( |$)?=> s`^_>(.*)iऔर इसके प्रतिस्थापन $1$#2$* i=> $1 i, और s`^_<(.*?)( )?i=> s`^_<(.*?) ?iऔर इसके प्रतिस्थापन $1i$2=> के साथ $1i।

— दावको

@ mbomb007 हां, मैंने सभी 24 इनपुट के लिए इसका परीक्षण किया है। कोई त्रुटि नहीं मिली।

— डेवको

@daavko धन्यवाद! मुझे पता था कि मेरे पास कुछ सामान पड़ा है जब मैंने दोनों मामलों के बीच में नकल की थी, लेकिन मुझे पोस्ट करने के तुरंत बाद अपना कंप्यूटर छोड़ना पड़ा। सम्पादित :)

— FryAmTheEggman

7

पायथन, 142 141 134 122 121 बाइट्स

सहेजे गए 19 बाइट्स xnor की बदौलत।

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?

— xnor

@xnor: विश्वास नहीं कर सकता कि मैं चूक गया :( धन्यवाद।

— vaultah

1

@vaultah मुझे लगता है कि यह आपको सूचियों और जुड़ने की किसी भी आवश्यकता के बिना I, डॉट्स, डॉट्स, के एक स्ट्रिंग कॉन्सेप्टन के लिए लाइन को सरल बनाने देता है i।

— xnor

7

GNU sed, 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

यह इनपुट से एक नया sed प्रोग्राम बनाता है (जिसे आप अंतिम पंक्ति को हटाकर देख सकते हैं), और इसे प्रारंभ स्थिति पर लागू करता है 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

जावास्क्रिप्ट (ईएस 6) 176 171 168 155 148 148 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"

Degolfed (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

उपयोग करने के बजाय =>{ ... }आप कर सकते हैं एक अभिव्यक्ति है और काफी कुछ बाइट्स बचाने के लिए

— 23

मैं काम पर समय छोड़ने पर रेंग रहा था और चीजों को लपेटना चाहता था :) मैंने इससे छुटकारा पाने की कोशिश की, लेकिन 4 से पहले काफी नहीं मिल सका: पी मैं एक और नज़र

— चार्ली व्यान

1

संकेत: अपने आप को एक बाइट सहेजें और केवल दो बार गणित लिखें।

— ETHproductions

6

MATL , 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

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

चार्ली व्यान के उत्तर का उपयोग करते हुए, मैंने Math.max को M के रूप में परिभाषित करते हुए 10 बार बाइट बचाने में कामयाबी हासिल की और हर बार अपनी स्क्रिप्ट का उपयोग करते हुए M को कॉल किया।

_=>{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

PPCG में आपका स्वागत है! यहां, हम उन पोस्ट पर टिप्पणी करते हैं जिन्हें बेहतर बनाया जा सकता है। जब तक आपके पास (मूल रूप से) अलग-अलग समाधान नहीं होता है, आप मूल पोस्ट पर एक गोल्फ सुझाव पर टिप्पणी करेंगे।

— कॉनर ओ'ब्रायन

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

जावास्क्रिप्ट (ईएस 6), 115 118

संपादित करें: 3 बाइट्स ने Thx CharlieWynn को बचाया

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बीच रिक्त स्थान की संख्या है । न ही नकारात्मक हो सकता है।Ii

कम गोल्फ वाला

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
स्रोत

यदि आप .split `` .replace (.replace (/ \ S + +) के बजाय एक को बचा सकते हैं, तो मुझे वास्तव में पसंद है कि कैसे आप i की स्थिति के बजाय I से i तक दूरी संग्रहीत कर रहे हैं। मैं उपयोग करने के लिए मेरा बदलना चाहता था। कि लेकिन मुझे लगता है कि यह सिर्फ तुम्हारा का एक दर्पण होगी।

— चार्ली व्यान

यह 2 बाइट्स बचाता है! thx @CharlieWynn .. या यहां तक कि 3

— edc65

3

रेटिना, 61 58 बाइट्स

3 बाइट्स ने @FryAmTheEggman को धन्यवाद दिया।

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

व्याख्या थोड़ी देर बाद आती है।

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

बैच टेस्ट के साथ संशोधित कोड।

— randomra
स्रोत

आह। I को सामने रखने से अधिक समझ में आता है ...

— mbomb007

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
स्रोत

शिफ्टी आईज शिफ्टिंग आई

क्या कहना?

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

CJam, 33 बाइट्स

पर्ल, 59 56 54 बाइट्स

व्याख्या

लिटिलुआ - 178 बाइट्स

रेटिना ,101 86

स्पष्टीकरण:

पायथन, 142 141 134 122 121 बाइट्स

GNU sed, 81 बाइट्स

व्याख्या

परीक्षण के परिणाम

जावास्क्रिप्ट (ईएस 6) 176 171 168 155 148 148 142 141 बाइट्स

MATL , 56 55 50 49 47 बाइट्स

रेटिना, 91 86 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 115 118

रेटिना, 61 58 बाइट्स

पायथन 2, 96 92 बाइट्स

लुआ, 104 बाइट्स

जावास्क्रिप्ट (ES5), 153 125 बाइट्स

गणितज्ञ, 125 बाइट्स