यह एक श्रृंखला में पहली है, दूसरी दो सड़कें हैं जो एक पीली लकड़ी में विभाजित हैं (भाग 2)

यह चुनौती रॉबर्ट फ्रॉस्ट की प्रसिद्ध कविता, "द रोड नॉट टेकन" से प्रेरित है:

दो सड़कें एक पीली लकड़ी में निकलीं,
और खेद है कि मैं दोनों यात्रा नहीं कर सका
और एक यात्री हो सकता था, जब तक मैं
नीचे की ओर
झुकता था, तब तक मैं खड़ा था और एक को नीचे देखा ।

फिर दूसरे को लिया, जैसा कि उचित था,
और शायद बेहतर दावा था,
क्योंकि यह घास था और पहनना चाहता था;
हालांकि उसके लिए वहाँ से गुजरने वालों ने
वास्तव में उसी के बारे में पहना था,

और उस सुबह दोनों समान रूप से बिछे
पत्तों में कोई कदम काला नहीं पड़ा था।
ओह, मैंने पहला किसी और दिन के लिए रखा था।
फिर भी यह जानते हुए कि रास्ते कैसे आगे
बढ़ते हैं , मुझे संदेह है कि क्या मुझे कभी वापस आना चाहिए।

मैं इसे
कहीं-कहीं युगों-युगों के साथ बता रहा हूँ, इसलिए:
दो सड़कें एक लकड़ी में बदल जाती हैं, और मैंने -
मैंने एक कम यात्रा की,
और इससे सारा फर्क पड़ा।

दूसरी से अंतिम पंक्ति पर ध्यान दें I took the one less traveled by,।

आपकी वास्तविक चुनौती

आप इस रूप में इनपुट लेंगे:

#     ##
 #   ##
  # ##
   #
   #
   #

और आपको पतली सड़क ढूंढनी होगी।

सड़क नीचे से शुरू होती है a #। अन्य 2 सड़कें, जो हमेशा शीर्ष पंक्ति पर समाप्त होती हैं, वे सड़कें हैं जिनकी आपको जांच करनी है। जो सड़क सबसे मोटी है, वह सबसे अधिक यात्रा करती है, और इसलिए यह वह नहीं है जो आप चाहते हैं। अन्य व्यक्ति सबसे कम यात्रा करता है, और यह वह है जो आप चाहते हैं।

उत्पादन

आपके प्रोग्राम / फंक्शन को 2 अलग-अलग वैल्यू (जैसे 0 या 1, ट्रू या गलत) में से किसी एक को आउटपुट करना चाहिए, जो आपके द्वारा ली गई सड़क की प्रत्येक संभावित स्थिति के लिए है। उदाहरण के लिए, आप 0 आउटपुट कर सकते हैं यदि सड़क नहीं ली गई सड़क के बाईं ओर है, और 1 अन्यथा, या आप स्ट्रिंग "बाएं" या "सही", सही, गलत, आदि का उत्पादन कर सकते हैं।

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

 ##    #
  ##  #
   ###
    #
    #
    #

उत्पादन "सही" हो सकता है।

 ##  #   
  ## #  
   ###
    ##
     #
     #
     #

उत्पादन "सही" हो सकता है।

 ##  #   
  ## #  
   ###
    ##
   # 
  #  
 #

उत्पादन "सही" हो सकता है।

 ##   #  
  ## #  
   ###
    #
   # 
  #  
  #

उत्पादन "सही" हो सकता है।

 #    ## 
  #  ## 
   ###
    #
   # 
  #  
  #

उत्पादन "छोड़ दिया" हो सकता है

 #    ## 
  #  ## 
   ###
    #
     #
     #
     #

उत्पादन "छोड़ दिया" हो सकता है

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है
मानक खामियों से मना किया
आपको "बाएं" और "दाएं" के लिए अपने आउटपुट को निर्दिष्ट करना होगा और उन्हें अलग होना चाहिए
इनपुट एक बड़ा स्ट्रिंग होगा, और इसमें किसी भी प्रकार की लाइनें हो सकती हैं
आपको मान्य इनपुट के बारे में चिंता करने की आवश्यकता नहीं है।
सड़क हमेशा वाई आकार की होती है, इसलिए आपको केवल सबसे ऊपर देखना होगा।
कोई भी प्रश्न है? नीचे टिप्पणी करें:

सबसे कम बाइट गिनती जीत!

code-golf ascii-art decision-problem

— programmer5000
स्रोत

1

हां, हमेशा # और ##, और क्षैतिज क्रॉससेक्शन।

— प्रोग्रामर

1

मुझे नहीं था मुझे यह पसन्द आया। अच्छी तरह से परिभाषित, अच्छी कहानी और स्पष्ट उदाहरण। यह काफी आसानी से संभव है और मुझे लगता है कि अस्पष्ट भाषाओं को आमंत्रित करने का विचार केवल अतिरिक्त स्वाद जोड़ता है और कुछ दिलचस्प उत्तरों को प्रोत्साहित कर सकता है।

— एलपेड्रो

1

आईबीएम / लोटस नोट्स फॉर्मूला भाषा और Acc !! प्रतिक्रियाएँ इस बात का प्रमाण हैं कि कैसे अस्पष्ट भाषाओं को आसान प्रश्नों के लिए आमंत्रित करना दिलचस्प परिणाम देता है।

— प्रोग्रामर

3

मैं बस अपने आप से कह रहा था: "आप जानते हैं कि एक चुनौती सरल है जब आप सोचते हैं, 'अरे, यह आसान होगा Acc में !! ';);)

— DLosc

22

@ प्रोग्रामर 5000: मैं डाउनवोटर्स में से एक हूं। मैंने चुनौती को कम कर दिया क्योंकि यह एक गिरगिट चुनौती है (इसमें ऐसा लगता है कि यह पार्सिंग के बारे में है या अन्यथा सड़कों को मापने के बारे में है, लेकिन वास्तव में यह सिर्फ "रिक्त स्थान पर विभाजित है, पहले खंड को लें"), बहुत सारी पृष्ठभूमि के साथ, जो स्पर्शरेखा के साथ है संबंधित और अभी भी चुनौती को अस्पष्ट करने के लिए; और क्योंकि यह बेहद आसान है (कुछ ऐसा है जो आम तौर पर मुझे चुनौतियों का सामना करना पड़ता है)। यह भी अधूरा निर्दिष्ट है (उदाहरण के इनपुट 1 और 2 के अलावा अन्य चौड़ाई भी हो सकते हैं?)

16

सीजाम , 1 बाइट

rपुट स्टैक पर stdin से सटे गैर-सफ़ेद पात्रों में से पहली स्ट्रिंग, तो यह प्रिंट ##के लिए छोड़ दिया और #के लिए सही ।

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

— डेनिस
स्रोत

4

यह पोकेमॉन गो के सोर्स कोड जैसा दिखता है।

— टेलर लोपेज

18

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

संपादित करें:

अधिक गोल्फ वाला संस्करण है

a=>a.trim[1]

#दाएं के लिए रिटर्न और बाएं के लिए एक स्थान है।

मूल:

a=>a.trim()[1]=='#'

व्याख्या

अधूरा :

function(input) {
  return input.trim().charAt(1) === '#';
};

यह फ़ंक्शन जो पहली चीज़ करता है, वह इनपुट की शुरुआत और अंत में सफेद स्थान को हटा देता है। इसका मतलब है कि पहला चरित्र हमेशा होता है #। फिर वहां से मैं दूसरे चरित्र की जांच करता हूं (जावास्क्रिप्ट 0 पर शुरू होता है) और देखें कि क्या यह एक #चरित्र है। यह एक बूलियन देता है। अगर रास्ता rightयह है true, अगर यह छोड़ दिया जाता है तो यह वापस आ जाएगा false।

मैंने इसे कैसे गोल्फ दिया

ES6 में एक अनाम फ़ंक्शन शॉर्टहैंड है जिसे एक तीर फ़ंक्शन कहा जाता है । इसका मतलब है कि मैं अपना रैपर फंक्शन ले सकता हूं और इसे इसमें बदल सकता हूं:

input => ...;

तीर फ़ंक्शन के नियमों के कारण यह बाकी कोड लौटाएगा। वहाँ से मैंने इसे एक छोटे तरीके से रूपांतरित charAt(1)किया [1], हालांकि इसकी अनुशंसा नहीं की गई है । फिर मैंने ले लिया ===और उसे चालू कर दिया ==। जबकि वे इस मामले में अलग हैं यह कोई फर्क नहीं पड़ता। अंत में, मैं नाम दिया inputकरने के लिए aऔर सभी व्हाइटस्पेस निकाल।

आउटपुट दाएं और बाएं

जबकि पहेली को वास्तव में दाएं और बाएं आउटपुट के लिए प्रोग्राम की आवश्यकता नहीं होती है, यहां अन्य आउटपुट का एक उदाहरण है:

a=>a.trim()[1]=='#'?'right':'left'

केवल जोड़ा हिस्सा है ?'right':'left'। यह एक टर्नरी ऑपरेटर बनाता है , एक संघनित यदि कथन है, तो इसका मतलब है कि (अपंग) कोड * के बराबर है:

function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};

उदाहरण

// Function assignment not counted in byte count
let f =
a=>a.trim()[1]=='#'

<textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"></textarea>
<button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)">Submit</button>
<p id="result"></p>

स्निपेट का विस्तार करें

— डेविड आर्चीबाल्ड
स्रोत

3

साइट पर आपका स्वागत है! अच्छा स्पष्टीकरण और स्निपेट, यह एक बहुत गहन पहला उत्तर है। :)

— जेम्स

2

धन्यवाद। मैं थोड़ी देर के लिए कोड गोल्फ सर्फिंग कर रहा हूं और अंत में एक बनाने का फैसला किया है। मान लीजिए कि इसका स्टैकऑवरफ्लो मुझ पर बरस रहा है।

— डेविड आर्किबाल्ड

1

वाह, पूरी तरह से बहिर्गमन!

— प्रोग्रामर

1

यह वास्तव में अच्छा तरीका है। उस एक के बारे में नहीं सोचा था।

— एलपेड्रो

1

जैसे ही @ प्रोग्रामर 5000 जवाब देगा मैं इसे संपादित करूँगा। यह एक महान विचार है, धन्यवाद।

— डेविड आर्किबाल्ड

10

अजगर, 2 बाइट्स

hc

#बाएं और ##दाएं के लिए आउटपुट ।

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

व्याख्या

hc
 cQ     Split the (implicit) input on whitespace.
h       Get the first part.

— mbomb007
स्रोत

10

एसीसी !! , 30 बाइट्स

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

Count i while 35-N {
}
Write N

स्टड से इनपुट लेता है। यदि बाएं हाथ की सड़क कम यात्रा की जाती है, या #यदि दाहिने हाथ की सड़क कम यात्रा की जाती है तो आउटपुट । इसे ऑनलाइन आज़माएं!

व्याख्या

Nहर बार संदर्भित किए जाने वाले स्टैडेन से किसी वर्ण का ASCII मान पढ़ता है। हम 35-Nसत्य होते हुए भी पाश ; वह है, जबकि 35-N != 0या N != 35। इसलिए, जब लूप बाहर निकलता है, तो हमने #लाइन पर पहला वर्ण पढ़ा है । इसके बाद अगले चरित्र के साथ पढ़ा जाता है Nऔर वापस stdout के साथ लिखा जाता है Write।

— DLosc
स्रोत

वाह! फिर भी एक और अस्पष्ट भाषा ...

— प्रोग्रामर

7

@ programmer5000 यदि आप प्रोग्रामिंग भाषाओं को अस्पष्ट करना चाहते हैं, तो आप सही साइट पर आए हैं। ;)

— DLosc

मैं Acc कहाँ चला सकता हूँ !! क्या GitHub लिंक, Tio, या अन्य है?

— प्रोग्रामर

@ programmer5000 पायथन 3 स्रोत कोड उस पोस्ट में है जिसे मैंने हेडर में लिंक किया है, लेकिन मैं देखूंगा कि क्या मैं आपके लिए एक TIO लिंक को एक साथ जोड़ सकता हूं।

— २

@ प्रोग्रामर 5000 ने उत्तर के लिए TIO लिंक जोड़ा।

— २०

8

रेटिना, 5 बाइट्स

आउटपुट 1अगर दाएं, 0अगर बाएं हैं।

^ *##

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

यदि सकारात्मक परिणाम के लिए मानों को अलग नहीं होना चाहिए (5 बाइट्स):

एक सकारात्मक पूर्णांक आउटपुट करता है यदि दाएं, शून्य यदि बाएं।

## +#

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

— mbomb007
स्रोत

1

वाह! यह कैसे काम करता है? अपने उत्तर की व्याख्या करने में सावधानी बरतें?

— प्रोग्रामर

1

@ programmer5000 यह सिर्फ एक मैच के लिए नियमित अभिव्यक्ति के खिलाफ इनपुट का परीक्षण करता है।

— mbomb007 19

6

आईबीएम / लोटस नोट्स फॉर्मूला भाषा, 37 35 26 बाइट्स

संपादित करें मैं हमेशा यह भूल जाता हूं कि @Likeवाइल्डकार्ड 2 बाइट्स से सस्ता है @Contains।

संपादित करें 2 वास्तव में इसकी आवश्यकता नहीं है @ifक्योंकि यह केवल प्रिंट करता है 1या 0इस पर निर्भर करता है कि सूत्र क्या परिणाम देता है @Trueया नहीं @False।

@Like(@Left(a;"##");"%#%")

गणना क्षेत्र सूत्र। सीधे शब्दों में पहले की बाईं करने के लिए सब कुछ ले ##यह क्षेत्र में पाता है aऔर एक अगर वहाँ #उस में आउटपुट 1छोड़ दिया अन्यथा आउटपुट के लिए 0सही करने के लिए।

@DavidArchibald के लिए धन्यवाद के साथ, यहां 22 बाइट्स के लिए एक समाधान है। दावेदारों के समाधान के संबंध में मैं इसे अपने मुख्य उत्तर के रूप में पोस्ट नहीं करूंगा।

@Left(@Trim(a);2)="##"

यह एक 1दाएं और 0बाएं के लिए आउटपुट करता है ।

— ElPedro
स्रोत

वाह! अस्पष्ट भाषा! अगर बेहतर जवाब जल्द नहीं आता है, तो इसे स्वीकार किया जा सकता है ...

— प्रोग्रामर

1

जब मैं एक युवा (एर) प्रोग्रामर था, तो अच्छे पुराने दिनों में इतना अस्पष्ट नहीं हुआ करता था ;-)

— ElPedro

4

पिप , 8 6 बाइट्स

a~`#+`

एक कमांड-लाइन तर्क के रूप में इनपुट लेता है (जिसे वास्तविक कमांड लाइन से चलने पर नईलाइन्स के उद्धरण और भागने की आवश्यकता होगी)। #यदि बाएं हाथ की सड़क कम यात्रा की जाती है, और ##यदि दाहिने हाथ की सड़क कम यात्रा की जाती है तो आउटपुट । इसे ऑनलाइन आज़माएं!

व्याख्या

यह पिप के हाल ही में जोड़े गए रेगेक्स प्रथम-मैच ऑपरेटर का उपयोग करता है।

a         First cmdline arg
 ~        Regex match the first instance of...
  `#+`    ...one or more #s (i.e. a cross-section of the left-hand road)
          Print (implicit)

सीधा रेगेक्स समाधान ( mbomb007 का रेटिना उत्तर का एक पोर्ट ) 9 बाइट्स है:

`^ +##`Na

— DLosc
स्रोत

क्या आपने बाइट गिनती में कमांड-लाइन तर्क को गिना था?

— प्रोग्रामर

@ programmer5000 कमांड-लाइन तर्क के माध्यम से इनपुट लेना एक इनपुट विधि है जिसे डिफ़ॉल्ट रूप से अनुमति दी जाती है (और पिप को इनपुट मिलता है)। बाइट पेनल्टी गैर-मानक कमांड-लाइन झंडे पर लागू होती है , जिसका उपयोग मैं इस सबमिशन में नहीं कर रहा हूं। उस ने कहा, इस विशेष मामले में, एक बदल सकताa है qऔर इसके बजाय स्टड से इनपुट प्राप्त कर सकता है।

— २०

ओह। मुझे समझ नहीं आया।

— प्रोग्रामर

4

चिप , 7 बाइट्स

AZ~S
at

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

0x0बाएं, और 0x1दाएं के लिए आउटपुट । (TIO में ध्वज शामिल है -vताकि आप बाइनरी मानों को stderr में देख सकें। ASCII में आउटपुट देखने के लिए, e*fपहली पंक्ति के अंत में जोड़ा जा सकता है।)

चिप एक बाइट स्ट्रीम के भीतर अलग-अलग बिट्स पर काम करता है, जो वास्तव में इस विशिष्ट समस्या को काफी अच्छा बनाता है।

Aइनपुट बाइट का सबसे कम महत्वपूर्ण बिट है, और '#' इनपुट का एकमात्र चरित्र है जिसके लिए यह बिट सेट है। जब इस बिट का पहली बार सामना किया जाता है, तो हम पहली पंक्ति के पहले '#' पर पहुंच गए हैं।

Z एक चक्र के लिए उस संकेत को विलंबित करता है, जिससे हम अब अगले चरित्र को देख रहे हैं।

tअब सक्रिय हो गया है, जिसका अर्थ है कि यह चक्र पूरा होने के बाद निष्पादन को समाप्त करना। हमें पहले सड़क की चौड़ाई से अधिक देखने की जरूरत नहीं है।

~Sअंतिम एक को छोड़कर सभी चक्रों के लिए उत्पादन को दबा देता है। यदि यह यहाँ नहीं था, तो हमें हर चक्र पर एक आउटपुट मिलेगा।

aअपने पड़ोसियों का वर्तमान मूल्य (केवल Aइस मामले में) आउटपुट बाइट के कम से कम महत्वपूर्ण बिट में डालता है ।

इस सब का मतलब है कि हम एक 0x1अगर पहले '#' तुरंत एक और '#' के बाद, और 0x0अन्यथा प्राप्त करते हैं।

— Phlarx
स्रोत

4

सी, 35 बाइट्स

f(char*s){while(35^*s++);return*s;}

PragmaticProgrammer के उत्तर के रूप में एक ही विचार : पहले ढूंढें #, और इसके बाद जो आउटपुट आता है - वह #"दाएं" के लिए, और <space>"बाएं" के लिए।

सी (लोफोल), 16 बाइट्स

परीक्षण के मामलों के अनुसार, ऐसा लगता है कि बाएं मार्ग हमेशा बाएं मार्जिन से ठीक एक स्थान पर है। इसलिए...

#define f(s)2[s]

— क्वेंटिन
स्रोत

खामी का इरादा नहीं था, उन परीक्षण मामलों में गलत थे। लेकिन आपका सी उत्तर प्रभावशाली है!

— प्रोग्रामर

3

बैच, 46 बाइट्स

@set/ps=
@for %%a in (%s%)do @echo %%a&exit/b

एसटीडीआईएन से एक पंक्ति पढ़ता है, इसे रिक्त स्थान पर विभाजित करता है, और पहले शब्द को प्रिंट करता है, इसलिए #बाएं और ##दाएं के लिए आउटपुट करता है । यदि उद्धृत कमांड-लाइन मापदंडों का एक सरणी स्वीकार्य है, तो 36 बाइट्स के लिए:

@for %%a in (%~1)do @echo %%a&exit/b

पहले तर्क को रेखांकित करता है ताकि यह रिक्त स्थान पर विभाजित हो जाए और इसके पहले शब्द को प्रिंट कर सके।

— नील
स्रोत

3

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

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

lambda S:S.split()[0]

#बाएं और ##दाएं के लिए आउटपुट

— मृत पोसुम
स्रोत

3

रेटिना , 5 बाइट्स

!1`#+

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

एक वैकल्पिक 5-बाइट समाधान। #बाएं और ##दाएं के लिए प्रिंट । विचार एस के सभी रन #( #+) और प्रिंट ( !) उनमें से केवल पहले एक ( ) का मिलान करना है 1।

— मार्टिन एंडर
स्रोत

3

हास्केल, 21 बाइट्स

f n=snd$span(==' ')n!!1

या बिंदु मुक्त शैली में:

(!!1).snd.span(' '==)

"#" का अर्थ दाएं है, और "" का अर्थ बाएं है

फ़ंक्शन केवल एक स्ट्रिंग लेता है, शुरुआत के रिक्त स्थान को गिराता है, और फिर, यह दूसरा चरित्र लेता है (अंतरिक्ष यदि बाईं ओर पतला है और # यदि बाईं तरफ मोटी है)

संपादित करें: तीन बाइट्स लाईकोनी और निम्मी के लिए धन्यवाद!

— सामान्य प्रदर्शन का नाम
स्रोत

बेनामी कार्य भी स्वीकार्य हैं, इसलिए (!!2).dropWhile(' '==)उत्तर के रूप में पर्याप्त है।

— लकोनी

यह !!1दूसरे तत्व के लिए है। आप परीक्षण को छोटा कर सकते हैं <'!'। पॉइंटफ्री संस्करण में, आप dropWhileद्वारा प्रतिस्थापित कर सकते हैं snd.span।

— नीमी

2

ब्रेनफक, 32 बाइट्स

+[>,>+++++[<------>-]<--[,.>>]<]

Ungolfed:

+[                       while 1
>,>+++++[<------>-]<--     3 if hash; 0 if space
[,.>>]                     print next char and break iff current char is hash
<]

#दाएं और बाएं के लिए प्रिंट ।

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

— रे
स्रोत

2

पर्ल 5 , 8 + 1 = 9 बाइट्स

die$F[0]

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

-a(1 बाइट पेनल्टी) के साथ चलाएं ।

आउटपुट है (जहां फ़ाइल नाम स्क्रिप्ट का फ़ाइल नाम है) यदि बाईं सड़क कम यात्रा की जाती है, या यदि सही सड़क कम यात्रा की जाती है।# at filename line 1, <> line 1## at filename line 1, <> line 1

व्याख्या

-aविकल्प स्वचालित रूप से इनपुट पढ़ता है और रिक्त स्थान को चारों ओर कॉलम में यह विभाजन, अग्रणी खाली स्थान के अनदेखी। जैसे, इनपुट का पहला डिटम वह है जो हमें चाहिए; वह है $F[0]। यह प्रोग्राम को एक निहित लूप में भी रखता है, जिसे हम नहीं चाहते हैं। हालांकि, dieहमें एक स्ट्रिंग का उत्पादन करने और अंतर्निहित लूप से बाहर निकलने की अनुमति देता है, एक ही समय में (और इसके अलावा और कोई वर्ण नहीं say, स्ट्रिंग को प्रिंट करने का सबसे सामान्य तरीका)।

अच्छी रचनात्मकता और कम बाइट गिनती! दुर्भाग्य से, पहले से ही एक 2-बाइट उत्तर है। क्या आप इस श्रृंखला में तीसरी चुनौती का प्रयास करने में रुचि रखते हैं ?

— प्रोग्रामर

2

@ programmer5000: मुझे नहीं लगता कि पर्ल (और, वास्तव में, यह गैर-गोल्फिंग भाषा में सबसे छोटा जवाब है) में 2-बाइट उत्तर है। आमतौर पर, हम प्रत्येक भाषा में / प्रत्येक दृष्टिकोण के माध्यम से सबसे अच्छा समाधान खोजने का लक्ष्य रखते हैं, अन्यथा गोल्फ की भाषा के अलावा कुछ भी उपयोग करने का कोई मतलब नहीं होगा।

2

सी 54 बाइट्स

char*strchr();char c(char*s){return*(strchr(s,35)+1);}

सी ++ 58 बाइट्स

#include<cstring>
char c(char*s){return*(strchr(s,35)+1);}

चूंकि ओपी ने निर्दिष्ट किया है कि यह एक "प्रोग्राम / फ़ंक्शन" हो सकता है जिसे मैंने पात्रों को बचाने के लिए एक फ़ंक्शन लिखने के लिए चुना। हालाँकि, मैंने अभी भी "#include" बयान को शामिल किया और वर्ण गणना में लाइन ब्रेक के साथ-साथ फ़ंक्शन को संकलित करने के लिए आवश्यक हैं।

उत्पादन

" "बाईं ओर इंगित करने के लिए स्पेस वर्ण लौटाता है , या "#"दाईं ओर इंगित करने के लिए हैश वर्ण।

व्याख्या

Strchr () फ़ंक्शन किसी दिए गए स्ट्रिंग को चलाता है और एक निर्दिष्ट चरित्र की पहली घटना के लिए एक संकेतक लौटाता है। इसमें एक अधिभार है जो एक पूर्णांक को एक तर्क के विपरीत दूसरे तर्क के रूप में स्वीकार करता है जो मुझे 1 वर्ण बचाता है। उदा '#' को 35 से बदला जा सकता है। फिर मैं फंक्शन से लौटे हुए पॉइंटर में से किसी एक को जोड़कर कैरेक्टर को तुरंत फॉलो कर सकता हूं, और उसे डिफर कर सकता हूं, फिर रिजल्ट चार पर लौटा सकता हूं।

ध्यान दें

जब मैं गोल्फ के लिए (take °） ° ╯︵ ┻━┻ to) की कोशिश कर रहा हूं, तो मैं इस दृश्य को औपचारिक रूप से अपनी नाराजगी को Visual Studio ऑटो-फॉर्मेट में व्यक्त करने का अवसर लेना चाहूंगा।

संपादित करें: C और C ++ में कुछ अंतरों को इंगित करने के लिए Ray का धन्यवाद और जहाँ मैं अक्षर <3 को सहेज सकता था।

— PragmaticProgrammer
स्रोत

C / C ++ एक भाषा नहीं है: ऐसे भाव हैं जो C और C ++ में अलग-अलग चीजें हैं। उदाहरण के लिए, C ++ में, यदि किसी फ़ंक्शन की खाली पैरामीटर सूची है, तो इसका मतलब है कि यह कोई तर्क नहीं लेता है। जबकि सी में, इसका मतलब है कि पैरामीटर अनिर्दिष्ट हैं। तो अगर आप तय करते हैं कि यह एक सी कार्यक्रम है, आप बदल सकते हैं #include <string.h>\nके साथ char*strchr();और 6 बाइट्स बचाने, जबकि अभी भी पूरी तरह से कानूनी है। (और अगर आप सी ++ जो भी कारण के लिए पसंद करते हैं, आप बदल सकते हैं #include <string.h>के साथ #include <cstring>और सेव 1 बाइट।)

— रे

दिलचस्प है, मुझे इसकी जानकारी नहीं थी। मेरे उत्तर का धन्यवाद, धन्यवाद।

— प्रागैमाटिकप्रोग्रामर

1

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

p=s=>/^ *#( |$)/.test(s.split("\n")[0])

स्पष्टीकरण:

p एक ऐसा फंक्शन है जो रिटर्न करता है true अगर सड़क से कम यात्रा करता है तो बाईं और झूठी है अन्यथा इस साइट पर यह मेरा पहला जवाब है, इसलिए इसे शायद और अधिक (शायद रेगेक्स) पर गोल्फ किया जा सकता है।

यह इनपुट की शीर्ष रेखा को ले कर काम करता है और यह देखता है कि यह रेगेक्स से मेल खाता है या नहीं /^ *#( |$)/ (स्ट्रिंग की शुरुआत, किसी भी राशि के रिक्त स्थान, एक # और एक स्थान या स्ट्रिंग के अंत) से ।

यह केवल लोगों को प्रारूप के बारे में स्पष्टीकरण देना और विचार उत्पन्न करना है। मुझे यकीन है कि इसे और हराया जा सकता है। हैप्पी गोल्फिंग!

p=s=>/^ *#[^#]/.test(s.split("\n")[0])

<textarea rows = "8" cols = "8" oninput = "console.log(p(this.value))"></textarea>

स्निपेट का विस्तार करें

— programmer5000
स्रोत

मुझे लगता है कि आपके पास एक जगह हो सकती है[^#]

— user41805

फिक्स्ड रेगेक्स मुद्दा।

— प्रोग्रामर

मैंने एक छोटा जावास्क्रिप्ट उत्तर दिया ।

— डेविड आर्चीबाल्ड

1

जाप , 3 बाइट्स

( -g1झंडे के लिए 2 बाइट्स ) #दाएं के लिए आउटपुट और बाएं के लिए एक स्थान। डेविड आर्चीबाल्ड द्वारा जावास्क्रिप्ट उत्तर के आधार पर ।

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

— टॉम
स्रोत

1

एक्सेल, 17 बाइट्स

=left(trim(A1),2)

सेल में इनपुट मानता है A1।

##दाएं के लिए रिटर्न और #( #और स्पेस) लेफ्ट के लिए।

— pajonk
स्रोत

1

Dyvil , 12 बाइट्स

s=>s.trim[1]

स्पष्टीकरण:

s=>          // lambda expression
   s.trim    // removes leading (and trailing) whitespace
         [1] // gets the second character

उपयोग:

let f: String -> char = s=>s.trim[1]
print f('...')

बाएं और #दाएं के लिए रिटर्न (व्हाट्सएप) ।

— Clashsoft
स्रोत

1

जावा 7, 166 66 63 52 43 बाइट्स

int c(String s){return s.trim().charAt(1);}

35दाएं और 32बाएं के लिए आउटपुट । @Clashsoft के Dyvil उत्तर के
आधार पर ।

स्पष्टीकरण:

int c(String s){   // Method with String parameter and integer return-type
  return s.trim()  //  Remove leading and trailing whitspaces
   .charAt(1);     //  and return the second character (as int value)
}                  // End of method

टेस्ट कोड:

class M{
  static int c(String s){return s.trim().charAt(1);}

  public static void main(String[] a){
    System.out.println(c(" ##    #\n  ##  #\n   ###\n    #\n    #\n    #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n     #\n     #\n     #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n   # \n  #  \n #   "));
    System.out.println(c(" ##   #  \n  ## #  \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n     #\n     #\n     #"));
  }
}

इसे यहाँ आज़माएँ।

आउटपुट:

— केविन क्रूज़सेन
स्रोत

0

Befunge 98, 11 बाइट्स

-!jv~'
@.~<

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

32बाईं ओर, और 35दाएं के लिए प्रिंट , दोनों एकल अनुगामी स्थान के साथ।

व्याख्या

-!jv      This is a no-op the first time through, but used later

    ~'    Pushes the ASCII value of the next character, and pushes 32
-!        Subtracts the 2, and nots. If the character was a space, the top will be 1
  jv      Goes to the second line if the character was not a space

  ~<      Pushes the next characer's ASCII value
 .        Prints it (32 for " " and 35 for "#")
@         Ends the program

मैंने जो एक तरकीब इस्तेमाल की थी, वह -!jvपहली थी, भले ही वह कुछ भी न करे। इसने मुझे अंतरिक्ष के बाद दोनों से छुटकारा दिलाया 'और कुछ गद्दी बचा ली। इस अंतिम के साथ, कोड होगा

~' -!jv
   @.~<

15 बाइट्स के लिए।

— MildlyMilquetoast
स्रोत

0

रूबी, 20 बाइट्स

->r{r.strip[1]==' '}

बाएं के लिए सही है, सही के लिए गलत है।

— dkudriavtsev
स्रोत

एक पीले रंग की लकड़ी में दो सड़कें (भाग 1)

आपकी वास्तविक चुनौती

उत्पादन

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

टिप्पणियाँ

सबसे कम बाइट गिनती जीत!

सीजाम , 1 बाइट

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

संपादित करें:

मूल:

व्याख्या

मैंने इसे कैसे गोल्फ दिया

आउटपुट दाएं और बाएं

उदाहरण

अजगर, 2 बाइट्स

व्याख्या

एसीसी !! , 30 बाइट्स

व्याख्या

रेटिना, 5 बाइट्स

आईबीएम / लोटस नोट्स फॉर्मूला भाषा, 37 35 26 बाइट्स

पिप , 8 6 बाइट्स

व्याख्या

चिप , 7 बाइट्स

सी, 35 बाइट्स

सी (लोफोल), 16 बाइट्स

बैच, 46 बाइट्स

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

रेटिना , 5 बाइट्स

हास्केल, 21 बाइट्स

ब्रेनफक, 32 बाइट्स

Ungolfed:

पर्ल 5 , 8 + 1 = 9 बाइट्स

व्याख्या

सी 54 बाइट्स

सी ++ 58 बाइट्स

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

स्पष्टीकरण:

जाप , 3 बाइट्स

एक्सेल, 17 बाइट्स

Dyvil , 12 बाइट्स

जावा 7, 166 66 63 52 43 बाइट्स

Befunge 98, 11 बाइट्स

व्याख्या

रूबी, 20 बाइट्स