#C++ Day45 Basic Data Structure Chapter3 review-2 January 2 2026

4.猜数字

LCP 01. 猜数字

已解答

简单

小A 和小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回小A 猜对了几次？

输入的guess数组为小A 每次的猜测，answer数组为小B 每次的选择。guess和answer的长度都等于3。

示例 1：

输入：guess = [1,2,3], answer = [1,2,3]

输出：3

解释：小A 每次都猜对了。

示例 2：

输入：guess = [2,2,3], answer = [3,2,1]

输出：1

解释：小A 只猜对了第二次。

限制：

guess的长度 = 3
answer的长度 = 3
guess的元素取值为 {1, 2, 3} 之一。
answer的元素取值为 {1, 2, 3} 之一。

myanswer:

class Solution {

public:

int game(vector<int>& guess, vector<int>& answer) {

int count=0;

for(int i=0;i<3;i++){

if(guess[i] == answer[i]){

count++;

}

return count;

}

};

5.拿硬币

LCP 06. 拿硬币

已解答

简单

相关标签

桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

示例 1：

输入：[4,2,1]

输出：4

解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。

示例 2：

输入：[2,3,10]

输出：8

限制：

1 <= n <= 4
1 <= coins[i] <= 10

class Solution {

public:

int minCount(vector<int>& coins) {

int ret = 0;

for(int i=0;i<coins.size();i++){

ret += (coins[i] + 1) /2;

//如果偶数这个+1 无效奇数把最后一次当1

}

return ret;

}

};

2.数值统计

数值统计 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 224358 Accepted Submission(s): 104159

Problem Description 统计给定的n个数中，负数、零和正数的个数。
Input 输入数据有多组，每组占一行，每行的第一个数是整数n（n<100），表示需要统计的数值的个数，然后是n个实数；如果n=0，则表示输入结束，该行不做处理。
Output 对于每组输入数据，输出一行a,b和c，分别表示给定的数据中负数、零和正数的个数。
Sample Input 6 0 1 2 3 -1 0 5 1 2 3 4 0.5 0
Sample Output 1 2 3 0 0 5
Author lcy
Source C语言程序设计练习（二）

//Sequential List – value statistics

#include <iostream>

using namespace std;

#define eleType double

//1.define a structure

struct SequentialList {

eleType* elements;

int capacity;

int size;

};

//2.initialize

void initializeList(SequentialList* list, int capacity) {

list->elements = new eleType[capacity];

list->capacity = capacity;

list->size = 0;

}

//3.destroy

void destroyList(SequentialList* list) {

delete[] list->elements;

list->elements = nullptr;

list->size = 0;

list->capacity = 0;

}

//4.size and is it empty

int sizeOfList(SequentialList* list) {

return list->size;

}

bool isEmpty(SequentialList* list) {

return list->size == 0;

}

//5.insert

void insertElement(SequentialList* list, int index, eleType element) {

if (index<0 || index>list->size) {

throw std::invalid_argument(“invalid index”);

}

if (list->capacity == list->size) {

int newcapacity = (list->capacity == 0) ? 4 : list->capacity * 2;

eleType* newlist = new eleType[newcapacity];

for (int i = 0; i < list->size; i++) {

newlist[i] = list->elements[i];

}

delete[] list->elements;

list->elements = newlist;

list->capacity = newcapacity;

}

for (int i = list->size; i > index; i–) {

list->elements[i] = list->elements[i – 1];

}

list->elements[index] = element;

list->size++;

}

//6.delete

void deleteElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

for (int i = index; i < list->size – 1; i++) {

list->elements[i] = list->elements[i + 1];

}

list->size–;

}

//7.findindex

int findIndex(SequentialList* list, eleType element) {

for (int i = 0; i < list->size; i++) {

if (list->elements[i] == element) {

return i;

}

return -1;

}

//8.get

eleType getElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

return list->elements[index];

}

//9.update

void updateElement(SequentialList* list, int index, eleType element) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

list->elements[index] = element;

}

int main() {

SequentialList mylist;

int n;

while (cin >> n && n!=0 ) {

initializeList(&mylist, n);

for (int i = 0; i < n; i++) {

double val;

cin >> val;

insertElement(&mylist, i, val);

}

double a=0, b=0, c=0;

for (int i = 0; i < n; i++) {

if (getElement(&mylist, i) > 0) {

c++;

}

else if(getElement(&mylist, i) < 0){

a++;

}

else {

b++;

}

cout << a <<‘ ‘ << b << ‘ ‘ << c <<endl ;

destroyList(&mylist);

}

return 0;

}

//Sequential List – value statistics

#include <iostream>

using namespace std;

#define eleType double

//1.define a structure

struct SequentialList {

eleType* elements;

int capacity;

int size;

};

//2.initialize

void initializeList(SequentialList* list, int capacity) {

list->elements = new eleType[capacity];

list->capacity = capacity;

list->size = 0;

}

//3.destroy

void destroyList(SequentialList* list) {

delete[] list->elements;

list->elements = nullptr;

list->size = 0;

list->capacity = 0;

}

//4.size and is it empty

int sizeOfList(SequentialList* list) {

return list->size;

}

bool isEmpty(SequentialList* list) {

return list->size == 0;

}

//5.insert

void insertElement(SequentialList* list, int index, eleType element) {

if (index<0 || index>list->size) {

throw std::invalid_argument(“invalid index”);

}

if (list->capacity == list->size) {

int newcapacity = (list->capacity == 0) ? 4 : list->capacity * 2;

eleType* newlist = new eleType[newcapacity];

for (int i = 0; i < list->size; i++) {

newlist[i] = list->elements[i];

}

delete[] list->elements;

list->elements = newlist;

list->capacity = newcapacity;

}

for (int i = list->size; i > index; i–) {

list->elements[i] = list->elements[i – 1];

}

list->elements[index] = element;

list->size++;

}

//6.delete

void deleteElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

for (int i = index; i < list->size – 1; i++) {

list->elements[i] = list->elements[i + 1];

}

list->size–;

}

//7.findindex

int findIndex(SequentialList* list, eleType element) {

for (int i = 0; i < list->size; i++) {

if (list->elements[i] == element) {

return i;

}

return -1;

}

//8.get

eleType getElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

return list->elements[index];

}

//9.update

void updateElement(SequentialList* list, int index, eleType element) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

list->elements[index] = element;

}

int main() {

SequentialList mylist;

int n;

while (cin >> n && n!=0 ) {

initializeList(&mylist, n);

double neg = 0, zero = 0, pos = 0;

for (int i = 0; i < n; i++) {

double val;

cin >> val;

if (val > 0) {

pos++;

}

else if (val < 0) {

neg++;

}

else {

zero++;

}

cout << neg <<‘ ‘ << zero << ‘ ‘ << pos <<endl ;

destroyList(&mylist);

}

/*return 0;

Run ID Submit Time Judge Status Pro.ID Exe.Time Exe.Memory Code Len.Language Author

40643282 2026 – 01 – 02 07:37 : 49 Accepted 2008 15MS 1812K 2546 B C++ supervito

40643281 2026 – 01 – 02 07 : 37 : 19 Accepted 2008 15MS 1812K 2549 B C++ supervito

40643280 2026 – 01 – 02 07 : 17 : 40 Accepted 2008 0MS 1812K 2626 B C++ supervito*/

}

4.青年歌手大奖赛_评委会打分

青年歌手大奖赛_评委会打分 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 184150 Accepted Submission(s): 90169

Problem Description 青年歌手大奖赛中，评委会给参赛选手打分。选手得分规则为去掉一个最高分和一个最低分，然后计算平均得分，请编程输出某选手的得分。
Input 输入数据有多组，每组占一行，每行的第一个数是n(2<n<=100)，表示评委的人数，然后是n个评委的打分。
Output 对于每组输入数据，输出选手的得分，结果保留2位小数，每组输出占一行。
Sample Input 3 99 98 97 4 100 99 98 97
Sample Output 98.00 98.50
Author lcy
Source C语言程序设计练习（三）

#include <iostream>

using namespace std;

#define eleType double

//1.define a structure

struct SequentialList {

eleType* elements;

int capacity;

int size;

};

//2.initialize

void initializeList(SequentialList* list, int capacity) {

list->elements = new eleType[capacity];

list->capacity = capacity;

list->size = 0;

}

//3.destroy

void destroyList(SequentialList* list) {

delete[] list->elements;

list->elements = nullptr;

list->size = 0;

list->capacity = 0;

}

//4.size and is it empty

int sizeOfList(SequentialList* list) {

return list->size;

}

bool isEmpty(SequentialList* list) {

return list->size == 0;

}

//5.insert

void insertElement(SequentialList* list, int index, eleType element) {

if (index<0 || index>list->size) {

throw std::invalid_argument(“invalid index”);

}

if (list->capacity == list->size) {

int newcapacity = (list->capacity == 0) ? 4 : list->capacity * 2;

eleType* newlist = new eleType[newcapacity];

for (int i = 0; i < list->size; i++) {

newlist[i] = list->elements[i];

}

delete[] list->elements;

list->elements = newlist;

list->capacity = newcapacity;

}

for (int i = list->size; i > index; i–) {

list->elements[i] = list->elements[i – 1];

}

list->elements[index] = element;

list->size++;

}

//6.delete

void deleteElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

for (int i = index; i < list->size – 1; i++) {

list->elements[i] = list->elements[i + 1];

}

list->size–;

}

//7.findindex

int findIndex(SequentialList* list, eleType element) {

for (int i = 0; i < list->size; i++) {

if (list->elements[i] == element) {

return i;

}

return -1;

}

//8.get

eleType getElement(SequentialList* list, int index) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

return list->elements[index];

}

//9.update

void updateElement(SequentialList* list, int index, eleType element) {

if (index < 0 || index >= list->size) {

throw std::invalid_argument(“invalid index”);

}

list->elements[index] = element;

}

int main() {

int n;

while (cin >> n && n>2 && n<=100) {

SequentialList mylist;

initializeList(&mylist, n);

for (int i = 0; i < n; i++) {

eleType ele;

cin >> ele;

insertElement(&mylist, i, ele);

}

//eleType Emax = -10000000000, Emin = 10000000000,Esum=0; //可能会有一个非常大的数字

eleType Emax = getElement(&mylist, 0);//假设第一个最大和最小

eleType Emin = getElement(&mylist, 0);

eleType Esum = 0;

for (int i = 0; i < n; i++) {

eleType ele = getElement(&mylist,i);

if (Emax < ele) Emax = ele;

if (Emin > ele) Emin = ele;

Esum += ele;

}

Esum -= Emax;

Esum -= Emin;

Esum /= (n – 2);

printf(“%.2lf\n”,Esum);

destroyList(&mylist);

}

6.值相等的最小索引

给你一个下标从 0 开始的整数数组 nums ，返回 nums 中满足i mod 10 == nums[i]的最小下标 i ；如果不存在这样的下标，返回-1。

x mod y 表示 x 除以 y 的余数。

示例 1：

输入：nums = [0,1,2]

输出：0

解释：

i=0: 0 mod 10 = 0 == nums[0].

i=1: 1 mod 10 = 1 == nums[1].

i=2: 2 mod 10 = 2 == nums[2].

所有下标都满足 i mod 10 == nums[i] ，所以返回最小下标 0

示例 2：

输入：nums = [4,3,2,1]

输出：2

解释：

i=0: 0 mod 10 = 0 != nums[0].

i=1: 1 mod 10 = 1 != nums[1].

i=2: 2 mod 10 = 2 == nums[2].

i=3: 3 mod 10 = 3 != nums[3].

2 唯一一个满足 i mod 10 == nums[i] 的下标

示例 3：

输入：nums = [1,2,3,4,5,6,7,8,9,0]

输出：-1

解释：不存在满足 i mod 10 == nums[i] 的下标

示例 4：

输入：nums = [2,1,3,5,2]

输出：1

解释：1 是唯一一个满足 i mod 10 == nums[i] 的下标

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 9

class Solution {

public:

int smallestEqual(vector<int>& nums) {

for(int i=0;i<nums.size();i++){

if(i % 10 == nums[i]){

return i;

}

return -1;

}

};

7.最大连续1的个数

485. 最大连续 1 的个数

已解答

简单

#C++ Day45 Basic Data Structure Chapter3 review-2 January 2 2026

更多文章

Tomcat 吉祥物：一只橙色猫咪背后的设计哲学与技术隐喻

Java Day 2-3 复习笔记 (26.2.2)

AI Day2~3-2 10分钟生成1000条爆款笔记！手把手教你搭建“抖音转小红书”AI智能体

Day 2 Coze 智能体开发日记：搞懂批处理 item 逻辑与飞书数据回写

JAVA Day2～3 26.2.1