LeetCode刷题计划---day3

已于 2024-02-19 15:56:22 修改
阅读量942 收藏 6
点赞数 25
文章标签： leetcode 算法 职场和发展
于 2024-02-17 21:33:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70420861/article/details/136131856
版权

卡码网 练习ACM模式 https://kamacoder.com/

11

在这里插入图片描述

可用静态链表存储树，最后求某个结点到共同树根的长度。

#include <iostream>
#include <vector>
using namespace std;



int main()
{
    int n;
    int a,b;
    vector<int> nums = vector<int>(30,0);
    
    while(cin>>n)
    {
        while(n--){
 
            cin>>a>>b;
            nums[a]=b;
        }
            int len_ming = 0;
            int len_yu =0;
            int ming = nums[1];
            int yu = nums[2];
            while(ming !=0){
                ming = nums[ming];
                len_ming++;
            }
            while(yu!=0){
                yu = nums[yu];
                len_yu++;
            }
                
        
        if(len_ming>len_yu)
            cout<<"You are my elder"<<endl;
        else if(len_ming==len_yu)
            cout<<"You are my brother"<<endl;
        else if(len_yu>len_ming)
            cout<<"You are my younger"<<endl;
        }

    
    return 0;
}

while True:
    try:
        n = int(input())
        relations = {}
        for _ in range(n):
            a, b = map(int, input().split())
            relations[a] = b

        len_ming = 0
        len_yu = 0
        ming = relations.get(1, 0)
        yu = relations.get(2, 0)

        while ming != 0 and ming in relations:
            ming = relations[ming]
            len_ming += 1
        while yu != 0 and yu in relations:
            yu = relations[yu]
            len_yu += 1

        if len_ming > len_yu:
            print("You are my elder")
        elif len_ming == len_yu:
            print("You are my brother")
        else:
            print("You are my younger")

    except EOFError:
        break

在访问 relations[ming] 之前，先判断一下 ming 是否在 relations 字典的键中。如果 ming 不在字典中，则说明已经找到了最后一个人，应该跳出循环。

12

在这里插入图片描述

#include <iostream>

int main() {
    int n;
    while (std::cin >> n) {
        // 输出上半部分
        for (int i = 1; i <= n; i++) {
            // 输出前面的空格
            for (int j = 1; j <= n - i; j++) {
                std::cout << " ";
            }
            // 输出左半部分的数字
            for (int j = 1; j <= i; j++) {
                std::cout << j;
            }
            // 输出右半部分的数字
            for (int j = i - 1; j >= 1; j--) {
                std::cout << j;
            }
            // 输出后面的空格和换行符
            std::cout << std::endl;
        }

        // 输出下半部分
        for (int i = n - 1; i >= 1; i--) {
            // 输出前面的空格
            for (int j = 1; j <= n - i; j++) {
                std::cout << " ";
            }
            // 输出左半部分的数字
            for (int j = 1; j <= i; j++) {
                std::cout << j;
            }
            // 输出右半部分的数字
            for (int j = i - 1; j >= 1; j--) {
                std::cout << j;
            }
            // 输出后面的空格和换行符
            std::cout << std::endl;
        }
    }
    return 0;
}



while True:
    try:
        n = int(input().strip())
        # 输出上半部分
        for i in range(1, n+1):
            # 输出前面的空格
            print(" " * (n-i), end="")
            # 输出左半部分的数字
            for j in range(1, i+1):
                print(j, end="")
            # 输出右半部分的数字
            for j in range(i-1, 0, -1):
                print(j, end="")
            # 输出后面的空格和换行符
            print()
        # 输出下半部分
        for i in range(n-1, 0, -1):
            # 输出前面的空格
            print(" " * (n-i), end="")
            # 输出左半部分的数字
            for j in range(1, i+1):
                print(j, end="")
            # 输出右半部分的数字
            for j in range(i-1, 0, -1):
                print(j, end="")
            # 输出后面的空格和换行符
            print()
    except:
        break

13

在这里插入图片描述

#include <iostream>
using namespace std;

int main() {
    char c;
    int n;
    while (cin >> c >> n) {
        if (c == '@') break;

        for (int i = 1; i <= n; i++) {
            if (i == n) {
                for (int j = 0; j < 2 * n - 1; j++) {
                    cout << c;
                }
            } else {
                for (int j = 0; j < 2 * n - 1; j++) {
                    if (j == n - i || j == n + i - 2) cout << c;
                    else cout << " ";
                }
            }

            cout << endl;
        }
        cout<<endl;
    }
   
    return 0;
}


while True:
    
    try:
        s = list(input().split())
        a = s[0]
        n = int(s[1])
     
        if a == '@':
           break
        else:
            for i in range(1,n+1):
                
                if i ==n:
                    print(a*(2*n-1))
                else:
                    for j in range(2*n-1):
                        if (j==n+i-2) or (j==n-i) :
                            print(a,end="")
                           
                        else:
                            print(' ',end="")
                    print()
                            
        print()
        
    except:
        break

Python中的print函数可以通过指定end参数来设置输出结尾字符，默认为换行符“\n”。在输出空格时，应该输出一个空格字符，而不是一个空字符串。

14

在这里插入图片描述

读取 n 后使用 cin.ignore() 来清除缓冲区中的换行符，然后再使用 getline(cin, s) 读取字符串。
cin.ignore(); // 清除换行符

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    cin.ignore(); // 清除换行符

    while (n) {
        string s;
        getline(cin, s);

        string abbreviation;
        istringstream iss(s);
        string word;

        while (iss >> word) {
            abbreviation += toupper(word[0]);
        }

        cout << abbreviation << endl;
        n--;
    }

    return 0;
}

使用了一个 istringstream 类型的对象 iss，它可以将字符串按照空格分割成一个个单词。iss >> word 的含义就是从输入流中提取下一个单词，并将其存储到字符串变量 word 中。
在 C++ 中，对于字符串的拼接操作，使用 + 和 += 运算符的区别在于：
使用 + 运算符：

当你使用 s1 = s1 + toupper(word[0]); 这样的表达式时，实际上是创建了一个新的临时字符串，其中包含了将 s1 和 toupper(word[0]) 拼接后的结果，然后将这个新的字符串赋值给 s1。这意味着原始的 s1 字符串会被销毁，而新的字符串会分配内存来存储拼接后的结果。
使用 += 运算符：

当你使用 s1 += toupper(word[0]); 这样的表达式时，它会直接将 toupper(word[0]) 添加到 s1 的末尾，而不会创建新的临时字符串。这种方式更高效，因为它避免了不必要的内存分配和复制操作。

while True:
    try:
        n = int(input())
        for i in range(n):
            s = input().split()
            s1 = ''
            for j in range(len(s)):
               
                s1 = s1+s[j][0]
                
            s_upper = s1.upper()
            print(s_upper)
        
    except:
        break

使用了字符串相加 + 的方式，这会将新的字符添加到已有字符串的末尾,注意前后关系
s.upper() 返回一个新的字符串，其中所有的小写字母都被转换为大写字母s.lower() 返回一个新的字符串，其中所有的大写字母都被转换为小写字母。

15

在这里插入图片描述

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
    int n;
    while(cin>>n){
        cin.ignore(); // 忽略换行符
        while(n--){
            string s1;
            string s2;
            getline(cin,s1);
            int len;
            len = s1.length();
            if(len %2!=0)
            {
                break;
            }
            else
            {
                getline(cin,s2);
               
                s1.insert(s1.size()/2,s2);
                cout<<s1<<endl;
            }
            

        }
        
        
    }
    

    
    return 0;
}

使用了 getline(cin, s1) 和 getline(cin, s2) 来读取输入的字符串。但是要注意，当之前使用 cin >> n 读取整数时，输入流中可能会有一个换行符残留在缓冲区中。这个换行符会被 getline 函数读取到，并导致第一个 getline 函数直接返回空字符串。

为了解决这个问题，可以在读取整数后，使用 cin.ignore() 来忽略剩余的换行符，然后再开始读取字符串。

while True:
    
    
    try:
        n = int(input())
        for i in range(n):
            s1 = input()
            s2 = input()
            index = len(s1) // 2  # 计算插入位置
            s1 = s1[:index] + s2 + s1[index:]  # 将 s2 插入到 s1 的中间位置
            print(s1)
    except:
        break

在这里插入图片描述

#include <iostream>
using namespace std;


int main()
{
    
    int n;
    cin>>n;
    cin.ignore();
    while(n>0){
        string s;
        char temp;
        getline(cin,s);
        int len;
        len = s.length();
        for (int i = 0;i<len;i++){
            if(i%2==0)
            {
                temp=s[i];
                s[i]=s[i+1];
                s[i+1]=temp;
            }
           
        
        }
        cout<<s<<endl;
        n--;
    }
    
    
    return 0;
}

while True:
    
    try:
        n = int(input())
        for i in range(n):
            s = list(input())
            for i in range(len(s)):
                temp = ''
                if i%2 ==0:
                    temp = s[i]
                    s[i] = s[i+1]
                    s[i+1] = temp
                    
                    
            print(''.join(s))
        
    except:
        break

在 Python 中，字符串是不可变的（immutable），因此无法通过索引赋值的方式来修改字符串中的单个字符。
使用 list() 函数将输入的字符串转换为列表，并使用 join() 方法将列表转换回字符串

小豆包的小朋友0217
关注
  • 25
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode刷题算法总结-LeetCode-31-day-May-2020-Challenge:包含我在31天-LeetCodeMay'2
06-30
leetcode刷题算法总结我与病毒式 LeetCode 月刊的冒险 - Code Everyday Challenge - 20 年 5 月版 所以在一个晴朗的日子（2020 年4 月 30 日），我随便打开了 LinkedIn ，我的订阅源中充斥着来自完成了LeetCode 4 月...
LeetCode 刷题 -- Day 3
2401_83694336的博客
03-28 1256
因为使用 sort() 后，nums1 和nums2 中元素都从小到大排列，所以用双指针遍历时 push_back到 ans 的数也是按从小到大的顺序，即下一个要 push_back 到 ans 的数，要么比ans中所有的数都大，要么等于ans.back()。所以值不会越来越大的，那就只有 ①、② 两种情况，那这题就简单了，循环计算各个位置平方和，若得到的值出现过，则说明进入循环了，break；所以这题其实不是用哈希表法，而是用动态规划的知识，动态规划以后再来探讨吧，先学基础的。
LeetCode 刷题 -- Day 2
2401_83694336的博客
03-24 1188
想了很久，发现一种比两趟好一点的方法：用一趟是为了代码跑得快，那我定义两个指针 *fast 和 *slow，fast一次走两步，slow每次走一步，这样fast到底终点后，slow只走了一半。这样只用花一半的时间就能得到链表的长度len了，此时slow还在链表的中间，若 n < len 的话，slow 继续向前next，找到要删除的结点删除就行，这不就一趟实现了。则 当 fast 走了 a 步时，f = a，s = nb + a，两者相遇，并同时指向链表入口。解决方法：用pre指针搭桥，连接各端。
LeetCode 刷题 -- Day 6
2401_83694336的博客
04-24 1014
在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。DFS 遍历树，且每下一层高度 h+1，当访问到叶子结点时，就得出了一条从根节点到最近叶子结点的路径长度了（为当前h+1），记录最小的路径长度即为答案。② root 不为空，则找它的左右孩子的高度，并返回较大的高度 h。
LeetCode 刷题 -- Day 8
2401_83694336的博客
04-26 1033
​ 先序遍历树，利用 mostDeepHight 记录遍历过程中遇到的最大深度，mostDeepVal 记录遍历过程中遇到的最大深度的结点值。这样可得到最底层的结点。​ 而利用先序遍历，先访问当前结点的左子树，再访问右子树，再加上 叶子结点的深度大于mostDeepHight 才更新（并非大于等于）这样就保证了对同一层结点，只记录最左边的结点值，即为答案。​ ② 中序序列以 x 为中心，x 左侧的元素为 x 的左子树， x 右侧的元素为 x 的右子树。
LeetCode 刷题 -- Day 4
2401_83694336的博客
04-20 701
有性质：将 s 中第一个（或前k个） s‘ 移去，再 s 末尾加入一个 （或k个）s’ ，则 s 不变。s’ ，将 s 的首尾拼接（ss）后，中间会出现 s。i += 2 * k) ，i 为观察区第一个元素下标，则 ① 为 reverse(s.begin() + i, s.begin() + i + k);从1开始计数，在计数开始前或每数到 2k 时都进行判断处理一次 ①数到2k的倍数则反转前k个，②剩余字符少于k个则全部反转并结束，③ 如果剩余字符少于2k个 但大于等于 k 个则反转前k个并结束。
LeetCode刷题计划---day2
小豆包的博客
02-15 323
LeetCode刷题计划--day2
LeetCode 刷题 -- Day 7
2401_83694336的博客
04-25 776
​ 先是vector ans 数组存各路径的结点，然后遍历ans 数组取出各结点形成路径，这太麻烦了。所以只需判断当前节点引导的子树是不是满二叉树，是的话直接返回子树的结点，不是的话就往下遍历。​ 自顶向下递归，因此对于同一个节点，函数 getHight 会被重复调用，导致时间复杂度较高。​ 自顶向下遍历树的各结点（先序遍历），对每一结点，判断左右子树的高度差是否小于等于 1。② 如果 root1 和 root2 一个为空，一个不为空，则不对称。
LeetCode 刷题 -- Day 5
2401_83694336的博客
04-22 834
c++11 新标准引入了三个新成员------- emplace_front，emplace 和 emplace_back，这些操作构造而不是拷贝元素，因此相比push_back 等函数能更好地避免内存的拷贝与移动，使容器插入元素的性能得到进一步提升。② 对于push 操作的实现，直接push存入q，对于pop 操作，先把q 中的非队尾元素按序存入 temp，q 的队尾即为要pop的元素，把队尾元素pop后，再将temp中的元素按序存入q。定义优先级队列，自动排序，队首元素即为最大值。
LeetCode 刷题 -- Day 1
2401_83694336的博客
03-22 587
2、为了使用双指针不停移动来更新ans，选择了从两端往中间移动，先让 j = nums.size() - 1，若a[i] [j] > target 再分别讨论 a[i+1] [j] 和 a[i] [j-1] 这两种情况，这样则要么使用DFS，要么用二维数组或结构体（发现没有，其实可以不用数组）定义sum为连续子数组值的和，sum < target 当然是 ++j，sum > target 那 j 不动，sum - nums[i] 后 i++，是不是比 i，j 从两端开始往中间移动好一点。
leetcode卡-LeetCode-solution:LeetCode刷题打卡
07-06
LeetCode刷题打卡—监督自己！不懂的代码Debug一遍 Day1: 2021年5月31日 Day2: 2021年6月1日 Day3: 2021年6月2日 Day4: 2021年6月3日 Day5: 2021年6月4日 Day6: 2021年6月5日 Day7: 2021年6月6日 Day8: 2021年6月7日...
谷歌师兄的leetcode刷题笔记-day_7_Premiers_programmes:day_7_Premiers_programmes
06-30
谷歌师兄的leetcode刷题笔记第七天 列表练习： 多 Caesar 这里有两个版本都可以使用。 每个人都做了自己的。 雷曼兄弟 Google 运行脚本时要小心。 更改或注释要运行的函数。 莎士比亚 运行脚本时要小心。 更改或注释...
Leetcode扑克-LeetCodeJava:leetcode刷题java
06-30
Leetcode扑克 LeetCodeJava LeetCode部分习题Java版，包括多种解法，时间复杂度和空间复杂度自行分析。 Day01 逆波兰表达式求值 Day02 合并两个有序链表 Day03 合并K个排序链表 Day04 验证二叉搜索树 Day05 二叉树中...
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
LeetCode 543.二叉树的直径
weixin_62438655的博客
05-01 315
刷leetcode冲冲冲
C++ | Leetcode C++题解之第78题子集
最新发布
Ddddddd_158的博客
05-09 189
C++ | Leetcode C++题解之第78题子集
C语言 | Leetcode C语言题解之第69题x的平方根
m0_59237910的博客
05-05 503
C语言 | Leetcode C语言题解之第69题x的平方根
【哈希表】Leetcode 14. 最长公共前缀
皮蛋的Bk
05-05 333
我们使用当前第一个字符串中的与后面的字符串作比较，如果第一个字符串中的字符没有出现在后面的字符串中，我们就直接返回；反之当容器中的所有字符串都遍历完成，说明所有的字符串都在该位置出现了当前字符，所以遍历完成之后就像ret中添加当前的字符
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值