Viết hàm / chương trình chấp nhận một chuỗi các chữ cái viết thường / in hoa [A-Za-z] làm đầu vào, kiểm tra xem các chữ cái xuất hiện có phải là duy nhất và theo thứ tự bảng chữ cái (bỏ qua chữ thường và chữ hoa) hay không. Đầu ra phải trung thực nếu chúng là duy nhất và theo thứ tự bảng chữ cái và giả nếu không.

Đây là một số thử nghiệm

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

Nếu bạn muốn, hãy chạy chương trình của bạn trên tất cả các từ của một danh sách từ như thế này và đăng một số từ thú vị =).

Ghi bàn

Số byte thấp nhất sẽ thắng.

CJam, 8 byte

lel_$_&=

Dưới đây là một khai thác thử nghiệm cho tất cả các ví dụ trong thử thách. Điều này trả về 0hoặc 1(tương ứng là giả và trung thực, tương ứng, trong CJam).

Và đây là một kịch bản để lọc danh sách từ trong câu hỏi (mất vài giây để chạy). Bạn sẽ phải sao chép danh sách từ vào trường nhập theo cách thủ công, vì quá dài cho một permalink.

Giải trình

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.";

Regex (bất kỳ hương vị), 55 byte

Một số người không coi regex là ngôn ngữ lập trình, nhưng nó đã được sử dụng trước đây và nó không gần như là ngôn ngữ ngắn nhất.

^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?$

Tôi đã thêm một byte cho icờ (không phân biệt chữ hoa chữ thường). Điều này rất đơn giản và có thể ngắn hơn để tạo ra khi đang bay.

Nếu một mình regex không được phép, bạn có thể sử dụng chương trình Retina 56 byte này do Martin Büttner đề xuất:

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?$

Chạy này trên danh sách từ được liên kết ở trên mang lại 10 từ 6 chữ cái theo thứ tự bảng chữ cái.

["tác giả", "gần như", "bắt đầu", "ăn xin", "bijoux", "sinh thiết", "tinh tinh", "chinos", "chintz", "bóng ma"]

Python 3, 44 byte

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

Một cách tiếp cận đơn giản - kiểm tra tính độc đáo, kiểm tra sự sắp xếp.

> <> , 52 42 39 byte

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

Loại câu hỏi này là một trong số ít loại> <> khá thoải mái, vì chúng ta chỉ cần xử lý một char mỗi lần.

Giải trình

Đừng để bị lạc! Có rất nhiều gói ở đây.

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

Giải pháp trước đó, 42 byte

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

Điều thú vị là, mặc dù dường như có cùng chức năng, sự thay thế

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

(Sự thay đổi nằm ở mũi tên và gương ở ngoài cùng bên phải)

thực sự cho kết quả không chính xác , do trình thông dịch của> <> sử dụng mặc định Python. Điều gì xảy ra là, bằng cách di chuyển qua khoảng trống ở cuối hàng thứ hai, 0 được đặt ngầm vào khoảng trống khi> <> cố gắng truy cập vào ô. Điều này sau đó gây rối với ?tấm bạt lò xo có điều kiện ở đầu cùng một hàng, vì số 0 mới được đặt bị bỏ qua thay vì vở cuối.

Haskell, 52 byte

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

Cách sử dụng: (and.(zipWith(>)=<<tail).map toLower) "abcd"đầu ra nào True.

C, 67 65 57 54 (52) ký tự

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

ngắn hơn một chút:

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

và thậm chí ngắn hơn:

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

Đây là một thử nghiệm nhỏ: http://ideone.com/ZHd0xl

Sau những gợi ý mới nhất ở đây vẫn là hai phiên bản ngắn hơn:

// 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;}

Ngoài ra mã này dựa trên thực tế, rằng trong chữ thường và chữ hoa ASCII chỉ khác nhau bởi bit thứ 5 (32) mà tôi lọc ra. Vì vậy, điều này có thể không hoạt động với các bảng mã khác rõ ràng.

EDIT: Phiên bản mới nhất luôn đặt bit thứ 5 |32ngắn hơn &~32.

Ruby, 33

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

Kiểm tra xem các ký tự duy nhất được sắp xếp có giống với tất cả các ký tự không.

Javascript (ES5), 101

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

Được cải thiện thành 87 bởi edc95:

nâng cao nhận xét của mình :)

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

Btw, các trường hợp thử nghiệm hiện tại trong OP được thực hiện nếu một chương trình chỉ kiểm tra tính duy nhất, không để ý đến thứ tự.

Tôi chưa thể viết bình luận, vì vậy tôi sẽ trả lời một số nhận xét ở đây:

@ edc65: Cảm ơn! Tôi đã thử viết lại nó bằng cách sử dụng some(), nhưng tôi không thể có được một giải pháp ngắn hơn, bởi vì mặc dù có vẻ như nó sẽ cho phép tôi thoát khỏi biến b siêu thừa, bạn cần phải gõ "return" hai lần (cùng với reduce()) không thể trả lại kết quả so sánh trực tiếp, bởi vì ký tự cuối cùng cần được lưu sau khi so sánh với nó.

@ edc65: Đó là một cách sử dụng tốt của toán tử dấu phẩy cho 87! Tôi chỉnh sửa nó thành câu trả lời của tôi để dễ nhìn hơn.

Haskell, 90 byte

Cung cấp chức năng f :: String -> Bool

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

Cách sử dụng (giả sử nó được lưu dưới dạng golf.hs). ...được sử dụng để thay thế ghcicác tin nhắn tải dài dòng.

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

Nếu ai đó có một lowercasephương pháp ngắn hơn import Distribution.Simple.Utilsthì hãy bình luận.

Wolfram Mathicala, 49 37 byte

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

Giải pháp rút gọn PS của Martin Büttner:

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

J, 17 byte

Kiểm tra xem /:~chuỗi chữ thường được sắp xếp có bằng chuỗi -:nub chữ thường không ~..

   (/:~-:~.)@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

Như trong J, một "chuỗi" dài 1 ký tự được biểu diễn dưới dạng một chuỗi thông thường (có dấu ngoặc kép) chỉ là một nguyên tử ký tự chứ không phải là một chuỗi thực tôi định dạng đầu vào một cách thích hợp để tất cả đầu vào sẽ là các chuỗi thực. (Trong ví dụ trên tôi đã sử dụng 1$'a'.)

MATLAB, 29 27 byte

Bây giờ cho một lót mà thậm chí có ý nghĩa bên ngoài của golf-code.

Là một hàm ẩn danh (sử dụng như o('yourstring'))

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

Tôi đoán chức năng này là khá tự giải thích vì nó đọc như một quảng cáo trên báo.

Phiên bản trước (29 byte):

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

Đầu vào phải được trình bày giữa các 'nhãn hiệu, ví dụ 'Potato'.

Brachylog , 3 byte

ḷ⊆Ạ

Hãy thử trực tuyến!

Vị ngữ thành công nếu đầu vào đáp ứng các yêu cầu được phác thảo và thất bại nếu không, in true.hoặc false.nếu chạy như một chương trình.

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

Phiên bản đầu tiên tôi nghĩ ra, không tham khảo rõ ràng bảng chữ cái:

Brachylog , 4 byte

ḷ≠.o

Hãy thử trực tuyến!

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

J, 21 ký tự

Cái này quá dài Đối số phải có thứ hạng 1, tức là nó phải là một chuỗi hoặc vectơ.

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

• tolower y- ytrong trường hợp thấp hơn.
• /:~ y- ytheo thứ tự từ vựng.
• ~. y- nub của y, nghĩa là, yvới các bản sao được loại bỏ.
• x ; y- xvà yđặt vào hộp và sau đó nối.
• < y- ybỏ vào hộp.
• x = y- x so sánh yếu tố khôn ngoan với y.
• (< y) = (~. y) ; (/:~ y)- một vectơ chỉ ra nếu ybằng nub của nó và tự sắp xếp.
• */ y- sản phẩm của các mặt hàng y, hoặc logic của nó và nếu các mặt hàng là booleans.
• */ (< y) = (~. y) ; (/:~ y)- một boolean chỉ ra thuộc tính mong muốn cho chữ thường y.

Julia, 44 byte

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

Điều này tạo ra một hàm ẩn danh nhận một đối số duy nhất s, chuyển đổi nó thành chữ thường và so sánh nó với phiên bản được sắp xếp duy nhất của chuỗi. Nó trả về một boolean, tức là truehoặc false. Nếu bạn muốn kiểm tra nó, hãy gán nó như thế f=s->...và sau đó gọi f("PuZ"), v.v.

Bash tinh khiết 4.x, 37

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

Đầu vào được thực hiện như một tham số dòng lệnh. Theo ngữ nghĩa shell tiêu chuẩn, mã thoát 0 có nghĩa là đúng (chữ cái) và mã thoát! = 0 có nghĩa là sai (không phải chữ cái).

Printf tạo regex như trong giải pháp của @ hsl . Chuỗi đầu vào được mở rộng thành chữ thường và được so sánh với biểu thức chính quy.

Câu trả lời trước:

Bash + coreutils, 52

Giải pháp đơn giản:

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

C # 6, 18 + 82 76 = 94 byte

Yêu cầu (18 byte):

using System.Linq;

Mã (76 byte):

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

C # 6 hỗ trợ lambdas để xác định chức năng, rất hữu ích cho việc chơi gôn.

Phiên bản không C # 6:

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

Mã bị đánh cắp:

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

JavaScript (ES6) 54

Chuyển đổi thành chữ hoa, sau đó đến mảng và sắp xếp. Nếu trong quá trình sắp xếp hai phần tử sai thứ tự hoặc bằng nhau, trả về 0 (giả) khác 1 (trung thực)

Sửa rút ngắn thx để @Optimizer (nhưng vẫn 2 hơn các giải pháp thực hiện trong @Tamas ES6: 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

Kiểm tra trong bảng điều khiển Firefox / FireBug

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

["a 1", "abcdefGHIjklmnopqrSTUVWXyz 1", "aa 0", "puz 1", "puzz 0", "puzZ 0", "puZ 1", "PuZ 1"]

C (44 byte)

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

Kiểm tra nó ở đây: http://ideone.com/q1LL3E

Đăng bài này vì tôi chưa thể bình luận, nếu không, đó sẽ là một gợi ý để cải thiện câu trả lời C hiện có vì tôi đã đánh cắp hoàn toàn ý tưởng không phân biệt chữ hoa chữ thường từ câu trả lời C hiện có.

Trả về 0 nếu chuỗi không được đặt hàng và giá trị khác không nếu được đặt hàng.

Golang (65 byte)

Đi không phải là một ngôn ngữ thân thiện với golf, ngoài ra, tôi chơi golf ...

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

Chạy nó ở đây: http://play.golang.org/p/xXJX8GjDvr

chỉnh sửa 106-> 102

chỉnh sửa 102-> 96

chỉnh sửa 96-> 91

chỉnh sửa 91-> 87

chỉnh sửa 87-> 65

Tôi đánh bại phiên bản java, tôi có thể dừng lại cho ngày hôm nay

Java 8 - 90 89 87 85 ký tự

Ý tưởng ở đây là sử dụng chức năng 'giảm' theo dõi char cuối cùng và "bỏ cuộc" khi phát hiện chuỗi không tăng nghiêm ngặt.

đánh gôn

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

vô dụng:

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

thí dụ:

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"));

đầu ra:

99
-1
122
122
122
-1

Perl 6, 35 byte

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

Điều này tạo ra một khối có thể gọi được; nếu tôi có thể giả sử rằng $_nó đã được đặt thành từ mong muốn, tôi có thể xóa các dấu ngoặc nhọn xung quanh và mất thêm hai byte, nhưng có lẽ cách hợp lý duy nhất để đưa ra giả định đó là chạy nó -nvà cung cấp từ đó làm đầu vào tiêu chuẩn , sẽ thêm hai byte trở lại.

R , 37 byte

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

Hãy thử trực tuyến!

Đăng bài vì điều này về cơ bản là khác nhau và ngắn hơn câu trả lời R của Michal .

Chuyển đổi các chữ cái thành các mã của ASCII utf8ToInt, sau đó lấy modulo 32 để các chữ cái dưới và trên được chuyển đổi thành cùng một số 1 ... 26. Tính toán sự khác biệt theo cặp và kiểm tra xem tất cả chúng đều dương.

Perl, 27

@ hsl's regrec xây dựng động.

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

Ngoài ra, chúng ta có thể thực hiện một kết hợp ngược lại: chuyển đổi đầu vào thành một biểu thức chính quy: PuZ=> .*p.*u.*z.*và sau đó khớp nó với một chuỗi các chữ cái theo thứ tự bảng chữ cái. Kết quả - cũng có 27 ký tự.

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

k (6 byte)

&/>':_

& trả về true nếu cả hai đối số đều đúng

/sửa đổi &để áp dụng "trên" một danh sách, giống như một nếp gấp trong các ngôn ngữ chức năng

> lớn hơn

':sửa đổi >để áp dụng "từng ưu tiên", do đó trả về một vectơ booleans cho biết phần tử nào lớn hơn phần tử trước

_ làm cho nó tranh luận trường hợp thấp hơn

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

( 0bcó nghĩa là boolean sai)

q (13 byte)

all(>':)lower

q chỉ là cú pháp đường trên k. allđược định nghĩa là &/, và thấp hơn là_

Python, 50 byte

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

Thử trực tuyến tại đây: http://repl.it/c5Y/2

VBA (161 byte)

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  

So sánh giá trị ascii với chữ cái trước bằng chữ thường, trả về 0 (sai) khi giá trị của nó nhỏ hơn / bằng và hàm thoát

Python 2 , 43 byte

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

Hãy thử trực tuyến!

Đặt <các ký hiệu giữa tất cả các chữ cái (được chuyển thành chữ thường), rồi evals nó. Các toán tử so sánh chuỗi của Python hoàn toàn vui mừng khi đánh giá toàn bộ sự việc như một biểu thức boolean lớn.

Erlang, 51

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

Sử dụng một bộ được đặt hàng (tương tự như java.util.TreeSet ) để sắp xếp các ký tự và loại bỏ bất kỳ bản sao nào. Danh sách mới sau đó được so sánh với chuỗi đầu vào.

Chức năng kiểm tra:

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

Java, 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;}

Khá đơn giản ở đây. Chỉ cần chuyển đổi tất cả để thấp hơn và so sánh từng với nhân vật trước đó.