如何将[0,1]区间内n个不同值映射为[0,n-1]的唯一整数索引？

这个需求在把连续数值转换成离散索引的场景里挺常见的，我分两种实用的场景给你拆解解法：

一、通用解法：基于排序的索引映射（适用于任何分布的n个不同值） #

不管你的[0,1]区间内的数值是均匀分布还是杂乱无章，这种方法都能保证每个值对应唯一的[0,n-1]整数索引，步骤超简单：

• 第一步：把所有n个不同的[0,1]值放到列表里，做一次排序
• 第二步：对每个原始值，找到它在排序后列表中的位置索引，这个索引就是你要的[0,n-1]整数

举个例子：假设n=4，给定值是[0.15, 0, 0.05, 0.1]（故意打乱顺序）

1. 排序后得到：[0, 0.05, 0.1, 0.15]
2. 每个原始值对应的索引就是：0.15→3，0→0，0.05→1，0.1→2

用Python代码实现的话：

def map_to_index(values):
    sorted_vals = sorted(values)
    # 先建一个值到索引的映射字典
    val_to_idx = {val: idx for idx, val in enumerate(sorted_vals)}
    # 给每个输入值返回对应的索引
    return [val_to_idx[val] for val in values]

# 测试示例
input_vals = [0.15, 0, 0.05, 0.1]
print(map_to_index(input_vals))  # 输出: [3, 0, 1, 2]

这种方法的好处是完全不依赖数值分布，只要是n个不同的值，就能拿到唯一的整数索引，而且根本不需要后续用floor()处理，直接就是整数，稳得一批。

二、线性缩放解法（适用于均匀分布或已知数值范围的场景） #

如果你的n个[0,1]值是均匀间隔分布的（比如你示例里的0、0.05、0.1、0.15），那线性缩放会更高效，步骤是：

1. 计算缩放因子：如果最小值是0，就用scale = (n-1) / max_value；更通用的情况是scale = (n-1) / (max_value - min_value)，再用(val - min_val)来把数值偏移到0起点
2. 对每个值应用缩放：scaled_val = (val - min_val) * scale
3. 最后用floor()取整得到整数索引（如果缩放结果不是整数的话）

拿你的示例来说：n=4，值是[0,0.05,0.1,0.15]

• min_val=0，max_val=0.15，scale=(4-1)/0.15=20
• 每个值乘以20直接得到0、1、2、3，完美匹配要求

但要注意，这种方法只适合均匀分布的情况，如果数值间隔不均匀，很可能出现重复索引。比如值是[0.1, 0.3, 0.6, 0.9]，n=4：

• scale=(3)/(0.9-0.1)=3.75
• 计算后得到：0、0.75、1.875、3
• 用floor()处理后得到0、0、1、3，这里0.3和0.1的索引重复了，就不符合要求了。

Python代码示例（均匀分布场景）：

import math

def linear_map_to_index(values, n):
    min_val = min(values)
    max_val = max(values)
    scale = (n-1) / (max_val - min_val)
    return [math.floor((val - min_val) * scale) for val in values]

# 测试均匀分布示例
input_vals = [0, 0.05, 0.1, 0.15]
print(linear_map_to_index(input_vals, 4))  # 输出: [0,1,2,3]

# 测试非均匀分布（会出现重复索引，不适用）
input_vals = [0.1, 0.3, 0.6, 0.9]
print(linear_map_to_index(input_vals, 4))  # 输出: [0,0,1,3]

总结 #

• 如果你的数值分布不确定，或者想100%保证拿到唯一的[0,n-1]整数索引，优先用排序映射法
• 如果确定数值是均匀间隔分布的，线性缩放法会更高效，不需要额外的排序操作

内容的提问来源于stack exchange，提问作者user1443317