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

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

2023-02-17 70
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 《算法基础课我的最爱》==》第一课 
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-
|
算法
【AcWing算法基础课】第五章 动态规划（未完待续）(3)
当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。
-dzk-
107 0
-dzk-
|
存储 人工智能 算法
【AcWing算法基础课】第四章 数学知识（未完待续）（3）
根据下面公式来预处理出等式右边的组合数的值，那么等式左边就可以用等式右边已经算过的值来进行计算（有点像dp）。
-dzk-
79 0
-dzk-
|
人工智能 算法 BI
【AcWing算法基础课】第四章 数学知识（未完待续）（2）
从2到n枚举每个数，删掉其所有的倍数，枚举完之后，没有被删掉的数为质数。
-dzk-
106 0
-dzk-
|
算法 存储 内存技术
【AcWing算法基础课】第三章 搜索与图论（2）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
79 0
【AcWing算法基础课】第三章 搜索与图论（2）
-dzk-
|
算法
【AcWing算法基础课】第五章 动态规划（未完待续）（1）
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且 总价值最大 。
-dzk-
63 0
【AcWing算法基础课】第五章 动态规划（未完待续）（1）
-dzk-
|
算法 存储 内存技术
【AcWing算法基础课】第三章 搜索与图论（3）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
108 0
【AcWing算法基础课】第三章 搜索与图论（3）
-dzk-
|
算法 存储 C++
【AcWing算法基础课】第三章 搜索与图论（1）
特点：尽可能先向纵深方向搜索。使用stack实现。所需空间O(h)（h为深度）。不具有“最短性”。
-dzk-
71 0
【AcWing算法基础课】第三章 搜索与图论（1）
真饭桶
|
11月前
|
算法 C++
算法基础课笔记_归并排序
思路： 两个有序的区间，合并成一个有序的区间
真饭桶
35 0
-dzk-
|
人工智能 算法 JavaScript
【AcWing算法基础课】第五章 动态规划（未完待续）（2）
给定一个如下图所示的数字三角形，从 顶部 出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点， 一直走到底层 ，要求找出一条路径，使 路径上的数字的和最大。
-dzk-
65 0
-dzk-
|
人工智能 算法
【AcWing算法基础课】第四章 数学知识（未完待续）（1）
利用秦九韶算法来实现其他进制转十进制的结果求解
-dzk-
76 0

热门文章

最新文章

  • 1
    泛型KMP算法
  • 2
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 3
    OneMob（一体传媒）：大数据算法 让营销更精准
  • 4
    算法学习之顺序结构
  • 5
    【算法】算法之美—Fire Net
  • 6
    Node.js使用jsrsasign实现SHA256withRSA加密算法
  • 7
    【编程练习】收集的一些c++代码片，算法排序，读文件，写日志，快速求积分等等
  • 8
    字符串相似度算法 递归与动态规划求解分析
  • 9
    【算法研究】Bresenham画线算法
  • 10
    算法导论第十四章 数据结构的扩张
  • 1
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98
  • 2
    【redis源码学习】持久化机制，java程序员面试算法宝典pdf
    77
  • 3
    对标腾讯T9架构师的 Android 面试题新鲜出炉，算法真的太重要了
    52
  • 4
    【机器学习】K-means算法与PCA算法之间有什么联系？
    265
  • 5
    【机器学习】维度灾难问题会如何影响K-means算法？
    302
  • 6
    【数据结构与算法 11，高并发系统基础篇
    41
  • 7
    sass 公用10个mixins代码块，算法太TM重要了，前端开发要求
    47
  • 8
    前端开发者必知的缓存淘汰策略：LRU算法解析与实践
    203
  • 9
    2024最新Android算法相关面试大全，请查收
    37
  • 10
    【机器学习】聚类算法中，如何判断数据是否被“充分”地聚类，以便算法产生有意义的结果？
    138

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

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

    • 相关实验场景

    更多
  • 【AI破次元壁合照】少年白马醉春风，函数计算一键部署AI绘画平台
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 重温童年的“五子棋”，赢取专属阿里云Serverless证书
  • 欧拉图的构造性证明与算法实现
  • 1分钟部署经典小游戏
    • 下一篇
    阿里云OSS设置跨域访问