यह एक ऊबड़ शब्द है?

31

( पज़लिंग पर इस चुनौती से प्रेरित - उस पहेली के लिए SPOILERS नीचे हैं, इसलिए यदि आप अपने दम पर उस पहेली को हल करना चाहते हैं तो यहां पढ़ना बंद कर दें!)

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

उदाहरण के लिए, शब्द ACEदो उगता है ( Aकरने के लिए Cऔर Cकरने के लिए E) और कोई, जाता है, जबकि THEदो गिरता है ( Tकरने के लिए HऔरH करने के लिए E) और कोई बढ़ जाता है।

हम एक शब्द को बम्पी कहते हैं यदि अनुक्रम बढ़ता है और वैकल्पिक गिरता है। उदाहरण के लिए, BUMPवृद्धि ( Bको U), पतन ( Uको M), वृद्धि (M को P) जाता है। ध्यान दें कि पहले अनुक्रम में वृद्धि की आवश्यकता नहीं है - BALDपतन-वृद्धि-पतन होता है और यह भी ऊबड़ है।

चुनौती

किसी शब्द को देखते हुए, आउटपुट बम्पी है या नहीं।

इनपुट

  • एक शब्द (आवश्यक रूप से एक शब्द नहीं शब्द) केवल ASCII वर्णमाला ( [A-Z]या [a-z]) अक्षरों से मिलकर , किसी भी उपयुक्त प्रारूप में ।
  • आपकी पसंद यदि इनपुट सभी अपरकेस या सभी लोअरकेस है, लेकिन यह सुसंगत होना चाहिए।
  • यह शब्द कम से कम 3 अक्षरों का होगा।

उत्पादन

एक सत्य / असत्यइनपुट शब्द Bumpy (सत्य) है या नहीं Bumpy (फाल्सी) के लिए मूल्य।

नियम

  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

Truthy:

ABA
ABB
BAB
BUMP
BALD
BALDY
UPWARD
EXAMINATION
AZBYCXDWEVFUGTHSIRJQKPLOMN

Falsey:

AAA
BBA
ACE
THE
BUMPY
BALDING
ABCDEFGHIJKLMNOPQRSTUVWXYZ

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

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

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  string  decision-problem 
— AdmBorkBork
स्रोत
धत तेरे की। यह आसान होगा यदि एक ही पत्र न तो उठ रहा था और न ही गिर गया था।
— mbomb007
मुझे प्रदान किए गए उदाहरण समझ में नहीं आते हैं: अगर BUMPट्रू (यानी बम्पी) में सूचीबद्ध BUMPYहै, तो फाल्सी सूची में क्यों है? क्या "उगता है और वैकल्पिक रूप से गिरता है" का अर्थ है? क्रमिक रूप से दो वृद्धि नहीं हो सकती है?
— VolAnd
4
@VolAnd हां, इसका मतलब है कि एक बढ़त हमेशा गिरावट और इसके विपरीत होती है। BUMPYमिथ्या है क्योंकि MPYदो लगातार उगता है। दूसरे शब्दों में, लंबाई 3 के किसी भी विकल्प को एक शब्द के लिए आरोही या अवरोही रूप से छांटना नहीं चाहिए (विशेष मामले के अलावा जहां दो लगातार अक्षर समान हैं)।
— मार्टिन एंडर
क्या आप Puzzling के उत्तर को बिगाड़ सकते हैं। ऐसे में अन्य लोग जो इसे हल करना चाहते हैं वे स्वयं ऐसा कर सकते हैं?
— OldBunny2800
1
@ OldBunny2800 मैं एक पूर्ण स्पॉइलर नहीं लगाऊंगा (मैं एक स्पॉइलर के पीछे महत्वपूर्ण जानकारी छिपाकर पढ़ने के लिए अपनी चुनौती को यहां कठिन नहीं बनाना चाहता), लेकिन मैं चेतावनी के रूप में शीर्ष पर कुछ अतिरिक्त पाठ जोड़ूंगा। धन्यवाद!
— AdmBorkBork

जवाबों:

31

MATL, 4 बाइट्स

d0>d

स्पष्टीकरण:

d     % Implicitly take input. Take difference between each element
 0>   % Check whether diff's are positive. Should result in [0 1 0 1 ...] pattern.
   d  % Again take the difference. Any consecutive rises or falls results in a 
      % difference of 0, which is a falsy value in MATL

यह मेरी पहली MATL प्रविष्टि है, इसलिए मुझे आश्चर्य है कि मेरे MATLAB / ऑक्टेव प्रयास (जो होगा @(a)all(diff(diff(a)>0))) से इस भोले बंदरगाह से कितना सुधार हो सकता है । ध्यान दें कि allआवश्यक नहीं है क्योंकि कोई भी शून्य किसी सरणी को गलत बनाता है, इसलिए AMATL पोर्ट में कोई भी नहीं है।

— Sanchises
स्रोत
सही चुनौती देखें। एक परीक्षण के मामले में एक टाइपो था। आपका दृष्टिकोण सही था। वास्तव में, d0>dकाम करना चाहिए (आपको सच A/ फाल्सी की हमारी परिभाषा के अनुसार ज़रूरत नहीं है )
— लुइस
1
अच्छा काम, अपनी भाषा में लुइस को पछाड़ कर! मैंने पहले भी कोशिश की है, और यह कोई आसान काम नहीं है। ;)
— डीजेमैकेम
@DJMcMayhem Haha यही मुझे चुनौती को जल्द से जल्द पढ़ने के लिए मिलता है। मेरे बचाव में, यह प्रति-सहज है कि दो समान अक्षर एक गिरावट हैं। और (अब सही किया गया) भ्रामक परीक्षण के मामलों में मदद नहीं मिली :-)
— लुइस मेंडू सेप
1
@DJMcMayhem धन्यवाद - हालांकि शायद मैं सिर्फ, भाग्यशाली है क्योंकि मैं वास्तव में लगातार बराबर पत्र के बारे में नहीं सोचा था, लेकिन यह होने के लिए वास्तव में क्या कहा गया था निकला ...
— Sanchises
1
MATL (AB) और ऑक्टेव में @immibis, हाँ। यह मेटा उत्तर देखें ।
— Sanchises
24

जावास्क्रिप्ट (ईएस 6), 75 69 63 46 43 बाइट्स

नील को धन्यवाद देकर 3 बाइट्स बचाए:

f=([c,...s])=>s[1]?c<s[0]^s[0]<s[1]&&f(s):1

इसके बजाय स्ट्रिंग पैरामीटर को नष्ट करना s.slice(1)।

पिछला समाधान:
बच गए 17 बाइट्स ETHproductions के लिए धन्यवाद:

f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1

पिछले समाधान कदम से कदम क्या हुआ:

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b // (63) Original
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(s[i]<s[i+1]))?f(s,i):b   // (61) No point in reassigning `a`, it's not used again
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^s[i]<s[i+1])?f(s,i):b     // (59) Remove unnecessary parentheses
f=(s,i=0)=>s[i+2]&&(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b         // (55) `a` is now just a waste of bytes
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b:1        // (56) Rearrange conditional expressions to allow for more golfing
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1         // (55) Rearrange conditional expression
f=(s,i=0)=>s[i+2]?(s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1           // (53) `b` is now also a waste of bytes
f=(s,i=0)=>s[i+2]?s[i++]<s[i]^s[i]<s[i+1]&&f(s,i):1             // (51) Remove unnecessary parentheses
f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1                  // (46) Use `s.slice(1)` instead of `i`

पिछला समाधान:
63 बाइट्स ETHproductions के लिए धन्यवाद:

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

69 बाइट्स:

f=(s,i=0,a=s[i++]<s[i])=>i+1<s.length&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

75 बाइट्स:

f=(s,a=s[0]<s[1])=>{for(i=1;i+1<s.length&&(b=a^(a=s[i++]<s[i])););return b}

एक शब्द में सभी अक्षरों का एक ही मामला होना चाहिए।

— Hedi
स्रोत
2
आप इसे थोड़ा आगे बढ़ा सकते हैं: github.com/ETHproductions/golf/blob/gh-pages/misc/93014.js
— ETHproductions
@ETHproductions क्या मुझे आपके लिंक की सामग्री पोस्ट करनी चाहिए?
— हेदी
अगर आप चाहें तो :-)
— ETHproductions
के !s[2]|...रूप में ही कर सकते हैं s[2]?...:1?
— टाइटस
1
पार्टी में देर से आने के लिए क्षमा करें, लेकिन 43 बाइट्स के लिए मैं आपको देता हूं:f=([c,...s])=>s[1]?c<s[0]^s[0]<s[1]&&f(s):1
— नील
14

LabVIEW, 36 बराबर बाइट्स

तार्किक समतुल्यताओं का उपयोग करते हुए नीचे गिरा:

golfed

Ungolfed:

ungolfed

पहले हम लोअरकेस में बदलते हैं, फिर बाइट सरणी में। बाइट सरणी के पहले तत्व को ट्रिम कर दें क्योंकि इसकी कोई मिसाल नहीं है। फिर, सरणी में प्रत्येक तत्व के लिए, जांचें कि क्या यह पिछले एक से अधिक है (U8 char मैप्स से ASCII जैसा कि आप उम्मीद करते हैं) और परिणाम को अगले पुनरावृत्ति के लिए संग्रहीत करें, साथ ही समग्र बंपन को देखने के लिए एक सरणी में। यदि वर्तमान और पूर्व बूलियन चेक समान हैं, तो हम लूप को समाप्त करते हैं और यह ऊबड़ नहीं है। और, यह ऊबड़ है!

— ijustlovemath
स्रोत
1
क्या मस्त भाषा है! PPCG में आपका स्वागत है!
— DJMcMayhem
1
धन्यवाद! मैं 4 बाइट के उत्तरों के साथ प्रतिस्पर्धा नहीं करूंगा, लेकिन यह मेरे कौशल को सुधारने का एक अच्छा तरीका है :)
— ijustlovemath
देखें यहाँ । आपका स्कोरिंग निश्चित रूप से गलत है और अत्यधिक अत्यधिक है । मुझे नहीं लगता कि आपका जवाब वास्तव में 246450 - 246549 बाइट्स है।
— आउटगॉल्फ
मैं मेमोरी टैब से जा रहा था, क्योंकि मुझे नहीं पता था कि लैबव्यू के लिए बराबर बाइट्स की अवधारणा थी। आज उनकी गणना करेंगे और बाद में उत्तर को संपादित करेंगे।
— इग्लूवेवमथ
1
@ एरिक मैं विंडोज पर फ़ायरफ़ॉक्स पर हूं, लेकिन इसे मोबाइल पर खोलने से भी चीजें टूट जाती हैं। बस meta.ppcg.lol काम करता है। वैसे भी, यह टिप्पणियों के दायरे से बाहर है।
— निधि मोनिका का मुकदमा
8

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

lambda s:all((x<y)^(y<z)for x,y,z in zip(s,s[1:],s[2:]))

सभी परीक्षण के मामले विचारधारा पर हैं

एस में पात्रों के परीक्षणों के माध्यम से ज़िप करता है और परीक्षण करता है कि इस तरह के सभी ट्रिपल अलग-अलग वृद्धि / गिरावट गुणों के साथ बाएं और दाएं जोड़े हैं।
सभी अपरकेस या सभी लोअरकेस के लिए काम करता है।

— जोनाथन एलन
स्रोत
6

रूबी, 57 48 बाइट्स

सभी अपरकेस होने के लिए इनपुट की अपेक्षा करता है।

->s{!s.gsub(/.(?=(.)(.))/){($&<$1)^($1<$2)}[?f]}

इसे repl.it पर देखें: https://repl.it/D7SB

व्याख्या

नियमित अभिव्यक्ति /.(?=(.)(.))/प्रत्येक वर्ण से मेल खाती है जिसके बाद दो और वर्ण होते हैं। (?=...)एक सकारात्मक रूप है, जिसका अर्थ है कि हम बाद के दो पात्रों से मेल खाते हैं, लेकिन मैच के हिस्से के रूप में उनका "उपभोग" नहीं करते हैं। घुंघराले ब्रेसिज़ के अंदर, $&मेल किया हुआ पाठ है- तीनों का पहला चरित्र है $1और $2वे लुकहेड के अंदर कैद किए गए अक्षर हैं। दूसरे शब्दों में, यदि स्ट्रिंग है "BUMPY", यह पहली से मेल खाएगी "B"(और यह में डाल $&) और कब्जा "U"और "M"(और उन्हें में डाल दिया $1और $2)। अगला यह मिलान कर देंगे "U"और कब्जा "M"और "P", और इतने पर।

ब्लॉक के अंदर हम जांचते हैं कि वर्णों की पहली जोड़ी ( $&और $1) एक उत्थान है और दूसरी ( $1और $2) एक गिरावट या इसके विपरीत है, बहुत अधिक अन्य उत्तरों की तरह। यह ^अभिव्यक्ति लौटती है trueया false, जो एक स्ट्रिंग में परिवर्तित हो जाती है और मैच के स्थान पर सम्मिलित हो जाती है। परिणामस्वरूप, हमारा उदाहरण "BUMPY"यह बन जाता है:

"truetruefalsePY"

चूँकि हम जानते हैं कि इनपुट सभी बड़े हैं, हम जानते हैं कि "f"केवल इसका हिस्सा होगा "false"और !result[?f]हमें अपना उत्तर देता है।

— जॉर्डन
स्रोत
यह कैसे काम करता है?
— ग्रीनएजजेड
1
@GreenAsJade मैंने अपने उत्तर में एक स्पष्टीकरण जोड़ा है।
— जॉर्डन
6

सी #, 64 63 55 बाइट्स

unsafe bool B(char*s)=>1>s[2]||*s<s[1]!=*++s<s[1]&B(s);

Scepheo के सुझावों से -8 बाइट्स

यह Hedi के C # के समाधान का एक बंदरगाह है । मैं भी एक पुनरावर्ती समाधान के साथ आया था, लेकिन पुनरावृत्ति उतना अच्छा नहीं था। मेरा मूल समाधान नीचे है।

मेरा मूल सी #, 96 94 91 बाइट्स

unsafe bool B(char*s,bool f=1>0,int i=0)=>1>s[1]||(s[0]<s[1]?f:1>i?!(f=!f):!f)&B(s+1,!f,1);

के 1>0बजाय का उपयोग करके -2 बाइट्स true।

ऊपर बंदरगाह समाधान के लिए Scepheo के सुझावों से -3 बाइट्स

कॉल खुद ही पुनरावर्ती जाँच करते हैं कि हर बार बढ़ते / गिरते विकल्प।

Ungolfed:

// unsafe in order to golf some bytes from string operations.
// f alternates with each recursive call
// i is 0 for the first call, 1 for all subsequent calls
unsafe bool B(char* s, bool f = 1 > 0, int i = 0) =>
    1 > s[1] ? 1 > 0// (instead of 1 == s.Length) check if s[1] = NULL, and return true.
    : (
        s[0] < s[1] ? f // Rising, so use f...
        : // Else falling
            1 > i ? !(f=!f) // But this is the first call, so use true (but flip f)...
            : !f // Not first call, so use !f...
    )
    & B(s+1, !f, 1) // ...AND the previous value with a recursive call
                    // s+1 instead of s.Substring(1)
;
— दूध
स्रोत
पिछले की तरह लगता है कि ?:ऑपरेटर या कोष्ठक के बिना कर सकते हैं :unsafe bool B(char*s)=>1>s[2]|s[0]<s[1]!=s[1]<s[2]&B(s+1);
— Scepheo
वास्तव में, हालाँकि मैं इसका परीक्षण नहीं कर सकता, लेकिन सूचक को छेड़छाड़ करना स्वयं को भी unsafe bool B(char*s)=>1>s[2]|*s<s[1]!=*++s<s[1]&B(s);
— कष्टप्रद
@ Scepheo मुझे उन सुझावों के साथ StackOverflowException मिली, लेकिन वे बूलियन या ||बिटवाइज़ के बजाय या का उपयोग करके काम करते हैं |। पोस्ट अपडेट किया, धन्यवाद।
— दूध
6

सी 59 बाइट्स

r;f(s)char*s;{for(r=0;r=*s?~r&1<<(*s>=*++s):0;);return!*s;}
— cleblanc
स्रोत
70 बाइट्स में समाधान केस के लिए 1 (ट्रू) रिटर्न देता है AAA- उदाहरणों में पहला "फाल्सी"
— VolAnd
मैं परीक्षण का उपयोग कर रहा हूं gcc (GCC) 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)और मैं आआ और उत्तेजित के लिए गलत हूं। इस संस्करण में गैर-शून्य गलत है, और शून्य सत्य है। वास्तव में अब सोच रहे हैं कि क्या इसकी अनुमति है।
— क्लेब्लैंक सेप
f("ABCDEFGHIJKLMNOPQRSTUVWXYZ")विजुअल स्टूडियो 2012 रिटर्न में संकलित कॉल को 23उस मूल्य के रूप Trueमें माना जा सकता है, लेकिन प्रश्न में यह मूल्य "फाल्सी" खंड में है, इसलिए मूल्य 0अपेक्षित है।
— VolAnd
मुझे गलत और गलत की अनुमति दी गई थी। अब मैंने वह पोस्ट पढ़ ली है और यह स्पष्ट हो गया है कि "C" के लिए क्या मान होना चाहिए।
— क्लैब्लांक
यहाँ मेटा सर्वसम्मति के आधार पर सत्य और असत्य के लिए हमारी मानक परिभाषा है ।
— AdmBorkBork
5

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

OI>0IẠ

@Sanchises के जवाब के आधार पर ।

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

व्याख्या

OI>0IẠ  Input: string S
O       Convert each char in S to an ordinal
 I      Get the increments between each pair
  >0    Test if each is positive, 1 if true else 0
    I   Get the increments between each pair
     Ạ  Test if the list doesn't contain a zero, 1 if true else 0
— मील की दूरी पर
स्रोत
5

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

सरल उपाय।

s=input()
m=map(lambda x,y:y>x,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))

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

यदि एक पंक्ति में समान अक्षर न तो वृद्धि और न ही गिरावट थे, तो समाधान 79 बाइट्स होगा:

s=input()
m=map(cmp,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))
— mbomb007
स्रोत
5

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

के लिए +3 शामिल है -p(कोड में 'ऐसा -eउपयोग नहीं किया जा सकता है)

STDIN पर अपरकेस इनपुट दें:

bump.pl <<< AAA

bump.pl

#!/usr/bin/perl -p
s%.%$&.z lt$'|0%eg;$_=!/(.)\1./
— टन हास्पेल
स्रोत
5

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

g=lambda a,b,c,*s:((a<b)^(b<c))*(s==()or g(b,c,*s))

इनपुट की तरह लेता है g('B','U','M','P')और आउटपुट 1या 0।

पहले तीन अक्षरों को लेने के लिए अनपैकिंग तर्क का उपयोग करता है और जाँच करता है कि पहले दो दूसरे दो से अलग तुलना करते हैं। फिर, शेष पर पुनरावृत्ति करता है, जिसके लिए गुणा का उपयोग करता है and।

— XNOR
स्रोत
अच्छा इनपुट गोल्फ। ;-)
— AdmBorkBork
5

जेली , 6 5 बाइट्स

-1 बाइट के लिए धन्यवाद @ डेनिस (एक संचयी कमी का उपयोग करें)

<2\IẠ

सभी परीक्षण मामले TryItOnline पर हैं

कैसे?

<2\IẠ - main link takes an argument, s,    e.g. "BUMP"    or "BUMPY"
<    - less than comparison (a dyad)
 2   - literal 2 (a nilad)
  \  - n-wise overlapping reduction when preceded by a dyad-nilad chain
       (i.e. reduce the list by pairs with less than)
                                           e.g. [1,0,1]   or [1,0,1,1]
   I  - consecutive differences,           e.g. [-1,1]    or [-1,1,0]
    Ạ - All, 0 if any values are 0 else 1, e.g. 1         or 0

सभी अपरकेस या सभी लोअरकेस के लिए काम करता है।

— जोनाथन एलन
स्रोत
4

जाप, 8 बाइट्स

Uä> ä- e

इसे ऑनलाइन टेस्ट करें!

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

Uä> ä- e  // Implicit: U = input string
Uä>       // Map each pair of chars X, Y in U to X > Y.
    ä-    // Map each pair of items in the result to X - Y.
          // If there are two consecutive rises or falls, the result contains a zero.
       e  // Check that every item is truthy (non-zero).
          // Implicit: output last expression
— ETHproductions
स्रोत
मेरे समाधान के रूप में भी। सिवाय 11x छोटी। : P
— mbomb007
4

सी # 105 104 बाइट्स

bool f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t>0;}

105 बाइट्स समाधान:

bool f(char[]x){bool t=1>0,f=x[0]<x[1];for(int i=2,p=x[1];i<x.Length;)f^=t&=p<(p=x[i++])?!f:f;return t;}

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

ब्रैकेट के बाद अंतरिक्ष को छोड़ा जा सकता है, क्योंकि एक बाइट से बचाया चार्ट की एक सरणी का उपयोग करना। f(string x) vs f(char[]x)

यह 101 बाइट्स है अगर मैं बूल सही / गलत के बजाय 1 int वापस कर सकता हूं

int f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t;}
— pinkfloydx33
स्रोत
4

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

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y

मुझे संदेह है कि अगर मैं "जहां" निर्माण से छुटकारा पाने में कामयाब रहा, तो मैं इसे छोटा कर सकता हूं, लेकिन मैं शायद zipWith के साथ फंस गया हूं।

यह उगता की सूची बनाकर काम करता है (सच) और गिरता है (झूठा), फिर यह सूची बनाना कि क्या इस सूची में आसन्न प्रविष्टियाँ अलग हैं

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

Ungolfed संस्करण (168 बाइट्स)

isBumpy :: [Char] -> Bool
isBumpy input = and $ areBumps $ riseFall input
  where
    riseFall ax@(x:xs) = zipWith (>) xs ax
    areBumps ax@(x:xs) = zipWith (/=) xs ax

संक्षिप्त नाम, प्रकार की जानकारी निकालें (100 बाइट्स)

f x = and $ g $ h x
  where
    h ax@(x:xs) = zipWith (>) xs ax
    g ax@(x:xs) = zipWith (/=) xs ax

इसे मुख्य फ़ंक्शन में ले जाएँ क्योंकि यह केवल एक बार उपयोग किया जाता है (86 बाइट्स)

f ax@(x:xs) = and $ g $ zipWith (>) xs ax
  where
    g ax@(x:xs) = zipWith (/=) xs ax

एहसास है कि धक्कों और वृद्धि रहे हैं अमूर्त के समान हैं (73 बाइट्स)

f x  = and $ g (/=) $ g (>) x
  where
    g h ya@(y:ys) = zipWith h ys ya

ध्यान दें कि (पूंछ y) ​​हां @ से कम है (y: ys) (70 बाइट्स)

f x  = and $ g (/=) $ g (>) x
  where
    g h y = zipWith h (tail y) y

संवारना; अनावश्यक स्थान हटाएं (52 बाइट्स)

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y
— टेरोन
स्रोत
... and I've just noticed a shorter Haskell answer that was posted before mine that does basically the same thing. I am terrible at spotting things.
— Teron
You mean the one that doesn't work? ;-) You may use g h=tail>>=zipWith h and make it a global function to avoid the where keyword.
— Christian Sievers
@ChristianSievers Fixed it, and I just noticed this answer which now does exactly the same thing as mine, rendering my answer better suited as a comment to this one.
— BlackCap
4

Java 7, 157 153 150 125 117 bytes

int c(char[]z){for(int i=2,a,b,c;i<z.length;i++)if(((a=z[i-1])<(c=z[i])&(b=z[i-2])<a)|(a>=c&b>=a))return 0;return 1;}

Ungolfed & test cases:

Try it here.

class M{
  static int c(char[] z){
    for(int i = 2, a, b, c; i < z.length; i++){
      if(((a = z[i-1]) < (c = z[i]) & (b = z[i-2]) < a) | (a >= c & b >= a)){
        return 0; //false
      }
    }
    return 1; //true
  }

  public static void main(String[] a){
    System.out.print(c("ABA".toCharArray()) + ", ");
    System.out.print(c("ABB".toCharArray()) + ", ");
    System.out.print(c("BAB".toCharArray()) + ", ");
    System.out.print(c("BUMP".toCharArray()) + ", ");
    System.out.print(c("BALD".toCharArray()) + ", ");
    System.out.print(c("BALDY".toCharArray()) + ", ");
    System.out.print(c("UPWARD".toCharArray()) + ", ");
    System.out.print(c("EXAMINATION".toCharArray()) + ", ");
    System.out.print(c("AZBYCXDWEVFUGTHSIRJQKPLOMN".toCharArray()) + ", ");

    System.out.print(c("AAA".toCharArray()) + ", ");
    System.out.print(c("ACE".toCharArray()) + ", ");
    System.out.print(c("THE".toCharArray()) + ", ");
    System.out.print(c("BUMPY".toCharArray()) + ", ");
    System.out.print(c("BALDING".toCharArray()) + ", ");
    System.out.print(c("ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray()) + ", ");
  }
}

Output:

1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0
— Kevin Cruijssen
स्रोत
@TimmyD Hmm, so it's rise when a > b, but fall when a <= b, instead of > and <?
— Kevin Cruijssen
@TimmyD Ok, it's fixed, and even saves 3 bytes. :)
— Kevin Cruijssen
1
you can redefine your method to accept char[] so you dont have to transform your input string to char array. that should save a few bytes. PS: java ftw!
— peech
1
Did you perhaps means to change String s --> char[]z?
1
You can return a truthy or falsey value, so make your method an int and return 1 or 0 :).. Puts you down to 117 bytes
— Shaun Wild
3

PowerShell v2+, 83 bytes

param($n)($a=-join(1..($n.Length-1)|%{+($n[$_-1]-lt$n[$_])}))-eq($a-replace'00|11')

A little bit of a different approach. This loops through the input $n, each iteration seeing whether the previous character $n[$_-1] is -lessthan the current character $n[$_], then casting the result of that Boolean operator to an int with +. Those are -joined together into a string, stored into $a. We then check whether $a is -equal to $a with any substrings of 00 or 11 removed.

— AdmBorkBork
स्रोत
3

Python 2.7, 84 bytes

s=input()
b=s[0]<s[1]
o=1
for i in range(len(s)-1):o&=(s[i]<s[i+1])==b;b^=1
print o

Returns 1 for bumpy, 0 for otherwise

Learned some cool stuff with bitwise & and ^.
Starts with boolean b defining first pair as up/down, then tests and flips b for each following pair.
o flips to false if test fails and sticks.
Requires quotes around input (+4 bytes for raw_input() if that breaks some rule)

Test It

— greyShift
स्रोत
3

05AB1E, 9 bytes

SÇ¥0›¥_O_

Explanation

SÇ          # convert to list of ascii values
  ¥         # take delta's
   0›       # check if positive, giving a list of 1's and 0's
            # if they alternate, the word is bumpy
     ¥      # take delta's again, if we have any 0's in the list the word is not bumpy
      _     # logical negation, turning 0 into 1 and everything else to 0
       O    # sum, producing 0 for a bumpy word and 1 for a non-bumpy word
        _   # logical negation, inverting the previous 1 into 0 and vice versa

Try it online!

— Emigna
स्रोत
2

Python 2.7 (again, 84 83 bytes)

def a(s):x=s[1:];return[cmp(s[0],x)]+a(x) if x else []
print len(set(a(input())))>1

Or, 78 77 bytes without the print.

By the way, the above 56 byte Python 2.7 example breaks on, for example, "abbab" or any other input with repeated characters. Never mind, didn't read instructions. Revising.

Okay, down to 83. The triples one is nicer though.

— Timothy Teräväinen
स्रोत
Here's some tips for ya. 1. Remove some whitespace a(x)if x else[]. 2. Use a lambda instead a=lambda s:[cmp(s[0],s[1:])]+a(s[1:])if s[1:]else[] 3. Use a lambda at the end instead of printing. lambda s:len(set(a(s)))>1 4. if len(set(a(s))) isn't greater than 1, than it's already falsy, so you can take off >1
— DJMcMayhem
2

CJam, 15 bytes

l2ew::<2ew::^:*

Try it online! (As a linefeed-separated test-suite.)

Explanation

l    e# Read input.
2ew  e# Get all (overlapping) pairs.
::<  e# Check whether each pair is strictly ascending (1) or not (0).
2ew  e# Get all (overlapping) pairs.
::^  e# Take the bitwise XOR of each pair, giving 1 if a rise and a fall alternate,
     e# and zero if there are two rises or two falls in succession.
:*   e# Product. Gives 1 only if the previous step yielded a list of 1s, meaning
     e# that any two consecutive rises/falls will turn this into a zero.
— Martin Ender
स्रोत
2

PHP, 80 bytes

$s=$argv[1];for($c=$s[0];$n=$s[++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

or

for($c=$argv[1][0];$n=$argv[1][++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

empty output for false, 1 for true

or Hedi´s recursive approach ported and a little golfed for 70 bytes:

function f($s){return!$s[2]|$s[0]<$s[1]^$s[1]<$s[2]&&f(substr($s,1));}

Actually, this should recurse infinitely for bumpy words, but it does not!

— Titus
स्रोत
2

Haskell, 30 37 bytes

q f=tail>>=zipWith f;k=and.q(/=).q(>)

Usage:

Prelude> k <$> words "ABA ABB BAB BUMP BALD BALDY UPWARD EXAMINATION AZBYCXDWEVFUGTHSIRJQKPLOMN"
[True,True,True,True,True,True,True,True,True]

Prelude> k <$> words "AAA BBA ACE THE BUMPY BALDING ABCDEFGHIJKLMNOPQRSTUVWXYZ"
[False,False,False,False,False,False,False]
— BlackCap
स्रोत
That doesn't accept "bald", foldl1(/=) doesn't do what you think it does.
— Christian Sievers
@ChristianSievers Auch, you're right. Thanks for the heads up
— BlackCap
2

PHP 7, 137 118 bytes

for($i=0;$i<strlen($argv[1])-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}

Empty output for Bumpy, 0 for Not Bumpy.

This is my first attempt at code golfing and I have to improve a lot, but it was a wonderful method to learn new things for me. I also wanted to challenge myself on that task by using the new PHP 7 Spaceship Operator which seems very interesting.

Anyway I'm not satisfied about it, first of all for the fact that I had to add an extra if(isset($s[$i+2])) to check if the variable exist because I did not find another workaround to the problem, but this is it for now. (Note: I fixed that simply by changing strlen($s)-1 to strlen($s)-2, I couldn't really see that before...).

Testing code:

$as = array("ABA", "ABB", "BAB", "BUMP", "BALD", "BALDY", "UPWARD", 
            "EXAMINATION", "AZBYCXDWEVFUGTHSIRJQKPLOMN", "AAA", "BBA", 
            "ACE", "THE", "BUMPY", "BALDING", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

foreach ($as as $s) {
    for($i=0;$i<strlen($s)-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}
}

Test online

— Mario
स्रोत
Hello, and welcome to PPCG! Great first post!
— NoOneIsHere
Welcome to PPCG! Nice first post. Check out Tips for PHP for some additional golfing suggestions.
— AdmBorkBork
1

Javascript ES6, 100 bytes

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}

Try it here: 

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}
alert(a(prompt()));
Expand snippet

Oh come on two people already beat me to it by 40 bytes... whatever

— Bald Bantha
स्रोत
Hint: "A"<"B", so you don't need to get the chars' charcodes.
— ETHproductions
Also, this returns 1 for BUMPY (or anything else that contains both a rise and a fall).
— ETHproductions
This doesn't seem to quite work right.
— AdmBorkBork
1

Python 3, 148 139 127 bytes

def _(w):*r,=map(lambda a,b:0>ord(a)-ord(b)and-1or 1,w,w[1:]);s=len(r)%2==0and r+[r[0]]or r;return sum(s)in(-1,1)and s==s[::-1]

testing code

positives = ('ABA', 'ABB', 'BAB', 'BUMP', 'BALD', 'BALDY', 'UPWARD', 'EXAMINATION', 'AZBYCXDWEVFUGTHSIRJQKPLOMN')
negatives = ('AAA', 'BBA', 'ACE', 'THE', 'BUMPY', 'BALDING', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

for w in positives:
    print(_(w), w)
    assert _(w)

for w in negatives:
    print(_(w), w)
    assert not _(w)
— Jeffrey04
स्रोत
i really suck at this #facepalm
— Jeffrey04
Welcome to PPCG! Check out Tips for Golfing in Python, and take inspiration from the other answers.
— AdmBorkBork
1

C, 65 57 60 bytes

 r;f(char*s){for(r=0;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

is fix of

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

that works correctly with any data only at single function call (when the global variable r is initialized to zero).

But in any case this is shorter than previous solution (65 bytes) due to use of for instead of while. But previous (the following) is a little easier to understand:

r;f(char*s){while(*++s)if(!(r=~r&1<<(*s>*(s-1))))break;return r;}

My solution is based on bitwise & with inverted previous and current direction code, where direction code can be 2 (1<<1) for character code increase (*s > *(s-1)) or 1 (1<<0) otherwise. Result of this operation became 0 if we use the same direction code as previous and current, i.e. when word is not Bumpy.

UPDATE:

Code for testing:

#include <stdio.h>
#include <string.h>

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

int main(void)
{
    char * Truthy[] = { "ABA", 
                        "ABB", 
                        "BAB",
                        "BUMP",
                        "BALD",
                        "BALDY",
                        "UPWARD",
                        "EXAMINATION",
                        "AZBYCXDWEVFUGTHSIRJQKPLOMN" };
    char * Falsey[] = { "AAA",
                        "BBA",
                        "ACE",
                        "THE",
                        "BUMPY",
                        "BALDING",
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
    int posTestNum = sizeof(Truthy) / sizeof(char *);
    int negTestNum = sizeof(Falsey) / sizeof(char *);
    int i;
    int rate = 0;
    int tests = 0;
    int res = 0;
    printf("Truthy (%d tests):\n", posTestNum);
    for (i = 0; i < posTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Truthy[i], f(Truthy[i]) ? (rate++, "OK") : "Fail");
        r = 0;
    }
    printf("\nFalsey (%d tests):\n", negTestNum);
    for (i = 0; i < negTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Falsey[i], f(Falsey[i]) ? "Fail" : (rate++, "OK"));
        r = 0;
    }
    printf("\n%d of %d tests passed\n", rate, tests);
    return 0;
}
— VolAnd
स्रोत
Per meta consensus, functions have to be reusable. That means you cannot reset r to 0 for free, but must do so from within the function.
— Dennis
@Dennis You're right, initialization is required, but only for repeated calls. Let's assume that for a single call that works with any data because compiler provide initialisation for global variables
— VolAnd
I think you should make the 60 byte solution your main one, since the 57 byte version isn't valid by that meta post I cited.
— Dennis
@Dennis Done! +3 bytes
— VolAnd
1

PHP, 100 bytes

for($s=$argv[1];$i<strlen($s)-1;$i++)$s[$i]=$s[$i+1]>$s[$i]?r:f;echo str_replace([rr,ff],'',$s)==$s;

Replaces every char of the string (except the last one obviously) with an r for rise or an f for fall and then checks whether rr or ff occur in the string. To avoid that the last remaining character interfers with that, input must be all uppercase.

I'm very unsatisfied with the loop, for example I have a feeling that there must be a way to combine the $i++ into one of the several $is used in the loop, but I failed to find that way. Maybe someone else sees it.

(That's also why I posted my code, despite it being 20 (!) bytes longer than Titus' nice solution.)

— Christallkeks
स्रोत
0

Java 8, 114 90 bytes

(c,b)->{b=c[0]<c[1];for(int i=2;i<c.length;i++)if(c[i]>c[i-1]!=(b=!b))return 0;return 1;};

Ungolfed test program

public static void main(String[] args) {
    BiFunction<char[], Boolean, Integer> func = (c, b) -> {
        b = c[0] < c[1];
        for (int i = 2; i < c.length; i++) {
            if (c[i] > c[i - 1] != (b = !b)) {
                return 0;
            }
        }
        return 1;
    };

    System.out.println(func.apply("ABCDEFG".toCharArray(), false));
    System.out.println(func.apply("AZBYCXDGEF".toCharArray(), false));
    System.out.println(func.apply("ZXZXZX".toCharArray(), false));
    System.out.println(func.apply("ZXCYZ".toCharArray(), false));
    System.out.println(func.apply("AAA".toCharArray(), false));
}
— Shaun Wild
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.