var s = new[] {1, 3, 3, 7, 9};
var r = s.Aggregate(new {V=int.MinValue, C=0}, (a, val) => a.V < val ? new {V=val, C=a.C+1} : a).C == s.Length;

var ascending = Enumerate()
                .Memoize(1)
                .Let(e => e.Zip(e.Skip(1), (a, b) => a < b))
                .All(x => x);

var isAscending = xs.OrderBy(x => x).SequenceEqual(xs);

var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);

var numbers = new[] {1, 3, 5, 7, 9};
bool isAscending = true;

int temp = numbers[0];

for (int i = 1; i < numbers.Length; i++)
{
    if (temp > numbers[i])
    {
        isAscending = false;
        break;
    }

    temp = numbers[i];
}

let rec f = function 
  | a::b::_  when a > b   -> false
  | h::t                  -> f t
  | _                     -> true

Помня одно предыдущее значение, соедини последовательность с самой собой, смещённой с на один элемент вперёд, и проверь, что во всех парах левое значение меньше или равно правому.

0K>var numbers = new[] {1, 3, 5, 7, 9};
0K>bool isAscending = true;

0K>int temp = numbers[0];

0K>for (int i = 1; i < numbers.Length; i++)
0K>{
0K>    if (temp > numbers[i])
0K>    {
0K>        isAscending = false;
0K>        break;
0K>    }

0K>    temp = numbers[i];
0K>}
0K>

var e = true; for (var i = 1; i < xs.Length; i++) if (xs[i-1] > xs[i]) e = false;
var isAscending = e;

pure auto f(int Arr[])
{
    if(Arr.length < 2)
        return true;
    
    if(Arr[0] > Arr[1])
        return false;
    
    return f(Arr[1 .. $]);
}

    if(Arr.length < 2)
00402017  push        ebx  
00402018  push        esi  
00402019  mov         esi,dword ptr [esp+2Ch] 
0040201D  cmp         esi,2 
00402020  push        edi  
00402021  jae         main@f+21h (402031h) 
        return true;
00402023  pop         edi  
00402024  mov         eax,1 
00402029  pop         esi  
0040202A  pop         ebx  
0040202B  add         esp,20h 
0040202E  ret         8    
    
    if(Arr[0] > Arr[1])
00402031  mov         edx,ecx 
00402033  mov         ebx,dword ptr [edx] 
00402035  mov         eax,esi 
00402037  cmp         ebx,dword ptr [edx+4] 
0040203A  jle         main@f+37h (402047h) 
        return false;
0040203C  pop         edi  
0040203D  xor         eax,eax 
0040203F  pop         esi  
00402040  pop         ebx  
00402041  add         esp,20h 
00402044  ret         8    
    
    return f(Arr[1 .. $]);
00402047  lea         edi,[esi-1] 
0040204A  add         edx,4 
0040204D  mov         ecx,edx 
0040204F  mov         dword ptr [esp+0Ch],edi 
00402053  mov         esi,edi 
00402055  mov         dword ptr [esp+10h],edx 
00402059  cmp         dword ptr [esp+0Ch],2 
0040205E  jb          main@f+13h (402023h) 
00402060  jmp         main@f+21h (402031h)

bool isOrdered = true;

enumerator.MoveNext();
var temp = enumerator.Current;

while (enumerator.MoveNext())
{
    if (temp > enumerator.Current)
    {
        isOrdered = false;
        break;
    }

    temp = enumerator.Current;
}

bool o = true; e.MoveNext();
var temp = e.Current;
while (e.MoveNext()){ if (temp > e.Current) { o = false; break; } temp = e.Current; }

Пустое множество считается упорядоченным.

SC>>var e = true; for (var i = 1; i < xs.Length; i++) if (xs[i-1] > xs[i]) e = false;
SC>>var isAscending = e;

SC>>

FR>Много недостатков алгоритм даже не квадратичный, "if" вместо оператора "?" мутабельный e нет рекурсии, в общем незачет

   e = !(xs[i-1] > xs[i]);

let rec f = function 
  | a::b::_  when a > b   -> false
  | h::t                  -> f t
  | _                     -> true

FR>А Linq это так, жалкое подобие

xs |> Seq.pairwise |> Seq.forall (fun (a,b) -> a <= b)

xs.Reduce((a, b) => a <= b).And()

K>xs |> Seq.pairwise |> Seq.forall (fun (a,b) -> a <= b)
K>

let rec pair_find f = function
  | a::b::t  -> if (f a b) then true else pair_find f (b::t)
  | _           -> false


let f l = pair_find (>) l |> not

int[] items = { 1, 2, 3, 4, 5 };

bool isAscending = items
    .GetAllPairsOfAdjacentItems()
    .ForAll( (previous, next) => (previous <= next) );

public class FileData {

    private int records_number;
    private long[] offsets;
    private int[] lengths;
    private RandomAccessFile raf;
    private FileChannel channel;
    MappedByteBuffer buffer;
    public FileData(String filename) {
            File file = new File(filename);
            long fl = file.length();
            raf = new RandomAccessFile(file, "r");
            records_number = raf.readInt();
            offsets = new long[records_number];
            lengths = new int[records_number];
            for (int i = 0; i < records_number; i++) {
                offsets[i] = raf.readLong();
                lengths[i] = raf.readInt();
            }
            channel = raf.getChannel();
            buffer = channel.map(
                    FileChannel.MapMode.READ_ONLY, 0, fl);

    }

seq.PairwiseBy((a,b) => a<b).All()

        private const int N = 30000000;
        static void Main(string[] args)
        {

            var ba = new double[N];
            for (int i = 0; i < N; i++)
                ba[i] = i*i;

            double sum = 0;
            DateTime t0 = DateTime.Now;
            for (int i = 0; i < N; i++)
                sum += ba[i];
            DateTime t1 = DateTime.Now;
            Console.WriteLine("{0} {1}", sum, t1-t0);

            t0 = DateTime.Now;
            double sum2 = ba.Sum(item => item);
            t1 = DateTime.Now;
            Console.WriteLine("{0} {1}", sum, t1 - t0);
        }

double sum2 = ba.Sum(item => item);

a, b = 1, 1

while True:
    process(a, b)
    a, b = b, a + b
    if is_exit():
        break