114 条题解

  • -1
    @ 2023-6-10 19:25:23

    本蒟蒻第一次发题解:

    #include <bits/stdc++.h> //头文件
    using namespace std;//命名空间
    int a,b; //定义变量
    int main() { //主函数,程序从这里开始 
        cin>>a>>b; //输入
        cout<<a+b<<endl; //输出他们的和
        return 0; //主函数需要返回0
    }
    
    • -1
      @ 2023-3-19 15:21:32
      #include <bits/stdc++.h>
      #define int long long
      using namespace std;
      signed main() {
          ios::sync_with_stdio(false);
          cin.tie(nullptr);
          int a, b; cin >> a >> b;
          cout << a + b << '\n';
          return 0;
      }
      
      • -1
        @ 2023-3-3 18:49:59

        这题很简单,输入 aa 和 bb,然后输出他们的和即可。

        #include <stdio.h>
        
        int main()
        {
            int a,b;
            scanf("%d%d",&a,&b);
            printf("%d\n", a+b);
            return 0;
        }
        
        • -1
          @ 2022-12-29 10:55:08

          非常简单的一道题,代码:

          var a,b:longint;
          begin
              readln(a,b);
              write(a+b);
          end.
          

          注意pascal用integer会爆掉。

          • -1
            @ 2022-12-3 11:34:28
            #include<bits/stdc++.h>
            using namespace std;
            int main(){
                 int a,b;
                 scanf("%d%d",&a,&b);
                 return !printf("%d",a+b);
            }
            
            • -1
              @ 2022-4-11 7:50:21
              #include<bits/stdc++.h>
              using namespace std;
              int main(){
                int a,b;
                cin>>a>>b;
                cout<<a+b;
                return 0;
              }
              
              • -1
                @ 2022-3-26 0:01:54
                //新手可看此贴
                #include<bits/stdc++.h>
                using namespace std;
                long long a,b;//定义变量a,b
                int main(){
                    cin>>a>>b;//将a,b输入
                    cout<<a+b;//将a,b的和输出
                    return 0;//主函数返回值为0
                }
                
                • -1
                  @ 2021-10-23 14:47:13
                  #include<iostream> 
                  using namespace std; 
                  int main(){ 
                      int a,b; 
                      cin>>a>>b; 
                      cout<<a+b<<endl;
                      return 0; 
                  }
                  
                  • -1
                    @ 2021-10-5 9:20:35

                    水个 py 的吧。

                    a=input().split()
                    # 用 split() 切片
                    print(int(a[0])+int(a[1]))
                    # 先转 int 型再相加
                    
                    • -1
                      @ 2021-4-24 8:53:55

                      我来写一个Python题解。

                      a,b=map(int,input().split())#读入变量a、b,以空格隔开,并转为整型(int)
                      print(a+b)#输出a+b的值
                      

                      不得不说Python是真心简单

                      • -1
                        @ 2021-4-19 6:47:31
                        
                        import java.util.Scanner;
                        public class Main {   
                            private static Scanner s;
                            public static void main(String[] args) {
                                s = new Scanner(System.in); 
                                int a = s.nextInt();
                                int b = s.nextInt();
                                System.out.println(a + b); 
                            } 
                        }
                        
                        • -2
                          @ 2024-1-28 13:57:08

                          a

                          • -2
                            @ 2024-1-15 10:17:25

                            #include<iostream> using namespace std; int main (){ int a,b; cin>>a>>b; cout<<a+b; return 0; }

                            • -2
                              @ 2023-8-31 23:04:01

                              C++ 式普通写法

                              #include<iostream>
                              
                              using namespace std;
                              
                              int a,b;
                              
                              int main(){
                                cin >> a >> b;
                                cout << a + b;
                                return 0;
                              }
                              

                              高精度

                              #include<iostream>
                              
                              using namespace std;
                              
                              const int MAXN = 1e5 + 10;
                              
                              long long r;
                              int c;
                              char op;
                              
                              struct bigint{
                                long long len,sz[MAXN] = {0};
                              
                                long long &operator [] (long long a){
                                  return sz[a];
                                }
                              
                                void input(){
                                  string s;
                                  cin >> s;
                                  len = s.size();
                                  for (int i = 0; i < len; i++){
                                    sz[i] = s[len - i - 1] - '0';
                                  }
                                }
                              
                                void output(){
                                  for (; len - 1 > 0 && !sz[len - 1]; len--){
                                  }
                              
                                  for (int i = len - 1; i >= 0; i--){
                                    cout << sz[i];
                                  }
                                  cout << '\n';
                                }
                                bigint operator + (const bigint &b){
                                  bigint c;
                                  c.len = max(len,b.len) + 1;
                                  for (int i = 0; i < c.len; i++){
                                    c[i] = sz[i] + b.sz[i];
                                  }
                              
                                  for (int i = 0; i < c.len - 1; i++){
                                    c[i + 1] += c[i] / 10,c[i] %= 10;
                                  }
                                  return c;
                                }
                              }a,b,ans;
                              
                              int main(){
                                a.input(),b.input();
                                ans = a + b;
                                ans.output();
                                return 0;
                              }
                              
                              • -2
                                @ 2023-7-19 14:33:53
                                #include<bits/stdc++.h>
                                using namespace std;
                                int main(){
                                    long long a , b ;//long long 的忠实粉丝
                                    cin >> a >> b ;//cincout就是香!!
                                    cout << a+b ;
                                    return 0; 
                                }
                                
                                • -2
                                  @ 2023-7-18 18:53:00
                                  #include <bits/stdc++.h>
                                  using namespace std;
                                  int main() {
                                      //以下三行为输入输出超大数据时标准输入输出流的加速
                                      ios::sync_with_stdio(false);
                                      cin.tie(0);
                                      cout.tie(0);
                                      long long a,b;
                                      cin>>a>>b;
                                      cout<<a+b<<endl;
                                      return 0;
                                  }
                                  
                                  • -2
                                    @ 2023-6-4 21:59:03
                                    **#include** **<**bits**/**stdc**++.**h**>**
                                     **using** **namespace** **std**;
                                     **/\***
                                     **  **思路:将字符串s所有拆分的可能性都尝试一下
                                     **  **打擂台求出最小的素数
                                     ** **\*/
                                     
                                     //素数判断
                                     **bool** **sushu**(**int** **n**)** **{
                                     **    **for** **(**int** **i** **=** **2**;** **i** **<=** **sqrt**(**n**);** **i**++)** **{
                                     **        **if** **(**n** **%** **i** **==** **0**)** **{
                                     **            **return** **false**;**
                                     **        **}
                                     **    **}
                                     **    **if** **(**n** **<=** **1**)** **return** **false**;**
                                     **    **return** **true**;**
                                     }
                                     **int** **main**()** **{
                                     **    **string** **s**,** **s1**,** **s2**;**
                                     **    **int** **i**,** **mi** **=** **INT\_MAX**;** **//mi存储最小的素数
                                     **    **cin** **>>** **s**;**
                                     **    **int** **x**,** **y**;
                                     **    **/\*长度为s.size()的字符串,拆s.size()-1次
                                     **      **12345
                                     **      **i=0** **1** **2345** **s.substr(0,1)**  **s.substr(1)
                                     **      **i=1** **12** **345** **s.substr(0,2)**  **s.substr(2)
                                     **     **\*/
                                     **    **//循环拆段的次数
                                     **    **for** **(**i** **=** **0**;** **i** **<** **s**.**size**()** **-** **1**;** **i**++)** **{**
                                     **        **s1** **=** **s**.**substr**(**0**,** **i** **+** **1**);
                                     **        **s2** **=** **s**.**substr**(**i** **+** **1**);**
                                     **        **//cout<<s1<<"** **"<<s2<<endl;
                                     **        **x** **=** **atoi**(**s1**.**c\_str**());**
                                     **        **y** **=** **atoi**(**s2**.**c\_str**());**
                                     
                                     **        **if** **(**sushu**(**x** **+** **y**)** **&&** **x** **+** **y** **<** **mi**)** **mi** **=** **x** **+** **y**;
                                     **    **}
                                     **    **if** **(**mi** **==** **INT\_MAX**)** **cout** **<<** **-**1**;
                                     **    **else** **cout** **<<** **mi**;**
                                     **    **return** **0**;**
                                     }
                                    
                                    • -2
                                      @ 2023-4-15 16:04:08
                                      #include<iostream>
                                      using namespace std;
                                      int a, b;
                                      int main() {
                                          cin >> a >> b;
                                          cout << a + b << endl;
                                          return 0; 
                                      }
                                      
                                      • -2
                                        @ 2023-4-8 20:33:53

                                        很简单,线段树模板题。

                                        #include <bits/stdc++.h>
                                        #define int long long
                                        using namespace std;
                                        int x, y, a[100005];
                                        struct node {
                                        	int l, r, w, tag;
                                        } tr[400005];
                                        inline bool inrange(int l1, int r1, int l2, int r2) {
                                        	return (l1 >= l2) && (r1 <= r2);
                                        }
                                        inline bool outofrange(int l1, int r1, int l2, int r2) {
                                        	return (l1 > r2) || (l2 > r1);
                                        }
                                        inline void pushup(int u) {
                                        	tr[u].w = tr[u * 2].w + tr[u * 2 + 1].w;
                                        }
                                        inline void build(int u, int l, int r) {
                                        	if (l == r) {
                                        		tr[u].w = a[l];
                                        		return;
                                        	}
                                        	int mid = l + r >> 1;
                                        	build(u * 2, l, mid); build(u * 2 + 1, mid + 1, r);
                                        	pushup(u);
                                        }
                                        inline int query1(int u, int l, int r, int p) {
                                        	if (l == r) {
                                        		return tr[u].w;
                                        	} else {
                                        		int mid = l + r >> 1;
                                        		if (p <= mid) return query1(u * 2, l, mid, p);
                                        		else return query1(u * 2 + 1, mid + 1, r, p);
                                        	}
                                        }
                                        inline void update1(int u, int l, int r, int p, int x) {
                                        	if (l == r) {
                                        		tr[u].w += x;
                                        	} else {
                                        		int mid = l + r >> 1;
                                        		if (mid >= p) update1(u * 2, l, mid, p, x);
                                        		else update1(u * 2 + 1, mid + 1, r, p, x);
                                        	}
                                        }
                                        inline void maketag(int u, int len, int x) {
                                        	tr[u].tag += x;
                                        	tr[u].w += len * x;
                                        }
                                        inline void pushdown(int u, int l, int r) {
                                        	int mid = l + r >> 1;
                                        	maketag(u * 2, mid - l + 1, tr[u].tag);
                                        	maketag(u * 2 + 1, r - mid, tr[u].tag);
                                        	tr[u].tag = 0;
                                        }
                                        inline int query(int u, int l1, int r1, int l2, int r2) {
                                        	if (inrange(l1, r1, l2, r2)) {
                                        		return tr[u].w;
                                        	} else if (!outofrange(l1, r1, l2, r2)) {
                                        		int mid = l1 + r1 >> 1;
                                        		pushdown(u, l1, r1);
                                        		return query(u * 2, l1, mid, l2, r2) + query(u * 2 + 1, mid + 1, r1, l2, r2);
                                        	}
                                        }
                                        inline void update(int u, int l1, int r1, int l2, int r2, int x) {
                                        	if (inrange(l1, r1, l2, r2)) {
                                        		maketag(u, r1 - l1 + 1, x);
                                        	} else if (!outofrange(l1, r1, l2, r2)) {
                                        		int mid = l1 + r1 >> 1;
                                        		pushdown(u, l1, r1);
                                        		update(u * 2, l1, mid, l2, r2, x);
                                        		update(u * 2 + 1, mid + 1, r1, l2, r2, x);
                                        		pushup(u);
                                        	}
                                        }
                                        signed main() {
                                            cin >> x >> y;
                                            build(1, 1, 1);
                                            update1(1, 1, 1, 1, x);
                                            update1(1, 1, 1, 1, y);
                                            cout << query1(1, 1, 1, 1);
                                            return 0;
                                        }
                                        
                                      • -2
                                        @ 2023-3-27 20:33:37
                                        #include<bits/stdc++.h>
                                        using namespace std;
                                        int main()
                                        {
                                        	ios::sync_with_stdio(false);
                                        	long long a,b;
                                        	cin>>a>>b;
                                        	cout<<a+b;
                                        	return 0;
                                        }
                                        

                                        信息

                                        ID
                                        56
                                        时间
                                        1000ms
                                        内存
                                        1024MiB
                                        难度
                                        1
                                        标签
                                        递交数
                                        7041
                                        已通过
                                        3085
                                        上传者