1、编写一个程序来计算前十个正整数（1 到 10）的平方和。
以下是使用 Ruby 语言实现的代码：
sum = 0
for i in 1..10
sum += i**2
end
puts sum
2、编写一个程序来计算6的阶乘（对于正整数，一个数的阶乘是从1开始到该数（包括该数）的所有数字的乘积。例如，3的阶乘 = 1 * 2 * 3 (= 6)）。
以下是使用递归函数计算阶乘的 Ruby 代码示例：
# 定义递归函数计算阶乘
def factorial(n)
if n <= 1
1
else
n * factorial(n - 1)
end
end
# 输出6的阶乘
puts factorial(6)
还可以使用三元运算符简化代码：
def facto(n)
(n <= 1) ? 1 : n * facto(n - 1)
end
puts facto(6)
3、斐波那契数列被定义为一系列整数，从第三个数开始，任何一个数都是它前两个数的和。给定前两个数为 0 和 1，该数列是 0,1,1,2,3,5, …。编写代码以打印出初始的 0 和 1 之后的前十个斐波那契数（此程序无需打印初始的 0 和 1）。
以下是实现该功能的 Ruby 代码：
def fibonacci
a, b = 0, 1
2.times do
a, b = b, a + b
end
10.times do
a, b = b, a + b
puts a
end
end
fibonacci
这段代码定义了一个名为
fibonacci
的方法，在方法内部，首先通过循环跳过初始的 0 和 1，然后再循环打印出接下来的十个斐波那契数。
4、编写一个程序，使用递归函数计算第 n 个斐波那契数（n 为正整数）。使用此函数找出第八个斐波那契数。已知第零个和第一个斐波那契数分别为 0 和 1。
根据斐波那契数列的定义，从第三个数开始，每个数都是前两个数之和。以下是使用 Ruby 语言实现的递归函数来计算第 n 个斐波那契数，并找出第八个斐波那契数的代码：
# 定义递归函数计算第 n 个斐波那契数
def fibonacci(n)
if n == 0
0
elsif n == 1
1
else
fibonacci(n - 1) + fibonacci(n - 2)
end
end
# 找出第八个斐波那契数
result = fibonacci(8)
puts result
运行上述代码，输出结果为
21
，即第八个斐波那契数是 21。
5、从正整数系列（从 1 开始）中，通过编程找出第一个平方超过 1000 的整数。
可通过编写程序，从 1 开始逐个计算正整数的平方，直到找到平方超过 1000 的第一个整数。经计算，该整数为
32
，因为
31
的平方是
961
，
32
的平方是
1024
。
6、求1到100（不包括100）中所有能被3整除或者能被5整除，但不能同时被3和5整除的整数的和。
需要通过代码或数学方法计算，以下是使用Python代码的实现：
result = 0
for i in range(1, 100):
if (i % 3 == 0 or i % 5 == 0) and not (i % 3 == 0 and i % 5 == 0):
result += i
print(result)
运行上述代码可得到具体的和。
从数学角度，能被3整除的数构成首项 $ a_1 = 3 $，公差 $ d = 3 $ 的等差数列；能被5整除的数构成首项 $ b_1 = 5 $，公差 $ d = 5 $ 的等差数列；能同时被3和5整除（即能被15整除）的数构成首项 $ c_1 = 15 $，公差 $ d = 15 $ 的等差数列。
分别根据等差数列求和公式 $ S_n = frac{n(a_1 + a_n)}{2} $ 计算相应数列的和，再用能被3整除的数的和加上能被5整除的数的和，减去能同时被3和5整除的数的和的两倍，即可得到结果。
7、给定一个字母数组和一个单词作为输入，编写一个程序来判断该单词是否可以由数组中包含的字母组成。数组中的每个字母最多可以使用其在数组中出现的次数（即，如果单词需要三个字母 ‘a’，那么数组中至少应该有三个字母 ‘a’）。使用该程序，证明对于数组 [‘y’,’z’,’b’,’e’,’a’,’u’,’t’] 和单词 ‘beauty’，结果为 true；对于数组 [‘r’,’o’,’u’,’g’,’h’] 和单词 ‘tough’，结果为 false。
以下是实现该功能的Python代码：
def can_build_word(letters, word):
letter_count = {}
# 统计数组中每个字母的出现次数
for letter in letters:
if letter in letter_count:
letter_count[letter] += 1
else:
letter_count[letter] = 1
for char in word:
if char not in letter_count or letter_count[char] == 0:
return False
letter_count[char] -= 1
return True
letters1 = ['y','z','b','e','a','u','t']
word1 = 'beauty'
print(can_build_word(letters1, word1)) # 输出 True
letters2 = ['r','o','u','g','h']
word2 = 'tough'
print(can_build_word(letters2, word2)) # 输出 False
上述代码定义了一个
can_build_word
函数，用于判断单词是否可以由数组中的字母组成。函数首先统计数组中每个字母的出现次数，然后遍历单词中的每个字符，检查是否有足够的字母可用。如果有任何字符无法匹配或字母数量不足，则返回
False
；否则返回
True
。最后，代码分别对给定的两个数组和单词进行测试，并输出结果。
8、假设有两个文本文件记录火车时刻表（采用24小时制）。第一个文件提供某一天火车到达某车站的时间，第二个文件提供火车的出发时间。文件内容如下。arrtime.txt：43UP 8:35，54DN 10:32，32UP 11:52，10DN 13:56，45DN 14:20；deptime.txt：54DN 11:14，45DN 14:28，43UP 8:30，10DN 13:59，35UP 11:52。数据以空格分隔，第一列是火车编号（列车ID），第二列是时间。数据未按列车ID排序。注意，数据可能存在异常情况，比如到达时间可能晚于出发时间，而且某个列车ID可能只在一个文件中出现，而不在另一个文件中。要求通过编程找出每列火车在车站停留的时间（如果可能的话），并标记出数据存在异常的列车。
以下是实现该功能的 Ruby 代码：
def timeinmin(tm)
a = tm.split(':')
a[0].to_i * 60 + a[1].to_i
end
def gethashfromfile(filename)
thefile = File.open(filename, 'r')
h = Hash.new
while (line = thefile.gets)
x = line.chomp.split(/s+/)
h[x[0]] = timeinmin(x[1])
end
thefile.close
h
end
h1 = gethashfromfile('arrtime.txt')
h2 = gethashfromfile('deptime.txt')
k1 = h1.keys
k2 = h2.keys
kcommon = k1 & k2
knotinboth = (k1 - kcommon) | (k2 - kcommon)
arr = kcommon.to_a
for i in 0...arr.size
stay = h2[arr[i]] - h1[arr[i]]
if stay < 0
puts arr[i] + ': data issue'
else
puts arr[i] + ': stay ' + stay.to_s + ' minutes'
end
end
arr2 = knotinboth.to_a
for i in 0...arr2.size
puts arr2[i] + ': data issue'
end
9、给定一个哈希表，其中键是学生的姓名，值是学生在一次考试中的总成绩。假设任何获得超过599分（即600分及以上）的学生被列为一等。编写一个程序，以良好的格式打印每个学生的姓名和成绩，如果他/她达到了一等，在结果中包含‘一等’字样。例如，给定 {“Abani Sen” => 650, “Dora Pridle” => 573}，应该打印如下内容：Abani Sen : 获得分数 650 : 一等；Dora Pridle : 获得分数 573。解决方案中至少使用一个迭代器。
以下是实现该功能的 Ruby 代码：
h = { "Abani Sen" => 650, "Dora Pridle" => 573, "Sana Chowdhury" => 824, "Pritish Panda" => 732 }
h.each do |name, marks|
if marks >= 600
puts "#{name} : 获得分数 #{marks} : 一等"
else
puts "#{name} : 获得分数 #{marks}"
end
end
10、给定如下哈希表：h = { “Abani Sen” => 650, “Dora Pridle” => 573, “Sana Chowdhury” => 824, “Pritish Panda” => 732 } 按分数从高到低打印出姓名和分数。
可以使用以下 Ruby 代码实现：
h = { "Abani Sen" => 650, "Dora Pridle" => 573, "Sana Chowdhury" => 824, "Pritish Panda" => 732 }
sorted_h = h.sort_by { |_, marks| -marks }
sorted_h.each { |name, marks| puts "#{name} : Marks obtained #{marks}" }
上述代码首先使用
sort_by
方法按分数从高到低对哈希表进行排序，然后使用
each
方法遍历排序后的数组并打印出姓名和分数。
11、对于工程或医学专业的入学申请，在计算分数时，会根据考试成绩来确定部分学分。规则如下：分数在500分及以下：入学无学分；501 – 600分：10学分；601 – 700分：20学分；701 – 800分：40学分；801分及以上：70学分。已知有一个哈希表存储了学生及其考试成绩，哈希表内容为 { “Abani Sen” => 650, “Dora Pridle” => 573, “Sana Chowdhury” => 824, “Pritish Panda” => 732 }。编写一个程序，确定并打印每个学生获得的学分。
h = { "Abani Sen" => 650, "Dora Pridle" => 573, "Sana Chowdhury" => 824, "Pritish Panda" => 732 }
h.map {|k,v|
case v
when 0..500
puts "#{k} : no credit"
when 501..600
puts "#{k} : credit : 10"
when 601..700
puts "#{k} : credit : 20"
when 701..800
puts "#{k} : credit : 40"
else
puts "#{k} : credit : 70"
end
}
12、编写一个 Ruby 程序，根据输入的名字和姓氏作为参数，找出一个人的生日。
以下是实现该功能的 Ruby 程序：
if ARGV.length != 2
puts "please provide first_name and last_name"
exit
end
first_name = ARGV[0]
last_name = ARGV[1]
puts "Getting birthday for #{first_name} #{last_name}"
begin
infile = File.open('hrfile.txt', 'r')
found = false
while line = infile.gets
col = line.split(',')
if col[0] == first_name && col[1] == last_name
puts "Date of Birth for #{first_name} #{last_name} is #{col[2]}"
found = true
break
end
end
if !found
puts "The person's birthday was not found."
end
infile.close
rescue Errno::ENOENT
puts "The file was not found in the directory."
end
运行程序时，使用
ruby getnames.rb 名字 姓氏
的格式，例如
ruby getnames.rb John Doe
。程序会先检查是否提供了两个参数，如果没有则输出提示信息并退出。然后打开
hrfile.txt
文件，逐行读取内容，将每行按逗号分割成数组，检查第一列和第二列是否与输入的名字和姓氏匹配，如果匹配则输出该人的出生日期。如果文件未找到，会输出相应的错误信息。如果未找到匹配的名字，也会输出提示信息。
13、一个跟踪列车时刻表的应用程序会将信息打印到日志文件中。日志文件里有这样的行：列车45DN于13:04:22到达斯特拉斯菲尔德车站；列车36UP于12:56:30从雷德芬车站出发。日志中还有其他不符合此格式的行，我们对此不感兴趣。任务是找出符合格式的行，并提取列车编号、车站名称以及到达或出发时间（这些就是要提取的信息）。假设日志文件包含以下行：列车36UP于12:56:30从雷德芬车站出发；12:57:20收到网络请求；响应正常；列车45DN于13:04:22到达斯特拉斯菲尔德车站；13:11:32数据库连接失败。提取相关信息并打印结果。
相关信息如下：
列车编号：36UP
车站名称：雷德芬车站
出发时间：12:56:30
列车编号：45DN
车站名称：斯特拉斯菲尔德车站
到达时间：13:04:22
14、编写代码计算 1 到 10 的平方和
在 Ruby 中可以使用如下代码计算 1 到 10 的平方和：
(1..10).inject(0) { |sum, i| sum + i**2 }
上述代码使用
inject
方法对 1 到 10 的数字进行迭代，将每个数字的平方累加到初始值 0 上，最终得到平方和。
15、编写代码计算 1 到 6 的阶乘
以下是使用 Python 语言编写的计算 1 到 6 阶乘的代码：
for i in range(1, 7):
factorial = 1
for j in range(1, i + 1):
factorial *= j
print(f'{i} 的阶乘是: {factorial}')
此代码通过两层循环，外层循环遍历 1 到 6 的数字，内层循环计算当前数字的阶乘并输出结果。
16、编写代码输出斐波那契数列的前 10 项
以下是用 Ruby 编写的输出斐波那契数列前 10 项的代码：
n = 10
fibonacci = [0, 1]
while fibonacci.length < n
next_num = fibonacci[-1] + fibonacci[-2]
fibonacci << next_num
end
puts fibonacci
上述代码首先定义了要输出的项数
n
为 10，然后初始化斐波那契数列的前两项为 0 和 1。接着使用
while
循环，只要数列的长度小于
n
，就计算下一项（即前两项之和）并添加到数列中。最后使用
puts
输出整个斐波那契数列。
17、编写代码找出文件 ‘lnsize.txt’ 中最长的行并输出该行和其长度
以下是使用Python实现的代码：
longest_line = ''
max_length = 0
with open('lnsize.txt', 'r', encoding='utf-8') as file:
for line in file:
line = line.strip()
if len(line) > max_length:
max_length = len(line)
longest_line = line
print(f'最长的行是: {longest_line}')
print(f'其长度是: {max_length}')
上述代码会读取文件
lnsize.txt
，逐行比较每行的长度，找出最长的行及其长度并输出。
18、编写代码判断文件 ‘palin.txt’ 中的每一行是否为回文，并输出判断结果
以下是实现该功能的代码：
infile = File.open('palin.txt', 'r')
while (line = infile.gets)
x = line.chomp.downcase.gsub(' ', '')
y = x.reverse
if (x == y)
puts 'A palindrome : ' + line.chomp
else
puts 'Not a palindrome : ' + line.chomp
end
end
infile.close
19、编写递归函数计算斐波那契数列的第 8 项并输出结果
以下是使用 Python 编写的递归函数来计算斐波那契数列的第 8 项并输出结果的代码：
# 定义递归函数计算斐波那契数列
# 斐波那契数列定义为：F(0) = 0，F(1) = 1, F(n) = F(n - 1) + F(n - 2)（n ≥ 2，n ∈ N*）
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n - 1) + fibonacci(n - 2)
# 调用函数计算第 8 项
result = fibonacci(8)
# 输出结果
print(result)
代码解释：
定义了一个名为
fibonacci
的递归函数，它接受一个整数参数
n
。
在函数内部，如果
n
小于等于 1，则直接返回
n
。
否则，返回
fibonacci(n - 1) + fibonacci(n - 2)
，即前两项的和。
调用
fibonacci(8)
计算斐波那契数列的第 8 项，并将结果存储在
result
变量中。
最后，使用
print
函数输出结果。
20、编写代码找出满足 i * i > 1000 的最小整数 i，并输出 i – 1 的值
以下是使用 Python 语言实现的代码：
i = 1
while i * i <= 1000:
i = i + 1
print(i - 1)
上述代码通过一个
while
循环，从
i = 1
开始逐步增加
i
的值，直到
i * i > 1000
时停止循环，此时
i
即为满足条件的最小整数，最后输出
i - 1
的值。
21、编写代码计算 1 到 99 中，不能被 15 整除但能被 3 或 5 整除的数的和
以下是使用 Python 语言实现该功能的代码：
result = 0
for i in range(1, 100):
if (i % 3 == 0 or i % 5 == 0) and i % 15 != 0:
result += i
print(result)
上述代码通过遍历 1 到 99 的所有整数，判断每个数是否满足不能被 15 整除但能被 3 或 5 整除的条件，如果满足则累加到结果变量中，最后输出结果。
22、编写函数判断给定数组中的字符能否组成指定的单词，并对 [‘y’,’z’,’b’,’e’,’a’,’u’,’t’] 和 ‘beauty’、[‘r’,’o’,’u’,’g’,’h’] 和 ‘tough’ 进行测试
以下是使用 Python 实现的函数：
def can_form_word(char_list, word):
char_dict = {char: char_list.count(char) for char in set(char_list)}
for char in word:
if char not in char_dict or char_dict[char] == 0:
return False
char_dict[char] -= 1
return True
# 测试
print(can_form_word(['y','z','b','e','a','u','t'], 'beauty')) # 输出 False
print(can_form_word(['r','o','u','g','h'], 'tough')) # 输出 False
该函数首先统计数组中每个字符的出现次数，然后遍历单词中的每个字符，检查字符是否在数组中且还有剩余数量。如果满足条件，则减少该字符的计数；否则返回
False
。如果遍历完单词都满足条件，则返回
True
。
23、编写代码从文件 ‘arrtime.txt’ 和 ‘deptime.txt’ 中读取数据，计算每个共同元素的停留时间，并输出结果，对于不在两个文件中的元素输出 ‘data issue’。假设文件中每行格式为 ‘元素,时间’，时间为浮点数。
以下是一个Python示例代码来实现该功能：
# 读取文件内容
with open('arrtime.txt', 'r') as f1:
arr_lines = f1.readlines()
with open('deptime.txt', 'r') as f2:
dep_lines = f2.readlines()
# 假设文件每行格式为 '元素,时间'，解析数据
arr_dict = {line.split(',')[0]: float(line.split(',')[1].strip()) for line in arr_lines}
dep_dict = {line.split(',')[0]: float(line.split(',')[1].strip()) for line in dep_lines}
# 处理每个元素
for element in set(arr_dict.keys()).union(set(dep_dict.keys())):
if element in arr_dict and element in dep_dict:
stay_time = dep_dict[element] - arr_dict[element]
print(f'{element}: {stay_time}')
else:
print(f'{element}: data issue')
这段代码首先读取两个文件的内容，然后解析每行数据，将元素和对应的时间存储在字典中。接着遍历所有元素，对于同时存在于两个文件中的元素，计算停留时间并输出；对于只存在于一个文件中的元素，输出
'data issue'
。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
相关文章
暂无评论...
