86 solutions

  • -10
    @ 2024-11-26 20:34:24
    群鸟齐飞映日边,
    童声笑语乐无边。
    欺霜傲雪梅花艳,
    我辈何惧风雨寒。
    老松矗立千年久,
    无畏风霜志更坚。
    力拔山河气盖世,
    一腔热血洒人间。
    肘悬明镜照人心,
    击鼓催征踏征程。
    击碎万难迎曙光,
    飞越千山梦无疆。
    二心同德共前行,
    里程碑前再启航,
    地广天高任翱翔。
    • -10
      @ 2024-11-26 20:31:50
      再逢花开春意浓,
      看尽繁华梦未空。
      一世情缘如逝水,
      眼前星河心留痕。
      就似烈火燃希望,
      会当凌云破长空。
      爆竹声中迎蜕变,
      炸破旧梦迎新程。
      • -10
        @ 2024-11-2 16:02:23

        • -10
          @ 2024-10-5 11:32:10

          • -11
            @ 2025-7-3 9:38:30
            #include<bits/stdc++.h>
            using namespace std;
            int main()
            {
                cout<<"Hello,World!";
                return 0;
            }
            
            • -11
              @ 2025-7-2 9:13:50

              #include<bits/stdc++.h> using namespace std; const int N=20; int g[N][N]; int main() { int n; cin>>n; int cnt=1; for(int i=1;i<=n;i++) //填写第i列的起点 { if(i%2==0) //偶数行左上到右下 { for(int x=1,y=i;x<=i;x++,y--) //从(1,i) { g[x][y]=cnt++; } } else //奇数行左下到右上 { for(int x=i,y=1;y<=i;x--,y++) //从(i,1) { g[x][y]=cnt++; } }

              }
              for(int i=1;i<=n;i++)
              {
              	for(int j=1;j<=n-i+1;j++)
              	{
              		cout<<g[i][j]<<" ";
              	}
              	cout<<endl;
              }
              return 0;
              

              }

              • -11
                @ 2025-6-14 11:23:23

                1234567890

                \

                \P[OJIT

                T T T T T T T T T

                T T T T T T TTTTTTTTTT

                T T T TT

                T T T T T T T

                T T T

                T T T T

                T T T

                T T

                • -11
                  @ 2025-6-7 11:28:42

                  #include<bits/stdc++.h> using namespace std; int main() { int n; cin>>n; cout<<'L'; for(int i=1;i<=n;i++) cout<<'o'; cout<<"ng"; return 0; }

                  • -11
                    @ 2025-5-31 12:01:54
                    #include<bits/stdc++.h>
                    using namespace std;
                    
                    // 全局变量定义区
                    int a[]={72,101,108,108,111,44,87,111,114,108,100,33};
                    int b[15];
                    int c[100];
                    int d[100];
                    int e[100];
                    int f[100];
                    int g[100];
                    int h[100];
                    int I[100];
                    int j[100];
                    int k[100];
                    int l[100];
                    int m[100];
                    int n[100];
                    int o[100];
                    int p[100];
                    int q[100];
                    int r[100];
                    int s[100];
                    int t[100];
                    int u[100];
                    int v[100];
                    int w[100];
                    int x[100];
                    int y[100];
                    int z[100];
                    
                    // 函数声明区
                    void initArrays();
                    void copyArray(int src[], int dest[], int size);
                    void printArrayAsChars(int arr[], int size);
                    void doNothing();
                    void complicatedLoop(int arr[], int size);
                    void superComplicatedLogic(int arr1[], int arr2[], int size);
                    void mysteryFunction(int arr[], int size);
                    void anotherMysteryFunction(int arr[], int size);
                    void andAnotherOne(int arr[], int size);
                    void justBecauseWeCan(int arr[], int size);
                    void whyNot(int arr[], int size);
                    void whatIsThis(int arr[], int size);
                    void seriously(int arr[], int size);
                    void thisIsGettingRidiculous(int arr[], int size);
                    void butWeAreNotDoneYet(int arr[], int size);
                    void almostThere(int arr[], int size);
                    void oneMoreFunction(int arr[], int size);
                    void okLastOne(int arr[], int size);
                    
                    int main() {
                    	// 初始化所有数组
                    	initArrays();
                    	
                    	// 复杂的数组复制操作
                    	copyArray(a, b, 12);
                    	
                    	// 对空数组进行一些操作
                    	complicatedLoop(c, 100);
                    	complicatedLoop(d, 100);
                    	complicatedLoop(e, 100);
                    	
                    	// 超级复杂的逻辑处理
                    	superComplicatedLogic(b, c, 12);
                    	
                    	// 一些毫无意义的函数调用
                    	doNothing();
                    	mysteryFunction(f, 100);
                    	anotherMysteryFunction(g, 100);
                    	andAnotherOne(h, 100);
                    	justBecauseWeCan(I, 100);
                    	whyNot(j, 100);
                    	whatIsThis(k, 100);
                    	seriously(l, 100);
                    	thisIsGettingRidiculous(m, 100);
                    	butWeAreNotDoneYet(n, 100);
                    	almostThere(o, 100);
                    	oneMoreFunction(p, 100);
                    	okLastOne(q, 100);
                    	
                    	// 最终打印结果
                    	printArrayAsChars(b, 12);
                    	
                    	return 0;
                    }
                    
                    void initArrays() {
                    	for(int i = 0; i < 100; i++) {
                    		c[i] = 0;
                    		d[i] = 0;
                    		e[i] = 0;
                    		f[i] = 0;
                    		g[i] = 0;
                    		h[i] = 0;
                    		I[i] = 0;
                    		j[i] = 0;
                    		k[i] = 0;
                    		l[i] = 0;
                    		m[i] = 0;
                    		n[i] = 0;
                    		o[i] = 0;
                    		p[i] = 0;
                    		q[i] = 0;
                    		r[i] = 0;
                    		s[i] = 0;
                    		t[i] = 0;
                    		u[i] = 0;
                    		v[i] = 0;
                    		w[i] = 0;
                    		x[i] = 0;
                    		y[i] = 0;
                    		z[i] = 0;
                    	}
                    }
                    
                    void copyArray(int src[], int dest[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		dest[i] = src[i];
                    	}
                    }
                    
                    void printArrayAsChars(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		cout << char(arr[i]);
                    	}
                    }
                    
                    void doNothing() {
                    	// 这个函数什么都不做,只是为了增加代码行数
                    	int a = 0;
                    	a++;
                    	a--;
                    	if(a == 0) {
                    		// 空块
                    	}
                    }
                    
                    void complicatedLoop(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] + 0;
                    	}
                    }
                    
                    void superComplicatedLogic(int arr1[], int arr2[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr2[i] = arr1[i] + 0;
                    	}
                    }
                    
                    void mysteryFunction(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] * 1;
                    	}
                    }
                    
                    void anotherMysteryFunction(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] / 1;
                    	}
                    }
                    
                    void andAnotherOne(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] - 0;
                    	}
                    }
                    
                    void justBecauseWeCan(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] + (0 * i);
                    	}
                    }
                    
                    void whyNot(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] - (0 * i);
                    	}
                    }
                    
                    void whatIsThis(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] * (1 + 0);
                    	}
                    }
                    
                    void seriously(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] / (1 - 0);
                    	}
                    }
                    
                    void thisIsGettingRidiculous(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] + (i * 0);
                    	}
                    }
                    
                    void butWeAreNotDoneYet(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] - (i * 0);
                    	}
                    }
                    
                    void almostThere(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] * (1 + (0 * i));
                    	}
                    }
                    
                    void oneMoreFunction(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] / (1 - (0 * i));
                    	}
                    }
                    
                    void okLastOne(int arr[], int size) {
                    	for(int i = 0; i < size; i++) {
                    		arr[i] = arr[i] + 0;
                    	}
                    }
                    • -11
                      @ 2025-1-18 15:09:22

                      • -11
                        @ 2024-12-7 10:19:51

                        //1. #include<bits/stdc++.h> using namespace std; int main() { int n,s,d,q=0; cin>>n; for (int i=1;i<=n;i++) { cin>>s>>d; if (s>d) { q+=3; } else if(s==d) { q++; } } cout<<q; return 0; }

                        //2. #include<bits/stdc++.h> using namespace std; int main() { int t,a=0,s; cin>>s; for (int i=1;i<=0;i++) { t=sqrt(i); if(t*t!=i) continue; int g=i%10,q=i/10%10,b=i/100%10; if(gq||qb||gb) { a++; if (as) { cout<<i; return 0; } } } return 0; }

                        //3. #include<bits/stdc++.h> using namespace std; int main() { int n,x,s=110; cin>>n; for (int i=1;i<=n,i++) { cin>>x; if (x>s) { cout<<"y"<<endl; } else { cout<<"N"<<endl; } if (s>x) { s=x; } } return 0; }

                        //4. #include<bits/stdc++.h> using namespace std; int main() { int a; cin>>a; for (int i=n-1;i>=1;i--) { bool st=1; for (int j=2;j<=i/j;j++) { if (i%j==0) { st=0; } } if (st) { cout<<i; return 0; } } return 0; }

                        //6. #include<bits/stdc++.h> using namespace std; int main() { int n; cin>>n; for (int i=1;i<=n;i++) { for (int j=1;j<i;j++) cout<<" "; for (int j=1;j<=n;j++) cout<<"*"; cout<<endl; } return 0; }

                        • -11
                          @ 2024-11-30 10:30:03

                          筷子

                          • -11
                            @ 2024-11-26 20:58:55

                            南村群童欺我老无力,一肘击飞二里地!!!

                            • -11
                              @ 2024-11-26 20:43:10
                              厚德载物心如镜,
                              颜容虽老志犹青。
                              无畏前行披荆棘,
                              耻于后退失豪情。
                              • -11
                                @ 2024-11-26 20:41:21
                                鸡鸣报晓迎新晨,
                                你如朝阳照我心。 
                                太虚浩瀚藏奥秘,
                                美景如画共赏寻。
                                • -11
                                  @ 2024-11-26 20:37:30
                                  我思珍宝遍天涯,
                                  要寻奇物不辞劳。
                                  金光闪耀如日辉,
                                  坷途历险志愈高。
                                  垃中寻宝心不倦,
                                  • -11
                                    @ 2024-11-26 20:32:55
                                    靠月寄情思绵绵,
                                    近水含烟梦轻扬。
                                    一帘幽梦随风舞,
                                    点点星光映心房。
                                    就中情深难自禁,
                                    会心一笑共徜徉。
                                    融情入景诗画里,
                                    化作春泥更护芳。
                                    • -11
                                      @ 2024-11-26 19:49:37

                                      文心一言编写的同行列对角线的格

                                      #include <iostream>
                                      using namespace std;
                                      
                                      int main() {
                                          int n, i, j;
                                          cin >> n >> i >> j;
                                      
                                          // 输出同一行上的格子位置
                                          cout << "同一行上格子的位置:" << endl;
                                          for (int k = 1; k <= n; k++) {
                                              cout << "(" << i << "," << k << ") ";
                                          }
                                          cout << endl;
                                      
                                          // 输出同一列上的格子位置
                                          cout << "同一列上格子的位置:" << endl;
                                          for (int k = 1; k <= n; k++) {
                                              cout << "(" << k << "," << j << ") ";
                                          }
                                          cout << endl;
                                      
                                          // 输出左上到右下对角线上的格子位置
                                          cout << "左上到右下对角线上的格子的位置:" << endl;
                                          for (int k = 1; k <= n; k++) {
                                              int row = i - (i - 1) + k; // 从i开始,每次递增1
                                              int col = j - (j - 1) + k; // 从j开始,每次递增1(这里其实简化为k,但为了与下面的对称,保持这种形式)
                                              // 但由于我们只需要对角线上的点,且行列从1开始,所以只需考虑row=col的情况
                                              // 当k=1时,row=i, col=j(即起点),之后每次移动都是row和col同时增减(但在这个特定情况下,我们只需考虑增加)
                                              // 所以我们只需要检查row(或col,因为它们应该相等)是否不超过n
                                              if (row <= n && row == (i - (i - k) + (j - (j - k)))) { // 这里其实row==col+k-i+i-k==col(简化后)且row<=n
                                                  // 但由于我们是从i,j出发,所以只需考虑row从i开始且不超过n的情况
                                                  // 因此上面的条件可以简化为row==i+k-1且row<=n(但k从1开始,所以row从i递增到不超过n)
                                                  // 但为了与题目要求的对角线逻辑一致(虽然这里有些冗余),我们还是用row==col的形式来表示
                                                  // 不过由于我们已经知道起点是(i,j),所以直接计算col=i+k-j(当row=i+k-1时,因为row==col)
                                                  // 并检查col是否不超过n即可(但这里为了与下面的代码风格一致,我们还是用row来表示)
                                                  // 注意:这里的解释有些冗长和复杂,实际上只需知道从(i,j)出发,沿对角线移动即可
                                                  // 正确的简化逻辑应该是:直接计算对角线上的点(i+d, j+d)或(i-d, j-d),其中d是从0开始的偏移量
                                                  // 但由于我们已经知道起点,且只考虑正向对角线(即从左上到右下),所以只需(i+d, j+d)且d<n-i+1且d<n-j+1
                                                  // 但为了与题目和下面的代码一致,我们还是用下面的形式来表示
                                                  int actualCol = i + k - 1 - (i - 1); // 简化后为k(因为是从i开始)但这里为了与row的计算形式一致而写成这样
                                                  if (actualCol == j + k - 1 - (j - 1) && actualCol <= n) { // 实际上只需检查row(或col)是否不超过n且row==col(在这里的形式下)
                                                      // 但由于上面的计算已经保证了row==col(当从(i,j)出发时),所以我们只需检查是否不超过n
                                                      cout << "(" << row << "," << actualCol << ") "; // 这里actualCol其实等于row,但为了与上面的计算一致而保留
                                                  }
                                                  // 注意:上面的条件判断有些冗余,实际上只需检查row(或col)的值即可
                                                  // 正确的简化应该是直接输出(i+k-1, j+k-1)且k从1递增到使得i+k-1和j+k-1都不超过n为止
                                                  // 但为了与题目要求和下面的代码风格一致,我们还是保留了上面的形式
                                                  // 下面的代码将直接采用简化的逻辑来输出对角线上的点
                                                  // 实际上,从(i,j)出发的对角线上的点应该是(i+d, j+d),其中d是从0到某个值的范围
                                                  // 所以我们可以直接这样计算并输出:
                                                  cout << "(" << i + k - 1 << "," << j + k - 1 << ") "; // 正确的对角线输出逻辑
                                                  // 注意:上面的输出中,我们直接计算了对角线上的点,而没有使用上面的冗余判断
                                                  // 这是因为我们已经知道起点是(i,j),且只考虑正向对角线(从左上到右下)
                                                  // 所以我们只需从i和j开始,每次同时增加相同的值(即d),直到达到或超过n为止(但不超过的部分才是有效的点)
                                              }
                                              // 注意:上面的解释部分是为了展示思考过程,实际代码中应该直接采用简化的逻辑来输出对角线上的点
                                              // 下面的代码将直接跳过上面的冗余部分,并正确输出对角线上的点
                                          }
                                          // 注意:上面的循环中,我们实际上多输出了一些不必要的判断和解释
                                          // 为了简洁和正确,我们应该直接这样输出对角线上的点:
                                          for (int d = 0; i + d <= n && j + d <= n; d++) { // d表示从(i,j)出发的偏移量
                                              cout << "(" << i + d << "," << j + d << ") "; // 直接计算并输出对角线上的点
                                          }
                                          // 注意:上面的循环才是正确的对角线输出逻辑,它直接计算了从(i,j)出发的对角线上的所有点
                                          // 并输出了它们的位置。之前的循环和判断是为了展示思考过程,实际代码中应该采用这个简化的逻辑。
                                          cout << endl; // 输出换行符以分隔不同的输出部分
                                      
                                          // 输出左下到右上对角线上的格子位置(注意这里的逻辑与上面类似,但方向相反)
                                          cout << "左下到右上对角线上的格子的位置:" << endl;
                                          for (int d = 0; i - d >= 1 && j + d <= n; d++) { // d表示从(i,j)出发的偏移量(但这次是向左下方向偏移的负值,但在计算中我们取正值,并在输出时调整行列)
                                              cout << "(" << i - d << "," << j + d << ") "; // 直接计算并输出对角线上的点(注意行列的调整)
                                          }
                                          // 注意:上面的循环正确地输出了从(i,j)出发的左下到右上对角线上的所有点
                                          // 它通过调整d的值来遍历对角线上的所有点,并输出了它们的位置。
                                          cout << endl; // 输出换行符以结束程序输出。
                                      
                                          return 0;
                                      }
                                      
                                      • -12
                                        @ 2025-7-2 14:21:01
                                        #include<bits/stdc++.h>
                                        using namespace std;
                                        int main()
                                        {
                                            cout<<"Hello,World!";
                                            return 0;
                                        }
                                        

                                        Information

                                        ID
                                        838
                                        Time
                                        1000ms
                                        Memory
                                        256MiB
                                        Difficulty
                                        1
                                        Tags
                                        # Submissions
                                        930
                                        Accepted
                                        178
                                        Uploaded By