给定输入字符串S，truthy如果S中的所有字母均按字母顺序排列，则返回：它们的ASCII值需要以升序或降序排列。falsy在其他情况下退货。

输入项

• 输入将使用相同的大小写（全部大写或全部小写）。您的提交应该能够同时处理这两种情况。
• 输入[A-Za-z]仅包含范围内的ASCII
• 输入长度至少为1，最多取决于您的语言支持的最大长度。
• 输入是字符串-不是字符列表，也不是ASCII码点数组。

输出量

• 输出应为true或false，或0/1，或者true / false您的语言可以提供的任何其他不同样式的输出。
• 所有正确的案例以及所有错误的案例都需要具有相同的输出。否为“ False为0，true为1、2或3”。

附加规则

• 禁止出现标准漏洞
• 答案必须是完整的程序或功能，而不是摘要或REPL条目。
• 代码高尔夫，最短答案（以字节为单位）获胜。

测试用例

特鲁西

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

虚假

"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

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]

Python 2中，53 44 40 39个字节

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

在线尝试！

Haskell，33个字节

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

在线尝试！

感谢ØrjanJohansen提供1个字节的别名别名scanl1。

Haskell是一种基于高尔夫分类挑战的有趣语言，因为它没有内置的分类方法，而且冗长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]

Perl 6，25个字节

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

这个怎么运作：

• .comb 将输入分为一系列字符。
• le和ge是“小于或等于”和“大于或等于”字符串比较运算符。
• [ ]围绕一个infix运算符，使用该运算符减少（“折叠”）参数列表。（如果输入仅包含零个或一个字符，则可以很聪明地返回True。）
• or 如果任一侧的表达式为true，则返回True。

JavaScript（ES6），43个字节

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

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

Clojure，47个字节

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

C（gcc），70个字节

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

我希望找到一个基于递归函数的较短解决方案，但由于输出要求而未能解决。因此，这是一种必要的方法。至少，C的运算符优先级可以很好地用于内部循环语句。

在线尝试！

R，48 50 61字节

作为未命名的函数

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

感谢@guiseppe提供了一些额外的字节。

charToRaw取s并分裂成原始矢量。这将转换为整数并diff应用。 sign使差异成为一个单位。 range将向量减小到最小和最大。然后，如果标准偏差sd小于1，则为TRUE

在线尝试！

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

果冻，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

Mathematica，33个字节

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

基于此技巧。不幸的是，我必须使用ToCharacterCode而不是Characters，因为<=并且>=不要比较字符串。

PowerShell，61字节

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

在线尝试！

接受input $a，然后检查它是否-in为两个元素的数组。该数组是通过以下方式形成的：将其$a转换为char-array，将其存储在$b后面以供sort-object按词法排序。另一个元素$b按-des升序排序。

Perl，35个字节

直接使用@Xcali节省了4个字节，间接节省了4个字节。

31个字节的代码+ -pF标志。

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

在线尝试！

该代码对输入进行排序，并检查输入是否与已排序的自身匹配（或以相反的顺序）。

果冻，5 个字节

,Ue@Ṣ

在线尝试！

怎么样？

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

Bash + coreutils，59个字节

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

输入字符串作为参数传递。

如PPCG I / O方法所允许，输出以退出代码返回（0表示真，1表示虚假）。

PHP，66字节

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

从命令行参数获取输入。用运行-r。

红宝石，44字节

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

在线尝试！

球拍，93字节

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

在线尝试！

取消高尔夫：

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

使用排序然后与原始方法进行比较

Brachylog，5个字节

我试图找到一个4字节的解决方案没有成功，所以现在这是我发现的最有趣的5字节的解决方案：

:No₎?

在线尝试！

o，排序功能，可以接受一个参数：0表示升序，1表示降序。我们将该参数设置为一个未绑定的变量N。Brachylog将尝试为N（仅0或1可能）使用不同的值，尝试与输入统一结果，并返回这些尝试是否成功。

MATLAB /八度，38字节

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

在线演示

JavaScript（ES6）74 62 50 47 43字节

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

经过打高尔夫球和修正错误后，这个答案与ETHProduction的答案几乎相同，因此请检查他的答案并给它一个+1。

Haskell，54个 50字节

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

用法示例：t "defggh"-> True。在线尝试！。

也许sort像其他答案一样使用可能更短，尽管需要import Data.List。这是另一种方法：

对于f来自的每个函数[(=<<),(<*>)]，计算and(zipWith(<=)`f`tail$a)并要求得到任何结果True。这些功能是

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

其中两个执行输入列表的相邻元素的比较a用<=，但一个与参数翻转导致>=。and检查所有比较是否为True。

Pushy，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

Pyth，5个字节

}Q_BS

输入a "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

八度，24字节

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

在线尝试！

GNU sed，97 + 1（r标志）= 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

CJam，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)

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

Scala，47个字节

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