एक शतरंज वर्ग का रंग निर्धारित करें


59

आपकी चुनौती एक ऐसे प्रोग्राम को लिखना है जो शतरंज के बोर्ड से दिए गए वर्ग के रंग को आउटपुट करता है। यह कैसे एक बिसात दिखता है:

यहाँ छवि विवरण दर्ज करें

आप देख सकते हैं कि वर्ग ए 1 अंधेरा है, और एच 1 एक हल्का वर्ग है। आपके प्रोग्राम को एक वर्ग दिए जाने पर आउटपुट darkया की जरूरत है light। कुछ उदाहरण:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

नियम:

  • आपको एक पूर्ण कार्यक्रम प्रदान करना होगा जो STDIN का उपयोग करता है और आउटपुट darkया STDOUT का उपयोग करता है light
  • मान लें कि इनपुट हमेशा मान्य है ( [a-h][1-8])
  • यह , इसलिए सबसे कम मात्रा में बाइट्स जीतती हैं!

स्कोरबोर्ड

var QUESTION_ID=63772,OVERRIDE_USER=8478;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


1
किसी ने कोशिश क्यों नहीं की <> ^ मछली?
भूत_न_थे_कोड

जवाबों:


46

जीएस 2 , 17 15 बाइट्स

de♦dark•light♠5

स्रोत कोड CP437 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

सत्यापन

$ xxd -r -ps <<< 6465046461726b076c696768740635 > chess.gs2
$ wc -c chess.gs2 
15 chess.gs2
$ gs2 chess.gs2 <<< b1
light

यह काम किस प्रकार करता है

d               Add the code points of the input characters.
 e              Compute the sum's parity.
  ♦             Begin a string literal.
   dark
       •        String separator.
        light
             ♠  End the string literal; push as an array of strings.
              5 Select the element that corresponds to the parity.

8
वह आश्चर्यजनक है! 9 अपरिहार्य बाइट्स के साथ, 3 बाइट आउटगोल्फिंग पाइथ और सीजम अद्भुत है।
23

29
पवित्र गाय, दोस्तों, जीएस 2 नया पायथ है! किसी ने यह पता लगाया कि डेनी से पहले इसका अच्छी तरह से कैसे उपयोग किया जाए ... कोई बात नहीं।
ETHproductions

56

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

print'ldiagrhkt'[int(input(),35)%2::2]

3 बाइट्स स्ट्रिंग इंटरलेसिंग के लिए मेगो को धन्यवाद

जैसे इनपुट लेता है "g6"। यह हल्का और गहरा है।


यह स्ट्रिंग इंटरलेसिंग के साथ बहुत खूबसूरत है।
वेन वर्नर

5
मैं वास्तव में कहूंगा कि int(input(),35)यह शानदार हिस्सा है। मैंने स्ट्रिंग इंटरलाकिंग के बारे में सोचा, लेकिन आपकी इनपुट विधि सबसे अधिक बाइट्स बचाती है।
mbomb007

26

हेक्सागोनी , 34 32 बाइट्स

,},";h;g;;d/;k;-'2{=%<i;\@;trl;a

अनफोल्डेड और एनोटेट निष्पादन पथ के साथ:

यहाँ छवि विवरण दर्ज करें
डायग्राम टिमवी के अद्भुत हेक्सागोनीकॉलर के साथ उत्पन्न हुई

बैंगनी मार्ग प्रारंभिक पथ है जो दो वर्णों को पढ़ता है, उनके अंतर की गणना करता है और इसे modulo 2 लेता है। <तत्पश्चात एक शाखा के रूप में कार्य करता है, जहां गहरे भूरे रंग का पथ (परिणाम 1) प्रिंट करता है darkऔर हल्के भूरे रंग का पथ (परिणाम 0) प्रिंट करता है light

मैं अंतर और मोडुलो की गणना कैसे करता हूं, यहां मेमोरी ग्रिड का एक आरेख है (इनपुट के लिए लिए गए मानों के साथ a1):

यहाँ छवि विवरण दर्ज करें
आरेख के साथ उत्पन्न Timwi के और भी अधिक अद्भुत गूढ़ आईडीई (जो Hexagony के लिए एक दृश्य डिबगर है)।

मेमोरी पॉइंटर किनारे लेबल वाली पंक्ति पर शुरू होता है , जहां हम चरित्र को पढ़ते हैं। कॉल} लेबल वाले किनारे पर जाता है , जहाँ हम अंक पढ़ते हैं। बढ़त लेबल करने के लिए ले जाता है diff जहां दो के अंतर की गणना करता है। बिना लेबल वाले सेल में ले जाता है जहाँ हम डालते हैं , और सेल लेबल वाले मॉड पर जाते हैं जहाँ हम मॉडुलो की गणना करते हैं ।"-'2{=%

यह कुछ के पुन: उपयोग करके कुछ बाइट्स द्वारा गोल्फ योग्य हो सकता है ;, लेकिन मुझे संदेह है कि यह बहुत अधिक द्वारा गोल्फ हो सकता है, निश्चित रूप से साइड-लंबाई 3 से नीचे नहीं।


7
ऊह, सुंदर रंग!
सेलेओ

1
यह भाषा मेरे लिए नई है, लेकिन मैं जितना संभव हो सके
उससे

18
मैं वास्तव में इन सभी गोल्फ भाषाओं नहीं मिलता है।
जूनियर जूनियर

4
@ कोडस्विफ्ट 4 लाइफ़ हेक्सागोनी एक गोल्फ भाषा होने से बहुत दूर है। इस तरह के तुच्छ कार्यों के लिए यह यथोचित प्रतिस्पर्धात्मक हो सकता है, क्योंकि इसमें एकल-वर्ण कमांड हैं, लेकिन यह कई अन्य 2D भाषाओं द्वारा साझा की जाने वाली आवश्यकता है , जिसमें Befunge, Piet,> <> शामिल हैं। हेक्सागोनी के अजीब मेमोरी मॉडल के कारण किसी भी नॉनवोरियल कार्य को बहुत बड़ी मात्रा में कोड और जटिल कार्यक्रमों की आवश्यकता होगी। यह किसी भी तरह से संक्षिप्त भाषा नहीं है, बल्कि एक विदेशी और अजीब है, जो हेक्सागोनल ग्रिड पर प्रोग्रामिंग की खोज कर रहा है।
मार्टिन एंडर

3
@qwr मैंने सोचा था कि वंचित किया जा रहा था esolangs के बिंदु। ;)
मार्टिन एंडर

21

सीजेएम, 18 बाइट्स

r:-)"lightdark"5/=

ऑनलाइन डेमो

विच्छेदन

r               e# Read a token of input
:-              e# Fold -, giving the difference between the two codepoints
)               e# Increment, changing the parity so that a1 is odd
"lightdark"5/   e# Split the string to get an array ["light" "dark"]
=               e# Index with wrapping, so even => "light" and odd => "dark"

34
अपने कोड मुस्कुरा रहा है:-)
दरवाज़े

8
मैंने समान रूप से प्रभावी माना:^)
पीटर टेलर

2
कृपया आप बता सकते हैं कि यह कैसे काम करता है।
फोगमिस्टर

@Fogmeister, स्पष्टीकरण जोड़ा।
पीटर टेलर

17

सेड, ३ 37

s/[1357aceg]//g
/^.$/{clight
q}
cdark

व्याख्या

s/[1357aceg]//gसभी विषम-अनुक्रमित निर्देशांक निकालता है। परिणामस्वरूप पैटर्न बफ़र में "प्रकाश" के लिए 1 की लंबाई या "अंधेरे" के लिए 0 या 2 की लंबाई है। /^.$/1-लंबाई के पैटर्न से मेल खाता है, cपैटर्न को "प्रकाश" और quits से लटका देता है। अन्यथा पैटर्न c"अंधेरे" को लटका दिया जाता है ।


q निरर्थक है, और आप इसके बजाय पहले डार्क के लिए जांच कर सकते हैं /../, tio.run/##K05N@f@/WD/a0NjUPDE5NT1WXz@dS19PTz85Jbomys5JzM9o@T//…
Kritii Lithos

14

पायथ, 18 बाइट्स

@c2"lightdark"iz35

आधार 35 नंबर के रूप में इनपुट की व्याख्या करें, lightdarkआधा में काटें , प्रिंट करें।


13

ShadyAsFuck, 91 बाइट्स / BrainFuck, 181 बाइट्स

मेरा पहला वास्तविक ब्रेनफैक कार्यक्रम, मेगो को मदद के लिए और एल्गोरिथम संग्रह की ओर इशारा करने के लिए धन्यवाद। (इसका मतलब है कि मैंने इसे वास्तव में अपने दम पर नहीं किया, लेकिन कुछ मौजूदा एल्गोरिदम की नकल की। ​​फिर भी एक अनुभव =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

यह निश्चित रूप से मेरे दिमाग के जवाब से अनुवाद है:

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

इस दुभाषिया / डिबगर का उपयोग करके विकसित किया गया ।

मैंने यहाँ से divmodऔर उसके लिए दो कोड स्निपेट चुराए हैं।if/else(@Mego को धन्यवाद!)

,>,               read input
[<+>-]            add
++<               set second cell to 2 

अब हमारे पास कोशिकाएँ हैं >sum 2 डिमॉड एल्गोरिथम करते हैं:

[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>
[-]>

Divmod का आउटपुट इस तरह दिखता है 0 d-n%d >n%d n/dलेकिन हमने शून्य कर दिया हैd-n%d और अगली सेल को भी शून्य कर रहे हैं:

>[-]

मान तक एक सेल भरें 100आसान आउटपुट के लिए :

++++++++++[>++++++++++<-]< 

अब कॉन्फ़िगरेशन है >cond 0 100और if/elseएल्गोरिथ्म को लागू करने के लिए हमें दो अस्थायी चर की आवश्यकता है, इसलिए हम कॉन्फ़िगरेशन का चयन करते हैंtemp0 >c temp1 100

c[<temp0+>>temp1+<c-]<temp0[>c+<temp0-]+
>>temp1[
 #>++++++++.---.--.+.++++++++++++.<         outputs light
 <<temp0-
>>temp1[-]]
<<temp0[
 #>>>.---.+++++++++++++++++.-------.<<<     outputs dark
temp0-]

12

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

print'dlairgkh t'[sum(map(ord,input()))%2::2]

जैसे इनपुट लेता है "a1"इसे ऑनलाइन आज़माएं


यह प्रिंट के लिए पैरेन्स की कमी के कारण पायथन 3 में काम नहीं करेगा।
isaacg

अभी परीक्षण नहीं कर सकता, लेकिन "ldiagrhgt"[expression::2]बाइट या दो बचाते समय कुछ ऐसा काम करना चाहिए
FryAmTheEggman

12

गंभीरता से , 19 बाइट्स

"dark""light"2,O+%I

जैसे इनपुट लेता है "a1"

इसे ऑनलाइन आज़माएं (आपको मैन्युअल रूप से इनपुट दर्ज करना होगा; पर्मलिंक उद्धरण पसंद नहीं है)


2
ऑनलाइन लिंक शुल्क ..
कैलक्यूलेटरफलाइन

10

ट्यूरिंग मशीन कोड, 235 बाइट्स

यहां परिभाषित नियम तालिका सिंटैक्स का उपयोग करना

0 a _ r 1
0 c _ r 1
0 e _ r 1
0 g _ r 1
0 * _ r 2
1 2 _ r 3
1 4 _ r 3
1 6 _ r 3
1 8 _ r 3
2 1 _ r 3
2 3 _ r 3
2 5 _ r 3
2 7 _ r 3
* * _ r 4
3 _ l r A
A _ i r B
B _ g r C
C _ h r D
D _ t r halt
4 _ d r E
E _ a r F
F _ r r G
G _ k r halt

1
यह संभवतः सबसे आश्चर्यजनक बात है जिसे मैंने कभी देखा है
लुकास

10

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

alert(parseInt(prompt(),35)%2?"dark":"light")

एक मूलांक का उपयोग करने के लिए जाने के लिए रास्ता! +1 FTW ...
वैलीवेस्ट

9

टीआई-बेसिक, 66 बाइट्स

एक TI-84 + कैलकुलेटर पर परीक्षण किया गया।

Input Str1
"light
If inString("bdfh",sub(Str1,1,1)) xor fPart(.5expr(sub(Str1,2,1
"dark
Ans

यहां तीसरी पंक्ति पर एक और दिलचस्प भिन्नता है, जो दुख की बात है कि वास्तव में एक ही आकार है:

Input Str1
"dark
If variance(not(seq(inString("bdfh2468",sub(Str1,X,1)),X,1,2
"light
Ans

आपको लगता है कि TI-BASIC इस चुनौती पर सभ्य होगा, क्योंकि इसमें modulo शामिल है 2. यह नहीं है; ये समाधान सबसे कम संभव लगते हैं।

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


9

बेफुज -93 , 39 37 33 31 बाइट्स

लाइनस को सभी श्रेय जिन्होंने इस 31-बाइट समाधान का सुझाव दिया :

<>:#,_@  v%2-~~
"^"light"_"krad

इस दुभाषिया का उपयोग करके परीक्षण करें

व्याख्या

<        v%2-~~

<शुरुआत में छोड़ दिया है, जहां यह सही करने के लिए इर्द-गिर्द घूमती करने के लिए अनुदेश सूचक भेजता है। यह तो ASCII के रूप में इनपुट से दो पात्रों में पढ़ता है, उन्हें घटा देती है, और 2 के रूप में से एक सापेक्ष करता है aऔर 1दोनों अजीब (ASCII कोड के संदर्भ में), यह काम करता है कर रहे हैं। vनीचे अनुदेश सूचक पुनर्निर्देश ...

"^"light"_"krad

... इस पर _, जो स्टैक के शीर्ष 0 और दाईं ओर अन्यथा बाईं ओर निर्देश सूचक भेजता है। क्रमशः "प्रकाश" या "अंधेरे" के पात्रों को रिवर्स ऑर्डर में स्टैक पर धकेल दिया जाता है। दोनों रास्ते ^बाईं ओर से टकराते हैं, जो निर्देश सूचक को ऊपर की ओर भेजता है ...

 >:#,_@

... आउटपुट सेगमेंट को। :स्टैक के शीर्ष को डुप्लिकेट करता है, पर और #उसके ऊपर कूदता ,है _, जो अनुदेश सूचक को दाईं ओर भेजता है यदि स्टैक के शीर्ष 0 है और अन्यथा छोड़ दिया गया है। जब स्टैक खाली होता है, तो स्टैक का शीर्ष (बाद में :) 0 होता है, इसलिए निर्देश सूचक हिट करता है @जो निष्पादन को रोकता है। अन्यथा, यह हिट करता है ,, जो एक चरित्र के रूप में स्टैक के शीर्ष पर आउटपुट करता है, और फिर #इसे :और पर कूदता है >, जो फिर से प्रक्रिया शुरू करता है।


rad"v>"kअंतरिक्ष के बिना एक बाइट को बचाएं ?
लाइनस

@ लिनुस: "अंतरिक्ष आवश्यक है क्योंकि अन्यथा आउटपुट होगा dar k।" लिंक किए गए ऑनलाइन दुभाषिया में इसे आज़माएं।
एल'एंडिया स्ट्रोमैन

1
आपका अधिकार। वैसे भी, मैं ऐसा करने जा रहा था, लेकिन मैं केवल आपके नीचे 2 बाइट्स प्राप्त कर सकता हूं ... नईलाइन ठीक करूं <>:#,_@ v%2-~~\n"^"light"_"krad
लाइनस

@ लीनस: यह शानदार है। धन्यवाद!
एलेंडिया स्ट्रोमैन

@JamesHolderness, कोई कठिन भावनाओं। आपको यह इंगित करने के लिए सही है कि यह मूल Befunge-93 दुभाषिया में काम नहीं करता है, वास्तविक कल्पना एक 80x25 टोरस के लिए है। आप अपना संस्करण पोस्ट कर सकते हैं क्योंकि यह स्वयं का उत्तर है और अंतर की व्याख्या करता है। मुझे लगता है कि कम से कम यह मेरे साथ साल पुराने शौक कोड पर बहस करने से ज्यादा व्यावहारिक होगा।
लिनस

8

जाप , 23 22 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है । दुभाषिया

Un19 %2?"dark":"light"

यह काम किस प्रकार करता है

          // Implicit: U = input string
Un19      // Convert U from a base 19 number to decimal.
%2        // Take its modulo by 2.
?"dark"   // If this is 1, return "dark".
:"light"  // Else, return "light".
          // Implicit: output last expression

नए संस्करण 0.1.3 (22 नवंबर को जारी) का उपयोग करते हुए, यह 17 बाइट्स बन जाता है , जो सभी जीएस 2 से कम है:

Un19 %2?`»rk:¦ght

या, वैकल्पिक रूप से, एक जादू सूत्र: (26 बाइट्स)

Un19 %2*22189769+437108 sH
Un19 %2                    // Convert input to base 19 and modulo by 2.
       *22189769+437108    // Where the magic happens (top secret)
                        sH // Convert to a base 32 string.

8

जावा, 157 127 124 बाइट्स

interface L{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).nextInt(35)%2>0?"dark":"light");}}

आप इस तरह से एक इंटरफ़ेस का उपयोग कर सकते हैं: interface i{static void mainचूंकि एक इंटरफेस में सब कुछ डिफ़ॉल्ट रूप से सार्वजनिक है
यसिन हज

7

टीस्क्रिप्ट , 23 बाइट्स

®x,35)%2?"dark":"light"

दुर्भाग्य से तार darkऔर lightसंपीड़ित नहीं किया जा सकता है।


Hehe, Japt एक बार के लिए छोटा है ;) +1 हालांकि, JS कम्प्रेशन तकनीक बहुत अच्छी है! मैं दुभाषिया को सुधारने के बाद उन्हें जाप में शामिल कर सकता हूं।
23

7

रूबी, 44 36 बाइट्स से बाहर

puts %w[light dark][gets.to_i(19)%2]

आप (कोई स्थान) के puts साथ बदलकर एक बाइट बचा सकते हैं $><<
लिन

@ मौरिस को मैं जानता हूं, लेकिन मुझे अपनी समाप्ति की नई
रूपरेखा

आप को बदलने के द्वारा 3 बाइट्स बचा सकता है putsके लिएp
Cyoce

7

सी, 55 बाइट्स

s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}

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

बहुत से गोल्फ टिप्स के लिए धन्यवाद DigitalTrauma


मुझे लगता है कि आपके पास एक अतिरिक्त (बाद हैputs
लेवल रिवर सेंट

यह 55 के लिए s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}:। मान लेता है कि पूर्णांक की चौड़ाई स्ट्रिंग के 3 वर्णों को पकड़ने के लिए काफी बड़ी है। आपको main(s){puts(strtol(gets(&s),0,19)&1?"light":"dark");}54 के लिए भी करने में सक्षम होना चाहिए , हालांकि किसी कारण से () कचरा वापस आ रहा है sयदि वैश्विक नहीं है, तो यह segfaults है।
डिजिटल ट्रॉमा

ओह वाह, बेस -19। चालाक।
शराबी

7

बॉटजीन , 165 14x11 = 154

v acegbdfh
>ISSSSSSSS
 v<<<<>v<<P
vS1   vS2ke
vS3   vS4re
vS5   vS6ae
vS7   vS8de
>     >   ^
>     >  v
^S2   ^S1el
^S4   ^S3ei
^S6  P^S5eg
^S8 te^S7eh
     ^   <

यहाँ यह विभिन्न पथ खंडों पर प्रकाश डाला गया है:

यहाँ छवि विवरण दर्ज करें

(कोई भी गैर-स्पेस वर्ण हाइलाइट नहीं किया गया है जो निर्देशों eऔर Sनिर्देशों के लिए तर्क के रूप में है - इनमें से प्रत्येक निर्देश बाईं ओर प्रतीक (यात्रा की बॉट की दिशा के सापेक्ष) को उसके तर्क के रूप में उपयोग करता है)


7

S, 26 चार्ट / 34 बाइट्स

ô(שǀ(ï,ḣ)%2?`dark`:`light”

Try it here (Firefox only).


1
मैं इसे "कम्प्रेशन" नहीं कहूँगा अगर यह अधिक बाइट्स लेता है : पी
lirtosiast

1
मैं इस बिंदु पर बाइट्स की तुलना में अधिक चिंतित हूं। मैं पूरी तरह से count ...
मामा फन रोल

1
हम हमेशा बाइट्स से स्कोर करते हैं, और जब एक माध्यमिक उद्देश्य के लिए अनुकूलन करना अक्सर दिलचस्प होता है, तो याद रखें कि सबसे कम बाइट हमेशा जीतती है।
lirtosiast

हाँ, मैं समझता हूँ कि। मैं वास्तव में ज्यादा से ज्यादा जीतने का लक्ष्य नहीं बना रहा हूं।
मामा फन रोल

7

सी, 49 बाइट्स

main(c){gets(&c);puts(c+c/256&1?"light":"dark");}

नहीं, यह संकलन नहीं है।
xsot

ओह, मेरा बुरा, मैं कुछ और के साथ fiddled था। हालांकि आउटपुट गलत है । मुझे लगता है कि आप क्या करना gets(&c)%256+c/256चाहते थे?
लिन

ओह, अच्छा कैच। हालांकि इस बिंदु पर, मेरा समाधान आपके से भी बदतर है क्योंकि हम उसी तकनीक का उपयोग कर रहे हैं। लगता है मुझे सीखने के लिए बहुत कुछ है।
xsot

यह पता चलता है कि गलत आउटपुट रिटर्न वैल्यू के कारण हुआ था gets(&c)। मैंने तदनुसार अपनी सबमिशन अपडेट कर दी है।
xsot

7

क्लोजर, 63 बाइट्स

(pr (['light 'dark] (mod (Integer/parseInt (read-line) 35) 2)))
  • हम एक पंक्ति में स्टड से पढ़ते हैं (रीड-लाइन)
  • तब JVM विधि के लिए कॉल का उपयोग करके स्ट्रिंग को आधार 35 में पूर्णांक मान में पार्स करें
  • परिणाम 2 का मोड लेना हमें बताता है कि यह सम या विषम है
  • अनुक्रम से एक सूचकांक के रूप में modulo फ़ंक्शन से लौटे परिणाम का उपयोग करें और इसे प्रिंट करें

मैं एक उद्धरण के साथ "प्रकाश" और "अंधेरे" को उद्धृत करके एक योग्य 2 बाइट्स को बचाता हूं ताकि क्लोजर इसे शाब्दिक के रूप में ले जाए, जैसा कि प्रत्येक शब्द को उद्धरण चिह्नों में लपेटने के विपरीत है। मैं भी println के बजाय जनसंपर्क का उपयोग करके कुछ बाइट्स बचा।

क्लोजर में उद्धृत करने पर कुछ जानकारी


प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छा पहला उत्तर है। :) मैं क्लोजर से बहुत परिचित नहीं हूँ; क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे?
एलेक्स ए।

पूर्ण रूप से! तुम वहाँ जाओ। अगर आपका कोई प्रश्न हैं, तो मुझे से पूछें!
मोनोडा 43


5

सी, 46 बाइट्स

main(c){gets(&c);puts(c%37%2?"light":"dark");}

एक ऐसे वातावरण की अपेक्षा करता है, जहाँ intछोटे एंडियन संग्रहित हों, और कम से कम दो बाइट्स हों।

व्याख्या

cहै argc, तो शुरू में यह शामिल है 01 00 00 00getsदो वर्णों को पढ़ेंगे, कहेंगे a (0x61)और 1 (0x31)उन्हें स्टोर करेंगे c, जो अब है

61 31 00 00

संख्या 0x3161, या 12641 का प्रतिनिधित्व करना।

अनिवार्य रूप से, इस समस्या में, दिए गए c = x + 256*y, हम गणना करना चाहते हैं (x + y) mod 2, और तदनुसार एक स्ट्रिंग प्रिंट करते हैं। ऐसा करने के लिए, मैं c % 255 % 2तब लिख सकता था

  (x + 256 * y) % 255 % 2
= (x % 255 + y % 255) % 2      since 256 ≡ 1 (mod 255)
= (x + y) % 2                  since 0 < x, y < 255

हालाँकि, 37यह भी काम करता है:

  (x + 256 * y) % 37 % 2
= (x % 37 - 3 * (y % 37)) % 2  since 256 ≡ -3 (mod 37)

x49-57 समावेशी (अंक 1-8) की सीमा में है, इसलिए x % 37 == x - 37

y 97-104 समावेशी (निचला आह) की सीमा में है, इसलिए y % 37 == y - 74

इसका मतलब है कि हम इसे सरल बना सकते हैं

= (x - 3 * y + 185) % 2
= (x + y + 1) % 2              since -3 ≡ 185 ≡ 1 (mod 2)

और बस समता के लिए सही करने के लिए तार फ्लिप।


5

बीम , 127 बाइट्स

rSr>`+v
   ^  )
n(`)nS<
    >L'''''>`+++++)S>`+++)@---@'''>`+++++)++@-------@H
>L'''''>`+++)S>`++++++)+++@---@--@+@'''>`++++)@H

एक स्पष्टीकरण यहाँ छवि विवरण दर्ज करें लाइट ब्लू - बीम में इनपुट से एक चरित्र को पढ़ें, स्टोर में बीम के मूल्य को बचाएं, बीम में इनपुट से एक चरित्र को पढ़ें।

गहरा नीला - किरण को बढ़ाते समय स्टोर को 0 से घटाकर बीम से जोड़ता है

हल्का हरा - एक विषम परीक्षण निर्माण। यदि बीम सम या विषम हो तो बाईं ओर से पाश निकल जाएगा।

गहरा हरा - गहरा अंधेरा

तान - प्रकाश उत्पन्न करता है


5

, २२ 17 बाइट्स

मैं # 2% "light'dark"?

यह वही करता है जो करने के लिए आवश्यक है, बिना किसी अतिरिक्त लाभ के।


5

भूलभुलैया , 48 46 45 42 बाइट्स

दो बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।

-,"
#
%0:::8.5.3.4.116.@
1
00.97.114.107.@

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

व्याख्या

कोड की शुरुआत एक मजाकिया मृत अंत है। याद रखें कि लेबिरिंथ अनंत संख्या में शून्य ग्रहण करता है जब उसे स्टैक के निचले हिस्से में ऑपरेंड की आवश्यकता होती है। कोड एक -सही चलना शुरू करता है, जो दो संख्याओं को घटाने की कोशिश करता है, इसलिए स्टैक बन जाता है:

[ ... 0 ]

फिर ,पहला पात्र पढ़ते हैं, aकहते हैं:

[ ... 0 97 ]

"नो-सेशन है, लेकिन यह भी एक अंत में मृत्यु तो अनुदेश सूचक चारों ओर मुड़ता है और बाईं ओर जा रहा शुरू होता है। फिर `दूसरे पात्र को पढ़ते हैं, 2कहते हैं:

[ ... 0 97 50 ]

इस बार, -उन दो संख्याओं को घटाएँ:

[ ... 0 47 ]

आईपी ​​अब "गलियारे" के मोड़ का अनुसरण करता है। #ढेर गहराई हो जाता है, निहित शून्य, जो आसानी से होता है अनदेखी 2:

[ ... 0 47 2 ]

और %मोडुलो की गणना करता है:

[ ... 0 1 ]

इस बिंदु पर, आईपी एक जंक्शन पर है। यदि स्टैक का शीर्ष शून्य है, तो यह सीधे आगे बढ़ेगा, जहां 100.97.114.107.@प्रिंट करता हैdark । लेकिन अगर स्टैक का शीर्ष गैर-शून्य (विशेष रूप से 1) है, तो यह दाईं ओर बढ़ जाएगा, जहां 0:::8.5.3.4.116.@प्रिंट light(ध्यान दें कि हम अग्रणी को छोड़ सकते हैं 1, क्योंकि 1स्टैक पर पहले से ही है , और हम दोहराया पर बचा सकते हैं 10में 108, 105, 103, 104के कुछ प्रतियां बनाकर 10जब हम पहले वहाँ पाने के)।


4

मतलाब, 51 बाइट्स

मुझे नहीं लगता कि इसके लिए किसी स्पष्टीकरण की आवश्यकता है =)

a={'light','dark'};disp(a(2-mod(sum(input('')),2)))

4

> <> , 31 बाइट्स

ii+2%?\"krad"oooo;
l"oc0.\"thgi

यहाँ मैं सोच रहा हूँ "वहाँ एक बेहतर तरीका हो गया है ..."


4

पर्ल, 29 27 बाइट्स

$_=/./&($'+ord)?light:dark

इस कोड की आवश्यकता है -p स्विच की , जिसे मैंने 1 बाइट के रूप में गिना है।

इस पर ऑनलाइन प्रयास करें Ideone आज़माएं

यह काम किस प्रकार करता है

  • की वजह से -pस्विच, पर्ल उस में इनपुट और दुकानों की एक पंक्ति पढ़ता है $_

  • /./एक नियमित अभिव्यक्ति है जो एक वर्ण से मेल खाती है। इसके दो निहितार्थ हैं:

    • चूंकि मैच सफल होता है, इसलिए /./रिटर्न 1

    • मैच के बाद (दूसरा इनपुट चरित्र) में संग्रहीत किया जाता है $'

  • $'+ordपूर्णांक जोड़ता है दूसरा इनपुट वर्ण ordनिहित चर के पहले चरित्र के कोड बिंदु ( ) का प्रतिनिधित्व करता है$_

  • &बिटवाइंड और रिटर्न मान का /./योग और योग $'+ord, 1 लौटाने का योग है अगर विषम, 0 अगर यह भी है।

  • ?light:darkयदि पिछला एक्सप्रेशन 1 और अंधेरा लौटा हो तो लाइट लौटाता है अन्यथा।

  • अंत $_=में परिणाम को असाइन करता है $_, जो पर्ल -p स्विच के कारण स्वचालित रूप से प्रिंट करता है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.