Ruby/Практикум/Числа

Числа

Дано четырехзначное целое число. Необходимо проверить, является ли оно числом Армстронга.

Возможное(Рабочее для всех чисел) решение:

print("Введите число: ")
s = gets.chomp
sc = 0
l = s.size
m = s.split(//)
for i in 0..(l - 1)
        sc = sc + (m[i].to_i**l)
end
if (s.to_i == sc) then
        puts "Число является числом Армстронга"
else
        puts "Число не является числом Армстронга"
end
STDIN.getc

Замечания по решению: вместо for лучше использовать each -- код будет чище и понятнее

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

class Fixnum 
  def is_narcissistic?
    (self.to_s.split(//).map(&:to_i).inject(0){ |x,y| x + y**(self.to_s.size) }) == self ? true : false
  end
end
p 153.is_narcissistic? #true

Замечания по решению: Создание нового метода в классе Fixnum.

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

puts "Введите 4х значное число, мы проверим его на число Армстронга"

number = gets.chomp
sum = 0

number.each_char { |i| sum +=  (i.to_i ** number.size) }

reply = if number.to_i == sum
	"#{sum} Является числом Армстронга"
        else
          "Не является числом Армстронга"
        end

puts reply

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

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

puts "Enter the number"
number = gets.chomp
num_string = number.to_s
stepen = num_string.length
num_array = num_string.split(//)
summ = 0
num_array.each{|x| summ +=(x.to_i ** stepen)}

if number.to_i == summ
	puts "Число является числом Армстронга"
else
	puts "Число не является числом Армстронга"
end

Вариант возможного решения

input   = (Integer(gets.chomp)).to_s
summ = 0
input.each_char {|element| summ += element.to_i**input.size}

if summ == input
    puts "The number #{input} is a number of Armstrong."
else 
    puts "The number #{input} is not a number of Armstrong."
end

Идет k-я секунда года. Необходимо определить сколько полных месяцев и полных недель осталось до конца года.

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

k = 12312
s = 365*24*60*60
m = (s-k)/(30*24*60*60)
n = (s-k)/(7*24*60*60)

Замечания по решению: решение дано для задачи сколько полных месяцев или полных недель осталось до конца года исправить нетрудно(см. задачу 1.42) мой вариант(месяц=28 дней, в месяце 4 недели)

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

k=12312345
temp=(28*12*24*60*60-k)/24/60/60
puts "#{temp/7/4} полных месяцев и #{temp/7%4} полных недель"

По-моему этот код неправильный

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

tn = Time::now
p 12 - tn.month
p Time::new(tn.year, 12, 31).strftime("%W").to_i - tn.strftime("%W").to_i

Замечания по решению: С неделями получилось немного запутано, зато код устойчив к високосным годам. Это решение выглядит наиболее практичным, однако неуместно в практикуме про числа.

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

puts "Months: #{(31536000 - rand(1-31536000))/60/60/24/30}, weeks: #{(((31536000 - rand(1-31536000))/60/60/24) % 30)/7}"

Даны два числа. Необходимо найти их среднее геометрическое.

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

print ("Введите первое число: ")
pc = gets.to_i
print ("Введите второе число: ")
vc = gets.to_i
sg = (pc * vc) ** 0.5
print ("Среднее геометрическое равно #{sg}")
STDIN.getc              #Ожидание ввода

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

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

print ("Введите значение x:")
x = gets.to_i
print ("Введите значение y:")
y = gets.to_i
puts f = Math.sqrt(y * x)   # присвоение избыточно, позволяет сохранить решение "про запас"

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

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

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

l = 0
while l != 6 do
	print("Введите шестизначное число: ")
	ch = gets.chop
	l  = ch.length
	if l != 6 then
		puts "Ошибка!!! Число #{ch.to_i} не шестизначное."
	end
end

m = ch.split(//)
ml = m[0].to_i + m[1].to_i + m[2].to_i
mr = m[3].to_i + m[4].to_i + m[5].to_i
if ml == mr then
  puts "Число #{ch.to_i} счастливое"
else
  puts "Число #{ch.to_i} не счастливое"
end
STDIN.getc

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

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

def is_lucky(x)
    if x.to_s.size != 6
        puts "for 6-digit numbers only"
        return false
    end
    digits = x.to_s.split(//)
    left_side_sum = digits
        .slice(0..2)
        .inject(0) { |mem, digit| mem + digit.to_i }
    right_side_sum = digits
        .slice(3..5)
        .inject(0) { |mem, digit|  mem + digit.to_i }
    if (left_side_sum == right_side_sum)
        true
    else
        false
    end
end

x = gets
puts is_lucky(x.to_i)

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

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

in_a = gets.chomp
if (in_a.length != 6)
	puts "You must enter 6-digit number."
	exit
end
in_a = in_a.match(/(\d{3})(\d{3})/)
proc = -> str {str.each_char.inject(0) {|sum, c| sum += c.to_i}}

puts "Lucky number!" if (proc.call(in_a[1]) == proc.call(in_a[2]))

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

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

happy = rand(111111..999999).to_s
arr = happy.split(//)
puts "Happy!" if arr[0].to_i + arr[1].to_i + arr[2].to_i == arr[3].to_i + arr[4].to_i + arr[5].to_i

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

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

l = 0
while l != 3 do
	print("Введите трёхзначное число:")
	ch = gets.chop
	l = ch.length
	if l != 3 then
		puts "Ошибка!!! Число #{ch.to_i} не трёхзначное!!!"
	end
end
b = true
m = ch.split(//)
for i in 1..2
	if m[i] < m[i - 1] then
		b=false
		break
	end
end
if b == false then
  puts "Цифры числа #{ch.to_i} не образуют возрастающую последовательность"
else
  puts "Цифры числа #{ch.to_i} образуют возрастающую последовательность"
end
STDIN.getc

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

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

print "Enter number: "
str = gets
num = str.chop.split(//)
p num == num.sort

Замечания по решению: Проверяет на неубывающую последовательность

Дано натуральное число меньшее 512. Необходимо проверить, является ли оно счастливым в двоичном представлении.

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

ch = 513
while ch < 1 || ch > 511 do
	print("Введите число [1..511]:")
	ch = gets.chop.to_i
	if ch < 1 || ch > 511 then
		puts "Ошибка!!! Число #{ch.to_i} не входит в указанный диапазон!!!"
	end
end

i    = 0
cht = String.new
cht  = ch
bch  = Array.new(12, 0)
bch1 = Array.new
m = [10, 10]
while cht > 0 do
	m      = cht.divmod 2
	cht    = m[0]
	bch[i] = m[1]
	i     += 1;
end

for j in 0..(i - 1)
	bch1[j] = bch[j]
end

a = i % 4

if i > 4 then
	for j in i..(i + (a - 1))
		bch1[j] = 0
	end
else
	for j in i..(a)
		bch1[j] = 0
	end
end

cht = ""
for i in 0..(bch1.length)
	cht.insert(i, bch1.at(i).to_s)
end
cht = cht.reverse
pl  = cht.length / 2
s1 = 0
s2 = 0

for i in 0..(pl - 1)
	s1 += cht[i].chr.to_i
	s2 += cht[i + pl].chr.to_i
end

print("Число #{ch} в десятичной системе = " + ch.to_s + "\n")
print("Число #{ch} в двоичной системе = " + cht.to_s + "\n")
if s1 == s2 then
	print("В двоичной системе число счастливое!")
else
	print("В двоичной системе число не счастливое")
end
STDIN.getc

Замечания по решению: Пример как не надо писать на руби... Экспрессивность языка сведена к базовым конструкциям.

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

puts "Введите натуральное число меньше 512"
flag = true
while flag do
	n = gets.to_i
	if n >= 512 then puts "Введите натуральное число меньше 512" ; flag = true
	else flag = false
	end
end
m = sprintf("%b",n)
p m = m.split(//)
sum1 = 0
sum2 = 0
if ((m.size[0]).zero?) then 
	(0...m.size/2).each do |i|
			sum1 = sum1 + m[i].to_i
			sum2 = sum2 + m[m.size-1-i].to_i 
	end
	if (sum1 == sum2) then puts "В двоичной системе число счастливое!"
	else puts "В двоичной системе число не счастливое!"
	end
else 
	puts "В двоичной системе число не счастливое!"
 end

Замечания по решению: Число 0 не входит во множество натуральных.

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

def lucky_bin(x)
    y = sprintf("%b", x)
    if (y.to_s.size % 2) != 0 || x <= 0 || x >= 512
        puts "unlucky one"
        return false
    end
    digits = y.to_s.split(//)
    left_side_sum = digits
        .slice(0...digits.size/2)
        .inject(0) { |sum, digit| sum + digit.to_i }
    right_side_sum = digits
        .slice(digits.size/2...digits.size)
        .inject(0) { |sum, digit| sum + digit.to_i }
    if left_side_sum = right_side_sum
        true
    else
        false
    end
end

x = gets
puts lucky_bin(x.to_i)

Замечания по решению: У меня возникает вопрос, кто-либо проверяет работу программ, перед тем, как их сюда разместить? Элементарная проверка выявляет ошибку: число 8 в двоичном представлении - это 1000, очевидно, что если разбить на группы 10 и 00, то сумма одной группы цифр не будет равна сумме второй группы("1 + 0 = 1" и "0 + 0 = 0"), т.е. число не является "счастливым", но представленная программа выше выдаёт нам true, что является неправильным.

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

print 'Введите число (0 < x < 512], х='
x = gets.to_i								              #пользователь вводит Х
binX = sprintf("%b", x)							      #перевод Х в двоичную СС
text1 = ' не является счастливым в двоичной СС'						
evenness = (binX.size).even?						      #проверка четности разряда (ответ будет true или false)
if (x > 512) || ( x<=0)							      #проверка числа по условию задачи (0<x<512]
	puts 'ERROR' 
elsif evenness == false						
	 puts 'число ' + x.to_s + text1					      #если разрядность нечетная, число несчастливое
else
	leftside = binX.slice(0..((binX.size/2)-1))		       	              #отделение левой части и запись в leftside		
	rightside = binX.slice(((binX.size/2))..binX.size)		      #отделение правой части и запись в rightside
	sumL = leftside.split('')						      #разделяем строку и создаём массив с
	sumR = rightside.split('')				        	      #левыми и правыми значениями
	left=0								              #переменные для хранения количества
	right=0								              #единиц каждой из сторон
	sumL.each do |el|						
		left = el.to_i + left.to_i				       	      #количество единиц для левой стороны
	end
	sumR.each do |el|
		right = el.to_i + right.to_i				              #количество единиц для правой стороны
	end
	if right == left                                                                 #если количество единиц в правой части равно количеству единиц в левой - число счастливое
		puts 'число ' + x.to_s + ' счасливое в двоичной СС'
	else 
		puts 'число ' + x.to_s + text1
	end
end

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

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

     val = gets.to_i;
     return false if val > 512 || val <= 0
     
     bin_str = sprintf("%b", val)
          
     s = 0
     bin_str.each_char.with_index{ |c, i| s += i > bin_str.size/2 ? c.to_i : -c.to_i }
     puts bin_str + " is  unlucky?" + (s==0).to_s

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

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

a = gets.chomp
exit if (a.to_i >= 512) or (a.to_i <= 1)
a_bin = sprintf("%b", a)
lf_a = 0
pr_a = 0
for chek in 0..a_bin.size-1
  chek < (a_bin.size/2) ? (lf_a += a_bin[chek].to_i) : (pr_a += a_bin[chek].to_i)
end
puts lf_a == pr_a ? "Da" : "Net"

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

Даны координаты некоторой точки A (на плоскости). Необходимо найти расстояние от точки A до начала координат.

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

print("Введите координату по оси X: ")
x = gets.to_f
print("Введите координату по оси Y: ")
y = gets.to_f
c = Math.sqrt(x**2 + y**2)
print("Расстояние от начала координат до точки = ")
printf("%5.2f", c)
STDIN.getc

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

Даны коэффициенты линейного уравнения: A и B . Необходимо найти корень этого уравнения.

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

print("Введите значение коэффициента A: ")
a = gets.to_f
print("Введите значение коэффициента B: ")
b = gets.to_f
x = -(b.quo a)
print("Корень х = ")
printf("%5.2f", x)
STDIN.getc

Замечания по решению: команда .to_f(перевод в формат числа с плавающей точкой) использована для универсальности, потому что иначе мы получим только целочисленное деление, а коэффициент по заданию может оказаться с плавающей точкой

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

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

l = 0
while l != 3 do
	print("Введите трёхзначное число:")
	ch = gets.chop
	l = ch.length
	if l != 3 then
		puts "Ошибка!!! Число #{ch.to_i} не трёхзначное!!!"
	end
end
b = true
m = ch.split(//)
for i in 1..2
	if m[i] > m[i - 1] then
		b=false
		break
	end
end
if b == false then
  puts "Цифры числа #{ch.to_i} не образуют убывающую последовательность"
else
  puts "Цифры числа #{ch.to_i} образуют убывающую последовательность"
end
STDIN.getc

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

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

n=321
m1=n.to_s.split(//)
p m1==m1.sort.reverse

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

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

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

c = 26
while c < 999 || c > 9999 do
	print("Введите четырёхзначное число [1000..9999]:")
	c = gets.to_f.round.to_i
		if c < 1000 || c > 9999
			print("Ошибка!!! Число не входит в диапазон [1000..9999]:\n")
		end
end

m = Array.new(4)
m = c.to_s.split(//)
h = Hash.new
j = 0

for i in 1..3
	if m[i] != m[i - 1]
		j += 1
	else
		h[i + 1] = i
	end
end

if j == 3
	print("Все элементы разные")
else
	p h.inspect
end
 
STDIN.getc

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

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

n=1524
m=n.to_s.split(//)
p m.uniq==m

Замечания по решению: 10+! Браво! Очень контрастно смотрится с предыдущим.

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

b = 1234
b = b.to_s.split(//)
h = Hash.new(0)
b.each {|x| h[x] += 1}
h.each do |k, v|
	puts "В числе b повторяется цифра #{k} : #{v} раз" if v > 1
end
puts "В числе нет совпадающих цифр" if b == b.uniq

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

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

puts 'Введите координаты первого поля: '
x1 = gets.to_i
y1 = gets.to_i
puts 'Введите координаты первого поля: '
x2 = gets.to_i
y2 = gets.to_i
z1 = (x1 + y1) % 2
z2 = (x2 + y2) % 2
if z1 == z2 then
	print('Поля одного цвета')
else
	print('Поля разных цветов')
end
STDIN.getc

Замечания по решению: Координаты шахматной доски задаются не одними цифрами, а вначале идет буква, потом цифра. Данный код не будет работать, если вводить координаты буквами и цифрами.

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

def color(n)                                                #функция для определения цвета клетки шахмотного поля
	axis = n.split('')                                   #полученное от юзера значение разбивается на массив, содержащий в первой ячейке букву, второй - цифру
	case (axis[0]) 
	when 'a','c','e','g'                                 # если первая ячейка содержит в себе данные буквы,
		if (((axis[1]).to_i).even? == true)  # а вторая ячейка является четной, то цвет номер 0 (белый), если является нечетной - то цвет номер 1 (черный)
			colorX = 0
		else
			colorX = 1
		end
	when 'b','d','f','h'                                 # второй случай противоположен первому
		if (((axis[1]).to_i).even? == true)
			colorX = 1
		else
			colorX = 0
		end
	end
	return colorX
end
puts 'Введите координаты первого поля, например e4.'
x1 = gets.chomp
puts 'Введите координаты второго поля, например f1.'
x2 = gets.chomp
if (color x1) == (color x2)                           # передаём значения х1 и х2 в функцию (которая вернет нам номер цвета) и сравниваем
	puts 'цвета совпадают'
else
	puts 'цвета разные'
end

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

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

def to_num (sym) #Возвращает численное выражение координаты
	('a'..'h').to_a.index(sym)
end
puts 'Input x1'; x1 = to_num(gets.chomp.to_s)
puts 'Input y1'; y1 = gets.to_i
puts 'Input x2'; x2 = to_num(gets.chomp.to_s)
puts 'Input y2'; y2 = gets.to_i
puts (x1 + y1).even? == (x2 + y2).even? #Сумма двух численных координат черных полей будет четной.

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

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

puts "Введите координаты первой клетки"
x1 = gets.chomp
puts "Введите координаты второй клетки"
x2 = gets.chomp
b = x1[0].ord + x1[1].ord
a = x2[0].ord + x2[1].ord
puts a.even? == b.even? ? "Да у них один цвет" : "Нет их цвета разные"

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

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

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

c = 26
while c < 100 || c > 999 do
	print("Vvedite chislo v diapazone[100..999]:")
	c = gets.to_f.round.to_i
		if c < 100 || c > 999
			print("OSHIBKA!!! Chislo ne vhodit v diapazon[100..999]:\n")
		end
end

m = Array.new(3)
m = c.to_s.split(//)
h = Hash.new
j = 0

for i in 1..2
	if m[i] != m[i - 1]
		j += 1
	else
		h[i + 1] = i
	end
end

if j == 2
	print("Vse elementy raznye")
else
	p h.inspect
end
 
STDIN.getc

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

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

 n = 311
 n = n.to_s.split(//)
p (n.size == n.uniq.size)?  "Sredi cifr dannogo chisla net odinakovih" :  "Sredi cifr dannogo chisla est odinakovie"

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

a = 464
a = a.to_s.split(//)
h = Hash.new(0)
a.each {|v| h[v] += 1}
h.each do |k, v|
	puts "Число #{k} повторяется #{v} раз" if v > 1
end

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

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

num = gets.to_i.to_s.split(//)
if num != num.uniq then
	puts "It have same numbers." 
else 
	puts "It have not same numbers."
end

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

Дано натуральное число меньшее 256. Необходимо найти сумму всех нечетных битов этого числа.

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

ch = 513
while ch < 0 || ch > 256 do
	print("Vvedite chislo[0..256]:")
	ch = gets.chop.to_i
	if ch < 0 || ch > 256 then
		puts "OSHIBKA!!! Chislo #{ch.to_i} ne vhodit v nujnyy diapazon!!!"
	end
end

i    = 0
cht = String.new
cht  = ch
bch  = Array.new(12, 0)
bch1 = Array.new
m = [10, 10]
while cht > 0 do
	m      = cht.divmod 2
	cht    = m[0]
	bch[i] = m[1]
	i     += 1;
end

for j in 0..(i - 1)
	bch1[j] = bch[j]
end

a = i % 4

if i > 4 then
	for j in i..(i + (a - 1))
		bch1[j] = 0
	end
else
	for j in i..(a)
		bch1[j] = 0
	end
end

cht = ""
for i in 0..(bch1.length)
	cht.insert(i, bch1.at(i).to_s)
end
cht = cht.reverse
m = cht.split(//)
l = m.size
s = 0

for i in 0..(l - 1)
	if (i % 2 == 0)
		s += m[i].to_i
	end
end

print("Chislo #{ch} v deseatichnoy sisteme = " + ch.to_s + "\n")
print("Chislo #{ch} v binarnoy sisteme = " + cht.to_s + "\n")
print("Summa nechiotnyh elementov = " + s.to_s + "\n")
STDIN.getc

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

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

puts "Vvedite naturaqlnoe chislo < 256"
flag = true
while flag do
	n = gets.to_i
	if n > 256 then puts "Vvedite naturaqlnoe chislo < 512" ; flag = true
	else flag = false
	end
end
m = sprintf("%b",n)
m = m.split(//)
sum = 0
size = ((m.size[0]).zero?)? m.size/2 :  m.size/2 + 1
1.step(size, 2) do |i| 
	sum = sum + m[i].to_i
end
p sum

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

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

while(1) 
	puts "Vvedite naturaqlnoe chislo < 256"
	number = gets.to_i
	if number < 256
		break
	else
		puts "vrong number"
	end
end

 p binary = number.to_s(2).reverse
sum = 0
for i in 0...binary.size
	sum+=binary[i].to_i if i%2==1
end
puts "summa nechotnux bit: #{sum}"

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

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

number = 65
p (number & 1) + (number & 4) / 4 + (number & 16) / 16 + (number & 64) / 64 if number >= 0 and number < 256

Замечания по решению: У меня программа выдает не правильный результат. Тут явно ошибка!

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

num = (rand(254) + 1)
num = num.to_s(2).split(//).reverse!
result = 0
num.size.times do |bit|
	result += num[bit].to_i if bit.odd?
end 
puts result

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

Идет k-я секунда суток. Необходимо определить сколько полных часов и полных минут прошло с начала суток.

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

h=k/3600
m=k%60

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

Дано целое число. Необходимо определить, является ли оно четным.

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

print("Vvedite tseloe chislo: ")
c = gets.to_f.round.to_i
if (c % 2 == 1)
	print("Chislo #{c} yavleaetsea nechiotnym")
else
	print("Chislo #{c} yavleaetsea chiotnym")
end
STDIN.getc

Замечания по решению: Классическое решение

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

n[0].zero?

Замечания по решению: Проверяем младший бит числа

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

p (n.even?)? "Even":"Odd"

Замечания по решению: Используем встроенный инструмент

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

number = 42
p (number & 1).zero?

Даны три числа. Необходимо найти их среднее геометрическое.

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

print ('Vvedite   I chislo: ')
pc = gets.to_i
print ('Vvedite  II chislo: ')
vc = gets.to_i
print ('Vvedite III chislo: ')
tc = gets.to_i
sg = (pc * vc * tc) ** (1.quo 3)
printf('Srednee geometricheskoe ravno %5.2f', sg)
STDIN.getc

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

Даны координаты двух полей шахматной доски. Необходимо определить, может ли конь добраться из одного поля в другое за один ход.

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

((i1-i2)!=0)&&((j1-j2)!=0)&&((i1-i2).abs+(j1-j2).abs == 3)

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

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

x1, x2, y1, y2 = 1, 2, 3, 4
p( ((x1 == x2-2) && (y1 == y2-1)) || 
((x1 == x2+2) && (y1 == y2-1)) || 
((x1 == x2+2) && (y1 == y2+1)) ||
((x1 == x2-2) && (y1 == y2+1)) || 
((x1 == x2-1) && (y1 == y2-2)) ||
((x1 == x2-1) && (y1 == y2+2)) ||
((x1 == x2+1) && (y1 == y2-2)) ||
((x1 == x2+1) && (y1 == y2+2)) )

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

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

x1,y1,x2,y2=1,5,3,6
p Math.sqrt((x1-x2)**2+(y1-y2)**2)==Math.sqrt(5)

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

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

puts 'Input first coordinate (c4:)' ; cFirst  = gets.chomp
puts 'Input second coordinate (c4:)'; cSecond = gets.chomp

cFirst[0] = (('a'..'h').to_a.index(cFirst[0]) + 1).to_s  #Перевод координаты типа с,4 в вид 3,4
cSecond[0] = (('a'..'h').to_a.index(cSecond[0]) + 1).to_s

yourMovie = (cFirst.to_i - cSecond.to_i).abs #разность двух координат дает понять смещение
puts [8, 12, 19, 21].include?(yourMovie)     #десятки это вертикали а единицы горизонтали

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

Даны коэффициенты квадратного уравнения: A, B и С. Необходимо найти корни этого уравнения.

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

print("A =  ")
a = gets.to_f
print("B =  ")
b = gets.to_f
print("C =  ")
c = gets.to_f
dk = b**2 - 4 * a * c
if (dk > 0)
  d  = Math.sqrt(dk)
  x1 = (- b + d) / (2 * a)
  printf("X1 = %5.2f\n", x1)
  x2 = (- b - d) / (2 * a)
  printf("X2 = %5.2f\n", x2)
end
if (dk == 0)
  d  = Math.sqrt(dk)
  x = (- b + d) / (2 * a)
  printf("X = %5.2f\n", x)
end
if (dk < 0)
  puts "Korney net!"
end
STDIN.getc

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

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

puts 'A*X2 + B*X + C = 0'
puts 'A = ?'; a = gets.to_f
puts 'B = ?'; b = gets.to_f
puts 'C = ?'; c = gets.to_f
d = b**2 - 4*a*c
if d >= 0 then
	x1 = (-b + d**0.5) / (2 * a)
	x2 = (-b - d**0.5) / (2 * a)
	x1 != x2 ? (puts "x1 = #{x1}, x2 = #{x2}, d = #{d}") : (puts "x = #{x1}")
else
	puts "Don`t have sqares! (D < 0)"
end

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

Дано целое четырехзначное число. Необходимо проверить является ли оно счастливым.

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

l = 0
while l != 4 do
  print('Vvedite 4 - i znachnoe chislo: ')
  ch = gets.chop
  l  = ch.length
  if l != 4 then
    puts "OSHIBKA!!! Chislo #{ch.to_i} ne 4 - i znachnoe!!!"
  end
end

m = ch.split(//)
ml = m[0].to_i + m[1].to_i
mr = m[2].to_i + m[3].to_i
if ml == mr then
  puts "Chislo #{ch.to_i} schastlivoe"
else
  puts "Chislo #{ch.to_i} neschastlivoe"
end
STDIN.getc

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

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

a=5234
puts ((a.to_s[0].to_i+a.to_s[1].to_i)==(a.to_s[2].to_i+a.to_s[3].to_i))

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

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

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

x1,x2,x3,y1,y2,y3 = 1,2,4,2,3,5
a = (x1+y1)[0]
b = (x2+y2)[0]
c = (x3+y3)[0]
(a == b)&&(b == c)&&(c == a)

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

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

x1,x2,x3,y1,y2,y3=1,4,2,7,4,6
p (x1+x2+y1+y2)[0]==(x1+x3+y1+y3)[0]

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

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

#Координаты в виде строки ('a1','c4'). На любое количество полей!
def to_num(c)
	c[0] = ('a'..'h').to_a.index(c[0]).to_s
	c[0].to_i + c[1].to_i
end
puts 'Input quantity of testing coordinates:'; n = gets.to_i
crds = Array.new
n.times do |n|
	puts "Input coordinate #{n + 1}"; crds.push(to_num(gets.chomp))
end
crds.map! { |c| c.even? }
puts crds.uniq.size == 1 ? 'Same color' : 'Different color'

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

Даны коэффициенты биквадратного уравнения: A, B и С. Необходимо найти корни этого уравнения.

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

d=(b**2)-(4*a*c)
t1=-b+Math.sqrt(d)
t2=-b-Math.sqrt(d)
x1=-Math.sqrt(t1)
x2=Math.sqrt(t1)
x3=-Math.sqrt(t2)
x4=Math.sqrt(t2)

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

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

a = 2; b = 4; c = 8
d = b**2 - 4*a*c
t1 = (-b + Math.sqrt(d)) / (2*a)
t2 = (-b - Math.sqrt(d)) / (2*a)
x1 = -Math.sqrt(t1);
x2 = Math.sqrt(t1);
x3 = -Math.sqrt(t2);
x4 = Math.sqrt(t2);

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

Дано пятизначное число. Необходимо получить число, которое получается перестановкой цифр исходного в обратном порядке.

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

a = 12345
b = a%10
c = a/10%10
d = a/100%10
e = a/1000%10
f = a/10000
f*10000 + e*1000 + d*100 + c*10 + b

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

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

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

s=12345
s.to_s.reverse.to_i

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

n = 12345
m = 0
while n>0 do
 m = m*10 + n%10
 n = n/10
end
n = m

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

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

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

x = 63517
a = x/10000
b = x/1000 - a*10
c = x/100 - (a*100 + b*10)
d = x/10 - (a*1000 + b*100 + c*10)
e = x - (a*10000 + b*1000 + c*100 + d*10)
p( (a < c)&&(c < e) )

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

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

a=12243
p (a/10000<a/100%10)&&(a/100%10<a%10)

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

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

odd = x.to_s.split(//).select.with_index { |elem, i| elem if i.even? }
p odd == odd.sort

Замечания по решению: по желанию можно перед .select добавить .map{|elem| elem.to_i}, тогда дальше будет обрабатываться массив цифр, а не строк, хотя на решение в данном случае это никак не повлияет

BlindMan (обсуждение) 10:33, 26 сентября 2012 (UTC)

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

x = 15341
p x / 100 < x % 1000 ? x % 1000 < (x % 10) * 100 : false

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

Дано натуральное число меньшее 256. Необходимо проверить, равенство первых и последних 4 бит этого числа.

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

(x[0]==x[4])&&(x[1]==x[5])&&(x[2]==x[6])&&(x[3]==x[7])

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

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

n=123
p (n/16==n%16)? "Yep":"No"

Замечания по решению: Поскольку биты идут подряд...

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

n = 68
p n >> 4 == n - ((n >> 4) << 4)

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

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

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

x = 1234
a = x/1000
b = x/100%10
c = x%100/10
d = x%10
a==b || b==c || c==d || a==d || b==d || a==c

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

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

x = 1652
p x.to_s.split("")!=x.to_s.split("").uniq

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

Дано натуральное число меньшее 256. Необходимо найти сумму всех четных битов этого числа.

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

ch = 513
while ch < 0 || ch > 256 do
	print("Vvedite chislo[0..256]:")
	ch = gets.chop.to_i
	if ch < 0 || ch > 256 then
		puts "OSHIBKA!!! Chislo #{ch.to_i} ne vhodit v nujnyy diapazon!!!"
	end
end

i    = 0
cht = String.new
cht  = ch
bch  = Array.new(12, 0)
bch1 = Array.new
m = [10, 10]
while cht > 0 do
	m      = cht.divmod 2
	cht    = m[0]
	bch[i] = m[1]
	i     += 1;
end

for j in 0..(i - 1)
	bch1[j] = bch[j]
end

a = i % 4

if i > 4 then
	for j in i..(i + (a - 1))
		bch1[j] = 0
	end
else
	for j in i..(a)
		bch1[j] = 0
	end
end

cht = ""
for i in 0..(bch1.length)
	cht.insert(i, bch1.at(i).to_s)
end
cht = cht.reverse
m = cht.split(//)
l = m.size
s = 0

for i in 0..(l - 1)
	if (i % 2 == 1)
		s += m[i].to_i
	end
end

print("Chislo #{ch} v deseatichnoy sisteme = " + ch.to_s + "\n")
print("Chislo #{ch} v binarnoy sisteme = " + cht.to_s + "\n")
print("Summa chiotnyh elementov = " + s.to_s + "\n")
STDIN.getc

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

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

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

a = 125
a = a.to_s(2).split(//)
sum = 0
0.step(a.size, 2) do |i| 
	sum = sum + a[i].to_i
end
p sum

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

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

s=129
p 64*s[6]+16*s[4]+4*s[2]+s[0]

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

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

num= gets
bin= sprintf("%b", num).to_s.split(//).reverse
index= 1   # 0 - nechetnie
factor= 2    # 1 - nechetnie
sum=0
while index <= bin.size do
   sum+=(bin[index].to_i*factor.to_i)
   index+=2
   factor*=4
end
puts sum
STDIN.getc

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

Даны коэффициенты биквадратного уравнения: A, B и С. Необходимо найти произведение корней этого уравнения.

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

a,b,c = 1,-4,1
d = b**2 - 4*a*c
z1 = (-b-Math.sqrt(d))/(2*a)
z2 = (-b+Math.sqrt(d))/(2*a)
x1 = Math.sqrt(z1)
x2 = -Math.sqrt(z1)
x3 = Math.sqrt(z2)
x4 = -Math.sqrt(z2)
p x1,x2,x3,x4

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

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

A,B,C=1,-7,12
p C

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

Дано натуральное число меньшее 16. Необходимо проверить, является ли оно двоичным полиндромом.

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

x = 14
(x[0] == x[3]) && (x[1] == x[2])

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

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

x = 15
p( (x[0]==x[3])&&(x[1]==x[2]) )

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

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

a=9.to_s(2)
p a==a.reverse

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

Даны координаты двух полей шахматной доски. Необходимо определить, может ли слон добраться из одного поля в другое за один ход.

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

x1, x2, y1, y2 = 1, 2, 3, 4
p( (x1-x2).abs == (y1-y2).abs )

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

Даны три числа. Необходимо найти их среднее арифметическое.

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

a=3
b=4
c=6
p (a+b+c)/3.0

Замечания по решению: Деление на 3.0 указывает, что операция не целочисленная, иначе ответ будет 4 вместо 4.(3)

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

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

x = 121
a=x/100; b=x/10%10; c=x%10
p ((b==a)&&(b!=c)&&(c!=a))||((b==c)&&(b!=a)&&(c!=a))||((a==c)&&(a!=b)&&(c!=b))

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

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

x = 911
a = x/100
b = x/10%10
c = x%10
p( ((a==b)&&(a!=c)&&(b!=c))||((b==c)&&(a!=c)&&(a!=b))||((a==c)&&(a!=b)&&(b!=c)) )

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

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

n=121
p n.to_s.split(//).uniq.size == 2

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

Дано четырехзначное целое число. Необходимо проверить, является ли оно счастливым.

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

a = 1234
b = a%10
c = a/10
e = c%10
d = c/10
g = d%10
m = d/10
(m + g) == (e + b)

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

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

d=3214
a=d/1000
b=d/100-a*10
c=d/10-(a*100+b*10)
r=d-(a*1000+b*100+c*10)
a+b==c+r

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

Дано трехзначное число. Необходимо получить число, которое получается перестановкой цифр исходного в обратном порядке.

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

m=123
a=m/100
b=(m-a*100)/10
c=(m-a*100-b*10)
p (c*100)+(b*10)+a

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

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

d=123
a=d/100
b=d/10-a*10
c=d-(a*100+b*10)
c*100+b*10+a

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

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

n=123
p n.to_s.reverse.to_i

Дано четырехзначное целое число. Необходимо проверить, является ли оно палиндромом.

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

n = 1234
a = n/1000
b = (n/100)%10
c = (n/10)%10
d = n%10
(a == d) && (b == c)

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

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

x=1234
a=x/1000
b=x/100-a*10
c=x/10-(a*100+b*10)
d=x-(a*1000+b*100+c*10)
(a==d)&&(b==c)

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

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

n = 1221
p (n.to_s.split(//)==n.to_s.split(//).reverse)? "da" : "net"

Замечания по решению: Здесь можно и без .split(//).

Дано натуральное число меньшее 256. Необходимо проверить, является ли оно счастливым в двоичном представлении.

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

x=165
( x[0]+x[1]+x[2]+x[3] ).eql?( x[4]+x[5]+x[6]+x[7] )

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

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

a=255
a[0]+a[1]+a[2]+a[3] == a[4]+a[5]+a[6]+a[7]

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

Даны три числа. Необходимо проверить, образуют ли они убывающую последовательность.

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

a=1
b=5
c=10
p (a>b)&&(b>c)

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

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

a, b, c = 7, 5, 1
p [a,b,c] == [a,b,c].sort.reverse

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

Дано шестизначное целое число. Необходимо проверить, является ли оно палиндромом.

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

d = 324156
a = d/100000
b = d/10000 - a*10
c = d/1000 - (a*100 + b*10)
e = d/100 - (a*1000 + b*100 + c*10)
f = d/10 - (a*10000 + b*1000 + c*100 + e*10)
g = d - (a*100000 + b*10000 + c*1000 + e*100 + f*10)
p(d == g*100000 + f*10000 + e*1000 + c*100 + b*10 + a)

Замечания по решению: Решение без фантазии

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

num = 123456
tmp = num
rev = 0
while tmp>0 do
 rev = rev*10 + tmp%10
 tmp = tmp/10
end
p (num == rev)? "Палиндром":"Не палиндром"

Замечания по решению: Каноническое решение для числа произвольной длины при запрете на приведение к строке.

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

a = 134431
p a == a.to_s.reverse.to_i

Замечания по решению: Вся сила Руби в одной строке.

Дано целое пятизначное число. Необходимо проверить, является ли оно палиндромом.

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

n = 12345
a = x/10000
b = x/1000%10
c = x%100/10
d = x%100/10
e = x%10
a==e || b==d

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

Даны три числа. Необходимо проверить, есть ли среди них хотя бы два одинаковых.

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

((a==b)or(b==c)or(c==a))

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

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

(a==b)||(b==c)||(c==a)

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

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

k,n,h=2,3,2
a=[k,n,h]
puts 'YES' if a!=a.uniq

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

Даны длины катетов прямоугольного треугольника. Необходимо найти длину гипотенузы.

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

a,b = 3,2
Math.sqrt(a**2 + b**2)

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

Идет n-я секунда суток. Необходимо определить сколько полных часов и полных минут осталось до конца суток.

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

n = 70000
x = 24*3600
t = x-n
h = t/3600
m = t%3600/60
p h.to_s + ':' + m.to_s

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

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

n=5040
last=86400-n
p "#{last/3600} ч. #{(last%3600)/60} мин."

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