для (увеличение времени задержки) в зависимости от количества объектов

Лучше всего выбрать время анимации, которое будет происходить КАЖДЫЙ раз, независимо от количества переменных.

let animateTime = 2 // 2 secs
let animateTimePerObject:Double = animateTime/objects.count
for (i,object) in objects.enumerated() {
    object.animate(withDelay: (i * animateTimePerObject) 
}

Скажем, есть 10 объектов, и вы хотите анимировать в течение 2 секунд. Это установит animateTimePerObject = 2/10 = .2 Каждый элемент будет задержан на i (whatever position they are at) * the animatetime per object. Итак по порядку, 0, 0.2, 0.4, 0.6, 0.8, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2.

То же самое можно сделать с 2 объектами.

ИЛИ вы могли бы выполнить функцию log, которая позволяла бы расти, но более медленными темпами. Вот некоторые функции , на которые вы могли бы обратить внимание при использовании.

Добавьте эту функцию, чтобы создать пользовательскую функцию журнала

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for (i,object) in objects.enumerated() {
    let delay = i == 0 ? .25 : logC(Double(i)*10, forBase: 10) * 0.25
    object.animate(withDelay: delay)
}

This will slow down your 0.25*i rate to a much slower one.

0 -> .25
1 -> Log(20, base: 10) = 1.3 * 0.25 = .325
...
25 -> Log(250, base: 10) = 2.3979 * 0.25 = .6 

, где она была бы

0 -> .25
1 -> .25 * 2 = .5
25 -> .25 * 25 = 6.25

Вы можете играть с функцией журнала, как вам нравится, но это всего лишь некоторые идеи. Не совсем понятно, какой алгоритм вы ищете.

ПРИМЕЧАНИЕ: Возможно, там немного проблемы с синтаксисом, с Double и Int с, но вы можете отрегулировать! :)

Сравнение Log и Sqrt:

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for i in 0..<25 {
    let delay = i == 0 ? 0.25 : pow(logC(val: Double(i)*10, forBase: 10) * 0.25, log(1/Double(i))) * 0.45
    let delay2 = i == 0 ? 0.25 : sqrt(Double(i)) * 0.5
    print(delay, delay2)
}

0.25 0.25
0.45 0.5
0.9801911408397829 0.7071067811865476
1.3443747821649137 0.8660254037844386
1.5999258430124579 1.0
1.7853405889097305 1.118033988749895
1.9234257236285595 1.224744871391589
2.0282300761096543 1.3228756555322954
2.1088308307833894 1.4142135623730951
2.1713433790123178 1.5
2.2200343505615683 1.5811388300841898
2.2579686175608598 1.6583123951777
2.2874024254699274 1.7320508075688772
2.3100316733059247 1.8027756377319946
2.32715403828525 1.8708286933869707
2.33977794890637 1.9364916731037085
2.348697701417663 2.0
2.3545463958925756 2.0615528128088303
2.357833976756366 2.1213203435596424
2.358975047645847 2.179449471770337
2.35830952737025 2.23606797749979
2.3561182050020992 2.29128784747792
2.35263460234384 2.345207879911715
2.348054124507179 2.3979157616563596
2.3425411926260447 2.449489742783178

Вы можете воспользоваться приведенной ниже функцией, которая зависит от количества объектов, как вы указали ранее, и если в массиве будет больше объектов, каждая анимация будет выполняться с меньшей задержкой, но, тем не менее, задержка первого элемента будет длиннее последней: ]

for (i,object) in objects.enumerated() {
    object.animate(withDelay: ((1/((i+1)*0.5)) * 0.25) / objects.count)
}

Есть много паратезов, но я надеюсь, что это повысит читабельность, также я применил i + 1, чтобы у вас не было проблемы деления на ноль для первого элемента.

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

Примечание:

• Если вы считаете, что задержка слишком велика, когда в массиве мало элементов (что приведет к уменьшению числа «objects.count». Попробуйте заменить objects.count с (2 * objects.count)
• Также, если вы думаете обратное (задержка невелика), когда в массиве много элементов (что увеличит число «objects.count». Попробуйте заменить [ 113] с (objects.count / 2)