Test results - Codility

Code: 03:41:32 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // Implement your solution here
    }
}

Code: 03:41:43 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(value > max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > middle){
          this.min = this.middle
          this.middle = value
      }else if(value > min){
          this.min = value
      }
  }
  compareMin(value){
      if(value < min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < middle){
          this.max = this.middle
          this.middle = value
      }else if(value < max){
          this.max = value
      }
  }
}

Code: 03:41:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > middle){
          this.min = this.middle
          this.middle = value
      }else if(value > min){
          this.min = value
      }
  }
  compareMin(value){
      if(value < min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < middle){
          this.max = this.middle
          this.middle = value
      }else if(value < max){
          this.max = value
      }
  }
}

Code: 03:42:15 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(this.max != null && value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:42:25 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(this.max != null && value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(this.middle != null && value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:42:37 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(this.max != null && value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(this.middle != null && value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min || ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:43:01 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(this.max != null && value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(this.middle != null && value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:43:13 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:43:32 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    con
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:43:43 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    console.log()
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:44:06 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    console.log()
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log()
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:44:17 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    console.log()
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:44:35 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:44:48 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    cons
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:44:58 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_negative.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:45:19 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_positive.max * max_negative.middle * max_negative.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:45:21 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_positive.max * max_positive.middle * max_positive.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:45:51 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_positive.max * max_positive.middle * max_positive.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:46:00 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        return max_positive.max * max_positive.middle * max_positive.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:46:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        
        return max_positive.max * max_positive.middle * max_positive.min
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:46:45 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        if(positive_count >= 3){
            var pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        return 
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:46:55 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        if(positive_count >= 3){
            var pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(){
            
        }
        return 
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:47:26 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){

        }
        return 
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:47:36 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = 
        }
        return 
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:47:58 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max
        }
        return 
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:48:16 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max()
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:48:19 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:49:09 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:49:26 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && )
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:49:47 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && )
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:50:10 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){

      }else if(){

      }else if(){

      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:50:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){

      }else if(this.middle == null && this.max == null){

      }else if(){

      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:50:32 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){

      }else if(this.middle == null && this.max == null){

      }else if(this.max == null){

      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:50:46 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){

      }else if(this.max == null){

      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:50:56 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.min = value
      }else if(this.max == null){
          this.min = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:51:10 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:51:25 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:51:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:52:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:52:04 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:52:35 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.m
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:52:36 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.max * max_positive.min
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:53:05 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:53:06 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.max = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:53:28 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.min = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:53:58 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
    max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.min = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:54:01 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.min = value
      }else if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:54:31 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.min = value
      } if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:54:41 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }else if(this.middle == null && this.min == null){
          this.middle = value
      }else if(this.min == null){
          this.min = value
      }
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:54:49 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
      }
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

The submission is being evaluated.

Code: 03:55:12 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
          this.middle = value
      }
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:55:22 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
          this.middle = value
          this.min = value
      }
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.min = value
      }else if(this.middle == null && this.max == null){
          this.middle = value
      }else if(this.max == null){
          this.max = value
      }else if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:55:33 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for(var i=0;i<A.length;i++){
        if(A[i] == 0) has_zero = true
        else if(A[i] > 0){
            max_positive.compareMax(A[i])
            
            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        }else{
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >=2 && positive_count > 0)){
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if(positive_count >= 3){
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }else if(negative_count >=2 && positive_count > 0){
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    }else if (has_zero){
        return 0
    }else{
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
  constructor() {
    this.max = null;
    this.middle = null;
    this.min = null;
  }
  getValue(){
      console.log(this.max, this.middle, this.min)
  }
  compareMax(value){
      if(this.middle == null && this.max == null && this.min == null){
          this.max = value
          this.middle = value
          this.min = value
      }
      if(value > this.max) {
          this.min = this.middle
          this.middle = this.max
          this.max = value
      }else if(value > this.middle){
          this.min = this.middle
          this.middle = value
      }else if(value > this.min ){
          this.min = value
      }
  }
  compareMin(value){
    if(this.middle == null && this.max == null && this.min == null){
          this.max = value
          this.middle = value
          this.min = value
      }
      if(value < this.min) {
          this.max = this.middle
          this.middle = (this.max)
          this.min = value
      }else if(value < this.middle){
          this.max = this.middle
          this.middle = value
      }else if(value < this.max){
          this.max = value
      }
  }
}

Code: 03:55:35 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])

            max_positive.getValue()
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 03:56:03 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 03:56:24 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 03:56:38 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 03:56:45 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 03:57:59 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 03:58:08 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = null;
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:02:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = float('-inf'), float('-inf'), float('-inf');
        this.middle = null;
        this.min = null;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (this.middle == null && this.max == null && this.min == null) {
            this.max = value
            this.middle = value
            this.min = value
        }
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:02:43 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = float('-inf');
        this.middle = float('-inf');
        this.min = float('-inf');
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:03:19 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = -Infinity;
        this.middle = float('-inf');
        this.min = float('-inf');
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:03:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor() {
        this.max = -Infinity;
        this.middle = -Infinity;
        this.min = -Infinity;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:03:50 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(default) {
        this.max = -Infinity;
        this.middle = -Infinity;
        this.min = -Infinity;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:04:00 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(default) {
        this.max = -Infinity;
        this.middle = -Infinity;
        this.min = -Infinity;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:04:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(is) {
        this.max = data*Infinity;
        this.middle = data*Infinity;
        this.min = data*Infinity;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:04:31 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        this.max = data*Infinity;
        this.middle = data*Infinity;
        this.min = data*Infinity;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:04:52 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet()
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:05:02 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet()
    var positive_count = 0
    var max_negative = new triplet()
    var min_negative = new triplet()
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:05:07 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = max_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:06:14 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * max_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:06:18 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:06:44 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.o
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:06:49 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        } else if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:07:23 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:07:24 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:08:17 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = (this.max)
            this.min = value
        } else if (value < this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:08:43 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:09:06 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.ma) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:09:27 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:10:24 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:10:35 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:10:50 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:10:54 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:11:10 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:11:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:11:23 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:11:34 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:11:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:11:54 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:12:01 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        console.log("pos_2_neg_1", pos_2_neg_1)
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:12:42 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:12:53 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:13:55 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        
        var max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:14:09 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = 
        if()
         = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:14:23 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if()
         = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:14:33 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count >= 2 && positive_count > 0)
         = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:14:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count >= 2 && positive_count >= 2)
         = min_positive.min * min_positive.middle * max_negative.max
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:15:07 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
         = 
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:15:18 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(){
            
        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:15:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(positive_count <=){

        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:15:39 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(positive_count <= 0){

        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:15:49 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(negative_count >= 3){

        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:16:30 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(negative_count >= 3){

        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:16:32 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if(negative_count > 0 && positive_count >= 2){
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if(negative_count >= 3){

        }
        var max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:16:58 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        }
        var

            console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:16:59 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = min_positive.max * min_positive.middle * min_positive.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:17:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * min_positive.middle * min_positive.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:18:02 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = min_negative.max * min_negative.middle * min_negative.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:18:15 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = min_negative.max * min_negative.middle * min_negative.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:18:32 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * min_negative.middle * min_negative.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:18:37 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:18:47 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    max_positive.getValue()
    min_positive.getValue()
    max_negative.getValue()
    min_negative.getValue()
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        console.log("max_2_pos_1_neg", max_2_pos_1_neg)
        console.log("max_3_neg", max_3_neg)
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:19:01 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    console.log(positive_count, negative_count)
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:19:08 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

Code: 04:19:08 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:19:18 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.

Code: 04:19:22 UTC, js, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // Implement your solution here
    var max_positive = new triplet(true)
    var min_positive = new triplet(false)
    var positive_count = 0
    var max_negative = new triplet(true)
    var min_negative = new triplet(false)
    var negative_count = 0
    var has_zero = false
    for (var i = 0; i < A.length; i++) {
        if (A[i] == 0) has_zero = true
        else if (A[i] > 0) {
            max_positive.compareMax(A[i])
            min_positive.compareMin(A[i])
            positive_count++
        } else {
            max_negative.compareMax(A[i])
            min_negative.compareMin(A[i])
            negative_count++
        }
    }
    if (positive_count >= 3 || (negative_count >= 2 && positive_count > 0)) {
        var pos_3 = 0
        var pos_2_neg_1 = 0
        if (positive_count >= 3) {
            pos_3 = max_positive.max * max_positive.middle * max_positive.min
        }
        if (negative_count >= 2 && positive_count > 0) {
            pos_2_neg_1 = min_negative.middle * min_negative.min * max_positive.max
        }
        return Math.max(pos_3, pos_2_neg_1)
    } else if (has_zero) {
        return 0
    } else {
        //確認該使用2個正數*1個負數還是3個負數
        var max_2_pos_1_neg = -Infinity
        var max_3_neg = -Infinity
        if (negative_count > 0 && positive_count >= 2) {
            max_2_pos_1_neg = min_positive.min * min_positive.middle * max_negative.max
        }
        if (negative_count >= 3) {
            max_3_neg = max_negative.max * max_negative.middle * max_negative.min
        }
        return Math.max(max_2_pos_1_neg, max_3_neg)
    }
}
class triplet {
    constructor(isMaxCompare) {
        var data = isMaxCompare ? -Infinity : Infinity
        this.max = data;
        this.middle = data;
        this.min = data;
    }
    getValue() {
        console.log(this.max, this.middle, this.min)
    }
    compareMax(value) {
        if (value > this.max) {
            this.min = this.middle
            this.middle = this.max
            this.max = value
        } else if (value > this.middle) {
            this.min = this.middle
            this.middle = value
        } else if (value > this.min) {
            this.min = value
        }
    }
    compareMin(value) {
        if (value < this.min) {
            this.max = this.middle
            this.middle = this.min
            this.min = value
        } else if (value < this.middle) {
            this.max = this.middle
            this.middle = value
        } else if (value < this.max) {
            this.max = value
        }
    }
}

The submission is being evaluated.