Lerp to target position in X amount of time

This script is attached to a pickupable item. I want to make this Item launch toward the player’s position on start (so basically when it spawns). I want the item to be launched toward the player’s position in an arc pathway. I have achieved this so far, but I want to make it so that depending on how far the item is from the player, it will launch at the player at different speeds, and heights. So for instance, if the item is right next to the player, it will launch slower, because it doesn’t need to cover as much distance, and if it is farther away from the player, it will launch at the player faster (also having a higher arc).

Can anyone help with this I am really stuck

using System.Collections;
using UnityEngine;

public class ItemLaunch : MonoBehaviour
{
    /// <summary>
    /// The player to target
    /// </summary>
    [SerializeField]
    private Transform player;

    /// <summary>
    /// The curve giving the throw amplitude according
    /// to the distance to the player
    /// </summary>
    [SerializeField]
    private AnimationCurve distanceToAmplitudeFunction ;

    /// <summary>
    /// The start position
    /// </summary>
    private Vector3 startPosition;

    /// <summary>
    /// The target position
    /// </summary>
    private Vector3 targetPosition;

    /// <summary>
    /// The coroutine
    /// </summary>
    private IEnumerator coroutine;

    // Use this for initialization
    void Start ()
    {
        // Called in the Start method for the example,
        // but you can call it whenever you want
        // Here, I use an animation curve to determine the amplitude,
        // but you can use a plain function, like Vector3.Distance( player.position, transform.position ) * 2 for instance
        // or Mathf.Exp( Vector3.Distance( player.position, transform.position ) )
        Launch( 1, distanceToAmplitudeFunction.Evaluate( Vector3.Distance( player.position, transform.position ) ) );	
    }

    /// <summary>
    /// Launches the item
    /// </summary>
    /// <param name="duration">The flight duration.</param>
    /// <param name="amplitude">The throw amplitude.</param>
    public void Launch( float duration, float amplitude )
    {
        startPosition = transform.position;
        targetPosition = player.position;

        if ( coroutine != null )
            StopCoroutine( coroutine );

        coroutine = Fly( duration, amplitude );
        StartCoroutine( coroutine );
    }

    /// <summary>
    /// Flies during the specified duration
    /// </summary>
    /// <param name="duration">The flight duration.</param>
    /// <param name="amplitude">The throw amplitude.</param>
    /// <returns></returns>
    private IEnumerator Fly( float duration, float amplitude )
    {
        if ( duration > Mathf.Epsilon )
        {
            for ( float progress = 0 ; progress < duration ; progress += Time.deltaTime )
            {
                transform.position = Vector3.Lerp( startPosition, targetPosition, progress / duration ) + Vector3.up * Mathf.Sin( progress / duration * Mathf.PI) * amplitude;
                yield return null;
            }
        }
        transform.position = targetPosition ;
        coroutine = null;
    }
}

@b2hinkle
Here you are using Lerp in the Update function with the start position as the current transform position.
The transform position is also updated in the same function causing the pickup item to move closer to the player every frame. This is a common approach but the movement will seem rather independent of time.
To make it time dependent, keep the start position constant and gradually change the lerp factor every frame.
This can be achieved as follows-
In the start method, initialize a timer = 0f. This timer will be our lerp factor and will go from 0 to 1 where timer at 0 denotes that the pickup is at the start position and 1 denotes that it has reached the player.
In the update method, try this -

timer += Time.deltaTime/n;
if (timer<1){
transform.position = Vector3.Lerp(startPosition, player.transform.position, timer);
}

Please note that here n denotes the
no. of seconds taken for the coin to
move from its start position to the
player.

Setting n = 1 will complete the journey in 1 second, =2 in 2 seconds and so on. Adjust it to get the required speed. Also note that in the Lerp function, my first argument is the startPosition (which you have initialized in the Start method and doesn’t change with time for this item instead of transform.position which was being changed every frame in your code.
Hope it works!