算法大比拼【送技术分】

小小瓶盖❤ · 小小瓶盖❤

package array;
import java.util.*;
/*
* 冒泡排序：相邻两个元素进行比较，满足条件换位。
* 选择排序：选择一元素，不停的与其他元素比较，满足条件换位。
*/
public class Test4 {
public static void main(String args[]){
int[] arr1={1,3,5,6,2,4};
int[] arr2={3,1,5,6,2,4};
int[] arr3={3,1,5,6,2,4};
rankArray1(arr1);
rankAaary2(arr2);
Arrays.sort(arr3); //指定一数组排序
for(int i=0;i<arr3.length;i++){
System.out.print(arr3[i]+" ");
}
}
// 冒泡排序
public static void rankArray1(int[] arr){
int temp;
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]){ //总是比较相邻元素大小，并把每次比较的最大值放在比较的元素的最末尾
/* temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp; */
swap(arr,j,j+1);
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
// 选择排序
public static void rankAaary2(int[] arr){
int temp;
for(int i=0;i<arr.length-1;i++){
for(int j=1+i;j<arr.length;j++){
if(arr[i]>arr[j]) //总是拿一指定角标元素和其后元素比较
{
/* temp=arr[j];
arr[j]=arr[i];
arr[i]=temp; */
swap(arr,i,j);
}
}
}
for(int i=0;i<arr.length;i++)
System.out.print(arr[i]+" ");
System.out.println();
}
// 位置置换(形参：指定数组，指定换位的两个下标)
public static void swap(int[] array,int a,int b){
int temp;
temp=array[a];
array[a]=array[b];
array[b]=temp;
}
}

复制代码

小小瓶盖❤ · 小小瓶盖❤

public class Test5 {
public static void main(String args[]){
int arr[]={2,1,1,2,2,3,3,2};
int arr2[]={1,3,5,7,9};
int x=getIndex1(arr,2);
System.out.println(x);
int y=getIndex2(arr2,6);
System.out.println(y);
y=getIndex2(arr2,8);
System.out.println(y);
int valueIndex[]=getIndex3(arr,2);
for(int i=0;i<valueIndex.length;i++)
System.out.print(valueIndex[i]+" ");
}
// 普通查找：遍历数组，在数组中查找第一次出现的与指定值相等的元素，获取其下标
public static int getIndex1(int arr[],int value){
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
return i;
}
}
return -1;
}
// 折半查找：
public static int getIndex2(int[] arr,int value){
int min=0;
int max=arr.length-1;
int mid=(max+min)/2;
/* //第一种方式
while(value!=arr[mid]){
if(value>arr[mid]) //当指定值大于中间值时，移动小角标
min=mid+1;
else //当指定值小于中间值时，移动大角标
max=mid-1;
mid=(min+max)/2; //根据大小角标的值确定中间值
if(max<min) //当没有要找的值是返回-1
return -1;
}
return mid; */
//第二种方式
while(min<=max){
if(arr[mid]>value)
max=mid-1;
else if(arr[mid]<value)
min=mid+1;
else
return mid;
mid=(max+min)>>1;
}
return -1;
}
// 普通查找:遍历数组查找所有与指定值相等的元素，获取其下标
public static int[] getIndex3(int[] arr,int value){
int j=0,k=0;
// 查找相同的数
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
j++; //用来记录有多少个元素与指定值相等
}
}
//根据j值建立数组
if(j>0){
int valueIndex1[]=new int[j]; //根据相等的元素个数建立数组
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
valueIndex1[k]=i;
k++;
}
}
return valueIndex1;
}
else{
int[] valueIndex2={-1};
return valueIndex2;
}
}
}

复制代码

未发光的金子 · 未发光的金子

本帖最后由未发光的金子于 2014-2-21 11:44 编辑

快速排序算法
快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
代码示例

public static void quickSort(int a[], int start, int end)
{ int i,j;
i = start;
j = end;
if((a==null)||(a.length==0))
return;
while(i<j){
while(i<j&&a[i]<=a[j]){ //以数组start下标的数据为key，右侧扫描
j--;
}
if(i<j){ //右侧扫描，找出第一个比key小的，交换位置
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
while(i<j&&a[i]<a[j]){ //左侧扫描（此时a[j]中存储着key值）
i++;
}
if(i<j){ //找出第一个比key大的，交换位置
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
if(i-start>1){
//递归调用，把key前面的完成排序
quickSort(a,start,i-1);
}
if(end-i>1){
quickSort(a,i+1,end); //递归调用，把key后面的完成排序
}
}

复制代码

未发光的金子 · 未发光的金子

选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。
排序实例
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 [38 65 97 76 49 27 49]
第二趟排序后 13 27 [65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [76 97 65 49 ]
第五趟排序后 13 27 38 49 49 [97 65 76]
第六趟排序后 13 27 38 49 49 65 [97 76]
第七趟排序后 13 27 38 49 49 65 76 [97]
最后排序结果 13 27 38 49 49 65 76 97

public class sort {
public static void selectSort (int[] arr){ // 选择排序的具体实现
for(int x = 0; x < arr.length - 1; x++) {
for(int y = x + 1; y < arr.length; y++) {
change(arr, x, y);
printArray(arr);
}
}
}
public static void printArray(int[] arr) { //打印数组的方法
for(int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
public static void main(String args[]) {
int[] arr = new int[]{7,6,5,4,3,2,1}; //随变生成一个数组
selectSort(arr); //调用选择排序算法
}
public static void change(int[] arr, int x, int y) { //交换的方法
if(arr[x] > arr[y]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}

复制代码

曾振华 · 曾振华

编程验证EN13条码真伪
"6921317905038"
计算13条码前12位奇数位数字的和，sum1
计算13条码前12位偶数位数字的和，sum2
int sum = sum1+sum2*3
将结果%10,int r = sum%10;
int result = 10-r;
return result==(code.charAt(12)-'0');
返回值类型：boolean
参数：String
*/
class EN13
{
public static void main(String[] args)
{
System.out.println(checkEN("6901028000826"));

String code = "6901028000826";
System.out.println(code);

int sum1 = 0;
int sum2 = 0;
for(int i =0;i<code.length()-1;i++)
{
int num = code.charAt(i)-'0';
System.out.print(num);
}

}

public static boolean checkEN(String code)
{
int sum1 = 0;
int sum2 = 0;
for(int i =0;i<12;i++)
{
int num = code.charAt(i)-'0';
if(i%2==0)
sum1 = sum1+num;
else
sum2 = sum2+num;
}
int sum = sum1+sum2*3;
int c = 10-sum%10;
return c ==(code.charAt(12)-'0');
}
}

曾振华 · 曾振华

/*
演示随机抽取算法
机选双色球
*/

import java.util.*;
class  Demo07
{
public static void main(String[] args)
{
String[] poor =
{"01","02","03","04","05","06","07","08","09","10",
   "11","12","13","14","15","16","17","18","19","20",
   "21","22","23","24","25","26","27","28","29","30",
   "31","32","33"};
String[] redBalls = ballsRandomSelect();
Arrays.sort(redBalls);
//随机获取蓝球号码
Random r = new Random();
int index = r.nextInt(16);
String blueBall = poor[index];
//定义一个数组存所有号码
String[] balls = new String[7];
//将随机获取的一组红球号码复制到balls中
System.arraycopy(redBalls,0,balls,0,redBalls.length);
balls[6] = blueBall;
System.out.println(Arrays.toString(balls));
}

public static String[] ballsRandomSelect()
{
String[] poor =
{"01","02","03","04","05","06","07","08","09","10",
   "11","12","13","14","15","16","17","18","19","20",
   "21","22","23","24","25","26","27","28","29","30",
   "31","32","33"};
boolean[] flags = new boolean[poor.length];
String[] balls = new String[6];
Random r = new Random();
int i = 0;
for (; ; )
{
int index = r.nextInt(poor.length);
if(!flags[index])
{
balls[i++] = poor[index];
flags[index] = true;
}
if(i==6)
{
break;
}
}
return balls;
}
}

曾振华 · 曾振华

//打印空心菱形

class Demo07
{
public static void main(String[] args)
{
for (int x = 1;x <= 5 ;x++ ) {
for (int y = x;y <= 4 ;y++ ) {
System.out.print(" ");
}
for (int z = 1;z <= x ;z++ ) {
if (z == 1 || z == x) {
System.out.print("* ");
}else {
System.out.print(" ");
}

}
System.out.println();
}

for (int a = 1; a <= 4;a++ ) {
for (int b = 1;b <= a ;b++ ) {
System.out.print(" ");
}
for (int c = a;c <= 4 ;c++ ) {
if (c == a || c == 4) {
System.out.print("* ");
}else {
System.out.print(" ");
}

}
System.out.println();
}
}

}

xiaofeng · xiaofeng

刚看到这,现学现用,讲十进制转成二进制.

/*
十进制转二进制
*/
import java.util.*;
class Demo03
{
public static void main(String[] args)
{
//创建用户键盘扫描;
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数: ");
//获取用户输入的数据;
int x = sc.nextInt();
toBin(x);
}
//定义一个十进制转二进制的方法.
public static void toBin(int num)
{
//存放数据的容器;
StringBuffer sb = new StringBuffer();
while (num>0)
{
//向容器中添加num%2的结果;
sb.append(num%2);
num/=2;
}
//倒着打印sb中的数据.
System.out.println(sb.reverse());
}
}

复制代码

曾振华 · 曾振华

//斗地主发牌算法

import java.util.*;
class  Demo
{
public static void main(String[] args)
{
String[] card=new String[]{"A","2","3","4","5","6","7","8","9","10","J","Q","K","queen","king"};
      char mark[]=new char[]{3,4,5,6};
      String.valueOf(mark);
      String[] cardList=new String[54];
String[] redHeartCard=new String[13];
String[] squareCard=new String[13];
String[] clubCard=new String[13];
String[] spadeCard=new String[13];
for(int i=0;i<card.length-2;i++)
{
            redHeartCard[i]=mark[0]+card[i];
            squareCard[i]=mark[1]+card[i];
            clubCard[i]=mark[2]+card[i];
            spadeCard[i]=mark[3]+card[i];
}
      System.arraycopy(card,13,cardList,52,2);
System.arraycopy(redHeartCard,0,cardList,0,13);
      System.arraycopy(squareCard,0,cardList,13,13);
System.arraycopy(clubCard,0,cardList,26,13);
      System.arraycopy(spadeCard,0,cardList,39,13);
      System.out.println("洗牌前:"+Arrays.toString(cardList));
upsite(cardList);
      System.out.println("==========================================================");
      System.out.println("洗牌后:"+Arrays.toString(cardList));
      System.out.println("==========================================================");
String[] player1=new String[17];
      String[] player2=new String[17];
      String[] player3=new String[17];
String[] cosineCard=new String[3];
System.arraycopy(cardList,51,cosineCard,0,3);
int i=0;
while(i<=cardList.length){
if(i%3==0){
            for(int j=i/3;j<player1.length;j++)
{
                  player1[j]=cardList[i];
}
}else if(i%3==1){
for(int j=i/3;j<player2.length;j++)
{
                  player2[j]=cardList[i];
}
}else{
            for(int j=i/3;j<player3.length;j++)
{
                  player3[j]=cardList[i];
}
}
i++;
}
System.out.println("玩家1："+Arrays.toString(player1));
               System.out.println("玩家2："+Arrays.toString(player2));
            System.out.println("玩家3："+Arrays.toString(player3));
System.out.println("底牌:"+Arrays.toString(cosineCard));
}
//定义洗牌方法
public static void upsite(String[] array)
{
      Random r=new Random();
int index=r.nextInt(array.length);
for(int i=array.length-1;i>=0;i--)
{
for(int j=i;j<=array.length-1;j++)
{
String temp=null;
temp=array[j];
array[j]=array[index];
array[index]=temp;
}
}
}
}

elq7xy · elq7xy

一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程找出1000以内的所有完数。

public class NinthWanshu {
public static void main(String[] args) {
System.out.println("1到1000的完数有： "); for(int i=1; i<1000; i++) { int t = 0;
for(int j=1; j<= i/2; j++) { if(i % j == 0) {
t = t + j;
} }
if(t == i) {
System.out.print(i + " "); } }
} }

复制代码

依旧00 · 依旧00

递归是程序调用自身的过程，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

public class RecursionDemo {
public static int getsum(int a){
if (a==1)
return 1;
return a+getsum(a-1);
}
public static void main(String[] args) {
int a=getsum(5);
System.out.println("a="+a);
}
}

复制代码

elq7xy · elq7xy

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足如下条件，即是结果。请看具体分析：

public class ThirteenthTwiceSqrt {
public static void main(String[] args) {
for(long l=1L; l<100000; l++) {
if(Math.sqrt((long)(l+100)) % 1 == 0) {
if(Math.sqrt((long)(l+268)) % 1 == 0) {
System.out.println(l + "加100是一个完全平方数，再加168又是一个完全平方数");
}
}
}
} }

复制代码

梦里花-静 · 梦里花-静

求阶乘

//递归算法
//求阶乘
import java.io.*;
public class DiGui
{
　public static void main(String args[])
　{ 　
　　int i=0; 　
　char ch=' '; 　
　String s; 　
　Child ren=new Child(); 　
　try 　
　{ 　
　　System.out.println("Please intput a Number,End whit '#'"); 　　　　
　　do
　　{ 　　　　
BufferedReader br=new BufferedReader(new InputStreamReaderSystem.in));
　　　
　s =br.readLine(); 　　　　
　i=Integer.parseInt(s); 　　　　
　System.out.println(ren.Factorial(i)); 　　
　　}
　while(ch!='#'); 　
　}catch(IOException e){}
　}
}
class Child
{
double Factorial(int n)
　{
　if (n==1) 　
　　　return 1;
　else 　
　　　return n*Factorial(n-1);
　}
}

复制代码

张稳 · 张稳

本帖最后由张稳于 2014-2-22 12:43 编辑

两种算法求最大公约数

class greatestCommonDiv{
private int larger;
private int smaller;
public greatestCommonDiv(int larger, int smaller){
this.larger=larger;
this.smaller=smaller;
}
public int getGreatestComDiv(int number1,int number2){
if(number1>number2){
larger=number1;
smaller=number2;
}
else{
larger=number2;
smaller=number1;
}
//常规算法
for(int index=2;index<=smaller;index++){
if((smaller&&index==0)&&(larger&&index==0))
return index;
}
}
public int getGreatestCom1(int number1,int number){
// 辗转相减法
while (number1!= number2) {
if (number1> number2)
number1= number1- number2;
else
number2= number2- number1;
}
return number1;
}
}

复制代码

Diferay · Diferay

/*
* 不好意思,来晚了,19号开的课,在传智参加java基础班,为了进黑马云9期,加油!
* 以下是从毕老师视频里学到的几个基础算法:
* 冒泡排序：相邻两个元素进行比较，满足条件换位。
* 选择排序：选择一元素，不停地与其他元素比较，满足条件换位。
*/
public class RankLearning {
public static void main(String args[]){
int[] arr1={1,3,5,6,2,4};
int[] arr2={3,1,5,6,2,4};
int[] arr3={3,1,5,6,2,4};
rankArray1(arr1);
rankAaary2(arr2);
Arrays.sort(arr3); //指定一数组排序
for(int i=0;i<arr3.length;i++){
System.out.print(arr3[i]+" ");
}
}
// 冒泡排序
public static void rankArray1(int[] arr){
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]){ //总是比较相邻元素大小，并把每次比较的最大值放在比较的元素的最末尾
swap(arr,j,j+1);
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
// 选择排序
public static void rankArray2(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=1+i;j<arr.length;j++){
if(arr[i]>arr[j]) //总是拿一指定角标元素和其后元素比较
{
swap(arr,i,j);
}
}
}
for(int i=0;i<arr.length;i++)
System.out.print(arr[i]+" ");
System.out.println();
}
// 位置置换(形参：指定数组，指定换位的两个下标)
public static void swap(int[] array,int a,int b){
int temp;
temp=array[a];
array[a]=array[b];
array[b]=temp;
}
}

复制代码

Diferay · Diferay

/*
* 不好意思,来晚了,19号开的课,在传智参加java基础班,为了进黑马云9期,加油!
* 以下是从毕老师视频里学到的几个基础算法:
*/
public class LookingForElemet {
public static void main(String args[]){
int arr[]={2,1,1,2,2,3,3,2};
int arr2[]={1,3,5,7,9};
int x=getIndex1(arr,2);
System.out.println(x);
int y=getIndex2(arr2,6);
System.out.println(y);
y=getIndex2(arr2,8);
System.out.println(y);
int valueIndex[]=getIndex3(arr,2);
for(int i=0;i<valueIndex.length;i++)
System.out.print(valueIndex[i]+" ");
}
// 普通查找：遍历数组，在数组中查找第一次出现的与指定值相等的元素，获取其下标
public static int getIndex1(int arr[],int value){
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
return i;
}
}
return -1;
}
// 折半查找：
public static int getIndex2(int[] arr,int value){
int min=0;
int max=arr.length-1;
int mid=(max+min)/2;
/* //第一种方式
while(value!=arr[mid]){
if(value>arr[mid]) //当指定值大于中间值时，移动小角标
min=mid+1;
else //当指定值小于中间值时，移动大角标
max=mid-1;
mid=(min+max)/2; //根据大小角标的值确定中间值
if(max<min) //当没有要找的值是返回-1
return -1;
}
return mid; */
//第二种方式
while(min<=max){
if(arr[mid]>value)
max=mid-1;
else if(arr[mid]<value)
min=mid+1;
else
return mid;
mid=(max+min)>>1;
}
return -1;
}
// 普通查找:遍历数组查找所有与指定值相等的元素，获取其下标
public static int[] getIndex3(int[] arr,int value){
int j=0,k=0;
// 查找相同的数
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
j++; //用来记录有多少个元素与指定值相等
}
}
//根据j值建立数组
if(j>0){
int valueIndex1[]=new int[j]; //根据相等的元素个数建立数组
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
valueIndex1[k]=i;
k++;
}
}
return valueIndex1;
}
else{
int[] valueIndex2={-1};
return valueIndex2;
}
}
}

复制代码

张稳 · 张稳

希尔排序法是基于插入排序法改变，大大提供了插入排序的执行效率

class ShellSort{
private int[] theArray;
private int nElems;
public ShellSort(int length, int[] array){
this.theArray=array;
this.nElems=length;
}
public int[] shellSort(){
int inner, outer, temp;
int h=1
while(h<=nElems/3)h=h*3+1;
while(h>0){
for(outer=h; outer<nElems; outer++){
temp=theArray[outer];
inner=outer;
while(inner>h-1&&theArray[inner-h]>=temp){
theArray[inner]=theArray[inner-h];
inner-=h;
}
theArray[inner]=temp;
}
h=(h-1)/3;
}
return theArray;
}
}

复制代码

徐芾清 · 徐芾清

刘旭升发表于 2014-2-19 21:53
写一个我以前自己写的一个方法：我觉得写的很好。呵呵

这不是我的基础测试题吗？
看我的代码：

package com.itheima;
/**
*第8题：数组去重
* 例如:
* 原始数组是{4,2,4,6,1,2,4,7,8}
* 得到结果{4,2,6,1,7,8}
*
* @author shine
*
*/
import java.util.Arrays;
public class Test8 {
public static void main(String[] args){
int[] ints = {2,24,24,3,2,24,32,54,6,5,3,7,7,12};//定义一个数组，并对其进行赋值
int[] newints = removeduplication(ints);//调用removeduplication对数组进行去重
System.out.println(Arrays.toString(newints));
}
//该方法用于对数组进行去重
public static int[] removeduplication(int[] ints){
int l = 0;
int[] tempints = new int[ints.length];
out: for(int i=0; i<ints.length; i++){
//对当前数组进行遍历，如果单签元素不与tempints中的已有元素相等则将其添加到tempints中去
for(int n=0; n<l; n++){
if(tempints[n]==ints[i])
continue out;
}
tempints[l++] = ints[i];
}
//取tempints的“有效长度”，并赋值于新数组newints
int[] newints = new int[l];
for(int i=0; i<l ;i++){
newints[i] = tempints[i];
}
return newints;//返回去重，并取合适长度的新数组
}
}

复制代码

徐芾清 · 徐芾清

张稳发表于 2014-2-22 15:40
希尔排序法是基于插入排序法改变，大大提供了插入排序的执行效率

话说我几天刚练过

/**
我对希尔排序的粗浅理解：
先对数组中小标间隔为一定值的数进行排序
而后逐渐缩小这种间隔，直至间隔为1，完成排序
@author shine
*/
import java.util.Arrays;
public class Shine01{
public static void main(String[] args){
int[] ints = {12,34,5,54,35,2,78,62,85,35,9,6,18,24,38,42};
System.out.println(Arrays.toString(order(ints)));
}
public static int[] order(int[] ints){
int d = ints.length;
while(true){
d = d/2;
for(int i=0; i<d; i++){
//下面这个嵌套for循环实际上实现了...>a[i+2d]>=a[i+d]>=a[i]的功能
for(int j=i+d; j<ints.length; j+=d){
int temp = ints[j];
int k;
for(k=j-d; k>=0&&ints[k]>temp; k-=d){
ints[k+d] = ints[k];
}
ints[k+d] = temp;
}
}
//具体实现方法如下：
//首先保证所有下标间隔为d的数间的排序，如：a[8]>a[0],a[9]>a[1],a[10]>a[2]……
//随后缩小下标的间隔，如：a[12]>a[8]>=a[4]>=a[0],a[13]>a[9]>=a[5]>=a[1]……
//并进一步缩小，如：a[14]>a[12]>a[10]>a[8]>a[6]>a[4]>a[2]>a[0],……
//直至d=1，即：a[15]>a[14]>a[13]>a[12]>……，至此排序完成
if(d==1)
return ints;
}
}
}

复制代码

曾振华 · 曾振华

//查表法

class Demo7 {
public static void main(String[] args) {
toHex(0);
}

public static void toHex(int num) {
if (num == 0) {
System.out.println('0');
return;
}
//定义一个表
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//定义一个空的字符数组
char[] arr = new char[8];
//定义一个指针
int pos = arr.length - 1;
//定义循环
while(num != 0) {
int temp = num & 15;
arr[pos] = chs[temp];
pos--;
num = num >>> 4;
}

for (int x = pos + 1;x < arr.length ;x++ ) {
System.out.print(arr[x]);
}
}
}

帐号		自动登录	找回密码
密码			加入黑马

算法大比拼【送技术分】

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

黑马骑士勋章