Cho một chuỗi đầu vào S, trả về truthynếu tất cả các chữ cái trong S được sắp xếp theo thứ tự: các giá trị ASCII của chúng cần phải theo thứ tự tăng dần hoặc giảm dần. Trả lại falsytrong các trường hợp khác.

Đầu vào

• Đầu vào sẽ trong cùng một trường hợp (tất cả chữ hoa hoặc chữ thường). Trình của bạn sẽ có thể xử lý cả hai.
• Đầu vào sẽ bao gồm ASCII trong phạm vi [A-Za-z]chỉ
• Độ dài đầu vào sẽ tối thiểu là 1, tối đa bằng bất cứ thứ gì ngôn ngữ của bạn hỗ trợ.
• Đầu vào là một chuỗi - không phải là danh sách các ký tự, không phải là một mảng các mã hóa ASCII.

Đầu ra

• Đầu ra nên truehay false, hoặc 0/1, hoặc bất kỳ khác biệt khác true / falsera phong cách ngôn ngữ của bạn có thể cung cấp.
• Tất cả các trường hợp đúng cần phải có cùng một đầu ra, cũng như tất cả các trường hợp sai. Không "Sai là 0, đúng là 1, 2 hoặc 3".

Quy tắc bổ sung

• Sơ hở tiêu chuẩn bị cấm
• Câu trả lời phải là một chương trình đầy đủ hoặc một chức năng, không phải là một đoạn trích hoặc một mục REPL.
• code-golf , câu trả lời ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Sự thật

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

Giả

"ABCDC"
"yes"
"deed"

không hợp lệ

"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

05AB1E , 5 byte

Â)¤{å

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

Giải trình

Â)     # 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]

Python 2 , 53 44 40 39 byte

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

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

Haskell , 33 byte

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

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

Cảm ơn Ørjan Johansen cho 1 byte với hàm bí danh scanl1.

Haskell là một ngôn ngữ thú vị cho các thử thách dựa trên phân loại golf bởi vì nó không có sắp xếp tích hợp, kéo dài import Data.List. Điều này khuyến khích việc tìm cách thực hiện nhiệm vụ bằng tay mà không cần sắp xếp rõ ràng.

Mã sử ​​dụng scanl1, gấp một thao tác trên danh sách từ trái sang phải, theo dõi các kết quả trung gian. Vì vậy, scanl1 maxcó tác dụng liệt kê cực đại tích lũy của danh sách, tức là cực đại của các tiền tố dài hơn dần dần. Ví dụ , scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Tương tự với minviệc kiểm tra xem danh sách có giảm không. Mã kiểm tra hai trường hợp và kết hợp chúng với ||.

So sánh với các biểu thức khác:

(%)=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]

Perl 6 , 25 byte

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

Làm thế nào nó hoạt động:

• .comb chia đầu vào thành một chuỗi các ký tự.
• levà gelà các toán tử so sánh chuỗi "ít hơn hoặc bằng" và "lớn hơn hoặc bằng" .
• [ ]xung quanh một toán tử infix, làm giảm ("nếp gấp") danh sách đối số với toán tử đó. (Nó đủ thông minh để trả về True nếu đầu vào chỉ có 0 hoặc một ký tự.)
• or trả về True nếu các biểu thức ở hai bên của nó là đúng.

JavaScript (ES6), 43 byte

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

MATL , 7 byte

dZSuz2<

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

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

Clojure, 47 byte

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

C (gcc) , 70 byte

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

Tôi đã hy vọng tìm ra một giải pháp ngắn hơn dựa trên hàm đệ quy, nhưng nó không hoạt động do yêu cầu đầu ra. Vì vậy, đây là một cách tiếp cận bắt buộc. Ít nhất, ưu tiên toán tử của C hoạt động độc đáo cho câu lệnh vòng lặp bên trong.

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

R, 48 50 61 byte

Là một chức năng không tên

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

Cảm ơn @guiseppe cho một vài byte bổ sung.

charToRawmất svà chia thành một vector thô. Điều này được chuyển đổi thành số nguyên và diffáp dụng. signlàm cho các khác biệt một đơn vị. rangegiảm vector đến mức tối thiểu và tối đa của nó. Sau đó, nếu độ lệch chuẩn sdnhỏ hơn 1 thì đó là TRUE

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

MATL, 8 byte

tPvGSXma

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

Giải trình

        % 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

Thạch , 4 5 byte

Ṣm0ẇ@

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

Ban đầu là Ṣm0wở bốn byte.

Giải trình

Ṣ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

Toán học, 33 byte

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

Dựa trên mẹo này . Thật không may, tôi phải sử dụng ToCharacterCodethay vì Characters, <=và >=không so sánh các chuỗi.

PowerShell , 61 byte

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

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

Đưa đầu vào $a, sau đó kiểm tra xem đó có phải là -inmảng hai thành phần không. Mảng được hình thành bằng cách lấy $a, đúc nó thành một char-array, lưu trữ nó $bđể sau này, đưa nó vào sort-objectđó sắp xếp theo từ vựng. Các yếu tố khác được $bsắp xếp theo -desthứ tự.

Perl , 35 byte

Đã lưu 4 byte nhờ @Xcali trực tiếp và 4 gián tiếp nữa.

31 byte mã + -pFcờ.

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

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

Mã sắp xếp đầu vào và kiểm tra xem đầu vào có khớp với chính nó được sắp xếp không (hoặc theo thứ tự ngược lại).

Thạch , 5 byte

,Ue@Ṣ

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

Làm sao?

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

Bash + coreutils, 59 byte

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

Chuỗi đầu vào được truyền dưới dạng đối số.

Đầu ra được trả về trong mã thoát (0 cho sự thật, 1 cho sai, như thường lệ), như được cho phép bởi các phương thức I / O của PPCG .

PHP, 66 byte

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

lấy đầu vào từ đối số dòng lệnh. Chạy với -r.

Ruby , 44 byte

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

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

Vợt , 93 byte

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

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

Ung dung:

(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))))

Sử dụng sắp xếp sau đó so sánh với cách tiếp cận ban đầu

Brachylog , 5 byte

Tôi đã cố gắng tìm một giải pháp 4 byte nhưng không thành công, vì vậy bây giờ đây là giải pháp 5 byte thú vị nhất mà tôi đã tìm thấy:

:No₎?

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

o, chức năng đặt hàng, có thể lấy một tham số: 0có nghĩa là thứ tự tăng dần, 1có nghĩa là thứ tự giảm dần. Chúng tôi đặt tham số đó thành một biến không liên kết N. Brachylog sẽ thử các giá trị khác nhau cho N(chỉ 0hoặc 1có thể), cố gắng thống nhất kết quả với đầu vào và trả về bất kỳ thử nào trong số những lần thử đó đã thành công.

MATLAB / Octave, 38 byte

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

Bản demo trực tuyến

JavaScript (ES6) 74 62 50 47 43 byte

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

Sau khi chơi golf và sửa lỗi, câu trả lời này cuối cùng cũng giống như của ETH Producttion, vì vậy vui lòng kiểm tra câu trả lời của anh ấy và đưa ra câu trả lời +1.

Haskell, 54 50 byte

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

Ví dụ sử dụng: t "defggh"-> True. Hãy thử trực tuyến! .

Có thể sử dụng sortlike có thể các câu trả lời khác ngắn hơn mặc dù nó yêu cầu import Data.List. Đây là một cách tiếp cận khác:

Đối với mọi hàm ftừ [(=<<),(<*>)], tính toán and(zipWith(<=)`f`tail$a)và yêu cầu bất kỳ kết quả nào True. Các chức năng là

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

mà cả hai thực hiện so sánh các yếu tố hàng xóm của danh sách đầu vào avới <=, nhưng một với những lập luận lộn kết quả trong một >=. andkiểm tra nếu tất cả các so sánh là True.

Đẩy , 7 byte

ogoGo|#

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

Giải trình:

      \ 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

Bình thường, 5 byte

}Q_BS

Một chương trình lấy đầu vào của một "quoted string"và in TruehoặcFalse khi thích hợp.

Bộ kiểm tra

Làm thế nào nó hoạt động

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

Octave, 24 byte

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

Dùng thử trực tuyến!

GNU sed, 97 + 1 (cờ r) = 98 byte

Nếu các chữ cái được sắp xếp, kịch bản trả về 1, nếu không 0. Trong sed không có loại dữ liệu.

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

Để kiểm tra xem tất cả các chữ cái có được sắp xếp theo thứ tự tăng dần hay không, tôi thực hiện tra cứu bảng của từng cặp chữ cái liên tiếp trong một bảng chữ cái giảm dần, đó là tôi cố gắng tìm một ví dụ ngược. Lưu ý rằng //thực sự lặp lại trận đấu biểu thức chính quy cuối cùng! (xem dòng 2 và 3)

Chạy ví dụ: tập lệnh có thể kiểm tra nhiều từ đầu vào, mỗi từ trên một dòng

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

CJam , 12 11 byte

q_$_W%+\#)g

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

Giải trình

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)

Mã máy 8086, 68 61 48 46 45 39 byte

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

Lắp ráp từ:

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

Scala, 47 byte

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