आसानी से टाइप करने योग्य शब्द

Question

यह प्रतियोगिता समाप्त हो गई है।

विजेता सीजेम 22 पात्रों के साथ है, जो एक चरित्र द्वारा ट्विनट के उत्तर को हरा रहा है । बधाई हो डेनिस !

एक सम्मानजनक उल्लेख फल्को को जाता है , जो मुफ्त आयात के साथ पूरी तरह से पागल हो गए थे।

।

---

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

यदि कोई लगातार दो अक्षर टेलीफोन कीबोर्ड पर एक ही बटन पर हों, तो मानक लेआउट को देखते हुए, हम आसानी से टाइप करने योग्य पाठ का एक टुकड़ा कहेंगे:

---

आपका कार्य

आपका कार्य एक प्रोग्राम / फ़ंक्शन लिखना है जो sस्टैडेन से / एक पैरामीटर के रूप में एक स्ट्रिंग को स्वीकार करता है और एक सत्य मान देता है यदि sआसानी से टाइप किया जा सकता है और एक मिथ्या मूल्य अन्यथा। इनपुट में केवल लोअरकेस अक्षर और रिक्त स्थान होंगे और गैर-रिक्त होने की गारंटी होगी!

स्कोरिंग

यह कोडगॉल्फ है, इसलिए सबसे कम चरित्र-गणना जीतती है।

आयात बयान अपने अंतिम स्कोर की ओर नहीं गिना जाएगा, इसलिए यदि आप कभी उपयोग करने के लिए चाहता था std::set_symmetric_difference, liftM4या itertools.combinationsअपने कोड में, अब समय आ गया है!

-3 यदि आपका स्रोत कोड आसानी से टाइप करने योग्य है, तो यह सब कुछ मान लेना कि कोई पत्र बटन पर नहीं है 0. आखिरकार, मैं आपके कोड को कुछ दोस्तों को संदेश देना चाह सकता हूं!

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

यह जांचने के लिए कि आपके कोड का उद्देश्य क्या है, जाँच करने के लिए यहाँ कुछ टेस्टकेस दिए गए हैं:

"x" -> True
"aardvark" -> False
"ardvark" -> True
"flonk" -> False

"im codegolfing all day long" -> False
"i indulge in minimizing bytecount" -> True

"havent heard from you in a long time" -> False
"your silence was of undue permanence" -> True

"how are  you" -> False
"how are you" -> True

हैप्पी गोल्फिंग!

Comments

क्या लगातार दो स्थान खराब हैं?

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

@ मार्टिनबटनर हाँ! शायद उसके लिए एक टेस्टकेस जोड़ना चाहिए।

— फ्लॉन्क सिप

मेरे पास एक नोकिया डंबफ़ोन है, अगर मैं दो बार स्पेस दबाता हूं, तो मुझे एक नंबर मिलता है। 0.

— ओवरएक्टर

संबंधित प्रश्न: एक फोन कीबोर्ड लेआउट तैयार करें जो आसानी से टाइप किए जाने वाले शब्दों को आसानी से टाइप करने के आधार पर कुछ स्कोर को अधिकतम करता है।

— justinpc

@jpcooper जैसे दो का उल्लेख यहां किया गया है ? मैंने 8pen का उपयोग किया है और वास्तव में इसे पसंद करता है, सिवाय इसके कि मेरा फोन ग्लास इसे (संपर्क से, सीपीयू गतिविधि से नहीं) का उपयोग करके गर्म करता है और घर्षण का गुणांक लंबे इनपुट के लिए उपयोग करना कठिन बनाता है। नोट 3 पर s-pen का उपयोग करना इतना आसान है :)

— Eben

Answer 1

सीजाम, 34 31 27 22 अक्षर

1l{'h-_9/-D+3/X\:X^*}/

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

उदाहरण चलाते हैं

$ cjam <(echo "1l{'h-_9/-D+3/X\:X^*}/") <<< 'aardvark'; echo
0
$ cjam <(echo "1l{'h-_9/-D+3/X\:X^*}/") <<< 'ardvark'; echo
66000

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

1l                         " Push a R := 1 and read a line L from STDIN.                  ";
                           " Initialize X := 1. (implicit)                                ";
  {                  }/    " For each character C of L, do the following:                 ";
    'h-                    "     C -= 'h'                                                 ";
       _9/-D+3/            "     Y := (C - C / 9 + 13) / 3                                ";
               X\  ^*      "     R *= X ^ Y                                               ";
                 :X        "     X := Y                                                   ";
                           " Print R. (implicit)                                          ";

पृष्ठभूमि

कोड के मूल में इनपुट स्ट्रिंग के प्रत्येक वर्ण C के लिए मानचित्र F को लागू करना शामिल है ताकि समान कुंजी मिलान पर प्रतीकों की छवियां। मैंने निम्नलिखित अवलोकन करके एक उपयुक्त मानचित्र पाया:

नक्शा T: C ↦ (C - 'h') + 13 स्ट्रिंग S को बदल देता है : = "abcdefghijklmnopqrstuvxyz" इस प्रकार है:

[-59   6  7  8   9 10 11  12 13 14  15 16 17  18 19 20  21 22 23 24  25 26 27  28 29 30 31]

कुंजियों के 0लिए 6, यह T (C) को 3 से विभाजित करने के लिए पर्याप्त होगा , लेकिन हमें कुछ प्रकार के सुधारों को s , t , v , y और z में लागू करना होगा ।

नक्शा D: C ↦ (C - 'h') / 9 स्ट्रिंग S को निम्न सरणी में बदल देता है:

[ -8   0  0  0   0  0  0   0  0  0   0  0  0   0  0  0   0  1  1  1   1  1  1   1  1  1  2]

यह दूसरों को प्रभावित किए बिना s , t , v , y और z के कोटेशन को सही करता है ।

अंत में, नक्शा F: C ↦ (T (C) - D (C)) / 3 स्ट्रिंग S को निम्नानुसार रूपांतरित करता है:

[-17   2  2  2   3  3  3   4  4  4   5  5  5   6  6  6   7  7  7  7   8  8  8   9  9  9  9]

सभी कि टिकी हुई है कि किसी न किसी तरह लगातार पात्रों की तुलना करना है। उस उद्देश्य के लिए, हम पिछले चरित्र की छवि के साथ XOR F (C) - पहले के लिए, हम 1 के साथ XOR F (C) (चर X का डिफ़ॉल्ट मान ) है, जिसका कोई पूर्वाभास नहीं है - और सभी परिणामों को गुणा करें।

यदि कोई कारक शून्य है, और केवल तभी यानी, यदि और केवल दो लगातार वर्णों में F के समान छवि है, तो उत्पाद मिथ्या होगा ।

Comments

मुझे लगता है कि इस के लिए बाइट (चरित्र नहीं) की गिनती 54 है

@Optimizer मुझे लगता है कि कोड-गोल्फ टैग विकी बाइट्स कहता है

इस उत्तर में अब गैर- ASCII वर्ण नहीं हैं।

— डेनिस

@professorfish टैग विकी केवल डिफ़ॉल्ट है। यदि चुनौती पात्रों को निर्दिष्ट करती है, तो यह वर्ण हैं।

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

Answer 2

अजगर 2 - 80, 68, 64, 61, 58, 50, 48, 45, 44 42

भले ही अब यह थोड़ा हास्यास्पद हो रहा है, फिर भी मैं मुक्त पुस्तकालय आयात का उपयोग करता रहूंगा, यहां तक ​​कि __builtin__पुस्तकालय:

from numpy import diff as D
from pprint import pprint as P
from __builtin__ import all as A
from __builtin__ import raw_input as I
from __builtin__ import bytearray as B

तो केवल निम्नलिखित छोटी लाइन कोड लंबाई की ओर गिना जाता है:

P(A(D([(o-o/112-o/59)/3for o in B(I())])))

विचारों के लिए मार्क्युज़ को श्रेय input()! ये मुफ्त-आयात चुनौतियां आपको हमेशा कुछ कम ज्ञात पुस्तकालयों से परिचित कराती हैं। ;)

---

केवल operatorपुस्तकालय का उपयोग करके वैकल्पिक ( 98, 83 79):

from operator import ne as n
K=[(ord(c)-1-(c>'p')-(c>'w'))/3for c in input()]
print all(map(n,K[1:],K[:-1]))

मैं यहाँ रुक जाऊँगा। लेकिन आप आगे इस संस्करण का उपयोग कर गोल्फ sys, pprintऔर अन्य पुस्तकालयों सकता है ...

---

पुस्तकालयों के बिना वैकल्पिक (105):

s=input()
n=lambda c:(ord(c)-1-(c>'p')-(c>'w'))/3
print all([n(s[i])!=n(s[i+1])for i in range(len(s)-1)])

Comments

और एक बार फिर हम स्वतंत्र रूप से रूबी और पायथन में एक ही समाधान पोस्ट करते हैं। ऐसा लगता है कि इस बार आप जीत रहे हैं। ;) ... तुम भी 4 बाइट्स नहीं बचा सकते हैं, ord(c)एक चर (कह o) और फिर घटाव c/112और c/119बूलियन के बजाय असाइन करके ?

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

@ मार्टिनबटनर: हाँ, एक बार में पाइथन रूबी को हरा सकता है। दुर्भाग्य से मैं lambdaआसानी से अभिव्यक्ति के भीतर चर नहीं दे सकता। साथ [(o-1-o/112-o/119)/3for o in map(ord,s)]मैं 80 के साथ खत्म हो फिर से बाइट्स।

— फाल्को

ओह समझा। हालांकि नया सुधार बीमार! : डी

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

बहुत प्रभावशाली। और आप अभी भी 3 बाइट्स को बचा सकते थे from sys import argv as s, s[1]इसके बजाय का उपयोग करते हुएinput()

— Markuz

आयात करने inputसे __builtin__के रूप में अच्छी तरह से वास्तव में और भी बेहतर है: डी अभी तक एक और बाइट बचत।

— Markuz

Answer 3

रूबी रेगेक्स (सबसे लोकप्रिय स्वाद), 106 83 बाइट्स

क्योंकि रेगेक्स

^(?!.*(  |[abc]{2}|[def]{2}|[ghi]{2}|[jkl]{2}|[mno]{2}|[p-s]{2}|[tuv]{2}|[w-z]{2}))

मैंने बस बिचौलिया (रूबी) को काट दिया है और इसे शुद्ध-रेगेक्स समाधान बना दिया है। बहुत सारे स्वादों में काम करता है और केवल एक मैच पाता है यदि स्ट्रिंग में एक ही बटन पर दो लगातार वर्ण नहीं होते हैं।

Comments

क्या आप {2}22 बाइट्स को सहेजते हुए वैकल्पिक रूप से बाहर नहीं रख सकते ?

— नीट द डार्क एबोल

@NiettheDarkAbsol दुर्भाग्य से नहीं, क्योंकि तब यह दो पुनरावृत्ति के लिए अलग-अलग विकल्प चुन सकता है।

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

आह, बिल्कुल। मुझे पता था कि एक कारण था XD

— नीट द डार्क एब्सोल

एक पठनीय, समझने योग्य, गोल्फ समाधान के लिए यश!

— ग्रीनएजजेड

Answer 4

बैश + कोरुटिल्स, 49

tr a-z $[36#8g7e9m4ddqd6]7778888|grep -Pq '(.)\1'

TRUE के लिए 1 का निकास कोड और FALSE के लिए 0:

$ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are  you" "how are you"; do echo "./3310.sh <<< \"$s\" returns $(./3310.sh <<< "$s"; echo $?)"; done
./3310.sh <<< "x" returns 1
./3310.sh <<< "aardvark" returns 0
./3310.sh <<< "ardvark" returns 1
./3310.sh <<< "flonk" returns 0
./3310.sh <<< "im codegolfing all day long" returns 0
./3310.sh <<< "i indulge in minimizing bytecount" returns 1
./3310.sh <<< "havent heard from you in a long time" returns 0
./3310.sh <<< "your silence was of undue permanence" returns 1
./3310.sh <<< "how are  you" returns 0
./3310.sh <<< "how are you" returns 1
$ 

Comments

बहुत अच्छा! यह पर्ल में 46 अक्षर होंगे: perl -pE'y/a-z/aaadddgggjjjmmmpppptttwwww/;$_=!/(.)\1/' <(echo "x")यह सच के लिए 1 प्रिंट करता है और झूठ के लिए कुछ भी नहीं।

— hmatt1

@chilemagic आगे बढ़ें और पर्ल उत्तर दें :)। -P कमांड-लाइन पैरामीटर (कोड-गोल्फ सम्मेलनों के अनुसार) का उपयोग करने के लिए स्कोर में एक जोड़ना न भूलें।

— डिजिटल ट्रामा

मुझे लगा कि मुझे छोटा करने का रास्ता मिल सकता है aaadddgggjjjmmmpppptttwwwwलेकिन मैंने हार मान ली है।

— बेन जैक्सन

@BenJackson मैंने एक तरीका निकाला। हम वास्तव में किसी भी विशिष्ट वर्ण की एक स्ट्रिंग का उपयोग कर सकते हैं - 11122233344455566667778888करेंगे। इस संख्या के पहले 19 अंकों को आधार बनाकर, हम 1 char को बचा सकते हैं!

— डिजिटल ट्रॉमा

Answer 5

एपीएल (डायलॉग), २४ २३

~∨/2=/⌊¯13⌈.21-.31×⎕AV⍳⍞

---

∧/2≠/⌊¯13⌈.21-.31×⎕AV⍳⍞

व्याख्या

⍞: स्क्रीन से स्ट्रिंग इनपुट लेता है
⎕AV: यह परमाणु वेक्टर है जो कि आधारभूत रूप से सभी वर्णों की एक स्ट्रिंग है जिसे एपीएल पहचानता है, जिसमें निश्चित रूप से सभी लोअरकेस अक्षर (इंडेक्स 18 ~ 43) और स्पेस (इंडेक्स 5) शामिल हैं
⍳: IndexOfफ़ंक्शन। एपीएल में कई कार्यों के लिए जो एक या दो स्केलर तर्क देता है, आप इसे एक स्केलर के स्थान पर एक सरणी खिला सकते हैं - एपीएल आपके लिए लूपिंग करेगा। तो ⍳सूचकांकों का एक संख्यात्मक सरणी देता है। .21-.31×: टाइम्स 0.31 और फिर 0.21 से घटाएं। यह एक छोटी सी चाल है जो एक ही नंबर (विशेष रूप से PQRS) पर एक ही नंबर (जब पूर्णांकों के लिए नीचे की ओर) को मैप करता है, Z को छोड़कर, जो अपने समूह में मैप किया जाता है
¯13⌈: max-13 के साथ। यह Z को WXY के साथ समूह में वापस लाता है
⌊: पूर्णांक के लिए नीचे
2≠/: Pairwise-≠। प्रत्येक लगातार जोड़ी के लिए बूलियन सरणी देता है।
∧/: और परिणामी सरणी की सभी प्रविष्टियाँ।

Comments

मैं इस तरह से कुछ पोस्ट करने जा रहा था, लेकिन आपने मुझे हरा दिया। धिक्कार है जेड कुंजी! आप अब भी कह सकते हैं कि (कोई लगातार जोड़ी उसी कुंजी पर टाइप नहीं हुई है ∧/2≠/) के बजाय ~∨/2=/( लगातार सभी जोड़े अलग-अलग कुंजी पर टाइप किए जाते हैं )

— तोबिया

हाँ tkx। मैं सोच रहा था कि "मुझे यहाँ 1 char को शेव करने में सक्षम होना चाहिए क्यों मैं इसे OMGGGG नहीं कर सकता !!!" लेकिन मुझे कक्षा में जाने के लिए मिला इसलिए मैंने अभी जो पोस्ट किया है वह पोस्ट करता हूं। और, हाँ, DAMN Z कुंजी। दुर्भाग्य से मैं अपने फोन पर हूं इसलिए मैं इसे बाद में संपादित नहीं कर सकता हूं

— TwiNight

और मैंने डी मॉर्गन के नियमों के बारे में एक जागरूक सोच बनाई और अभी भी इसका पता नहीं लगा

— सकी

अपने दोस्तों को यह शुभकामनाएं। ;)

— ठाणे ब्रिम्हल

यह बहुत दिलचस्प लग रहा है। क्या Dyalog APL दुभाषिया खरीदे बिना इस कोड को आज़माने का कोई तरीका है? ऑनलाइन दुभाषिया जो मैं आमतौर पर उपयोग करता हूं, वह बोली को समझने के लिए नहीं लगता है ...

— डेनिस

Answer 6

पर्ल - 44

यह मूल रूप से उनकी अनुमति के साथ @ DigitalTrauma के उत्तर का पर्ल रूपांतरण है । @KyleStrand की बदौलत 2 पात्रों को शेव किया।

y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/

-pझंडे के लिए 43 अक्षर + 1 । y///के रूप में ही है tr///। यह 1सच के लिए प्रिंट करता है और झूठ के लिए कुछ भी नहीं। अनुरोध होने पर मैं एक विस्तृत विवरण पोस्ट कर सकता हूं।

उदाहरण रन:

perl -pE'y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/' <(echo "x")

---

पर्ल - 81

$s=join"]{2}|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.*(  |[$s]{2}))/?1:0

-nझंडे के लिए +1 । यह joinregex ( मार्टिन के रूप में एक ही ) बनाने के लिए उपयोग करके काम करता है , जो कुछ बाइट्स को हिलाता है।

उदाहरण रन:

perl -nE'$s=join"]{2}|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.*(  |[$s]{2}))/?1:0' <(echo "your silence was of undue permanence")

Comments

क्या आप अनैतिक aऔर zअनर्गल बने रहने से पर्ल के समाधान से दो पात्रों को नहीं हटा सकते हैं ? y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/इसके अलावा, यह रिक्त स्थान को संभाल नहीं करेगा, यह होगा?

— काइल स्ट्रैंड

... ओह, ठीक है, एक पंक्ति में दो स्थान पहले से ही एक पंक्ति में दो समान अक्षर हैं। मेरी गलती।

— काइल स्ट्रैंड

@KyleStrand देने पर अच्छा कॉल aऔर zएक ही रहना। अद्यतन उत्तर!

— hmatt1

Answer 7

जावास्क्रिप्ट - 159 156 बाइट्स

function g(s){p=n=-1;for(i=0;i!=s.length;i++){p=n;n=s.charCodeAt(i);n-=97;if(n>17)n--;if(n>23)n--;if(p==-1)continue;if(~~(p/3)==~~(n/3))return 0;}return 1;}

सच्चाई के लिए 1 और झूठी के लिए 0 रिटर्न।

अगर केवल मैं कीवर्ड से छुटकारा पा सकता था।

Comments

कम से कम आप कुछ व्हाट्सएप से छुटकारा पा सकते हैं और अगर :): 141:function g(s){p=n=-1;for(i=0;i<s.length;i++){p=n;n=s.charCodeAt(i)-97;n>17&&n--;n>23&&n--;if(~p)continue;if(~(p/3)==~(n/3))return 0}return 1}

— अनुकूलक

आप अपने जवाब में बहुत सी दिलचस्प चीजों का उपयोग करते हैं जो मैंने पहले नहीं देखी हैं। मैं आमतौर पर सी ++ में लिखता हूं, लेकिन मैंने सोचा कि मैं जेएस को एक शॉट दूंगा क्योंकि यह ऑनलाइन परीक्षण करने के लिए तेज है।

— Lozzaaa

मुझे आज ही यह जगह मिली और मुझे लगा कि मैं इसे एक शॉट दूंगा। मेरी अगली कोशिश बेहतर होगी: D

— Lozzaaa

आप !=लूप के लिए for में बदलकर अपने कोड को छोटा बना सकते हैं <।

— प्रोग्रामफॉक्स

हां जो ऑप्टिमाइज़र के ऑप्टिमाइज़ेशन में था :) मेरे जवाब में लोगों के सुझावों का उपयोग करने पर क्या शिष्टाचार है? अब जबकि एक और जावास्क्रिप्ट प्रविष्टि है जिसे मैं उन संशोधनों को स्वीकार करके हरा सकता हूं।

— लोजाज़ा

Answer 8

सी, 74 बाइट्स

main(c,d,r){for(;~(c=getchar());r*=d!=c/3,d=c/3)c-=--c/'p'*(c-'k')/7;c=r;}

TRUE और 0 के लिए FALSE के लिए एक गैर-शून्य निकास स्थिति लौटाता है:

$ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are  you" "how are you"; do echo "./3310 <<< \"$s\" returns $(./3310 <<< "$s"; echo $?)"; done
./3310 <<< "x" returns 40
./3310 <<< "aardvark" returns 0
./3310 <<< "ardvark" returns 216
./3310 <<< "flonk" returns 0
./3310 <<< "im codegolfing all day long" returns 0
./3310 <<< "i indulge in minimizing bytecount" returns 72
./3310 <<< "havent heard from you in a long time" returns 0
./3310 <<< "your silence was of undue permanence" returns 232
./3310 <<< "how are  you" returns 0
./3310 <<< "how are you" returns 8
$ 

Comments

आप अपने को बदलने के द्वारा 3 बाइट्स बचा सकते हैं whileकरने के लिए for(;c=~getchar();d=c/3)अपने पहले बदलकर, और एक अन्य बाइट ifएक करने के लिए ?:ऑपरेटर।

— एलबेर्ट सिप

@Allbeert - धन्यवाद आसपास कोष्ठक की c=getchar()आवश्यकता होती है, क्योंकि ~इसकी तुलना में अधिक पूर्वता होती है =। फिर भी, मैं अन्य दो बाइट्स ले जाऊंगा :)

— डिजिटल ट्रॉमा

आखिरी बिट के लिए, काम के exit(d!=c/3);बजाय कुछ पसंद करता है if(d==c/3)exit(0);?

@professorfish उस बिंदु से बाहर निकल जाएगा बिना शर्त, जो मैं नहीं चाहता

— डिजिटल ट्रॉमा

आप एक चरित्र को r * = d ^ c / 3

— Alchymist

Answer 9

रूबी 1.8, 89 83 81 78 बाइट्स

p$*[0].chars.map{|c|c=c[0];(c-c/?p-c/?w-1)/3}.each_cons(2).map{|a,b|a!=b}.all?

यहाँ एक और सबमिशन है। मेरी शर्म की बात है, यह regex धड़कता है। :(

यह स्ट्रिंग को कमांड-लाइन तर्क के माध्यम से ले जाता है और एक बूलियन प्रिंट करता है।

एल्गोरिथ्म के रूप में, मैं pएक के बाद एक और zदो के बाद अक्षरों को नीचे स्थानांतरित कर रहा हूं , और फिर मैं जांचता हूं कि पूर्णांक विभाजन के बाद 3 द्वारा कोई टक्कर नहीं है।

पुनश्च: यह पहली बार है, कि रूबी 1.8 का उपयोग करके कोड को छोटा कर दिया गया है (चरित्र कोड प्राप्त करने के छोटे तरीके के कारण)।

Answer 10

कोबरा - 80

def f(s)
    for c in s
        for x in 9,if' adgjmptw'[x]>c,break
        t,f=x,t<>x
    print f

Answer 11

जावास्क्रिप्ट (ईएस 6) 66 74

F=s=>[...s].every(c=>[...' adgjmptw'].map(x=>s+=c<x,w=s,s=0)|s!=w)

आंतरिक लूप प्रत्येक वर्ण के लिए समूह ढूंढता है। वैचारिक रूप से एक 'कम' है, लेकिन 'नक्शा' छोटा है। बाहरी लूप लगातार वर्णों के समूह की तुलना करते हैं और समान होने पर झूठे से बाहर निकलते हैं।

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;["x","aardvark","ardvark","flonk","im codegolfing all day long",
"i indulge in minimizing bytecount","havent heard from you in a long time",
"your silence was of undue permanence","how are  you","how are you"]
.forEach(x=>console.log(x + ' -> ' + F(x)))

उत्पादन

x -> true
aardvark -> false
ardvark -> true
flonk -> false
im codegolfing all day long -> false
i indulge in minimizing bytecount -> true
havent heard from you in a long time -> false
your silence was of undue permanence -> true
how are  you -> false
how are you -> true

Comments

आप .someहर के बजाय कर सकते हैं । क्योंकि भले ही यह एक बार विफल हो जाए, लेकिन उत्तर गलत है।

— अनुकूलक

@ ओप्टिमाइज़र someऔर everyइंटरचेंज हैं, जो शर्तों के साथ फ़िदा होते हैं। लेकिन यहाँ केवल काम नहीं किया जाएगा, someइसके बजाय everyप्रयास करें।

— edc65

हम्म, तुम सही हो। मुझे पहले आपके तर्क को समझने की जरूरत है।

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

कृपया बुरा न मानें अगर मैं इस [...s].everyट्रिक को अपने गोल्फ में इस्तेमाल करना शुरू कर दूं :)

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

Answer 12

पर्ल, 83 बाइट्स

$_=<>;chop;map{$_=ord;$_=($_-$_/112-$_/119-1)/3;die 0 if$l==$_;$l=$_}split//;die 1

पर्ल में $ _ का भारी दुरुपयोग करना।

Comments

जैसा कि आप देख सकते हैं, दुभाषिया को कमांड-लाइन पैरामीटर पारित करने की अनुमति है, बस आपको अतिरिक्त मापदंडों को गिनना होगा। ( -eपर्ल में कोड को एक्सेस करने के लिए आवश्यक नंगे न्यूनतम , मुफ़्त है।) कमांड-लाइन मापदंडों के साथ 71 वर्ण विकल्प perl -nlaF -e 'map{$_=ord;$_=($_-$_/112-$_/119-1)/3;die 0 if$l==$_;$l=$_}@F;die 1':।

— 16:14 पर मैनटवर्क

@manatwork आप की जरूरत नहीं है -l, लेकिन यह अच्छा लग रहा है!

— hmatt1

@chilemagic, मैंने सिर्फ मूल कोड के समकक्ष पुन: पेश करने की कोशिश की, इसलिए मैंने -lप्रतिस्थापन के रूप में जोड़ा chop। लेकिन निश्चित रूप से, आप सही हैं।

— ०४ में

धन्यवाद @manatwork, मैंने पर्ल के लिए कमांड लाइन विकल्पों का उपयोग करने के बारे में सोचा भी नहीं था।

— १

Answer 13

पायथन में दो काम मुश्किल हैं; चेन का पता लगाना, और समूहों को असाइन करना। दोनों को सुपी का उपयोग करके सहायता दी जा सकती है, लेकिन यह मानक पुस्तकालय में नहीं है।

पायथन 2 (केवल मानक पुस्तकालय) - 59 वर्ण फ़ंक्शन

from itertools import imap as M
from __builtin__ import bytearray as A, all as E
from operator import ne as D, not_ as N
from re import S, sub as X, search as F

# 68
#def f(s):
# g=[(n-n/115-n/61)/3for n in A(s)]
# return E(M(D,g,g[1:]))

# 67 with regex via regex
#f=lambda s:N(F(X('(\S)(.)',r'|[\1-\2]{2}','  acdfgijlmopstvwz'),s))

# 59 slightly optimized ordinal classifier and regex sequence detector
f=lambda s:N(F(r'(.)\1',A((n-n/23-n/30)/3for n in A(s)),S))

# 69 using itertools.groupby
#from itertools import groupby as G
#from __builtin__ import sum as S, len as L
#f=lambda s:N(S(L(A(g))-1for _,g in G((n-n/115-n/61)/3for n in A(s))))

पायथन 2 (केवल मानक पुस्तकालय) - मूल्य से बाहर निकलने के लिए 53 चार्ट स्टड

यहां मैं इस तथ्य का दुरुपयोग करता हूं issubclass(bool,int), इसलिए मुझे एक वैध निकास मान प्राप्त all()करने के लिए बदल रहा है any(), not()वापसी मूल्य से शेविंग । फ़ंक्शन ओवरहेड को हटाने से रेगेक्स संस्करण आकार में पीछे हो जाते हैं।

from itertools import groupby as G, imap as M
from __builtin__ import bytearray as A, any as E
from __builtin__ import raw_input as I
from sys import exit as Q
from operator import eq as S

g=[(n-n/23-n/30)/3for n in A(I())]
Q(E(M(S,g,g[1:])))

Answer 14

जे - ४२ चार

दाईं ओर स्ट्रिंग लेना समारोह।

*/@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)

पहले हम u:97+i.2625 में से वर्णमाला ( ) को 0 में मैप करते हैं , अन्य सभी वर्ण (रिक्त स्थान सहित) 26 पर जा रहे हैं ( i.)। फिर हम {~पहले कुंजी के लिए पहले तीन तत्वों का नक्शा ( ), अगले तीन से अगली कुंजी पर मैप करते हैं, और इसी तरह फोन पैड की कुंजी के माध्यम से, अंत में एक अलग कुंजी के लिए अंतरिक्ष / अन्य विराम चिह्न का नक्शा बनाना सुनिश्चित करते हैं । ( 4 3 4 1,~5#3के बराबर है 3 3 3 3 3 4 3 4 1और I.बदल जाता है कि एक 27-आइटम सरणी में जहां पहले तीन कुंजी 1 हैं, आदि) फिर हम जोड़ीदार असमानता ( 2~:/\) और और सभी परिणामों को एक साथ जांचते हैं ( */)।

   */@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.) 'i indulge in minimizing bytecount'
1
   f =: */@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)
   f 'im codegolfing all day long'
0
   f '*/@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)'  NB. no -3 bonus :(
0

Answer 15

रैकेट, 119

(define(f t)(for*/and([s(map ~a'(abc def ghi jkl mno pqrs tuv wxyz))][i s][j s])(not(regexp-match(format"~a~a"i j)t))))

अनगोल्डेड (कॉम्बीनेटरिक रेगेक्सिंग):

(define(f t)
  (for*/and([s (map ~a '(abc def ghi jkl mno pqrs tuv wxyz))]
            [i s]
            [j s])
    (not (regexp-match (format "~a~a" i j) t))))

Answer 16

जावास्क्रिप्ट - 152

विजेता नहीं लेकिन मैंने इसे शॉट दिया। समय पोस्टिंग के रूप में 4 बाइट्स द्वारा @ लोज़ाए बीट्स :)

function m(a){c="abc-def-ghi-jkl-mno-pqrstuv-wxyz";j=a.split("");for(z in j)if(j[z]=Math.floor(c.indexOf(j[z])/4),0!=z&&j[z-1]==j[z])return 0;return 1};

सभी टेस्ट पास करता है।
जेएस की टाइपिंग की कमी का फायदा उठाकर मल्टी टाइप एरे बनाते हैं, और यह इंडेक्सऑफ का फायदा उठाता है।

उपयोग:

m("string here")

केवल अक्षर और रिक्त स्थान को कम करता है। सत्य के लिए १, झूठ के लिए ०।

शायद अगर मुझे पता था कि ES6 मैं दूसरी चुनौती की कोशिश कर सकता है ...

Comments

"यदि केवल ..." - क्या आपने मेरा उत्तर देखा? : पी

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

हाँ, मैंने किया। मैं ES6 (अभी तक) नहीं जानता, दुख की बात है। हालांकि, यह बनाने के लिए दिलचस्प था।

— DankMemes

हाँ, एक दिलचस्प दृष्टिकोण का उपयोग करके आपका समाधान।

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

Answer 17

ईएस 6, जावास्क्रिप्ट 89 70 वर्ण

मुझे पता है कि इसका विजेता नहीं है क्योंकि जब एएससीआईआई के चरित्र को प्राप्त करने जैसे आसान संचालन के लिए आते हैं, तो जेएस बहुत ब्लोट ( .charCodeAt()) डालता है ।

N=s=>[...s].every(c=>l-(l=(c.charCodeAt()-(c>"r")-(c>"y")-1)/3|0),l=1)

इसे नवीनतम फ़ायरफ़ॉक्स के वेब कंसोल में चलाएं।

उपयोग:

N("testing if this works")

फ़ंक्शन या तो सही या गलत देता है।

संपादित करें : [...x].every@ edc65 (सीखें!) से सीखी गई ट्रिक का उपयोग करके बहुत कुछ हासिल किया (धन्यवाद!)

मैं इसे और अधिक करने की कोशिश करूंगा :)

Answer 18

जीएमएल (गेम मेकर लैंग्वेज), 149

s=argument0p=n=-1for(i=0;i<string_length(s);i++){p=n;n=string_char_at(s,i)-97;x=n>17&&n--;x=n>23&&n--‌​;if(!p)x=1if(!(p/3)=!(n/3))x=0}show_message(x)

Answer 19

पायथन 3 - 152 वर्ण

कम से कम मैं नहीं जा सकता था, लेकिन यह अभी के लिए करूँगा

k=['abc','def','ghi','jkl','mno','pqrs','tuv','wxyz',' ']
x=input()
l=2>1
for i in range(len(x)-1):
 for j in k:
  if x[i+1] in j and x[i] in j:l=1>2
print(l)