Question

这是最近一次编程采访中提出的一个问题。

给定字符串“str”和一对“N”交换索引，生成按字典顺序排列的最大字符串。交换索引可以重复使用任意次数。

例如：

String = "abdc" 
Indices: 
(1,4) 
(3,4)

答案：

cdba, cbad, dbac,dbca

您应该只打印字典上最大的“dbca”。

这可能听起来很幼稚，但我完全没有回答这个问题。有人可以帮我理解这个问题的含义吗？

Answer 1

我认为，鉴于字符串mystring = "abdc"，您被指示在指定的索引对处切换字符，以便您按字典顺序生成＆＃34;最大的＆＃34;字符串（即，如果你lex-sorted所有可能的字符串，它将最终在最后一个索引处）。因此，您有两个有效的操作：（1）切换mystring[1] mystring[4]（"abdc" - ＆gt; "cbda"），以及（2）切换mystring[3] mystring[4]（"abdc" - ＆gt; "abcd"）。此外，您可以乘以链操作：操作（1）后跟（2）（"abdc" - ＆gt; "cbda" - ＆gt; "cbad"），反之亦然（{{ 1}} - ＆gt; "abdc" - ＆gt; "abcd"），依此类推等等（"dbca" - ＆gt; "abdc" - ＆gt; {{ 1}} - ＆gt; "cbda"）。

然后你（反向）lex-sort这些并弹出顶部索引：

"cbad"

Answer 2

根据@ncemami的澄清，我提出了这个解决方案。

public static String swap(String str, Pair<Integer, Integer> p1, Pair<Integer, Integer> p2){

        TreeSet<String> set = new TreeSet<>();
        String s1 = swap(str, p1.getKey(), p1.getValue());
        set.add(s1);
        String s2 = swap(s1, p2.getKey(), p2.getValue());
        set.add(s2);
        String s3 = swap(str, p2.getKey(), p2.getValue());
        set.add(s3);
        String s4 = swap(s3, p1.getKey(), p1.getValue());
        set.add(s4);
        return set.last();

    }
    private static String swap(String str, int a, int b){
        StringBuilder sb = new StringBuilder(str);
        char temp1 = str.charAt(a);
        char temp2 = str.charAt(b);
        sb.setCharAt(a, temp2);
        sb.setCharAt(b, temp1);
        return sb.toString();
    }

Answer 3

这是我的Java解决方案：

String swapLexOrder(String str, int[][] pairs) {
Map<Integer, Set<Integer>> neighbours = new HashMap<>();

for (int[] pair : pairs) {
    // It contains all the positions that are reachable from the index present in the pairs
    Set<Integer> reachablePositionsL = neighbours.get(pair[0]);
    Set<Integer> temp = neighbours.get(pair[1]); // We use it just to merge the two sets if present

    if (reachablePositionsL == null) {
        reachablePositionsL = (temp == null ? new TreeSet<>() : temp);
    } else if (temp != null) {
        // Changing the reference so every addition to "reachablePositionsL" will reflect on both positions
        for (Integer index: temp) {
            neighbours.put(index, reachablePositionsL);
        }
        reachablePositionsL.addAll(temp);
    }
    reachablePositionsL.add(pair[0]);
    reachablePositionsL.add(pair[1]);
    neighbours.put(pair[0], reachablePositionsL);
    neighbours.put(pair[1], reachablePositionsL);
}

StringBuilder result = new StringBuilder(str);
for (Set<Integer> set : neighbours.values()) {
    Iterator<Character> orderedCharacters = set.stream()
        .map(i -> str.charAt(i - 1))
        .sorted(Comparator.reverseOrder())
        .iterator();

    set.forEach(i -> result.setCharAt(i - 1, orderedCharacters.next()));
}
return result.toString();
}

Here一篇解释我的问题的文章。

Answer 4

String = "abcd"

co_ord = [(1,4),(3,4)]

def find_combinations(co_ord, String):

    l1 = []
    for tup_le in co_ord:
        l1.extend(tup_le)
    l1 = [x-1 for x in l1]
    l1 = list(set(l1))
    l2 = set(range(len(String)))-set(l1)
    return l1,int(''.join(str(i) for i in l2))

def perm1(lst):

    if len(lst) == 0:
        return []
    elif len(lst) == 1:
        return [lst]
    else:
        l = []
        for i in range(len(lst)):
            x = lst[i]
            xs = lst[:i] + lst[i+1:]
            for p in perm1(xs):
                l.append([x]+p)
        return l

lx, ly = find_combinations(co_ord, String)    

final = perm1(lx)

print(final)

temp = []

final_list=[]

for i in final:

    for j in i:

        temp.append(String[j])

    final_list.append(''.join(temp))

    temp=[]

final_list = [ i[:ly] + String[ly] + i[ly:] for i in final_list]    

print(sorted(final_list,reverse=True)[0])

难以理解的技术面试

4 个答案: