海蓝博客

import java.util.ArrayList;
import java.util.List;

public class SplitOil {

  /**
   * 题目要求：一个桶中有12斤油，要求倒出6斤，可现在另外只有两个桶，分别可装8斤与5斤，请问应如何来倒？
   * 补充：这里的12,6,8,5都是变量，应该可以自己设置，输出是每一次分油的步骤。
   *
   * 题目可理解为对8和5进行加减，使之能产生6即可。
   * 其中，+代表往改桶里倒满油。-代表将该桶的里油全部倒出。
   * 此题的一个简单结果是8+8-5-5=6，这意味着，只要连续2次将8的桶灌满然后2次将5的桶灌满则8斤的桶里面剩下的刚好是6斤的油。
   * 由此可以归纳出来算法就是找到满足x*8+y*5使之满足最后所求即可，x和y是可正可负的一个系数。
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    List<OilQuestion> resultList = new ArrayList<OilQuestion>();
    int a=8;//桶1的容量
    int b=5;//桶2的容量
    int c=6;//要求的结果
    resultList=getXY(a,b,c);
    for(int i=0;i<resultList.size();i++){
      OilQuestion o = (OilQuestion)resultList.get(i);
      System.out.println("x="+o.getA()+";"+"y="+o.getB());
    }
  }
  
  public static List<OilQuestion> getXY(int a ,int b,int result){
    //考虑到可能有多种结果，所以把结果OilQuestion放到一个List当中，每一个OilQuestion是一个由a，b系数组成的对象
    //选出一个结果 为 result=x*a+y*b ,这里的x,y可正可负
    List<OilQuestion> resultList = new ArrayList<OilQuestion>();
    int max=50;
    int x=0;
    int y=0;
    for(int i=-max;i<max;i++)
      for(int j=-max;j<max;j++){
        if((i*a+j*b)==result) {
          x=i;
          y=j;
          OilQuestion o = new OilQuestion();
          o.setA(x);
          o.setB(y);
          resultList.add(o);
          }
        else continue;
      }
        
    return resultList;
  }
}

class OilQuestion{//定义一个内部类，该内部类有两个属性a和b
  int a;
  int b;
  public void setA(int a)
  {
    this.a=a;
  }
  public void setB(int b)
  {
    this.b=b;
  }
  public int getA(){
    return a;
  }
  public int getB(){
    return b;
  }
}

class StaticTest{
   int x=1;
   static int y=1;
}
class StaticTester{
  public static void main(String args[]){
    int i;
    StaticTest.y= StaticTest.y +1;
    StaticTest  m=new  StaticTest();
    StaticTest  n=new  StaticTest();
    m.x= m.x +3;
    m.y= m.y+3;
    n.x= n.x+5;
    n.y= n.y+5;
    System.out.println("m.x="+m.x+" "+ "m.y="+m.y);
    System.out.println("n.x="+n.x+" "+ "n.y="+n.y);
  }
}

package wenly.util;

import java.util.Stack;
import java.util.regex.*;

public class StringToArithmetic ...{
    private StringToArithmetic() ...{
    }

    /** *//**
     * 给出一个算术表达式，返回结果。 例如 (5+8+10)*1，返回23
     *
     * @param string
     */
    public static double stringToArithmetic(String string) ...{
        return postfixExprToArithmetic(prefixExprToPostfixExpr(string));
    }

    /** *//**
     * 中缀表达式转后缀表达式
     *
     * @param String
     *            prefix
     * @return String
     */
    private static String prefixExprToPostfixExpr(String prefix) ...{
        Stack<Character> stack = new Stack<Character>();
        String postfix = "";
        int length = prefix.length();
        for (int i = 0; i < length; i++) ...{
            Character temp;
            char c = prefix.charAt(i);
            switch (c) ...{
            // 忽略空格
            case ' ':
                break;
            // 碰到'('，push到栈
            case '(':
                stack.push(c);
                break;
            // 碰到'+''-'，将栈中所有运算符弹出，送到输出队列中
            case '+':
            case '-':
                while (stack.size() != 0) ...{
                    temp = stack.pop();
                    if (temp == '(') ...{
                        stack.push('(');
                        break;
                    }
                    postfix += " " + temp;
                }
                stack.push(c);
                postfix += " ";
                break;
            // 碰到'*''/'，将栈中所有乘除运算符弹出，送到输出队列中
            case '*':
            case '/':
                while (stack.size() != 0) ...{
                    temp = stack.pop();
                    if (temp == '(' || temp == '+' || temp == '-') ...{
                        stack.push(temp);
                        break;
                    } else ...{
                        postfix += " " + temp;
                    }
                }
                stack.push(c);
                postfix += " ";
                break;
            // 碰到右括号，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号
            case ')':
                while (stack.size() != 0) ...{
                    temp = stack.pop();
                    if (temp == '(')
                        break;
                    else
                        postfix += " " + temp;
                }
                postfix += " ";
                break;
            default:
                postfix += c;
            }
        }
        while (stack.size() != 0)
            postfix += " " + stack.pop();
        return postfix;
    }

    /** *//**
     * 通过后缀表达式求出算术结果
     *
     * @param String
     *            postfix
     * @return double
     */
    private static double postfixExprToArithmetic(String postfix) ...{
        Pattern pattern = Pattern.compile("\d+||\d+\.\d*"); // 匹配数字
        String strings[] = postfix.split(" ");
        for (int i = 0; i < strings.length; i++)
            strings[i].trim();
        Stack<Double> stack = new Stack<Double>();
        for (int i = 0; i < strings.length; i++) ...{
            if (strings[i].equals(""))
                continue;
            if ((pattern.matcher(strings[i])).matches()) ...{
                stack.push(Double.parseDouble(strings[i]));
            } else ...{
                double y = stack.pop();
                double x = stack.pop();
                stack.push(caculate(x, y, strings[i]));
            }
        }
        return stack.pop();
    }

    private static double caculate(double x, double y, String simble) ...{
        if (simble.trim().equals("+"))
            return x + y;
        if (simble.trim().equals("-"))
            return x - y;
        if (simble.trim().equals("*"))
            return x * y;
        if (simble.trim().equals("/"))
            return x / y;
        return 0;
    }
}