एक इनपुट स्ट्रिंग एस को देखते हुए, truthyयदि एस के सभी अक्षर लेक्सिकली ऑर्डर किए गए हैं , तो वापस लौटें : उनके एएससीआईआई मूल्यों को आरोही या अवरोही क्रम में होना चाहिए। falsyअन्य मामलों में लौटें ।

इनपुट

इनपुट एक ही मामले में होगा (सभी ऊपरी या सभी लोअरकेस)। आपका सबमिशन दोनों को संभालने में सक्षम होना चाहिए।
इनपुट में [A-Za-z]केवल सीमा में ASCII शामिल होगा
आपकी भाषा का अधिकतम समर्थन करने के लिए इनपुट की लंबाई कम से कम 1 होगी।
इनपुट एक स्ट्रिंग है - वर्णों की सूची नहीं, ASCII-codepoint की एक सरणी नहीं।

उत्पादन

आउटपुट होना चाहिए trueया false, या 0/1, या किसी अन्य विशिष्ट true / falseशैली उत्पादन अपनी भाषा प्रदान कर सकते हैं।
सभी सच्चे मामलों में समान आउटपुट और साथ ही सभी झूठे मामलों की आवश्यकता होती है। कोई भी "गलत 0 नहीं है, सच 1, 2 या 3 है"।

अतिरिक्त नियम

मानक खामियों को मना किया जाता है
उत्तर एक पूर्ण कार्यक्रम या एक फ़ंक्शन होना चाहिए, न कि एक स्निपेट या एक REPL- प्रविष्टि।
कोड-गोल्फ , बाइट्स जीत में सबसे छोटा जवाब।

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

Truthy

"ABCDEF"
"ZYX"
"no"
"tree"   --> the multiple 'e's don't break the order
"q"

Falsy

"ABCDC"
"yes"
"deed"

अमान्य

"Hello" --> invalid input - mixed case-, does not have to be handled
""      --> invalid input - length 0-, does not have to be handled
"\n
  "     --> invalid input - newline is not in range [A-Za-z]-, does not have to be handled

— steenbergh
स्रोत

1

क्या आप आउटपुट के बारे में स्पष्ट कर सकते हैं: क्या इनपुट दिए जाने की परवाह किए बिना सत्य मूल्य की आवश्यकता है?

— बिजनेस कैट

1

@BusinessCat मैंने एक स्पष्टीकरण जोड़ा है।

— steenbergh

क्या होगा अगर आपकी भाषा एक स्ट्रिंग का कार्यान्वयन वर्णों की एक सूची है? यहाँ पोस्ट किए गए कई उत्तर ऐसी भाषाओं का उपयोग कर रहे हैं ...

— theonlygusti

1

यदि आप वास्तव में True और False के लिए अलग-अलग मान चाहते हैं, तो आपको truthyया नहीं कहना चाहिए falsy। इसका तात्पर्य यह है कि किसी भी मूल्य का मूल्यांकन trueया करने falseकी अनुमति है।

— 21

3

संबंधित: लहराती शब्दों का पता लगाएं!

— टाइटस

8

05AB1E , 5 बाइट्स

Â)¤{å

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

व्याख्या

Â)     # pair the input with it's reverse in a list
  ¤{   # get a copy of the reverse and sort it
    å  # check if the sorted copy is in the list of [input,reverse_input]

— Emigna
स्रोत

{Â¹å4 के लिए, मेरे उत्तर को हटा दिया। ध्यान नहीं दिया द्विभाजित का उपयोग करें, मेरा भी समान था।

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

@carusocomputing: यह दुर्भाग्य से केवल जांच करेगा कि इनपुट सॉर्ट किए गए इनपुट के विपरीत है या नहीं।

— इमिग्ना

या सॉर्ट किए गए इनपुट के बराबर। aba => ['aab', 'baa'] => is in? => 0| aab => same => 1

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

@carusocomputing: सॉर्ट किए गए इनपुट को अनदेखा कर दिया जाता है क्योंकि यह स्टैक पर रिवर्स के नीचे है। आप उन्हें कभी सूची में शामिल नहीं करते।

— इमीना

डिब्बाबंद लिपटे आउटपुट शपथ; एनवीएम, मुझे अनदेखा करें।

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

17

पायथन 2 , 53 44 40 39 बाइट्स

lambda a:`sorted(a)`[2::5]in(a,a[::-1])

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

— छड़ी
स्रोत

अच्छा है, लेकिन यह अमान्य मूल्यों के

— पैट्रिक बार्ड

5

@PatrickBard मिश्रित मामला एक अमान्य इनपुट है, इसे संभाला नहीं जाना चाहिए

— रॉड

13

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

(%)=scanl1
f s=s==max%s||s==min%s

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

अलियासिंग scanl1इन्फिक्स के साथ 1 बाइट के लिए अर्जन जोहानसन को धन्यवाद ।

हास्केल गोल्फ की छंटाई-आधारित चुनौतियों के लिए एक दिलचस्प भाषा है क्योंकि इसमें एक लंबी छँटाई करने के लिए एक अंतर्निहित सॉर्ट नहीं है import Data.List। यह स्पष्ट रूप से छँटाई के बिना हाथ से कार्य करने का एक तरीका खोजने के लिए प्रोत्साहित करता है।

कोड का उपयोग करता है scanl1, जो इंटरमीडिएट के परिणामों पर नज़र रखते हुए सूची पर एक ऑपरेशन को बाएं से दाएं तक मोड़ देता है। तो, scanl1 maxसूची के संचयी अधिकतम को सूचीबद्ध करने का प्रभाव है, अर्थात उत्तरोत्तर लंबे उपसर्गों की अधिकतम सीमा। उदाहरण के लिए, scanl1 max [3,1,2,5,4] == [3,3,3,5,5]।

minचेक के साथ वही है जो सूची कम हो रही है। कोड दो मामलों की जांच करता है और उनके साथ संयोजन करता है ||।

अन्य अभिव्यक्तियों की तुलना करें:

(%)=scanl1;f s=s==max%s||s==min%s

f s=or[s==scanl1 q s|q<-[min,max]]
f s=s==scanl1 max s||s==scanl1 min s
f s=any(\q->scanl1 q s==s)[min,max]
f s=any((==s).(`scanl1`s))[min,max]
f s=elem s$(`scanl1`s)<$>[min,max]

— XNOR
स्रोत

||यदि आप परिभाषित करते हैं तो वास्तव में आपका संस्करण जीत जाता है (?)=scanl1।

— अर्जन जोहानसन

11

पर्ल 6 , 25 बाइट्स

{[le] .comb or[ge] .comb}

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

.comb वर्णों के अनुक्रम में इनपुट को विभाजित करता है।
leऔर geकर रहे हैं "कम या बराबर" और "अधिक या बराबर" स्ट्रिंग तुलना ऑपरेटरों।
[ ]एक infix ऑपरेटर के आसपास, उस ऑपरेटर के साथ तर्क सूची ("सिलवटों") को कम कर देता है। (यदि इनपुट केवल शून्य या एक वर्ण है, तो यह सही लौटने के लिए पर्याप्त स्मार्ट है।)
or यदि इसके दोनों ओर के भाव सत्य हैं, तो यह सही है।

— SMLS
स्रोत

10

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

([...s],q=s+"")=>q==s.sort()|q==s.reverse()

— ETHproductions
स्रोत

पता नहीं था कि आप तर्क में ही चर को संशोधित कर सकते हैं। अच्छा!

— ल्यूक

1

@ ल्यूक यह केवल डिफ़ॉल्ट मापदंडों का एक मुश्किल उपयोग है : यदि आप फ़ंक्शन को दूसरे तर्क के साथ कॉल करने के लिए थे, qतो इसके बजाय उस मान पर सेट किया जाएगा।

— ईथप्रोडक्शन

मैं वास्तव में प्रसार ऑपरेटर का मतलब था (इस मामले में) इसे तुरंत एक सरणी में परिवर्तित करता है।

— ल्यूक

ओह ठीक। हाँ, विनाशकारी असाइनमेंट वास्तव में बहुत आसान हैं ;-)

— ETHproductions

चेक .sort()में अंतर्निहित रूप से सॉर्ट करने के लिए reverse

— म्यूट

7

MATL , 7 बाइट्स

dZSuz2<

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

d     % Implicitly input string. Push array of consecutive differences of code points
ZS    % Sign. Transforms each entry into 1, 0 or -1
u     % Unique
z     % Number of nonzeros
2<    % Is it less than 2? Implicit display

— लुइस मेंडो
स्रोत

यह सभी अमान्य मामलों के

— पैट्रिक बार्ड

1

@PatrickBard जैसा कि निर्देश कहते हैं, उनमें से किसी को भी संभालने की आवश्यकता नहीं है।

— Suever

6

क्लोजर, 47 बाइट्स

#(let[c(map int %)a apply](or(a <= c)(a >= c)))

— NikoNyrh
स्रोत

समझ नहीं पा रहा था कि कैसे तय किया जाए कि कौन सा ऑपरेटर कंसीलर लगाएगा। यह भी खूब रही।

— कैरिजनेट

प्रतीक्षा करें आप क्लोजर में वेरिएबल्स में बिलियन फ़ंक्शन नाम रख सकते हैं? हुह, यह अच्छा है। यह बनाता है <=और >=हालांकि infix देखो, जो वास्तव में अजीब है।

— क्लिस्मिक्स

(let[+ *](+ 2 3))= 6: D यह किसी भी फ़ंक्शन पर काम करता है लेकिन जाहिरा तौर पर मैक्रोज़ पर नहीं: "मैक्रो का मूल्य नहीं ले सकता"

— NikoNyrh

6

सी (जीसीसी) , 70 बाइट्स

o(s,a)char*s;{for(a=0;s[1];s++)a|=s[1]-*s&64|*s-s[1]&32;return a!=96;}

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

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

— nwellnhof
स्रोत

6

आर, 48 50 61 बाइट्स

एक अनाम फ़ंक्शन के रूप में

function(s)sd(range(sign(diff(utf8ToInt(s)))))<1

कुछ अतिरिक्त बाइट्स के लिए @guiseppe को धन्यवाद।

charToRawsकच्चे वेक्टर में ले जाता है और विभाजित करता है। यह पूर्णांकों में परिवर्तित हो जाता है और एक diffलागू होता है। signएक एकल इकाई diffs बनाता है। rangeयह कम से कम और अधिकतम करने के लिए वेक्टर कम कर देता है। फिर यदि मानक विचलन sd1 से कम है तो यह TRUE है

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

— MickyT
स्रोत

आप का उपयोग कर 9 बाइट्स बचा सकता है function(s,d=utf8ToInt(s))all(d==sort(d))याfunction(s,d=utf8ToInt(s))!is.unsorted(d)

— mnel

या नीचे के साथ 34 बाइट्स!is.unsorted(utf8ToInt(scan(,'')))

— एमएचएल

@ दुर्भाग्य से ये रिवर्स प्रकार को नहीं संभालते हैं उदाहरण के लिए cbaऔर अंतिम एक के cat()लिए इसे पूरा कार्यक्रम बनाने की आवश्यकता होगी

— मिकी 22

5 बाइट्स के साथ सहेजें function(s)all(!diff(order(utf8ToInt(s)),,2))(रिवर्स सॉर्ट के साथ भी काम करता है!)

— 22

@ फिर से क्षमा करें, यह विफल होता हैtree

— मिकी 0

5

MATL, 8 बाइट्स

tPvGSXma

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

व्याख्या

        % Implicitly grab the input as a string
tP      % Create a copy that is reversed
v       % Vertically concatenate these
GS      % Grab the input again and sort it
Xm      % Check if each row of the normal and reversed matrix is equal to the sorted one
a       % Check if either row matched
        % Implicitly display the result

— Suever
स्रोत

अच्छा है, लेकिन यह सच है '\n'और 'Hello': /

— पैट्रिक बार्ड

1

@PatrickBard इनपुट सभी समान मामला होगा और केवल [A-Za-z]प्रारंभिक पोस्ट में कहा जाएगा । वे "अमान्य" अनुभाग में हैं क्योंकि उन्हें स्पष्ट रूप से नियंत्रित करने की आवश्यकता नहीं है।

— स्वेवर

5

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

Ṣm0ẇ@

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

मूल रूप Ṣm0wसे चार बाइट्स पर था ।

व्याख्या

Ṣm0ẇ@  Input: string S
Ṣ      Sort S
 m0    Concatenate sort(S) with reverse(sort(S))
   ẇ@  Sublist exists? Check if S is contained in the previous result

— मील की दूरी पर
स्रोत

मुझे यकीन था कि एक चार बाइट थी, लेकिन इसके बारे में सोच भी नहीं सकते थे!

— जोनाथन एलन

1

... दुर्भाग्य से ओपी ने स्पष्ट किया है कि उत्पादन सत्य / मिथ्या नहीं है, बल्कि दो अलग-अलग मूल्य हैं। चार बाइट्स अभी भी संभव है ẇहालांकि, मुझे विश्वास है। संपादित करें: ugh Ṣm0ẇ@।

— जोनाथन एलन

@JonathanAllan दुर्भाग्यपूर्ण है क्योंकि यह भाषा की वास्तविक / झूठी शैली का उपयोग करने के मूल नियम को पूरा करता है। एक और रूप हो सकता है Ṣẇm0$। यदि तर्क आदेश अलग नहीं था wऔर ẇ...

— मील

अच्छा है, लेकिन यह अमान्य मूल्यों

— पैट्रिक बार्ड

@PatrickBard हुह? '\n'और 'Hello'पूरी तरह से मान्य मूल्य हैं।

— एग्लोफ़र

5

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

0<=##||##>=0&@@ToCharacterCode@#&

इस टिप के आधार पर । दुर्भाग्य से, मैं का उपयोग करने के ToCharacterCodeबजाय Characters, क्योंकि <=और >=नहीं की तुलना तार है।

— मार्टिन एंडर
स्रोत

4

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

param($a)$a-in-join(($b=[char[]]$a)|sort),-join($b|sort -des)

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

इनपुट लेता है $a, फिर जांचता है कि यह -inदो-तत्व सरणी है या नहीं। सरणी को ले कर बनाया जाता है $a, इसे एक char-रे के रूप में कास्टिंग करते हुए , $bबाद में के लिए इसे स्टोर करते हुए , sort-objectजो इसे लेक्सिकली सॉर्ट करता है। अन्य तत्व को $bक्रमबद्ध रूप से क्रमबद्ध किया गया है -des।

— AdmBorkBork
स्रोत

4

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

सहेजे गए 4 बाइट्स @ @ धन्यवाद सीधे @ xcali , और 4 परोक्ष रूप से।

कोड + -pFध्वज के 31 बाइट्स ।

@b=reverse@a=sort@F;$_=/@a|@b/x

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

कोड इनपुट को सॉर्ट करता है, और जांचता है कि इनपुट खुद से मेल खाते हैं (या रिवर्स ऑर्डर में)।

— बापू
स्रोत

थोड़ा अलग तरीका है, लेकिन इसे 38 बाइट्स तक काट देता है: इसे ऑनलाइन आज़माएं!

— Xcali

@Xcali बहुत अच्छा, धन्यवाद। फिर हम 5 और बाइट्स को बचाने के बजाय संशोधक का $"=$,उपयोग कर सकते हैं /x।

— दादा

3

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

,Ue@Ṣ

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

कैसे?

,Ue@Ṣ - Main link: string
,     - pair string with
 U    - reverse(string)
    Ṣ - sorted(string)
  e@  - exists in with reversed arguments

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

3

बैश + कोरुटिल्स, 59 बाइट्स

f()(sed 's/\(.\)/\1\
/g'<<<$s|grep .|sort -c$1)
s=$1
f||f r

इनपुट स्ट्रिंग को एक तर्क के रूप में पारित किया जाता है।

पीपीसीजी I / O विधियों द्वारा अनुमति के अनुसार आउटपुट को निकास कोड ( सत्य के लिए 0, मिथ्या के लिए 1, हमेशा की तरह) में वापस कर दिया जाता है ।

— मिशेल स्पेक्टर
स्रोत

3

PHP, 66 बाइट्स

$a=$s=$r=str_split($argv[1]);sort($s);rsort($r);echo$s==$a|$r==$a;

कमांड लाइन तर्क से इनपुट लेता है। के साथ भागो -r।

— टाइटस
स्रोत

3

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

->s{[s,s.reverse].include?s.chars.sort.join}

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

— अंजीर
स्रोत

3

रैकेट , 93 बाइट्स

(define(f s)(let([t(string->list s)])(or(equal?(sort t char<=?)t)(equal?(sort t char>=?)t))))

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

Ungolfed:

(define (lex-sorted? string)
  (let ([char-list (string->list string)])
    (or
     (equal? (sort char-list char<=?) char-list)
     (equal? (sort char-list char>=?) char-list))))

सॉर्ट का उपयोग करना फिर मूल दृष्टिकोण की तुलना करना

— रोड्रिगो रुइज़ मुर्गुआ
स्रोत

3

ब्रेकीलॉग , 5 बाइट्स

मैं सफलता के बिना एक 4 बाइट्स समाधान खोजने की कोशिश की है, तो अब के लिए सबसे दिलचस्प 5 बाइट्स समाधान मैंने पाया है:

:No₎?

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

oआदेश देने का कार्य, एक पैरामीटर ले सकता है: 0आरोही क्रम, 1मतलब अवरोही क्रम। हम उस पैरामीटर को एक अनबाउंड वैरिएबल पर सेट करते हैं N। Brachylog विभिन्न मानों के लिए N(केवल 0या 1संभव है) प्रयास करेगा, इनपुट के साथ परिणाम को एकजुट करने का प्रयास करें, और वापसी करें कि क्या उनमें से कोई भी प्रयास सफल हुआ है।

— सिंह
स्रोत

अब काम नहीं करता है :( o?|o₁?एक अतिरिक्त बाइट के लिए काम करता है

— hakr14

अगर आप कोलन को अर्धविराम से बदलते हैं तो काम करने लगता है। एक और एक बाइट-लंबे संस्करण होगा o{|↔}?।

— असंबंधित स्ट्रिंग

2

MATLAB / ऑक्टेव, 38 बाइट्स

@(x)any(all([x;flip(x)]'==sort(x)',1))

ऑनलाइन डेमो

— Suever
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 74 62 50 47 43 बाइट्स

([...a],b=a+'')=>b==a.sort()|b==a.reverse()

कुछ गोल्फिंग और बगफिक्सिंग के बाद, यह उत्तर ETHProducts के समान ही समाप्त हो गया, इसलिए कृपया उसका उत्तर देखें और उसे दें +1।

— ल्यूक
स्रोत

बग फिक्स्ड ..

— ल्यूक

1

आपने मुझे पकड़ा, मैंने संपादन से पहले टिप्पणी पोस्ट की ...

— ल्यूक

मुझे बग का कारण मिल गया, और मैंने अब सब कुछ चतुराई से व्यवस्थित करके इसे ठीक से तय किया ...

— ल्यूक

बग वापस आ गया है ... repl.it/FZrs/2

— steenbergh

1

खैर, यह बहुत अधिक ETHProduct का जवाब है, इसलिए मैंने एक नोटिस जोड़ा। कृपया +1उसका उत्तर दें।

— ल्यूक

2

हास्केल, 54 50 बाइट्स

t a=or[and(zipWith(<=)`f`tail$a)|f<-[(=<<),(<*>)]]

प्रयोग उदाहरण: t "defggh"-> True। इसे ऑनलाइन आज़माएं! ।

हो सकता है कि इसके उपयोग की sortतरह अन्य उत्तर भी कम हों, हालांकि इसकी आवश्यकता होती है import Data.List। यहाँ एक अलग दृष्टिकोण है:

हर कार्य के लिए fसे [(=<<),(<*>)], calculate and(zipWith(<=)`f`tail$a)और होने के लिए परिणामों के किसी भी आवश्यकता होती है True। कार्य हैं

((=<<) (zipWith(<=)) tail) a
((<*>) (zipWith(<=)) tail) a

दोनों इनपुट सूची के पड़ोसी तत्वों की तुलना प्रदर्शन जो aसाथ <=है, लेकिन तर्क के साथ एक एक में जिसके परिणामस्वरूप फ़्लिप >=। andसभी तुलना कर रहे हैं अगर जाँच करता है True।

— nimi
स्रोत

2

पुष्य , 7 बाइट्स

ogoGo|#

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

स्पष्टीकरण:

      \ Implicit: Input on stack as charcodes
og    \ Check if the stack is sorted ascendingly (Push 0/1)
oG    \ Check if the stack is sorted descendingly (Push 0/1)
      \   - Note that this will work regardless of the first check, as input
      \     is guaranteed to be /[A-Za-z]+/
o|    \ Bitwise OR
#     \ Print the result

— FlipTack
स्रोत

यह एक अलग वास्तविक मूल्य नहीं लौटाता है।

— १

1

@steenbergh नहीं है, लेकिन यह संतुष्ट हमारे मेटा आम सहमति क्या truthy या falsy के रूप में गिना पर - 1और 2कर रहे हैं TruePushy में है, जबकि 0है False।

— FlipTack

यदि पुष्य में बिटवाइस या ऑपरेटर है, तो इसके बजाय काम करना चाहिए।

— ईथप्रोडक्शन

@ फेलटैक मैंने सोचा कि यह चुनौती में स्पष्ट था, लेकिन मैंने अब इसे और अधिक विशिष्ट बना दिया है: TRUE को सभी टेस्टकेस पर समान मूल्य का उत्पादन करना चाहिए। वही FALSE के लिए जाता है।

— २१:३

@steenbergh मेटा सर्वसम्मति वहाँ एक कारण के लिए है और समझ में आता है, लेकिन अगर आप जोर देते हैं ...

— FlipTack

2

अजगर, 5 बाइट्स

}Q_BS

एक प्रोग्राम जो एक "quoted string"और प्रिंट Trueया Falseउपयुक्त के रूप में इनपुट लेता है।

परीक्षण सूट

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

}Q_BS   Program. Input: Q
}Q_BSQ  Implicit variable fill
 Q      Is Q
}       in
    SQ  Q sorted
   B    or
  _     Q sorted reversed?
        Implicitly print

— TheBikingViking
स्रोत

आप एक बाइट को बचा सकते हैं (और सबसे छोटा उत्तर बन सकते हैं) के }Qसाथ बदलकर /, जो एक निहित का उपयोग करता है Q।

— इस्साक

2

ऑक्टेव, 24 बाइट्स

@(s)issorted(s,'either')

यह ऑनलाइन की कोशिश करो!

— rahnema1
स्रोत

2

GNU सेड, 97 + 1 (आर झंडा) = 98 बाइट्स

यदि अक्षरों का आदेश दिया जाता है, तो स्क्रिप्ट वापस आती है 1, अन्यथा 0। Sed में कोई डेटा प्रकार नहीं हैं।

s:$: zyxwvutsrqponmlkjihgfedcba:
s:(.*(.)(.).* ).*\2.*\3.*:\1abcdefghijklmnopqrstuvwxyz:i
//c0
c1

यह जांचने के लिए कि क्या सभी पत्रों को आरोही क्रम में व्यवस्थित किया गया है, मैं लगातार अवरोही वर्णमाला में प्रत्येक अक्षर की जोड़ी की तालिका खोज करता हूं, यही मैं एक काउंटर उदाहरण खोजने की कोशिश करता हूं। ध्यान दें कि //वास्तव में अंतिम नियमित अभिव्यक्ति मैच दोहराता है! (लाइनें 2 और 3 देखें)

रन उदाहरण: स्क्रिप्ट कई इनपुट शब्दों का परीक्षण कर सकती है, प्रति पंक्ति एक

me@LCARS:/PPCG$ echo -e "tree\nABCDC" | sed -rf word_ordered.sed
1
0

— seshoumara
स्रोत

2

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

q_$_W%+\#)g

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

व्याख्या

q            Push the input
 _$          Duplicate and sort
   _W%       Duplicate and reverse
      +      Concatenate the sorted and the reversed strings
       \     Bring input to the top
        #    Find the index of the input in the other string; returns -1 if not found
         )   Increment
          g  Signum (coerces to 0 or 1)

— बिजनेस कैट
स्रोत

2

8086 मशीन कोड, 68 61 48 46 45 39 बाइट्स

00000000  b2 31 be 82 00 ac 9f 88  c3 ac 3c 0d 74 14 38 c3  |.1........<.t.8.|
00000010  74 f5 e3 03 b1 00 9f 77  05 9e 76 ea eb 03 9e 77  |t......w..v....w|
00000020  e5 4a b4 02 cd 21 c3                              |.J...!.|
00000027

से लिया गया:

org 0x100
use16
    mov dl, 0x31
    mov si, 0x82
    lodsb
a:  lahf
b:  mov bl, al
    lodsb
    cmp al, 0x0d
    je y
    cmp bl, al
    je b
    jcxz @f
    mov cl, 0
    lahf
@@: ja @f
    sahf
    jbe a
    jmp n
@@: sahf
    ja a
n:  dec dx
y:  mov ah, 0x02
    int '!'
    ret

— user5434231
स्रोत

2

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

def f(x:String)=x==x.sorted|x==x.sorted.reverse

— आरिया ऐक्स
स्रोत

क्या यह शब्द लेक्सिकली ऑर्डर किया गया है?

इनपुट

उत्पादन

अतिरिक्त नियम

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

05AB1E , 5 बाइट्स

पायथन 2 , 53 44 40 39 बाइट्स

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

पर्ल 6 , 25 बाइट्स

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

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

MATL , 7 बाइट्स

क्लोजर, 47 बाइट्स

सी (जीसीसी) , 70 बाइट्स

आर, 48 50 61 बाइट्स

MATL, 8 बाइट्स

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

व्याख्या

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

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

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

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

कैसे?

बैश + कोरुटिल्स, 59 बाइट्स

PHP, 66 बाइट्स

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

रैकेट , 93 बाइट्स

ब्रेकीलॉग , 5 बाइट्स

MATLAB / ऑक्टेव, 38 बाइट्स

जावास्क्रिप्ट (ईएस 6) 74 62 50 47 43 बाइट्स

हास्केल, 54 50 बाइट्स

पुष्य , 7 बाइट्स

अजगर, 5 बाइट्स

ऑक्टेव, 24 बाइट्स

GNU सेड, 97 + 1 (आर झंडा) = 98 बाइट्स

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

8086 मशीन कोड, 68 61 48 46 45 39 बाइट्स

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