12/21 JAVA程式小考 多載

恩...此篇只是要讓自己別再犯白癡的錯誤
簡單的題目.....
1.3個陣列存值 分別為X Y Z三陣列 各存固定的值
2.創立的函式名稱(add)相同 但參數不同
分別為
X陣列自己加自己
X陣列+Y陣列
X陣列+Y陣列+Z陣列
3.將執行結果寫在output函數裡面


先來說一下多載的定義

相同函式的名稱() 但參數的不同型態不同或者是參數數量不同都可以形成多載

以下狀況都成立
型態不同
public static void add(int x){}
public static void add(int[][] x){}

數量不同
public static void add(int x){}
public static void add(int x,int y){}


陣列宣告丟值這邊不贅述了....(這也是我今早考試耍笨的地方 忘記這邊的語法...)

int[][] X={{1,2,3},{4,5,6},{7,8,9}}; 
  int[][] Y={{10,11,12},{13,14,15},{16,17,18}};
  int[][] Z={{19,20,21},{22,23,24},{25,26,27}};

接下來宣告方法 X陣列自己加自己(也可以直接*2)....只舉一個函式就夠了...其他一樣

int i=0,j=0;
public static void add(int[][] X)
 {
  
  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    sumbox[i][j]=X[i][j]+X[i][j];
   }

  }
  output(sumbox);
 }

我知道很多人在這邊卡住了...如何輸出?也就是output....
其實很簡單 我只要在走訪陣列時...把值相加後
丟到額外的陣列裡面去做輸出動作就可以了
所以 我為了方便 我在最外層也就是public class那一層 宣告了全域變數
也就是說我不管在哪個函式裡面我都可以用這個陣列 他是共通的!


static int[][] sumbox=new int [3][3]; <==全域陣列



所以上面sumbox在走完陣列 並儲存相加後的值之後
呼叫output(sumbox)另外一個函式 把sumbox陣列裡面的值丟到output這個函式裡面做輸出
所以output為....

public static void output(int[][] M)
 {

  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    System.out.print(M[i][j]+"  ");
    M[i][j]=0;

   }
   System.out.println("");

  }

 }

正常輸出 以上.....
另外 每個函式內的參數名稱 都為區域變數 你愛取甚麼變數名稱其實隨意 重複也行
因為它是把你的值抓進來存成只在這個函式裏面的變數做運算而已

如:public static void output(int[][] 隨你取名子)

public class Javatest
{

 static int[][] sumbox=new int[3][3];
 public static void main(String args[])
 {
  int[][] X={{1,2,3},{4,5,6},{7,8,9}}; 
  int[][] Y={{10,11,12},{13,14,15},{16,17,18}};
  int[][] Z={{19,20,21},{22,23,24},{25,26,27}};
  add(X);
  System.out.println("");
  add(X,Y);
  System.out.println("");
  add(X,Y,Z);


 }
 public static void add(int[][] X)
 {
  
  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    sumbox[i][j]=X[i][j]+X[i][j];
   }

  }
  output(sumbox);
 }
 public static void add(int[][] X,int[][] Y)
 {
  
  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    sumbox[i][j]=X[i][j]+Y[i][j];
   }

  }
  output(sumbox);
 }
 public static void add(int[][] X,int[][] Y,int[][] Z)
 {
  
  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    sumbox[i][j]=X[i][j]+Y[i][j]+Z[i][j];
   }

  }
  output(sumbox);
 }
 public static void output(int[][] M)
 {

  int i=0,j=0;
  for(i=0;i<=2;i++)
  {

   for(j=0;j<=2;j++)
   {

    System.out.print(M[i][j]+"  ");
    M[i][j]=0;

   }
   System.out.println("");

  }



 }

}

(1A2B遊戲)手把手教你如何光源氏計畫培養電腦成為你的1A2B遊戲伴侶 Part2.5 重複數字檢查 12/20補充

這篇只是簡單的提示如何檢查陣列裡面像是1155這種4位數字有重複數字給0
1023正常數字給1
這邊為了方便起見，所以
只列印出101~200中間重複數字給0 不重複給1
本篇目標就是101~200陣列給0或給1
成功答案結果為

兩個函數功能
Dismantling(拆數字)
Comparison(比對)
判別會是 ex:
box1[110]=0 box1[133]=0 <==重複
box1[120]=1 box1[123]=1 <==不重複

在這邊先給大家看陣列若沒給值 預設都是0.....
示意圖1~100(程式碼如下)

import java.util.*;
public class Arraysamenum
{
 static int i=0,j=0,x=0,y=0,z=0;
 static int[] box1=new int[101];
 public static void main (String args[])
 {
  for(i=1;i<=100;i++)
  {
   System.out.print("box1["+i+"]="+box1[i]+" ");
   if(i%10==0)
   {

    System.out.println("");
   }


  }
 }

}

-------------------------------------Dismantling---------------------

public static void Dismantling(int x)
 {
  int i=0;
  for(i=0;i<=2;i++)
  {
   switch(i)
   {
    case 0:
    y=x/100;
    box2[i]=y;
    break;
    case 1:
    z=(x-(y*100))/10;
    box2[i]=z;
    break;
    case 2:
    a=(x-(y*100)-(z*10));
    box2[i]=a;
    break;

   }
    
  }
 }

以上為拆解數字 先前解釋過了 這邊不贅述
-----------------------Comparison----------------------
接下來 我們就來把值拆掉放到另外一個陣列box2 去做比對動作....(一樣拆數字)
示意圖如下 可以發現我把前一個值跟後一個值抓出來做比對 是一個巢狀迴圈

i=0的時候 j=i+1; j永遠是下一個數字 這樣跑過一次 如果我發現有重複數字
box2[i]==box2[j]的時候 我就把ck存成1 ck=1 沒有重複數字就存0 做完迴圈後回傳ck值 判別ck值就知道有沒有重複了


提示容易寫錯重點:因為這是個迴圈 若我在第0個跟第1個對有重複
但第1個數字跟第2個數字沒有重複
如果你寫成.....

for(i=0;i<=1;i++)
{
   for(j=i+1;j<=2;j++)
   {

     if(box2[i]==box2[j])
     {
       ck=1;//重複

     }
     else
     {

      ck=0;//沒重複

     }

   }
   return ck;//廻傳ck
}

那麼....就算第0個跟第1個數字有重複 最終ck值還是"0" 因為第1個和第2個不符合 所以ck又被覆蓋掉了對吧?所以我們應該....如果有重複ck=1 那麼之後就直接跳出迴圈
是不是我只要在else 給0之前做個判斷呢?
if(ck==1)break; 所以我只要拿到值ck==1那麼我就直接跳出 就不給0
所以程式碼就是....

public static int Comparison(int[] box2)
 {
  int i=0,j=0;
  for(i=0;i<=1;i++)
  {
   for(j=i+1;j<=2;j++)
   {
    if(box2[i]==box2[j])
    {
     ck=1;
    }
    else
    {
     if(ck==1)break;
     ck=0;
    }

   }
  }
  return ck;
 }

------------------------做完拆解數字跟比對之後我們把功能融合起來---------------------------------
做完這邊之後......呼應本篇的要求 要把101~200陣列弄出來對吧?
所以呢 是不是就會寫成for(i=101;i<=201;i++){執行要的程式}?

-----------------------------------以下為執行要的程式內容---------------------------------------------
好~該要的功能都有了 拆解數字跟比對
所以拆解數字我放一個函數Dismantling 比對我放另外一個函數Comparison
Dismantling(i)//拆解並存給box2[]
Comparison(int[] box2)//box2的比對 回傳ck值 (1有重複 0沒重複)
接下來判斷
if(ck==1)
{
  box1[i]=0
  ck=0;//注意!box[i]給完0之後 ck要回復成0 否則 後面都是1.....

}
else
{
box1[i]=1;
ck=0;

}
接下來就列印 不解釋了......
附上完整程式碼...

import java.util.*;
public class Arraysamenum
{
 static int x=0,y=0,z=0,a=0,ck=0,ak=0;
 static int[] box1=new int[201];
 static int[] box2=new int[3];
 public static void main (String args[])
 {
  int i=0;

  for(i=101;i<=200;i++)
  {
   Dismantling(i);
   Comparison(box2);
   if(ck==1)
   {
    box1[i]=0;
    ck=0;
   }
   else
   {
    box1[i]=1;
    ck=0;
   }
   
   System.out.print("box1["+i+"]="+box1[i]+" ");
   if(i%10==0)
   {

    System.out.println("");
   }


  }
  
 }
 public static void Dismantling(int x)
 {
  int i=0;
  for(i=0;i<=2;i++)
  {
   switch(i)
   {
    case 0:
    y=x/100;
    box2[i]=y;
    break;
    case 1:
    z=(x-(y*100))/10;
    box2[i]=z;
    break;
    case 2:
    a=(x-(y*100)-(z*10));
    box2[i]=a;
    break;

   }
    
  }
 }
 public static int Comparison(int[] box2)
 {
  int i=0,j=0;
  for(i=0;i<=1;i++)
  {
   for(j=i+1;j<=2;j++)
   {
    if(box2[i]==box2[j])
    {
     ck=1;
    }
    else
    {
     if(ck==1)break;
     ck=0;
    }

   }
  }
  return ck;
 }

}

(1A2B遊戲)手把手教你如何光源氏計畫培養電腦成為你的1A2B遊戲伴侶 Part2 數字比對

會拆數字之後接下來就把兩個數字做拆解後個別存到box1 跟box2上

也就是box1[]跟box2[]

那問題就來了 我們如何讓電腦知道幾A幾B呢?

我們先自己比對一次 是不是就像下圖一樣呢? 

如果我把A1(box1)當成主要角色B1(box2)當成次要角色 

那麼對應方式就會為.....

box1[0]去對上box2[0,1,2,3] 

box1[1]去對上box2[0,1,2,3] 

以此類推

所以注意到了嗎? box1和box2的關係是不是就變成巢狀迴圈了呢?

再來.... 接下來A代表數字對位置也對

B則是數字對 位置不對.....

我們把剛剛的巢狀迴圈 控制i j的值 是不是就是位置呢?

不懂的話回去看上一張圖.... A1裡面有4個格子 所以變成box1[i] i=0,1,2,3以此類推

也就是說 我們跑這個巢狀迴圈是在抓box1[i]裡面的值 那i就是索引值也就是位置

囉.....

接下來....了解位置後

應該就能很輕鬆判斷A和B的條件吧

所以 符合A 程式碼就是:if(i==j&&box1[i]==box2[j]) 如果位置正確裡面的值也正確那麼....

         符合B 程式碼就是:if(i!=j&&box1[i]=box2[j]) 如果位置不正確 裡面值正確那麼.....

以上就是數字比對的部分

注意!這裡只是教方法如何使用....複製貼上一點意義都沒有.(1A2B 不懂這些程式碼拼拼湊湊絕對不會有答案出來喔..... 真心不騙)

以下程式碼為:

public static void comp(int[] box1,int[] box2)
 {
  for(i=0;i<=3;i++)
  {

   for(j=0;j<=3;j++)
   {
    if(i==j&&box1[i]==box2[j])
    {
     aok++;

    }else if(i!=j&&box1[i]==box2[j])
    {
     bok++;
    }
   }

  }
 }

(1A2B遊戲)手把手教你如何光源氏計畫培養電腦成為你的1A2B遊戲伴侶 Part1 數字拆解

廢話不多說 今天寫一下如何讓電腦成為你心目中的伴侶
結果如下圖:

在此先說明此1A2B的遊戲規則之後文章不在贅述

1.是一個4位數，其中0~9不得在同一個4位數內出現兩次而且千位數不能是0所以以下是不能出現的情況(EX:0123,1223,1315,1454等)所以範圍1023~9876
2.本遊戲是讓電腦猜你心裡的數字後，你回答幾A幾B，所以..流程=>電腦猜你數字假設(1234)=>你心目中的答案是1235所以你回答3A0B=>....以此類推，直到電腦猜到你的數字為止
3.使用者不得欺負電腦，如5A0B不可能出現的數字，或者一次的遊戲內是你心裡想的答案不斷更換，若有以上情況電腦應該都會出現ERROR提示使用者.....

4.電腦成功猜出數字時(當你輸入4A0B時)，會高興的跟你說猜到了

-------------------以上為本1A2B大概的遊戲規則-------------------

現在大家清楚了遊戲規則後我大概分成幾個步驟 

1.輸入兩個數字 拆數字(稍後本文介紹)

2.比對1A2B

3.創造一個1023~9876之間的陣列且不得有重複數字(請見規則1)此陣列用來標記有無可能是使用者猜的數字 有可能則1不可能則0幾A幾B

4.電腦每次產生一個亂數在1023~9876之間且不得重複數字出現每猜完一次下一次亂數就不可能再出現(利用第二步的陣列)

5.結合 功能整合 

-----------------------數字拆解讓電腦辨別幾A幾B---------------------

首要達成目標 使用者輸入兩個數字讓電腦做比對動作，並顯示幾A幾B

假設有兩個數字1023 1024整數

我們自己去比對一個一個看 那麼既然知道是一個一個看

也就可以知道我們能用陣列一個一個下去比對

如下:我把1023 1024個別存到box1和box2這兩個陣列裡面

所以創出兩個陣列大小為4 然後一個一個去比對用迴圈方式做4次

當然若要比對，基本上就是要拆數字 給個觀念

1234=(A*1000+B*100+C*10+D*1)相信這個大家都會算

那麼若用電腦拆數字呢??

我們設一A,B,C,D的整數

是不是就變成...

1234/1000=A

1234=(1234-A*1000)/100=B

1234=(1234-A*1000-B*100)/10=C

1234=(1234-A*1000-B*100-C*10)/1=D

我們發現每次數字拆解都是4次而且取值都需要上一次的結果

抓下來運算 需要一個巢狀迴圈

所以......JAVA結果為 

程式碼如下:Dismantling為函數拆解

 
import java.util.*;
public class NumberComparison
{
 static int a1=0,b1=0,i=0,a=0,b=0,c=0,d=0;
 static int[] box1=new int[4];
 static int[] box2=new int[4];
 public static void main(String args[])
 {
  Scanner sc=new Scanner (System.in);
  System.out.println("a1的數值為");
  a1=sc.nextInt();
  System.out.println("b1的數值為");
  b1=sc.nextInt();
  Dismantling1(a1);
  Dismantling2(b1);
  for(i=0;i<=3;i++)
  {
   System.out.println("box1\t"+box1[i]);
   
  }
  for(i=0;i<=3;i++)
  {
   System.out.println("box2\t"+box2[i]);
   
  }
  
  
  
 }
 
 public static void Dismantling1(int a1)
 {
   for(i=0;i<=3;i++)
   {
    switch(i)
    {
     case 0:
      a=a1/1000;
      box1[i]=a;
      break;
     case 1:
      b=(a1-a*1000)/100;
      box1[i]=b;
      break;
     case 2:
      c=(a1-a*1000-b*100)/10;
      box1[i]=c;
              break;
     case 3:
      d=(a1-a*1000-b*100-c*10)/1;
      box1[i]=d;
      break;
    } 
    
   }
  }
 public static void Dismantling2(int b1)
 {
   for(i=0;i<=3;i++)
   {
    switch(i)
    {
     case 0:
      a=b1/1000;
      box2[i]=a;
      break;
     case 1:
      b=(b1-a*1000)/100;
      box2[i]=b;
      break;
     case 2:
      c=(b1-a*1000-b*100)/10;
      box2[i]=c;
              break;
     case 3:
      d=(b1-a*1000-b*100-c*10)/1;
      box2[i]=d;
      break;
    } 
    
   }
  }
} 

數字金字塔

import java.util.*;
public class Num
{
public static void main(String[] main)
{
int num=0,z=0;//創立兩個變數 num為使用者輸入的數量 z為空格計數器
Scanner sc=new Scanner(System.in);
num=sc.nextInt();
for(int i=1;i<=num;i++)//注意!i控制列j控制行
{
z=num-i;//每一列所需的空格數 可以發現規律 假設輸入3列 那麼第一列需要的空格數量就是2 第二列就是1以此類推
for(int x=1;x<=z;x++)
{
System.out.print(" ");
}
for(int j=1;j<=i;j++)
{

if(i==j)//當i和j相等時就是那列的最大值 如"123"到3的時候最大那剩下的"21"就得往回扣 如此才能得到"12321"完整的一列

{
for(int k=j;k>=1;k--)
{
System.out.print(k);
}

}
else //如果沒有相等那代表還不是那列最大值就做出輸出
{
System.out.print(j);

}

}
System.out.println("");
}
}
}

-----------------------輸出結果如下---------------------------

迴圈累加 java

import java.util.*;
public class Forplus
{
public static void main(String[] main)
{
int num,num1,sum=0;//創立三個變數 num讀需要加幾次 num1則負責計數還有幾列
Scanner sc=new Scanner(System.in);
num=sc.nextInt();//讀使用者需要幾次
num1=num;//開始計數
while(num>=1)
{
if(num==1)//只要num==1就表示已經加完了一列
{

sum+=num;//sum累積起來
System.out.print(num+"="+sum);//......+1=sum
System.out.println();//換下一列
sum=0;//歸零
num1--;
num=num1;
//重要!num1--計數
}
else//不是1的話就不斷sum累加
{
sum+=num;
System.out.print(num);
System.out.print("+");
num--;
}
}

}
}

----------------------執行結果如下----------------------

帕斯卡三角形

--------前情提要---------------------
基本上帕斯卡從第三列開始 都是上面兩個相加等的和(我只要把每個值存到陣列之後就能相加了)
然後"1"在每列的頭以及列的尾出現所以我這樣切 中間的值就用陣列相加就足夠了

--------------------------------------------
import java.util.*;
public class Pt
{
public static void main (String[] args)
{
Scanner sc= new Scanner(System.in);
int a,x=1,z;
a=sc.nextInt();//讀需要幾列
int [][] box=new int[a][a];//創造二維陣列陣列 這個大小只要大於等於存放的空間就可以了
for(int i=0;i<a;i++)//注意!i控制列 j控制裡面的行不懂直接帶值跑一次就知道了
{
z=(a-1)-i;//z做空格調整每一列空格數量
for(int y=1;y<=z;y++)
{
System.out.print(" ");
}
for(int j=0;j<=i;j++)
{
if(j==0||i==j)//如果在這列的頭或在這列的尾那麼我們就固定輸入"1"且存到陣列裡
{
box[i][j]=x;
System.out.print(box[i][j]+" ");
}
else//不是的話 那麼就是上面兩個值做相加動作(陣列相加)
{
box[i][j]=box[i-1][j-1]+box[i-1][j];//i-1往上面找前一列j找上一列的第幾個

System.out.print(box[i][j]+" "); //加完之後輸出
}
}
System.out.println(""); //每做完一列(i)就換行
}
}
}

-----------------執行結果如下--------------------------------