blocks|key|1702129|text|public+static+boolean+checkSortedness(final+int[]+data)+
{
++++for+(int+i+=+1;+i+<+data.length;+i%2B%2B)+
++++{
++++++++if+(data[i-1]+>+data[i])+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1702130|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static boolean checkSortedness(final int[] data) 
{
 for (int i = 1; i &lt; data.length; i++) 
 {
 if (data[i-1] &gt; data[i]) {
 return false;
 }
 }
 return true;
}
</code></pre>

blocks|key|1702193|text|应该是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1702194|public+static+bool+IsArraySorted(int[]+numbers)
{
++++bool?+ascending+=+null;

++++for+(int+i+=+1;+i+<+numbers.Length;+i%2B%2B)
++++{
++++++++if+(numbers[i+-+1]+!=+numbers[i])
++++++++{
++++++++++++bool+ascending2+=+numbers[i+-+1]+<+numbers[i];

++++++++++++if+(ascending+==+null)
++++++++++++{
++++++++++++++++ascending+=+ascending2;
++++++++++++}
++++++++++++else+if+(ascending.Value+!=+ascending2)
++++++++++++{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++}

++++return+true;
}|code-block|syntax|javascript|1702195|注意使用ascending变量保存数组的“方向”。当第一次发现两个不同的元素时，就初始化它。|offset|length|style|CODE|1702196|注意，如果需要，甚至可以返回数组的“方向”：|1702197|public+static+bool+IsArraySorted(int[]+numbers,+out+bool+isAscending)
{
++++isAscending+=+true;
++++bool?+ascending+=+null;|1702198|在if+(ascending+==+null)内部|1702199|if+(ascending+==+null)
{
++++ascending+=+ascending2;
++++isAscending+=+ascending2;
}|1702200|这是一个基于IEnumerable<TSource>的通用版本|1702201|public+static+bool+IsSorted<TSource>(IEnumerable<TSource>+source,+out+bool+isAscending,+Comparer<TSource>+comparer+=+null)
{
++++isAscending+=+true;

++++if+(comparer+==+null)
++++{
++++++++comparer+=+Comparer<TSource>.Default;
++++}

++++bool+first+=+true;
++++TSource+previous+=+default(TSource);

++++bool?+ascending+=+null;

++++foreach+(TSource+current+in+source)
++++{
++++++++if+(!first)
++++++++{
++++++++++++int+cmp+=+comparer.Compare(previous,+current);

++++++++++++if+(cmp+!=+0)
++++++++++++{
++++++++++++++++bool+ascending2+=+cmp+<+0;

++++++++++++++++if+(ascending+==+null)
++++++++++++++++{
++++++++++++++++++++ascending+=+ascending2;
++++++++++++++++++++isAscending+=+ascending2;
++++++++++++++++}
++++++++++++++++else+if+(ascending.Value+!=+ascending2)
++++++++++++++++{
++++++++++++++++++++return+false;
++++++++++++++++}
++++++++++++}
++++++++}

++++++++first+=+false;
++++++++previous+=+current;
++++}

++++return+true;
}|1702202|注意使用bool+first/TSource+previous来处理i+-+1+(以及for循环能够“跳过”第一个元素的事实)|1702203|entityMap^0|0|0|4|9|0|0|0|1|M|0|0|6|K|0|0|4|A|F|G|Y|5|17|3|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|19|8|@$I|1A|J|1B|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1H|8|@$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|11|$]]

It should be something like:

<pre><code>public static bool IsArraySorted(int[] numbers)
{
 bool? ascending = null;

 for (int i = 1; i &lt; numbers.Length; i++)
 {
 if (numbers[i - 1] != numbers[i])
 {
 bool ascending2 = numbers[i - 1] &lt; numbers[i];

 if (ascending == null)
 {
 ascending = ascending2;
 }
 else if (ascending.Value != ascending2)
 {
 return false;
 }
 }
 }

 return true;
}
</code></pre>

Note the use of the <code>ascending</code> variable to save the "direction" of the array. It is initialized the first time two elements that are different are found.

Note that if you want, you can even return the "direction" of the array:

<pre><code>public static bool IsArraySorted(int[] numbers, out bool isAscending)
{
 isAscending = true;
 bool? ascending = null;
</code></pre>

and inside the <code>if (ascending == null)</code>

<pre><code>if (ascending == null)
{
 ascending = ascending2;
 isAscending = ascending2;
}
</code></pre>

This is a generic version based on <code>IEnumerable&lt;TSource&gt;</code>:

<pre><code>public static bool IsSorted&lt;TSource&gt;(IEnumerable&lt;TSource&gt; source, out bool isAscending, Comparer&lt;TSource&gt; comparer = null)
{
 isAscending = true;

 if (comparer == null)
 {
 comparer = Comparer&lt;TSource&gt;.Default;
 }

 bool first = true;
 TSource previous = default(TSource);

 bool? ascending = null;

 foreach (TSource current in source)
 {
 if (!first)
 {
 int cmp = comparer.Compare(previous, current);

 if (cmp != 0)
 {
 bool ascending2 = cmp &lt; 0;

 if (ascending == null)
 {
 ascending = ascending2;
 isAscending = ascending2;
 }
 else if (ascending.Value != ascending2)
 {
 return false;
 }
 }
 }

 first = false;
 previous = current;
 }

 return true;
}
</code></pre>

Note the use of <code>bool first</code>/<code>TSource previous</code> to handle the <code>i - 1</code> (and the fact that the <code>for</code> cycle was able to "skip" the first element)

blocks|key|1702236|text|使用Linq+-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1702237|public+static+bool+IsArraySorted(int[]+numbers)
{
++++var+orderedAsc+=+numbers.OrderBy(a+=>+a);
++++var+orderedDes+=+numbers.OrderByDescending(a+=>+a);

++++bool+isSorted+=+numbers.SequenceEqual(orderedAsc)+%7C%7C
++++++++++++++++++++numbers.SequenceEqual(orderedDes);
++++return+isSorted;
}|code-block|syntax|javascript|1702238|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using Linq - 

<pre><code>public static bool IsArraySorted(int[] numbers)
{
 var orderedAsc = numbers.OrderBy(a =&gt; a);
 var orderedDes = numbers.OrderByDescending(a =&gt; a);

 bool isSorted = numbers.SequenceEqual(orderedAsc) ||
 numbers.SequenceEqual(orderedDes);
 return isSorted;
}
</code></pre>

blocks|key|1986336|text|这使用一个循环来测试这两种情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1986337|public+static+bool+IsSorted<T>(IEnumerable<T>+items,+Comparer<T>+comparer+=+null)
{
++++if+(items+==+null)+throw+new+ArgumentNullException("items");
++++if+(!items.Skip(1).Any())+return+true;++//+only+one+item

++++if+(comparer+==+null)+comparer+=+Comparer<T>.Default;
++++bool+ascendingOrder+=+true;+bool+descendingOrder+=+true;

++++T+last+=+items.First();
++++foreach+(T+current+in+items.Skip(1))
++++{
++++++++int+diff+=+comparer.Compare(last,+current);
++++++++if+(diff+>+0)
++++++++{
++++++++++++ascendingOrder+=+false;
++++++++}
++++++++if+(diff+<+0)
++++++++{
++++++++++++descendingOrder+=+false;
++++++++}
++++++++last+=+current;
++++++++if(!ascendingOrder+&&+!descendingOrder)+return+false;
++++}
++++return+(ascendingOrder+%7C%7C+descendingOrder);
}|code-block|syntax|javascript|1986338|用法：|1986339|int[]+ints+=+{+1,+2,+3,+4,+5,+6+};
bool+isOrderedAsc+=+IsSorted(ints);+//+true
bool+isOrderedDesc+=+IsSorted(ints.Reverse());+//true|1986340|如果将其作为扩展方法，则可以将其用于任何类型：|1986341|bool+ordered+=+new[]{"A",+"B",+"C"}.IsSorted();|1986342|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This uses one loop to test both cases:

<pre><code>public static bool IsSorted&lt;T&gt;(IEnumerable&lt;T&gt; items, Comparer&lt;T&gt; comparer = null)
{
 if (items == null) throw new ArgumentNullException("items");
 if (!items.Skip(1).Any()) return true; // only one item

 if (comparer == null) comparer = Comparer&lt;T&gt;.Default;
 bool ascendingOrder = true; bool descendingOrder = true;

 T last = items.First();
 foreach (T current in items.Skip(1))
 {
 int diff = comparer.Compare(last, current);
 if (diff &gt; 0)
 {
 ascendingOrder = false;
 }
 if (diff &lt; 0)
 {
 descendingOrder = false;
 }
 last = current;
 if(!ascendingOrder &amp;&amp; !descendingOrder) return false;
 }
 return (ascendingOrder || descendingOrder);
}
</code></pre>

usage:

<pre><code>int[] ints = { 1, 2, 3, 4, 5, 6 };
bool isOrderedAsc = IsSorted(ints); // true
bool isOrderedDesc = IsSorted(ints.Reverse()); //true
</code></pre>

If you make it an extension method you can use it with any type:

<pre><code>bool ordered = new[]{"A", "B", "C"}.IsSorted();
</code></pre>

blocks|key|1644819|text|我的答案在哪里？我一小时前写的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1644820|public+enum+SortType
{
+++++unsorted+++=+0,
+++++ascending++=+1,
+++++descending+=+2
}

public+static+SortType+IsArraySorted(int[]+numbers)
{
++++bool+ascSorted+=+true;
++++bool+descSorted+=+true;

++++List<int>+asc+=+new+List<int>(numbers);++++++++++++

++++asc.Sort();

++++for+(int+i+=+0;+i+<+asc.Count;+i%2B%2B)
++++{
++++++++if+(numbers[i]+!=+asc[i])+ascSorted+=+false;
++++++++if+(numbers[asc.Count+-+1+-+i]+!=+asc[i])+descSorted+=+false;
++++}

++++return+ascSorted+?+SortType.ascending+:+(descSorted?+SortType.descending+:+SortType.unsorted);
}|code-block|syntax|javascript|1644821|示例：|1644822|​|1644823|📷|atomic|offset|length|1644824|1644825|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/3dfc6cffa59bc6e9c0730a0b0d45e231.png|imageAlt^0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|13|8|@]|9|@$N|14|O|15|1|16]]|A|$]]|$1|P|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X|Y|-4]]]]

Where is my answer? I wrote it about an hour ago:

<pre><code>public enum SortType
{
 unsorted = 0,
 ascending = 1,
 descending = 2
}

public static SortType IsArraySorted(int[] numbers)
{
 bool ascSorted = true;
 bool descSorted = true;

 List&lt;int&gt; asc = new List&lt;int&gt;(numbers); 

 asc.Sort();

 for (int i = 0; i &lt; asc.Count; i++)
 {
 if (numbers[i] != asc[i]) ascSorted = false;
 if (numbers[asc.Count - 1 - i] != asc[i]) descSorted = false;
 }

 return ascSorted ? SortType.ascending : (descSorted? SortType.descending : SortType.unsorted);
}
</code></pre>

Example: 

<img src="https://i.stack.imgur.com/gZNJF.png" alt="enter image description here">

blocks|key|1702308|text|与其说这是一个实际的问题，不如说它更像是一个学术任务。我想偶尔回到基本面并不会有什么坏处：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1702309|public+static+bool+IsSortedAscOrDesc(int[]+arr)
{
++++int+last+=+arr.Length+-+1;
++++if+(last+<+1)+return+true;

++++bool+isSortedAsc+=+true;
++++bool+isSortedDesc+=+true;

++++int+i+=+0;
++++while+(i+<+last+&&+(isSortedAsc+%7C%7C+isSortedDesc))+
++++{
++++++++isSortedAsc+&=+(arr[i]+<=+arr[i+%2B+1]);
++++++++isSortedDesc+&=+(arr[i]+>=+arr[i+%2B+1]);
++++++++i%2B%2B;
++++}

++++return+isSortedAsc+%7C%7C+isSortedDesc;
}|code-block|syntax|javascript|1702310|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It looks more like an academic assignment than a practical question. I guess it does not hurt to return to basics once in a while:

<pre><code>public static bool IsSortedAscOrDesc(int[] arr)
{
 int last = arr.Length - 1;
 if (last &lt; 1) return true;

 bool isSortedAsc = true;
 bool isSortedDesc = true;

 int i = 0;
 while (i &lt; last &amp;&amp; (isSortedAsc || isSortedDesc)) 
 {
 isSortedAsc &amp;= (arr[i] &lt;= arr[i + 1]);
 isSortedDesc &amp;= (arr[i] &gt;= arr[i + 1]);
 i++;
 }

 return isSortedAsc || isSortedDesc;
}
</code></pre>

blocks|key|1644866|text|对包含2个(或更少)元素的数组进行排序，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1644867|{0,0}被排序为asc+&+desc，{0,1}+asc，{1,0}+desc，{1,1}+asc+&+desc。|1644868|可以使用一个循环，但分离情况似乎更快。对于具有两个以上元素的数组，|1644869|如果第一个元素小于最后一个元素，请检查:+ai+<=+ai+%2B+1。|1644870|下面我使用"ai+<=+(ai+=+ai)"，将ai的旧值与新的ai值进行比较，每个元素只读取一次。|1644871|using+System;
class+Program
{
++++static+void+Main()
++++{
++++++++int+i+=+512;+int[]+a+=+new+int[i--];+while+(i+>+0)+a[i]+=+i--;+//a[511]+=+1;
++++++++Console.WriteLine(isSorted0(a));
++++++++var+w+=+System.Diagnostics.Stopwatch.StartNew();
++++++++for+(i+=+1000000;+i+>+0;+i--)+isSorted0(a);
++++++++Console.Write(w.ElapsedMilliseconds);+Console.Read();
++++}

++++static+bool+isSorted0(int[]+a)++//+267+ms
++++{
++++++++if+(a.Length+<+3)+return+true;+int+j+=+a.Length+-+1;
++++++++return+a[0]+<+a[j]+?+incr(a)+:+a[0]+>+a[j]+?+decr(a)+:+same(a);
++++}
++++static+bool+incr(int[]+a)
++++{
++++++++int+ai+=+a[0],+i+=+1,+j+=+a.Length;
++++++++while+(i+<+j+&&+ai+<=+(ai+=+a[i]))+i%2B%2B;+return+i+==+j;
++++}
++++static+bool+decr(int[]+a)
++++{
++++++++int+ai+=+a[0],+i+=+1,+j+=+a.Length;
++++++++while+(i+<+j+&&+ai+>=+(ai+=+a[i]))+i%2B%2B;+return+i+==+j;
++++}
++++static+bool+same(int[]+a)
++++{
++++++++int+ai+=+a[0],+i+=+1,+j+=+a.Length+-+1;
++++++++while+(i+<+j+&&+ai+==+a[i])+i%2B%2B;+return+i+==+j;
++++}

++++static+bool+isSorted1(int[]+numbers)++//+912+ms++accepted+answer
++++{
++++++++bool?+ascending+=+null;
++++++++for+(int+i+=+1;+i+<+numbers.Length;+i%2B%2B)
++++++++++++if+(numbers[i+-+1]+!=+numbers[i])
++++++++++++{
++++++++++++++++bool+ascending2+=+numbers[i+-+1]+<+numbers[i];
++++++++++++++++if+(ascending+==+null)+ascending+=+ascending2;
++++++++++++++++else+if+(ascending.Value+!=+ascending2)+return+false;
++++++++++++}
++++++++return+true;
++++}
}|code-block|syntax|javascript|1644872|简短的版本。|1644873|++++static+bool+isSorted(int[]+a)
++++{
++++++++if+(a.Length+<+3)+return+true;+int+i+=+a.Length+-+1,+ai+=+a[i--];
++++++++if+(ai+>+a[0])+while+(i+>=+0+&&+ai+>=+(ai+=+a[i]))+i--;
++++++++else+if+(ai+<+a[0])+while+(i+>=+0+&&+ai+<=+(ai+=+a[i]))+i--;
++++++++else+while+(i+>=+0+&&+ai+==+a[i])+i--;+return+i+<+0;
++++}|1644874|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

An array with 2 (or less) elements is sorted, {0,0} is sorted asc &amp; desc, {0,1} asc, {1,0} desc, {1,1} asc &amp; desc. It is possible to use one loop, but it seems faster to separate cases.
For an array with more than 2 elements, if the first element is less than the last element,
check: a[i] &lt;= a[i + 1]. Below I use &quot;ai &lt;= (ai = a[i])&quot;, compare the old value of ai with the new
value of ai, each element is read once.
<pre><code>using System;
class Program
{
 static void Main()
 {
 int i = 512; int[] a = new int[i--]; while (i &gt; 0) a[i] = i--; //a[511] = 1;
 Console.WriteLine(isSorted0(a));
 var w = System.Diagnostics.Stopwatch.StartNew();
 for (i = 1000000; i &gt; 0; i--) isSorted0(a);
 Console.Write(w.ElapsedMilliseconds); Console.Read();
 }

 static bool isSorted0(int[] a) // 267 ms
 {
 if (a.Length &lt; 3) return true; int j = a.Length - 1;
 return a[0] &lt; a[j] ? incr(a) : a[0] &gt; a[j] ? decr(a) : same(a);
 }
 static bool incr(int[] a)
 {
 int ai = a[0], i = 1, j = a.Length;
 while (i &lt; j &amp;&amp; ai &lt;= (ai = a[i])) i++; return i == j;
 }
 static bool decr(int[] a)
 {
 int ai = a[0], i = 1, j = a.Length;
 while (i &lt; j &amp;&amp; ai &gt;= (ai = a[i])) i++; return i == j;
 }
 static bool same(int[] a)
 {
 int ai = a[0], i = 1, j = a.Length - 1;
 while (i &lt; j &amp;&amp; ai == a[i]) i++; return i == j;
 }

 static bool isSorted1(int[] numbers) // 912 ms accepted answer
 {
 bool? ascending = null;
 for (int i = 1; i &lt; numbers.Length; i++)
 if (numbers[i - 1] != numbers[i])
 {
 bool ascending2 = numbers[i - 1] &lt; numbers[i];
 if (ascending == null) ascending = ascending2;
 else if (ascending.Value != ascending2) return false;
 }
 return true;
 }
}
</code></pre>
A short version.
<pre><code> static bool isSorted(int[] a)
 {
 if (a.Length &lt; 3) return true; int i = a.Length - 1, ai = a[i--];
 if (ai &gt; a[0]) while (i &gt;= 0 &amp;&amp; ai &gt;= (ai = a[i])) i--;
 else if (ai &lt; a[0]) while (i &gt;= 0 &amp;&amp; ai &lt;= (ai = a[i])) i--;
 else while (i &gt;= 0 &amp;&amp; ai == a[i]) i--; return i &lt; 0;
 }
</code></pre>

blocks|key|1702337|text|我已经写了这个方法来检查是一个按升序排序的数组，我很感谢您的评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1702338|++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++int[]+arrayToCheck+=+{+1,+1,+3,+5+,2,+7};
++++++++++++
++++++++++++Console.WriteLine(IsSorted(arrayToCheck));
++++++++++++
++++++++}|code-block|syntax|javascript|1702339|在第一步中，我设置了"for循环“来检查每个数组整数是否小于index+-+1，然后创建了存储所有这些条件(true/false)的booleans数组。|1702340|+static+bool+IsSorted(int[]+array)
++++++++{
++++++++++++bool[]+checkAscending+=+new+bool[array.Length+-+1];

++++++++++++for+(int+i+=+1;+i+<+array.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++checkAscending[i+-+1]+=+array[i]+>=+array[i+-+1];
++++++++++++++++
++++++++++++}|1702341|在第二步中，为了将1的值赋值为true，将0赋值给false，conditionI设置了"for循环“嵌套if和else条件。|1702342|++++++++++++int[]+trueToOne+=+new+int[checkAscending.Length];
++++++++++++
++++++++++++for+(int+i+=+0;+i+<+checkAscending.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++if+(checkAscending[i]+==+true)
++++++++++++++++++++trueToOne[i]+=+1;
++++++++++++++++else+if+(checkAscending[i]+==+false)
++++++++++++++++++++trueToOne[i]+=+0;
++++++++++++}|1702343|在最后一步中，我必须创建新的方法"Add“，它将整数数组作为参数，并添加每个数组字符。如果加法的结果等于数组的trueToOne长度，这意味着所有条件都为真，并对整数数组进行排序。|1702344|++++++++++++int+result+=+Add(trueToOne);

++++++++++++if+(result+==+trueToOne.Length)
++++++++++++{
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++return+false;
++++++++++++}
++++++++}|1702345|并添加方法：|1702346|++++++++public+static+int+Add(int[]+array)
++++++++{
++++++++++++int[]+sum+=+new+int[array.Length];


++++++++++++for+(int+i+=+1;+i+<+array.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++sum[0]+=+array[0];
++++++++++++++++sum[i]+=+array[i]+%2B+sum[i+-+1];
++++++++++++}

++++++++++++return+sum[sum.Length+-+1];
++++++++}

++++}|1702347|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

I have written this method to check is an array sorted in ascending order.I would be grateful for your reviews.
<pre><code>
 static void Main(string[] args)
 {
 int[] arrayToCheck = { 1, 1, 3, 5 ,2, 7};
 
 Console.WriteLine(IsSorted(arrayToCheck));
 
 }
</code></pre>
In the first step I setted up &quot;for loop&quot; to check every single array integer is less than integer with index - 1. And then I created Array of booleans which stored all of these conditions (true/false).
<pre><code> static bool IsSorted(int[] array)
 {
 bool[] checkAscending = new bool[array.Length - 1];

 for (int i = 1; i &lt; array.Length; i++)
 {
 checkAscending[i - 1] = array[i] &gt;= array[i - 1];
 
 }
</code></pre>
In the second step in order to assign value of 1 to true and 0 to false conditionI setted up &quot;for loop&quot; nesting if and else condition.
<pre><code> int[] trueToOne = new int[checkAscending.Length];
 
 for (int i = 0; i &lt; checkAscending.Length; i++)
 {
 if (checkAscending[i] == true)
 trueToOne[i] = 1;
 else if (checkAscending[i] == false)
 trueToOne[i] = 0;
 }
</code></pre>
In the last step I had to create new method &quot;Add&quot; which takes array of integers
as a parameter and adding every single array character. If result of addition is equal to array trueToOne length that means all condition are true and Array of integers is sorted.
<pre><code>

 int result = Add(trueToOne);

 if (result == trueToOne.Length)
 {
 return true;
 }
 else
 {
 return false;
 }
 }
</code></pre>
And ADD METHOD:
<pre><code>
 public static int Add(int[] array)
 {
 int[] sum = new int[array.Length];


 for (int i = 1; i &lt; array.Length; i++)
 {
 sum[0] = array[0];
 sum[i] = array[i] + sum[i - 1];
 }

 return sum[sum.Length - 1];
 }

 }
</code></pre>

I'm having trouble writing a method that returns true if the elements of an array (numbers) are in sorted order, ascending or descending, and false, if they are not in any sorted order. I can return a correct boolean value if the array is ascending but i do not know how to check for descending order as well in the same method. I currently have: 

<pre><code>public static bool IsArraySorted(int[] numbers)
{
 for (int i = 1; i &lt; numbers.Length; i++)
 {
 if (numbers[i - 1] &gt; numbers[i])
 return false;
 }

 return true;
}
</code></pre>

Anyone able to offer help on how to check for a sorted descending array as well? Cheers!

C# sorting arrays in ascending and descending order

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

如果数组(数字)的元素按排序顺序(升序或降序)，如果元素没有按任何排序顺序排列，则编写一个返回true的方法有困难。如果数组正在上升，我可以返回一个正确的布尔值，但我不知道如何在同一方法中检查降序。我目前有：public static bool IsArraySorted(int[] numbers){    for ...

问C#排序数组的升序和降序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#排序数组的升序和降序EN