Java 将整数列表转换为单词

我正在做一个游戏，这个游戏有一个组件，它会根据生物的属性为它指定一个特定的名字。具体来说，我有一组整数，告诉我游戏中的生物拥有哪些属性，我需要根据这些特定属性来制定一个名称

---

我当时的想法是：给每个数字1-47分配一个音节（通过Hashmap），这种方式取决于动物的哪个属性，字符串会有所不同。然而，一个明显的缺陷是字符串太长。我写了一个算法，如果有超过4个音节，它基本上是组合音节的。然而，这种方法产生了许多类似的结果，特别是在大约20个音节缩减为4个之后。有人对我如何将一系列整数转换成一个有点独特的易读单词有什么想法吗？（有些副本还可以，但在大多数情况下，我希望每个数字组合都有一个唯一的单词）

我正在使用哈希代码将整数列表转换为一个16位整数。然后把这个int转换成一个字符串，假设它是一个以n为基数的数字系统，其中n是音节的数目，每个数字是一个音节。（通过将int限制在16位，你的音节就少了）。我不知道这是否合理，但我希望输出能满足您的要求

    import java.util.Arrays;
import java.util.List;

public class NameGenerator {

    final static List<String> syllables = Arrays.asList("ka", "sa", "ta", "na", "ha", "ma", "ya", "ra", "wa",
            "ki", "si", "ti", "ni", "hi", "mi", "yi", "ri", "wi",
            "ku", "su", "tu", "nu", "hu", "mu", "yu", "ru", "wu",
            "ke", "se", "te", "ne", "he", "me", "ye", "re", "we",
            "ko", "so", "to", "no", "ho", "mo", "yo", "ro", "wo");
    final static int maxSyllable = syllables.size() - 1;

    public static void main(String[] args) {
        int[] attributes = new int[]{25, 325, 4, 2, 11, 98, 23};
        String name = toName(attributes);
        System.out.println("name = " + name);
    }

    public static String toName(int[] attributes) {
        int hashCode = Arrays.hashCode(attributes);
        int smallHashCode = (hashCode >> 16) ^ (hashCode & 0xffff);
        return toName(smallHashCode);
    }

    public static String toName(int i) {
        if (i < 0) {
            i = -i;
        }
        StringBuilder buf = new StringBuilder();
        while (i > maxSyllable) {
            buf.append(syllables.get(i % maxSyllable));
            i = i / maxSyllable;
        }
        buf.append(syllables.get(i));
        return buf.toString();
    }
}

导入java.util.array；
导入java.util.List；
公共类名称生成器{
最终静态列表音节=数组。asList（“ka”、“sa”、“ta”、“na”、“ha”、“ma”、“ya”、“ra”、“wa”，
“ki”、“si”、“ti”、“ni”、“hi”、“mi”、“yi”、“ri”、“wi”，
"苦,苏,土,怒,胡,木,玉,儒,吴",，
“克”、“色”、“特”、“尼”、“他”、“我”、“叶”、“热”、“我们”，
“ko”、“so”、“to”、“no”、“ho”、“mo”、“yo”、“ro”、“wo”）；
final static int max音节=音节.size（）-1；
公共静态void main（字符串[]args）{
int[]attributes=newint[]{25325,4,2,11,98,23}；
字符串名称=toName（属性）；
System.out.println（“name=“+name”）；
}
公共静态字符串toName（int[]属性）{
int hashCode=Arrays.hashCode（属性）；
int smallHashCode=（hashCode>>16）^（hashCode&0xffff）；
返回toName（smallHashCode）；
}
公共静态字符串toName（int i）{
if（i<0）{
i=-i；
}
StringBuilder buf=新的StringBuilder（）；
while（i>max音节）{
buf.append（音节.get（i%最大音节））；
i=i/最大音节；
}
附加（音节.get（i））；
返回buf.toString（）；
}
}

此解决方案基于Java 8流API。
如果整数序列中的每个数字小于音节数组长度，则该方法返回唯一的单词

final static String[] syllables = new String[] {"ka", "sa", "ta", "na", "ha", "ma", "ya", "ra", "wa",
        "ki", "si", "ti", "ni", "hi", "mi", "yi", "ri", "wi",
        "ku", "su", "tu", "nu", "hu", "mu", "yu", "ru", "wu",
        "ke", "se", "te", "ne", "he", "me", "ye", "re", "we",
        "ko", "so", "to", "no", "ho", "mo", "yo", "ro", "wo"};

public static String listToString(List<Integer> list) {
    return list.stream().map(num -> syllables[num % syllables.length])
                        .collect(Collectors.joining(""));
}

最终静态字符串[]音节=新字符串[]{“ka”、“sa”、“ta”、“na”、“ha”、“ma”、“ya”、“ra”、“wa”，
“ki”、“si”、“ti”、“ni”、“hi”、“mi”、“yi”、“ri”、“wi”，
"苦,苏,土,怒,胡,木,玉,儒,吴",，
“克”、“色”、“特”、“尼”、“他”、“我”、“叶”、“热”、“我们”，
“ko”、“so”、“to”、“no”、“ho”、“mo”、“yo”、“ro”、“wo”}；
公共静态字符串listToString（列表）{
return list.stream（）.map（num->sylleles[num%sylleles.length]）
.collect（收集器。连接（“”）；
}

用一个枚举表示“整数系列（列表）”，用一个：

好处：

生成一个字符串的唯一单词字符串 生物属性的组合

无论顺序是什么，可预测顺序都由枚举定义 属性被添加到生物中

位集提供了方便的集操作，并且比存储整数需要更少的内存

---

散列函数的作用几乎相同。尝试对属性进行散列，然后从前几个字节生成名称，可以选择使用前几个位作为音节数。编程语言是什么？爪哇？谢谢！我会调查比特集的！谢谢你的回复，我也会调查的@我已经修改了我的答案。若序列中的每个数字都小于音节数组的长度，那个么结果单词应该是唯一的。我把这段代码放到eclipse中，非常棒！我也喜欢代码的简洁，非常感谢您的代码！听到这个消息我很高兴。谢谢你提出这么有趣的问题。

import java.util.BitSet;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class BitSetString {
    private static Pattern regex = Pattern.compile("(\\d+)");
    private static Prop[] props = Prop.values(); 
    public static void main(String[] args) {
        BitSet bs = new BitSet(47) {
            @Override public String toString() {
                Matcher m = regex.matcher(super.toString());
                StringBuffer r = new StringBuffer();
                while (m.find()) m.appendReplacement(r, props[Integer.parseInt(m.group())].toString());
                m.appendTail(r);
                return r.toString();
            }
        };
        bs.set(Prop.ZED.ordinal());
        bs.set(Prop.IFF.ordinal());
        bs.set(Prop.WOW.ordinal());
        bs.set(Prop.HEX.ordinal());
        bs.set(Prop.ALT.ordinal());
        bs.set(Prop.FOO.ordinal());
        System.out.println(bs.toString()); // outputs '{FOO, WOW, IFF, ZED, HEX, ALT}'
    }

    private static enum Prop {
        FOO, BAR, WOW, HEY, CAN, CAR, CUB, BIG, FAT, DRY, WET, EGO, MEH, EYE,
        GOD, GUN, IFF, JOY, KEG, LOG, NIL, OHM, PIG, SAX, SKY, TIC, VIM, VOX,
        YIN, ZED, HEX, HOG, GNU, ELF, CAB, BUS, ABS, ALT, ANY, CUE, DIF, FEZ,
    }
}