Haskell, 34 bytes

f s=or[s==scanl1 q s|q<-[min,max]] 

Try it online!

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Then, s==scanl1 max s if s is sorted in increasing order. The same expression with min checks if the list is decreasing. In the code, [s==scanl1 q s|q<-[min,max]] checks both these options and or sees if either is true.

Compare to other expressions:

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] 

Haskell, 33 bytes

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

Try it online!

Thanks to Ørjan Johansen for 1 byte with aliasing scanl1 infix.

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

The same with min checks whether the list is decreasing. The code checks the two cases and combines them with ||.

Compare to other expressions:

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

Haskell, 34 bytes

f s=or[s==scanl1 q s|q<-[min,max]] 

Try it online!

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Then, s==scanl1 max s if s is sorted in increasing order. The same expression with min checks if the list is decreasing. In the code, [s==scanl1 q s|q<-[min,max]] checks both these options and or sees if either is true. This is twp bytes shorter than a more direct check:

f s=s==scanl1 max s||s==scanl1 min s 

Haskell, 34 bytes

f s=or[s==scanl1 q s|q<-[min,max]] 

Try it online!

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Then, s==scanl1 max s if s is sorted in increasing order. The same expression with min checks if the list is decreasing. In the code, [s==scanl1 q s|q<-[min,max]] checks both these options and or sees if either is true.

Compare to other expressions:

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] 

Haskell, 35 bytes

f s=elem s[scanl1 q s|q<-[min,max]] 

Try it online!

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

This equals to the original list exactly if it is sorted in increasing order. The same expression with min gives cumulative minima, which leaves invariant any decreasing list. In the code, [scanl1 q s|q<-[min,max]] generates both the cumulative minima and maxima, and elem s checks if the original list is either one. This is one byte shorter than a more direct check:

f s=s==scanl1 max s||s==scanl1 min s 

Haskell, 34 bytes

f s=or[s==scanl1 q s|q<-[min,max]] 

Try it online!

Haskell is an interesting language to golf sorting-based challenges because it does not have a built-in sort, barring a lengthy import Data.List. This encourages finding a way to do the task by hand without explicitly sorting.

The code uses scanl1, which folds an operation over the list from left to right, keeping track of the intermediate results. So, scanl1 max has the effect of listing the cumulative maxima of the list, i.e. the maxima of progressively longer prefixes. For example, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Then, s==scanl1 max s if s is sorted in increasing order. The same expression with min checks if the list is decreasing. In the code, [s==scanl1 q s|q<-[min,max]] checks both these options and or sees if either is true. This is twp bytes shorter than a more direct check:

f s=s==scanl1 max s||s==scanl1 min s