Блог

Прошу прощения за мой английский. Мне нужна функция для разделения строки во всех вариантах, порядок и длина остаются неизменными.

введите ‘abc’

выведите ‘abc / a,bc / ab, c / a, b, c’

или

введите ‘rrd’

выведите ‘rrd / r,rd / rr, d / r, r, d’

Спасибо

Проверьте этот «красивый» код, хороший тренажер для мозга для меня 🙂
Это определенно нуждается в некоторой оптимизации, но работает идеально.
Примечание: array_reverse() и strrev() можно удалить, но так порядок выглядит лучше.

 function TheFunction($s) {
    for($i=strlen($s)-1;$i>0;$i--) $h .= '1';
    $z = str_replace('1','0',$h);
    for($i=bindec($h);$i>=0;$i--) $array[] = strrev(substr_replace($z, decbin($i), strlen($z)-strlen(decbin($i))));
    foreach($array as $value){
        $value = str_replace(array('0','1'),array(' ',','),$value);
        $string = '';
        for($i=0;$i<strlen($s)-1;$i  ) $string .= $s[$i].$value[$i];
        $string .= $s[strlen($s)-1];
        $results[] = str_replace(' ','',$string);
    }
    return array_reverse($results);
}
  

Пример

 print_r(TheFunction('Anne'));
  

ВОЗВРАТ

 Array
(
    [0] => Anne
    [1] => A,nne
    [2] => An,ne
    [3] => A,n,ne
    [4] => Ann,e
    [5] => A,nn,e
    [6] => An,n,e
    [7] => A,n,n,e
)
  

Другой пример

 print_r(TheFunction('Stack'));
  

ВОЗВРАТ:

 Array
(
    [0] => Stack
    [1] => S,tack
    [2] => St,ack
    [3] => S,t,ack
    [4] => Sta,ck
    [5] => S,ta,ck
    [6] => St,a,ck
    [7] => S,t,a,ck
    [8] => Stac,k
    [9] => S,tac,k
    [10] => St,ac,k
    [11] => S,t,ac,k
    [12] => Sta,c,k
    [13] => S,ta,c,k
    [14] => St,a,c,k
    [15] => S,t,a,c,k
)
  

Я сделал что-то похожее на Anne, за исключением того, что я использовал класс Variations от Adrian Akison здесь.

Как и в решении Энн, я нахожу все варианты единиц и 0 (Variations.cs) длиной на 1 меньше исходной строки. Это делается с учетом смещения запятой. Обратите внимание, что позже я заменю 1 запятыми, а 0 — пустым пробелом.

«Битная» строка 111 = «,,,» или 101 = «, , ,» и т. Д

Итак, получите все варианты определенного размера, используя определенные символы, в данном случае 1 и 0:

     private HashSet<string> fetchBinaryVariations(int size)
    {
        HashSet<string> returnVal = new HashSet<string>();
        String variationResultItem = string.Empty;
        string[] oneZero = { "1", "0" };

        /* Generate all variations of 1's and 0's given size using Adrian Akison's handy dandy variations class */
        Variations<string> variationsList = new Variations<string>(oneZero.ToList<string>(), size, GenerateOption.WithRepetition);
        Console.WriteLine("Total Variations: {0}", variationsList.Count());

        foreach (List<string> variationItem in variationsList)
        {
            variationResultItem = String.Join("", variationItem);
            returnVal.Add(variationResultItem);
            // Console.WriteLine("Variation: {0}", variationResultItem);
        }
        return returnVal;
    }
  

Далее я беру эти «битовые» строки, преобразую их в запятые и пробелы и объединяю их с моей исходной последовательностью. В моем случае у меня есть еще один шаг, на котором я декодирую цифры в буквы, используя перечисление (не показано):

Например. Строка «Bit» = 101 = разделители ‘, ,’, добавленные к исходной последовательности 1234 = ‘1,2 3,4’

Например. Строка «Bit» = 111 = разделители ‘,,,’, добавленные к исходной последовательности 1234 = ‘1,2,3,4’

     private Dictionary<string, string> processDeliminatorsWithInputSequence(string sequence, HashSet<string> binaryVariations)
    {
        Dictionary<string, string> returnVal = new Dictionary<string, string>();
        string message = string.Empty, variationWithDelim = string.Empty, finalString = string.Empty;
        StringBuilder characterContainer = null;
        int satisfiedCnt = 0, unsatisfiedCnt = 0;

        foreach (string variation in binaryVariations)
        {
            variationWithDelim = variation.Replace('0', ' ').Replace('1', ','); // 0's are spaces and 1's are commas
            characterContainer = new StringBuilder();
            for (int i = 0; i < sequence.Length - 1; i  )
            {
                characterContainer.Append(sequence[i]); // Original Input
                characterContainer.Append(variationWithDelim[i]); // Append with space or comma
            }
            characterContainer.Append(sequence[sequence.Length - 1]); // Need to append last character from original input - offset again
            characterContainer.Replace(" ", ""); // Clean up empty spaces in final string

            finalString = decodeToAlphabet(characterContainer); // converat numerals to their alpha equivelant
            if (finalString != null)
                returnVal.Add(characterContainer.ToString(), finalString); // Add original encoding and decoded strings to hastable
            else
                unsatisfiedCnt  ;

            satisfiedCnt = returnVal.Count();
        }

        message = String.Format("Input Sequence: {0}rnInput Binary Variations: {1}rn", sequence, binaryVariations.Count());
        message  = String.Format("Valid Alphabet Sequence Variations: {0}rnInvalid Alphabet Sequence Variations: {1}", satisfiedCnt, unsatisfiedCnt);
        result.Messsage = message;
        Console.WriteLine(message);

        return returnVal;
    }