實現思路：因為手機感測器每隔一段時間會發送採集到的資料包， 首先獲取第一個資料包所在的三個軸的加速度值，記錄， 當過一段時間之後再次獲取三個軸的加速度值，計算增量，將相鄰兩個點的增量進行彙總，當達到預先設定的閥值，說明手機搖晃了。

實現步驟：
1、記錄第一個點的資料： 三個軸的加速度，為了遮蔽不同手機取樣的時間間隔差異，將第一個點的時間也記錄下 來。
2、選取第二個點的資料：當有新的感測器資料傳遞進來後，用當前的時間與第一個點的時間進行比對，判斷時間間 隔，如果滿足了時間間隔（經驗值：100）的要求，認為是合格的第二個點，否則捨棄改資料包。
3、 進行增量的計算：獲取到的新的加速度值與第一個點上的加速度值進行差值運算，獲取到一點和二點之間的增量，將三個增量值進行彙總。
4、以此類推，獲取到相鄰兩個點的增量，進行彙總。
5、通過彙總的值與之前設定好的閥值（經驗值：200）進行比對，如果>=閥值，使用者搖晃手機。否則記錄當前點的資料（加速度的值 和 該點的時間）。

一、核心感測器監聽程式碼：

package com.huang.mylottery.view.sensor;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.os.Vibrator;

/**
 * 處理感測器監聽
 *
 * @author wuseyukui
 *
 */
public abstract class
 
 ShakeListener implements SensorEventListener {

      // 判斷手機搖晃的閾值
      private final static float SWITH_VALUE = 200f;
      private final static long DURATION = 100;

      private Vibrator vibrator;

      private float lastX;
      private float lastY;
      private float lastZ;
      private long lastTime;
      private
 
 float total;

      public ShakeListener(Context context) {
             super();
             vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE );
      }


      private void initParam() {
             lastX = 0;
             lastY = 0;
             lastZ = 0;
             lastTime = 0;
             total = 0;
      }


      @Override
      public void onSensorChanged(SensorEvent event) {
             // 判斷 是否第一個點
             if ( lastX == 0 && lastY == 0 && lastZ == 0 && lastTime == 0) {
                   // 記錄三個軸的加速度值
                   float[] values = event. values;
                   lastX = values[0];
                   lastY = values[1];
                   lastZ = values[2];
                   lastTime = System. currentTimeMillis();
                   total = lastX + lastY + lastZ;

            } else {
                   // 儘可能遮蔽掉不同手機感測器的差異
                   if (System. currentTimeMillis() - lastTime > DURATION) {
                         float[] values = event. values;
                         // 第二個點及以後
                         float x = values[0];
                         float y = values[1];
                         float z = values[2];

                         // 計算增量
                         float dx = Math. abs(x-lastX);
                         float dy = Math. abs(y-lastY);
                         float dz = Math. abs(z-lastZ);

                         // 儘量遮蔽掉微小的增量值
                         if (dx < 1) {
                              dx = 0;
                        }
                         if (dy < 1) {
                              dy = 0;
                        }
                         if (dz < 1) {
                              dz = 0;
                        }

                         // 極個別手機，靜止狀態 某個軸的增量會大於1，10以上，甚至100以上
                         if (dx == 0 && dy == 0 && dz == 0) {
                              initParam();
                               return;
                        }

                         // 彙總(一點和二點總得增量)
                         float shake = dx + dy + dz;

                         if(shake == 0) {
                              initParam();
                               return;
                        }

                         total += shake;

                         if ( total >= SWITH_VALUE) {
                               // 手機搖晃了
                               // 機選一注彩票
                              RandomCure();
                               // 提示使用者
                               vibrator.vibrate(100);
                               // 所有的資料都要初始化
                              initParam();

                        } else {
                               lastX = x;
                               lastY = y;
                               lastZ = z;
                               lastTime = System. currentTimeMillis();
                        }
                  }
            }
      }


      public abstract void RandomCure();


      @Override
      public void onAccuracyChanged(Sensor sensor, int accuracy) {

      }

}


二、註冊監聽

listener = new ShakeListener(context){
      @Override
      public void RandomCure() {
     //機選一注
     randomSSQ();
   }
 };
 // 註冊感測器監聽
  sensor.registerListener( listener,
                          sensor.getDefaultSensor(Sensor. TYPE_ACCELEROMETER),
                          SensorManager. SENSOR_DELAY_FASTEST);

二、各種彩票的演算法

package cn.com.soarmobile.lottery;

import android.content.res.TypedArray;
import cn.com.soarmobile.SoarEngine;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;

/**
* Type代表彩種玩法(如：任選一、任選二); Mode代表選號型別(如：直選)
*
* @author Administrator
*
*/
public abstract class LotteryBase {
     /**
     * 彩種LOGO
     */
     public int icon;

     /**
     * 彩種名字 例如排列三
     */
     public String name;
     /**
     * 彩種名字編號 例如排列三:p3 雙色球:ssq
     */
     public String gameName;

     /**
     * 彩種代號 例如雙色球:001 福彩3D:002
     */
     public String code;
     /**
     * 官方規則
     */
     public int officialrule;

     /**
     * 獎金說明
     */
     public int prizeexplain;
     /**
     * 彩票期數 例如20110115
     */
     public String issue;
     /**
     * 彩種簡介，例如：天天排列3，不愁吃喝穿
     */
     public String summary;
     /**
     * 購買一注的價格
     */
     public int price;
     /**
     * 購買截止時間
     */
     public String deadLine;
     /**
     * 紅色選號區標籤 如只有紅色球 則顯示選號 藍球選號區域不顯示
     */
     public String redTag;
     /**
     * 藍色選號區標籤 如果木有藍球 該區域不顯示
     */
     public String buleTag;
     /**
     * 最少要選擇的紅球數 例如雙色球至少選6個紅球
     */
     public int redMin;
     /**
     * 最少要選擇的藍球數 例如雙色球至少選1個藍球 值可以為0
     */
     public int blueMin;
     /**
     * 選號規則介紹 例如 請選擇至少六個紅球和一個藍球
     */
     public String[] rules;
     /**
     * 當前模式選號規則
     */
     public String currentRule;
     /**
     * 彩種玩法，例如：任選一、任選二
     */
     public String[] playType;
     /**
     * 當前彩種玩法 <br>
     * 參照{@link #playType playType}
     */
     protected String currentType;
     /**
     * 機選玩法，例如：二星、三星、五星 <br>
     * 該玩法目前為{@link #playType playType}的子集
     */
     public String[] autoPlayType = null;

     /**
     * 選號型別，例如：直選、組選、通選
     */
     public String[] playMode;
     /**
     * 當前選號型別 <br>
     * 參照{@link #playMode playMode}
     */
     protected String currentMode;
     /**
     * 不同玩法 模式的注意事項提醒
     */
     public String[] notices;
     /**
     * 當前模式注意事項
     */
     public String currentNotice;

     /**
     * 是否允許追加
     */
     public boolean allowAddTo = false;
     /**
     * 是否格式化顯示號碼 例如 雙色球01，02，03
     */
     public boolean format = false;

     /**
     * 獲取紅球選號池 例如 :排列三{0,1,2,3,4,5,6,7,8,9} 選號型別和選號模式影響改返回值
     *
     * @return
     */
     /**
     * 根據playtype和playmode計算出來當前索引
     */
     public int currentIndex;

     public abstract int[] getRedPool();

     protected int[] getRedPool(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          int count = Integer.parseInt(string[1]);
          int start = Integer.parseInt(string[2]);
          int end = Integer.parseInt(string[3]);
          return CalculatorUtils.createBalls(count, start, end);
     }

     /**
     * 紅球選擇區的顯示時候的列數
     *
     * @return
     */
     public abstract int getRedColumnCount();

     protected int getRedColumnCount(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          return Integer.parseInt(string[0]);
     }

     /**
     * 獲取藍球選號池 例如排列三{0,1,2,3,4,5,6,7,8,9} 選號型別和選號模式影響改返回值
     *
     * @return
     */
     public abstract int[] getBluePool();

     protected int[] getBluePool(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          int count = Integer.parseInt(string[1]);
          int start = Integer.parseInt(string[2]);
          int end = Integer.parseInt(string[3]);
          return CalculatorUtils.createBalls(count, start, end);
     }

     /**
     * 藍球選擇區的顯示時候的列數
     *
     * @return
     */
     public abstract int getBlueColumnCount();

     protected int getBlueColumnCount(int resId) {
          String[] redrules = getStringArray(resId);
          String temp = redrules[currentIndex];
          String[] string = temp.split("-");
          return Integer.parseInt(string[0]);
     }

     /**
     * 機選紅球
     */
     public abstract int[] getRandomRed();

     /**
     * 機選藍球
     */
     public abstract int[] getRandomBlue();

     /**
     * 機選n注號碼
     * 返回int[][]
     */
     public abstract int[][] getRandom(int n);

     /**
     * 機選n注號碼
     * 返回String[]
     * 這樣就不用根據redMin blueMin判斷填充那種顏色了，
     * 減少彩種切換時對redMin和blueMin的管理
     */
     public abstract String[] getRandomString(int n);

     /**
     * 判斷當前選擇是否合法
     *
     * @param red
     * @param bule
     * @return
     */
     public abstract boolean isValid(int[] red, int[] bule);

     /**
     * 計算當前選了多少注 數學公式C(red,bule)或A(red,bule)
     *
     * @param red
     *            當前選擇的紅球
     * @param bule
     *            當前選擇的藍球
     * @return 計算出注數
     */
     public abstract long calculatorBoxes(int[] red, int[] bule);

     /**
     * 重新為預設設定
     */
     public abstract void reset(boolean isAutoToManual);

     /**
     * 根據plaype和playMode獲取索引 例如 福彩3d {直選 複式}對應索引0 {直選 單式}對應索引1 {組三 複式}對應索引2
     */
     public int getIndex(int resId) {
          int n = 0;
          for (int i = 0; i < playType.length; i++) {
               String[] strings = CountModeByType(resId, i);
               for (int j = 0; j < strings.length; j++) {
                    if (currentType.equals(playType[i])
                              && currentMode.equals(strings[j])) {
                         return n;
                    }
                    n++;
               }
          }

          for (int i = 0; i < playMode.length; i++) {
               if (currentMode.equals(playMode[i])) {
                    return n;
               }
               n++;
          }
          return n;
     }

     /**
     *
     * @return 獲取當前選擇playType的索引 例如 福彩3d {直選，組三，組六}對應的索引分別為{0,1,2}
     */
     public int getPlayTypeIndex() {
          for (int i = 0; i < playType.length; i++) {
               if (currentType.equals(playType[i])) {
                    return i;
               }

          }
          return 0;
     }

     /**
     *
     * @param resId
     *            R.array.xx_playmodes
     * @param index
     *            當前選擇playType的索引 例如 福彩3d {直選，組三，組六}對應的索引分別為{0,1,2}
     * @return 對應plaype下的playmodes 例如 福彩3d直選 {複式 單式}
     */
     public String[] CountModeByType(int resId, int index) {
          TypedArray typedArray = SoarEngine.getInstance().getResources()
                    .obtainTypedArray(resId);
          resId = typedArray.getResourceId(index, -1);
          return getStringArray(resId);

     }

     /**
     * 彩種playype發生變化 例如 福彩3d{直選 組三}
     */
     public abstract void notifyPlayTypeChanged();

     /**
     * 當有的彩種的玩法型別改變時，其redMin或buleMin的值會相應的被改變， 這種情況下，在具體的彩種類中要重寫該方法，使玩法型別與redMin
     * 和buleMin相對應。例如，11選5的玩法，任選二 任選三等的最小 紅球數不同，切換玩法型別時就要對redMin做相應的改變，否則在自選
     * 和機選間切換時會出問題，因為機選顯示號碼個數時會用到以上量值。 {@link #setCurrentMode(String)
     * setCurrentMode()}類似。
     *
     * @param currentType
     */
     public void setCurrentType(String currentType) {
          this.currentType = currentType;
          notifyPlayTypeChanged();
     }

     public String getCurrentType() {
          return currentType;
     }

     /**
     * 彩種playMode發生變化 例如 福彩3d{單式 複式}
     */
     public abstract void notifyPlayModeChanged();

     /**
     * 使用說明參考{@link #setCurrentType(String) setCurrentType}
     *
     * @return
     */
     public void setCurrentMode(String currentMode) {
          this.currentMode = currentMode;
          notifyPlayModeChanged();
     }

     public String getCurrentMode() {
          return currentMode;
     }

     /**
     *
     * @param resId
     *            R.arrat.xx_playmodes
     * @return 當前PlayType對應的PlayMode 例如 福彩3d直選{複式，單式}
     */
     public String[] getPlayModes(int resId) {
          TypedArray typedArray = SoarEngine.getInstance().getResources()
                    .obtainTypedArray(resId);
          resId = typedArray.getResourceId(getPlayTypeIndex(), -1);
          return getStringArray(resId);

     }

     protected String getString(int resId) {
          return SoarEngine.getInstance().getResources().getString(resId);
     }

     protected String[] getStringArray(int resId) {
          return SoarEngine.getInstance().getResources().getStringArray(resId);
     }

     protected int getInteger(int resId) {
          return SoarEngine.getInstance().getResources().getInteger(resId);

     }

     protected boolean getBoolean(int resId) {
          return SoarEngine.getInstance().getResources().getBoolean(resId);
     }

     /**
     * 判斷當前想要選擇的紅球是否能被選選擇
     *
     * @param selected
     *            當前已經選中的紅球
     * @param index
     *            想要選擇的紅球
     * @return
     */
     public abstract String canSelecteRed(int[] selected, int index);

     /**
     * 判斷當前想要選擇的藍球是否能被選選擇
     *
     * @param selected
     *            當前已經選中的藍球
     * @param index
     *            想要選擇的藍球
     * @return
     */
     public abstract String canSelecteBlue(int[] selected, int index);

     /**
     * 根據當前已選紅球和想要選擇的紅球計算出新的選中狀態
     *
     * @param selected
     *            當前已經選中的紅球
     * @param index
     * @return
     */
     public abstract int[][] newRedBalls(int[] selected, int index,
               boolean isCancel);

     /**
     * 根據當前已選紅球和想要選擇的藍球計算出新的選中狀態
     *
     * @param selected
     *            當前已經選中的紅球
     * @param index
     * @return
     */
     public abstract int[][] newblueBalls(int[] selected, int index,
               boolean isCancel);

     /**
     * 將當前已經選擇的紅球格式化為字串 例如 已經選擇3 6 7格式化為3，6，7
     *
     * @param text
     * @param index
     * @return
     */
     public abstract String formatSelectedRed(String[] texts, int[] indexs);

     /**
     * 將當前已經選擇的藍球格式化為字串 例如 已經選擇3 6 7格式化為3，6，7
     *
     * @param text
     * @param index
     * @return
     */
     public abstract String formatSelectedBlue(String[] texts, int[] indexs);

     //根據當前選號情況建立代表當前選好的彩票訂單專案
     /**
     * @param redpool 紅球
     * @param bluepool 藍球
     * @param result 方案資訊（X注X元）
     * @param zhuijia 是否追加
     */
     public abstract LotteryCartItem createLotteryCartItem(String redpool,String bluepool,String result,boolean zhuijia);

     public abstract int getTypeCodeByMode(String mode);
}

package cn.com.soarmobile.lottery;

import cn.com.soarmobile.R;
import cn.com.soarmobile.bean.LotteryCartItem;
import cn.com.soarmobile.util.CalculatorUtils;
import cn.com.soarmobile.util.StringUtil;

public class Lottery11x5 extends LotteryRed {
     public Lottery11x5() {
          icon = R.string.llx5_icon;
          name = getString(R.string.llx5_name);
          gameName = getString(R.string.llx5_game_name);
          code = getString(R.string.llx5_code);
          issue = getString(R.string.llx5_issue);
          summary = getString(R.string.llx5_summary);
          price = getInteger(R.integer.llx5_price);
          deadLine = getString(R.string.llx5_deadline);
          redTag = getString(R.string.llx5_redtag);
          buleTag = getString(R.string.llx5_bluetag);
          redMin = getInteger(R.integer.llx5_redmin);
          blueMin = getInteger(R.integer.llx5_bluemin);
          rules = getStringArray(R.array.llx5_rules);
          notices = getStringArray(R.array.llx5_notices);
          playType = getStringArray(R.array.llx5_playtypes);
          currentType = getString(R.string.llx5_defaulttype);
          playMode = getStringArray(R.array.llx5_playmodes);
          currentMode = getString(R.string.llx5_defaultmode);
          allowAddTo = getBoolean(R.integer.llx5_allowAdd);
          format = getBoolean(R.integer.llx5_format);
          officialrule = R.string.llx5_officialrule;
          prizeexplain = R.string.llx5_prizeexplain;
          autoPlayType = getStringArray(R.array.llx5_auto_playtypes);
          notifyPlayTypeChanged();
     }

     @Override
     public int[] getRedPool() {
          return super.getRedPool(R.array.llx5_redpools);
     }

     @Override
     public int getRedColumnCount() {
          return super.getRedColumnCount(R.array.llx5_redpools);
     }

     @Override
     public int[] getRandomRed() {
          int n = getIndex(R.array.llx5_playmodes);
          int column = getRedColumnCount();
          switch (n) {
          case 0:// 任一-直選
               return CalculatorUtils.getRandomArrayNumber(1, 0, 10);
          case 1:// 任二-直選
               return CalculatorUtils.getRandomArrayNumber(2, 0, 10);
          case 2:// 任三-直選
               return CalculatorUtils.getRandomArrayNumber(3, 0, 10);
          case 3:// 任四-直選
               return CalculatorUtils.getRandomArrayNumber(4, 0, 10);
          case 4:// 任五-直選
               return CalculatorUtils.getRandomArrayNumber(5, 0, 10);
          case 5:// 任六-直選
               return CalculatorUtils.getRandomArrayNumber(6, 0, 10);
          case 6:// 任七-直選
               return CalculatorUtils.getRandomArrayNumber(7, 0, 10);
          case 7:// 任八-直選
               return CalculatorUtils.getRandomArrayNumber(8, 0, 10);
          case 8:// 前二-直選
               int[] reds = CalculatorUtils.getRandomArrayNumber(2, 0, 10);
               for (int i = 0; i < reds.length; i++) {
                    reds[i] = reds[i] + column * i;
               }
               return reds;
          case 9:// 前二-組選
               return CalculatorUtils.getRandomArrayNumber(2, 0, 10);
          case 10:// 前三-直選
               reds = CalculatorUtils.getRandomArrayNumber(3, 0, 10);
               for (int i = 0; i < reds.length; i++) {
                    reds[i] = reds[i] + column * i;
               }
               return reds;
          case 11:// 前三-組選
               return CalculatorUtils.getRandomArrayNumber(3, 0, 10);

          }
          return null;

     }

     @Override
     public int[][] getRandom(int n) {
          if (n < 1) {
               n = 1;
          }
          int[][] result = new int[n][redMin];
          for (int i = 0; i < n; i++) {
               for (int j = 0; j < redMin; j++) {
                    result[i][j] = CalculatorUtils.getRandomNumber(1, 11);
               }
          }
          return result;
     }

     @Override
     public String[] getRandomString(int n) {
          if (n < 1) {
               n = 1;
          }
          String[] result = new String[n];
          StringBuffer sBuffer = new StringBuffer();
          for (int i = 0; i < n; i++) {
               sBuffer.delete(0, sBuffer.length());
               int[] nums = CalculatorUtils.getRandomArrayNumber(redMin, 1, 11);
               for (int j = 0; j < redMin; j++) {
                    sBuffer.append(StringUtil.format(nums[j]) + ",");
               }
               result[i] = sBuffer.toString().substring(0, sBuffer.length() - 1);
          }
          return result;
     }

     @Override
     public boolean isValid(int[] red, int[] bule) {
          if (red.length == 0)
               return false;

          switch (currentIndex) {
          case 0:// 任一-直選
               break;
          case 1:// 任二-直選
               break;
          case 2:// 任三-直選
               break;
          case 3:// 任四-直選
               break;
          case 4:// 任五-直選
               break;
          case 5:// 任六-直選
               break;
          case 6:// 任七-直選
               break;
          case 7:// 任八-直選
               break;
          case 8:// 前二-直選
               if (red[red.length - 1] / getRedColumnCount() != 1)
                    return false;
          case 9:// 前二-組選
               break;
          case 10:// 前三-直選
               if (red[red.length - 1] / getRedColumnCount() != 2)
                    return false;
          case 11:// 前三-組選
               break;

          }
          if (red.length < redMin)
               return false;
          return true;
     }

     @Override
     public long calculatorBoxes(int[] red, int[] blue) {
          if (!isValid(red, blue)) {
               return -1;
          }
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:
          case 1:
          case 2:
          case 3:
          case 4:
          case 5:
          case 6:
          case 7:// 任一-直選 到 任八-直選
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 8:// 前二-直選
               return CalculatorUtils.calculatorBoxs(red, column);
          case 9:// 前二-組選
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          case 10:// 前三-直選
               return CalculatorUtils.calculatorBoxs(red, column);
          case 11:// 前三-組選
               return CalculatorUtils.calculatorCombination(red.length, redMin);
          }
          return 0;
     }

     @Override
     public void reset(boolean isAutoToManual) {
          currentType = getString(R.string.llx5_defaulttype);
          if (isAutoToManual) {
               notifyPlayTypeChanged();
          }
     }

     @Override
     public void notifyPlayTypeChanged() {
          playMode = getPlayModes(R.array.llx5_playmodes);
          currentMode = playMode[0];
          notifyPlayModeChanged();
     }

     @Override
     public void notifyPlayModeChanged() {
          currentIndex = getIndex(R.array.llx5_playmodes);
          if (!StringUtil.isEmpty(rules))
               currentRule = rules[getIndex(R.array.llx5_playmodes)];
          if (!StringUtil.isEmpty(notices))
               currentNotice = notices[getIndex(R.array.llx5_playmodes)];
          switch (currentIndex) {
          case 0:// 任一-直選
               redMin = 1;
               break;
          case 1:// 任二-直選
               redMin = 2;
               break;
          case 2:// 任三-直選
               redMin = 3;
               break;
          case 3:// 任四-直選
               redMin = 4;
               break;
          case 4:// 任五-直選
               redMin = 5;
               break;
          case 5:// 任六-直選
               redMin = 6;
               break;
          case 6:// 任七-直選
               redMin = 7;
               break;
          case 7:// 任八-直選
               redMin = 8;
               break;
          case 8:// 前二-直選
               redMin = 2;
               break;
          case 9:// 前二-組選
               redMin = 2;
               break;
          case 10:// 前三-直選
               redMin = 3;
               break;
          case 11:// 前三-組選
               redMin = 3;
               break;

          }
     }

     @Override
     public String canSelecteRed(int[] selected, int index) {
          int column = getRedColumnCount();
          switch (currentIndex) {
          case 0:// 任一-直選
               break;
          case 1:// 任二-直選
               break;
          case 2:// 任三-直選
               break;
          case 3:// 任四-直選
               break;
          case 4:// 任五-直選
               break;
          case 5:// 任六-直選
               break;
          case 6:// 任七-直選
               break;
          case 7:// 任八-直選
               if(selected.length>=8){
                    return "最多隻能選8個號碼！";
               }
               break;
          case 8:// 前二-直選
               if (index / column == 0) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index + column) {
                              return "前二選號：各位不能重複";
                         }
                    }
               } else if (index / column == 1) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column) {
                              return "前二選號：各位不能重複";
                         }
                    }
               }

               break;
          case 9:// 前二-組選
               break;
          case 10:// 前三-直選

               if (index / column == 0) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index + column
                                   || selected[i] == index + 2 * column) {
                              return "前三選號：各位不能重複";
                         }
                    }
               } else if (index / column == 1) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column
                                   || selected[i] == index + column) {
                              return "前三選號：各位不能重複";
                         }
                    }
               } else if (index / column == 2) {
                    for (int i = 0; i < selected.length; i++) {
                         if (selected[i] == index - column
                                   || selected[i] == index - 2 * column) {
                              return "前三選號：各位不能重複";
                         }
                    }
               }
               break;
          case 11:// 前三-組選
               break;

          }
          return "yes";
     }

     public int[][] zhixuanrenyi(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = selected;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] zhixuan(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = null;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     public int[][] zuxuan(int[] selected, int index) {
          int[][] state = new int[2][];
          int[] remove = null;
          int[] add = new int[] { index };
          state[0] = add;
          state[1] = remove;
          return state;
     }

     @Override
     public int[][] newRedBalls(int[] selected, int index, boolean isCancel) {
          if (isCancel) {
               int[][] state = new int[2][];
               int[] remove = new int[] { index };
               int[] add = null;
               state[0] = add;
               state[1] = remove;
               return state;
          }
          int n = getIndex(R.array.llx5_playmodes);
          switch (n) {
          case 0:
               return zhixuanrenyi(selected, index);
           
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Android——手機彩票搖晃選號（雙色球） 實現原理
     
 
							
							
							實現思路：因為手機感測器每隔一段時間會發送採集到的資料包， 首先獲取第一個資料包所在的三個軸的加速度值，記錄， 當過一段時間之後再次獲取三個軸的加速度值，計算增量，將相鄰兩個點的增量進行彙總，當達到預先設定的閥值，說明手機搖晃了。

實現步驟： 
1、記錄第一個 

  
 

    

    
    
Android手機中取得當前時區（以GMT形式）
     
  
  
  
 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow
 
 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
 
 
          

  
 

    

    
    
從位元組碼看Java中for-each迴圈（增強for迴圈）實現原理
     
 
下面是的兩個很簡單的類，可以看出它們的功能是一樣的。Java環境使用的是jdk1.8_111。
package iter;

public class TestArray {
    public static void main(String[] args) {
        //String[] a  

  
 

    

    
    
用python程式設計 雙色球彩票系統（改良）
     
  
 
 # author : momo
'''
開始遊戲之後，請使用者輸入投入的金額，使用者可以選擇購買彩票的張數，
一張彩票是兩塊錢，當金額不足時，可以提示使用者繼續投入金額，
若使用者拒絕投入，則退出遊戲。
此時系統可以隨機產生一組資料，一組彩票資料有六位數，這六位數的的取值範圍是0和1。
若金額充足， 

  
 

    

    
    
android手機獲取SIM卡號
     
 
                適配Apple的最新三款手機iPhoneXs、iPhoneXs Max及iPhoneXr。2048 * 1536 是iPad Retina 的解析度。也是我們需要適配的裝置裡面解析度最高的。 所以我們在遊戲中都選擇了這個大小，讓它來相容解析度低的裝置。 在其他裝置上就用 As 

  
 

    

    
    
Android後臺模擬點選探索（附原始碼）
     
 
							
							
							本篇文章已授權微信公眾號 guolin_blog （郭霖）獨家釋出

工作中我們需要自制一套工具，其中遇到需要模擬點選事件的需求，類似按鍵精靈的功能，支援後臺持續執行，滿足觸發條件時完成點選。

經過一番探索，一共整理出兩種不同的方案：Accessibility 

  
 

    

    
    
Android listview 的 item 點選無效（無法獲取焦點）的解決方法
     
 
                
當listview的item中包含Button之類的空間時就會出現item無法響應事件 ，這是由於item的view中包含的button控制元件獲取了焦點；網上很多人給出的在item的根佈局屬性中新增  android:descendantFocusability="blo 

  
 

    

    
    
如何在Android手機上進行自動化測試（上）
     
 
版權宣告：允許轉載，但轉載必須保留原連結；請勿用作商業或者非法用途

前言
通過閱讀本節教程，你將瞭解到以下內容：

如何在指令碼程式碼中、執行指令碼時指定手機
如何填寫--device Android:///的內容
如何便捷地在指令碼中呼叫ADB指令或Android專屬介面

連線Android手機
在A 

  
 

    

    
    
如何在Android手機上進行自動化測試（下）
     
 
版權宣告：允許轉載，但轉載必須保留原連結；請勿用作商業或者非法用途

前言
通過閱讀本篇教程，你將會了解到：

如何使用Poco對Android原生應用進行測試

Poco支援直接對任何Android原生應用（非遊戲引擎、非webview）進行UI層次結構識別，用法上與Poco在其他平臺上一模一樣。
注：基 

  
 

    

    
    
Android Api Demos登頂之路（四十五）Loader--&gt;Cursor
     
 adapt   lists   清空   function   icon   創建   nal   pat   lines   
        這個demo演示了類載入器的用法。關於類載入器的使用我們在前面的demo中已經介紹過了 在此再小小的復習一下。類載入器的使用步驟： 
     * 1.獲取類載入 

  
 

    

    
    
Java  用兩個一維數組實現雙色球彩票
     
 flag   true   模擬   用兩個   div   for   arr   全部   lean   

設計一個程序，模擬雙色球的選號過程（6個藍球+1個紅球），
要求：生成的6個紅球號碼不重復數字大小在（1-33）之間，藍球大小（1-16）之間。
思路：
1、創建一個int類型的一維數組balls 

  
 

    

    
    
Android動畫效果之Frame Animation（逐幀動畫）
     
 想要   顯示   star   載體   rop   復雜   ide   sources   post   前言：
      上一篇介紹了Android的Tween Animation（補間動畫） Android動畫效果之Tween Animation（補間動畫），今天來總結下Android的另外一種動 

  
 

    

    
    
linux服務器外網內網（雙網絡）搭建
     
 失敗   work   網線   網卡名   找到   改錯   ethernet   關於   不清楚   　　　　一共有2臺服務器，分別用a,b表示。a雙網卡，即有外網也有內網。b只有內網環境。a,b的內網是通過交換機組建。至於外網怎麽搭建我就不說了。關鍵說一說內網是怎麽組建的。
　　　　如果你對linu 

  
 

    

    
    
Tarjan三大算法之雙連通分量（雙連通分量） （轉載）
     
 進行   ack   clear   例題   min   路徑   ace   相關   重復   定義：  對於一個連通圖，如果任意兩點至少存在兩條點不重復路徑，則稱這個圖為點雙連通的（簡稱雙連通）；如果任意兩點至少存在兩條邊不重復路徑，則稱該圖為邊雙連通的。點雙連通圖的定義等價於任意兩條邊都同在一個簡單 

  
 

    

    
    
移動端二三事【四】：陀螺儀（重力感應器）實現手機位置、加速度感應以及常見應用。
     
 效果   防止   size   tro   通過   select   代碼   陀螺儀   prime   首先說明一下：陀螺儀感應需在真機環境下進行調試，PC端無效果。
1.獲取感應器
需在window上監聽devicemotion事件，再通過事件對象獲取accelerationIncludingG 

  
 

    

    
    
模擬雙色球彩票開獎結果：隨機生成一註雙色球彩票.......
     
 tint   ack   模擬雙色球   test   nbsp   next   2-2   彩票   返回   模擬雙色球彩票開獎結果：隨機生成一註雙色球彩票，判斷其是否中獎，獎金為多少。一註雙色球彩票由6個不重復的紅球（序號：1~32）和1個籃球（序號：1~16）構成。雙色球中獎規則如下：

（提示：① 

  
 

    

    
    
Android------Button 添加聲音效果（兩種方式）
     
 div   abs   一次   播放   pool   當前   傳送門   ide   col   我在先前的案例《Android 的底部導航欄 BottomNavigationBar》中添加以底部
的4個按鈕切換添加聲音
下來看看案例效果圖
              
 
使用添加依賴
 

comp 

  
 

    

    
    
數據庫  之  Mysql的主主同步（雙主模型）
     
 兩個   white   serve   執行   密碼連接   進行   st3   提交   復制   1  概述互為主從：兩個節點各自都要開啟binlog和relay log；	1、數據不一致；	2、自動增長id；為了防止id沖突，解決辦法是一個服務器使用奇數id，另一個服務器使用偶數id,合並的時候一 

  
 

    

    
    
PHP實現簡單的雙色球機選號碼
     
 tex   ima   實現簡單   組成   輸出   img   簡單的   push   each   
<?php
header(‘Content-Type: text/html; charset=utf-8‘);


//PHP實現雙色球機選號碼

$red = range(1, 33);// 

  
 

    

    
    
手機自動化測試環境搭建（eclipse+python+uiautomator）
     
 list   fig   finish   java環境   pda   所有   開發   界面   自己   最近在公司做了一個階段的手機APP自動化測試，是在已有的環境基礎上進行腳本開發，所有對基礎的環境搭建不是很清楚，後來自己閑來無事就在家裏搭建了一下下，接下來和大家分享一下搭建過程。
一：搭建手機A