अनुदेश

एक अज्ञात इनपुट स्ट्रिंग को देखते हुए iदोनों में से किसी एक मूल्य के साथ सिर या पूंछ , वापसी 1के लिए सिर या -1के लिए पूंछ कम से कम कोड के साथ।

नमूना नहीं गोल्फ कोड (55b):

if(i == "heads"){
    print(1);
}else{
    print(-1);
}

नमूना गोल्फ कोड (16 बी):

print("t">i||-1)

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

code-golf string

— जुआन कोर्टेस
स्रोत

14

PPCG में आपका स्वागत है! यह एक दिलचस्प चुनौती बनने के लिए बहुत सरल है। भविष्य में, सैंडबॉक्स में चुनौतियों को पोस्ट करने पर विचार करें , जहां उन्हें लाइव पोस्ट करने से पहले प्रतिक्रिया मिल सकती है।

— एलेक्स ए

1

6 जवाब, वास्तव में इतनी बुरी चुनौती नहीं है। फिर से कोशिश करें

— edc65

4

4 अपवोट्स और 5 डाउनवोट्स पर, आपका प्रश्न वास्तव में अलोकप्रिय नहीं था; यह सिर्फ मिश्रित समीक्षाएँ मिलीं। जबकि हाथ में काम थोड़ा बुनियादी है, यह अच्छी तरह से परिभाषित है और अब तक 7 उत्तरों को आकर्षित करता है जो कई अलग-अलग दृष्टिकोणों की सुविधा देते हैं। पहली कोशिश के लिए बुरा नहीं है।

— डेनिस

7

मैं अभी उलझन में हूँ, कल -4, अब +4, यह निश्चित रूप से स्टैकओवरफ़्लो नहीं है: पी

— जुआन कोर्टेस

10

मैं उम्र के लिए इस तरह की एक छोटी चुनौती का इंतजार कर रहा हूं, ज्यादातर चुनौतियां मेरे जैसे नौसिखिए के लिए बहुत लंबी और जटिल हैं।

— सीन लाथम

11

CJam, 4 बाइट्स

I'e#

मान लेता है कि चर Iइनपुट रखता है, क्योंकि iCJam में मान्य पहचानकर्ता नहीं है।

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

यह जावास्क्रिप्ट कोड के बराबर है I.indexOf('e')।

— डेनिस
स्रोत

इस चुनौती के लिए शायद अपराजेय है।

— एलेक्स ए

1

क्षमा करें, मैंने आवश्यकताओं को पर्याप्त नहीं समझा और इस प्रश्न के साथ स्वयं को मूर्ख बना लिया। मैं वापस जाऊंगा और अब छिप जाऊंगा

— जुआन कोर्टेस

आप इसमें शामिल क्यों नहीं हैं p? क्या यह सीजेएम में मानक नहीं है?

— टिम

@ टीम सीजेएम हमेशा कार्यक्रम में स्टैक सामग्री को स्वचालित रूप से प्रिंट करता है।

— मार्टिन एंडर

2

@ समय: प्रश्न 1 या -1 को वापस करने के लिए कहता है , इसलिए मैंने माना कि संख्या को स्टैक पर छोड़ना ठीक रहेगा। मैंने पर्मलिंक को दिखाने के लिए संपादित किया है जिसकी pआवश्यकता नहीं है।

— डेनिस

17

सी, 18 बाइट्स

बहुत आसान है, लेकिन यह सिर्फ मनोरंजन के लिए करते हैं ...

puts("-1"+*i/8%2);

स्ट्रिंग को देखते हुए char *iयह 1 के लिए heads-1 और -1 के लिए प्रिंट करता है tails, जिसमें नई लाइन होती है।

व्याख्या

सी में, "-1" + 11 चरित्र को इंगित करता है, इसलिए यह उसी के समान है "1"। आइए पहले पात्रों पर एक नज़र डालें:

"heads"[0] = 'h' = 104 = 0b01101000
"tails"[0] = 't' = 116 = 0b01110100

यदि हम बिट्स को शून्य से शुरू करने वाले सबसे दाहिने भाग से गिनते हैं, तो बिट 3 में 1 headsऔर 0 में tails: "-1"सही स्ट्रिंग देने के लिए इसे संक्षेप में लिखें । यह इस तरह दिख रहा है:

"-1" + ((i[0] >> 3) & 1)

अब, कुछ बाइट्स को बचाने के लिए पावर-ऑफ-टू डिवीजन के i[0]साथ *iऔर सही शिफ्ट के साथ विकल्प । इसके अलावा बेकार कोष्ठक निकालें:

"-1" + (*i / 8 & 1)

अब, & 1के साथ प्रतिस्थापित किया जा सकता है % 2। वर्ण गणना समान है, लेकिन मापांक में उच्च प्राथमिकता है, जिससे कोष्ठकों को छोड़ दिया जा सकता है। व्हाट्सएप निकालें:

"-1"+*i/8%2

बोनस

मुझे लगता है कि C में पूर्णांक 1 या -1 (स्ट्रिंग नहीं) पाने का सबसे छोटा तरीका है:

18-*i/6

स्पष्टीकरण:

'h' = 104
't' = 116

('h' + 't') / 2 = 110
110 - 'h' =  6
110 - 't' = -6

(110 - 'h') / 6 =  1
(110 - 't') / 6 = -1

Apply distributive property (integer division):
18 - 'h' / 6 =  1
18 - 't' / 6 = -1

— एंड्रिया बियोन्डो
स्रोत

1

सुंदर, इसे प्यार करें

— जुआन कोर्टेस

11

रूबी, 8 (आउटपुट के बिना 6)

p ?t<=>i

रॉकेट ऑपरेटर!

— histocrat
स्रोत

स्पष्ट रूप से नौकरी के लिए सही उपकरण।

— Primo

9

PHP - 11 बाइट्स

<?=1-$i^=F;

यह काम करता है क्योंकि 'tails' ^ 'F'→ '2'और 'heads' ^ 'F'→ '.', जो जब पूर्णांक के रूप में टाइप किया जाता है 0।

आप निम्न तरीके से इस समाधान (या नीचे के किसी भी) का परीक्षण कर सकते हैं:

<?php foreach(['heads', 'tails'] as $i): ?>
 <?=1-$i^=F;
endforeach; ?>

Ideone लिंक

वैकल्पिक

15 : <?=1-md5($i)%3;
16 : <?=md5($i)[5]-5;
16 :<?=-crc32($i)%5;

— Primo
स्रोत

लघु संस्करण के साथ मुझे हमेशा 1 मिल रहा है, यह समझाने के लिए परवाह है कि यह XOR के साथ क्या करता है?

— जुआन कोर्टेस

@ JuanCortés मैंने एक स्पष्टीकरण, और Ideone का लिंक जोड़ा है।

— प्रिमो

2

अब वह बॉक्स के बाहर सोच रहा है!

— डेनिस

6

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

cos(πʳinString(Ans,"t

सीधा। "t" "tails" की स्थिति 1 में है, लेकिन "t" स्ट्रिंग "शीर्ष" में नहीं है, इसलिए inString (पूंछों के लिए 1 और सिर के लिए 0 लौटाता है।

यदि आपका कैलकुलेटर रेडियन मोड में है (जैसा कि किसी भी गणितज्ञ का होना चाहिए), इसमें केवल नौ बाइट्स लगते हैं:

cos(πinString(Ans,"t

ध्यान दें कि TI कैलकुलेटर का नाम स्ट्रिंग्स नहीं है, इसलिए इनपुट कैलकुलेटर के उत्तर चर में है। यह भी ध्यान दें कि लोअरकेस अक्षर दो बाइट्स हैं, इसलिए यह समाधान वास्तव में "हेड्स" शब्द की तुलना में कम मेमोरी लेता है।

— lirtosiast
स्रोत

यह कमाल का है। आपकी बाइट की गिनती बंद है, हालांकि - कॉस (,, ian और रेडियन प्रतीक सभी एक बाइट हैं, इसलिए यह वास्तव में 9 बाइट्स है।

— MI राइट

1

tऔर inString(प्रत्येक दो बाइट्स हैं।

— lirtosiast

ओह, मैं लोअरकेस अक्षरों के बारे में दो बाइट्स भूल गया हूं। तो कोई बात नहीं।

— एमआई राइट

5

विखंडन , 26 21 बाइट्स

O/';'1
"S@]_"-
R? <tL

मार्टिन (और उनके उत्कृष्ट जवाब यहाँ ) मेरे एक नई भाषा, और एक त्वरित गोल्फ से क्या बेहतर जगह जानने के लिए राजी कर लिया? यह लगभग निश्चित रूप से इष्टतम नहीं है, लेकिन हे, यह मजेदार था! एक बार जब मुझे इसके बारे में अच्छा महसूस होता है, तो मैं अनुरोध करने पर स्पष्टीकरण के कुछ रूप प्रदान कर सकता हूं।

— BrainSteel
स्रोत

4

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

print(i<'t')*2-1

— जेम्स विलियम्स
स्रोत

4

पायथ - 4 बाइट्स

 xz"e

सिर या पूंछ के साथ भागो । के रूप में iहै intPyth, इस का उपयोग करता है में zचर नाम है, जो किसी भी उपयोगकर्ता इनपुट शामिल है। यह पायथन के बराबर है print(z.find("e")), इसलिए @ डेनिस की विधि का उपयोग करता है।

— matsjoyce
स्रोत

4

VBA (एक्सेल), 12 बाइट्स

गोल्फ का एक शानदार सा नहीं है, लेकिन यह एक उचित प्रोग्रामिंग भाषा के पास कहीं भी पाने के लिए VBA के साथ प्रयास करने के लिए मजेदार है ...

?13-asc(i)/6

मैं स्ट्रिंग हूं, और यह सिर्फ पहले चरित्र के ASCII मूल्य का शोषण करता है, 6 से विभाजित और 13 से 1 या -1 देने के लिए प्रतिस्थापित किया जाता है। बहुत आसान।

उदाहरण तत्काल विंडो में चलता है (इनपुट चर सेट करने के लिए 10 अतिरिक्त बाइट्स):

i="Heads":?13-asc(i)/6
 1

— Shazback
स्रोत

4

सी, 22 बाइट्स

puts(*i>'h'?"-1":"1");

^{_{इस बारे में मुझे बताने के लिए क्रेडिट @TheE को जाता है !}}

स्पष्टीकरण:

यदि स्ट्रिंग का पहला वर्ण इससे अधिक है 'h', तो स्ट्रिंग "-1"मुद्रित होती है। अन्यथा, स्ट्रिंग "1"मुद्रित हो जाती है। ध्यान दें कि यह दृष्टिकोण एक अनुगामी न्यूलाइन वर्ण के साथ आता है।

पुराना संस्करण (25 बाइट्स):

printf("%d",*i>'h'?-1:1);

स्पष्टीकरण:

यदि स्ट्रिंग का पहला वर्ण इससे अधिक है 'h', तो -1 मुद्रित होता है। नहीं तो 1 छपा है।

— Spikatrix
स्रोत

मैंने अभी कहा कि पहले टी, मैं टाइप चार के रूप में उपयोग करता हूं, वास्तविक परिभाषा इस वापसी की तरह 1byte से अधिक होगी - (- 1) ** i / 16

— Abr001am

@ Agawa001, लेकिन यह 6 के लिए hऔर 7 के लिए रिटर्न t।

— स्पिकट्रिक्स

ओह मैं भूल गया, मुझे शक्ति का उपयोग करना चाहिए: p

— Abr001am

कूल पुरुष दुर्भाग्य सी does not को इस प्रकार यू उपयोग करने के लिए -1 * पॉव (-1, * मैं / 16) में आता है जो यह waaay अब, में दूसरी ओर, अजगर और matlab उपयोग ** है और ^ इस तरह के गणित आपरेशन है

— Abr001am

1

@CoolGuy का उपयोग करना puts(*i>'h'?"-1":"1");बेहतर नहीं होगा? (22 बाइट्स)

— euanjt

4

Tr: 17 13 वर्ण

(या 14 10 यदि आप केवल तर्कों को गिनें ...)

tr -s ta-s -1

नमूना रन:

bash-4.3$ tr -s ta-s -1 <<< heads
1

bash-4.3$ tr -s ta-s -1 <<< tails
-1

संक्षिप्त विवरण:

tr ट्रांसपेरेंट के लिए खड़ा है, जिसका अर्थ है, पहले तर्क में पाए गए इनपुट के प्रत्येक चरित्र को दूसरे स्थान पर उसी स्थिति में चरित्र के साथ मिलाएं:

tr ta -1 <<< tails         # replaces t ⇢ -, a → 1
⇒ -1ils

यदि पहला तर्क लंबा है, तो दूसरे तर्क में स्थितीय मिलान के बिना वर्णों को दूसरे तर्क के अंतिम चरित्र से बदल दिया जाता है:

tr tals -1 <<< tails       # replaces t ⇢ -, a → 1, l → 1, s → 1
⇒ -1i11

जब -s( --squeeze-repeats) विकल्प का उपयोग किया जाता है, तो एक ही चरित्र के साथ बदले जाने वाले क्रमिक पात्रों को एक ही बार में बदल दिया जाएगा:

tr -s tals -1 <<< tails    # replaces t ⇢ -, a → 1, l+s → 1
⇒ -1i1

इसलिए यदि हम सभी पात्रों को "पूंछ" में शामिल करते हैं, तो हमें वह मिलता है जो हमें चाहिए:

tr -s tails -1 <<< tails    # replaces t ⇢ -, a+i+l+s → 1
⇒ -1

"हेड्स" के लिए समान है, लेकिन माइनस (रेंगने के लिए वर्णानुक्रम से वर्णित वर्ण) का उपभोग करने के लिए "सामने" रखने की आवश्यकता है:

tr -s taedhs -1 <<< heads   # replaces h+e+a+d+s → 1
⇒ 1

"Tails" और "हेड्स" के सभी uniques अक्षर को एक एकल तर्क में विलय करना, "t" को सामने रखना अंतिम समाधान की ओर ले जाता है:

tr -s tadehils -1 <<< tails # replaces t → -, a+i+l+s → 1
⇒ -1

tr -s tadehils -1 <<< heads # replaces h+e+a+d+s → 1
⇒ 1

वर्ण, में एक अंतराल की गणना से बचने के लिए से - करने के लिए प्रारूप बजाय प्रयोग किया जा सकता है।

— आदमी काम पर है
स्रोत

इसे समझाने के लिए देखभाल?

— जुआन कोर्टेस

यह BSD / GNU को मानता है tr। POSIXly:tr -s ta-s '-[1*]'

— sch

4

8088 विधानसभा, आईबीएम पीसी डॉस, 17 बाइट्स

00000000: b402 0826 8200 7a04 b22d cd21 b231 cd21  ...&..z..-.!.1.!
00000010: c3

unassembled:

B4 02           MOV  AH, 02H        ; DOS API display char function     
08 26 0082      OR   DS:[82H], AH   ; set parity flag from input 
7A 04           JPE  HEADS          ; if even, heads - display just '1'
B2 2D           MOV  DL, '-'        ; otherwise first display a '-''
CD 21           INT  21H            ; output DL to console
            HEADS: 
B2 31           MOV  DL, '1'        ; display the '1'
CD 21           INT  21H            ; output DL to console
C3              RET

स्पष्टीकरण:

सीपीयू के समता ध्वज का उपयोग यह निर्धारित करने के लिए करें कि क्या पहले चार एक 'h'(बाइनरी 1की संख्या भी है ) या एक 't'(बाइनरी 1की विषम संख्या )। यह ASCII में चार की तुलना में एक बाइट बचाता है।

कमांड लाइन से इनपुट, कंसोल के लिए आउटपुट।

इनपुट आउटपुट:

— 640KB
स्रोत

4

जाप , 2 बाइट्स

ae

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

— ओलिवर
स्रोत

4

शेल (पोर्टेबल / POSIX), 16 बाइट्स

expr $i : he - 1

यह ऑनलाइन की कोशिश करो!
के लिए धन्यवाद @ StéphaneChazelas में unix.stackexchange.com

अन्य समाधानों की कोशिश की:
echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. यह ऑनलाइन कोशिश करो!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. यह ऑनलाइन की कोशिश करो!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . यह ऑनलाइन की कोशिश करो!
a=${i%h*};echo ${a:+-}1 # 23 . पोर्टेबल। यह ऑनलाइन की कोशिश करो!
he=2;echo $((${i%a*}-1)) # 24 bytes . पोर्टेबल। यह ऑनलाइन की कोशिश करो!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . पोर्टेबल। यह ऑनलाइन की कोशिश करो!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . पोर्टेबल। यह ऑनलाइन की कोशिश करो!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . पोर्टेबल। यह ऑनलाइन की कोशिश करो!

नोट: dashपोर्टेबल शेल परीक्षक के एक उचित उपमा के रूप में उपयोग करना ।

expr $i : he - 1कितने वर्णों के heसाथ मिलान करके काम करता है $i : he। एक headsमैच 2और एक tailsमैच 0 (कोई नहीं) तो फिर substracting 1साथ - 1।
$[30#$i%7-1]स्ट्रिंग को पूर्णांक में परिवर्तित करके काम करता है। बेस 30 और मॉड को 7 के बीच में headsऔर 2 के अंतर को प्राप्त करने के लिए चुना गया था tails। फिर 1 घटाना संख्याओं को 1और में परिवर्तित करता है -1।
ध्यान दें कि $[...]अंकगणित का एक पुरातन रूप $((...))केवल कुछ गोले में मान्य है।
he=2;echo $[${i%a*}-1]कुछ मान का चर बनाकर और फिर उस चर (पाठ मान से) का विस्तार करने के लिए अंकगणितीय विस्तार का उपयोग करके काम करता है। ${i%a*}धर्मान्तरित headsकरने के लिए heऔर tailsकरने के लिए t(जो एक चर के रूप में, 0 मान है)।
IFS=h;set $i;echo ${1:+-}1दो चरणों में काम करता है। करने के लिए भारतीय विदेश सेवा की स्थापना hटूटता गैर उद्धृत $iमें set $iचरित्र से विभाजित भागों में h, headsकरने के लिए विभाजित किया गया है ''और 'eads', इस प्रकार की स्थापना $1अशक्त करने के लिए। इस प्रकार से tailविभाजित नहीं किया जाता है h, इस प्रकार के $1बराबर होता है tails। फिर, ${1:+-}एक उत्पन्न -करता है, तो के मूल्य $1(के रूप में गैर-शून्य है tails) या कुछ भी नहीं (एक अशक्त के साथ के रूप में $1)। उस संकेत (या कुछ नहीं) के साथ सहमति है 1।
(IFS=h;set $i;echo $(($#*2-3)))इसी तरह से काम करता है लेकिन भागों की संख्या ( $#) का उपयोग करें जो स्ट्रिंग में $iटूट गया।

— इसहाक
स्रोत

3

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

print'-1'['t'>i:]

'heads'से कम है 't', इसलिए यह True == 1पहले वर्ण के बाद स्ट्रिंग का मूल्यांकन और प्रिंट करता है। 'tails'से अधिक है 't', इसलिए यह मूल्यांकन करता है False == 0और पूरे स्ट्रिंग को मुद्रित किया जाता है।

यदि हम यह कमांड लाइन से कर रहे हैं, तो निहित मुद्रण के साथ, यह बस बन जाता है:

'-1'['t'>i:]

... 12 बाइट्स के लिए, लेकिन यह आउटपुट में एकल उद्धरण जोड़ता है।

— sirpercival
स्रोत

3

QBasic, 11 बाइट्स

यह QBasic का सबसे छोटा टुकड़ा है जिसे मैंने कभी लिखा है।

c=i>"t
?c^c

स्पष्टीकरण:

ऊपर कुछ बहुत भारी गोल्फ QBasic है। एक बार ऑटोफ़ॉर्मेटर इसके साथ हो जाता है, यह इस तरह दिखेगा:

c = i > "t"
PRINT c ^ c

पहली पंक्ति स्ट्रिंग तुलना iके साथ "t"। अगर iहै "heads", i > "t"गलत है और c = 0। अगर iहै "tails", i > "t"सच है और c = -1। हाँ, -1QBasic में बूलियन सच के लिए डिफ़ॉल्ट मान है!

दूसरी पंक्ति के नक्शे -1के लिए -1और 0करने के लिए 1एक गणित चाल के माध्यम से: (-1)^(-1) == 1/(-1) == -1, और 0^0, हालांकि तकनीकी रूप से गणितीय अपरिभाषित, रिटर्न 1।

इस कोड की आवश्यकता है कि iस्पष्ट रूप से एक स्ट्रिंग चर के रूप में घोषित किया जाना चाहिए ; अन्यथा, यह होना चाहिए i$। पूर्ण परीक्षण कार्यक्रम ( QB64 पर परीक्षण किया गया ):

DIM i AS STRING
DATA heads, tails

FOR x = 1 TO 2
READ i

c=i>"t
?c^c

NEXT x

— DLosc
स्रोत

3

गैया , 5 4 बाइट्स

'eI(

करने के लिए इसी तरह के डेनिस के CJam जवाब , के सूचकांक पाता eइनपुट स्ट्रिंग में

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

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

'e  Push e
I   Index of e in the the input. 2 if heads, 0 if tails
(   Subtract One
Stack gets automatically outputted

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

— EdgyNerd
स्रोत

3

बैश , २२

echo $[0x${1:1:1}/2-6]

दूसरा अक्षर ( eया a) लेता है और इसे हेक्स अंक (14 या 10) के रूप में व्याख्या करता है, फिर 2 से विभाजित करता है और सही उत्तर पाने के लिए 6 घटाता है।

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

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

बहुत बढ़िया चाल, मैं इसे उधार लेने जा रहा हूँ :)

— लूटेरा

1

बैश के लिए, उपयोग करें: echo $[30#$i%7-1]केवल 17 बाइट्स। :-)

— इसहाक

3

एड , 27 25 21 बाइट्स

edमुझे सिरदर्द दिया। अंत में इसे @ed1confट्विटर और कुछ झांकियों की मदद से समझ लिया unix.se। आप सिर्फ चीजों से मेल नहीं खा सकते हैं s/re/newtext/, आपको इसके साथ उपसर्ग करना होगा gअन्यथा edएक उदास पैक। यह 50 साल पुराने यूनिक्स कार्यक्रम की तरह है, जिसमें कहा गया है कि "मेरा लॉन बंद कर दो"।

g/t/s//-
,s/\w\+/1
w

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

_{-2 बाइट्स को अंतिम /s

-4 बाइट्स पर छोड़ कर @manatwork के लिए धन्यवाद (और जिसका sedउत्तर मैंने साहित्यिकृत किया)

पुराने संस्करण:

g/t/s//-
g/\w\+/s//1
wq
.}

— roblogic
स्रोत

1

लेकिन आपको केवल 1 कमांड के लिए एड्रेस ट्रिक की जरूरत है, क्योंकि 2nd कभी भी फेल नहीं होगा। और स्पष्ट रूप से कोई ज़रूरत नहीं है q, जब कुछ भी करने के लिए नहीं छोड़ा जाता है, तो यह खुद ही छोड़ देगा। और आपको केवल उनके बाद एक नई पंक्ति की आवश्यकता है, "" (या "रोबोट" ...) अनावश्यक है। इसे ऑनलाइन आज़माएं!

— मैनटवर्क

अहह धन्यवाद मैं आपके सुझावों की कोशिश करूंगा जब मैं घर पहुंचूंगा। पब में अब the

— डकैती

2

पायथन, 20 बाइट्स

print(('h'in i)*2-1)

Falseयदि यह नहीं है, और Trueयदि यह है तो यह लौटाता है। अजगर में Falseऔर 0एक ही हैं, और Trueऔर 1साथ ही कर रहे हैं।

इसलिए:

True (1) * 2 -1 = 2-1 = 1
False (0) * 2 - 1 = 0-1 = -1

— टिम
स्रोत

2

गोल्फलुआ २५ २० १ 18

w(I.r():f'h'&1|-1)

संभवतः कुछ ट्रिक्स का उपयोग करके कुछ और गॉल्फ़ किया जा सकता है जो मैं इस समय नहीं सोच रहा हूँ। ( पुराने संस्करण के लिए इतिहास देखें ) इनपुट को वहां writeके ifकथन को अनदेखा करके और स्थानांतरित करके 5 चार्ट सहेजे गए । वैकल्पिक कोष्ठक को अनदेखा करके दो और चार्ट सहेजे गए find। यह विफल स्थितियों (यानी, इनपुट जो सिर या पूंछ नहीं है ) की जांच नहीं करता है ।

एक लुआ समकक्ष होगा

io.write(io.read():find('h') and 1 or -1)

— काइल कानोस
स्रोत

2

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

f('h':_)=1
f _= -1

पत्र के साथ शुरू होने वाले प्रत्येक स्ट्रिंग hको 1अन्य सभी को मैप किया जाता है -1।

— nimi
स्रोत

2

पाल: 16 वर्ण

s/t/-/
s/\w\+/1/

नमूना रन:

bash-4.3$ sed 's/t/-/;s/\w\+/1/' <<< 'heads'
1

bash-4.3$ sed 's/t/-/;s/\w\+/1/' <<< 'tails'
-1

— आदमी काम पर है
स्रोत

अच्छा, मैंने आपके edसमाधान के लिए अपने रेगेक्स का उपयोग किया , लेकिन यह अभी भी 23 बाइट्स ले रहा है, क्योंकि edपुराना और क्रोधी है!

— डकैती

\wऔर \+हालांकि GNU एक्सटेंशन हैं।

— sch

2

स्टैक्स , 3 बाइट्स

'eI

इसे चलाएं और डीबग करें

— ओलिवर
स्रोत

2

स्टैक्स , 4 बाइट्स

└0Y.

इसे चलाएं और डीबग करें

यह पहले वर्ण मॉड 7 माइनस 5 का कोड पॉइंट है।

— पुनरावर्ती
स्रोत

2

पॉवरशेल , 15 बाइट्स

($args[1]-99)/2

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

विभाजन के माध्यम से इनपुट लेता है। ASCII गणित करने के लिए eबनाम का उपयोग करता हैa

— Veskah
स्रोत

2

डीसी , 8 बाइट्स

?z2*1r-p

डीसी उन्हें पढ़ने और उन्हें मूल्यांकन करने के प्रयास के अलावा अन्य तार के साथ कुछ भी सार्थक नहीं कर सकता। ऐसा करने पर, "हेड्स" अनइम्प्लीमेंटेड कमांड्स और खाली स्टैक के बारे में कुछ चेतावनियाँ उत्पन्न करता है, जिसे हम अनदेखा कर देते हैं, लेकिन महत्वपूर्ण रूप से स्टैक खाली रहता है। "पूंछ" महत्वपूर्ण अपवाद के साथ लगभग वही करता है जो अंतिम "एलएस" एस रजिस्टर से स्टैक के लिए एक मूल्य लोड करता है।

हम सही उत्तर प्राप्त करने के लिए स्टैक की लंबाई और अंकगणितीय फिडेल प्राप्त करने के लिए "z" का उपयोग करते हैं।

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

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

2

त्रिकोणीय , 10 बाइट्स

F.~%.7/-_<

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

वर्ण इनपुट के ASCII मान को 7. से विभाजित करता है। भागफल को 15. से घटाता है। जब प्रोग्राम प्रोग्राम से बाहर निकलता है तो निष्पादन रुक जाता है। यह काम करता है क्योंकि त्रिकोणीय केवल पूर्णांक विभाजन का प्रबंधन कर सकता है। आसानी से, "एच" का मूल्य 104 है, जो 14 है जब पूर्णांक 7 से विभाजित होता है; "t" 116 है, जो कि 16 है जब पूर्णांक 7 से विभाजित होता है।

Ungolfed / स्पष्टीकरण:

   F
  . ~
 % . 7
/ - _ <
---------------------------------------------------------------
F                 - Push 15 to Top of Stack
 ~                - Read a character from input, push its value to ToS
   7              - Push 7 to ToS
     <_           - Change directions, then pop ToS-1 and ToS, push their integer quotient
        -         - Pop ToS-1 and ToS, push their difference
          %       - Print ToS as an integer

पिछला संस्करण (14 बाइट्स):

~\81|m/,!<.>i%

इनपुट से एक चरित्र पढ़ें; यदि उस वर्ण का ASCII मान 8 से विभाजित होता है, तो शेष -1, अन्यथा 1 प्रिंट होता है।

— मोनिका को बहाल करो
स्रोत

2

केग ,8 12 8 बाइट्स

_d=2*1-.

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

स्पष्टीकरण (संक्रियात्मक रूप से अमान्य)

_        Take input and discard the last item
 d=      If the top of the stack is d:
   2*    Re-set the top of the stack as 2
     1-  Decrement the top of the stack by 1
       . Explicitly output the top of the stack

-4 बाइट्स मैनटवर्क की बदौलत

— ए
स्रोत

कुछ TIO दुभाषिया संस्करण अंतर हो सकता है? ऐसा लगता है कि यह न तो "सिर" या "पूंछ" को संभालता नहीं है।

— मैनटवर्क

अब मैंने कार्यक्रम तय किया।

— एक

कुछ TIO दुभाषिया संस्करण अंतर हो सकता है? ऐसा लगता है कि यह अंतर्निहित रूप से इनपुट लेता है और इसे बिना किसी डेटा के संसाधित करने के किसी भी प्रयास पर उलट देता है, जिससे यह बिना काम के हो जाता है ^।

— मैनटवर्क

BTW, आपको 2 "d" या "l" के रूप में "t" तक 4 वर्णों को त्यागने की आवश्यकता नहीं है, जो पहले से ही आपको इनपुट मिला है। बस स्पष्ट रूप से आउटपुट करना है ताकि स्टैक पर अनप्रोसेस किए गए इनपुट को छोड़ सकें: इसे ऑनलाइन आज़माएं! ।

— मैनटवर्क

मुझे लगता है कि मैं अभी भी -1 बाइट्स को "Reg" पर स्विच करके कर सकता हूं: TIO!

— a

1

विटसी , 13 बाइट्स

तो क्या, मुझे पार्टी के लिए देर हो रही है। ¯ \ _ (ツ) _ / ¯

zv&v'h'=)i1rN
z             Grab all input.
 v            Capture the top item (h or t) as a temp variable.
  &           Generate new stack, move to it.
   v'h'=      Test if the variable is h.
        )i    If it isn't, push -1.
          1   Push 1.
           r  Reverse the stack.
            N Print out the top item as a number.

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

कोडगॉल्फ - हेड्स या टेल्स

अनुदेश

नमूना नहीं गोल्फ कोड (55b):

नमूना गोल्फ कोड (16 बी):

CJam, 4 बाइट्स

सी, 18 बाइट्स

व्याख्या

बोनस

रूबी, 8 (आउटपुट के बिना 6)

PHP - 11 बाइट्स

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

विखंडन , 26 21 बाइट्स

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

पायथ - 4 बाइट्स

VBA (एक्सेल), 12 बाइट्स

सी, 22 बाइट्स

Tr: 17 13 वर्ण

8088 विधानसभा, आईबीएम पीसी डॉस, 17 बाइट्स

जाप , 2 बाइट्स

शेल (पोर्टेबल / POSIX), 16 बाइट्स

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

QBasic, 11 बाइट्स

गैया , 5 4 बाइट्स

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

बैश , २२

एड , 27 25 21 बाइट्स

पायथन, 20 बाइट्स

गोल्फलुआ २५ २० १ 18

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

पाल: 16 वर्ण

स्टैक्स , 3 बाइट्स

स्टैक्स , 4 बाइट्स

पॉवरशेल , 15 बाइट्स

डीसी , 8 बाइट्स

त्रिकोणीय , 10 बाइट्स

केग ,8 12 8 बाइट्स

स्पष्टीकरण (संक्रियात्मक रूप से अमान्य)

विटसी , 13 बाइट्स