編集履歴

質問編集履歴

コード　わからないこと

2020/02/14 10:41

投稿

rikitaro

スコア6

title CHANGED Viewed

File without changes

body CHANGED Viewed

@@ -1,4 +1,423 @@
 Javaを使ってナベアツプログラムの進化系を作りたいと考えています。
 ナベアツ条件からナベアツの画像を出力するプログラムを作りたいのです。
 しかし条件から画像を入出力する方法がわかりません。
+現状でできている部分が電卓（電卓といってもウィンドウ上で単に計算するのみ）の部分のみとなり
+、それぞれの演算にいif文を追加しその条件から画像を出力するというプログラムが以下のものです。
+画像を読み->書き出す部分がどのようにifの中で呼び出すかがわかりません。
+```java
+import java.util.*;
+import java.math.*;
+import java.io.*;
+//画像を読む->画像を書き出す
+//読む部分
+BufferedImage bufferedImage = ImageIO.read(new File(ファイル名));
+//書き出す部分
+//フォーマット名->jpegとか
+ImageIO.write(bufferedImage, フォーマット名, new File(ファイル名));
+/**
+ * 「現在の結果＋環境（各変数の値）」というオブジェクト。
+ * 各演算子は、基本的にはこのオブジェクトの「現在の結果」部分を書き換えて戻す。
+ */
+class BIwithMem {
+    // ここらに必要なフィールドとメソッドの定義を入れる。コンストラクタも忘れずに。
+    /**
-よろしくお願いします
+     * 変数の値を取得。
+     * @param x 変数名。
+     * @return その変数に入っている値。なければ {@code null}。
+     */
+    private BigInteger val;
+    private HashMap<String, BigInteger>mem;
+    BIwithMem(){
+	val = BigInteger.ZERO;
+	mem = new HashMap<String, BigInteger>();
+    }
+    BigInteger getValue(){
+	return val;
+    }
+    void setValue(BigInteger bi){
+        val = bi;
+    }
+    void store(String x, BigInteger a){
+	mem.put(x, a);
+    }
+    BigInteger load(String x) {
+        BigInteger bi = mem.get(x);
+        if(bi == null) {
+            throw new RuntimeException("Unknown variable: " + x);
+        }
+        return bi;
+    }
+    /**
+     * このオブジェクトの文字列表現を返す。とりあえず「現在の結果」のみ。
+     * @return 文字列表現
+     */
+    public String toString() {
+        return val.toString();
+    }
+    /**
+     * 環境内の変数とその値の一覧の文字列。
+     * @return 環境内の変数とその値の一覧の文字列。
+     */
+    public String dumpVars() {
+        StringBuffer sb = new StringBuffer();
+        for(Map.Entry<String, BigInteger> e : mem.entrySet()) {
+            String var = e.getKey();
+            BigInteger bi = e.getValue();
+            sb.append(" " + var + " = " + bi + "¥n");
+        }
+        return sb.toString();
+    }
+}
+/**
+ * 単項演算子の雛形。"演算子" という行を受け付ける。
+ */
+abstract class MonoOpBIWM implements Command<BIwithMem> {
+    /**
+     * 演算子の文字列。
+     * @retrun 演算子の文字列。
+     */
+    abstract String opeStr();
+/**
+     * 演算子の中身。
+     * @param a 引数。
+     * @retrun 演算を適用した結果。
+     */
+    abstract BigInteger op(BigInteger a);
+    /**
+     * "演算子" という行を受け付ける。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        return tokens.length == 1 && tokens[0].equals(opeStr());
+    }
+    /**
+     * 演算子を適用する。演算の実体は {@code op} 。
+     * @param res 「現在の整数値＋環境」のオブジェクト。
+     * @return 「演算結果＋環境」のオブジェクト。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        res.setValue(op(res.getValue()));
+        return res;
+    }
+}
+/**
+ * "整数" or "変数" を読み込むためのベース。
+ */
+abstract class BIorVarWM implements Command<BIwithMem> {
+    /**
+     * 引数を整数にパースするか、変数だと思って環境から変数の値を取り出す。
+     * @param res 「現在の結果＋環境」のオブジェクト。
+     * @param arg 引数の文字列。
+     * @return 引数に対応した値。
+     */
+    BigInteger parseOrLoad(BIwithMem res, String arg) {
+        try {
+            return new BigInteger(arg); // 整数への変換を試す
+        } catch(NumberFormatException e){
+        }
+        BigInteger bi = res.load(arg); // ダメなら変数なのだろう
+        return bi;
+    }
+}
+/**
+ * 加減乗除などの、"演算子 引数" という行を受け付ける二項演算子の雛形2。
+ */
+abstract class BinOpBIWM extends BIorVarWM {
+    /**
+     * 演算子の文字列。
+     * @retrun 演算子の文字列。
+     */
+    abstract String opeStr();
+    /**
+     * 演算子の中身。
+     * @param a 第一引数。
+     * @param b 第二引数。
+     * @retrun 演算を適用した結果。
+     */
+    abstract BigInteger op(BigInteger a, BigInteger b);
+    /**
+     * オペランド。
+     */
+    String x;
+    /**
+     * "演算子 引数" という行を受け付ける（引数が整数か変数かは後で考える）。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        if(tokens.length != 2) return false;       // 引数があるか？
+        if(!tokens[0].equals(opeStr())) return false; // 最初が演算子か？
+        x = tokens[1];            // 整数 or 変数を記憶しておく
+        return true;   // ここまで来たら OK
+    }
+    /**
+     * 演算子を適用する。演算の実体は {@code op} 。
+     * @param res 「現在の整数値＋環境」のオブジェクト。
+     * @return 「演算結果＋環境」のオブジェクト。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        BigInteger bi = parseOrLoad(res, x);
+        res.setValue(op(res.getValue(), bi));
+        return res;
+    }
+}
+public class nabeatu extends Applet{
+  Image img;
+  public void init(){
+    img = getImage();
+  }
+/****** 諸々の普通の演算子の定義 ******/
+class NegBIWM extends MonoOpBIWM {
+  String opeStr() { return "neg"; }
+  BigInteger op(BigInteger a) {
+    BigInteger b = a.negate();
+    if(b % 3 == 0||(b % 10 == 3||b / 10 == 3)){
+    }
+	  return b;
+  }
+}
+class AddBIWM extends BinOpBIWM {
+  String opeStr() { return "+"; }
+  BigInteger op(BigInteger a, BigInteger b) {
+    BigInteger w = a.add(b);
+    if(w % 3 == 0||(w % 10 == 3||w / 10 == 3)){
+    }
+    return w;
+  }
+}
+class SubBIWM extends BinOpBIWM {
+  String opeStr() { return "-"; }
+  BigInteger op(BigInteger a, BigInteger b) {
+    BigInteger w = a.subtract(b);
+    if(w % 3 == 0||(w % 10 == 3||w / 10 == 3)){
+    }
+	  return w;
+  }
+}
+class MulBIWM extends BinOpBIWM {
+  String opeStr() { return "*"; }
+  BigInteger op(BigInteger a, BigInteger b) {
+    BigInteger w = a.multiply(b);
+    if(w % 3 == 0||(w % 10 == 3||w / 10 == 3)){
+    }
+  }
+}
+class DivBIWM extends BinOpBIWM {
+  String opeStr() { return "/"; }
+  BigInteger op(BigInteger a, BigInteger b) {
+    BigInteger w = a.divide(b);
+    if(w % 3 == 0||(w % 10 == 3||w / 10 == 3)){
+    }
+    return w;
+  }
+}
+class KAIJOBIWM extends MonoOpBIWM {
+  public boolean accept(String [] tokens) {
+    return tokens.length == 1 && tokens[0].equals(opeStr());
+  }
+  String opeStr() {return  "fact";}
+  public BigInteger op(BigInteger a){
+    BigInteger result = BigInteger.ONE;
+    int m = a.intValue();
+    for(int i = 1; i<= m; i++){
+      result = result.multiply(BigInteger.valueOf(i));
+    }
+    if(result % 3 == 0||(result % 10 == 3||result / 10 == 3)){
+      return result;
+    }
+  }
+}
+/****** 諸々の普通の演算子の定義 end ******/
+/**
+ * 現在の値を変数に代入する演算。
+ */
+class StoreBIWM implements Command<BIwithMem> {
+    /**
+     * 変数名。
+     */
+    String x;
+    /**
+     * "store 変数" という行を受け付ける。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        if(tokens.length != 2) return false;       // 引数があるか？
+        if(!tokens[0].equals("store")) return false; // 最初が演算子か？
+        x = tokens[1];            // 変数名を記録
+        return true;   // ここまで来たら OK
+    }
+    /**
+     * 変数に現在の結果を代入する（環境に記憶する）。
+     * @param res 「現在の結果＋環境」のオブジェクト。
+     * @return 「現在の結果＋新しい環境」のオブジェクト。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        res.store(x, res.getValue());
+        return res;
+    }
+}
+/**
+ * 変数の値を現在の結果にロードする演算。
+ */
+class LoadBIWM implements Command<BIwithMem> {
+    /**
+     * 変数名。
+     */
+    String x;
+    /**
+     * "load 変数" という行を受け付ける。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        if(tokens.length != 2) return false;       // 引数があるか？
+        if(!tokens[0].equals("load")) return false; // 最初が演算子か？
+        x = tokens[1];            // 変数名を記録
+        return true;   // ここまで来たら OK
+    }
+    /**憶し
+     * 変数の値を現在の結果に入れて返す。
+     * @param res 「現在の結果＋環境」のオブジェクト。
+     * @return 「その変数の値＋環境」のオブジェクト。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        BigInteger bi = res.load(x);
+        res.setValue(bi);
+        return res;
+    }
+}
+/**
+ * 環境内の変数の値を出力するメタ演算。
+ * "show" という行を受け付ける。
+ */
+class ShowVarsBIWM implements Command<BIwithMem> {
+    /**
+    憶し * "show" という行を受け付ける。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        return tokens.length == 1 && tokens[0].equals("show");
+    }
+    /**
+     * 環境を表示。
+     * @param res 「現在の結果＋環境」のオブジェクト。
+     * @return {@code res} をそのまま返す。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        System.out.println(res.dumpVars());
+        return res;
+    }
+}
+/**
+ * 横着をするための演算。
+ * "整数" or "変数" という行を受け付け、その値を現在の結果にセットする。
+ */
+class LoadImmBIWM extends BIorVarWM {
+    /**
+     * オペランド。
+     */
+    String x;
+    /**
+     * "整数" or "変数" という行を受け付ける（引数が整数か変数かは後で考える）。
+     * @param tokens 入力行をトークンに分解したもの。
+     * @return 入力行が上の形なら {@code true}。
+     */
+    public boolean accept(String [] tokens) {
+        if(tokens.length != 1) return false;       // トークン一つ？
+        x = tokens[0];       // 整数 or 変数を覚えておく
+        return true;   // ここまで来たら OK
+    }
+    /**
+     * 値を読み込む。
+     * @param res 「現在の整数値＋環境」のオブジェクト。
+     * @return 「演算結果＋環境」のオブジェクト。
+     */
+    public BIwithMem exec(BIwithMem res) {
+        BigInteger bi = parseOrLoad(res, x);
+        res.setValue(bi);
+        return res;
+    }
+}
+/**
+憶し * 「変数」を扱えるようにした電卓
+ */
+class BICalculatorWithVar {
+    public static void main(String [] args) throws Exception {
+        // 標準入力を読む準備
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        // 電卓のコマンドを用意
+        List<Command<BIwithMem>> cmds = new ArrayList<Command<BIwithMem>>();
+        cmds.add(new AddBIWM());
+        cmds.add(new SubBIWM());
+        cmds.add(new MulBIWM());
+        cmds.add(new DivBIWM());
+        cmds.add(new NegBIWM());
+	cmds.add(new KAIJOBIWM());
+        // ここらに自分で書いた "fact" 演算の登録を忘れずに。
+        cmds.add(new LoadBIWM());
+        cmds.add(new StoreBIWM());
+        cmds.add(new ShowVarsBIWM());
+        cmds.add(new LoadImmBIWM()); // これは最後に追加
+        // 電卓を生成
+        Calculator<BIwithMem> calc = new Calculator<BIwithMem>(cmds);
+        // 電卓を動かす
+        BIwithMem biwm = new BIwithMem();
+        calc.run(biwm, br);
+    }
+}
+コード
+```