Arrays 如何从长度为'；n'；要匹配给定的长度'；y'；？

假设我有一个数组

foo

和一个正整数

y

，其中

foo.length

y

。 我想从

foo

中删除元素，以便

foo.length

变成

y

（或者非常接近它）

另外，我需要保留

foo

的第一个和最后一个元素。移除元素的索引必须尽可能等距隔开

Foo

可以切片，也可以用于创建新数组

示例：如果

foo

=

[a，b，c，d，e，f，g，1，2，3，4，5]

和

y

=

6

，那么

trimmedfoo

可以是

[a，c，e，g，2，4，5]

，但不能是

[a，c，e，g，g，2，4]

，因为

的最后一个元素丢失了

伪代码解决方案很好，尽管as3是我的首选语言。：）

谢谢
 如果第一个和最后一个元素是数组中唯一不可接触的元素，那么更简单的方法不是重复删除第二个和最后第二个项目，直到达到所需的长度吗

foo = [a,b,c,d,e,f,g,1,2,3,4,5];
y = 6;
loopType = 1;

while(foo.length>y)
{
    if(loopType==1)
    {
        foo[1].splice(1,1); //remove second item
        loopType = 2; //set loop to remove from other end of array
    }
    else
    {
        foo[1].splice(foo.length-2,1); //remove second-last item (foo.length-1 is the last item)
        loopType = 1; //set loop to remove from other end of array
    }
}

现在foo应该是[a，e，f，g，1,5]
 如果第一个和最后一个元素是数组中唯一不可接触的元素，那么更简单的方法不是重复删除第二个和最后第二个项目，直到达到所需的长度吗

foo = [a,b,c,d,e,f,g,1,2,3,4,5];
y = 6;
loopType = 1;

while(foo.length>y)
{
    if(loopType==1)
    {
        foo[1].splice(1,1); //remove second item
        loopType = 2; //set loop to remove from other end of array
    }
    else
    {
        foo[1].splice(foo.length-2,1); //remove second-last item (foo.length-1 is the last item)
        loopType = 1; //set loop to remove from other end of array
    }
}

现在foo应该是[a，e，f，g，1,5]
 从foo的长度中减去y的值。
将foo的长度除以减法结果，然后调用结果N。
现在将数组复制到新数组并跳过，而不复制每个第N个元素。
确保仅从第二个元素开始跳过元素，并在最后一个元素之前停止（如果最后N个计数是最后一个元素，请跳过之前的元素）

在上述示例中：
foo.length=12，y=6，N=12-6=6，foo.length/N=2

所以我们每过一秒就移动一个元素

在另一个例子中，我们可能需要跳过几个元素来修正除法的结果数组，即用余数从foo的长度中减去y的值。
将foo的长度除以减法结果，然后调用结果N。
现在将数组复制到新数组并跳过，而不复制每个第N个元素。
确保仅从第二个元素开始跳过元素，并在最后一个元素之前停止（如果最后N个计数是最后一个元素，请跳过之前的元素）

在上述示例中：
foo.length=12，y=6，N=12-6=6，foo.length/N=2

所以我们每过一秒就移动一个元素

在另一个示例中，我们可能需要跳过几个元素来修复除法的结果数组，并根据您的值和其他值测试余数

var originalArray:Array = ['a','b','c','d','e','f','g','1','2','3','4','5'];
var newLength:Number = 6;

var trimmedArray:Array = originalArray.filter(function(item:*, i:int, a:Array):Boolean {
    return  (((i + 1) % (a.length/newLength)) == 1) || (i == 0) || (i == a.length - 1);
});

trace(trimmedArray); // outputs a,c,e,g,2,4,5

根据你的价值观和其他人进行测试，并且有效

var originalArray:Array = ['a','b','c','d','e','f','g','1','2','3','4','5'];
var newLength:Number = 6;

var trimmedArray:Array = originalArray.filter(function(item:*, i:int, a:Array):Boolean {
    return  (((i + 1) % (a.length/newLength)) == 1) || (i == 0) || (i == a.length - 1);
});

trace(trimmedArray); // outputs a,c,e,g,2,4,5

假设您有一个长度为
n
的字符串，并且希望它是长度
m
。您有
n-2
元素可供选择，还有
m-2
元素可供选择以用于新阵列。现在，假设您当前已经选择了
i
元素，并且已经传递了
j
元素。如果
i/j
<
（m-2）/（n-2）
，那么你就落后了。你可能应该采取另一种手段。对于最大偶数选择，您真正想知道的是
（i+1）/（j+1）
或
i/（j+1）
是否更接近您的
（m-2）/（n-2）
。如果溢出不是一个问题，您可以做一点代数来计算这是否等于
（i+1）*（n-2）-（j+1）*（m-2）
大于或小于
（n-2）/2
；越多意味着
i
越好（所以不要选这个），而越少意味着
i+1
越好

我不熟悉ActionScript，但这里有一些Scala，希望可以作为伪代码使用：

// Don't worry about the [T: ClassManifest] thing
// that just means it can work on arrays of any type

def pare[T: ClassManifest](a: Array[T], m: Int) = {
  val b = new Array[T](m)
  val n2 = a.length - 2
  val m2 = m - 2
  b(0) = a(0)
  var i,j = 0
  while (j < n2) {
    val diff = (i+1)*n2 - (j+1)*m2
    if (diff < n2/2) {
      i += 1
      j += 1
      b(i) = a(j)
   }
   else j += 1
  }
  b(m2+1) = a(n2+1)
  b    // This means "return b"
}

如您所见，这会给出非常均匀的间距。
假设您有一个长度为
n
的字符串，并且希望它是长度
m
。您有
n-2
元素可供选择，还有
m-2
元素可供选择以用于新阵列。现在，假设您当前已经选择了
i
元素，并且已经传递了
j
元素。如果
i/j
<
（m-2）/（n-2）
，那么你就落后了。你可能应该采取另一种手段。对于最大偶数选择，您真正想知道的是
（i+1）/（j+1）
或
i/（j+1）
是否更接近您的
（m-2）/（n-2）
。如果溢出不是一个问题，您可以做一点代数来计算这是否等于
（i+1）*（n-2）-（j+1）*（m-2）
大于或小于
（n-2）/2
；越多意味着
i
越好（所以不要选这个），而越少意味着
i+1
越好

我不熟悉ActionScript，但这里有一些Scala，希望可以作为伪代码使用：

// Don't worry about the [T: ClassManifest] thing
// that just means it can work on arrays of any type

def pare[T: ClassManifest](a: Array[T], m: Int) = {
  val b = new Array[T](m)
  val n2 = a.length - 2
  val m2 = m - 2
  b(0) = a(0)
  var i,j = 0
  while (j < n2) {
    val diff = (i+1)*n2 - (j+1)*m2
    if (diff < n2/2) {
      i += 1
      j += 1
      b(i) = a(j)
   }
   else j += 1
  }
  b(m2+1) = a(n2+1)
  b    // This means "return b"
}

如您所见，这会提供非常均匀的间距。
我已将Rex Kerr的出色算法翻译成PHP，并希望将其发布在这里，因为我认为这会让其他人更容易阅读。唯一的实际区别是，如果数组小于所需数量，则返回未触及的数组：

private function evenlyReduceArray($originalArray, $desiredCount){

    if(count($originalArray) <= $desiredCount)
    {
        return $originalArray;
    }

    $newArray             = array();
    $trimmedLength        = count($originalArray) - 2;
    $trimmedDesiredCount  = $desiredCount - 2;

    $newArray[0] = $originalArray[0];

    $i = 0;
    $j = 0;
    while($j < $trimmedLength)
    {
        $diff = ($i + 1) * $trimmedLength - ($j + 1) * $trimmedDesiredCount;
        if($diff < $trimmedLength / 2)
        {
            $i += 1;
            $j += 1;
            $newArray[$i] = $originalArray[$j];
        }
        else{
            $j+= 1;
        }
    }

    $newArray[$trimmedDesiredCount + 1] = $originalArray[$trimmedLength + 1];

    return $newArray;
}

private function evenryreducearray（$originalArray，$desiredCount）{
如果（count（$originalArray）我已经将Rex Kerr的很棒的算法翻译成PHP，并希望将其发布在这里，因为我认为这会让其他人更容易阅读。唯一的真正区别是，如果数组小于所需的数量，它将返回未被触及的数组：

private function evenlyReduceArray($originalArray, $desiredCount){

    if(count($originalArray) <= $desiredCount)
    {
        return $originalArray;
    }

    $newArray             = array();
    $trimmedLength        = count($originalArray) - 2;
    $trimmedDesiredCount  = $desiredCount - 2;

    $newArray[0] = $originalArray[0];

    $i = 0;
    $j = 0;
    while($j < $trimmedLength)
    {
        $diff = ($i + 1) * $trimmedLength - ($j + 1) * $trimmedDesiredCount;
        if($diff < $trimmedLength / 2)
        {
            $i += 1;
            $j += 1;
            $newArray[$i] = $originalArray[$j];
        }
        else{
            $j+= 1;
        }
    }

    $newArray[$trimmedDesiredCount + 1] = $originalArray[$trimmedLength + 1];

    return $newArray;
}

private function evenryreducearray（$originalArray，$desiredCount）{
如果（count（$originalArray）我理解
1
和
3
之间的区别是2。
f
和
g
之间的区别是1。
g
和
1
之间的区别是什么？我对你想要完成的事情感到困惑，你的第一句话