हाँ या नहीं का निर्धारण?

19

एक स्ट्रिंग [लंबाई 1-20] इनपुट करने के बाद, केवल हाँ और n के लिए वर्ण y युक्त , आपके प्रोग्राम को परिणाम (y या n) आउटपुट करना चाहिए। उदाहरण इनपुट: आउटपुट y होगा।yynynynny

परिणाम निम्नलिखित तरीके से y और n के संयोजन से निर्धारित होता है:

  • y es और n o बराबर n o

  • y es और y es के बराबर होती है y es

  • n o और n o बराबर y es

यदि स्ट्रिंग में 2 से अधिक अक्षर (संभावना ...) हैं, तो गणना समान दिखाई देगी। उदाहरण:

  • y es और y es और n बराबर ओ एन ओ (तो कोई और हाँ छोड़ दिया जाता है, क्योंकि कोई करने के लिए पहले हाँ के साथ कोई मर्ज के। और एक ही बात फिर से होता है)

  • n ओ और एन ओ और एन बराबर ओ एन ओ (हाँ पहले दो नहीं की मर्ज, तो हां और ना छोड़ दिया जाता है, जो कोई को उभरने)

आउटपुट के साथ उदाहरण इनपुट:

  • yynynynynyyn = एन

युक्ति: इस बात का ध्यान रखें कि आपके प्रोग्राम का कार्य करने का क्रम परवाह नहीं करता है। (उदाहरण के लिए आप इनपुट को पीछे से, या पीछे से पढ़ सकते हैं, अक्षरों को मिला सकते हैं, इसे सॉर्ट कर सकते हैं, जो भी हो। क्या मायने रखता है सही ouptput)!

जीत के मानदंड: यह कोड-गोल्फ है , इसलिए बाइट जीत में सबसे छोटा कोड है।

code-golf  decision-problem 
— Squareoot
स्रोत
3
स्पष्ट विनिर्देश के साथ पहली चुनौती पर बधाई! (हालांकि यह दुर्भाग्यपूर्ण है कि कुछ समुदाय के सदस्यों को "बहुत तुच्छ" चुनौतियां पसंद नहीं हैं ....)
— यूजर 202729
3
— user202729
7
क्या हम एक वैकल्पिक जोड़ी का उत्पादन कर सकते हैं? कहो 1के लिए y, और 0के लिए n।
— ओलिवर
5
क्या हम इनपुट को पात्रों की सूची के रूप में ले सकते हैं["y", "n", "n"]
— ओकेक्स
3
चूंकि इस चुनौती के डुप्लिकेट को भारी रूप से घटा दिया गया था, इसलिए मुझे नहीं लगता कि इसे डुप्लिकेट के रूप में बंद करना बहुत मददगार है। कुछ भी करते हैं, तो पुराने चुनौती के बाद से इस एक का डुप्लिकेट होना चाहिए यह की नीति बेहतर चुनौती छोड़ने के लिए खुला मैं इस चुनौती को फिर से खोल दिया है
— DJMcMayhem

जवाबों:

9

चारकोल , 6 बाइट्स

§yn№Ｓn

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

    Ｓ   Input string
   № n  Count number of `n`s
§yn     Circularly index into string `yn`
        Implicitly print appropriate character
— नील
स्रोत
1
कृपया बताएं कि यह कैसे काम करता है?
— मालदीव
@Malandy लिंक कोड के वर्बोज़ संस्करण के लिए है।
— एडम
1
@ Adám वास्तव में मैं आमतौर पर एक को जोड़ता हूं, हालांकि मैंने इसे केवल एक काम के ब्रेक में धराशायी कर दिया था और एक को संपादित करने के लिए भूल गया।
— नील
14

ऑक्टेव , 29 27 बाइट्स

गलती को इंगित करने के लिए @RickHithcock को धन्यवाद , अब सही किया गया। इसके अलावा, @StewieGriffin के लिए 2 बाइट्स धन्यवाद !

@(s)'yn'(mod(sum(s+1),2)+1)

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

व्याख्या

ASCII कोड बिंदु 'y'विषम है, और वह 'n'भी है। कोड

  1. 1प्रत्येक स्ट्रिंग में इनपुट स्ट्रिंग में 'y'सम और 'n'विषम बनाने के लिए जोड़ता है ;
  2. योग की गणना करता है;
  3. परिणाम को कम कर देता है 1, भले 2ही विषम;
  4. इंडेक्स (1-आधारित) स्ट्रिंग में 'yn'।
— लुइस मेंडो
स्रोत
मैं शायद कुछ स्पष्ट याद कर रहा हूं, लेकिन यह -4 बाइट्स के लिए कुछ सीमित परीक्षण मामलों में उसी तरह काम करता है । यह शायद बेतहाशा गलत है क्योंकि मुझे ऑक्टेव का पता नहीं है!
— डोम हेस्टिंग्स
2
@DomHastings ओपी में दिए गए yynynynny के लिए विफल रहता है, y को वापस लौटना चाहिए, लेकिन रिटर्न n
— स्किड्सदेव
9

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

एक स्ट्रिंग के रूप में इनपुट लेता है।

s=>'ny'[s.split`n`.length&1]

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

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

वर्णों के एक सरणी के रूप में इनपुट लेता है।

y=>'yn'[n=1,~~eval(y.join`^`)]

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

— Arnauld
स्रोत
31:: s=>'yn'[s.match(/n/g).length&1]P
— केवल
@ ASCII- केवल यह उन स्ट्रिंग्स पर विफल होगा जिनमें कम से कम एक नहीं है n।
— अरनौलद
ओह, यह होगा। ऊप्स> _>
— केवल
8

हास्केल , 33 28 बाइट्स

f a=cycle"yn"!!sum[1|'n'<-a]

अनंत सूची "nnynynyn ..." में n की गिनती को अनुक्रमित करता है। पिछला दृष्टिकोण (33 बाइट्स) अलग-अलग तत्वों के जोड़े को n, अन्यथा y:

f=foldl1(\a b->last$'y':['n'|a/=b])

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

— Angs
स्रोत
1
आपका पिछला दृष्टिकोण 30 बाइट्स में किया जा सकता है। इसे ऑनलाइन आज़माएं!
— गेहूं जादूगर
7

जेली , 7 बाइट्स

ċ”nị⁾ny

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

सी के ount संख्या "n , मैं स्ट्रिंग में ndex ⁾ny । (मोडुलो 2 के साथ)

ċḢịɗ⁾ny

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

{ Ḣ ount संख्या, ċ ead ले , फिर into ndex में} string .ny ।

OCSị⁾ny

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

ऊपर दिए गए ऑक्टेव उत्तर के समान। हे rd मान की गणना करें , C ऑलिफ़ाइंड लें (प्रत्येक ऑर्ड वैल्यू x 1-x की गणना के लिए ), S um, फिर। Ndex को स्ट्रिंग में लें ।

— user202729
स्रोत
यह मेरा फर्जी समाधान था जो मुझे भ्रमित कर रहा था!
— जोनाथन एलन
7

एपीएल (डायलॉग यूनिकोड) , 15 बाइट्स

'ny'[1+=/'y'=⍞]

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

नोट: करने के लिए TIO चूक ⎕IO = 1। यदि के साथ चलाया जाता है ⎕IO←0,

एपीएल (डायलॉग यूनिकोड) , 13 बाइट्स

'ny'[=/'y'=⍞]

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

यह एक्सएनओआर फ़ंक्शन है (कभी-कभी इसे EQV कहा जाता है, विशेष रूप से पुराने बेसिक में।

अपघटन / विश्लेषण:

             ⍞  - Accept string input  
         'y'=   - Compare it to the letter `y`. This "converts" the input 
                  string into a vector of 1s and 0s where the 1s correspond 
                  to 'y' and the 0s to 'n'.  
       =/       - XNOR/EQV/equality reduction - converts the vector into a 
                  single boolean value by evaluating e.g., 1 xnor 0 xnor 0 
                  xnor 1 ...  
     1+         - adds one for subscripting in ⎕IO = 1 environment. In 
                  ⎕IO = 0, should be omitted (save 2 bytes)  
    [         ] - subscript indicator - the expression, which should be 
                  either a 1 or 2 (0 or 1 in `⎕IO = 0`), is now going to be 
                  interpreted as a subscript of...  
'ny'            - The string of possible results - a 0/1 is 'n', a 1/2 is 'y'
— जेफ़ ज़िटलिन
स्रोत
जबकि XOR 0s पर ध्यान नहीं देता है और 1s पर फ़्लिप करता है, XNOR 1s पर ध्यान नहीं देता और 0 पर फ़्लिप करता है, "शुरुआत में" X के समान 0 के बजाय 1 पर होता है।
— फ्रॉन्फ्रॉग
@FrownyFrog - मुझे लगता है कि आप इसे इस तरह देख सकते हैं ... या आप इसे देखने के लिए एक चेक के रूप में देख सकते हैं कि क्या इसके दोनों इनपुट मान समान हैं।
— जेफ ज़िटलिन
6

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

@"yn"l@\n

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

व्याख्या

@"yn"l@\n
     l@\nQ   Get the length of the intersection of the (implicit) input and "n".
@"yn"        Modular index into "yn".
6

डीसी , ३ ९

?dsiZdsl[[]r1-d0<m]dsmxklixzll-2%B*C1+P

इनपुट स्ट्रिंग STDIN से पढ़ी जाती है और फॉर्म में होनी चाहिए [yynynynynyyn]।

dc अपने स्ट्रिंग हैंडलिंग के लिए नहीं जाना जाता है, लेकिन हमारे पास काम करने के लिए बस इतना ही है। यहाँ दृष्टिकोण nएस की गिनती करने के लिए है , और आउटपुट yयदि भी या nविषम हो तो। यह मैक्रो के रूप में इनपुट स्ट्रिंग को निष्पादित करके किया जाता है। सभी s के लिए एरर dcआउटपुट करेगा और स्ट्रिंग्स को पॉप करने का प्रयास करेगा और उन्हें सभी s के लिए प्रिंट करेगा । तो पहले हम यह सुनिश्चित करें कि हमारे पास स्टैक पर पॉप करने के लिए खाली तार के बहुत (कुल इनपुट स्ट्रिंग लंबाई) है । फिर हम इनपुट स्ट्रिंग को निष्पादित करते हैं और देखते हैं कि ढेर पर कितने शेष हैं। कुल (एस) एस की कुल संख्या देने के लिए मूल स्ट्रिंग की लंबाई को इससे घटाया जाता है । बाकी अंक 2 करने के लिए अंकगणित है और ASCII या के रूप में आउटपुट सही निकला है ।'y' (0171) unimplementedyn[][]nyn

?dsi                                    # Read input string, duplicate, store in register i
    Zdsl                                # Get input length, duplicate, store in register l
        [         ]                     # define macro to:
         []                             #   push empty string
           r                            #   swap empty string and remaining length 
            1-                          #   subtract 1 from length
              d0                        #   duplicate and compare with 0
                <m                      #   if >0 recursively call this macro again
                   dsmx                 # duplicate macro, store in register m and execute
                       k                # discard left-over 0
                        lix             # load input string and execute as macro
                           z            # get stack length
                            ll-         # load string length and subract
                               2%       # mod 2 (result is -ve because difference is -ve)
                                 B*     # multiply by 11 ('y' - 'n')
                                   C1+  # add 121 ('y')
                                      P # print result as ASCII char

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

— डिजिटल आघात
स्रोत
6

जाप , 8 बाइट्स

"yn"gUèn

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

स्पष्टीकरण:

"yn"gUèn
"yn"       String literal - "yn"
    g      Return the char at index:   
      è      Number of matches where:
       n       "n" is found in
     U         Input

जाप इंडेक्स-रैपिंग का उपयोग करता है, इसलिए यदि Uènरिटर्न मिलता है 2, तो यह yचार से मिलने पर वापस आ जाएगा "yn"।

— ओलिवर
स्रोत
मेरे पास जो था, उसकी पहचान।
— झबरा
5

जे , 10 9 बाइट्स

{&'ny'@=/

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

— FrownyFrog
स्रोत
1
कमी का बहुत चालाक उपयोग!
— 18'18
वास्तव में अच्छा समाधान है!
— गैलन इवानोव
क्या आप कृपया / दोनों समाधानों का अपघटन प्रदान करेंगे (जैसा कि मैंने अपने एपीएल समाधान के साथ किया था)? (संयोग से, आपको एपीएल समाधान को जे समाधान से अलग समाधान के रूप में पोस्ट करना चाहिए, भले ही एल्गोरिथ्म समान हो।)
— जेफ ज़िटलिन
{&'ny'@=/एक बाइट बचाता है।
— एल्गोरिथमशार्क
@ अल्गोरिद्मशर्क ओह्ह धन्यवाद!
— FrownyFrog
3

आर , 46 44 बाइट्स

"if"(sum(1+utf8ToInt(scan(,"")))%%2,"n","y")

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

नीचे 2 बाइट्स Giuseppe और ngm के लिए धन्यवाद। पोर्ट ऑफ ऑक्टेव उत्तर लुइस मेंडो द्वारा।

— Jayce
स्रोत
ऑक्टेव उत्तर से प्रेरित होना सबसे आसान है; जबकि ऑक्टेव का यह फायदा है कि तार अधिक आसानी से उनके कोड बिंदुओं में परिवर्तित हो जाते हैं, मुझे लगता है कि आप वहां युगल बाइट्स के लिए दृष्टिकोण को पोर्ट कर सकते हैं।
— ग्यूसेप
sum(utf8ToInt(scan(,""))%%2)%%2एक बाइट बचाता है।
— एन जी एम
@ngm @Giuseppe दुख nकी बात तो यह है कि इसे + 1 पहले जोड़ना होगा
— JayCe
3

जाप, 9 बाइट्स

ओलिवर ने मुझे सबसे छोटे समाधान के लिए हराया, इसलिए यहां एक युगल हैं जो अभी एक बाइट हैं।

B*aUèÍu¹d

कोशिश करो

#ndB*UèÍv

कोशिश करो

स्पष्टीकरण

              :Implicit input of string U
B             :11
 *            :Mutiplied by
  a           :  The absolute difference of 11 and
   UèÍ        :    The count of "n" in U
      u       :    Mod 2
       ¹d     :Get the character at that codepoint

              :Implicit input of string U
#n            :110
   B*         :Add 11 multiplied by
        v     :  The parity of
     UèÍ      :    The count of "n" in U
  d           :Get the character at that codepoint
— झबरा
स्रोत
3

/// , 24 बाइट्स

/ny/n//nn/y//yy/y//yn/n/<input>

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

मेरा मानना ​​है कि यह सबसे कम संभव /// कार्यक्रम है, क्योंकि एक चरित्र प्रतिस्थापन को या तो बेकार बना दिया जाता है (यदि आप इसके स्थान पर कुछ डालें) या इसे आउटपुट होने से रोकता है (यदि आप कुछ भी नहीं डालते हैं)। हालांकि, चूंकि कार्यक्रम को दो चरित्र मामलों से निपटना चाहिए, इसलिए यह न्यूनतम होना चाहिए।

पहले yएक के सभी सही निकालता है n। फिर nएस के साथ डबल एस को yप्रतिस्थापित करता है, एलटीआर प्रतिस्थापन का लाभ उठाता है। इस स्तर yपर बहुत से लोगों द्वारा पीछा किया जाता है n; हम ys को घटाते हैं और यदि nअंतिम उपयोग करने के लिए इसे उपयोग करते हैं y।

— boboquack
स्रोत
3

MATL , 8 बाइट्स

Qs'ny'w)

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

लुइस मेंडो के लिए धन्यवाद 2 बाइट्स सहेजे गए! मैंने पहले इंडेक्स को सीमा में लाने के लिए स्पष्ट मापांक कमांड का उपयोग किया था 1,2।

व्याख्या

यह इस तथ्य का उपयोग करता है कि MATL में मॉड्यूलर इंडेक्सिंग है, जिसका अर्थ है कि स्ट्रिंग का 1, 3, 5 वां ... तत्व nyसमान हैं ( n)। तो 2, 4, 6 वें ... स्ट्रिंग के तत्व ( y) हैं।

Q          % Grab input implicitly, and increment each ASCII-value by 1
           % This makes 'n' odd, and 'y' even
 s         % Take the sum of all elements
  'ny'     % Push the string `ny`
      w    % Swap the stack to facilitate the indexing
       )   % Take the n'th element of 'yn' and output it.
— स्टीवी ग्रिफिन
स्रोत
1
'yn'3)देता है y...? अब यह चतुर डिजाइन लुइस =) सुझावों के लिए धन्यवाद! :)
— स्टीवी ग्रिफिन
— लुइस मेंडो
2

जावा (ओपनजेडके 8) , 143 बाइट्स

a->{char[] u=a.toCharArray();if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}

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

और अगर हम इनपुट को एक सूची के रूप में लेते हैं:

जावा (ओपनजेडके 8) , 118 बाइट्स

u->{if(u.length==1)return u[0];else{char b=(u[0]==u[1])?'y':'n',i=2;for(;i<u.length;b=(b==u[i++])?'y':'n');return b;}}

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

स्पष्टीकरण:

(इनपुट स्ट्रिंग के रूप में)

char[] u=a.toCharArray();  //turn string into char array
if(u.length==1){    
    return u[0];      //if single letter, return it
}else{
    char b=(u[0]==u[1])?'y':'n';     //first two XNOR
    for(char i=2;i<u.length;b=(b==u[i++])?'y':'n');   //XNOR each remaining character
return b;    //return final result
}
— X1M4L
स्रोत
आपको अपने त्रिगुट-ifs (-4 बाइट्स) में कोष्ठक की आवश्यकता नहीं है, आप char[]u(-1 बाइट) पर स्थान हटा सकते हैं ; और (-1 बाइट) if(u.length==1)हो सकता है if(u.length<2)। गोल्फ के लिए शायद अधिक है, लेकिन मेरे पास अभी समय नहीं है। :)
— केविन क्रूज़सेन
2

क्यूबिक्स , 24 20 बाइट्स

कुछ समय के बाद से मैं क्यूबिक्स के साथ खेला, इसलिए ...

i;iwW-?;o@..!'yv.n'|

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

काफी भोली कार्यान्वयन जो स्ट्रिंग के माध्यम से कदम उठाता है और वर्तमान परिणाम के खिलाफ चरित्र की तुलना करता है।

इंटरएक्टिव डेमो

यह क्यूब पर अलिखित है

    i ;
    i w
W - ? ; o @ . .
! ' y v . n ' |
    . .
    . .
  • W शिफ्ट आईपी छोड़ दिया
  • i प्रारंभिक चरित्र प्राप्त करें
  • i? ईओआई (-1) के लिए चरित्र और परीक्षण प्राप्त करें, लूप की शुरुआत भी करें
    • यदि ईओआई ;o@टीओएस हटाता है, तो आउटपुट टीओएस चरित्र और निकास के रूप में।
  • और -W!घटाना, शिफ्ट आईपी छोड़ दिया, सच्चाई के लिए परीक्षण
    • यदि सत्य 'nधक्का टी के लिए n चरित्र धक्का
    • यदि फांसी |!'yप्रतिबिंबित होती है, तो परीक्षण करें और चरित्र y को टीओएस पर धकेलें
  • v'.;wघन को चारों ओर पुनर्निर्देशित करना और हटाना। चरित्र और सही पाश में वापस स्थानांतरण
— MickyT
स्रोत
2

Befunge-98 , 13 बाइट्स

~k!aj@,+n'*b!

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

मूल रूप से हर एक के लिए 0 उलट nइनपुट में, और एक बार फिर अच्छा उपाय है, तो आउटपुट yके लिए 1और nके लिए0

~     Get inputted character
 k!   Invert the current value 110 (n) or 121 (y) + 1 times
   aj Jump past the rest of the code
~     Get input again. If no more input, reverse direction
            ! Invert the value once again
       +n'*b  Convert 0/1 to n/y
     @,       Output letter
— मजाक कर रहा है
स्रोत
2

जावास्क्रिप्ट, 39 37 बाइट्स

s=>[...s].reduce((x,y)=>x==y?'y':'n')

इनपुट स्ट्रिंग को विभाजित करने के बाद सरल कम फ़ंक्शन।

— user3335941
स्रोत
1
PPCG में आपका स्वागत है! आपका कोड मानता है कि इनपुट वैरिएबल में है s, जो यहां मान्य इनपुट विधि नहीं है। इसके बजाय आप s=>42 बाइट्स के लिए अपने उत्तर को प्रस्तुत करके एक तर्क के रूप में इनपुट के रूप में लेम्बडा फ़ंक्शन को अपना उत्तर बना सकते हैं।
— द्विजिमा
गोल्फ सुझाव: 37 बाइट्स के s.split('')साथ बदलें [...s]:s=>[...s].reduce((x,y)=>x==y?'y':'n')
— द्वजिमा
2

सी (जीसीसी) , 52 50 बाइट्स

सुझाव के लिए @Neil को धन्यवाद।

मैंने गिनती के हल का उधार लिया n, लेकिन एक गिनती रखने के बजाय, मैं प्रारंभिक अवस्था और इसके व्युत्क्रम के बीच में पलटा n।

i;f(char*a){for(i=*a;*++a;i^=*a&1?0:23);return i;}

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

— ErikF
स्रोत
*a&1?0:23एक बाइट return iबचाता है और दूसरा बचाता है।
— नील
सुझावi;f(char*a){for(i=*a;*++a;i^=*a&1?:23);a=i;}
— सीलिंगकैट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.