Gewusst wie: konvertieren der Sequenz von zahlen in einem array in range von zahlen

Einfach nur Spaß mit der Lösung von CMS :

  function getRanges (array) {
    for (var ranges = [], rend, i = 0; i < array.length;) {
      ranges.push ((rend = array[i]) + ((function (rstart) {
        while (++rend === array[++i]);
        return --rend === rstart;
      })(rend) ? '' : '-' + rend)); 
    }
    return ranges;
  }

Ich fand diese Antwort hilfreich, sondern benötigt ein Python-version:

def GroupRanges(items):
  """Yields 2-tuples of (start, end) ranges from a sequence of numbers.

  Args:
    items: an iterable of numbers, sorted ascendingly and without duplicates.

  Yields:
    2-tuples of (start, end) ranges.  start and end will be the same
    for ranges of 1 number
  """
  myiter = iter(items)
  start = myiter.next()
  end = start
  for num in myiter:
    if num == end + 1:
      end = num
    else:
      yield (start, end)
      start = num
      end = num
  yield (start, end)


numbers = [1, 2, 3, 5, 6, 7, 8, 9, 10, 20]
assert [(1, 3), (5, 10), (20, 20)] == list(GroupRanges(numbers))
assert [(1, 1)] == list(GroupRanges([1]))
assert [(1, 10)] == list(GroupRanges([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

Wenn Sie wollen einfach nur ein string für einen Bereich, dann würden Sie finden den mid-point der Sequenz, und das wird Ihr mittlerer Wert (10 in deinem Beispiel). Sie würden dann schnappen Sie sich das erste Element in der Sequenz, und die Artikel, die unmittelbar vor Ihrer Mitte, und bauen Sie Ihr erste-Sequenz-Darstellung. Würden Sie das gleiche Verfahren, um Ihren letzten Element, und das Element folgt unmittelbar auf Ihre Mitte, und bauen Sie Ihre Letzte-Folge-Darstellung.

//Provide initial sequence
var sequence = [1,2,3,4,5,6,7,8,9,10];
//Find midpoint
var midpoint = Math.ceil(sequence.length/2);
//Build first sequence from midpoint
var firstSequence = sequence[0] + "-" + sequence[midpoint-2];
//Build second sequence from midpoint
var lastSequence  = sequence[midpoint] + "-" + sequence[sequence.length-1];
//Place all new in array
var newArray = [firstSequence,midpoint,lastSequence];

alert(newArray.join(",")); //1-4,5,6-10

Demo Online: http://jsbin.com/uvahi/edit

Hier ist mein nehmen auf diese...

function getRanges(input) {

  //setup the return value
  var ret = [], ary, first, last;

  //copy and sort
  var ary = input.concat([]);
  ary.sort(function(a,b){
    return Number(a) - Number(b);
  });

  //iterate through the array
  for (var i=0; i<ary.length; i++) {
    //set the first and last value, to the current iteration
    first = last = ary[i];

    //while within the range, increment
    while (ary[i+1] == last+1) {
      last++;
      i++;
    }

    //push the current set into the return value
    ret.push(first == last ? first : first + "-" + last);
  }

  //return the response array.
  return ret;
}

Hier ist ein port des CMS-code für die BASH:

#!/usr/bin/env bash
# vim: set ts=3 sts=48 sw=3 cc=76 et fdm=marker: # **** IGNORE ******
get_range() { RANGE= # <-- OUTPUT                  **** THIS   ******
   local rstart rend i arr=( "$@" )  # ported from **** JUNK   ******
   for (( i=0 ; i < $# ; i++ )); do  # http://stackoverflow.com
      (( rstart = arr[i] ))          # /a/2270987/912236
      rend=$rstart; while (( arr[i+1] - arr[i] == 1 )); do
      (( rend = arr[++i] )); done; (( rstart == rend )) &&
   RANGE+=" $rstart" || RANGE+=" $rstart-$rend"; done; } # }}}

 ; For all cells of the array
    ;if current cell = prev cell + 1 -> range continues
    ;if current cell != prev cell + 1 -> range ended

int[] x  = [2,3,4,5,10,18,19,20]
string output = '['+x[0]
bool range = false; --current range
for (int i = 1; i > x[].length; i++) {
  if (x[i+1] = [x]+1) {
    range = true;
  } else { //not sequential
  if range = true
     output = output || '-' 
  else
     output = output || ','
  output.append(x[i]','||x[i+1])
  range = false;
  } 

}

Sowas.

import java.util.ArrayList;
import java.util.Arrays;



public class SequencetoRange {

    /**
     * @param args
     */
    public static void main(String[] args) {
    //TODO Auto-generated method stub

        int num[] = {1,2,3,63,65,66,67,68,69,70,80,90,91,94,95,4,101,102,75,76,71};

        int l = num.length;
        int i;
        System.out.print("Given number : ");
        for (i = 0;i < l;i++ ){
            System.out.print("  " + num[i]);
        }
        System.out.println("\n");
        Arrays.sort(num);

        ArrayList newArray = new ArrayList();
        newArray = getRanges(num);
        System.out.print("Range : ");
        for(int y=0;y<newArray.size();y++)
        {
            System.out.print(" " +newArray.get(y));
        }
    }

    public static ArrayList getRanges(int num[])
    {  
        ArrayList ranges = new ArrayList();
        int rstart, rend;   
        int lastnum = num[num.length-1];
        for (int i = 0; i < num.length-1; i++) 
        {     
            rstart = num[i];     
            rend = rstart;     
            while (num[i + 1] - num[i] == 1) 
            {       
                rend = num[i + 1]; 
                //increment the index if the numbers sequential       
                if(rend>=lastnum)
                {
                    break;
                }
                else
                {
                    i++;
                }  
            }  
            if(rstart==rend)
            {
                ranges.add(rend);
            }
            else
            {
                ranges.add(+rstart+"..."+rend);
            }
        } 
        return ranges; 
    } 
}

Ist eine Anpassung der CMS javascript-Lösung für Kalte Fusion

Es tut, Sortieren Sie die Liste zunächst so, dass 1,3,2,4,5,8,9,10 (oder ähnlich) richtig konvertiert 1-5,8-10.

<cfscript>
    function getRanges(nArr) {
        arguments.nArr = listToArray(listSort(arguments.nArr,"numeric"));
        var ranges = [];
        var rstart = "";
        var rend = "";
        for (local.i = 1; i <= ArrayLen(arguments.nArr); i++) {
            rstart = arguments.nArr[i];
            rend = rstart;
            while (i < ArrayLen(arguments.nArr) and (val(arguments.nArr[i + 1]) - val(arguments.nArr[i])) == 1) {
                rend = val(arguments.nArr[i + 1]); //increment the index if the numbers sequential
                i++;
            }
            ArrayAppend(ranges,rstart == rend ? rstart : rstart & '-' & rend);
        }
        return arraytolist(ranges);
    }
</cfscript>

Winzigen ES6-Modul für Euch. Es übernimmt eine Funktion, um zu bestimmen, Wann müssen wir brechen die Sequenz (breakDetectorFunc param - Standard ist die einfache Sache, für integer-Sequenz-Eingang).
HINWEIS: da input ist Abstrakt - es gibt keine automatische Sortierung vor Verarbeitung, so, wenn Ihre Reihenfolge ist nicht sortiert - tun Sie vor dem aufrufen dieses Modul

function defaultIntDetector(a, b){
    return Math.abs(b - a) > 1;
}

/**
 * @param {Array} valuesArray
 * @param {Boolean} [allArraysResult=false] if true - [1,2,3,7] will return [[1,3], [7,7]]. Otherwise [[1.3], 7]
 * @param {SequenceToIntervalsBreakDetector} [breakDetectorFunc] must return true if value1 and value2 can't be in one sequence (if we need a gap here)
 * @return {Array}
 */
const sequenceToIntervals = function (valuesArray, allArraysResult, breakDetectorFunc) {
    if (!breakDetectorFunc){
        breakDetectorFunc = defaultIntDetector;
    }
    if (typeof(allArraysResult) === 'undefined'){
        allArraysResult = false;
    }

    const intervals = [];
    let from = 0, to;
    if (valuesArray instanceof Array) {
        const cnt = valuesArray.length;
        for (let i = 0; i < cnt; i++) {
            to = i;
            if (i < cnt - 1) { //i is not last (to compare to next)
                if (breakDetectorFunc(valuesArray[i], valuesArray[i + 1])) {
                    //break
                    appendLastResult();
                }
            }
        }
        appendLastResult();
    } else {
        throw new Error("input is not an Array");
    }

    function appendLastResult(){
        if (isFinite(from) && isFinite(to)) {
            const vFrom = valuesArray[from];
            const vTo = valuesArray[to];

            if (from === to) {
                intervals.push(
                    allArraysResult
                        ? [vFrom, vTo] //same values array item
                        : vFrom //just a value, no array
                );
            } else if (Math.abs(from - to) === 1) { //sibling items
                if (allArraysResult) {
                    intervals.push([vFrom, vFrom]);
                    intervals.push([vTo, vTo]);
                } else {
                    intervals.push(vFrom, vTo);
                }
            } else {
                intervals.push([vFrom, vTo]); //true interval
            }
            from = to + 1;
        }
    }

    return intervals;
};

module.exports = sequenceToIntervals;

/** @callback SequenceToIntervalsBreakDetector
 @param value1
 @param value2
 @return bool
 */

erste argument ist die Eingangs-Reihenfolge sortiert-array, der zweite ist ein Boolesches flag zum Steuern des Ausgangs-Modus: wenn true - single Element (außerhalb der Intervalle) zurückgegeben werden als arrays sowieso: [1,7],[9,9],[10,10],[12,20], ansonsten einzelne Gegenstände zurück, wie Sie in der Eingabe-array

Ihre Probe-Eingang

[2,3,4,5,10,18,19,20]

zurück:

sequenceToIntervals([2,3,4,5,10,18,19,20], true) //[[2,5], [10,10], [18,20]]
sequenceToIntervals([2,3,4,5,10,18,19,20], false) //[[2,5], 10, [18,20]]
sequenceToIntervals([2,3,4,5,10,18,19,20]) //[[2,5], 10, [18,20]]

Brauchte ich eine PHP-version, die unterstützt auch nach unten reicht (z.B. [10,9,8] wird umgewandelt zu [10-8]). So habe ich geändert DisgruntledGoat version, die portiert CMS-Lösung. Es kann auch mit Zeichenketten in der Eingabe richtig.

function getRanges($nums)
{
    $ranges = array();

    for ($i = 0; $i < count($nums); $i++) {
        if (!is_numeric($nums[$i]) || !isset($nums[$i+1]) || !is_numeric($nums[$i+1])) {
            $ranges[] = $nums[$i];
            continue;
        }
        $rStart = $nums[$i];
        $rEnd = $rStart;
        $rDiff = $nums[$i+1] > $nums[$i] ? 1 : -1;
        while (isset($nums[$i+1]) && is_numeric($nums[$i+1]) && $nums[$i+1]-$nums[$i] == $rDiff)
            $rEnd = $nums[++$i];
        $ranges[] = $rStart == $rEnd ? $rStart : $rStart.'-'.$rEnd;
    }

    return $ranges;
}

Beispiel:

getRanges([2,3,4,5,10,18,19,20,"downwards",10,9,8,7,6,5])
//Returns [2-5,10,18-20,"downwards",10-5]