73

एक प्रोग्राम या फ़ंक्शन लिखें जो केवल एक स्ट्रिंग में होता है जिसमें वर्ण होते हैं ^और v(आप मान सकते हैं कि कोई अन्य वर्ण नहीं होगा)। बाईं ओर से दाईं ओर पढ़ें यह स्ट्रिंग एक स्टैक एक्सचेंज प्रश्न या उत्तर को पहली बार देखने के दौरान किए गए एकल उपयोगकर्ता क्लिक के अनुक्रम का प्रतिनिधित्व करता है ।

हर ^की एक क्लिक को दर्शाती वोट दें बटन और हर vके एक क्लिक का प्रतिनिधित्व करता है downvote बटन। (काम के उदाहरणों के लिए थोड़ा बाएं देखें।)

मान लें कि कोई मतदान सीमाएं प्रभावी नहीं हैं, इसलिए सभी क्लिक सही तरीके से पंजीकृत हैं।
प्रिंट या वापसी:

1या +1यदि पोस्ट समाप्त हो रहा है ऊपर की ओर।
0यदि पद समाप्त नहीं होता है तो मतदान नहीं किया जाएगा। ( -0और +0मान्य नहीं हैं)
-1 अगर पोस्ट को समाप्त किया जा रहा है।

पोस्ट उपयोगकर्ता से शून्य नेट वोटों के साथ शुरू होते हैं और बटन नेट वोटों को निम्नानुसार बदलते हैं:

Net Votes Before    Button Pressed    Net Votes After
1                   ^                 0
1                   v                 -1
0                   ^                 1
0                   v                 -1
-1                  ^                 1
-1                  v                 0

बाइट्स में सबसे छोटा कोड जीतता है।

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

[empty string] -> 0
^^ -> 0
^v -> -1
^ -> 1
v -> -1
v^ -> 1
vv -> 0
^^^ -> 1
vvv -> -1
^^^^ -> 0
vvvv -> 0
^^^^^ -> 1
vvvvv -> -1
^^^^^^ -> 0
vvvvvv -> 0
^^v -> -1
^v^ -> 1
^vv -> 0
vv^ -> 1
v^v -> -1
v^^ -> 0
^vvv^^vv^vv^v^ -> 1
^vvv^^vv^vv^v^^ -> 0
^vvv^^vv^vv^v^^^ -> 1
^vvv^^vv^vv^v^^v -> -1
^vvv^^vv^vv^v^^vv -> 0
^vvv^^vv^vv^v^^vvv -> -1
^vvvvvvvvvvvv -> 0
^^vvvvvvvvvvvv -> 0
^^^vvvvvvvvvvvv -> 0
vvv^^^^^^^^^^^^ -> 0
vv^^^^^^^^^^^^ -> 0
v^^^^^^^^^^^^ -> 0

code-golf arithmetic

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

14

क्या? कोई पक्ष मतदान नहीं? Geoborts और Seadrus दु: खी हैं

— ऑप्टिमाइज़र

25

प्रिय गुप्त एसई डेवलपर: आपके लिए साइट सुधार करने में अपने स्वयं के समुदाय को सफलतापूर्वक धोखा देने के लिए बधाई ...;)

— 9 से

1

मैं अब थोड़ी देर के लिए उदाहरण तालिका में अभिनय कर रहा हूं और मुझे अभी भी परीक्षा के मामले नहीं आते हैं। 1 के स्कोर के साथ एक पोस्ट अप-वोट किया जाता है और इसका स्कोर 0. होता है और 0 के स्कोर के साथ एक पोस्ट को 1 का स्कोर मिलता है। 1 का स्कोर करने के लिए मतदान किया। तो ^चरित्र एक -1, +1 या +2 स्कोर परिवर्तन का कारण बन सकता है? क्या मैं घना हूं? क्या चल रहा है?

— ब्रैड

4

@ ब्रैड मैं सुझाव देता हूं कि आप कुछ वास्तविक पोस्ट के साथ क्रियाओं का प्रयास करें (उदाहरण के लिए यह प्रश्न)। एक पोस्ट अपवोट करने से आप पहले से ही अपवोट को हटा देते हैं। डाउनवोटिंग के साथ भी।

— केल्विन के शौक

6

मुझे आश्चर्य है कि इस सवाल पर वास्तविक समय के वोट क्या थे। मैं बहुत से लोगों को शर्त लगाने के लिए तैयार हूं, जिन्होंने इस मामले को एक परीक्षण मामले के रूप में इस्तेमाल किया है।

— माइकइलियार

35

गोल> <> 0.3.11 , 13 12 11 बाइट्स

iEh`^=:@)+M

इसे ऑनलाइन आज़माएं । भले ही यह अगले अद्यतन में ठीक काम करेगा, मैंने इसे केवल मामले में 0.3.11 के रूप में सूचीबद्ध किया है।

व्याख्या

i               Read char
 Eh             If EOF, halt and output top of stack as num
   `^=          Push 1 if char is ^, else 0
      :@        Dup and rotate, giving [is^ is^ votecount]
        )       Compare greater than, pushing 1 or 0 as appropriate
         +M     Add and subtract 1

ध्यान दें कि @पहली पुनरावृत्ति के लिए वोट की गिनती शुरू करने के लिए स्टैक के नीचे से 0 का पहला उपयोग खींचता है

एक पूर्ण तालिका के साथ वर्णन करने के लिए:

Votes before    Button    Is ^?    Compare <    Add     Subtract 1
     1            ^         1         0          1          0
     1            v         0         0          0         -1
     0            ^         1         1          2          1
     0            v         0         0          0         -1
    -1            ^         1         1          2          1
    -1            v         0         1          1          0

— Sp3000
स्रोत

1

.... डांग! अच्छा है!

— एल'एंडिया स्ट्रोमैन

22

x86 मशीन कोड, 24 बाइट्स

31 C0 8A 11 84 D2 75 07 C0 E0 02 C0 F8 06 C3 41 38 C2 74 EC 88 D0 EB EA

यह फास्टकॉल कॉलिंग कन्वेंशन का उपयोग करने वाला एक फ़ंक्शन है, जो एक स्ट्रिंग लेता है और 8-बिट पूर्णांक देता है।

मैंने इसे निम्नलिखित सी प्रोग्राम के साथ परीक्षण किया, जिसे 32-बिट मोड के लिए संकलित किया जाना चाहिए।

#include <stdio.h>
#include <inttypes.h>

 __attribute__ ((aligned (16))) const unsigned char fun[] = {

    0x31,  //xor eax,eax
        0xC0,
    0x8A, //mov [ecx],dl
        1 | 2<<3,
    0x84, //test dl, dl
        0xC0 | 2<<3 | 2,
    0x75, // jnz
        7,
    0xC0, //shl al 2
        0xC0 | 4<<3,
        2,
    0xC0, //sar al 6
        0xC0 | 7<<3,
        6,
    0xC3, //ret
    0x41, //inc ecx
    0x38, //cmp al,dl
        0xC0 | 2,
    0x74, //je
        -20,
    0x88, //mov dl,al
        0xC0 | 2<<3,
    0xEB, //jmp
        -22,
};

int main()
{
    __fastcall int8_t (*votesimulator)(char*) = fun;
    char* s[] = {
        "",
        "^^",
        "^v",
        "^",
        "v",
        "v^",
        "vv",
        "^^^",
        "vvv",
        "^^^^",
        "vvvv",
        "^^^^^",
        "vvvvv",
        "^^^^^^",
        "vvvvvv",
        "^^v",
        "^v^",
        "^vv",
        "vv^",
        "v^v",
        "v^^",
        "^vvv^^vv^vv^v^",
        "^vvv^^vv^vv^v^^",
        "^vvv^^vv^vv^v^^^",
        "^vvv^^vv^vv^v^^v",
        "^vvv^^vv^vv^v^^vv",
        "^vvv^^vv^vv^v^^vvv",
        "^vvvvvvvvvvvv",
        "^^vvvvvvvvvvvv",
        "^^^vvvvvvvvvvvv",
        "vvv^^^^^^^^^^^^",
        "vv^^^^^^^^^^^^",
        "v^^^^^^^^^^^^",
    };

    for(int i = 0; i < sizeof(s)/sizeof(*s); i++)
        printf("%d\n", votesimulator(s[i]));

    printf("\n%d\n", sizeof(fun));
    for(int i = 0; i < sizeof(fun); i++)
        printf("%02X ", fun[i]);
    return 0;
}

— feersum
स्रोत

क्या यह अनुमति है? मेरा मतलब है कि मैं सी में पूरी बात भी लिख सकता हूं और सिर्फ यह कह सकता हूं कि सी कोड को कार्य करने के लिए एक खाली फाइल की आवश्यकता है, जबकि मेरा कोड यह कह रहा है कि मेरा कोड 0bytes बन रहा है। आपके समाधान से यह अलग क्यों है?

— ज़ैबिस

@Zaibis क्योंकि मेरे समाधान में वह कोड है जो चुनौती को हल करता है? Meta.codegolf.stackexchange.com/a/1071/30688 देखें ।

— feersum

21

जावास्क्रिप्ट (ईएस 7), 47 46 44 43 37 36 बाइट्स

^{पार किया 44 अभी भी नियमित है 44 :(}

s=>[for(x of s)s=x<"v"?s!=1:!~s-1]|s

में एक कुल चल रहा रखता है s। का उपयोग करता है for ofस्ट्रिंग और अद्यतन में हर किरदार से अधिक पुनरावृति करने के लिए लूप sवर्तमान चरित्र और पिछले मूल्य के आधार पर।

संपादन: गोल्फ ~s&&-1से !~s-1। यह अभिव्यक्ति 0 के sबराबर है अगर -1 और -1 के बराबर है। सहेजे गए 6 बाइट @nderscore की बदौलत।

अभिव्यक्ति कैसे काम करती है:

 ~s    // Bitwise inverse. ~s==0 only if s==-1
!      // Logical negate. Casts to boolean. Equivalent to s==-1
   -1  // Subtract. Casts to number so true-1 is 1-1 and false-1 is 0-1

— intrepidcoder
स्रोत

3

मैं इसे 37 बाइट्स तक ले गया:v=>[for(x of v)v=x<"v"?~~v<1:!~v-1]|v

— nderscore

@nderscore अरे, यह बहुत अच्छा है। मुझे लगा कि अतिरिक्त चर अनाड़ी था, लेकिन मुझे नहीं लगा कि मैं इसे खत्म कर सकता हूं।

— intrepidcoder

1

पार किया 44 अभी भी नियमित है 44 ...

— R '

सरणी से हटाए गए सरणी समझ नहीं थे?

— मेयरमोनी

8

CJam, 18 14 बाइट्स

डेनिस द्वारा महत्वपूर्ण सुधार के साथ अद्यतन संस्करण:

0'jqf{-g_@=!*}

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

स्पष्टीकरण:

0     Start value for running total.
'j    Push character between '^ and 'v for use in loop.
q     Get input.
f{    Apply block with argument to all input characters.
  -     Subtract character from 'j. This will give -12 for '^, 12 for 'v.
  g     Signum, to get 1 for '^, -1 for 'v, which is our increment value.
  _     Copy increment value.
  @     Bring running total to top.
  =     Compare. This will give 1 for the -1/-1 and 1/1 combinations where the new
        running total is 0. Otherwise, the new running total is the increment value.
  !     Negate to get 0 for the -1/-1 and 1/1 cases.
  *     Multiply result with increment value, to get new running total.
}     End block applied to input characters.

— रेटो कोराडी
स्रोत

7

Befunge 93 - 55 बाइट्स

vj#p01:>#<:1+|
>~:10g-|v:g25<
^p01"j"<1^   <
./*34-g0<@

52 वर्ण और 3 नई रेखाएँ।

इस दुभाषिए पर परीक्षण किया गया ।

jसे समान दूरी पर है ^और vइसलिए यह नहीं बल्कि अंतरिक्ष लेने वाली सशर्त, की तुलना में, अंत में गणित रूपांतरण बनाने के लिए प्रयोग किया जाता है ascii में।

— लीनुस
स्रोत

7

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

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

यह प्रोग्राम इनपुट के प्रत्येक बाइट को लेता है और अंतिम के मुकाबले इसकी तुलना करता है। यदि वे समान हैं, तो यह इनपुट को दूर फेंकता है और "0" को "पिछले इनपुट" के रूप में संग्रहीत करता है, अन्यथा यह इसे सामान्य रूप से बचाता है।

यदि अंतिम परिणाम है v, तो यह प्रिंट करता है -। यदि अंतिम परिणाम गैर-शून्य था, तो एक खाली सेल में 1 जोड़ा जाता है। अंत में, उस सेल में 48 जोड़ा जाता है और इसे प्रिंट किया जाता है।

— undergroundmonorail
स्रोत

7

जावास्क्रिप्ट ईएस 6, 91 48 चार्ट

s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)]

स्पष्टीकरण: undefinedद्वारा समाप्त होता है d।

परीक्षा:

` -> 0
^^ -> 0
^v -> -1
^ -> 1
v -> -1
v^ -> 1
vv -> 0
^^^ -> 1
vvv -> -1
^^^^ -> 0
vvvv -> 0
^^^^^ -> 1
vvvvv -> -1
^^^^^^ -> 0
vvvvvv -> 0
^^v -> -1
^v^ -> 1
^vv -> 0
vv^ -> 1
v^v -> -1
v^^ -> 0
^vvv^^vv^vv^v^ -> 1
^vvv^^vv^vv^v^^ -> 0
^vvv^^vv^vv^v^^^ -> 1
^vvv^^vv^vv^v^^v -> -1
^vvv^^vv^vv^v^^vv -> 0
^vvv^^vv^vv^v^^vvv -> -1
^vvvvvvvvvvvv -> 0
^^vvvvvvvvvvvv -> 0
^^^vvvvvvvvvvvv -> 0
vvv^^^^^^^^^^^^ -> 0
vv^^^^^^^^^^^^ -> 0
v^^^^^^^^^^^^ -> 0`
.split("\n").map(s => s.split(" -> "))
.every(([s,key]) => (s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)])(s)==key)

उत्तर इतिहास:

s=>({'':0,'^':1,v:-1}[s.replace(/^(.)\1(\1\1)*(?=.?$)|.*(.)(((?!\3).)\5)+/,"").substr(-1)])
s=>~~{'^':1,v:-1}[s.replace(/^(.)\1(\1\1)*(?=.?$)|.*(.)(((?!\3).)\5)+/,"").substr(-1)]
s=>~~{'^':1,v:-1}[s.replace(/^.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").substr(-1)]
s=>~~{'^':1,v:-1}[s.replace(/^.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/.*(.)(((?!\1).)\3)+|((.)\5)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/((.)\2)+/g,"!").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g,"!").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g,0).slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)]

— Qwertiy
स्रोत

7

अजगर 2, 49

lambda s:reduce(lambda x,c:cmp(cmp('u',c),x),s,0)

अपडेट फ़ंक्शन के माध्यम से Iterates

lambda x,c:cmp(cmp('u',c),x)

जो वर्तमान मतगणना xऔर नए चरित्र को लेता है और cनए मत की गणना करता है।

विचार अजगर 2 के उपयोग करने के लिए है cmpसमारोह है, जो अपने दो आर्ग तुलना करता है और देता है -1, 0, 1के लिए <, ==, >क्रमशः। भीतर वाला cmp('u',c)देता -1है vऔर उसके 1लिए ^; उनके बीच के किसी भी चरित्र के लिए पर्याप्त है 'u'। बाहरी एक तो है कि तुलना xहै, जो देता है cmp(1,x)के लिए ^और cmp(-1,x)के लिए vहै, जो सही मान हैं।

प्रत्यक्ष पुनरावृत्ति 3 वर्णों लंबा (52) था, हालांकि input()उद्धरण के साथ लेने पर एक चार लघु (48) होगा ।

x=0
for c in raw_input():x=cmp(cmp('u',c),x)
print x

सबसे अच्छा पुनरावर्ती कार्य जो मुझे मिला वह एक चार लंबा (50) था

f=lambda s:len(s)and cmp(cmp('u',s[-1]),f(s[:-1]))

— XNOR
स्रोत

5

प्रोलॉग, 159 152 बाइट्स

कोड:

v(1,^,0).
v(1,v,-1).
v(0,^,1).
v(0,v,-1).
v(-1,^,1).
v(-1,v,0).
r(X,[H|T]):-T=[],v(X,H,Z),write(Z);v(X,H,Z),r(Z,T).
p(S):-atom_chars(S,L),r(0,L).

इसे स्वयं परखें:
ऑनलाइन दुभाषिया यहाँ

उदाहरण

>p("^vvv^^vv^vv^v^^vvv").
-1

>p("^vvv^^vv^vv^v^")
1

संपादित करें: OR के साथ r-clauses को एकीकृत करके 7 बाइट्स सहेजे गए।

— Emigna
स्रोत

हम्म। ऐसा लगता है कि आप फ़ंक्शंस को परिभाषित करने के बजाय ऑपरेटरों को पुनर्परिभाषित करके बहुत कुछ बाइट्स बचा सकते हैं (यदि वह पीपीसीजी के नियमों के तहत एक फ़ंक्शन के रूप में गिना जाता है?)

— एएससीआईआई-केवल

@ ASCII- केवल: हाँ। जब मैंने यह लिखा था तो उस तरकीब को सीखा नहीं था :)

— एमिग्ना

4

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

0re`W=(2%*c'a--g

यदि लागू हो, तो यह 0 प्रिंट करने के बाद क्रैश हो जाएगा । जावा इंटरप्रेटर के साथ त्रुटि को दबाया जा सकता है। यदि आप इसे ऑनलाइन आज़माते हैं , तो सब कुछ अनदेखा करें लेकिन आउटपुट की अंतिम पंक्ति।

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

0                e# Push a 0 on the stack.
 r               e# Read a whitespace-separated token from STDIN.
  e`             e# Perform run-length encoding.
    W=           e# Select the last [repetitions character] pair.
                 e# This will fail for the empty string, so the
                 e# interpreter will print the stack's only element (0).
      (          e# Shift out the number of repetitions.
       2%        e# Compute its parity.
         *       e# Create a string, repeating the character 1 or 0 times.
          c      e# Cast to character.
                 e# This will fail for a zero-length string, so the
                 e# interpreter will print the stack's only element (0).
           'a-   e# Subtract the character 'a' from '^' or 'v'.
              -  e# Subtract the difference (integer) from 0.
               g e# Apply the sign function.

— डेनिस
स्रोत

4

पायथन 2, 177 159 72 बाइट्स

अभी भी इस कोड गोल्फ बात करने के लिए नया थोड़े।

def v(s): 
 c=0 
 for i in s:c=((0,1)[c<1],(0,-1)[c>-1])[i=="^"] 
 return c

संपादित करें: गलत व्यवहार तय किया।
संपादित करें 2: बहुत सारे बाइट्स को बंद करने के लिए @MorganThrapp धन्यवाद।

— DJgamer98
स्रोत

अजीब। मैं इस पर गौर करूंगा।

— डीजेगैमर 98

बाहर मुड़ता है मैं सही ^ फिर v व्यवहार (और इसके विपरीत) भूल गया।

— डीजेगमर 9898

पोस्ट को उसके निश्चित होने तक हटाना।

— डीजेगमर 9898

यह अब काम करना चाहिए।

— डीजेगमेर 98

1

यह इंडेंटेशन बिल्कुल सही नहीं है, मैंने सिर्फ सही इंडेंटेशन के साथ एक एडिट का सुझाव दिया है। आप टिप्पणियों में कोड को प्रारूपित नहीं कर सकते, इसलिए यह मेरा गलत था।

— मॉर्गन थ्रैप

4

जावास्क्रिप्ट (ईएस 6), 64 59 58 52 बाइट्स

f=v=>(t=/\^*$|v*$/.exec(v)[0]).length*(t<'v'?1:-1)%2

यह अवलोकन पर आधारित है कि केवल पुनरावृत्ति का अंतिम खिंचाव ( ^या तो v) परिणाम को प्रभावित करता है।

6 बाइट्स से गोल्फ के लिए नील को धन्यवाद ।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

1

आपको कैप्चर की आवश्यकता क्यों है? मुझे लगता है f=v=>(t=/\^*$|v*$/.exec(v)[0]).length*(t<'v'?1:-1)%2।

— नील

@ नील: मुझे सरणी के बारे में पता नहीं है कि पहले तत्व में >या <ऑपरेटर के लिए मजबूर किया जा रहा है । युक्तियों के लिए धन्यवाद

— n̴̖̋h̷͉̃a̷̭̿h̷̰̀ĥ̷̳d

किसी भी प्रकार का जोर-जबरदस्ती शामिल नहीं है, मैंने केवल उसे स्थानांतरित किया है [0]जो आपको भ्रमित कर सकता है।

— नील

@ नील: ओह, मैं वास्तव में भ्रमित हूँ। मुझे महसूस नहीं हुआ कि आपने इसे अंदर स्थानांतरित कर दिया है, मुझे लगा कि यह ऐसा था f=v=>(t=/\^*$|v*$/.exec(v))[0].length*(t<'v'?1:-1)%2, जो सरणी के साथ प्रकार के जबरदस्ती के कारण काम करता है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

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

1%'^'=0
_%'^'=1
1%_=-1
_%_=0
v=foldl(%)0

— लीफ विलर्ट्स
स्रोत

आप fएक इनफ़िक्स फ़ंक्शन के रूप में परिभाषित करके सभी रिक्त स्थान काट सकते हैं %। इसके अलावा, मुझे लगता है कि एक vहो सकता है _।

— xnor

वास्तव में, यह नहीं देता है -1के लिए vvके बजाय 0?

— xnor

ओह, मैं हमेशा इन्फिक्स के बारे में भूल जाता हूं। मौके के लिए धन्यवाद, आंतरिक उलट याद किया।

— बजे लीफ विलर्ट्स

1%_=-1 _%_=012 वर्णों के साथ तीसरी पंक्ति (15 वर्ण) को प्रतिस्थापित करके 3 वर्ण सहेजें ।

— केविन रीड ने

ठीक है ठीक है, अब वह छोटा हो गया है।

— लेइफ विलर्ट्स

4

स्काला, 75 बाइट्स

def d(s:String)=s./:(0){case(1,94)|(-1,'v')=>0;case(_,94)=> 1;case _=> -1}

कार्यान्वित फ़ंक्शन के लिए परीक्षण करें।

  object Util {
        def d(s: String) = s./:(0) { 
    case (1, '^') | (-1, 'v') => 0
    case (_, '^') => 1
    case (_, _) => -1
  }      
      def main(s: Array[String]): Unit = {
        println("1 == " + d("^vvv^^vv^vv^v^^^"))
        println("1 == " + d("^vvv^^vv^vv^v^"))
        println("-1 == " + d("^vvv^^vv^vv^v^^vvv"))
        println("0 == " + d("^^^vvvvvvvvvvvv"))
        println("0 == " + d("vvv^^^^^^^^^^^^"))
      }
    }

— वीजी
स्रोत

1

PPCG में आपका स्वागत है! क्या आप कृपया एक स्पष्टीकरण और / या एक असम्बद्ध संस्करण जोड़ सकते हैं?

— एडिसन क्रम्प

3

एपीएल, १,

(⊣×≠)/⌽0,2-'^ '⍳⍞

कांटा संकेतन के बिना व्याख्याताओं के लिए (जैसे कि जीएनयू एपीएल), यह {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19) होगा। यह संभव समाधानों का सबसे उबाऊ है क्योंकि यह समस्या की परिभाषा से सीधे काम करता है।

— user46915
स्रोत

3

रूबी, 41 35 बाइट्स

रेगेक्स। केवल अंतिम बटन दबाया गया दिलचस्प है, इसलिए उस की रन-लंबाई की जांच करें। तब की तुलना "a"(या के बीच किसी भी पत्र ^और v) प्राप्त करने के लिए 1या -1।

->s{s[/(.?)\1*$/].size%2*(?a<=>$1)}

— daniero
स्रोत

3

सी # 6, 18 + 80 = 98 बाइट्स

आवश्यक है:

using System.Linq;

वास्तविक कार्य:

int S(string v)=>v.Split(new[]{"^^","vv"},0).Last().Length<1?0:v.Last()<95?1:-1;

यह कैसे काम करता है: कोड पहले आखिरी ^^या उससे पहले सब कुछ हटा देता है vv। यह सामग्री प्रासंगिक नहीं है क्योंकि एक ही बटन पर दो बार क्लिक करने से आपका वोट हमेशा रद्द रहेगा। यह पर बंटवारे से करता है ^^और vvऔर अंतिम आइटम ले रही। यदि यह आइटम एक रिक्त स्ट्रिंग ( .Length<1) है, तो फ़ंक्शन वापस आ जाता है 0क्योंकि सभी मतदान रद्द कर दिया गया है। यदि स्ट्रिंग इसे खाली नहीं करती है, तो यह मूल स्ट्रिंग के अंतिम चार्ट को देखता है: यह सभी पिछले वोटों को ओवरराइड करेगा। यदि चार कोड 95 से छोटा है, तो यह 94 होगा ^, इसलिए यह वापस आ जाता है 1, अन्यथा -1।

— ProgramFOX
स्रोत

3

पायथन 2.7, 79 75 88

s=input()
print (0,(1,-1)[s[-1]=='v'])[len(s[s.rfind(('v^','^v')[s[-1]=='v'])+1:])%2!=0]

— wnnmaw
स्रोत

यह वास्तव में कुछ भी नहीं छापता है।

— मॉर्गन थ्रैप

मेरे दुभाषिया में इसे चलाने से, यह

— wnnmaw

ऐसा इसलिए है क्योंकि आप इसे REPL में चला रहे हैं। आपको एक पूर्ण कार्यक्रम प्रदान करने की आवश्यकता है जो REPL के बाहर काम करेगा।

— मॉर्गन थ्रैप

इसके अलावा, आप (-1,(1,0)[n==0])[n>0]10 बाइट्स को बचाने के लिए उस टर्नरी को छोटा कर सकते हैं । इसके अलावा, उपयोग न करें a=str.count। यह वास्तव में आपकी लागत 4 बाइट्स है।

— मॉर्गन थ्रैप

वह n = 0 के लिए -1 का उत्पादन करता है, लेकिन शांत वाक्यविन्यास

— wnnmaw

2

मिन्कोलांग 0.11 , 28 22 बाइट्स

0$I2&N."j"o-34*:dr=,*!

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

व्याख्या

0                         Push a 0 (running total)
 $I                       Push length of input
   2&N.                   Output as integer and stop if this is 0
       "j"                Push 106
          o               Take character from input (94 for ^, 118 for v)
                          <<so ^ becomes +12 and v becomes -12>>
           -              Subtract
            34*:          Divide by 12
                d         Duplicate top of stack
                 r        Reverse stack
                  =,      Push 0 if equal, 1 otherwise
                    *     Multiply
                          <<this handles two of the same vote in a row>>
                     !    Unconditional trampoline (jumps the 0 at the beginning)

ध्यान दें कि N.अंत में कोई भी नहीं है । ऐसा इसलिए है क्योंकि मैंने इसे शुरुआत के आसपास लपेटने दिया। जब इनपुट खाली होता है, तो अंतिम टैली पूर्णांक के रूप में आउटपुट होता है और प्रोग्राम बंद हो जाता है।

— एलेंडिया स्ट्राटन
स्रोत

2

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

ut+Jq\^H>JGzZ

— isaacg
स्रोत

2

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

Mod[#,2]Sign@#&@Tr@Last@Split@StringCases[#,{"^"->1,_->-1}]&

— alephalpha
स्रोत

@#&? यही कारण है कि बेकार है (जब तक Sequenceरों शामिल कर रहे हैं, लेकिन Sequenceरों शामिल नहीं कर रहे हैं।

— CalculatorFeline

2

शेप स्क्रिप्ट , 26 बाइट्स

"^"$"0>1@-"~"v"$"0<1-"~0@!

यह कैसे जागता है:

"^"$     split input on '^'
"
  0>         Check if the number is more than 0 (1 if true, 0 if false).
  1@-        subtract the answer from one.
"~       Join it back together, with this string in place of '^'
"v"$     Split on 'v'
"        
  0<         Check if 0 is more than the number (1 if true, 0 if false).
  1-         subtract one from the results
"~       Join it back together, with this string in place of 'v'
0@       add a zero to the stack and place it under the string just built. 
!        run the string as code

— MegaTom
स्रोत

2

C # 6, 18 + 97 95 = 115 113 बाइट्स, कोई स्ट्रिंग विधियाँ, अत्यधिक LINQ नहीं

int v(string s)=>(int)s.Reverse().TakeWhile((c,i)=>i<1||c==s[s.Length-i])?.Sum(x=>x<95?1:-1)%2;

सच में से पहले होने का हकदार है

using System.Linq;

का उपयोग करने का विचार आया x<95?1:-1बजाय x=='^'?1:-1से ProgramFOX के जवाब

संयोग:

जो ट्विक मैंने चुराया है वह 95 की तुलना करने का उपयोग करता है - बाइट काउंट का उपयोग करते हुए स्टेटमेंट को छोड़कर कहा जाता है
कुल बाइट काउंट के अंकों का योग, रोमन अंक के रूप में लिखे गए कुल बाइट काउंट के अंकों की संख्या के बराबर होता है

— सोरेन डी। Ptøus
स्रोत

2

सी: 67 66 बाइट्स

golfed:

void f(char *v){int i=0,c,s=0;for(;v[i]!=0;i++){v[i]>94?s--:s++;}}

ungolfed:

void f (char *v)
{
    int i = 0, c, s = 0;

    for (;v[i]!=0;i++)
    {
        v[i] > 94 ? s-- : s++;
    }
}

— Zaibis
स्रोत

इससे परिणाम वापस नहीं आता है। यह सभी परीक्षणों को पास नहीं करता है।

— रॉबर्ट आंद्रेजुक

2

जाओ, 179 बाइट्स

एक अत्यंत भोला समाधान।

package main
import(."fmt"."strings")
func main(){a:=""
i:=0
Scanln(&a)
b:=Split(a,"")
for _,e:=range b{switch i{case 1:i--
case 0:if e=="^"{i++}else{i--}
case-1:i++}}
Println(i)}

Ungolfed:

package main

import (
    ."fmt"
    ."strings"
)

func main() {
    a := ""
    i := 0
    Scanln(&a)
    b := Split(a, "")
    for _, e := range b {
        switch i {
        case 1:
            i--
        case 0:
            if e == "^" {
                i++
            } else {
                i--
            }
        case -1:
            i++
        }
    }
    Println(i)
}

— बिल्ली
स्रोत

2

पर्ल 5, 41 बाइट्स

40 बाइट्स, प्लस 1 के लिए -p

/(.)\1*$/;$_=((length$&)%2)*($1=~v?-1:1)

/(.)\1*$/;इनपुट स्ट्रिंग की तुलना रेगेक्स से करता है /(.)\1*$/, अर्थात यह देखता है कि क्या यह एकल वर्ण के साथ समाप्त होता है, जो कुछ संख्या में number1 बार दोहराया जाता है।

यदि ऐसा है, $&पूरे पुनरावृत्ति स्ट्रिंग है और $1चरित्र है; अन्यथा (यानी इनपुट स्ट्रिंग खाली है), वे दो चर खाली स्ट्रिंग हैं।

$1=~v?-1:1$1रेगेक्स से तुलना करता है vऔर −1 देता है अगर यह मेल खाता है और 1 अन्यथा।

और उस multip 1 को गुणा करें (length$&)%2, $&मोडुलो 2 की लंबाई ।

— msh210
स्रोत

2

05AB1E , 14 12 11 बाइट्स

Îvy'^QDŠ‹+<

पोर्ट ऑफ @ Sp3000 का गोल> <> उत्तर ।

नोट: @Grimy ने पहले ही 05AB1E के लिए एक छोटा 8 बाइट्स विकल्प पोस्ट किया है , इसलिए उसे अपवोट करना सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Î            # Push 0 (later mentioned as `r`) and the input-string
 v           # Loop over the characters of the input:
  y'^Q      '#  Does the current character equal "^"?
             #  (results in 1 for truthy; 0 for falsey - later mentioned as `b`)
      D      #  Duplicate this result `b`
       Š     #  Triple swap (`r`,`b`,`b`) to (`b`,`r`,`b`)
        ‹    #  Check if the boolean `b` is smaller than the result-integer `r`
             #  (again results in 1 for truthy; 0 for falsey)
         +   #  Add them together
          <  #  Decrease this by 1
             # (Implicitly output the result-integer `r` after the loop)

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

2

05AB1E , 8 बाइट्स

γ¤®öÓÆ.±

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

एक ही लंबाई के साथ वैकल्पिक समाधान: uγ¤®öÓÆ(, γ¤®ögÓÆ(।

— साँवला
स्रोत

1

यह काम नहीं करता है। न तो आपके पोस्ट किए गए कोड और न ही TIO लिंक में कोड (जो अलग है) वोटों को ध्यान में रखते हैं जैसे^^ -> 0

— Emigna

@Eignigna इसे इंगित करने के लिए धन्यवाद! मैंने कोड तय किया, यह अभी भी 8 बाइट्स है।

— मटमैला

1

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

'^_]r+e`W=(2%\(i99-g@*W*

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

मैं डेनिस के उत्तर से लिया गया सब g(साइन फंक्शन) है।

— geokavel
स्रोत

1

रूबी, ४३

->s{a=0
s.bytes{|i|b=9-i/11;a=a!=b ?b:0}
a}

9-i/11^(94) या v(118) की आस्की कोड दिए जाने पर 1 या -1 का मूल्यांकन करता है

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

f=->s{a=0
s.bytes{|i|b=9-i/11;a=a!=b ?b:0}
a}

g=gets.chomp
puts f[g]

— स्तर नदी सेंट
स्रोत

स्टैक एक्सचेंज वोट सिम्युलेटर

गोल> <> 0.3.11 , 13 12 11 बाइट्स

व्याख्या

x86 मशीन कोड, 24 बाइट्स

जावास्क्रिप्ट (ईएस 7), 47 46 44 43 37 36 बाइट्स

CJam, 18 14 बाइट्स

Befunge 93 - 55 बाइट्स

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

जावास्क्रिप्ट ईएस 6, 91 48 चार्ट

अजगर 2, 49

प्रोलॉग, 159 152 बाइट्स

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

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

पायथन 2, 177 159 72 बाइट्स

जावास्क्रिप्ट (ईएस 6), 64 59 58 52 बाइट्स

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

स्काला, 75 बाइट्स

एपीएल, १,

रूबी, 41 35 बाइट्स

सी # 6, 18 + 80 = 98 बाइट्स

पायथन 2.7, 79 75 88

मिन्कोलांग 0.11 , 28 22 बाइट्स

व्याख्या

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

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

शेप स्क्रिप्ट , 26 बाइट्स

C # 6, 18 + 97 95 = 115 113 बाइट्स, कोई स्ट्रिंग विधियाँ, अत्यधिक LINQ नहीं

सी: 67 66 बाइट्स

जाओ, 179 बाइट्स

पर्ल 5, 41 बाइट्स

05AB1E , 14 12 11 बाइट्स

05AB1E , 8 बाइट्स

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

रूबी, ४३