备案控制台
开发者社区 人工智能 文章 正文

《算法基础课我的最爱》==》第一课（三）

2023-02-17 52
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 《算法基础课我的最爱》==》第一课 
package com.lqb;
import java.util.Scanner;
public class Test {
  int[][] nums=null;
  private void init() {
    //生成二位数组
    System.out.println("请输出数组的阶数");
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.close();
    //创建二维数组
    nums =new int [n][n];
    int m=1;
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        nums[i][j]=m++;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    //设置起点 终点坐标
    int x1=0,y1=0;
    int x2=nums.length-1,y2=nums.length-1;
    //默认从left==>right
    boolean l2r=true;
    while(x1<=x2&&y1<=y2) {
      //从left==>right
      if(l2r) {
        System.out.print(nums[x1][y1]+"\t");
        if(x1==0&&y1<y2) {
          //第一行 没有到最后的y 平移变向
          y1++;
          l2r=!l2r; 
        }else if (y1==y2) {
          //在第一行 没有到最后一Y  平移变向
          x1++;
          l2r=!l2r;
        }else {
          //上
          x1--;
          y1++;
        }
      }else {
        System.out.print(nums[x1][y1]+"\t");
        //从right到left
        if(y1==0&&x1<=x2) {
          x1++;
          l2r=!l2r;
        } else if (x1==x2) {  
          y1++;
          l2r=!l2r;
        }else {
          x1++;
          y1--;
        }
      }
    }
  }
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    new Test().init();
  }
}
package com.lqb;
import java.util.Scanner;
public class Test1 {
private int[][] nums;
/**
 * 2022/38
 */
/**
 * 
 * 
 * @param args
 */
    private void init() {
      System.out.println("请输入二维数组");
      //创建Scanner对象
      Scanner scanner =new Scanner(System.in);
      int n=scanner.nextInt();
      //创结二维数组
      nums =new int[n][n];
      int num=0;
      for (int i = 0; i <nums.length; i++) {
        for (int j = 0; j < nums[i].length; j++) {
          nums[i][j]=++num;
          System.out.print(nums[i][j]+"\t");
        }
        System.out.println();
      }
    print();
  }
  private void print() {
    System.out.println("输出结果为");
    //定义二个点的（X，Y） 起点(x1,y1) 到  终点(x2,y2)
    //找到当前数组的范围
    int x1=0,y1=0,x2=nums.length-1,y2=nums[0].length-1;
    //控制层数
    while(x1<=x2&&y1<=y2) {
    //定义移动点的x y
    int x=x1,y=y1;
    //向右移动 x不动 y++
    while(y<=y2) {
      System.out.print(nums[x][y++]+"\t");
    }
    //数值向下移动y不变 x加加 
    y=y2; x++;
    while(x<=x2) {
      System.out.print(nums[x++][y]+"\t");
    }
    //数值向left移动 x不变 y在--
    x=x2;
    y--;
    while(y>=y1) {
      System.out.print(nums[x][y--]+"\t");
    }
    y=y1;
    x--;
    //数值向上移动 y不变x--
    while(x>x1) {
      System.out.print(nums[x--][y]+"\t");
      }
    //逐渐缩小范围
    x1++;y1++;x2--;y2--;
    /*
     * //将范围缩小 
     */
    }
  }
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    new Test1().init();
  }
}
package com.lqb;
import java.util.Scanner;
/**
 *
 * @author MZFAITHDREAM
 *
 */
public class Test2 {
  private int[][] nums;
  private void init() {
    System.out.println("输入二维数组的阶数");
    Scanner scanner =new Scanner(System.in);
    int n=scanner.nextInt();
    nums =new int[n][n];
    int num=0;
    for (int i = 0; i <nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        nums[i][j]=++num;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    // TODO Auto-generated method stub
    System.out.println("输出结果为");
    int x1=0,y1=0,x2=nums.length-1,y2=nums.length-1;
    while(x1<=x2&&y1<=y2) {
    //定义坐标 向下
    int x=x1,y=y1;
    //在同一
    while(x<=x2){
      System.out.print(nums[x++][y]+"\t");
    }
    //righ
    x=x2;
    y++;
    while(y<=y2){
      System.out.print(nums[x][y++]+"\t");
    }
    //向上
    y=y2;
    x--;
    while(x>x1){
      System.out.print(nums[x--][y]+"\t");
    }
    x=x1;
    y--;
    //向left
    while(y>y1){
      System.out.print(nums[x][y--]+"\t");
    }
    x1++; y1++;x2--;y2--;
    }
  }
  public static void main(String[] args) {
    new Test2().init();
  }
}
package com.lqb;
/**
 *第四章的第二题
 *2022/3/9
 */
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class Test3 {
  /**
   * 
   * @param args
   */
  int[][] nums=null;
  private void init() {
    System.out.println("输入数组的阶数:");
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.close();
    nums=new int[n][n];
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //随机性产生0
        nums[i][j]=Math.random()>0.1?new Random().nextInt(9)+1:0;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    System.out.println("结果:");
    //创建两个一维数组，分别用于记录为0的横纵坐标
    int[] row=new int[nums.length];
    int[] col=new int[nums[0].length];
    //循环遍历所有的点
    for (int i = 0; i < nums.length; i++ ) {
      for (int j = 0; j < nums[i].length; j++) {
        if (nums[i][j]==0) {
          row[i]=1;
          col[j]=1;
        }
      }
    }
    System.out.println(Arrays.toString(row));
    System.out.println(Arrays.toString(col));
    System.out.println("\n\n");
    //判断两个一维数组中记录的下标的位置所在的整行和整列清零
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        if (row[i]>0||col[j]>0) {
           nums[i][j]=0; 
        }
      }
    }
    for (int i = 0; i < nums.length; i++) {
      System.out.println(Arrays.toString(nums[i]));
    }
  }
  public static void main(String[] args) {
    new Test3().init();
  }
}
package com.lqb;
import java.util.Random;
import java.util.Scanner;
public class Test4 {
  /**
   * 
   * @param args
   */
  int[][] nums=null;
  private void init() {
    System.out.println("输入数组的阶数:");
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.close();
    nums=new int[n][n];
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //随机性产生0
        nums[i][j]=Math.random()>0.1?new Random().nextInt(9)+1:0;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    System.out.println("结果:");
    //创建两个一维数组，分别用于记录为0的横纵坐标
    int[] row=new int[nums.length];
    int[] col=new int[nums[0].length];
    //循环遍历所有的点
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        if (nums[i][j]==0) {
          row[i]=1;
          col[j]=1;
        }
      }
    }
    //判断两个一维数组中记录的下标的位置所在的整行和整列清零
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        if (row[i]==1||col[j]==1) {
          nums[i][j]=0;
        }
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
  }
  public static void main(String[] args) {
    new Test4().init();
  }
}
package com.lqb;
import java.util.Random;
import java.util.Scanner;
public class Test5 {
  /**
   * 
   * @param args
   */
  int[][] nums=null;
  //创建临时的二维数组
  int[] [] temp=null;
  private void init() {
    System.out.println("输入数组的阶数:");
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.close();
    //定义两个二维数组
    nums=new int[n][n];
    temp=new int[n][n];
    //for循环遍历二位数组
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //随机性产生 用Random
        nums[i][j]=Math.random()>0.2?new Random().nextInt(5)+1:0;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    System.out.println("结果:");
    //创建两个一维数组，分别用于记录为0的横纵坐标
    //x y
    int[] row=new int[nums.length];
    int[] col=new int[nums[0].length];
    //循环遍历所有的点 x y
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //判断了
        if (nums[i][j]==0) {
          //将行y 标记一维数组标记唯一
          row[i]=1;
          col[j]=1;
        }
      }
    }
    //返找
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //如果两格一维数组中  X坐标  Y坐标
        if (row[i]!=1&&col[j]!=1) {
          //该数字X y都 不为0
          int sum=0;
          // 累加横坐标的和
          for (int k = 0; k < nums.length; k++) {
            sum+=nums[i][k];
          }
            //累加Y坐标的和为
            for (int k = 0; k < nums.length; k++) {
              sum+=nums[k][j];
            }
            sum-=nums[i][j];
            temp[i][j]=sum;
          }
        }
      }
    //for
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        if(temp[i][j]>0) {
          nums[i][j]=temp[i][j];
        }
        System.out.print(nums[i][j]+"\t");
        //随机性产生0
        /*nums[i][j]=Math.random()>0.1?new Random().nextInt(5)+1:0;*/
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    }
  public static void main(String[] args) {
    new Test5().init();
  }
}
package com.lqb;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
public class Test6 {
  /**
   * 
   * @param args
   */
  int[][] nums=null;
  //创建临时的二维数组
  List<Map<String, Integer>> olist =new ArrayList<>();
  /*int[][] temp=null;*/
  private void init() {
    System.out.println("输入数组的阶数:");
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.close();
    //定义两个二维数组
    nums=new int[n][n];
    /*
     * temp=new int[n][n];
     */
    //for循环遍历二位数组
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //随机性产生 用Random
        nums[i][j]=Math.random()>0.2?new Random().nextInt(5)+1:0;
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    print();
  }
  private void print() {
    System.out.println("结果:");
    //创建两个一维数组，分别用于记录为0的横纵坐标
    //x y
    int[] row=new int[nums.length];
    int[] col=new int[nums[0].length];
    //循环遍历所有的点 x y
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //判断了
        if (nums[i][j]==0) {
          //将行y 标记一维数组标记唯一
          row[i]=1;
          col[j]=1;
        }
      }
    }
    //返找
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        //如果两格一维数组中  X坐标  Y坐标
        if (row[i]!=1&&col[j]!=1) {
          //该数字X y都 不为0
          int sum=0;
          // 累加横坐标的和
          for (int k = 0; k < nums.length; k++) {
            sum+=nums[i][k];
          }
            //累加Y坐标的和为
            for (int k = 0; k < nums.length; k++) {
              sum+=nums[k][j];
            }
            sum-=nums[i][j];
            /* temp[i][j]=sum; */
          }
        }
      }
    //for
    for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
        /*
         * if(temp[i][j]>0) { nums[i][j]=temp[i][j]; }
         */
        System.out.print(nums[i][j]+"\t");
        //随机性产生0
        /*nums[i][j]=Math.random()>0.1?new Random().nextInt(5)+1:0;*/
        System.out.print(nums[i][j]+"\t");
      }
      System.out.println();
    }
    }
  public static void main(String[] args) {
    new Test6().init();
  }
}
文章标签：
算法
关键词：
算法基础课
t75yjb52rsccc
目录
相关文章
-dzk-
|
6月前
|
算法
【AcWing算法基础课】第五章 动态规划（未完待续）(3)
当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。
-dzk-
74 0
-dzk-
|
6月前
|
存储 人工智能 算法
【AcWing算法基础课】第四章 数学知识（未完待续）（3）
根据下面公式来预处理出等式右边的组合数的值，那么等式左边就可以用等式右边已经算过的值来进行计算（有点像dp）。
-dzk-
58 0
-dzk-
|
6月前
|
人工智能 算法 BI
【AcWing算法基础课】第四章 数学知识（未完待续）（2）
从2到n枚举每个数，删掉其所有的倍数，枚举完之后，没有被删掉的数为质数。
-dzk-
49 0
-dzk-
|
6月前
|
算法 存储 内存技术
【AcWing算法基础课】第三章 搜索与图论（2）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
52 0
【AcWing算法基础课】第三章 搜索与图论（2）
真饭桶
|
5月前
|
算法 C++
算法基础课笔记_归并排序
思路： 两个有序的区间，合并成一个有序的区间
真饭桶
23 0
-dzk-
|
6月前
|
人工智能 算法 JavaScript
【AcWing算法基础课】第五章 动态规划（未完待续）（2）
给定一个如下图所示的数字三角形，从 顶部 出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点， 一直走到底层 ，要求找出一条路径，使 路径上的数字的和最大。
-dzk-
31 0
-dzk-
|
6月前
|
算法
【AcWing算法基础课】第五章 动态规划（未完待续）（1）
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且 总价值最大 。
-dzk-
48 0
【AcWing算法基础课】第五章 动态规划（未完待续）（1）
-dzk-
|
6月前
|
人工智能 算法
【AcWing算法基础课】第四章 数学知识（未完待续）（1）
利用秦九韶算法来实现其他进制转十进制的结果求解
-dzk-
51 0
-dzk-
|
6月前
|
算法 存储 内存技术
【AcWing算法基础课】第三章 搜索与图论（3）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
79 0
【AcWing算法基础课】第三章 搜索与图论（3）
-dzk-
|
6月前
|
算法 存储 C++
【AcWing算法基础课】第三章 搜索与图论（1）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
51 0
【AcWing算法基础课】第三章 搜索与图论（1）

热门文章

最新文章

  • 1
    【MATLAB】GA_ELM神经网络时序预测算法
  • 2
    使用Python实现DBSCAN聚类算法
  • 3
    R语言聚类算法的应用实例
  • 4
    Machine Learning机器学习之决策树算法 Decision Tree（附Python代码）
  • 5
    普林斯顿算法讲义（二）（4）
  • 6
    52个AIGC视频生成算法模型介绍（上）
  • 7
    【算法与数据结构】队列的实现详解
  • 8
    深度解析JVM世界：垃圾判断和垃圾回收算法
  • 9
    普林斯顿算法讲义（一）（4）
  • 10
    R语言贝叶斯MCMC：GLM逻辑回归、Rstan线性回归、Metropolis Hastings与Gibbs采样算法实例
  • 1
    Python基础算法解析：K最近邻算法
    25
  • 2
    【数据结构与算法】—— 手撕红黑树
    40
  • 3
    【优选算法】—— 字符串匹配算法
    49
  • 4
    【优选算法】—— 滑动窗口类问题
    44
  • 5
    【算法】——全排列算法讲解
    37
  • 6
    【排序算法】数据结构排序详解
    48
  • 7
    数据结构——排序算法之快速排序
    34
  • 8
    ArrayList集合的两个实例应用，有趣的洗牌算法与杨辉三角
    28
  • 9
    数据结构--算法的时间复杂度和空间复杂度
    20
  • 10
    KNN和SVM实现对LFW人像图像数据集的分类应用
    44

    • 相关课程

    更多
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解
  • 天池leetcode编程基础课
  • 【机器学习入门】 台大李宏毅老师经典机器学习课程视频
  • 深入浅出白话Serverless-1024程序员节创造营公益课

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • TLS1.3的后量子算法集成
  • RSA非对称加密算法
  • 重温童年的“五子棋”，赢取专属阿里云Serverless证书
  • 1分钟部署经典小游戏
  • 搭建超级小班课网课系统
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）