Как найти количество минимальных элементов массива

 В этой статье рассмотрены два способа нахождения минимального (максимального) элемента массива, а также задачи с применением этих способов.

1 способ

Считаем, что первый элемент массива – минимальный.  Затем, сравниваем, начиная со второго до последнего все элементы массива с минимальным. Используем для этого цикл. Если очередной элемент на каком-то шаге цикла оказывается меньше минимального, то значение минимального изменяем, присвоив ему значение этого очередного элемента. По окончании цикла выводим результат: минимальный элемент.

program min1;
var a:array[1..100] of integer;
i,min,n:integer;
begin
//заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do begin
a[i]:=random(-100,100);
write(a[i],’ ‘);
end;
//нахождение минимального элемента массива
min:=a[1];
for i:=2 to n do
if min>=a[i] then min:=a[i];
//вывод результата
writeln;
write(min);
end.

Заметим, что для нахождения максимального элемента массива достаточно заменить имя переменной min на max и знак >= на знак <=.

Если в задаче требуется найти индекс минимального (максимального), то вводим переменную imin, в которую будем запоминать индекс минимального (максимального), причем первоначально ее значение равно 1.

program min2;
var a:array[1..100] of integer;
i,min,n,imin:integer;
begin
//заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do begin
a[i]:=random(-100,100);
write(a[i],’ ‘);
end;
//нахождение индекса минимального элемента массива
min:=a[1];
imin:=1;
for i:=2 to n do
if min>=a[i] then begin
imin:=i;
min:=a[i];
end;
//вывод результата
writeln;
write(imin);
end.

Если в массиве есть несколько равных между собой минимальных элементов, то данная программа найдет номер последнего (правого) элемента. Для того чтобы найти индекс первого (левого) элемента достаточно изменить знак  >= на строгий знак >.
Эту программу можно оптимизировать, так как, зная индекс минимального элемента, можно найти значение минимального элемента массива. Значит, переменная min не нужна:

var a:array[1..100] of integer;
i,n,imin:integer;

Фрагмент нахождения индекса минимального элемента массива выглядит так:

imin:=1;
for i:=2 to n do
if a[imin]>=a[i] then imin:=i;

program min3;
var a:array[1..100] of integer;
i,min,n,k:integer;
begin
//заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do begin
a[i]:=random(-5,5);
write(a[i],’ ‘);
end;
//нахождение минимального элемента массива
min:=a[1];
for i:=2 to n do
if min>=a[i] then
min:=a[i];
//считаем количество равных элементов
k:=0;
for i:=1 to n do
if a[i]=min then k:=k+1;
//вывод результата
writeln;
write(k);
end.

В этой задаче первый способ нахождения минимального не подойдет. Первый элемент массива может оказаться меньше, чем минимальный четный и не кратный четырем и программа выведет неверный результат. Каким должно быть начальное значение переменной min? Его нужно выбрать таким, чтобы для первого же «подходящего» элемента выполнилось условие a[i] < min, и это «временное» начальное значение было бы заменено на реальное. Такое «подходящее» обязательно будет, так как это гарантировано условием задачи. Оно должно быть большим и таким, какое не может быть по условию задачи, например, 1001.

Кроме того заметим, что задавать элементы массива нужно с клавиатуры, чтобы обеспечить условия задачи.

Итак, находим минимальный элемент вторым способом.

2 способ

Записываем в переменную min значение 1001. Затем в цикле просматриваем все элементы массива, с первого до последнего. Если остаток от деления очередного элемента на 2 равен 0 и остаток от его деления на 4 не равен нулю и значение элемента меньше, чем значение переменной min, сохраняем в переменную min значение очередного элемента массива. После окончания работы цикла выводим значение переменной min.

program min4;
var a:array[1..100] of integer;
i,min,n:integer;
begin
//заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do
readln(a[i]);
for i:=1 to n do
write(a[i],’ ‘);
//нахождение минимального элемента массива
min:=1001;
for i:=1 to N do
if (a[i] mod 2=0) and (a[i] mod 4 <> 0) and (a[i]<min) then
  min:=a[i];
//вывод результата
writeln;
write(min);
end.

Проверяем на тестах:

 Конечно, решить эту задачу можно и первым способом, но для нахождения первого значения min нужно написать дополнительные команды поиска. Вот таким может быть решение:

program min5;
var a:array[1..100] of integer;
i,min,n,j:integer;
begin
//заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do
readln(a[i]);
for i:=1 to n do
write(a[i],’ ‘);
//нахождение первого четного и не кратного 4 числа
i:=1;
while (i<=n)and not((a[i] mod 2=0) and (a[i] mod 4 <> 0)) do i:=i+1;
//в переменной i запомнился номер первого элемента, удовлетворяющего условию
//нахождение минимального, начиная со следующего за найденным
min:=a[i];
for j:=i+1 to N do
if (a[j] mod 2=0) and (a[j] mod 4 <> 0) and (a[j]<min) then
  min:=a[j];
//вывод результата
writeln;
write(min);
end.

Мы знаем, как найти первый максимум, а в этой задаче нужно найти второй по величине максимум. Попробуем это сделать это за один проход по массиву. Нам нужны две переменные, max1 (максимальный элемент) и max2 (второй максимум). Сначала выбираем максимальный из первых двух элементов и записываем его значение в max1, а второй по величине записываем в max2.

Затем в цикле перебираем все элементы, начиная с 3-го до последнего. Если очередной элемент a[i] больше, чем max1, записываем значение max1 в max2 (предыдущий максимум становится вторым), а значение a[i] – в max1. Иначе, если a[i] больше, чем max2, записываем значение a[i] в max2. После завершения цикла выводим значение переменной max2.

program min6;
var a: array [1..100] of integer;
i, k,n, max1, max2: integer;
begin
  //заполнение массива и вывод массива в строчку
readln(n);
for i:=1 to n do begin
a[i]:=random(0,100);
write(a[i],’ ‘);
end;
//начальные значения max1 и max2
if a[1] > a[2] then begin
max1:=a[1]; max2:=a[2]
end
else begin
max1:=a[2]; max2:=a[1]
end;
// поиск второго максимального
for i:=3 to N do
if a[i] > max1 then begin
max2:= max1;
max1:= a[i]
end
else
if a[i] > max2 then max2:=a[i];
//вывод результата
writeln;
writeln(max2);
end.

Эта задача усложнена только тем, что элементы массива должны быть в диапазоне от 16 до 255. В этом случае первая цифра находится как результат деления нацело на 16, а вторая цифра – как остаток от деления на 16.

Кроме этого здесь массив можно объявить через константу n, так как размер массива задан явно: 20 элементов.

program z6;
//объявление массива через константу
const n=20;
var a: array [1..n] of integer;
i,min: integer;
begin
  //заполнение массива и вывод массива в строчку
for i:=1 to n do begin
a[i]:=random(0,10000);
write(a[i],’ ‘);
end;
writeln;
min := 10001;
for i := 1 to n do begin
//для проверки правильности программы выведем две шестнадцатеричные цифры:
//write(a[i] div 16,a[i] mod 16,’ ‘);
if (16 <= a[i]) and (a[i] < 256) and (a[i] div 16 > a[i] mod 16) and (a[i] < min) then
    min := a[i];
end;
writeln;
//вывод результата
if min = 10001 then
  writeln(0)
else
  writeln(min);
end.

Задачи для самостоятельного решения:

1. Дан целочисленный массив из n элементов. Элементы могут принимать значения от 150 до 210 ­– рост учащихся выпускного класса. В волейбольную команду берут тех, чей рост не менее 170 см. Напишите программу, которая определяет и выводит минимальный рост игрока баскетбольной команды. Гарантируется, что хотя бы один ученик играет в баскетбольной команде.
2. Дан целочисленный массив из n элементов. Элементы массива могут принимать целые значения от 0 до 100 – баллы учащихся выпускного класса за экзамен по информатике. Для получения положительной оценки за экзамен требовалось набрать не менее 50 баллов. Напишите программу, которая находит и выводит минимальный балл среди учащихся, получивших за экзамен положительную оценку. Известно, что в классе хотя бы один учащийся получил за экзамен положительную оценку.
3. Дан целочисленный массив – сведения о температуре за каждый день октября. Элементы массива могут принимать целочисленные значение значения от -15 до 20. Напишите программу, которая находит и выводит максимальную температуру среди дней, когда были заморозки (температура опускалась ниже нуля). Гарантируется, что хотя бы один день в октябре была отрицательная температура.
4. Дан целочисленный массив из n элементов, все элементы которого – неотрицательные числа, не превосходящие 10000. Напишите программу, которая находит и выводит минимальное трехзначное число, записанное в этом массиве. Если таких чисел нет, нужно вывести сообщение «Таких чисел нет».
5. Дан целочисленный массив из n элементов. Элементы массива могут принимать целые значения от 1 до 10000 включительно. Напишите программу, позволяющую найти и вывести наибольший из элементов массива, шестнадцатеричная запись которого оканчивается на букву F. Если таких чисел нет, нужно вывести ответ 0.
6. Дан целочисленный массив из n элементов. Элементы массива могут принимать произвольные целые значения. Напишите программу, которая находит и выводит номера двух элементов массива, сумма которых минимальна.
7. Дан целочисленный массив из 20 элементов. Элементы массива могут принимать целые значения от 1 до 10000 включительно. Напишите программу, находящую минимальный элементов массива, шестнадцатеричная запись которого содержит ровно две цифры, причём вторая (младшая) цифра – это буква (от A до F). Если таких чисел нет, нужно вывести ответ 0.

Источники информации

1. Угринович Н.Д. Информатика и информационные технологии. Учебник для 10-11 классов/ Н.Д. Угринович. – М.:Бином. Лаборатория знаний, 2005.
2. Сайт К. Полякова http://kpolyakov.spb.ru/school/ege.htm

Без сортировки задача может быть решена, например, так. Создаем рабочий массив длины m и заполняем его начальными значениями. В общем случае можно в качестве такого значения выбрать минимальное значение int/integer для соответствующей среды программирования. А если известна нижняя граница значений исходного массива, то можно взять любое число, меньшее этой границы.

Итак рабочий массив заполнен одинаковыми значениями. Теперь берем элемент за элементом исходного массива и вставляем его в нужное место рабочего массива. При этом длину рабочего массива сохраняем равной m (после вставки последний элемент пропадает). Если очередной элемент меньше последнего значения рабочего массива, то он просто пропускается. Этот процесс имеет вычислительную сложность O(nm). Тогда как сортировка в лучшем случае описывается асимптотикой O(n*og(n)). Асимптотики показывают, как ведет себя функция (в данном случае — время сортировки) при стремлении параметров к бесконечности. Можно сказать, что время описанного алгоритма при стремлении n к бесконечности задается формулой t1=k1*O(n), а время сортировки t2=k2*O(n*log(n)). Здесь k1 и k2 — некие константы, зависящие от процессора, языка программирования, операционной системы и других факторов.

Я построил три системы тестов (для Питона, Java и VBA). Все тесты устроены по сути одинаково: строились массивы возрастающих размеров, заполнялись случайными числами задаваемого диапазона, сортировались с фиксацией времени и прогонялись через описанный выше алгоритм тоже с фиксацией времени. Каждый тест повторялся 10 раз и время усреднялось. В Питоне и Java использовалась встроенная сортировка, в VBA — реализация QuickSort.

Питон

Ниже показан код питоновских тестов.

import time
from random import randint
    
def max_n_1(arr,n):
    return sorted(arr,reverse=True)[0:n]
    
def max_n_2(arr,n):
    res=[-1 for _ in range(n)]
    for x in arr:
        if x > res[n-1]:
            i=n-1
            j=i-1
            while(j>=0 and res[j]<x):
                res[i]=res[j]
                i=i-1
                j=j-1
            res[i]=x
    return res  
    
def start():
    k=10
    n=10000
    print("k=",k)
    while(n<=500000):
        print("n=",n,end=' ')

        t1=0.0
        for i in range(10):
            arr=[randint(1,2000) for _ in range(n)]
            start_time = time.time()
            z1=max_n_1(arr,k)
            fin_time = time.time()
            t1=t1+(fin_time-start_time)
        print(t1/10.0,end=' ')
    
        t2=0.0
        for i in range(10): 
            arr=[randint(1,2000) for _ in range(n)]
            start_time = time.time()
            z2=max_n_2(arr,k)
            fin_time = time.time()
            t2=t2+(fin_time-start_time)
        print(t2/10.0)
    
        n+=10000
        
start()

Размеры массива менялись от 10 до 500 тыс. элементов с шагом 10 тыс. Было выполнено два прогона: определение пяти и десяти максимумов. Результат для 10 максимумов показан ниже.

Время здесь приведено в миллисекундах. Что видим? Сортировка отстает (на краю интервала — вдвое). Для пяти максимумов картина аналогична. И надо заметить, что хотя питоновская сортировка очень эффективна, простой алгоритм оказывается быстрее. Заметны резкие провалы в производительности (зубцы на графиках). Они, вероятно, объясняются влиянием внутренних процессов (типа сборки мусора). Это же замечание относится и к другим графикам.

Java

Код тестов выглядел так:

import java.util.*;

class Start
{
   public static void main(String [] args)
   {   
    Random random = new Random();
    Scanner inp = new Scanner(System.in);
    long startTime,endTime,tot1,tot2;
    int i,a,b,n,m,x,ii,jj,u;
	
    a=1;
    b=3000; // диапазон случайных чисел [a,b]
    m=10;
    
    System.out.println(a+" "+b+" "+m);
    for (n=50000; n<=5000000; n+=50000)
    {
	    int arr[] = new int[n];
      int ma[]  = new int[m];
	
      tot1=0;
      for (u=0; u<10; u++)
      {        
	      for (i=0; i<n; i++)
	      {
		     arr[i]=a+random.nextInt(b-a+1);
	      }
        startTime = System.currentTimeMillis();
        Arrays.sort(arr);
        endTime = System.currentTimeMillis();
        tot1=tot1+(endTime-startTime);
      }

      tot2=0;
      for (u=0; u<10; u++)
      {        
	      for (i=0; i<n; i++)
	      {
		      arr[i]=a+random.nextInt(b-a+1);
	      }
   
        startTime = System.currentTimeMillis();
	      for (i=0; i<m; i++) ma[i]=-999999;
	      for (i=0; i<n; i++)
	      {
            x=arr[i];        
            if (x >= ma[m-1])
            {
              ii=m-1;
              jj=ii-1;
              while(jj>=0 && ma[jj]<x)
              {
                ma[ii]=ma[jj];
                ii--;
                jj--;
              }  
              ma[ii]=x;
            }
          }
          endTime = System.currentTimeMillis();
          tot2=tot2+(endTime-startTime);
        }
      System.out.println(n+" "+tot1+" "+tot2); 	
  	}
  } 
}

Здесь размер массива тоже менялся от 10 тыс. до 500 тыс. элементов. Время — в миллисекундах. Результат оказался весьма похожим на питоновский (только сортировка Javа, увы, медленнее).

VBA

В этом языке нет универсальной встроенной сортировки (можно, правда, сортировать ячейки листа, но в этом случае будут велики накладные расходы, связанные с загрузкой и выгрузкой данных). Поэтому пришлось реализовать QuickSort вручную. Все это выглядит так:

Private Declare Function GetTickCount Lib "kernel32" () As Long

'::: Собственно сортировка
Sub QSort(A() As Long, Optional b As Long = 1, Optional e As Long = 0)
    If b > e Then Exit Sub
    i& = b
    j& = e
    w& = A((i& + j&) / 2)
    Do While (True)
      Do While (A(i&) < w&)
         i& = i& + 1
      Loop
      Do While (A(j&) > w&)
         j& = j& - 1
      Loop
      If i& <= j& Then
         Tmp& = A(i&)
         A(i&) = A(j&)
         A(j&) = Tmp&
         i& = i& + 1
         j& = j& - 1
      End If
      If i& > j& Then Exit Do
    Loop
    
    If j& > b Then QSort A, b, j&
    If i& < e Then QSort A, i&, e

End Sub

'::: Проверка успешности сортировки 
Function check(X() As Long) As Boolean
     n& = UBound(X)
     For i& = 1 To n& - 1
         If X(i& + 1) < X(i&) Then
            Debug.Print "Err! i=" + CStr(i&)
            check = False
            Exit Function
         End If
     Next i&
     check = True
End Function

'::: Вставка в упорядоченный массив
Sub ins_in_arr(X As Long, A() As Long, n As Integer)
    If X < A(n) Then Exit Sub
    For i% = 1 To n
        If X > A(i%) Then
           For j% = n To i% + 1 Step -1
               A(j%) = A(j% - 1)
           Next j%
           A(i%) = X
           Exit Sub
        End If
    Next i%
End Sub

'::: Собственно тест
Sub test()
Const sz = 500
Dim X() As Long
Dim Ma(1 To sz) As Long
    Randomize
    ooo& = 1

    For n& = 10000 To 500000 Step 10000
        
        t1# = 0
        For nc% = 1 To 10
                    
            ReDim X(1 To n&) As Long
            For i& = 1 To n&
                X(i&) = Rnd() * 5000
            Next i&
            s1& = GetTickCount
            For i& = 1 To sz
                Ma(i&) = -2147483647
            Next i&
            For i& = 1 To n&
                ins_in_arr X(i&), Ma, 10
            Next i&
            s2& = GetTickCount
            t1# = t1# + s2& - s1&
        
        Next nc%
                
        Cells(ooo&, 1).Value = n&
        Cells(ooo&, 2).Value = t1# / 10
                
        t2# = 0
        
        For nc% = 1 To 10
        
            ReDim X(1 To n&) As Long
            For i& = 1 To n&
                X(i&) = Rnd() * 5000
            Next i&
            s1& = GetTickCount
            QSort X, 1, n&
            s2& = GetTickCount
            If Not check(X) Then
               MsgBox "Ошибка при сортировке!"
               Exit Sub
            End If
            t2# = t2# + s2& - s1&

        Next nc%

        Cells(ooo&, 3).Value = t2# / 10
        ooo& = ooo& + 1
        
    Next n&

End Sub

На каждом витке цикла корректность сортировки проверяется. Время проверки, естественно, не включается в общий хронометраж. Набор исходных данных тот же — от 10 до 500 тыс. целых чисел. Получает, в общем, похожая картина:

Представляет некоторый интерес изучить зависимость времени от количества искомых максимумов (при фиксированном размере массива). Здесь, очевидно, сортировка будет тем выгоднее, чем больше максимумов требуется найти. А вставка в упорядоченный массив будет тем медленнее, чем массив больше.

Самым невыгодным случаем будет являться, как ни странно, входной массив, уже упорядоченный по возрастанию. В этом случае количество сравнений при вставке достигнет максимума и будет равно n*m. Массив, упорядоченный по убыванию, напротив, весьма выгоден. Число сравнений здесь будет ~ m+n.

Описанный в самом начале статьи алгоритм, можно ускорить, если вместо простого упорядоченного массива использовать древовидную или пирамидальную структуру. Именно так и реализована в Питоне в модуле heapq функция nsmallest.

Для небольших массивов (несколько тысяч элементов и менее) разница в подходах представляется несущественной. И если нужно быстро написать код, то сортировка — вполне приемлемое решение. Для больших массивов выгоднее от сортировки отказаться.

Вот и все, что я хотел рассказать об этой задаче. Спасибо, что дочитали до конца. С наступившим 2021-м годом!

Массивы[править]

Дан целочисленный массив. Необходимо найти количество элементов, расположенных после последнего максимального.[править]

Возможное решение:

a = [1,6,4,5,23,7,8,23,1,4]
p a.reverse.index(a.max)

Замечания по решению:

Возможное решение:

a = [1, 3, 4, 2]
n = a.max
s = a.rindex(n)
m = a.size
k = m - s - 1

Замечания по решению:

Возможное решение:

m = [1,2,3,2,3,2,1,2]
p m[m.rindex(m.max)+1..-1].size

Замечания по решению:

Дан целочисленный массив. Необходимо найти индекс минимального элемента.[править]

Возможное решение:

a = [3, 4, 1, 5]
p a.index(a.min)

Замечания по решению:

Дан целочисленный массив и натуральный индекс (число, меньшее размера массива). Необходимо определить является ли элемент по указанному индексу глобальным максимумом.[править]

Возможное решение:

a = [3, 4, 1, 5]
n = 3
p a[n] == a.max

Замечания по решению:

Дан целочисленный массив. Вывести индексы массива в том порядке, в котором соответствующие им элементы образуют убывающую последовательность.[править]

Возможное решение:

maccuB = [1, 2, 3, 5, 4, 2, 3, 4]
p (0...maccuB.size).sort_by{ |i| maccuB[i] }.reverse

Замечания по решению:

Дан целочисленный массив и натуральный индекс (число, меньшее размера массива). Необходимо определить является ли элемент по указанному индексу глобальным минимумом.[править]

Возможное решение:

a = [3, 4, 1, 5]
n = 2
p a[n] == a.min

Замечания по решению:

Дан целочисленный массив. Необходимо осуществить циклический сдвиг элементов массива влево на три позиции.[править]

Возможное решение:

a = [1, 2, 3, 4, 5, 6, 7, 8]
p a.rotate(3)

Замечания по решению:
ruby 1.9.2

Возможное решение:

a = [1, 2, 3, 4, 5, 6, 7, 8]
p a[3...a.size] + a[0..2]

Замечания по решению:

Возможное решение:

a = [1, 2, 3, 4, 5, 6, 7, 8]
b = a.push(a.shift)
c = b.push(b.shift)
d = c.push(c.shift)
p d

Замечания по решению:

Возможное решение:

a = [1, 2, 3, 4, 5, 6, 7, 8]
3.times{ a<<a.shift }
p a

Замечания по решению:

Дан целочисленный массив. Необходимо осуществить циклический сдвиг элементов массива вправо на две позиции.[править]

Возможное решение:

a = [1, 2, 3, 4, 5, 6, 7, 8]
p a.rotate(-2)

Замечания по решению:
ruby 1.9.2

Возможное решение:

m = [1, 3, 4, 5, 6]
p( m[-2..-2] + m[-1..-1] + m[0..-3] )

Замечания по решению:

Возможное решение:

arr = [1,2,3,4,5,6]
2.times{arr.unshift(arr.pop)}
p arr

Замечания по решению:

Дан целочисленный массив. Необходимо найти индексы двух наименьших элементов массива.[править]

Возможное решение:

m = [1, 2, 3]
a = m.min
m1 = m-[m.min]
b = m1.min
p(m.index(a), m.index(b))

Замечания по решению:
Не работает, если в массиве более одного минимума (например, [1,2,1,3]).

Возможное решение:

a = [1,2,3,12,3,4,5,7,0,7,12,9,6]
p a.sort.slice(0...2).map { |item| a.index(item) }

Замечания по решению:
Не работает, если в массиве более одного минимума (например, [1,2,1,3]).

Возможное решение:

arr = [1,0,2,0,3,12,3,4,5,7,7,12,9,6]

m = [arr.index(arr.min)]
arr1 = arr
arr1[m[0]] = arr1.max+1
p m << arr1.index(arr1.min)

Замечания по решению:
Решение с учетом возможности наличия в массиве двух и более минимумов. — извращение просто

Возможное решение:

a=[1,4,3,1,5,6,3]
p Array(0...a.size).sort_by{|i|a[i]}.first 2

Замечания по решению:

Возможное решение:

p a = [2, 1, 5, 4, 3, 8, 1, 6, 9]

min1 = a.min
min2 = a.min_by {|i| !min1 }

p a.index(min1), a.index(min2)

Замечания по решению:
Решение не работает, если есть два одинаковых минимума

Дан целочисленный массив. Необходимо найти элементы, расположенные перед последним минимальным.[править]

Возможное решение:

m = [1,2,3,4,5,6,7,1]
a = m.rindex( m.min )
p m[0...a]

Замечания по решению:

Даны два массива. Необходимо найти количество совпадающих по значению элементов.[править]

Возможное решение:

a = [0, 2]
m = [2, 3]
p (a&m).size

Замечания по решению:

Дан целочисленный массив, в котором лишь один элемент отличается от остальных. Необходимо найти значение этого элемента.[править]

Возможное решение:

m = [1,1,1,9,1]
d = (m.sort[0] - m.sort[-1]) - m.sort[1]
p d

Замечания по решению:

1. Возвращает значение со знаком «-» (что не является искомым значением).

2. Работает неверно, если искомое значение — отрицательное (например, [1,1,1,-9,1]).

Возможное решение:

massive-[massive.sort[1]]

Замечания по решению:

Возможное решение:

a = [1,1,1,-9,1,1,1,1,1,1]
b = [ a - [a[1]], a - [a[2]] ].sort
p b[1]

Замечания по решению:

не работает для a = [1,-9,1,1,1,1,1,1,1]

Возможное решение:

m = [1,1,1,-9,1]
p(
if m[0]== m[-1]
  (m.uniq- m[0..0])[0]
elsif m[0]== m[1]
  m[-1]
else
  m[0]
end)

Замечания по решению:

Возможное решение:

 
arr = [1,1,1,1,-12,1,1,1]
x = arr.uniq
s = arr - [x[0]]
if s.size > 1:
  p x[0]
  else p x[1]
end

Замечания по решению:

Возможное решение:

 
a = [1,1,1,1,-12,1,1,1]
p ( a.count{|x| x == a.uniq[0] } ) == 1 ? a.uniq[0] : a.uniq[1]

Замечания по решению:

Возможное решение:

 
a = [1,1,1,-9,1,1,1,1]
p a.select { |num| a.count(num) == 1 }

Замечания по решению:

Возможное решение:

 
a = [1,1,1,-9,1,1,1,1]
a.sort!
p (a[0] * (a[1] - a[0]) + a[-1] * (a[-1] - a[-2])) / (a[1] - a[0] - a[-1] + a[-2])

Дан целочисленный массив. Необходимо переставить в обратном порядке элементы массива, расположенные между его минимальным и максимальным элементами.[править]

Возможное решение:

maccuB = [1, 2, 3, 4]
b = maccuB.min
c = maccuB.max
a = maccuB.index( b )
d = maccuB.index( c )
maccuB[a+1..d-1] = maccuB[a+1..d-1].reverse
p maccuB

Замечания по решению:

Не работает для примера [4,3,2,1]

Возможное решение:

m = [1, 2, 3, 4]
p [m.min] + (m - ([m.min]+[m.max])).reverse + [m.max]

Замечания по решению:Совсем плохой код, какие бы массивы ни были, он вырывает из них мин и макс элементы(где бы они ни были), потом всё оставшееся(что надо и не надо) переворачивает, а затем к концам прилепляет мин и макс и говорит что так и было

Возможное решение:

arr = [7,3,0,4,3,2,9,1]
mn, mx = arr.index(arr.min), arr.index(arr.max)
mn,mx = mx,mn if mn > mx

arr [mn+1...mx]=arr[mn+1...mx].reverse
p arr

Замечания по решению:
Решение с учетом возможности расположения в массиве максимального элемента перед минимальным.

Возможное решение:

a=[3,2,9,6,3,-4,1]
b=[a.index(a.min),a.index(a.max)].sort
p a[0..b[0]]+a[b[0]+1...b[1]].reverse+a[b[1]..a.size]

Замечания по решению:

Возможное решение:

arr = Array.new(10).map(){rand(10)}
p arr
max = arr.rindex(arr.max)
min = arr.index(arr.min)
left = min < max ? min : max
right = max > min ? max : min
p arr[0..left] + arr[left+1...right].reverse + arr[right..arr.size]

Замечания по решению:

Дан целочисленный массив. Необходимо разместить элементы, расположенные до минимального, в конце массива.[править]

Возможное решение:

m = [1,2,3,45,6,0,23,3,54,3]
p (m[m.index(m.min)..-1]+m[0..m.index(m.min)-1])

Замечания по решению:
Работает неправильно если, минимумом является первый элемент массива.

Возможное решение:

arr = [7,3,0,4,3,2,9,1]
(0...arr.index(arr.min)).each{arr<<arr.shift}
p arr

Замечания по решению:

Возможное решение:

a=[-7,7,1,9,-9,3,5,3]
a.index(a.min).times{a<<a.shift}
p a

Замечания по решению:

Возможное решение:

a = [3,2,5,2,3,4,1,4,3]
puts  a.push a.slice! 0...a.index(a.min)

Замечания по решению:

Дан целочисленный массив и интервал a..b. Необходимо найти количество элементов в этом интервале.[править]

Возможное решение:

m=[1,2,3,4,5]
a,b=1,3
p m[a..b].size

Замечания по решению:
Не верно если, a>b.
По заданию дан интервал a..b, если они его дают изначально неправильным, то это их проблемы, не нужно искать где бы усложнить себе задачу.

Возможное решение:

a,i1,i2=[2,6,9,4,5,2,6,4,9,6],6,2
i=[i1,i2].sort
p a[i[0]+1...i[1]].size

Замечания по решению:

Дан целочисленный массив и натуральный индекс (число, меньшее размера массива). Необходимо определить является ли элемент по указанному индексу локальным минимумом.[править]

Возможное решение:

m = [1,2,3,4,5,7]; i = 3
c = m[i] < m[i-1]
d = m[i] < m[i+1]
c == d

Замечания по решению: если c и d = false, то их сравнение c == d выдаст true. Нужно писать c && d, как в примере ниже

Возможное решение:

a=maccuB[n]
b=maccuB[n+1]
c=maccuB[n-1]
(a<b)&&(a<c)

Замечания по решению:

Возможное решение:

array,index=[2,7,4,2,4,1,8,9,5,3],[4]
p array[index-1..index+1].min==array[index]

Замечания по решению:

Дан целочисленный массив. Необходимо найти элементы, расположенные между первым и вторым максимальным.[править]

Возможное решение:

m = [2, 10, 5, 4, 10, 5, 10]
a = m.index( m.max )
b = m[0..a]
c = m[a+1..-1]
g = c.index( c.max ) + b.size

Замечания по решению:

Решение не верное, точнее недописанное.
Нужна строчка p m[a + 1…g]

Возможное решение:

a = [1,2,3,12,3,0,12,7,4,7,12,9,6]
b = a[(a.index(a.max) + 1)..-1]
p b[0...b.index(b.max)]

Замечания по решению:

Возможное решение:

m = [1,2,3,12,3,0,12,7,4,7,12,9,6]
fmin = m.index(m.max)
smin = (m[fmin+1..-1].index(m[fmin+1..-1].max)) + (fmin + 1)
p m[fmin+1 ... smin]

Замечания по решению:

Дан целочисленный массив. Необходимо поменять местами минимальный и максимальный элементы массива.[править]

Возможное решение:

m = [3, 2, 1, 7]
a = m.max
b = m.min
d = m.index( a )
c = m.index( b )
m[ d ] = b
m[ c ] = a
p m

Замечания по решению:

Возможное решение:

c=m.index(m.max)
b=m.index(m.min)
a=m.max
m[c]=m[b]
m[b]=a

Замечания по решению:

Возможное решение:

a = [1,2,3,2,3,0,5,7,4,7,12,9,6]
imin, imax = a.index(a.min), a.index(a.max)
a[imin], a[imax] = a.max, a.min
p a

Замечания по решению:

Даны два массива. Необходимо найти количество не совпадающих по значению элементов.[править]

Возможное решение:

maccuB1 = [1,2,3]
maccuB2 = [3,4,5]
p( (maccuB1-maccuB2).size + (maccuB2-maccuB1).size )

Замечания по решению:
не работает для варианта a = [-1, -2, -6, 4]
b = [ 2, 8, -6, 4, 2, -1 ]

Возможное решение:

 a = [-1, -2, -6, 4] 
b = [ 2, 8, -6, 4, 2, -1 ]
p ((a+b)-(a&b)).uniq.size

Возможное решение:

BlindMan (обсуждение) 20:34, 25 сентября 2012 (UTC)

Возможное решение:

a = [1,2,3,4,3,4,2]
b = [3,4,5,6,7,3]       
puts  (a|b).size-(a&b).size

Дан целочисленный массив. Необходимо найти элементы, расположенные перед первым минимальным.[править]

Возможное решение:

m = [1,2,1,4,3]
a = m.index(m.min)
m[0...a]

Замечания по решению:

Дан целочисленный массив. Необходимо осуществить циклический сдвиг элементов массива вправо на одну позицию.[править]

Возможное решение:

m = [1, 2, 3, 4]
p [ m[-1] ] + m[0..-2]

Замечания по решению:

Возможное решение:

a=[1,2,3,4]
a.unshift(a.pop)

Замечания по решению:

Возможное решение:

maccuB=[1,1,2,3,1,2,3]
zer=maccuB.size-1
na=maccuB[1..zer]
dub=maccuB[0]
na.push(dub)

Замечания по решению:сдвиг влево, к тому же не оптимизировано

Дан целочисленный массив. Необходимо найти все пропущенные числа.[править]

Возможное решение:

a = [1,5,8]
(a.min..a.max).to_a - a

Замечания по решению:

Чуточку проще:

BlindMan (обсуждение) 20:50, 25 сентября 2012 (UTC)

Замечания по решению:
It works only for a sorted array.
It doesn’t work for a = [1,9,3,7,5]

Дан целочисленный массив. Необходимо найти элементы, расположенные после первого максимального.[править]

Возможное решение:

m = [1, 2, 3, 4, 1, 2]
m[m.index( m.max )+1 .. -1]

Замечания по решению:

Возможное решение:

maccuB = [1,2,3,4,2,3,1,2,3]
x = maccuB.index( maccuB.max )
maccuB[x+1..-1].size

Замечания по решению:

Дан целочисленный массив и интервал a..b. Необходимо найти количество минимальных элементов в этом интервале.[править]

Возможное решение:

maccuB = [2, 2, 2, 3, 2, 2]
a,b = 3,5
p( maccuB[a..b].sort.rindex( maccuB.min ) )

Замечания по решению:

Неверное решение — должно быть p( maccuB[a..b].sort.rindex( maccuB.min )+ 1)

Возможное решение:

arr = [7,3,4,6,0,3,6,9,0]
d=1..3

p arr[d].select{|e| e==arr.min}.size

Замечания по решению:

Возможное решение:

any_arr = [1, 98, 34, 345, 1, 4895, 23, 2, 4]
y = any_arr[0..5]

p y.count(any_arr.min)

Замечания по решению:

Дан целочисленный массив. Необходимо найти два наименьших элемента.[править]

Возможное решение:

m = [1, 3, 3, 8]
m = m.uniq
m = m.sort
p m.shift
p m.shift

Замечания по решению:

Возможное решение:

m = [1,2,3,2,1,2,3]
p m.sort.uniq[0..1]

Замечания по решению:

Возможное решение:

mac = [1, 3, 7, 5, 8, 11]
p mac.min
mac.delete( mac.min )
p mac.min

Замечания по решению:

Возможное решение:

mac = [1, 3, 7, 5, 8, 11]
p mac.min, (mac - [mac.min]).min

Замечания по решению:

Возможное решение:

array = [1, 4, -7, 3, 9, -7]
p array.sort.uniq.first 2

Замечания по решению:

Дан целочисленный массив. Необходимо найти два наибольших элемента.[править]

Возможное решение:

m=m.sort.uniq
p m.pop
p m.pop

Замечания по решению:

Возможное решение:

maccuB = [6,9,3,4,2,5,1]
maccuB.max
maccuB.delete(maccuB.max)
maccuB.max

Замечания по решению:

Возможное решение:

arr = [7,3,4,6,0,3,6,0,9,1]

p arr.sort.uniq[-2..-1]

Замечания по решению:

Возможное решение:

array = [1, 4, -7, 3, 9, -7]

p array.sort.uniq.last 2

Замечания по решению:

Дан целочисленный массив и интервал a..b. Необходимо найти максимальный из элементов в этом интервале.[править]

Возможное решение:

Замечания по решению:

Дан целочисленный массив. Необходимо найти количество элементов между первым и последним минимальным.[править]

Возможное решение:

m = [1,0,0,1,0,0,1]
a = m.index(m.min)
b = m.rindex(m.min)
m[a+1...b]

Замечания по решению:

Т.к. в задании требуется найти количество элементов, то m[a+1…b].size или, b-a.

Возможное решение:

arr = [6,0,3,1,0,6,0,9,1]

p (arr.rindex(arr.min) - arr.index(arr.min) - 1)

Замечания по решению:

Дан целочисленный массив. Необходимо осуществить циклический сдвиг элементов массива влево на одну позицию.[править]

Возможное решение:

m=maccuB.shift
maccuB.push(m)

Замечания по решению:

Возможное решение:

maccuB = [1, 2, 3, 4, 5]
maccuB[1..-1] + [ m[0] ]

Замечания по решению:

Дан целочисленный массив. Необходимо найти элементы, расположенные между первым и последним максимальным.[править]

Возможное решение:

macc = [7,5,1,3,7]
_max = macc.max
_ind = macc.index(_max)
_rind = macc.rindex(_max)
_a = _ind + 1
_b = _rind - 1
macc[_a.._b]

Замечания по решению:

Возможное решение:

maccuB=[1,2,4,9,5,7,8,3]
a=maccuB.index(maccuB.max)
maccuB=maccuB[a+1..-1].reverse
a=maccuB.index(maccuB.max)
maccuB=maccuB[0..a-1].reverse

Замечания по решению:

Возможное решение:

max=array.max
p array[array.index(max)+1..array.rindex(max)-1]

Замечания по решению:

Дан целочисленный массив и интервал a..b. Необходимо проверить наличие максимального элемента массива в этом интервале.[править]

Возможное решение:

m = [1, 3, 4, 5, 6]
a,b = 1,5
p m.max == m[a..b].max

Замечания по решению:

Возможное решение:

maccuB = [1,1,3,1,1]
a = 0
b = 5
p( maccuB[a..b].include?( maccuB.max ) )

Замечания по решению:

Дан целочисленный массив и натуральный индекс (число, меньшее размера массива). Необходимо определить является ли элемент по указанному индексу локальным максимумом.[править]

Возможное решение:

m = [1, 2, 4, 2, 5, 7]
i = 3
(m[i] < m[i-1]) && (m[i] < m[i+1])

Замечания по решению:

Возможное решение:

m = [4, 3, 8, 8, 9, 7, 6, 7, 8, 5]
n = 8
p( (m[n-1] < m[n])&&(m[n] > m[n+1]) )

Замечания по решению: