查找两个字符串的最小连接数

Question

Alice 有两个字符串，初始和目标。她可以从初始字符中删除一些字符，这将为她提供该字符串的子序列。没有删除的字符串仍被视为其自身的子序列。给定这两个字符串，你能找到初始子序列的最小数量，当它们附加在一起时，将形成目标？

函数 minimumConcat() 有两个参数：

initial：您将从中获取子序列的源字符串 目标：需要形成的目标字符串

输入格式 对于我们的一些模板，我们已经为您处理了解析。如果我们没有为您提供解析功能，您将需要直接解析输入。在这个问题中，我们的输入格式如下：

第一行是我们将从中生成子序列的初始字符串 第二行是要形成的目标字符串 以下是原始输入的示例：

abc bcbac

预期输出 返回 initial 的最小可能子序列的数量，这些子序列可以附加在一起形成目标。

如果没有可能的解决方案，则返回 -1。 示例 minimumConcat() 输入 #1

initial: "xyz"
goal: "xzyxz"

输出：3

function minimumConcat(initial, goal) {
     //Put your code here.
    return 0;
}

Answer 1

循环初始字符串数组形成目标字符串数组。

function minimumConcat(initial, goal) {
    initial = initial.split('');
    goal = goal.split('');
    let res,count=0;
    while(true){
        if(goal.length > 0){
            res = checkChar(initial,goal);
            if(false === res){
                return -1;
            }
        }else{
            return count;
        }
        goal = res;
        count++;
    }
}
function checkChar(initial,goal){
    let started = false;
    let foundIndex = 0;
    for(let i=0; i<initial.length; i++){
        if(initial[i] == goal[foundIndex]){
            started = true;
            foundIndex++;
        }
    }
    if(started){
        return goal.slice(foundIndex);
    }else{
        return false;
    }
}
console.log(minimumConcat('abc','bcbac'));

Answer 2

给你！

function minimumConcat(initial, goal) {
let result = 0;
let pattern = '';
let count1 = Array.apply(null, Array(26)).map(Number.prototype.valueOf, 0);
let count2 = Array.apply(null, Array(26)).map(Number.prototype.valueOf, 0);

initial.split('').forEach(c => {
    pattern = pattern + c
});
pattern = "^[" + pattern + "]*$";

if (!RegExp(pattern).test(goal)) return -1;

for (let i = 0; i < initial.length; i++) {
    count1[initial.charCodeAt(i) - 97]++;
}

for (let i = 0; i < goal.length; i++) {
    count2[goal.charCodeAt(i) - 97]++;
}

for (let i = 0; i < 26; i++) {
    result += Math.abs(count1[i] - count2[i]);
}

return result;
}

console.log(minimumConcat("abc", "bcbac"));

Answer 3

由于这看起来像家庭作业，我不会马上给出解决方案，而是这里有一个关于如何解决它的建议：

我认为最难的部分是找到所有子字符串，如果您使用的是由itertools 简化的 Python，如提到的here。

编辑，我没有注意到javascript标签，你可以得到子字符串集，没有库，有几个for循环。

从initial 获得所有组合后，您可以对它们进行排序，使其具有最长的第一个。然后从goal 中一一删除。每次删除时都会计数。如果在遍历所有子字符串后，goal 不是空字符串，那么initial 的任何子序列都不能构造goal。

Answer 4

这使用 Java 回答了您的问题

public static int minimumConcat(String initial, String goal) {
        HashSet<Character> set = new HashSet<>();
        for(char c : initial.toCharArray()) set.add(c);
        for(char c : goal.toCharArray()) {
            if(!set.contains(c)) return -1;
        }
        int j = 0, result = 0;
        for(int i = 0; i < goal.length();) {
            char c = goal.charAt(i);
            while(j < initial.length() && initial.charAt(j) != c) j++;
            if(j == initial.length()) {
                j = 0;
                result++;
            } else {
                j++;
                i++;
            }
        }
        result++;
        return result;
   }

Answer 5

这是我用python所做的

def minimumConcat(initial, goal):
   #verify that goal has all character of initial
    res = 0
    for i in goal:
        if i in initial:
            pass
        else:
            res=-1;

    if res != -1:
        while goal!="":
            a = removefirstGreatestSubstring(initial,goal)
            goal=a["goal"];
            if a["has"] ==True :
                res=res+1
        #find the greatest concat 
    print(res)

def removefirstGreatestSubstring(initial,goal):
    has_subtring = False
    start = 0
    for car in initial:
        if car == goal[start]:
            has_subtring= True
            start = start+1
            finalgoal=goal[start:]
    return {"goal": finalgoal, "has":has_subtring}

initial = "abc"
goal = "bcbac"
b = minimumConcat(initial, goal)

Answer 6

我已经通过正则表达式使用了不同的方法。

这里是代码的干净版本：

"use strict";

// Solution:
function minimumConcat(initial, goal) {

    let result = -1;
    let goal_slice = goal;
    let exp = "", sub = "";
    let initial_concat =  "";
    let matches = 0, count = 0; 
    let initial_arr = initial.split('');

    for(let i = 0 ; i<initial_arr.length; i++){
        for(let j = initial_arr.length ; j>i+1; j--){
            sub = initial.slice(i,j);
            exp = new RegExp(sub,"ig");
            matches = (goal_slice.match(exp) || []).length; 
            if(matches>=1) {
                count +=matches;
                initial_concat+=sub.repeat(matches);
                goal_slice = goal_slice.slice((goal_slice.lastIndexOf(sub)+sub.length));
            }
        }      
    }

    result = (initial_concat==goal)? count : result;
    return result; 
}

// Test cases:
let test_cases = [
    {initial:"abc", goal: "abcbc"},  // expected result  2
    {initial:"abc", goal: "acdbc"},  // expected result -1
    {initial:"bcx", goal: "bcbcbc"}, // expected result  3
    {initial:"xyz", goal: "xyyz"},   // expected result  2
]

// Running the tests:
test_cases.forEach(function(item,index){
    console.log(minimumConcat(item.initial, item.goal));
});

此外，我还添加了一个调试标志来打开/关闭 console.log 消息，以便任何人都可以轻松了解每个迭代周期中发生的情况。

"use strict";

// Shwitch for debugging:
const debug = true;

// Solution:
function minimumConcat(initial, goal) {

    let exp = "";
    let sub = "";
    let match = 0;
    let count = 0;
    let result = -1;
    let goal_slice = goal;
    let initial_concat =  "";

    let initial_arr = initial.split('');

    for(let i = 0 ; i<initial_arr.length; i++){
        for(let j = initial_arr.length ; j>i+1; j--){
            sub = initial.slice(i,j);
            exp = new RegExp(sub,"ig");
            match = (goal_slice.match(exp) || []).length; 
            if(match>=1) {
                count +=match;
                initial_concat+=sub.repeat(match);
                goal_slice = goal_slice.slice((goal_slice.lastIndexOf(sub)+sub.length));
            }

            if(debug){
                console.log("-----------------------------");
                console.log("   i:", i, " - j:", j);
                console.log("   exp:", exp);
                console.log("   goal:", goal);
                console.log("   goal_slice:", goal_slice);
                console.log("   match:",match);  
            }    
        }      
    }

    result = (initial_concat==goal)? count : result;

    if(debug){
        console.log("---RESULTS:--------------------------");
        console.log("count:",count);
        console.log("goal vs initial_concat: ", goal, " - ", initial_concat);
        console.log("result: ", result);
    }

    return result; 
}

// Test cases:
let test_cases = [
    {initial:"abc", goal: "abcbc"},  // expected result  2
    {initial:"abc", goal: "acdbc"},  // expected result -1
    {initial:"bcx", goal: "bcbcbc"}, // expected result  3
    {initial:"xyz", goal: "xyyz"},   // expected result  2
]

// Running the tests:
test_cases.forEach(function(item,index){    
    if(debug){
        console.log("-----------------------------");
        console.log("TEST CASE #",index,":");
        console.table(item);
    }
    minimumConcat(item.initial, item.goal);
});

Answer 7

这里是 php

public function index()
{

    $init="abc";
    $goal="abacabacabacacb";
    $res=$this->minimum($init,$goal);

}

public function check($inital,$goal){
    $inital=str_split( $inital);
    $goal=str_split( $goal);


    for($i=0;$i<sizeof($goal);$i++){
        if(!in_array($goal[$i],$inital)){
            return -1;
        }
    }
    return 0;

}
public function minimum($inital,$goal){
    $res=$this->check($inital,$goal);
    if($res==-1){
        return -1;
    }
    $counter=0;
    $c=0;
    $inital=str_split( $inital);
    $goal=str_split( $goal);


    for($i=0;$i<sizeof($goal);$i++){
        for($j=0;$j<sizeof($inital);$j++){

            if(($i+$c)<sizeof($goal)){

                echo " ".$i." > ".$j." > ".$c."   /// ";
                if($goal[$i+$c]==$inital[$j]){
                    $c+=1;
                }
            }

        }

        $counter+=1;
         if(($i+$c)>=sizeof($goal)){
            break;
        } 
        $c=$c-1;

    }


    return $counter;
}

Answer 8

这是我的python解决方案

def check_char(initial, goal):
    N = len(initial)
    started = False
    found_index = 0
    for i in range(N):
        if (initial[i] == goal[found_index]):
            started = True
            found_index += 1
    if(started):
        return goal[found_index:]
    else:
        return '-'


def minimumConcat(initial, goal):
    res = 0
    count = 0
    while(True):
        if( len(goal) > 0 ):
            res = check_char(initial, goal)
            if(res == '-'):
               print(-1)
               break;
        else:
            print(count)
            break;

        goal = res
        count += 1

initial = input()
goal = input()
minimumConcat(initial, goal)