算法一直是自己的弱项 通过算法来学习语言吧
Java版：
/**
* 算法练习 1
* Created by Exile on 2017/5/25.
* 1 N（N为偶数）个数字，把数字平分 N/2 组，使得每组的数字和相等。
*/
public class ArithmeticTest1 {
// 题目1偶数个数组
public static void main(String[] args) {
int[] evenNumberArry = new int[]{1, 7, 2, 7, 6, 5, 2, 8, 3, 4};
int arryNum = evenNumberArry.length / 2;
// 1 计算sum;
int sum = 0;
for (int i : evenNumberArry) {
sum = sum + i;
}
// 2 计算出每组的和是多少
int arryMax = sum / arryNum;
for (int i = 0; i < evenNumberArry.length; i++) {
int value = arryMax - evenNumberArry[i];
int temp;
// 假定一定会有一个与之组成一组
for (int j = i + 1; j < evenNumberArry.length; j++) {
if (evenNumberArry[j] == value) {
temp = evenNumberArry[i + 1];
evenNumberArry[i + 1] = value;
evenNumberArry[j] = temp;
}
}
}
for (int i : evenNumberArry) {
System.out.println(i);
}
}
}
import java.util.ArrayList;
import java.util.Random;
/**
* 算法练习 2
* Created by Exile on 2017/5/25.
* NxN的棋盘，每个格子可以放一个车，有M个车，问：每个车放完后，棋盘还剩多少格子是所有车攻击范围外？
* 车可以重叠
*/
public class ArithmeticTest2 {
public static void main(String[] args) {
// n和m
int m = 3;
int n = 3;
ArrayList<Model> modelList = createModelList(m, n);
ArrayList<Model> manList = new ArrayList<>();
for (Model model : modelList) {
System.out.println("当前model：" + model.toString());
}
// 方法1：从头到尾撸一遍
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
manList.add(new Model(i, j));
}
}
System.out.println("筛选前：" + manList.size());
// 速度太快的话会出问题
for (int i = 0; i < modelList.size(); i++) {
for (int j = 0; j < manList.size(); j++) {
if (!modelList.get(i).getAttackOutCall(manList.get(j))) {
manList.remove(j);
}
}
}
// }
System.out.println("筛选后：" + manList.size());
for (Model model : manList) {
System.out.println(model.toString());
}
}
/**
* 根据输入的mn生成对应个数的m对象
*
* @param m
* @param n
* @return
*/
private static ArrayList<Model> createModelList(int m, int n) {
ArrayList<Model> models = new ArrayList<>();
for (int i = 0; i < m; i++) {
models.add(new Model(n));
}
return models;
}
public static class Model {
private int x;
private int y;
public Model(int n) {
Random random = new Random();
this.x = random.nextInt(n);
this.y = random.nextInt(n);
}
public Model(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
@Override
public String toString() {
return "Model{" +
"x=" + x +
", y=" + y +
'}';
}
public boolean getAttackOutCall(Model mainModel) {
if (this.getX() == mainModel.getX() || this.getY() == mainModel.getY()) {
return false;
}
return true;
}
}
}
算法练习3：
package com.test.demo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
public class TestDemo {
/**
* 题目大意：N个字符串，找到最短的区间，包含所有字符串出现过的字符，输出区间长度。
代码实现：
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String string = "sadasdasdasdasd";
int type = 3;
// 1将字符串转化成char Arry
char[] charArray = string.toCharArray();
// 2 用一个Map集合来存储
HashMap<Character,Integer> hashSet = new HashMap<>();
// 3用来存储各种情况的实例
ArrayList<HashMap<Character,Integer>> arrayList = new ArrayList<HashMap<Character, Integer>>();
for (int i = 0; i < charArray.length; i++) {
// 把每个字符都放入map当中
hashSet.put(charArray[i], i);
// 如果不满足长度条件就不进行比较
if(hashSet.entrySet().size()<type){
continue;
}
arrayList.add((HashMap<Character, Integer>) hashSet.clone());
}
// 展示实例情况
for (int i = 0; i < arrayList.size(); i++) {
// System.out.println(arrayList.get(i).toString());
// 对实例的步长进行排序
Set<Entry<Character,Integer>> entrySet = arrayList.get(i).entrySet();
int max = 0;
int min = 0;
boolean isFirst = true;
for (Iterator iterator = entrySet.iterator(); iterator.hasNext();) {
Entry<Character, Integer> entry = (Entry) iterator.next();
max = entry.getValue()>max?entry.getValue():max;
if (isFirst) {
isFirst = false;
min = entry.getValue();
}
min = entry.getValue()<min?entry.getValue():min;
}
System.out.println("集合对象为："+arrayList.get(i).toString());
System.out.println("步长为："+(max-min));
}
}
}
golang版：
package main
import (
p "fmt"
)
//创建数组
var intArry = [...]int{1, 3, 2, 4, 5, 6, 7, 8}
func main() {
p.Println("Hello, Demo 01!")
//1计算总的sum
sum := 0
arryCount := len(intArry) / 2
for i := 0; i < len(intArry); i++ {
sum = sum + intArry[i]
}
p.Println("总和是：", sum)
//2计算每组的和是多少
itmeSum := sum / arryCount
p.Println("每组和是：", itmeSum)
for i := 0; i < len(intArry); i++ {
value := itmeSum - intArry[i]
for j := i + 1; j < len(intArry); j++ {
if intArry[j] == value {
p.Println("满足条件：", value)
p.Println("满足条件item角标：", j)
// temp := intArry[i+1]
// intArry[i+1] =
intArry[j], intArry[i+1] = swap(intArry[i+1], intArry[j])
}
// temp := intArry[i]
}
}
for k := 0; k < len(intArry); k++ {
p.Println("最后的遍历：", intArry[k])
}
}
func swap(value int, value2 int) (int, int) {
return value, value2
}
package main
import (
"fmt"
"math/rand"
)
/*算法练习2
这次的练习主要以 构造对象为主
NxN的棋盘，每个格子可以放一个车，有M个车，问：每个车放完后，棋盘还剩多少格子是所有车攻击范围外？
*/
func main() {
// 初始化m，n m个车nXn的棋盘
m, n := 3, 3
fmt.Println("m:", m)
fmt.Println("n:", n)
// 随机生成指定位置的车
calls := createRandomCalls(m, n)
fmt.Println(calls)
// 生成一个棋盘所有的call
allCalls := make([]Call, 0)
for x := 0; x < n; x++ {
for y := 0; y < n; y++ {
call := Call{x: x, y: y}
allCalls = append(allCalls, call)
}
}
fmt.Println(allCalls)
for j := 0; j < len(calls); j++ {
for i := 0; i < len(allCalls); i++ {
if allCalls[i].x == calls[j].x || allCalls[i].y == calls[j].y {
allCalls = append(allCalls[:i], allCalls[i+1:]...)
}
}
}
fmt.Println(allCalls)
}
//构造一个行列模型
type Call struct {
x int
y int
}
// 创建一个随机的列表
func createRandomCalls(m int, n int) []Call {
randomCalls := make([]Call, 3)
for i := 0; i < len(randomCalls); i++ {
call := Call{}
call.x = rand.Intn(n)
call.y = rand.Intn(n)
// randomCalls[i] = call
randomCalls[i] = call
}
// randomCalls = append(randomCalls, Call{x: 1, y: 2})
return randomCalls
}
网友评论