java炼精化气之数组上山

最新推荐文章于 2022-03-11 15:25:56 发布
最新推荐文章于 2022-03-11 15:25:56 发布
阅读量122 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45215975/article/details/104374696
版权

排序

选择排序

方法：当前元素与之后所有的元素进行比较，若后者小于前者则两者交换位置。

  • 从数组第一个元素开始。
  • 遍历整个数组，找到最小的元素。
  • 将最小的元素与数组第一个元素交换。
  • 从第二个元素开始重复上述步骤。

Selection Sort

public class Test05_01{
    public static void main(String[] args){
        int[] arr={7,4,5,9,8,2,1};
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+",");
        }
    }
}

冒泡排序

算法步骤

  • 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  • 针对所有的元素重复以上的步骤，除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class Test05_01{
    public static void main(String[] args){
        int[] arr={7,4,5,9,8,2,1};
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+",");
        }
    }
}

插入排序

 算法步骤

  • 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
  • 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

public class Test05_01{
    public static void main(String[] args){
        int[] arr={7,4,5,9,8,2,1};
        int e;
        int j;
        for(int i=1;i<arr.length;i++){
            e=arr[i];
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }

计数排序

  • 计数排序的核心思想是把一个无序序列 A 转换成另一个有序序列 B，从 B 中逐个“取出”所有元素，取出的元素即为有序序列

public class Test05_01{
    public static void main(String[] args){
        int[] arr={7,4,5,9,8,2,1};
        int min=arr[0];
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] nums=new int[max-min+1];
        int offset=min;
        for(int i=0;i<arr.length;i++){
            nums[arr[i]-offset]++;
        }
        int index=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                for(int j=0;j<nums[i];j++){
                    arr[index++]=i+offset;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
        */
    }
}

练习

思路1：数组长度不固定 需要读取一个数据 数组扩容 填入数据数据填入之后进行排序 然后遍历数组依次判断数据的个数连续相等。2 2 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7

思路2：借助计数排序的思想 将数组固定起来。

import java.util.*;
class Demo05_01{
    public static void main(String[] args){
        //1.获取用户输入的数据 动态的扩容数组填充数据
        Scanner scanner = new Scanner(System.in);
        int[] arr=new int[0];
        System.out.print("Enter numbers:");
        while(true){
            int num=scanner.nextInt();
            if(num==0){
                break;
            }
            //验证用户输入数据的正确性
            if(num<1||num>100){
                System.out.println("有非法数据！");
                return;
            }
            arr=copyOf(arr,arr.length+1);
            arr[arr.length-1]=num;
        }
        //2.按照输出结果 将数据中的数据进行排序
        insertSort(arr);
        //3.输出连续相等的数字
        show(arr);
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
    public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
    }
    /*
    Arrays Math都是属于工具类
    Arrays 特殊的是数组的工具类
        toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据
        "[1,2,3,4]"
    */
    public static void show(int[] arr){
        System.out.println(Arrays.toString(arr));
        //此时就将问题转成了如何判断连续相等的数据分别出现多少次
        //[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
            i+=count;
        }
    }
}

import java.util.Scanner;
 
public class Home05_02 {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int[] f = new int[10];
		
		System.out.print("Enter ten numbers: ");
		int count=0;
		
		for(int i=1;i<10;i++){
			int number = input.nextInt();
			int j;
			for(j=0;j<count;j++){
				if(number==f[j]){
					break;
				}	
			}
			if(j==count){
				f[count]=number;
				count++;
			}
		}
		System.out.print("The distinct numbers are: ");
		for(int i=0;i<count;i++){
			System.out.print(f[i]+" ");
		}
	}
}

import java.util.*;
class Demo05_03{
    public static void main(String[] args){
        //1.获取用户的输入 只不过第一个输入的数据时数据的个数(数组的长度)
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter a list:");
        int len=scanner.nextInt();//获取的第一个数值就是数组的长度
        int[] arr=new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i]=scanner.nextInt();
        }
        //2.对数组进行有序的判断
        if(isSorted(arr)){
            System.out.println("The list is already sorted.");
        }else{
            System.out.println("The list is not sorted.");
        }
    }
    public static boolean isSorted(int[] list){
        //如果不是升序排列 那么势必会出现有一组数据 左大右小的情况
        for(int i=1;i<list.length;i++){
            if(list[i-1]>list[i]){
                return false;
            }
        }
        return true;
    }

}

class Demo05_05{
    public static void main(String[] args){
        int[] list1={1,2,3,4,5,6,7};
        int[] list2={1,2,3,4,5,7,6};
        System.out.println(equals(list1,list2));
    }
    public static boolean equals(int[] list1,int[] list2){
        //判断两个数组是否完全相同
        //1.先判断长度
        if(list1.length!=list2.length){
            return false;
        }
        //2.再依次判断元素大小
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

class Demo05_06{
    public static void main(String[] args){
        int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]==arr[j]){
                    count++;
                }else{
                    break;
                }
            }
            if(count>=4){
                System.out.println(arr[i]);
                return;
            }
            i+=count;
        }
        System.out.println("没有！");
    }
}

import java.util.*;
class Demo05_07{
    public static void main(String[] args){
        int[] list1={1,3,5,7,9};
        int[] list2={2,4,6,8,10};
        System.out.println(Arrays.toString(merge(list1,list2)));
    }
    /*
    有序数组的合并
    最主要的问题在于 数组之间有长有短
    */
    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        //只有两个都不是null的情况再考虑具体操作
        int[] list3=new int[list1.length+list2.length];
        int p1=0;
        int p2=0;
        int p3=0;
        while(true){
            if(p1==list1.length&&p2==list2.length){
                break;
            }
            if(p1<list1.length&&p2==list2.length){
                list3[p3++]=list1[p1++];
            }else if(p1==list1.length&&p2<list2.length){
                list3[p3++]=list2[p2++];
            }else{
                if(list1[p1]<=list2[p2]){
                    list3[p3++]=list1[p1++];
                }else{
                    list3[p3++]=list2[p2++];
                }
            }
        }
        return list3;
    }
}

import java.util.Scanner;
public class Home05_09{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("Enter number:");
        double[][] matrix=new double[3][4];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                matrix[i][j]=input.nextDouble();
            }
        }
        //打印每列的和
        for(int col=0;col<matrix[0].length;col++){
            System.out.println(sumColumn(matrix,col));
        }
    }
    public static double sumColumn(double[][] m,int col){
        double sum=0;
        for(int row=0;row<m.length;row++){
            sum=sum+m[row][col];
        }
        return sum;
    }
}

public class Home05_10{
    public static void main(String[] args) {
        int m[] []={
            {1,2,3,4},
            {5,6,7,8},
            {9,10,11,12},
            {13,14,15,16}
        };
        /*
        int sum=0;
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                if(i==j){
                    sum=sum+m[i][j];
                }
            }
        }
        */
        /*主对角线
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum=sum+m[i][i];
        }
        System.out.println(sum);
        */
        //副对角线
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum=sum+m[i][m.length-1-i];
        }
        System.out.println(sum);
    }
}

public class Home05_11{
    public static void main(String[] args) {
        int[][] a={
            {1,3,2},
            {1,0,0},
            {1,2,2}
        };
        int[][] b={
            {0,0,2},
            {7,5,0},
            {2,1,1}
        };
        double [] [] c=new double[a.length][b[0].length];
        for(int i=0;i<c.length;i++){
            for(int j=0;j<c[i].length;j++){
                double sum=0;
                for(int k=0;k<b.length;k++){
                    sum+=a[i][k]*b[k][j];

                }
                c[i][j]=sum;
                System.out.print(c[i][j]+" ");
            }
            System.out.println();
        }
        
    }
}

五子棋

import java.util.*;
public class Home05_15{
    public static String[][]board;
    public static String BLACK_CHESS="O";   //黑棋
    public static String WHITE_CHESS="X";   //白棋
    public static Scanner scanner=new Scanner(System.in);
    public static void main(String[] args) {
        intiboard();
        printboard();
        startgame();
        gameover();

    }
    public static boolean gameover(){
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                if(!board[i][j].equals("+")){
                    //向右
                    if(j<=board.length - 5){
                        boolean flag = true;
                        for(int c = 1;c<=4;c++){
                            if(board[i][j]!=board[i][j + c]){
                                flag = false;
                                break;
                            }
                        }
                        if(flag){
                            return true;
                        }
                    }
                    //向下
                    if(i<=board.length - 5){
                        boolean flag = true;
                        for(int r = 1;r<=4;r++){
                            if(board[i][j]!=board[i + r][j]){
                                flag = false;
                                break;
                            }
                        }
                        if(flag){
                            return true;
                        }
                    }
                    //向右下
                    if(i<=board.length - 5 && j<=board.length - 5){
                        boolean flag = true;
                        for(int k = 1;k<=4;k++){
                            if(board[i][j]!=board[i + k][j + k]){
                                flag = false;
                                break;
                            }
                        }
                        if(flag){
                            return true;
                        }
                    }
                    //向右上
                    if(i>=4 && j<=board.length - 5){
                        boolean flag = true;
                        for(int k = 1;k<=4;k++){
                            if(board[i][j]!=board[i - k][j + k]){
                                flag = false;
                                break;
                            }
                        }
                        if(flag){
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    public static void startgame(){
        int player=0;
        while(true){
            if(player%2==0){
                System.out.print(">>>请黑方下棋:");
                if(!putchess(BLACK_CHESS)){
                continue;
                }
            }
            else{
                System.out.print(">>>请白方下棋:");
                if(!putchess(WHITE_CHESS)){
                continue;
                }
            }
            if(gameover()){
                break;
            }
            player++;
        }
        System.out.println("游戏结束！");
    }
    public static boolean putchess(String chess){
        int x=scanner.nextInt()-1;
        int y=scanner.nextInt()-1;
        if(!board[x][y].equals("+")){
            System.out.println(">>>此处已有棋子，请重新下棋");
            return false;
        }
        board[x][y]=chess;
        printboard();
        return true;
    }
    public static void printboard(){
        System.out.print("  ");
        for(int i=0;i<=14;i++){
            System.out.printf("%2d",i+1);
        }
        System.out.println();
        for(int i=0;i<board.length;i++){
            System.out.printf("%2d ",i+1);
            for(int j=0;j<board[i].length;j++){
               System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void intiboard(){
        board=new String[15][15];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                board[i][j]="+";
            }
        }
    }
}

 

七笔一个L
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java字符 inputnext,score=input.nextInt();的作用是?java相关
weixin_30708203的博客
03-09 966
匿名用户1级2013-07-20 回答一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。Scanner使用分隔符模式将其输入分解为标记，默认情况下该分隔符模式与空白匹配。然后可以使用不同的next方法将得到的标记转换为不同类型的值。例如，以下代码使用户能够从System.in中读取一个数：Scannersc=newScanner(System.in);inti=s...
一位高人隐士传授的炼精化气秘法 透彻之极!
热门推荐
予衡飞翔
07-31 2万+
文源成山居士                 炼精化气秘法(高人隐士传授,透彻之极!) 先是阐述该法的特点和意义: 一、该法继承和发展了传统丹道功         传统气功一般不是打命门内窍，而是打会阴。如道家正宗丹道功从下丹田练起，打开阴跷库，然后走任督二脉循环。而且小周天那个督脉走的不是外面，而是走的脊柱里面，这样就把先天气的信息量直接通过督脉上升
练精化气
dongfangmingyi123的专栏
10-14 1180
 练精化气法亦名少林童子功，过去为修持之士不传之秘。近年由武林泰斗、自然门大师万籁声先生传出。练法极简，每天寝前、早起、午休之时，均可练习。真诀是：侧身而卧（蜷身），以左右食指塞两耳孔，以舒适不透气为度，闭目，闭口，轻合齿，如此，用鼻自然呼吸；待心静后，由鼻呼气时，将气送至两脚板，吸气时不要管它，如此二三次即可。以后仍是自然呼吸，3分钟内，口内生津，咽下就是，随之10分钟内，练至很舒适，觉精管、尿
万籁声童子功，练精化气详解
客亦知夫水与月乎？
12-24 6959
万老的童子功是个宝，普通人健肾只此一招便可受益无穷。其法简易，每日睡前习十分钟即可，最适合现代人的生活节奏。 可惜，此功虽流传多年，却鲜有习者掌握其中的诀窍，导致功效减弱。为了人人得益，本人在此吧详细说明童子功的正确练法。 先说明一点，万老所传的童子功并非自然门功法，
时间宝贵，Java 并发编程复习路线。
slw213106的博客
11-24 91
多线程这部分内容确实比较高深而且每个知识点之间比较零散，让人摸不着头脑，不知道该从哪里下手。而且对于大部分学生群体来讲，很少有机会接触到高并发这方面的真实场景，平常自己敲代码也基本不会用到，所以也导致我们大部分同学都是面向面经学习，你问 synchronized，叭叭叭我能说一堆，你问 volatile，叭叭叭我也能说一堆，但总感觉差点意思，就是这些知识点是零散的，没有那么一根线把它们很好的串联起来。 所以今天我斗胆造一根线，站在小白的角度，讲讲多线程这部分我们到底要学啥，按照什么样的顺序去学，帮助各..
面试经验｜春招在即，时间宝贵，这一定是最近的 Java 并发学习路线
m0_67455745的博客
03-11 90
多线程这部分内容确实比较高深而且每个知识点之间比较零散，让人摸不着头脑，不知道该从哪里下手。而且对于大部分学生群体来讲，很少有机会接触到高并发这方面的真实场景，平常自己敲代码也基本不会用到，所以也导致我们大部分同学都是面向面经学习，你问 synchronized，叭叭叭我能说一堆，你问 volatile，叭叭叭我也能说一堆，但总感觉差点意思，就是这些知识点是零散的，没有那么一根线把它们很好的串联起来。 所以今天我斗胆造一根线，站在小白的角度，讲讲多线程这部分我们到底要学啥，按照什么样的顺序去学，帮助各位建
Java混元功法_陈式太极心意混元 入门功法---太极内功 1
weixin_36152359的博客
02-28 351
入门功法太极拳属内家拳术，练的是动静两功，内外双求，性命双修，以心意行气为法则，以内外双求为宗旨。从无极入门，静极生动，动分阴阳而成太圾，再在心意的主宰下，运行阴阳二气，通遍周身内外，引导四肢百骸通过开合、动静、虚实、松紧、升降、吐纳、收放、蓄发、仲屈、长短、刚柔、进退、顺逆、卷展等运动体现太圾阴阳的变化，经过长时期的修炼，逐渐向太极太和的顶峰攀登。然而现在不少太极拳习练者，没有真正领悟或忽略了太...
Java排序修真：从入门到进阶，从后天生灵到祖神祖仙
遙夜人間
06-15 1210
由浅入深，大道至简。 一、炼精化气：int数组冒泡排序 什么，听说你修真忘了秘籍？这就带你回忆回忆，冒泡排序图解： 理解了冒泡排序流程之后，我们随手写一个int类型数组的冒泡排序： public static void main(String[] args) { int[] array = {5, 6, 7, 12, 36, 9, 10, 4}; for (int i = 0; i < array.length; i++) { for (int j = i; j &l
印光法师:《灵岩遗旨》壹、悲化有情
ptpkf14o
01-17 639
印光法师:《灵岩遗旨》壹、悲化有情 2012年01月13日 　　（一）外道与佛法 　　外道惑众 有二种法 　　今之外道，遍世间皆是。以佛法深妙，人莫能知，彼遂窃取佛法之名，而不知其义，遂以炼丹运气保身之法，认做了生脱死之法。且彼等既不知生死因何而有，故瞎造谣言，谓炼精化气，炼气化神，炼神还虚，复合一处，为得道。实则完全是识神用事，心性真如实际之理体，绝未梦见。尚自诩云：六祖...
正身、打坐、守一、修空法、吐纳、炼精化气与答疑.doc
10-11
包括正身、打坐、守一、修空法、吐纳、炼精化气等概念和步骤的详细解释。 一、正身 正身是道家修行的基础，是指身体的正确姿势和状态。正身包括身体的正确姿势、呼吸的正确方法和心态的正确状态。在修行的过程中，...
机器学习作业-基于python实现的垃圾邮件分类源码(高分项目)
06-27
<项目介绍> 机器学习作业-基于python实现的垃圾邮件分类源码(高分项目) - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
Dijkstra算法：探索最短路径的数学之美.pdf
06-27
Dijkstra算法，全名为Dijkstra's Shortest Path Algorithm，是一种用于寻找加权图中最短路径的算法。它由荷兰计算机科学家Edsger W. Dijkstra在1959年提出，并迅速成为图论和网络理论中最重要的算法之一。本文将探讨Dijkstra算法的起源、原理、应用以及它在解决实际问题中的重要性。 一、Dijkstra算法的起源 Dijkstra算法最初是为了解决荷兰阿姆斯特丹的电话交换网络中的路径规划问题而开发的。在那个时代，电话网络的规模迅速扩大，传统的手动路径规划方法已经无法满足需求。Dijkstra意识到，通过数学方法可以高效地解决这类问题，于是他开始着手研究并最终提出了Dijkstra算法。这个算法不仅在电话网络中得到了应用，而且很快在交通、物流、计算机网络等众多领域展现了其强大的实用价值。
2011全国软件专业人才设计与开发大赛java集训试题及答案.doc
最新发布
06-27
2011全国软件专业人才设计与开发大赛java集训试题及答案.doc
Android 4.4 示例集（含Api演示）
06-27
mysql针对Android 4.4 SDK的示例项目（其中ApiDemos位于legacy文件夹内），由于某些原因，在国内可能难以直接下载。这些示例项目为开发者提供了丰富的API使用案例和演示，有助于深入理解Android 4.4平台的功能和应用开发。虽然直接下载可能存在挑战，但您仍可通过其他渠道或资源寻找相关文件和指导，以便充分利用这些示例来加速您的开发过程。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
屏幕录制 2024.6.27 9.51.46.ASF
06-27
屏幕录制 2024.6.27 9.51.46.ASF
8-Bit Retro Game SFX Pack 1.0
06-27
大量高品质、专业制作的8位复古声音。8Bit Retro SFX Pack 1将为您的游戏带来您想要的优势。将跳跃、物品拾取和武器声音添加到经典视觉效果中。伴随着爆炸声、火灾声、通电声和断电声，让人回到怀旧的电子游戏黄金时代。通过包含的数百个音频文件，找到您所需的确切声音。强化游戏体验。给它应有的声音！ 发现 -由获奖合成器创造的高品质声音 -基本声音，包括硬币拾取、脚步声、游戏结束、游戏开始、受到/造成的伤害以及入口/门/过渡 -20多种有组织的声音 -超过500MB的HQ音频内容 -1000多个声音文件，您可以直接导入到项目中
2024年欧洲肌酸市场主要企业市场占有率及排名.docx
06-27
2024年欧洲肌酸市场主要企业市场占有率及排名.docx
《JAVA面向对象程序设计》练习题---参考答案.doc
06-27
《JAVA面向对象程序设计》练习题---参考答案.doc
Zombie Voices Audio Pack 1.0
06-27
僵尸声音音频包是600多个高质量声波的集合。 它提供了僵尸主题游戏所需的一切，这要归功于它的20多个类别： 攻击、咬、呼吸、窒息、损坏、死亡、进食、血腥、咕噜、大笑、疼痛、反应、尖叫、喉咙、呕吐、单词和句子。 + 我们的僵尸动画包带来的额外奖励，包括攻击、侦测、进食、地面、击中、闲置、跳跃、运动、尖叫。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值