लहराते शब्दों का पता लगाएं!

Question

(ध्यान दें: यह मेरी पिछली चुनौती का एक आसान स्पिन-ऑफ है । इन्फिनिटी वर्ड्स ढूंढें!, जो मेरी अन्य पिछली चुनौती का स्पिन-ऑफ है, जो घूमता हुआ शब्द खोजें! :)

एक लहराती शब्द की परिभाषा :

1. यदि आप एक लहराती शब्द के सभी वर्णों के साथ जुड़ते हैं तो वर्णमाला (AZ) पर आप एक तरंग का मार्ग लगातार दाईं ओर या बाईं ओर और कभी नहीं बदलते दिशा की तरह प्राप्त करते हैं, जैसे नीचे दिए गए चित्र में।
2. एक लहराती शब्द हो सकता है:
   • उठाना अगर प्रत्येक लगातार चरित्र पिछले एक के दाईं ओर (वर्णमाला पर) है।
   • घटाना अगर प्रत्येक लगातार चरित्र पिछले एक के बाईं ओर (वर्णमाला पर) है।
3. सभी समान कनेक्शन नीचे होने चाहिए, सभी विषम कनेक्शन ऊपर होने चाहिए।
4. आप ऊपरी / निचले हिस्से को अनदेखा कर सकते हैं या सभी ऊपरी मामले या सभी निचले मामले में विचार / रूपांतरण कर सकते हैं।
5. AZ के वर्णमाला रेंज में इनपुट शब्द केवल वर्ण हैं, कोई रिक्त स्थान, कोई विराम चिह्न या प्रतीक नहीं हैं।
6. यदि किसी शब्द में दोहरे वर्ण होते हैं, जैसे "SPOON", तो आपको युगल को एक वर्ण में ढोना होगा: "SPOON"> "SPON" (क्योंकि यदि आप O से O तक जाते हैं तो शून्य दूरी है)।
7. लहरदार शब्द कम से कम 3 अलग वर्ण हो जाएगा (के बाद भी युगल गिर)।

यहाँ कुछ उदाहरण हैं:

कार्य:

एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें जो मानक इनपुट से एक शब्द लेगा और आउटपुट देगा यदि यह एक लहरदार शब्द है या नहीं, और सकारात्मक मामले में, आउटपुट अगर यह बढ़ा या घट रहा है । उत्पादन हो सकता है True/False/Null, 2/1/0, 1/Null/0, -1/0/1, NO/WR/WD, आदि, आप यह कैसे का प्रतिनिधित्व करने का फैसला।

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

WAVY WORDS:
  ADEPT, BEGIN, BILL, BOSS, BOOST, CHIMP,
  KNOW, SPONGE, SPOON, TROLL, WOLF  

ADEPT  > YES > RAISING
BEGIN  > YES > RAISING
BILL   > YES > RAISING
BOSS   > YES > RAISING
BOOST  > YES > RAISING
CHIMP  > YES > RAISING
KNOW   > YES > RAISING
SPONGE > YES > DECREASING
SPOON  > YES > DECREASING
TROLL  > YES > DECREASING
WOLF   > YES > DECREASING

NOT WAVY WORDS:
  WATCH, EARTH, NINON, FOO, BAR, WAVE, SELECTION,
  YES, NO, DEFINITION, WATER, WINE, CODE, AAAHHHH, I, MM, ABCA

नियम:

• सबसे छोटा कोड जीतता है।

वैकल्पिक कार्य:

एक सूची के रूप में, एक अंग्रेजी शब्दकोश में आप कर सकते हैं के रूप में कई लहराती शब्दों का पता लगाएं, और सबसे लंबा भी। आप उदाहरण के लिए अंग्रेजी शब्दों की पूरी सूची यहाँ संदर्भ के लिए ले सकते हैं ।

Comments

आपने चित्र कैसे बनाए?

— ओलिवर नी

Illustrator के साथ @ ओलिवर क्योंकि मेरे पास यह काम के लिए है, लेकिन जिम्प या इंक्सकैप, या अन्य के साथ समान परिणाम प्राप्त करना संभव है।

— मारियो

NOऔर FOOआपके नियमों द्वारा मान्य इनपुट नहीं हैं।

— पुरकाकूदरी

@ Pietu1998 वे NOT WAVY WORDSअनुभाग में हैं, हालांकि, जो सही है ..

— Kade

@xnor # 5 आप मान सकते हैं कि सभी इनपुट शब्द वर्णित हैं, जिन्हें मान्य करने की कोई आवश्यकता नहीं है। # 7 यह एक तरंग आकार बनाने के लिए अक्षरों की न्यूनतम संख्या है। बाकी के लिए आप अपनी पसंद के अनुसार आउटपुट तय करते हैं।

— मारियो

Answer 1

05AB1E , 11 9 बाइट्स (अदनान को धन्यवाद)

Dg2›iÇü‹Ù

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

लहरदार मामले:

0 - घटती लहराती

1 - लहराती बढ़ रही है

लहराती मामले नहीं:

[0,1] - लहराती नहीं, शुरू में कम होती है, लेकिन फिर वृद्धि / समानता होती है जिसने पैटर्न को तोड़ दिया।

[१०२] - लहराती नहीं है, शुरू में बढ़ती है, लेकिन फिर एक कमी / समानता है जिसने पैटर्न को तोड़ दिया है

इनपुट स्ट्रिंग - लंबाई के कारण पहली जगह पर लहराया जाना संभव नहीं है।

स्पष्टीकरण:

Dg2›iÇü‹Ù   # Full program

D           # Push 2 copies of input.
 g2›i       # If length is greater than 2. 
     Ç      # Push ASCII values for all characters in the string.
      ü     # Push pairwise array.
       ‹    # Vectorize 1 if negative difference, 0 if positive difference.
        Ù   # Uniquify using right most unique values first.
            # Else just print the string back, letting them know it's not valid input.

Comments

@JonathanAllan Dangit ... मैंने अभी टिप्पणियों और परिवर्तनों को देखा ... मेरा The input words will contain at least 3 distinct charactersमतलब था कि मुझे 3 से कम शब्दों को संभालना नहीं था। परिवर्तनों पर काम करना, थोड़ी देर लग सकती है; यह मेरा पहला उत्तर है जो मैं 05AB1E में करने में सक्षम था।

— मैजिक ऑक्टोपस Urn

@JonathanAllan फिक्स्ड :)! लेकिन अब तुम मुझे मार रहे हो;)

— मैजिक ऑक्टोपस उर्न

बहुत अच्छा! एक टिप, :) ü‹के समान हैü-0‹

— अदनान

हेहेहे ... यार, मुझे बस अजगर सीखना होगा और 05AB1E का विस्तार करने में मदद करना शुरू करना होगा। यह भाषा प्रभावशाली है। पारितोषिक के लिए धन्यवाद!

— मैजिक ऑक्टोपस Urn

Answer 2

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

OIṠḟ0µL’aQ

TryItOnline! या सभी परीक्षण मामलों को चलाएं

यह दिखाता है:
[1]लहरदार बढ़ाने के लिए
[-1]लहरदार कम करने के लिए
कुछ और नहीं तो कुछ ( [], [0], [-1,1], या [1,-1])

(अनावश्यक रूप घोषित: के लिए प्रत्येक के लिए एक एकल मान OIṠḟ0µL’aQS(11 बाइट्स) वापस आ जाएगी 1, -1और 0क्रमशः।)

कैसे?

OIṠḟ0µL’aQ - Main link: s
O          - cast to ordinals
 I         - incremental differences
  Ṡ        - sign (-1 for decreasing, 0 for no change, 1 for increasing)
   ḟ0      - filter out zeros
     µ     - monadic chain separation
      L    - length
       ’   - decremented
        a  - and
         Q - unique items

Comments

क्या आपको न तो मामले के लिए 3 अलग-अलग संभावित आउटपुट की अनुमति है?

— xnor

मैंने "हां, यह तय करने के लिए कि आपको इसका प्रतिनिधित्व कैसे करना है" लिया, हां, जब तक वे अलग हैं। हालाँकि नियम # 5 के बारे में आपका प्रश्न इसे अमान्य कर सकता है (और शायद हर दूसरी प्रविष्टि)।

— जोनाथन एलन

जरूरत पड़ने पर उसका समाधान जोड़ा।

— जोनाथन एलन

क्या आप केवल सूची नहीं दे सकते?

— xnor

ओह, हाँ, बिल्कुल> _ <धन्यवाद।

— जोनाथन एलन

Answer 3

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

lambda s:[2<len(set(s))<s[::b]==sorted(s)for b in-1,1]

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

[False, True] for ascending
[True, False] for descending
[False, False] for neither

यह जांचता है कि क्या सॉर्ट किया गया इनपुट स्ट्रिंग इसके मूल या रिवर्स के बराबर है। 1 और -1 के स्टेप साइज के साथ स्लाइस करके ऐसा करता है। उसी समय, हम जांचते हैं कि क्या शब्द में कम से कम 2 अलग अक्षर हैं।

यदि "त्रुटि के साथ बाहर निकलें" न तो मामले के लिए आउटपुट का उपयोग किया जा सकता है, तो हम 51 बाइट्स तक नीचे जा सकते हैं:

lambda s:[s,s[::-(len(set(s))>2)]].index(sorted(s))

Comments

बहुत यकीन है कि आप पात्रों की एक सूची ले सकते हैं क्योंकि यह एक स्ट्रिंग के रूप में निर्दिष्ट नहीं है: meta.codegolf.stackexchange.com/a/2216/8478

— जोनाथन एलन

Answer 4

पायथन 3, 77 75 बाइट्स

lambda x:(len(set(x))>2)*(list(x)==sorted(x)or(list(x)==sorted(x)[::-1])*2)

मान लें कि सभी पत्र एक ही मामले के हैं।

यह दिखाता है:

• 0 अगर लहराती नहीं
• 1 अगर आगे लहराती है
• 2 अगर पीछे की तरफ लहराती है

अनावश्यक रिक्त स्थान हटा दिया गया है धन्यवाद @ETHproductions

Comments

PPCG में आपका स्वागत है, और पहला अच्छा जवाब! हालांकि, आपको यह भी सुनिश्चित करने की आवश्यकता है कि स्ट्रिंग में कम से कम तीन अलग-अलग वर्ण हैं; यदि नहीं, तो यह एक लहराती शब्द नहीं है, चाहे जो भी हो।

— ETHproductions

ठीक है। एक लहराती शब्द की परिभाषा पर करीब से देखा जाना चाहिए। फिक्स्ड।

— सी। स्मिथ

अच्छा! मैं अजगर विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि आप दोनों में से किसी एक जगह को हटा सकते हैं or।

— ETHproductions

हाँ, तुम सही हो। कोष्ठक के साथ भावों को घेरने के बाद उन्हें निकालना भूल गए। पकड़ने के लिए धन्यवाद!

— सी। स्मिथ

Answer 5

आर, 96 95 बाइट्स

function(x,d=diff(rle(utf8ToInt(x))$v))if(any(d>0)&any(d<0)|sum(1|d)<2)3 else`if`(all(d<1),2,1)

यह दिखाता है:

• 1 लहराती और उभार लिए
• 2 लहरदार और कम करने के लिए
• 3 गैर-लहराती के लिए

व्याख्या की

• d=diff(rle(utf8ToInt(x))$v): dपहली बार स्ट्रिंग को परिवर्तित करके एक वैरिएबल बनाता है इसमें वे ASCIIमान हैं utf8ToIntजिनका उपयोग करके आसानी से एक वेक्टर वापस आ जाता है। बाद में रन लंबाई एन्कोडिंग का उपयोग कर प्रदर्शन करते हैं rle। rle(...)$vअनुक्रम के दोहराए जाने वाले मानों को लौटाता है (यानी सभी रन ढहना)। अंत में अंतर लें।
• if(any(d>0)&any(d<0)|sum(1|d)<2)3: यदि कम से कम एक अंतर सकारात्मक है और कम से कम एक नकारात्मक है, या यदि अंतर अनुक्रम 2तत्वों से कम है (मूल शब्द 3 वर्णों से कम है), तो शब्द गैर-लहराती है और वापस आ जाती है3
• else``if``(all(d<1),2,1): यदि सभी अंतर नकारात्मक हैं, तो 2लहराती और घटती हुई वापसी, अन्यथा 1लहराती और उठी हुई वापसी ।

---

आर-फिडल पर सभी परीक्षण मामलों की कोशिश करें (ध्यान दें कि इसका नाम ऐसा है कि इसे परीक्षण मामलों के लिए वेक्टर किया जा सकता है)।

Answer 6

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

s=>(new Set(t=[...s]).size>2)*(!t.some((c,i)=>c>s[i+1])-!t.some((c,i)=>c<s[i+1]))

इनपुट मानता है कि सभी एक ही मामले में हैं। रिटर्न 1, लहरदार ऊपर उठाने के लिए -1लहरदार कम करने के लिए, 0या -0के लिए लहरदार नहीं (दोनों falsy हैं)। संपादित करें: @RobertHickman के लिए 3 बाइट्स सहेजे गए।

Comments

मैं नई विशेषताओं का विशेषज्ञ नहीं हूं, लेकिन क्या आप हटा सकते हैं new?

— साइओस

@ नई सुविधाओं का सही उपयोग करें new।

— नील

@ निएल, मेरा मानना ​​है, आप सेट () फ़ंक्शन के अंदर एक अन्य चर को इनिशियलाइज़ करके एक बाइट बचा सकते हैं t=[...s]और उन दो स्पॉट्स में [... s] के बजाय t का उपयोग कर सकते हैं।

— रॉबर्ट हिकमैन

Answer 7

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

i=>new Set(s=[...i]).size>2?[i,s.reverse().join``].indexOf(s.sort().join``):-1

जहां लहराती बढ़ती 0 है, घटाना 1 है, और -1 लहराती नहीं है।

2 बाइट बचाने में मेरी मदद करने के लिए @ निएल को धन्यवाद ।

Comments

new Set(s=[...i])आपको 2 बाइट्स बचाता है। (यह पुनरावृत्ति करके काम करता है i, इसे एक सरणी में बदलकर, सरणी को पुनरावृत्त करता है, और इसे एक सेट में बदल देता है। उल्टा लेकिन आप गोल्फ बनाते समय उस तरह की चिंता नहीं करते हैं।)

— नील

Answer 8

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

x*<2lrQ8_BQS

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

Answer 9

पायथन 2, 53 52 50 बाइट्स

उद्धरणों में संलग्न इनपुट की अपेक्षा करता है, जैसे "watch"

अनाम लंबोदर के रूप में:

lambda s:(sum(map(cmp,s[1:],s))+1)/min(len(s)-1,3)

द्वारा प्रत्येक अक्षर और पूर्णांक-विभेद के बीच अंतर का संकेत देता है len-1। यदि सभी थे 1(बढ़ते हुए) तो len-1वह है जो प्रदर्शित करता है 1, घटने के लिए -1और मिश्रित के लिए समान है 1, -1यह योग len-1प्रदर्शित होने की तुलना में छोटा है 0।

-1 बाइट को बदलने के cmp,s[1:],s[:-1])लिएcmp,s[1:],s)+1

Comments

वापस आ जाएगी 1के लिए"NO"

— जोनाथन एलन

@JonathanAllan LMNOPतो O, N के बाद है जिसका मतलब है बढ़ता हुआ जिसका अर्थ है 1

— कार्ल नेफ

हां, लेकिन 3 अक्षरों से कम के किसी भी शब्द (किसी भी नकली पत्र को हटाने के बाद) को लहराती नहीं के रूप में परिभाषित किया गया था ("नहीं" लहराती परीक्षण मामलों में नहीं है)।

— जोनाथन एलन

@JonathanAllan ने इस lenमुद्दे को ठीक किया , लेकिन मैं दोहराए गए चार्ट अभी भी एक समस्या हैं

— कार्ल नेफ

Answer 10

रूबी, 54 बाइट्स

->w{c=w.chars.uniq;c==(s=c.sort)?2:(c==s.reverse)?1:0}

रिटर्न 0अगर शब्द, लहरदार नहीं है 1, तो पीछे की ओर लहराती, और 2अगर आगे लहरदार।

Answer 11

ग्रूवी - 56 बाइट्स

{घ = यह [0]; ग = [0] * 3; it.each {a-> ग [(क <=> घ)] = 1; d = एक}; ग [1 ..- 1]}

[1,0]लहराती बढ़ाने के लिए आउटपुट , लहराती [0,1]घटने के लिए, [0,0]एकल चरित्र इनपुट के लिए या [1,1]गैर-लहराती के लिए।

नोट: मान लें कि इनपुट या तो एक स्ट्रिंग है या एक चार [] और सभी अक्षर एक ही मामले के हैं।

Answer 12

PHP, 96 बाइट्स

for(;($t=$argv[1])[++$i];)$s+=$r[]=$t[$i-1]<=>$t[$i];echo(max($r)-min($r)<2)*(0<=>$s)*(1<$s*$s);

या 98 बाइट्स

$s=str_split($t=$argv[1]);sort($s);echo(-($t==strrev($j=join($s)))|$t==$j)*!!count_chars($t,3)[2];

0 नहीं लहराती 1 -1 को कम करना

Comments

-के बजाय 2*(घटते के लिए -1: 1 बाइट)। *(!!...)कोई कोष्ठक की जरूरत है। (-2)

— टाइटस

$s*$s>1इसके बजाय abs($s)>1(-2)

— टाइटस

@ टिट्स डन थैंक यू

— जॉर्ग हल्सरमैन

Answer 13

PHP, 100 बाइट्स

$n=$m=$l=str_split($argv[1]);sort($n);rsort($m);echo(($n==$l)-($m==$l))*(count(array_unique($l))>2);

यह दिखाता है:

• -1 लहरदार के लिए, घटते हुए।
• 0 लहराती नहीं के लिए।
• 1 लहराती के लिए, उठा।

Comments

!!array_unique($s)[2]के बजायcount(array_unique($l))>2

— Jörg Hülsermann

असल में, इसके साथ समस्या यह है कि array_unique कुंजियों को प्रबल करेगा। इस प्रकार array_unique का उपयोग करते समय aaabc जैसा एक इनपुट मिथ्या आउटपुट 0 होगा।

— चोकोचोस

Answer 14

सी, 164 बाइट्स

main(){char s[99];scanf("%s",s);char *c=&s;int p=*c;while(*c^0){if(p>*c){if(c-&s[0]>1)return 0;while(*c^0){if(p<*c)return 0;p=*c;c++;}return 2;}p=*c;c++;}return 1;}

रिटर्न 0 अगर वाउ नहीं, तो 1 वाउ और राइजिंग, 2 अगर घटती है।

Answer 15

रैकेट 321 बाइट्स

(let*((ld(λ(sl)(for/list((i(sub1(length sl))))(-(list-ref sl(add1 i))(list-ref sl i)))))(l(ld(remove-duplicates(map
(λ(x)(char->integer x))(string->list s)))))(am andmap)(N"Not WAVY")(d displayln))(cond[(<(length l)2)(d N)][(am(λ(x)(>= x 0))l)
(d"YES; RAISING")][(am(λ(x)(<= x 0))l)(d"YES; DECREASING")][else(d N)])))

Ungolfed:

(define (f s)
  (let*  ((ld (lambda(sl)          ; sub-fn to get differences in list elements
                (for/list ((i (sub1(length sl))))
                  (- (list-ref sl (add1 i))
                     (list-ref sl i) ) )))
          (l (ld
              (remove-duplicates
               (map
                (lambda(x)
                  (char->integer x))
                (string->list s)))))
          (am andmap)
          (N "Not WAVY")
          (d displayln))
    (cond
      [(< (length l) 2)(d N)]
      [(am (lambda(x) (>= x 0)) l) (d "YES; RAISING")]
      [(am (lambda(x) (<= x 0)) l) (d "YES; DECREASING")]
      [else (d N)]
      )))

परिक्षण:

(f "ADEPT"); > YES > RAISING
(f "BEGIN"); > YES > RAISING
(f "BILL"); > YES > RAISING
(f "BOSS"); > YES > RAISING
(f "BOOST"); > YES > RAISING
(f "CHIMP"); > YES > RAISING
(f "KNOW"); > YES > RAISING
(f "SPONGE"); > YES > DECREASING
(f "SPOON"); > YES > DECREASING
(f "TROLL"); > YES > DECREASING
(f "WOLF"); > YES > DECREASING

(f "WATCH")
(f "EARTH")
(f "NINON")
(f "FOO")
(f "BAR")
(f "WAVE")
(f "SELECTION")

आउटपुट:

YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; RAISING
YES; DECREASING
YES; DECREASING
YES; DECREASING
YES; DECREASING
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY
Not WAVY

Answer 16

जावा 7, 254 240 बाइट्स

import java.util.*;int c(String s){char[]a=s.toCharArray(),x=a.clone();Arrays.sort(x);return s.replaceAll("(.)\\1{1,}","$1").length()<3?0:Arrays.equals(a,x)|Arrays.equals(x,(new StringBuffer(s).reverse()+"").toCharArray())?a[0]>a[1]?1:2:0;}

आउटपुट 0यदि इनपुट स्ट्रिंग, लहरदार नहीं है 1अगर यह एक को ऊपर उठाने लहर है, और 2यह एक कम लहर है या नहीं।

Ungolfed और परीक्षण कोड:

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

import java.util.*;
class M{
  static int c(String s){
    char[] a = s.toCharArray(),
           x = a.clone();
    Arrays.sort(x);
    return s.replaceAll("(.)\\1{1,}", "$1").length() < 3
            ? 0
            : Arrays.equals(a, x) | Arrays.equals(x, (new StringBuffer(s).reverse()+"").toCharArray())
               ? a[0] > a[1]
                  ? 1
                  : 2
               : 0;
  }

  public static void main(String[] a){
    System.out.print(c("ADEPT") + ", ");
    System.out.print(c("BEGIN") + ", ");
    System.out.print(c("BILL") + ", ");
    System.out.print(c("BOSS") + ", ");
    System.out.print(c("BOOST") + ", ");
    System.out.print(c("CHIMP") + ", ");
    System.out.println(c("KNOW"));

    System.out.print(c("SPONGE") + ", ");
    System.out.print(c("SPOON") + ", ");
    System.out.print(c("TROLL") + ", ");
    System.out.println(c("WOLF"));

    System.out.print(c("WATCH") + ", ");
    System.out.print(c("EARTH") + ", ");
    System.out.print(c("NINON") + ", ");
    System.out.print(c("FOO") + ", ");
    System.out.print(c("BAR") + ", ");
    System.out.print(c("WAVE") + ", ");
    System.out.print(c("SELECTION") + ", ");
    System.out.print(c("YES") + ", ");
    System.out.print(c("NO") + ", ");
    System.out.print(c("DEFINITION") + ", ");
    System.out.print(c("WATER") + ", ");
    System.out.print(c("WINE") + ", ");
    System.out.print(c("CODE") + ", ");
    System.out.print(c("AAAHHHH") + ", ");
    System.out.print(c("I") + ", ");
    System.out.print(c("MM") + ", ");
    System.out.println(c("ABCA"));
  }
}

आउटपुट:

2, 2, 2, 2, 2, 2, 2
1, 1, 1, 1
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

Comments

int c(char[]s){int t=s[0],f=s.length,a=1,b=1,i;for(i=1;i<f;){if(s[i]-s[i-1]>=0)++a;if(s[i]-s[i++-1]<1)++b;}return a==f?1:b==f?-1:0;}(132 बाइट्स)

— नंबर

आउटपुट 1 अगर लहराती है, तो आउटपुट -1 अगर लहराती घटती है, तो 0 नहीं, अगर लहराती नहीं है

— 12