Данный отчёт сгенерирован 04.04.2023 06:21:13 UTC.
HTML версия (этот сайт) сгенерирован 04.04.2023 06:21:31 UTC.
Коммит: [bfeb65b9] add automatic zip creation 04.04.2023 06:21:13
Задача: Сортування Структур 04.04.2023 06:21:13
Описание: Вже оголошено структуру struct Struct { public int Key; public string Value; } Оголосити статичний метод void Sort (Struct [] ss), який упорядкує структури в масиві за зростанням ключів. 04.04.2023 06:21:13
Решений: 41 04.04.2023 06:21:13
Сортування Структур 04.04.2023 06:21:13
 static void Sort(Struct[] ss)
{
    Array.Sort(ss, (s1, s2) => s1.Key.CompareTo(s2.Key));
}
 static void Sort(Struct[] ss)
        {
            Sort(ss, 0, ss.Length - 1);
        }
        static void swap(ref Struct a, ref Struct b)    
        {
            var temp = a;
            a = b;
            b= temp;
        }
        static void Sort(Struct[] ss, int l, int r)
        {
            if (l > r) return;
            int mid = ss[l + ((r - l) / 2)].Key;
            int i = l;
            int j = r;
            while (i<=j)
            {
                while (ss[i].Key < mid) i++;
                while (ss[j].Key > mid) j--;
                        if (i<=j)
                        {
                    swap(ref ss[i], ref ss[j]);
                    i++;
                    j--;
                        }
            }
            if(i< r) Sort(ss, i, r);
            if(j>l) Sort(ss, l, j);
        }
 static void Sort(Struct[] ss){
    for(int i = 0;i < ss.Length; i++){
        Struct p = ss[i];
        for(int j = i-1;j >= 0; j--){
            Struct p1 = ss[j];
            if(p.Key < p1. Key){
                ss[i] = p1;
                ss[j] = p;
            }
        }
    }
}
 static void Sort(Struct[] ss)
{
   Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] ss)
{
    int n = ss.Length;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (ss[j].Key > ss[j + 1].Key)
            {
                Struct temp = ss[j];
                ss[j] = ss[j + 1];
                ss[j + 1] = temp;
            }
        }
    }
}
 static void Sort(Struct[] ss){
    ss.OrderBy(x=>x.Key);
}
 static void Sort(Struct[] ss){
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] ss)
{
    for(int i = 0; i < ss.Length; i += 1)
    {
       foreach(Struct s in ss)
       {
           if(s.Key < i)
           {
               ss[i] = s;
           }
       }
    }
}
 static void Sort(Struct[] ss)
{
    Struct temp;
    for (int i = 0; i < ss.Length; i++)
    {
        for (int j = 0; j < ss.Length - 1; j++)
        {
            if (ss[j].Key > ss[j + 1].Key)
                {
                    temp = ss[j];
                    ss[j] = ss[j + 1];
                    ss[j + 1] = temp;
                }
        }
    }
}
 static void Sort(Struct[] ss)
{
    for(int i = 0, j = 1; j < ss.Length; i++, j++)
    {
        if(ss[i].Key > ss[j].Key)
        {
            var temp = ss[i];
            ss[i] = ss[j];
            ss[j] = temp;
        }
    }
}
 static void Sort(Struct[] ss) 
{
    Struct tmp;
    for (int i = 0; i < ss.Length; i++)
    {
        for (int j = i + 1; j < ss.Length; j++)
        {
            if (ss[i].Key > ss[j].Key)
            {
                tmp = ss[i];
                ss[i] = ss[j];
                ss[j] = tmp;
            }
        }
    }
}
 static void Sort(Struct[] ss) {
    ss = ss.OrderBy(key => key.Key).ToArray();
}
 static void Sort(Struct[] ss)
    {
        for (int i = 0; i < ss.Length - 1; i++)
        {
            for (int j = 0; j < ss.Length - i - 1; j++)
            {
                if (ss[j].Key > ss[j + 1].Key)
                {
                    Struct temp = ss[j];
                    ss[j] = ss[j + 1];
                    ss[j + 1] = temp;
                }
            }
        }
    }
 static void Sort(Struct[] ss)
{
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] ss){
    for (int i = 0; i < ss.Length-1; i++){
        int smallestval = i;
        for(int j = i + 1; j < ss.Length; j++){
            if(ss[j].Key < ss[smallestval].Key){
                smallestval = j;
            }
        }
        var temp = ss[smallestval];
        ss[smallestval] = ss[i];
        ss[i] = temp;
    }
}
 static void Sort(Struct[] ss)
{
    for (int i = 0; i < ss.Length; i++)
    {
    for (int j = i+1; j < ss.Length; j++)
        if(ss[i].Key > ss[j].Key)
        {
            Struct t = ss[i];
            ss[i] = ss[j];
            ss[i+1] = t;
        }
    }
}
 static void Sort(Struct[] ss)
{
    for(int i = 0; i < ss.Length; i++)
    {
        for(int j = 0; j < ss.Length - 1 - i; j++)
        {
            if(ss[j].Key > ss[j + 1].Key)
            {
                Swap(ref ss[j], ref ss[j + 1]);
            }
        }
    }
}

static void Swap(ref Struct a, ref Struct b)
{
    Struct temp = a;
    a = b;
    b = temp;
}
 static void Sort(Struct[] ss){
    bool swapped = false;
    for(int i = 0; i < ss.Length-1; i++){
        for(int j = 0; j < ss.Length-i-1; j++){
            if(ss[j].Key > ss[j+1].Key){
                swapped = true;
                (ss[j], ss[j+1]) = (ss[j+1], ss[j]);
            }
        }
        if(!swapped) break;
    }
}
 static void Sort(Struct[] ss)
    {
        for(int i=1; i>ss.Length; i++)
        {
            int elm = ss[i].Key;// само число ключ
            int prevElm = ss[i - 1].Key;
           // if(elm)
           while (elm< prevElm)
            {
                Struct p = ss[i];
                ss[i ] = ss[i - 1];
                ss[i - 1] = p;

                // 
            }

        }
    }
 static void Sort(Struct[] ss)
{
    Struct buffer;

    for(int i = 0; i < ss.Length; i++)
    {
        for(int j = 0; j < ss.Length; j++)
        {
            if (ss[i].Key < ss[j].Key)
            {
                buffer = ss[j];
                ss[j] = ss[i];
                ss[i] = buffer;
            }
        }
    }
}
 static void Sort(Struct[] ss) {
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
static void Sort(Struct[] ss) {
    for(int i = 0; i < ss.Length; i++) {
        for(int j = 0; j < i; j++) {
            if(ss[j].Key > ss[j+1].Key) {
                Struct t = ss[j+1];
                ss[j+1] = ss[j];
                ss[j] = t;
            }
        }
    }
}
 static void Sort(Struct[] ss)
{
   Array.Sort(ss, (s1, s2) => s1.Key.CompareTo(s2.Key));
}
 static void Sort(Struct[] ss)
{
    ss.OrderBy(x=>x.Key);
}
 static void Sort(Struct[] ss)
{
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] s) {
    for (int i = 1; i < s.Length; i++) {
        for (int j = s.Length - 1; j >= i; j--) {
            if (s[j].Key > s[j - 1].Key) continue;
            Struct temp = s[j - 1];
            s[j - 1] = s[j];
            s[j] = temp;
        }
    }
}
 static void Sort(Struct[] ss)
{
    ss.OrderBy(x => x.Key);
}
 static void Sort(Struct[] ss) {
    Array.Sort(ss, (s1, s2) => s1.Key.CompareTo(s2.Key));
}
 static void Sort(Struct[] ss)
{

    for(int i = 0; i < ss.Length; i++)
    {
        for(int j = 0; j < ss.Length - 1 - i; j++)
        {
            if(ss[j].Key > ss[j + 1].Key)
            {
              Swap(ref ss[i], ref ss[j+1]);
            }
        }
    }
}

static void Swap(ref Struct a, ref Struct b)
{
    Struct temp = a;
    a = b;
    b = temp;
}
 static void Sort(Struct[] ss)
{
    int stop = ss.Length;
    
    for (int i = 1; i < stop; i++)
    {
        if (ss[i - 1].Key > ss[i].Key)
        {
            Struct temp = ss[i - 1];
            ss[i - 1] = ss[i];
            ss[i] = temp;
        }
        stop--;
    }
}
 static void Sort(Struct[] ss){
    for(int i=0; i< ss.Length-1; i++){
        if(ss[i].Key>ss[i+1].Key){
            Struct a=ss[i];
            ss[i]=ss[i+1];
            ss[i+1]=a;
        }
    }
}
 static void Sort(Struct[] ss){
    int t = ss.Length;
    for(int i = 0;i < t - 1;i++){
        for(int j = 0;j < t - i - 1;j++){
            if(ss[j].Key > ss[j + 1].Key){
                Struct temp = ss[j];
                ss[j] = ss[j +1];
                ss[j + 1] = temp;
            }
        }
    }
}
 static void Sort(Struct[] ss){
for(int j = 0; j < ss.Length; j++){
    for(int i = 0; i < ss.Length-1; i++){
        if(ss[i].Key>ss[i+1].Key){
            Struct newStruct = new Struct {Key = ss[i].Key, Value = ss[i].Value};
            ss[i] = new Struct {Key = ss[i+1].Key, Value = ss[i+1].Value};
            ss[i+1] = newStruct;
            }
        }
    }
}
 static void Sort(Struct[] ss){
    for (int i = 0; i < ss.Length-1; i++)
    {
        if (ss[i].Key > ss[i+1].Key)
        {
            Struct tmp= ss[i];
            ss[i]= ss[i+1];
            ss[i+1]= tmp;
        }
    }
}
 static void Sort(Struct[] ss) {
    Array.Sort(ss, (x, y) => y.Key.CompareTo(x.Key));
}
 static void Sort(Struct[] ss){
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] ss) {
     ss.OrderBy(a => a.Key);
}
 static void Sort(Struct[] ss)
{
    // Это будет шейкерная сортировка
    int left = 0, right = ss.Length - 1;
    while (left <= right)
    {
        for (int i = right; i > left; i--)
        {
            if (ss[i - 1].Key > ss[i].Key)
                (ss[i - 1], ss[i]) = (ss[i], ss[i - 1]); // типа Swap(...) в C++
        }
        ++left;
        for (int i = left; i < right; i++)
        {
            if (ss[i].Key > ss[i + 1].Key)
                (ss[i], ss[i + 1]) = (ss[i + 1], ss[i]);
        }
        --right;
    }
}
 static void Sort(Struct[] ss)
{
    Array.Sort(ss, (x, y) => x.Key.CompareTo(y.Key));
}
 static void Sort(Struct[] ss)
{
    Struct[] sorted = new Struct[ss.Length];
    for(int i = 0;i< ss.Length;i++)
    {
        int count = 0;
        for(int q = 0;q< ss.Length;q++)
        {
            if(ss[i].Key>ss[q].Key) count++;
        }
        if(sorted[count].Value==null)
        {
            sorted[count] = ss[i];
        }
        else
        {
            sorted[count++] = ss[i];
        }
    }
    ss=sorted;
    
}
 static void Sort(Struct[] ss){
    for(int i = 0; i< ss.Length; i++)
    for(int j = ss.Length-1; j>0; j--){
        if(ss[j].Key < ss[j-1].Key){
            var temp = ss[j];
            ss[j] = ss[j-1];
            ss[j-1] = temp;
        }
    }
}