来自对数组的二进制矩阵答案

【问题标题】：Binary Matrix from Array of Pairs来自对数组的二进制矩阵
【发布时间】：2018-12-21 14:01:36
【问题描述】：

我在 java 中遇到以下问题：

我正在尝试创建一个二进制矩阵，其中输入是一对数组

ArrayList<Pair<String, String>> inputArray = new ArrayList<Pair<String, String>>();

所以可以说它看起来像这样：

[(argument1, value1), 
 (argument1, value2), 
 (argument1, value4),
 (argument2, value2), 
 (argument2, value4), 
 (argument3, value1),
 (argument3, value2),
 (argument3, value3),]

预期的输出是：

           value1   value2   value3   value4
argument1     1        1       0        1
argument2     0        1       0        1
argument3     1        1       1        0

我知道这个论坛上有关于如何创建二进制数组的答案，但我没有找到任何关于如何使用一对数组来完成的内容。

提前感谢您的任何提示。

输出

short[][] matrix = new short[rows][columns];

【问题讨论】：

对输出结构的要求？
所以输出应该是：short[][] binaryMatrix = new short[count(arguments)][count(values)];
您不能使用short 数组，因为您会丢失“argument1”和“value1”字符串？或者你不需要保留字符串，只想要一个 0/1 数组？
这里是short[][] 的解决方案，如果需要保留字符串，Map<String,Map<String,Integer>> 的解决方案
认真的吗？您似乎可以使用仅提供保持您的价值观的结构的解决方案，您从不谈论打印，对，考虑投票也可能

标签： java arrays matrix binary

【解决方案1】：

使用Map<String, Map<String,Integer>>，从第一张地图中您将选择argument，在第二张地图中您将选择value 并获得0 或1

ArrayList<Pair<String, String>> list = new ArrayList<>();
list.add(new Pair<>("ag1", "val1"));  list.add(new Pair<>("ag1", "val2"));
list.add(new Pair<>("ag1", "val4"));  list.add(new Pair<>("ag2", "val2"));
list.add(new Pair<>("ag2", "val4"));  list.add(new Pair<>("ag3", "val2"));
list.add(new Pair<>("ag3", "val2"));  list.add(new Pair<>("ag3", "val3"));

List<String> arguments = list.stream().map(Pair::getKey).distinct().collect(Collectors.toList());
List<String> values = list.stream().map(Pair::getValue).distinct().collect(Collectors.toList());

Map<String, Map<String,Integer>> map = new TreeMap<>();

for(String ag : arguments){
    map.putIfAbsent(ag, new TreeMap<>());

    for(String val : values){
        if(list.contains(new Pair<>(ag,val))){
            map.get(ag).put(val, 1);
        }else{
            map.get(ag).put(val,0);        
        }
    }

}
System.out.println(map);
//{ag1={val1=1, val2=1, val3=0, val4=1}, 
   ag2={val1=0, val2=1, val3=0, val4=1}, 
   ag3={val1=0, val2=1, val3=1, val4=0}}

使用short[][]，在stream 操作上只需添加sorted() 操作以确保保持顺序。它将遍历不同的arguments 和values，如果初始列表中有相应的Pair，它将设置好的索引为1，如果没有0

ArrayList<Pair<String, String>> list = new ArrayList<>();
list.add(new Pair<>("ag1", "val1"));  list.add(new Pair<>("ag1", "val2"));
list.add(new Pair<>("ag1", "val4"));  list.add(new Pair<>("ag2", "val2"));       
list.add(new Pair<>("ag2", "val4"));  list.add(new Pair<>("ag3", "val2"));
list.add(new Pair<>("ag3", "val2"));  list.add(new Pair<>("ag3", "val3"));

List<String> arguments = list.stream().map(Pair::getKey).distinct().sorted().collect(Collectors.toList());
List<String> values = list.stream().map(Pair::getValue).distinct().sorted().collect(Collectors.toList());

short[][] res = new short[arguments.size()][values.size()];      

for(int ag = 0 ; ag<arguments.size() ; ag++){
    for(int val = 0 ; val<values.size() ; val++){  
        if(list.contains(new Pair<>(arguments.get(ag),values.get(val)))){
            res[ag][val] = 1;
        }else{
            res[ag][val] = 0;        
        }
    }    
}
System.out.println(Arrays.deepToString(res)); 
// [[1, 1, 0, 1], [0, 1, 0, 1], [0, 1, 1, 0]]

【讨论】：

【解决方案2】：

这是一种使用分组来模拟数据透视表的替代方法：

List<String> rights = inputArray.stream()
        .map(Pair::getRight)
        .distinct()
        .sorted()
        .collect(Collectors.toList());

List<Pair<String, Map<String, Boolean>>> mapping = inputArray.stream()
        .collect(Collectors.groupingBy(Pair::getLeft, 
                    Collectors.mapping(Pair::getRight, Collectors.toSet())))
        .entrySet().stream()
        .map(entry -> {
            Map<String, Boolean> values = new HashMap<>();

            rights.stream().forEach(v -> {
                values.put(v, entry.getValue().contains(v) ? Boolean.TRUE : Boolean.FALSE);
            });

            return Pair.of(entry.getKey(), values);
        }).collect(Collectors.toList());

打印该地图会产生以下结果：

rights.forEach(r -> System.out.print(r + " | "));
System.out.println();
mapping.forEach((key) -> {
    StringBuilder sb = new StringBuilder(key.getLeft() + " | ");
    rights.forEach(rr -> sb.append((key.getRight().get(rr) ? "      1" : "      0") + "|"));
    System.out.println(sb);
});

结果：

            value1 | value2| value3| value4| 
argument1 |       1|      1|      0|      1|
argument2 |       0|      1|      0|      1|
argument3 |       1|      1|      1|      0|

【讨论】：