Ruby/Практикум/Массивы

Материал из Викиучебника — открытых книг для открытого мира
Перейти к: навигация, поиск

Содержание

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

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

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

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


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

p (a | b).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

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

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

(a[0]..a[-1]).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

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

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

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

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[a..b].max

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

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

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

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]) )

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