Instead of using a loop, you can leverage `np.einsum` or direct broadcasting with array operations. Here are two approaches:

### 1. Using `np.einsum` (Most Elegant)
```python
c = np.einsum('...i,...->...i', a, b)
```

### 2. Using Broadcasting with Array Operations
```python
c = a * b[..., np.newaxis]
```

### Explanation
- **Input Assumptions**:

• `a` has shape, e.g., `(..., K)` where `K` is the last dimension.
• `b` has shape, e.g., `(...)`, and `a.shape[:-1]` and `b.shape` are broadcastable.
• The output `c` should have shape `(*broadcasted_shape, K)`, where `broadcasted_shape` is the result of broadcasting `a.shape[:-1]` and `b.shape`.

- **Why These Work**:

• **Broadcasting Approach**:

  • `b[..., np.newaxis]` adds a new axis to `b`, making its shape `(..., 1)`.
  • When `a` (shape `(..., K)`) is multiplied with `b[..., np.newaxis]`, NumPy broadcasts `b` across the last dimension of `a`, effectively performing `a[..., i] * b` for each `i` in a vectorized manner.
  • The result has shape `(*broadcasted_shape, K)`.

• **Einsum Approach**:

  • `np.einsum('...i,...->...i', a, b)` explicitly describes the operation:
    • `...` represents the broadcastable dimensions of `a.shape[:-1]` and `b.shape`.
    • `i` indexes the last dimension of `a`.
    • The output `...i` keeps the broadcasted shape plus the last dimension of `a`.
  • This is concise and optimized for performance.

### Why These Are Better
- **No Loops**: Both methods avoid explicit Python loops, which are slow compared to NumPy's vectorized operations.
- **Idiomatic**: Using `np.einsum` or broadcasting is standard in NumPy for such operations.
- **Performance**: Both approaches are generally faster than the loop, especially for large arrays, as they leverage NumPy's optimized C-based operations.
- **Readability**: The code is more concise and expressive.

### When to Use Which
- **Broadcasting (`a * b[..., np.newaxis]`)**: Use this for simplicity and when the operation is straightforward. It's intuitive if you're familiar with NumPy broadcasting.
- **Einsum**: Use `np.einsum` for maximum clarity in complex operations or when you need fine-grained control over indexing. It can also be slightly more performant in some cases due to optimized execution paths.

### Example
```python
import numpy as np

# Example arrays
a = np.ones((2, 3, 4)) # Shape: (2, 3, 4)
b = np.ones((3,)) # Shape: (3,)

# Original loop-based approach
c = np.empty(np.broadcast_shapes(a.shape[:-1], b.shape) + (a.shape[-1],), a.dtype)
for i in range(a.shape[-1]):
c[..., i] = a[..., i] * b

# Broadcasting approach
c_broadcast = a * b[..., np.newaxis]

# Einsum approach
c_einsum = np.einsum('...i,...->...i', a, b)

# Verify results are identical
print(np.array_equal(c, c_broadcast)) # True
print(np.array_equal(c, c_einsum)) # True
```

Both methods produce the same result as your loop but are more concise and typically faster. If performance is critical, you can benchmark both approaches with your specific array sizes, but `np.einsum` is often preferred for its clarity and optimization.