एक फ़ंक्शन / प्रोग्राम लिखें जो इनपुट के रूप में निचले / अपरकेस अक्षरों [A-Za-z] की एक स्ट्रिंग को स्वीकार करता है, जो यह जांचता है कि क्या आवर्ती पत्र अद्वितीय हैं और वर्णानुक्रम में हैं (निचले और अपरकेस को अनदेखा करते हुए) या नहीं। आउटपुट सत्य होना चाहिए अगर वे अद्वितीय हैं और वर्णमाला के क्रम में हैं और यदि नहीं तो मिथ्या है।

यहाँ कुछ वृषण

a                           true
abcdefGHIjklmnopqrSTUVWXyz  true     
aa                          false
puz                         true
puzz                        false
puzZ                        false
puZ                         true
PuZ                         true
pzu                         false
pzU                         false
abcdABCD                    false
dcba                        false

यदि आप चाहते हैं, तो अपने प्रोग्राम को किसी शब्दसूची के सभी शब्दों पर चलाएं, जैसे एक और कुछ दिलचस्प पोस्ट करें =)।

स्कोर

सबसे कम संख्या बाइट्स जीतती है।

code-golf string decision-problem

— flawr
स्रोत

3

कमजोर परीक्षण के मामले। ( रिचर्ड ए के PHP उत्तर पर मेरी टिप्पणी देखें ।)

— मैनटवर्क

क्या अक्षर लूप करता है? zaएक सत्य मूल्य होना चाहिए?

— मेयरमोनी

नहीं, वर्णमाला के साथ शुरू होता है aऔर समाप्त होता है z।

— दोष

आपके पास कुछ परीक्षण मामले होने चाहिए जो कि वर्णानुक्रम में नहीं हैं

— जो किंग

1

@JoKing मैंने कुछ जोड़े।

— निर्दोष

28

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

lel_$_&=

यहाँ चुनौती में सभी उदाहरणों के लिए एक परीक्षण हार्नेस है । यह रिटर्न 0या 1(जो सीजेएम में क्रमशः मिथ्या और सत्य हैं)।

और यहां प्रश्न में शब्द सूची को फ़िल्टर करने के लिए एक स्क्रिप्ट है (चलाने के लिए कुछ सेकंड लगते हैं)। आपको शब्द सूची को इनपुट फ़ील्ड में मैन्युअल रूप से कॉपी करना होगा, क्योंकि यह एक पर्मलिंक के लिए बहुत लंबा है।

व्याख्या

l        "Read input.";
 el      "Convert to lower case.";
   _$    "Get a copy and sort it.";
     _&  "Remove duplicates (by computing the set intersection with itself).";
       = "Check for equality with original (lower case) word.";

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

21

रेगेक्स (कोई भी स्वाद), 55 बाइट्स

कुछ लोग रेगेक्स को एक प्रोग्रामिंग भाषा नहीं मानते हैं, लेकिन इसका उपयोग पहले किया जा चुका है, और यह सबसे छोटा होने के करीब नहीं है।

^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?$

मैंने iकेस (असंवेदनशील) झंडे के लिए एक बाइट जोड़ी है । यह बहुत सीधा है और मक्खी पर उत्पन्न करने के लिए छोटा हो सकता है।

यदि अकेले रेगेक्स की अनुमति नहीं है, तो आप मार्टिन ब्यूटनर द्वारा सुझाए गए 56-बाइट रेटिना कार्यक्रम का उपयोग कर सकते हैं :

i`^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?$

इसे ऊपर दिए गए शब्दसूची पर चलाने से वर्णमाला क्रम में 10 6-अक्षर वाले शब्द मिलते हैं।

]

— NinjaBearMonkey
स्रोत

2

आप ES6 के बजाय रेटिना का उपयोग कर सकते हैं यदि कोई शिकायत करता है कि रेक्सक्स एक भाषा नहीं है:i`^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?$

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

@ मार्टिनबटनर मैं रेटिना के बारे में भूल गया था। धन्यवाद!

— NinjaBearMonkey

@ मार्टिनबटनर मेटा के अनुसार ( meta.codegolf.stackexchange.com/questions/2028/… ) Regexes को प्रोग्रामिंग भाषा के रूप में कुछ हद तक 'देखा' जा सकता है।

— इस्माइल मिगुएल

@IsmaelMiguel मुझे पता है। और वास्तव में यह परिभाषा विशेष रूप से यह सुनिश्चित करने के लिए चुना गया था कि यह रेगेक्स को खारिज नहीं करता है। लेकिन कुछ लोग अभी भी नियमित रूप से शिकायत करते हैं, क्योंकि आप किसी अन्य भाषा की तरह रेगेक्स का उपयोग नहीं कर सकते हैं।

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

@ मार्टिनबटनर जो लोग शिकायत करते हैं, वे मेटा नामक स्थान पर जा सकते हैं और इसकी तलाश कर सकते हैं। क्यों कोई भी ऐसे सुंदर स्थान पर नहीं जाता है जो अधिकांश मुद्दों को हल करता है?

— इस्माइल मिगुएल

19

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

*s,=input().lower()
print(sorted(set(s))==s)

एक सरल दृष्टिकोण - अद्वितीयता की जांच करें, क्रमबद्धता की जांच करें।

— Sp3000
स्रोत

क्या आप बता सकते हैं कि क्या *s,=...करता है?

— निर्दोष

@flawr इसे 'तारांकित असाइनमेंट' कहा जाता है। इस कोड में, यह बस दाईं ओर को सूची में परिवर्तित करता है। यह वैसा ही है s=list(input().lower())।

— जकुबे

1

@flawr जैसा कि जकुबे कहते हैं, यहां यह सिर्फ इनपुट को चार की सूची में परिवर्तित कर रहा है। सामान्य तौर पर यह एक विशेष काम वाक्य रचना है जो आप की तरह बातें करते हैं की सुविधा देता है है x,*y = [1, 2, 3, 4], जो प्रदान करती है 1 xऔर [2, 3, 4]करने के लिए y।

— Sp3000

@ mbomb007 *s,= है list(s) ... लिंक

— Sp3000

आप 2 बाइट्स को बचाने के {*s}बजाय कर सकते हैं set(s)।

— mbomb007

12

> <> , 52 42 39 बाइट्स

0>i:1+?v1n;
? )'`':/'@'v
0v?){:-<'`'/;n

इस प्रकार का प्रश्न कुछ प्रकारों में से एक है कि> <> के साथ बहुत सहज है, क्योंकि हमें केवल एक समय में एक चार से निपटने की आवश्यकता है।

व्याख्या

खो मत जाओ! यहां बहुत कुछ है।

0            Push 0. We'll be mapping a-z to 1-26, so 0 will be smaller than everything

(loop)
i            Read a char of input
:1+? 1n;     If there's no more input, print 1
:'`')?       If the char is bigger than backtick...
  '`'          Push backtick  (which is one before 'a'), else...
  '@'          Push an @ sign (which is one before 'A')
-            Subtract, mapping a-z to 1-26
:{)?         If the new char is bigger than the previous char...
               Repeat from the beginning of the loop, else...
  0n;          Print 0

पिछला समाधान, 42 बाइट्स

0i:1+?v1n;n0/\!
?)'`':/'@'v
? ){:-<'`'/ vv

दिलचस्प बात यह है कि, समान कार्यक्षमता होने के बावजूद, विकल्प

0i:1+?v1n;n0\/!
?)'`':/'@'v
? ){:-<'`'/ ^^

(परिवर्तन तीर और दर्पण में दाईं ओर है)

वास्तव में गलत परिणाम देता है , पायथन डिफॉल्ट के उपयोग के कारण> <> दुभाषिया। क्या होता है, दूसरी पंक्ति के अंत में खाली स्थान के माध्यम से ट्रैवर्स करके, 0 को स्पष्ट रूप से रिक्त स्थान में रखा जाता है जब> <> सेल तक पहुंचने का प्रयास करता है। यह फिर ?उसी पंक्ति की शुरुआत में सशर्त ट्रैम्पोलिन के साथ खिलवाड़ करता है , क्योंकि नव रखा गया 0s vअंत में के बजाय छोड़ दिया जाता है ।

— Sp3000
स्रोत

मुझे ऐसा लगता है कि आप सभी पत्रों के लिए वर्णमाला सूचकांक प्राप्त करने के बजाय केवल लोअरकेस अक्षरों से 32 को घटाकर कुछ बाइट्स बचा सकते हैं

— हारून

9

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

import Data.Char
and.(zipWith(>)=<<tail).map toLower

उपयोग: (and.(zipWith(>)=<<tail).map toLower) "abcd"जो आउटपुट True।

— nimi
स्रोत

9

सी, 67 65 57 54 (52) अक्षर

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>(d&~32);d=c);return!c;}

थोड़ा छोटा:

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>d;d=c&~32);return!c;}

और इससे भी कम:

f(char*s){int d=32;for(;(*s|32)>d;d=*s++|32);return!*s;}

यहाँ थोड़ा परीक्षण है: http://ideone.com/ZHd0xl

नवीनतम सुझावों के बाद यहाँ अभी भी दो छोटे संस्करण हैं:

// 54 bytes
f(char*s){int d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

// 52, though not sure if valid because of global variable
d;f(char*s){d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

इसके अलावा यह कोड इस तथ्य पर निर्भर करता है, कि ASCII लोअरकेस और अपरकेस में केवल 5 बिट (32) से भिन्न होता है जिसे मैं बाहर फ़िल्टर करता हूं। तो यह स्पष्ट रूप से अन्य एन्कोडिंग के साथ काम नहीं कर सकता है।

संपादित करें: नवीनतम संस्करण हमेशा 5 बिट को सेट करता |32है जो इससे छोटा है &~32।

— फेलिक्स बायटॉ
स्रोत

केस सेंसिटिविटी समस्या से निपटने के लिए डोमेन ज्ञान का अच्छा उपयोग।

— रोमीस्टेडी

2 को लूप के साथ बदलकर सहेजें for(;(*s&=95)>d;d=*s++);। और अगर आप को प्रारंभ कर सकते हैं dकरने के लिए 1परिणाम बदले बिना, 1 अधिक बचत। देख।

— एशेल्ली

1

मुझे यकीन नहीं है कि अगर यह कोड गोल्फ में कानूनी माना जाता है, लेकिन d;f(char*s){d=32;for...}काम करता है, तो dस्पष्ट रूप से एक वैश्विक इंट के रूप में घोषित किया जाता है (जो, जीसीसी में, एक चेतावनी है- "डेटा परिभाषा का कोई प्रकार या भंडारण वर्ग नहीं है" -लेकिन कोई त्रुटि नहीं है)। इससे दो बाइट बचती हैं।

— १३:३३ पर wchargin

AShelly hm, इस पर विचार नहीं किया। आपका सुझाव हालांकि मूल स्ट्रिंग को बदलता है। लेकिन जो भी हो, यह कोड गोल्फ है: डी भी मैं WChargin के संकेत के बारे में निश्चित नहीं हूं क्योंकि d एक वैश्विक वैरिएबल वास्तव में फ़ंक्शन का हिस्सा नहीं होगा।

— फेलिक्स बाइटो

1

अपने स्वयं के बयान के बजाय लूप dमें इनिशियलाइज़ क्यों नहीं किया जाता है for? इस तरह आप एक को बचाने के ;।

— जोश

6

रूबी, ३३

->s{c=s.upcase.chars
c==c.sort|c}

यह देखने के लिए कि क्या छांटे गए अद्वितीय वर्ण सभी वर्णों के समान हैं।

— britishtea
स्रोत

1

लगता है कि तुम साथ में थोड़ा छोटा प्राप्त कर सकते हैंc==c.sort|c

— histocrat

ऊह, मुझे वह पसंद है, वह चतुर है। धन्यवाद।

— ब्रितिश्तिया

5

जावास्क्रिप्ट (ES5), 101

function i(s){b=0;l=''.a
s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1
l=c})
return!b}

Edc95 द्वारा 87 में सुधार:

उनकी टिप्पणी को आगे बढ़ाएं :)

function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}

Btw, ओपी में वर्तमान में परीक्षण के मामलों को पूरा कर रहे हैं अगर एक कार्यक्रम केवल विशिष्टता की जांच कर रहा है, तो आदेश की अवहेलना।

मैं अभी तक टिप्पणी नहीं लिख सकता, इसलिए मैं यहाँ कुछ टिप्पणियों का जवाब दूंगा:

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

@ edc65: यह 87 के लिए अल्पविराम ऑपरेटर का एक अच्छा उपयोग है! मैंने इसे अधिक दृश्यता के लिए अपने उत्तर में संपादित किया।

— तमस
स्रोत

यह मेरा एक बेहतर विचार है।

— .Some

आप के बीच की जगह को हटाने returnऔर !bएक चार को बचाने के लिए कर सकते हैं ।

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

जैसा कि, बस सफेद स्थान की देखभाल, 96:function i(s){b=0;l='';s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1;l=c});return!b}

— edc65

वही, अधिक गोल्फ, 92:function i(s){s.toUpperCase(b=0).split(l='').forEach(function(c){if(c<=l)b=1;l=c});return!b}

— edc65

1

कुछ (या हर समान स्कोर) का उपयोग करते हुए, 87:function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}

— edc65

4

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

फ़ंक्शन की आपूर्ति करता है f :: String -> Bool

import Data.List
import Distribution.Simple.Utils
f l=g$lowercase l
g l=sort l==l&&l==nub l

उपयोग (यह मानते हुए कि इसे गोल्फ के रूप में सहेजा गया है)। ...का उपयोग ghciवर्बोज़ लोडिंग संदेशों को बदलने के लिए किया जाता है ।

$ ghci golf.hs
...
*Main> f "as"
...
True
*Main> f "aa"
False

अगर किसी के पास इससे lowercaseछोटा तरीका है import Distribution.Simple.Utilsतो कृपया कमेंट करें।

— HEGX64
स्रोत

1

उपयोग map toLowerसे Data.Charबजायlowercase

— nimi

1

इसके अलावा: आप पैरामीटर निकाल सकते हैं lपर f, यानी f=g.lowercase(या f=g.map toLowerआप पर स्विच करते हैं toLower)। gएक तुलना के भीतर पर्याप्त है g l=nub(sort l)==l:।

— नीमी

4

वोल्फ्राम मैथमेटिका, 49 37 बाइट्स

f[x_]:=(l=Characters[ToLowerCase[x]];Union[l]==l)

मार्टिन ब्यूटनर द्वारा पुनश्च छोटा समाधान:

Union[l=Characters@ToLowerCase@#]==l&

— सावेनकोव एलेक्सी
स्रोत

2

#⋃#==#&@*Characters@*ToLowerCase

— एलेफाल्पा

1

@alephalpha यह सुंदर है!

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

4

जे, 17 बाइट्स

जाँचता है कि क्या लोअरकेस सॉर्ट किया गया /:~स्ट्रिंग -:लोअरकेस नब ~.स्ट्रिंग के बराबर है ।

   (/:~-:~.)@tolower

   NB. testing with the example inputs
   ((/:~-:~.)@tolower) every (1$'a');'abcdefGHIjklmnopqrSTUVWXyz';'aa';'puz';'puzz';'puzZ';'puZ';'PuZ'
1 1 0 1 0 0 1 1

जे के रूप में एक 1-चारित्र लंबा "स्ट्रिंग" एक नियमित स्ट्रिंग (उद्धरण के साथ) के रूप में दर्शाया गया है, बस एक चरित्र परमाणु है एक वास्तविक स्ट्रिंग नहीं है मैंने उचित रूप से इनपुट को स्वरूपित किया है ताकि सभी इनपुट वास्तविक तार होंगे। (ऊपर दिए गए उदाहरण में मैंने प्रयोग किया है 1$'a'।)

— randomra
स्रोत

4

MATLAB, 29 27 बाइट्स

अब एक-लाइनर के लिए जो कोड-गोल्फ के बाहर भी समझ में आता है।

अनाम फ़ंक्शन के रूप में (जैसा उपयोग करें o('yourstring'))

o=@(s)all(diff(lower(s))>0)

मुझे लगता है कि यह समारोह बहुत आत्म-व्याख्यात्मक है क्योंकि यह एक अखबार के विज्ञापन की तरह पढ़ता है।

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

~~all(diff(lower(input('')))>0)~~

~~इनपुट को उदाहरणों के बीच प्रस्तुत किया जाना चाहिए ', जैसे 'Potato'।~~

— Sanchises
स्रोत

4

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

ḷ⊆Ạ

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

यदि इनपुट उल्लिखित आवश्यकताओं को पूरा करता है और यह प्रोग्राम के रूप में मुद्रण true.या नहीं किया जाता है, तो विफल हो जाता है false.।

       The input,
ḷ      lowercased,
 ⊆     is a not-necessarily-contiguous sub-list of
  Ạ    "abcdefghijklmnopqrstuvwxyz".

पहला संस्करण जिसके साथ मैं आया था, स्पष्ट रूप से वर्णमाला का संदर्भ नहीं दे रहा था:

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

ḷ≠.o

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

        The input,
ḷ       lowercased,
 ≠      in which every character is distinct,
  .     is the output variable,
   o    which sorted,
        is still the output variable.

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

3

जे, 21 अक्षर

यह बहुत लंबा है। तर्क में रैंक होना चाहिए 1, अर्थात यह एक स्ट्रिंग या वेक्टर होना चाहिए।

*/@(<=~.;/:~)@tolower

tolower y- yनिचले मामले में।
/:~ y- yशाब्दिक क्रम में।
~. y- डुप्लिकेट को हटा दिया गया yहै, के yसाथ , अर्थात् ।
x ; y- xऔर yबक्से में डाल दिया और फिर concatenated।
< y- yएक बॉक्स में डालें।
x = y- x तत्व-वार की तुलना y।
(< y) = (~. y) ; (/:~ y)- एक वेक्टर जो इंगित करता है कि yउसके नब के बराबर है और खुद को सॉर्ट किया गया है।
*/ y- के आइटम y, या उसके तार्किक और यदि आइटम बूलियन हैं।
*/ (< y) = (~. y) ; (/:~ y)- एक बूलियन लोअरकेस के लिए वांछित संपत्ति का संकेत देता है y।

— FUZxxl
स्रोत

3

जूलिया, 44 बाइट्स

s->(l=lowercase(s);l==join(sort(unique(l))))

यह एक अनाम फ़ंक्शन बनाता है जो एकल तर्क लेता है s, इसे निचले मामले में परिवर्तित करता है, और इसे स्ट्रिंग के अनन्य सॉर्ट किए गए संस्करण से तुलना करता है। यह एक बूलियन, यानी trueया false। यदि आप इसका परीक्षण करना चाहते हैं, f=s->...तो इसे असाइन करें और फिर कॉल करें f("PuZ"), आदि।

— एलेक्स ए।
स्रोत

आमीन ने कहा कि, @flawr। सहायता का शुक्रिया।

— एलेक्स ए।

3

शुद्ध बैश 4.x, 37

[[ ${1,,} =~ ^`printf %s? {a..z}`$ ]]

कमांड-लाइन पैरामीटर के रूप में इनपुट लिया गया। मानक शेल शब्दार्थ के अनुसार, बाहर निकलने का कोड 0 का अर्थ है सच (वर्णानुक्रम) और निकास का कोड! = 0 का अर्थ है असत्य (वर्णनात्मक नहीं)।

Printf @ hsl के समाधान के रूप में regex बनाता है । इनपुट स्ट्रिंग को लोअरकेस में विस्तारित किया जाता है और रेगेक्स के खिलाफ तुलना की जाती है।

पिछला उत्तर:

बाश + कोरुटिल्स, 52

सीधा समाधान:

a=`fold -1<<<${1,,}`
cmp -s <(sort -u<<<"$a")<<<"$a"

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

ध्यान दें कि इसके लिए bash 4.x की आवश्यकता है।

— मार्क रीड 20

@MarkReed हाँ। का उल्लेख किया।

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

3

सी # 6, 18 + 82 76 = 94 बाइट्स

आवश्यक (18 बाइट्स):

using System.Linq;

कोड (76 बाइट्स):

bool a(string s)=>(s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);

C # 6 एक फ़ंक्शन को परिभाषित करने के लिए लैम्ब्डा का समर्थन करता है, जो कि गोल्फ के लिए उपयोगी है।

गैर-सी # 6 संस्करण:

bool a(string s){return (s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);}

अघोषित कोड:

bool IsInAlphabeticalOrder(string s)
{
    s = s.ToLower();
    return s.Distinct()
            .OrderBy(x => x)
            .SequenceEqual(s);
}

— ProgramFOX
स्रोत

3

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

अपरकेस में कनवर्ट करें, फिर सरणी और सॉर्ट करने के लिए। यदि सॉर्ट के दौरान दो तत्व गलत क्रम या बराबर हैं, तो 0 (मिथ्या) और 1 (सत्य) लौटाएं

@ को छोटा करने के लिए छोटा thx संपादित करें (लेकिन अभी भी ES6 में लागू @Tasas समाधान से 2 अधिक है F=s=>[...s.toUpperCase()].every(c=>(u=l,l=c)>u,l='')) :

F=s=>[...s.toUpperCase(x=1)].sort((a,b)=>a<b?1:x=0)&&x

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

;['a','abcdefGHIjklmnopqrSTUVWXyz','aa','puz','puzz','puzZ','puZ','PuZ']
.map(w=>w+' '+F(w))

]

— edc65
स्रोत

1

s=आवश्यक नहीं लगता ...

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

@ सही, यह पहली कोशिश थी जब आखिरी में मैंने मूल (अपरकेस) और सॉर्ट की तुलना की

— edc65

3

सी (44 बाइट्स)

f(char*s){return(*s&=95)?f(s+1)>*s?*s:0:96;}

इसे यहाँ टेस्ट करें: http://ideone.com/q1LL3E

इसे पोस्ट करना क्योंकि मैं अभी तक टिप्पणी नहीं कर सकता, अन्यथा यह मौजूदा सी उत्तर को बेहतर बनाने का सुझाव होगा क्योंकि मैंने मौजूदा सी उत्तर से केस-असंवेदनशील विचार को पूरी तरह से चुरा लिया है।

यदि स्ट्रिंग का आदेश नहीं दिया गया है, तो 0 और अगर ऑर्डर किया गया है तो एक गैर-शून्य मान।

— ERAI
स्रोत

3

गोलंग (65 बाइट्स)

गो एक गोल्फ फ्रेंडली भाषा नहीं है, मैं भी गोल्फ में चूसता हूँ ...

func a(s[]byte)(bool){return len(s)<2||s[0]|32<s[1]|32&&a(s[1:])}

इसे यहां चलाएं: http://play.golang.org/p/xXJX8GjDvr

संपादित करें 106-> 102

संपादित करें 102-> 96

96-> 91 संपादित करें

91-> 87 संपादित करें

87-> 65 संपादित करें

मैंने जावा संस्करण को हराया, मैं आज के लिए रोक सकता हूं

— क्रिस्टोफ़र साल्-स्टोर्गार्ड
स्रोत

3

जावा 8 - 90 89 87 85 चार्ट

यहां विचार एक 'कम' फ़ंक्शन का उपयोग करने के लिए है जो अंतिम चार को ट्रैक करता है और "छोड़ देता है" जब यह पता लगाता है कि अनुक्रम सख्ती से आरोही नहीं है।

golfed:

int f(String s){return s.toLowerCase().chars().reduce(0,(v,c)->(v<0)?v:(c>v)?c:-1);}

ungolfed:

int f(String s){
    return s.toLowerCase()
            .chars()
            .reduce(0, (v,c) -> (v<0)? v : (c>v)?c:-1);
}

उदाहरण:

System.out.println(new Quick().f("abc"));
System.out.println(new Quick().f("aa"));
System.out.println(new Quick().f("abcdefGHIjklmnopqrSTUVWXyz"));
System.out.println(new Quick().f("puZ"));
System.out.println(new Quick().f("Puz"));
System.out.println(new Quick().f("cba"));

उत्पादन:

— माइकल ईस्टर
स्रोत

3

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

{my@c=.uc.comb;@c eq@c.sort.unique}

यह एक कॉल करने योग्य ब्लॉक का उत्पादन करता है; अगर मैं यह मान सकता हूं कि $_पहले से ही वांछित शब्द पर सेट है, तो मैं आसपास के घुंघराले ब्रेसिज़ को हटा सकता हूं और दो और बाइट्स खो सकता हूं, लेकिन शायद यह मानने का एकमात्र उचित तरीका है कि इसे -nमानक इनपुट के रूप में शब्द के साथ चलाया जाए और खिलाया जाए। , जो दो बाइट्स को वापस जोड़ देगा।

— मार्क रीड
स्रोत

ज़रूर करता है। .uc.combकुछ भी पुनर्व्यवस्थित नहीं करता है, इसलिए यदि अपरकेस और कंघी सरणी सॉर्ट किए गए अपरकेस और कंघी सरणी के बराबर है , तो इसका मतलब है कि यह क्रमबद्ध क्रम में शुरू हुआ था।

— मार्क रीड

सही, यह चौराहे के आकार की जाँच कर रहा है, जो आदेश की अनदेखी करता है। ठीक है, अपडेट किया गया।

— मार्क रीड

3

आर , 37 बाइट्स

all(diff(utf8ToInt(scan(,''))%%32)>0)

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

यह पोस्टिंग काफी हद तक अलग है और मिशल के उत्तर की तुलना में कम है ।

अक्षरों को ASCII कोडपॉइंट्स के साथ परिवर्तित करता है utf8ToInt, फिर modulo 32 लेता है ताकि निचले और ऊपरी अक्षर समान संख्या 1 ... 26 में परिवर्तित हो जाएं। जोड़ीदार अंतरों की गणना करता है, और जांचता है कि वे सभी सकारात्मक हैं।

— रॉबिन राइडर
स्रोत

2

पर्ल, 27

@ hsl का regexp गतिशील रूप से निर्माण करता है।

#!perl -p
$"="?";@x=a..z;$_=/^@x?$/i

इसके अलावा, हम एक रिवर्स मैच कर सकते हैं: इनपुट को regexp में कनवर्ट करें: PuZ=> .*p.*u.*z.*और फिर इसे वर्णमाला क्रम में अक्षरों के एक स्ट्रिंग से मिलाएं। परिणाम - 27 वर्ण भी।

#!perl -lp
$_=join(s//.*/g,a..z)=~lc

— nutki
स्रोत

2

k (6 बाइट्स)

&/>':_

& यदि दोनों आर्ग्स सत्य हैं, तो सही है

/&एक सूची को "ओवर" लागू करने के लिए संशोधित करता है, जैसे कार्यात्मक भाषाओं में गुना

> से अधिक

':>"प्रत्येक-पूर्व" को लागू करने के लिए संशोधित करता है, इसलिए मल के एक वेक्टर को यह बताते हुए लौटाता है कि कौन से तत्व उनके पूर्ववर्ती से अधिक हैं

_ यह तर्क कम मामले बनाता है

  _"puzZ"
"puzz"
  >':_"puzZ"
1110b
  &/>':_"puzZ"
0b

( 0bबूलियन झूठ का मतलब है)

क्यू (13 बाइट्स)

all(>':)lower

क्ष k पर मात्र संश्लिष्ट चीनी है। allके रूप में परिभाषित किया गया है &/, और कम है_

— mollmerx
स्रोत

4

क्या आप बता सकते हैं कि यह कैसे काम करता है?

— निर्दोष

यह लगभग अन्य भाषाओं को धोखा देने जैसा लगता है ... किसे फ़ंक्शन नाम, कोष्ठक और अर्धविराम की आवश्यकता है? :)

— Sanchises

@sanchises k के पास वे सभी चीजें हैं और वे सी शैली की भाषाओं की तरह ही बहुत अधिक काम करते हैं। यह सिर्फ इतना है कि यह समस्या एक बयान के रूप में व्यक्त होने के लिए होती है।

— मोलमरक्स

2

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

f=lambda x:sorted(set(x.lower()))==list(x.lower())

यहां ऑनलाइन कोशिश करें: http://repl.it/c5Y/2

— mbomb007
स्रोत

2

VBA (161 बाइट्स)

Function t(s As String)
t = 0
For i = 2 To Len(s)
a = Left(LCase(s), i)
    If Asc(Right(a, 1)) <= Asc(Right(a, 2)) Then Exit Function
Next
t = 1
End Function

लोअरकेस में पिछले अक्षर के साथ एससीआई मूल्य की तुलना करता है, 0 (गलत) वापस करता है जब इसका मूल्य छोटा / बराबर और निकास कार्य होता है

— एलेक्स
स्रोत

2

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

lambda s:eval('"%s"'%'"<"'.join(s.lower()))

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

डालता है <सभी अक्षरों के बीच प्रतीक (लोअरकेस परिवर्तित), और फिर evalयह है। अजगर की जंजीर तुलना ऑपरेटर पूरी तरह से एक बड़े बूलियन अभिव्यक्ति के रूप में पूरी चीज का मूल्यांकन करने के लिए खुश हैं।

— अरबो
स्रोत

1

एर्लांग, 51

f(S)->G=string:to_lower(S),ordsets:from_list(G)==G.

java.util.TreeSetवर्णों को क्रमबद्ध करने और किसी भी डुप्लिकेट को छोड़ने के लिए एक निर्धारित सेट (अनुरूप ) का उपयोग करता है । नई सूची की तुलना इनपुट स्ट्रिंग के साथ की जाती है।

परीक्षण समारोह:

test() ->
    [io:format("~p ~p~n", [S, f(S)]) || S <- ["a","abcdefGHIjklmnopqrSTUVWXyz","aa","puz","puzz","puzZ","puZ","PuZ"]].

— CPU1
स्रोत

1

जावा, 96

boolean a(char[]a){int i=-1,l=0;for(;++i<a.length;l+=i>0&&a[i]<=a[i-1]?1:0)a[i]|=32;return l<1;}

यहाँ बहुत सीधा है। बस सभी को पिछले वर्ण में परिवर्तित करें और प्रत्येक की तुलना करें।

— Geobits
स्रोत

जाँचें कि क्या शब्द के अक्षर वर्णमाला के क्रम में हैं

स्कोर

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

व्याख्या

रेगेक्स (कोई भी स्वाद), 55 बाइट्स

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

> <> , 52 42 39 बाइट्स

व्याख्या

पिछला समाधान, 42 बाइट्स

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

सी, 67 65 57 54 (52) अक्षर

रूबी, ३३

जावास्क्रिप्ट (ES5), 101

Edc95 द्वारा 87 में सुधार:

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

वोल्फ्राम मैथमेटिका, 49 37 बाइट्स

जे, 17 बाइट्स

MATLAB, 29 27 बाइट्स

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

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

जे, 21 अक्षर

जूलिया, 44 बाइट्स

शुद्ध बैश 4.x, 37

बाश + कोरुटिल्स, 52

सी # 6, 18 + 82 76 = 94 बाइट्स

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

सी (44 बाइट्स)

गोलंग (65 बाइट्स)

जावा 8 - 90 89 87 85 चार्ट

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

आर , 37 बाइट्स

पर्ल, 27

k (6 बाइट्स)

क्यू (13 बाइट्स)

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

VBA (161 बाइट्स)

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

एर्लांग, 51

जावा, 96