รับสตริงอินพุต S ส่งคืนtruthyถ้าตัวอักษรทั้งหมดใน S ถูกเรียงลำดับอย่างย่อ: ค่า ASCII ของพวกเขาต้องอยู่ในลำดับจากน้อยไปหามากหรือจากมากไปหาน้อย ส่งคืนfalsyในกรณีอื่น

อินพุต

• อินพุตจะอยู่ในกรณีเดียวกัน (ตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กทั้งหมด) การส่งของคุณควรจะสามารถจัดการได้ทั้งสองอย่าง
• ข้อมูลที่ป้อนจะประกอบด้วย ASCII ในช่วง[A-Za-z]เท่านั้น
• ความยาวของอินพุตจะต้องมีอย่างน้อย 1 ขึ้นอยู่กับภาษาของคุณที่รองรับได้สูงสุด
• อินพุตเป็นสตริง - ไม่ใช่รายการอักขระไม่ใช่อาร์เรย์ของ ASCII-codepoints

เอาท์พุต

• เอาต์พุตควรเป็นtrueหรือfalse, หรือ0/1, หรือtrue / falseเอาท์พุทสไตล์ที่แตกต่างอื่น ๆ ที่ภาษาของคุณสามารถให้
• เคสจริงทั้งหมดต้องมีเอาต์พุตเหมือนกันรวมถึงเคสเท็จทั้งหมด ไม่มี "เท็จเป็น 0 จริงคือ 1, 2 หรือ 3"

กฎเพิ่มเติม

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• คำตอบจะต้องเป็นโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบไม่ใช่ตัวอย่างหรือรายการ REPL
• code-golfคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ

กรณีทดสอบ

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

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

ลองออนไลน์!

ขอบคุณØrjan Johansen สำหรับ 1 ไบต์พร้อมนามแฝงscanl1มัด

Haskell import Data.Listเป็นภาษาที่น่าสนใจที่จะท้าทายกอล์ฟเรียงลำดับตามเพราะมันไม่ได้มีในตัวในการเรียงลำดับยกเว้นยาว สิ่งนี้กระตุ้นการค้นหาวิธีการทำงานด้วยมือโดยไม่ต้องเรียงลำดับอย่างชัดเจน

รหัสใช้scanl1ซึ่งพับการดำเนินการผ่านรายการจากซ้ายไปขวาติดตามผลกลาง ดังนั้นscanl1 maxมีผลกระทบจากรายการสูงสุดสูงสุดของรายการคือ maxima ของคำนำหน้าอีกต่อไปก้าวหน้า ตัวอย่างเช่น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เป็นตัวดำเนินการเปรียบเทียบสตริง"น้อยกว่าหรือเท่ากับ"และ"มากกว่าหรือเท่ากับ"
• [ ]รอบตัวดำเนินการมัดลด ("เท่า") รายการอาร์กิวเมนต์ด้วยตัวดำเนินการนั้น (มันฉลาดพอที่จะคืนค่าเป็น True ถ้าอินพุตมีเพียงศูนย์หรือหนึ่งตัวอักษร)
• or ผลตอบแทนจริงถ้าการแสดงออกของทั้งสองด้านของมันเป็นจริง

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ทำให้ diffs เป็นหน่วยเดียว 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)

ลองออนไลน์!

รับอินพุต$aจากนั้นตรวจสอบว่า-inเป็นอาร์เรย์สององค์ประกอบหรือไม่ อาเรย์ถูกสร้างขึ้นโดยการจับ$aมันเป็น - charเรย์เก็บไว้ใน$bภายหลังท่อไปsort-objectที่เรียงลำดับศัพท์ องค์ประกอบอื่น ๆ จะถูก$bจัดเรียงตามลำดับการส่ง-desมอบ

Perl , 35 ไบต์

บันทึก 4 ไบต์ต้องขอบคุณ@Xcaliโดยตรงและอีก 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

สตริงอินพุตถูกส่งผ่านเป็นอาร์กิวเมนต์

เอาท์พุทจะถูกส่งกลับในรหัสทางออก (0 สำหรับ truthy, 1 สำหรับ falsy ตามปกติ) เช่นได้รับอนุญาตจากPPCG ฉันวิธีการ

PHP, 66 ไบต์

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

รับอินพุตจากอาร์กิวเมนต์บรรทัดคำสั่ง -rทำงานด้วย

Ruby , 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))))

ลองออนไลน์!

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

ใช้การเรียงลำดับแล้วเปรียบเทียบกับวิธีการดั้งเดิม

Brachylogขนาด 5 ไบต์

ฉันพยายามหาโซลูชัน 4 ไบต์ไม่สำเร็จดังนั้นตอนนี้นี่เป็นโซลูชัน 5 ไบต์ที่น่าสนใจที่สุดที่ฉันพบ:

:No₎?

ลองออนไลน์!

oฟังก์ชั่นการสั่งซื้อสามารถใช้พารามิเตอร์: 0หมายถึงลำดับจากน้อยไปมาก1หมายถึงลำดับจากมากไปน้อย เราตั้งค่าพารามิเตอร์นั้นเป็นตัวแปรที่ไม่ได้ผูกNไว้ Brachylog จะลองใช้ค่าที่แตกต่างกันสำหรับN(เท่านั้น0หรือ1เป็นไปได้) พยายามรวมผลลัพธ์เข้าด้วยกัน

MATLAB / Octave, 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()

หลังจากการเล่นกอล์ฟและ bugfixing คำตอบนี้จบลงด้วยการที่สวยมากเช่นเดียวกับ 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ด้วยแต่อย่างหนึ่งที่มีการขัดแย้งพลิกผลในการ<= ตรวจสอบว่ามีการเปรียบเทียบทั้งหมด >=andTrue

มีขนาด 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

โปรแกรมที่รับอินพุต"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

สกาลา, 47 ไบต์

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