fork(2) download
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.lang.reflect.Array;
  6. import java.io.*;
  7.  
  8. /* Name of the class has to be "Main" only if the class is public. */
  9. class Ideone
  10. {
  11. public static void main (String[] args) throws java.lang.Exception
  12. {
  13. // (4 == 2 + 2) && true
  14. No<Double> mais = new Galho<Double,Double>(new Soma(), new FolhaNumerica(2), new FolhaNumerica(2));
  15. No<Boolean> igual = new Galho<Double,Boolean>(new Igualdade(), new FolhaNumerica(4), mais);
  16. No<Boolean> raiz = new Galho<Boolean,Boolean>(new Conjuncao(), igual, new FolhaBooleana(true));
  17.  
  18. boolean resultado = raiz.avaliar(); // true
  19. System.out.println(resultado);
  20. }
  21. }
  22.  
  23. interface No<T> {
  24. T avaliar();
  25. }
  26.  
  27. class FolhaNumerica implements No<Double> {
  28. double valor;
  29. public Double avaliar() { return valor; }
  30. FolhaNumerica(double valor) { this.valor = valor; }
  31. }
  32.  
  33. class FolhaBooleana implements No<Boolean> {
  34. boolean valor;
  35. public Boolean avaliar() { return valor; }
  36. FolhaBooleana(boolean valor) { this.valor = valor; }
  37. }
  38.  
  39. interface Operador<E,S> {
  40. S aplicar(E[] operandos);
  41. Class<E> obterClasseOperandos();
  42. }
  43.  
  44. class Soma implements Operador<Double,Double> {
  45. public String toString() { return "+"; }
  46. public Double aplicar(Double[] operandos) {
  47. double ret = 0;
  48. for ( Double d : operandos )
  49. ret += d;
  50. return ret;
  51. }
  52. public Class<Double> obterClasseOperandos() { return Double.class; }
  53. }
  54.  
  55. class Conjuncao implements Operador<Boolean,Boolean> {
  56. public String toString() { return "&&"; }
  57. public Boolean aplicar(Boolean[] operandos) {
  58. for ( Boolean b : operandos )
  59. if ( !b )
  60. return false;
  61. return true;
  62. }
  63. public Class<Boolean> obterClasseOperandos() { return Boolean.class; }
  64. }
  65.  
  66. class Igualdade implements Operador<Double,Boolean> {
  67. public String toString() { return "=="; }
  68. public Boolean aplicar(Double[] operandos) {
  69. double primeiro = operandos[0];
  70. for ( Double d : operandos )
  71. if ( d != primeiro )
  72. return false;
  73. return true;
  74. }
  75. public Class<Double> obterClasseOperandos() { return Double.class; }
  76. }
  77.  
  78. class Galho<E,S> implements No<S> {
  79. Operador<E,S> op;
  80. No<E>[] operandos;
  81.  
  82. public S avaliar() {
  83. @SuppressWarnings("unchecked")
  84. E[] array = (E[])Array.newInstance(op.obterClasseOperandos(), operandos.length);
  85. for ( int i = 0 ; i < array.length ; i++ )
  86. array[i] = operandos[i].avaliar(); // Avalia cada sub-nó recursivamente
  87.  
  88. return op.aplicar(array); // Passa os resultados para o operador
  89. }
  90.  
  91. Galho(Operador<E,S> op, No<E>... operandos) {
  92. this.op = op;
  93. this.operandos = operandos;
  94. }
  95. }
Success #stdin #stdout 0.06s 380160KB
stdin
Standard input is empty
stdout
true