android演算法題
1. android 面試，演算法題。
final int size = data.length;
for(int i = 0; i< size; i++){
if(data[i] == 0xffffffff)
data[i] = 0x80ffffff;
}
不知道你是不是這個意思。
2. 畢業設計選了用android做一個3d魔方的游戲，應為android以前沒接觸過的，要從頭開始學的。這個難嗎高手
只要java好就沒有問題，這是3D魔方android的源碼。
package com.example.android.image3D;
import android.view.SurfaceView;
import android.view.SurfaceHolder;
import android.content.Context;
import android.util.AttributeSet;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;
public class View3D extends SurfaceView implements SurfaceHolder.Callback {
private static final Semaphore sEglSemaphore = new Semaphore(1);
private boolean mSizeChanged = true;
private SurfaceHolder mHolder;
private GLThread mGLThread;
private GLWrapper mGLWrapper;
public View3D(Context context) {
super(context);
init();
}
public View3D(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mHolder = getHolder();
mHolder.addCallback(this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}
public SurfaceHolder getSurfaceHolder() {
return mHolder;
}
public void setGLWrapper(GLWrapper glWrapper) {
mGLWrapper = glWrapper;
}
public void setRenderer(Renderer renderer) {
mGLThread = new GLThread(renderer);
mGLThread.start();
}
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder,
int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}
public void onPause() {
mGLThread.onPause();
}
public void onResume() {
mGLThread.onResume();
}
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
mGLThread.onWindowFocusChanged(hasFocus);
}
public void queueEvent(Runnable r) {
mGLThread.queueEvent(r);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mGLThread.requestExitAndWait();
}
public interface GLWrapper {
GL wrap(GL gl);
}
public interface Renderer {
int[] getConfigSpec();
void surfaceCreated(GL10 gl);
void sizeChanged(GL10 gl, int width, int height);
void drawFrame(GL10 gl);
}
private class EglHelper {
EGL10 mEgl;
EGLDisplay mEglDisplay;
EGLSurface mEglSurface;
EGLConfig mEglConfig;
EGLContext mEglContext;
public EglHelper() {
}
public void start(int[] configSpec){
mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1,
num_config);
mEglConfig = configs[0];
mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig,
EGL10.EGL_NO_CONTEXT, null);
mEglSurface = null;
}
public GL createSurface(SurfaceHolder holder) {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
}
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay,
mEglConfig, holder, null);
mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext);
GL gl = mEglContext.getGL();
if (mGLWrapper != null) {
gl = mGLWrapper.wrap(gl);
}
return gl;
}
public boolean swap() {
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;
}
public void finish() {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
mEgl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}
}
class GLThread extends Thread {
private boolean mDone;
private boolean mPaused;
private boolean mHasFocus;
private boolean mHasSurface;
private boolean mContextLost;
private int mWidth;
private int mHeight;
private Renderer mRenderer;
private ArrayList<Runnable>
mEventQueue = new ArrayList<Runnable>();
private EglHelper mEglHelper;
GLThread(Renderer renderer) {
super();
mDone = false;
mWidth = 0;
mHeight = 0;
mRenderer = renderer;
setName("GLThread");
}
@Override
public void run() {
try {
try {
sEglSemaphore.acquire();
} catch (InterruptedException e) {
return;
}
guardedRun();
} catch (InterruptedException e) {
} finally {
sEglSemaphore.release();
}
}
private void guardedRun() throws InterruptedException {
mEglHelper = new EglHelper();
int[] configSpec = mRenderer.getConfigSpec();
mEglHelper.start(configSpec);
GL10 gl = null;
boolean tellRendererSurfaceCreated = true;
boolean tellRendererSurfaceChanged = true;
while (!mDone) {
int w, h;
boolean changed;
boolean needStart = false;
synchronized (this) {
Runnable r;
while ((r = getEvent()) != null) {
r.run();
}
if (mPaused) {
mEglHelper.finish();
needStart = true;
}
if(needToWait()) {
while (needToWait()) {
wait();
}
}
if (mDone) {
break;
}
changed = mSizeChanged;
w = mWidth;
h = mHeight;
mSizeChanged = false;
}
if (needStart) {
mEglHelper.start(configSpec);
tellRendererSurfaceCreated = true;
changed = true;
}
if (changed) {
gl = (GL10) mEglHelper.createSurface(mHolder);
tellRendererSurfaceChanged = true;
}
if (tellRendererSurfaceCreated) {
mRenderer.surfaceCreated(gl);
tellRendererSurfaceCreated = false;
}
if (tellRendererSurfaceChanged) {
mRenderer.sizeChanged(gl, w, h);
tellRendererSurfaceChanged = false;
}
if ((w > 0) && (h > 0)) {
mRenderer.drawFrame(gl);
mEglHelper.swap();
}
}
mEglHelper.finish();
}
private boolean needToWait() {
return (mPaused || (! mHasFocus) || (! mHasSurface) || mContextLost)
&& (! mDone);
}
public void surfaceCreated() {
synchronized(this) {
mHasSurface = true;
mContextLost = false;
notify();
}
}
public void surfaceDestroyed() {
synchronized(this) {
mHasSurface = false;
notify();
}
}
public void onPause() {
synchronized (this) {
mPaused = true;
}
}
public void onResume() {
synchronized (this) {
mPaused = false;
notify();
}
}
public void onWindowFocusChanged(boolean hasFocus) {
synchronized (this) {
mHasFocus = hasFocus;
if (mHasFocus == true) {
notify();
}
}
}
public void onWindowResize(int w, int h) {
synchronized (this) {
mWidth = w;
mHeight = h;
mSizeChanged = true;
}
}
public void requestExitAndWait() {
synchronized(this) {
mDone = true;
notify();
}
try {
join();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
public void queueEvent(Runnable r) {
synchronized(this) {
mEventQueue.add(r);
}
}
private Runnable getEvent() {
synchronized(this) {
if (mEventQueue.size() > 0) {
return mEventQueue.remove(0);
}
}
return null;
}
}
}
3. 五子棋人機簡單演算法,根據下面演算法描述寫代碼，代碼附解釋（android）
這是問題？還是論文？
是否考慮一下棋譜匹配演算法？
4. Android中%和&&是什麼演算法
%是取余數 5%2 =1
/是取整數 5/2 =2
&&是「並且」的意思
5. Android開發計步器，求解釋代碼、、、求大神！
著急的計算，是走動時手機的顫動，這是根據重力感應計算
6. android md5 演算法那麼多哪個是對的
在Java中，java.security.MessageDigest （rt.jar中）已經定義了 MD5 的計算，所以我們只需要簡單地調用即可得到 MD5 的128 位整數。然後將此 128 位計 16 個位元組轉換成 16 進製表示即可。
下面是一個可生成字元串或文件MD5校驗碼的例子，測試過，可當做工具類直接使用，其中最主要的是getMD5String(String s)和getFileMD5String(File file)兩個方法，分別用於生成字元串的md5校驗值和生成文件的md5校驗值，getFileMD5String_old(File file)方法可刪除，不建議使用：
Java代碼
package com.why.md5;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Util {
/**
* 默認的密碼字元串組合，用來將位元組轉換成 16 進製表示的字元,apache校驗下載的文件的正確性用的就是默認的這個組合
*/
protected static char hexDigits[] = { '0' , '1' , '2' , '3' , '4' , '5' , '6' ,
'7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };
protected static MessageDigest messagedigest = null ;
static {
try {
messagedigest = MessageDigest.getInstance("MD5" );
} catch (NoSuchAlgorithmException nsaex) {
System.err.println(MD5Util.class .getName()
+ "初始化失敗，MessageDigest不支持MD5Util。" );
nsaex.printStackTrace();
}
}
/**
* 生成字元串的md5校驗值
*
* @param s
* @return
*/
public static String getMD5String(String s) {
return getMD5String(s.getBytes());
}
/**
* 判斷字元串的md5校驗碼是否與一個已知的md5碼相匹配
*
* @param password 要校驗的字元串
* @param md5PwdStr 已知的md5校驗碼
* @return
*/
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
/**
* 生成文件的md5校驗值
*
* @param file
* @return
* @throws IOException
*/
public static String getFileMD5String(File file) throws IOException {
InputStream fis;
fis = new FileInputStream(file);
byte [] buffer = new byte [ 1024 ];
int numRead = 0 ;
while ((numRead = fis.read(buffer)) > 0 ) {
messagedigest.update(buffer, 0 , numRead);
}
fis.close();
return bufferToHex(messagedigest.digest());
}
/**
* JDK1.4中不支持以MappedByteBuffer類型為參數update方法，並且網上有討論要慎用MappedByteBuffer，
* 原因是當使用 FileChannel.map 方法時，MappedByteBuffer 已經在系統內佔用了一個句柄，
* 而使用 FileChannel.close 方法是無法釋放這個句柄的，且FileChannel有沒有提供類似 unmap 的方法，
* 因此會出現無法刪除文件的情況。
*
* 不推薦使用
7. android加密演算法有哪些
android中用的到加密：
Https編程 :應該是使用帶安全的網路協議處理。除非你本地需要加密
2.數據簽名：混淆代碼和防二次打包的APK加密技術
3.對稱加密：可以先將數據通過某種加密方式加密發送到伺服器端，然後伺服器端再解密 ，項目中除了登陸，支付等介面採用rsa非對稱加密，之外的採用aes對稱加密
4.非對稱加密====支付寶
數字摘要是指通過演算法將長數據變為短數據，通常用來標識數據的唯一性，是否被修改，常用的加密演算法有md5和sha1兩種，如Android的App簽名也是用的這兩種演算法。
由於以上兩種生成數字摘要的演算法都是不可逆的，對於可逆的加密演算法中，按照密鑰的數量和加密規則一半分為對稱加密和非對稱加密兩類：
對稱加密：
密鑰可以自己指定，只有一把密鑰，如果密鑰泄漏數據就會暴漏；
常用的對稱加密演算法有DES和AES兩種；
特點是加密速度快，但是缺點是安全性低，因為只要密鑰暴漏，數據就可以被解密。
非對稱加密的特點：
常見的非對稱加密演算法是RSA；
他有兩把密鑰，且是由程序生成的，不能自己指定；
特點是加密速度比較慢，但是安全性比較高；
加密和解密的規則是：公鑰加密只能私鑰解密，私鑰加密只能公鑰解密；
8. android寫一個演算法求12和8的最大公約數
classex1
{
intgys1(intm,intn)//循環實現
{
intk,y;
if(m<n)
{
k=m;
m=n;
n=k;
}
while(m%n!=0)
{
y=m%n;
m=n;
n=y;
}
returnn;
}
intgys2(intm,intn)//遞歸實現
{
intk,y;
if(m<n)
{
k=m;
m=n;
n=k;
}
y=m%n;
if(y==0)
{
returnn;
}
else
{
m=n;
n=y;
returngys2(m,n);
}
}
publicstaticvoidmain(String[]args)
{
ex1e1=newex1();
System.out.println(e1.gys1(12,8));
ex1e2=newex1();
System.out.println(e1.gys2(12,8));
}
}
9. android 面試題
1、前言
6 月 26 日， Google Android 發布了 NDK ，引起了很多發人員的興趣。 NDK 全
稱： Native Development Kit 。下載地址為：
http://developer.android.com/sdk/ndk/1.5_r1/index.html 。
2、誤解
新出生的事物，除了驚喜外，也會給我們帶來一定的迷惑、誤解。
2.1、誤解一： NDK 發布之前， Android 不支持進行 C 開發
在 Google 中搜索 「NDK」 ，很多 「Android 終於可以使用 C++ 開發 」 之類
的標題，這是一種對 Android 平台編程方式的誤解。其實， Android 平台從誕生起，就已
經支持 C 、 C++ 開發。眾所周知， Android 的 SDK 基於 Java 實現， 這意味著基於 Android
SDK 進行開發的第三方應用都必須使用 Java 語言。但這並不等同於 「 第三方應用只能使
用 Java」 。在 Android SDK 首次發布時， Google 就宣稱其虛擬機 Dalvik 支持 JNI 編程
方式，也就是第三方應用完全可以通過 JNI 調用自己的 C 動態庫，即在 Android 平台上，
「Java+C」 的編程方式是一直都可以實現的。
當然這種誤解的產生是有根源的：在 Android SDK 文檔里，找不到任何 JNI 方面的
幫助。即使第三方應用開發者使用 JNI 完成了自己的 C 動態鏈接庫（ so ）開發，但是 so
如何和應用程序一起打包成 apk 並發布？這裡面也存在技術障礙。我曾經花了不少時間，
安裝交叉編譯器創建 so ，並通過 asset （資源）方式，實現捆綁 so 發布。但這種方式只
能屬於取巧的方式，並非官方支持。所以，在 NDK 出來之前，我們將 「Java+C」 的開發
模式稱之為灰色模式，即官方既不聲明 「 支持這種方式 」 ，也不聲明 「 不支持這種方
式 」 。
2.2、誤解二：有了 NDK ，我們可以使用純 C 開發 Android 應用
Android SDK 採用 Java 語言發布，把眾多的 C 開發人員排除在第三方應用開發外
（ 注意：我們所有討論都是基於「 第三方應用開發 」 ， Android 系統基於 Linux ，系
統級別的開發肯定是支持 C 語言的。 ）。 NDK 的發布，許多人會誤以為，類似於 Symbian 、
WM ，在 Android 平台上終於可以使用純 C 、 C++ 開發第三方應用了！其實不然， NDK
文檔明確說明： it is not a good way 。因為 NDK 並沒有提供各種系統事件處理支持，也沒
有提供應用程序生命周期維護。此外，在本次發布的 NDK 中，應用程序 UI 方面的 API 也
沒有提供。至少目前來說，使用純 C 、 C++ 開發一個完整應用的條件還不完備。
3、NDK 是什麼
對 NDK 進行了粗略的研究後，我對 「NDK 是什麼 」 的理解如下：
1、NDK 是一系列工具的集合。
NDK 提供了一系列的工具，幫助開發者快速開發 C （或 C++ ）的動態庫，並能自動
將 so 和 java 應用一起打包成 apk 。這些工具對開發者的幫助是巨大的。
NDK 集成了交叉編譯器，並提供了相應的 mk 文件隔離 CPU 、平台、 ABI 等差異，
開發人員只需要簡單修改 mk 文件（指出 「 哪些文件需要編譯 」 、 「 編譯特性要求 」
等），就可以創建出 so 。
NDK 可以自動地將 so 和 Java 應用一起打包，極大地減輕了開發人員的打包工作。
2、NDK 提供了一份穩定、功能有限的 API 頭文件聲明。
oogle 明確聲明該 API 是穩定的，在後續所有版本中都穩定支持當前發布的 API 。
從該版本的 NDK 中看出，這些 API 支持的功能非常有限，包含有： C 標准庫（ libc ）、
標准數學庫（ libm ）、壓縮庫（ libz ）、 Log 庫（ liblog ）。
G
4、NDK 帶來什麼
1、NDK 的發布，使 「Java+C」 的開發方式終於轉正，成為官方支持的開發方式。
使用 NDK ，我們可以將要求高性能的應用邏輯使用 C 開發，從而提高應用程序的執
行效率。
使用 NDK ，我們可以將需要保密的應用邏輯使用 C 開發。畢竟， Java 包都是可以反
編譯的。
NDK 促使專業 so 組件商的出現。（樂觀猜想，要視乎 Android 用戶的數量）
2、NDK 將是 Android 平台支持 C 開發的開端。
NDK 提供了的開發工具集合，使開發人員可以便捷地開發、發布 C 組件。同時，
Google 承諾在 NDK 後續版本中提高 「 可調式 」 能力，即提供遠程的 gdb 工具，使我
們可以便捷地調試 C 源碼。在支持 Android 平台 C 開發，我們能感覺到 Google 花費了
很大精力，我們有理由憧憬 「C 組件支持 」 只是 Google Android 平台上 C 開發的開端。
畢竟， C 程序員仍然是碼農陣營中的絕對主力，將這部分人排除在 Android 應用開發之外，
顯然是不利於 Android 平台繁榮昌盛的。
10. android消滅星星尋找相同星星演算法（不用任何游戲引擎：如Cocos2dx...)
如果要代碼的話，我也沒有，不過網上應該能搜到吧。要思路的話，可以一起討論討論