Суммирование массива + подсчет экземпляров

Этот код пытается решить этот тип версий сравнения.

Большинство спецификаторов версии, например> = 1.0, не требуют пояснений. Спецификатор ~> имеет особое значение, лучше всего показано на примере. ~> 2.0.3 идентична> = 2.0.3 и & lt; 2.1. ~> 2.1 совпадает с> = 2.1 и & lt; 3.0.

public static boolean apply(String cmpDeviceVersion, String reqDeviceVersion)
{
    Boolean equal           = !cmpDeviceVersion.contains(">") && !cmpDeviceVersion.contains(">=") &&
                              !cmpDeviceVersion.contains("<") && !cmpDeviceVersion.contains("<=") &&
                              !cmpDeviceVersion.contains("~>");

    Boolean between         = cmpDeviceVersion.contains("~>");
    Boolean higher          = cmpDeviceVersion.contains(">") && !cmpDeviceVersion.contains(">=") && !cmpDeviceVersion.contains("~>");
    Boolean higherOrEqual   = cmpDeviceVersion.contains(">=");

    Boolean less            = cmpDeviceVersion.contains("<") && !cmpDeviceVersion.contains("<=");
    Boolean lessOrEqual     = cmpDeviceVersion.contains("<=");

    cmpDeviceVersion        = cmpDeviceVersion.replaceAll("[<>=~]", "");
    cmpDeviceVersion        = cmpDeviceVersion.trim();

    String[] version        = cmpDeviceVersion.split("\\.");
    String[] reqVersion     = reqDeviceVersion.split("\\.");

    if(equal)
    {
        return isEqual(version, reqVersion);
    }
    else if(between)
    {
        return isBetween(version, reqVersion);
    }
    else if(higher)
    {
        return isHigher(version, reqVersion);
    }
    else if(higherOrEqual)
    {
        return isEqual(version, reqVersion) || isHigher(version, reqVersion);
    }
    else if(less)
    {
        return isLess(version, reqVersion);
    }
    else if(lessOrEqual)
    {
        return isEqual(version, reqVersion) || isLess(version, reqVersion);
    }

    return false;
}

private static boolean isEqual(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strVersion.equals(strReqVersion);
}

private static boolean isHigher(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strReqVersion.compareTo(strVersion) > 0;
}

private static boolean isLess(String[] version, String[] reqVersion)
{
    String strVersion = StringUtils.join(version);
    String strReqVersion = StringUtils.join(reqVersion);
    if(version.length > reqVersion.length)
    {
        Integer diff = version.length - reqVersion.length;
        strReqVersion += StringUtils.repeat(".0", diff);
    }
    else if(reqVersion.length > version.length)
    {
        Integer diff = reqVersion.length - version.length;
        strVersion += StringUtils.repeat(".0", diff);
    }

    return strReqVersion.compareTo(strVersion) < 0;
}

private static boolean isBetween(String[] version, String[] reqVersion)
{
    return (isEqual(version, reqVersion) || isHigher(version, reqVersion)) &&
            isLess(getNextVersion(version), reqVersion);
}

private static String[] getNextVersion(String[] version)
{
    String[] nextVersion = new String[version.length];
    for(int i = version.length - 1; i >= 0 ; i--)
    {
        if(i == version.length - 1)
        {
            nextVersion[i] = "0";
        }
        else if((i == version.length - 2) && NumberUtils.isNumber(version[i]))
        {
            nextVersion[i] = String.valueOf(NumberUtils.toInt(version[i]) + 1);
        }
        else
        {
            nextVersion[i] = version[i];
        }
    }
    return nextVersion;
}
0
задан turtlepower 18 January 2019 в 03:24
поделиться

1 ответ

ОК. Думаю, вы хотите вот что:

Массив объектов, которые содержат имя телефона со списком всех использованных телефонов. Массив должен быть отсортирован.

Сначала пройдите ввод, добавьте записи в карту со счетчиком. При каждом включении телефона ищите его список времени. Если время существует, увеличьте его, если нет, добавьте время. Затем сопоставьте список телефонов с массивом объектов, которые связывают данные телефона с именем телефона. Переместить счет и сортировать

const phoneMap = {};

const log = [
  {
"phone": "OPPO R11s",
"roundedTime": "10:45"
  },
  {
"phone": "iPhone 7",
"roundedTime": "03:15"
  },
  {
"phone": "Samsung Galaxy XCover 4",
"roundedTime": "11:45"
  },
  {
"phone": "iPhone XS Max",
"roundedTime": "12:00"
  },
  {
"phone": "iPhone XS",
"roundedTime": "01:00"
  },
  {
"phone": "Samsung Galaxy Note9",
"roundedTime": "02:30"
  },
  {
"phone": "Samsung Galaxy J4",
"roundedTime": "07:15"
  },
  {
"phone": "iPhone XS Max",
"roundedTime": "03:00"
  },
  {
"phone": "Samsung Galaxy J4 Plus",
"roundedTime": "02:45"
  },
  {
"phone": "iPhone 6s",
"roundedTime": "12:45"
  },
  {
"phone": "iPhone XS Max AirPods Bundle",
"roundedTime": "01:00"
  }];

log.forEach(function(logItem) {
  if (!phoneMap[logItem["phone"]]) {
    phoneMap[logItem["phone"]] = {count:1, times:[]};
  } else {
  	phoneMap[logItem["phone"]]["count"]++
  }

  var timeNode = phoneMap[logItem["phone"]]["times"].find(function(timeNode) {
    return timeNode["time"] === logItem["roundedTime"];
  })

  if (timeNode) {
    timeNode["count"]++;
  } else {
    phoneMap[logItem["phone"]]["times"].push({
      "time": logItem["roundedTime"],
      "count":1
    });
  }
})

var result = Object.keys(phoneMap).map(function(key){
	let obj = {};
  obj[key] = phoneMap[key];
  obj["count"] = phoneMap[key].count;
  delete phoneMap[key]["count"];
	return obj;
}).sort(function(a,b){
	return b.count - a.count;
});


console.log(result);

0
ответ дан Jon Grant 18 January 2019 в 03:24
поделиться
Другие вопросы по тегам:

Похожие вопросы: