Greasy Fork is available in English.
HX专供
当前为
// ==UserScript==
// @name 自动选择，选择题和判断答案
// @namespace http://tampermonkey.net/
// @version 0.9
// @description HX专供
// @author 慕阳
// @match *://*/*
// @grant none
// ==/UserScript==
(function() {
'use strict';
const Jianda = {
'40. 友元函数的作用，声明、定义和调用注意事项': "友元函数不是类的成员函数，可以访问类的私有数据成员; 友元函数声明在类中，定义在类外且不需要加类名，调用按照普通函数进行即可不需要对象名。",
'41. 什么是对象？什么是面向对象方法？这种方法有哪些特点？': "1. 对象是现实世界中一个实际存在的事物，是构成世界的一个独立单位，它具有自己的静态特征和动态特征。\n" +
"2. 面向对象的方法将数据及对数据的操作方法放在一起，作为一个相互依存、不可分离的整体——对象。对同类型对象抽象出其共性，形成类。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通讯。通过实现继承与多态性，可以大大提高程序的可重用性，使得软件的开发和维护更为方便。\n" +
"3. 面向对象方法的基本原则是直接面对客观存在的事物进行软件开发，将人们在日常生活中习惯的思维方式和表达方式应用于软件开发，使软件开发回归到客观世界。",
'42. 声明一个时钟类，并定义时、分、秒三个数据成员及相应的成员函数': `#include <iostream>
using namespace std;
class Clock {
public:
void SetTime(int NewH, int NewM, int NewS);
void ShowTime();
private:
int Hour, Minute, Second;
};
void Clock::SetTime(int NewH, int NewM, int NewS) {
Hour = NewH;
Minute = NewM;
Second = NewS;
}
void Clock::ShowTime() {
cout << Hour << ":" << Minute << ":" << Second;
}
int main() {
Clock c;
c.SetTime(8, 30, 30);
c.ShowTime();
return 0;
}`,
'43. 定义Shape类及其派生类Rectangle和Circle，并派生Square类': `#include <iostream>
using namespace std;
#define PI 3.14
class Shape {
public:
virtual float GetArea() { return -1; }
};
class Circle : public Shape {
public:
Circle(float radius) : itsRadius(radius) {}
float GetArea() { return PI * itsRadius * itsRadius; }
private:
float itsRadius;
};
class Rectangle : public Shape {
public:
Rectangle(float len, float width) : itsLength(len), itsWidth(width) {}
float GetArea() { return itsLength * itsWidth; }
private:
float itsWidth;
float itsLength;
};
int main() {
Circle c(5.0);
cout << "The area of the Circle is " << c.GetArea() << endl;
Rectangle r(4, 6);
cout << "The area of the Rectangle is " << r.GetArea() << endl;
return 0;
}`,
'44. 声明一个点类，具有横纵坐标，并实现相应函数': `#include<iostream>
using namespace std;
class Point {
public:
void SET(int xx = 0, int yy = 0) {
X = xx;
Y = yy;
}
int GetX() { return X; }
int GetY() { return Y; }
private:
int X, Y;
};
int main() {
Point myp1;
myp1.SET(1, 2);
cout << myp1.GetX() << endl;
cout << myp1.GetY() << endl;
return 0;
}`,
'45. 定义Mammal类和Dog类，设置体重和年龄并输出': `#include<iostream>
using namespace std;
class Mammal {
public:
int GetAge() const { return itsAge; }
void SetAge(int age) { itsAge = age; }
protected:
int itsAge;
};
class Dog : public Mammal {
public:
int GetWeight() const { return itsWeight; }
void SetWeight(int weight) { itsWeight = weight; }
private:
int itsWeight;
};
int main() {
Dog Jack;
Jack.SetWeight(5);
Jack.SetAge(10);
cout << "Jack is " << Jack.GetAge() << " years old.\n";
cout << "Jack is " << Jack.GetWeight() << " kg.\n";
return 0;}`
};
const Tiankong = {
'继承的三种方式public、protected和private，默认的继承方式是': 'private',
'程序运行结果': [
"X::X() constructor executing",
"Y::Y() constructor executing",
"Z::Z() constructor executing",
"Z::~Z() destructor executing",
"Y::~Y() destructor executing",
"X::~X() destructor executing"
],
'程序运行结果': [
"--- MAIN函数---",
"i: 0 a: 0 b: -2 c: 1",
"--- f函数---",
"i: 10 a: 4 b: 0 c: 26"
],
'单一继承的派生类中含有对象成员，析构函数调用顺序': [
'派生类',
'对象成员所属类',
'基类'
],
'C++语言特有的引用是': '别名',
'动态联编通过': ['继承', '虚函数'],
'默认形参值声明顺序': [
'右', '左', '右', '左', '右'
],
'填空程序的正确语句': [
'X=n;',
'return X;',
'test.init(10);'
],
'程序运行结果': [
'd.A::n=10,d.B::n=10,d.C::n=10,d.D::n=10',
'd.A::n=20,d.B::n=20,d.C::n=20,d.D::n=20',
'd.A::n=30,d.B::n=30,d.C::n=30,d.D::n=30',
'd.A::n=40,d.B::n=40,d.C::n=40,d.D::n=40'
]
};
// 题目和答案的映射（这里的答案是选项的文本，如 "连接符" 对应 "A"）
const questionKeywordsToAnswers = {
'封装是面向对象方法的一个重要原则，就是把对象的属性和服务结合成一个独立的系统单位，并不隐蔽对象的内部细节': '错',
'在程序运行过程中，其值始终不可改变的量称为变量': '对',
'全局变量，就是具有文件作用域的变量': '对',
'在C++中，将数据从一个对象到另一个对象的流动抽象为“流”': '对',
'函数可以作为表达式调用，但不可以作为语句调用': '错',
'不可以自定义命名空间': '错',
'可以自定义一个运算符进行重载': '错',
'某函数与基类的虚函数有相同参数个数及对应的相同参数类型，则该函数就是虚函数': '对',
'多态是面向对象程序设计的一种特性，可以使程序简洁。': '对',
'使用类模板可以使类中的某些函数成员的参数、返回值或局部变量能取任意类型': '对',
'友元函数的作用，友元函数声明、定义和调用应该注意什么？': '友元函数不是类的成员函数，可以访问类的私有数据成员。友元函数声明在类中，定义在类外且不需要加类名，调用按照普通函数进行即可不需要对象名。',
'下列关于对象的描述中，错误的是': 'C',
'下列带缺省值参数的函数说明中，正确的说明是': 'A',
'执行这个程序段输出字符 * 的个数是': 'B',
'以下关于类的访问属性不正确的是': 'D',
'类的静态成员初始化的位置': 'B',
'有以下 4 条语句: static int hot = 200; int &rad = hot; hot = hot + 100; cout << rad << endl; 执行后输出为': 'D',
'在多继承时，基类与基类之间出现同名成员时，通过派生类对象访问时出现的二义性可以通过': 'B',
'下列符号不能组成标识符的是': '连接符',
'复制构造函数的作用是': 'A',
'以下不是虚函数正确的描述': 'B',
'以下关于抽象类描述正确的是': 'B',
'下列正确的类定义或原型声明是': 'B',
'已知类A中的一个成员函数的说明如下： void Set(A &a); 则该函数的参数“A &a”的含义是': 'C',
'下面对结构或类中成员的访问中,不正确的访问是': 'A',
'下面有关基类与公有派生类的赋值兼容原则，正确的是': 'D',
'下列关于运算符重载的描述中，正确的是': 'D',
'静态多态性可以使用获得': 'B',
'假设定义如下函数模板。template <class T> T max(T x,T y) { return (x>y)?x:y; } 并有定义“int i;char c; ”,则错误的调用语句是': 'D',
'类模板的模板参数': 'D',
'当用ifstream流类对象打开文件时，其默认打开方式是': 'B'
};
// 查找并自动选择答案的函数
function findAndSelectAnswers() {
// 获取所有题目元素（更新后的选择器）
const questionElements = document.querySelectorAll('.testpaper-question.testpaper-question-choice.js-testpaper-question');
questionElements.forEach((element, index) => {
// 获取题目文本并去除空白字符
const questionText = element.querySelector('.testpaper-question-stem.js-testpaper-question-stem').textContent.trim();
// 清理题目文本，移除特殊字符，如括号
const cleanedQuestionText = questionText.replace(/[\(\)（）。]/g, '').trim();
console.log(`题号 ${index + 1}: ${cleanedQuestionText}`); // 调试输出，确保能准确获取题目文本
const answer = questionKeywordsToAnswers[cleanedQuestionText]; // 查找对应答案
if (answer) {
console.log(`答案: ${answer}`);
// 获取题目中的选项列表（它们包含在 <li> 标签中）
const options = element.querySelectorAll('.testpaper-question-body-item.testpaper-question-choice-item');
console.log(`共找到 ${options.length} 个选项`); // 输出找到的选项数量
let selectedOption = null;
// 遍历选项，找出匹配的选项
options.forEach(option => {
const optionText = option.textContent.trim().replace(/[\(\)（）。]/g, ''); // 清理选项文本
console.log(`选项文本: ${optionText}`); // 输出选项文本，帮助调试
// 判断选项文本是否包含在题目答案中
if (optionText.includes(answer)) {
selectedOption = option;
console.log(`匹配选项: ${optionText}`);
}
});
// 如果找到了匹配的选项，选中它
if (selectedOption) {
const optionText = selectedOption.querySelector('.testpaper-question-body-item__index').textContent.trim();
console.log(`匹配的选项: ${optionText}`); // 输出匹配的选项
const footerElement = element.querySelector('.testpaper-question-footer.clearfix'); // 获取选项区域
const labels = footerElement.querySelectorAll('label.radio-inline'); // 获取所有label元素
// 遍历label元素，找到与匹配选项相对应的label
labels.forEach(label => {
const labelText = label.textContent.trim(); // 获取label文本
console.log(`labelText: "${labelText}"`);
console.log(`optionText: "${optionText}"`);
// 清理并统一文本：去除空格和句号，统一小写
const cleanedOptionText = optionText.replace(/[\s.]+/g, '').toLowerCase();
const cleanedLabelText = labelText.replace(/[\s.]+/g, '').toLowerCase();
console.log(`cleanedOptionText: "${cleanedOptionText}"`);
console.log(`cleanedLabelText: "${cleanedLabelText}"`);
// 比较清理后的文本
if (cleanedOptionText === cleanedLabelText) {
const input = label.querySelector('input'); // 获取对应的input元素
console.log(`input: ${input}`);
if (input) {
input.checked = true; // 选中input元素
console.log(`已选中：${optionText}`);
} else {
console.log(`未找到对应的input元素`);
}
}
});
} else {
console.log(`没有找到匹配的选项`);
}
} else {
console.log(`题号 ${index + 1}: ${questionText} - 未找到答案`);
}
});
// 获取所有判断题元素
const judgmentQuestionElements = document.querySelectorAll('.testpaper-question.testpaper-question-determine.js-testpaper-question');
judgmentQuestionElements.forEach((element, index) => {
// 提取判断题文本并清理
const judgmentQuestionText = element.querySelector('.testpaper-question-stem.js-testpaper-question-stem').textContent.trim();
const cleanedJudgmentQuestionText = judgmentQuestionText.replace(/[\(\)（）。]/g, '').trim();
console.log(`判断题号 ${index + 1}:${cleanedJudgmentQuestionText}`); // 调试输出
const answer = questionKeywordsToAnswers[cleanedJudgmentQuestionText]; // 查找对应答案
if (answer) {
console.log(`答案: ${answer}`);
// 获取判断题中的选项列表
const options = element.querySelectorAll('.testpaper-question-footer.clearfix label.radio-inline');
console.log(`共找到 ${options.length} 个选项`); // 输出找到的选项数量
// 遍历选项，找出匹配的选项
let optionFound = false;
options.forEach(option => {
const labelText = option.textContent.trim().replace(/[\(\)（）。]/g, ''); // 清理选项文本
console.log(`选项文本: ${labelText}`); // 输出选项文本，帮助调试
// 判断选项文本是否与答案匹配
if (labelText.includes(answer)) {
const input = option.querySelector('input'); // 获取对应的input元素
if (input) {
input.checked = true; // 选中input元素
console.log(`已选中：${answer}`);
optionFound = true;
} else {
console.log(`未找到对应的input元素`);
}
}
});
if (!optionFound) {
console.log(`没有找到匹配的选项`);
}
} else {
console.log(`判断题号 ${index + 1}:${judgmentQuestionText} - 未找到答案`);
}
});
}
// 设置计时器间隔时间（毫秒）
const interval = 10000; // 每10秒检查一次
// 启动计时器
setInterval(findAndSelectAnswers, interval);
// 当DOM内容加载完毕后，立即运行一次查找
document.addEventListener('DOMContentLoaded', findAndSelectAnswers);
})();