1. C# / Говнокод #23277

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    public static int index(string word, char comp)
            {
                int k = -1;
                for (int i = 0; i < word.Length; i++)
                    if (word[i] == comp)
                    {
                        k = i;
                        break;
                    }
                return k;
            }
    
            public static char[] strtocharr(string str)
            {
                char[] tmp = new char[str.Length];
                for (int i = 0; i < tmp.Length; i++)
                    tmp[i] = str[i];
                return tmp;
            }
    
            public static string charrtostr(char[] charr)
            {
                string tmp = null;
                for (int i = 0; i < charr.Length; i++)
                    tmp = String.Format("{0}{1}", tmp, charr[i]);
                return tmp;
            }
    
            public static char maskfromword(string word)
            {
                return word[word.Length - 1];
            }
    
            public static string maskfromword(string word, int n)
            {
                string mask = null;
                for (int i = 0; i < n; i++)
                    mask = String.Format("{0}{1}", mask, word[word.Length - 1]);
                return mask;
            }
    
            public static char Counter(char crnt, string word)
            {
                if (crnt != maskfromword(word))
                    crnt = word[index(word, crnt) + 1];
                else
                    crnt = word[0];
                return crnt;
            }
    
            public static string Counter(string prev, string word, int k)
            {
                char[] tmp = strtocharr(prev);
                if (k >= prev.Length - 1)
                    k = prev.Length - 1;
                else
                    for (int i = k + 1; i < prev.Length; i++)
                        tmp[i] = word[0];
                if (tmp[k] == maskfromword(word))
                    return MultiCounter(prev, word, k - 1);
                else
                    tmp[k] = Counter(tmp[k], word);
                return charrtostr(tmp);
            }

    Список методов, позволяющие сделать счетчик по словарю (полезно для генераторов словарей) на любое количество символов.

    Запостил: Vero92, 18 Августа 2017

    Комментарии (36) RSS

    • Вместо "MultiCounter" надо "Counter" (перегружаемый метод)
      Ответить
    • Сишник может писать на любом языке как на си.

      З.Ы. Хотя... настоящий сишник всяко бы не стал клеить строки форматом.
      Ответить
      • вут? они же их снпринтфом и клеят, я сам видел.
        Ответить
        • Ну паттерн snprintf-builder это немного другое. Там на каждый чих строка не аллоцируется. Да и юзают его явно не ради приклеивания одного символа к строке...
          Ответить
    • эм... а чего делает метод Counter? этоо курево какое-то.
      нахрена оно надо?
      Ответить
      • Ща обьясню:
        вот у тебя есть словарик типа "0123456789ABCDEF"
        И тебе надо сгенерировать строки типа:
        000000
        000001
        ...
        00000F
        000010
        000011
        ...
        FFFFFF
        С помощью этих методов все сводится к вызову одной функции с последующим выводом на экран.
        З.Ы. Количество символов при этом может быть произвольной
        Ответить
        • Haskell:
          replicateM 6 "0123456789ABCDEF"
          https://ideone.com/XdVQ3K
          Ответить
        • я бы сделал это одной строчкой
          Enumerable.Range(0, 1024).Select( i=>i.ToString("x6").ToUpper()).ToList();
          Ответить
          • # Enumerable.Range(0, 1024).Select( i=>i.ToString("x6").ToUpper()).ToList();

            Enumerable.Range(0, 1024).Select(I => i.ToString("X6"));
            Ответить
          • А теперь представь, что словарь должен быть любым)))
            Ответить
            • > словарь должен быть любым)

              На самом деле, решение не сильно отличается. Нужно только функцию перевода в нужную систему счисления написать.
              Ответить
              • Раз уж у нас .net, то вот моя первая программа на F#
                (* https://ideone.com/VONwRD *)
                open System
                 
                let byIndex (alpha: string) (width: int) (n: int) =
                  let b = alpha.Length in
                  let digits = Array.create width (alpha.Chars(0)) in
                  let mutable k = n in
                  let mutable p = width - 1 in
                  while k > 0 do
                    let m = k % b in
                    digits.[p] <- alpha.[m];
                    k <- k / b;
                    p <- p - 1
                  done;
                  String.Concat digits
                 
                let printAll (alpha: string) (width: int) =
                  for i in 0 .. pown (alpha.Length) width - 1 do
                    byIndex alpha width i |> printfn "%5d -> %s" i
                  done
                 
                let () = printAll "ABCD" 4
                Ответить
                • Как можно сделать столько ошибок в хеловорлде?
                  Ответить
                  • Почему-то об ошибках вспоминают только тогда, когда на пороге уже гудбайворлд.
                    Ответить
                • Как-то нефункциональненько... Моя первая (и последняя?) прога на F#
                  let byIndex (letters:string) width index =
                    let b = letters.Length in
                      Seq.unfold (fun n -> Some(n%b, n/b)) index
                      |> Seq.take width
                      |> Seq.rev
                      |> Seq.map (fun i -> letters.[i])
                      |> String.Concat
                  https://ideone.com/DKiN8E
                  Ответить
                  • Да, я вчера вечером сходу не нашёл unfold-а, и решил написать по рабоче-крестьянски. Утром пошёл искать unfold, но ты меня опередил.
                    Ответить
                    • Кстати, а почему (::) запретили каррировать?
                      Ответить
                      • > Кстати, а почему (::) запретили каррировать?

                        О_о не знаю, но оказалось, что в OCaml тоже нельзя:
                        # (+);;
                        - : int -> int -> int = <fun>
                        # (::);;
                        Error: Syntax error: operator expected.
                        # (+) 1 0;;
                        - : int = 1
                        # (::) 1 [];;
                        Error: Syntax error: operator expected.
                        Ответить
              • Хорошо, а что ты будешь делать, если нужно вывести 8-символьные комбинации из такого словаря: "0123456789a..zA..Z!@+=-_/.,"? (Например, для брута вай-фая)?
                Ответить
                • printAll "0123456789a..zA..Z!@+=-_/.," 8
                  Ответить
                  • Честно: меня немного синтаксис F# пугает xD
                    https://ideone.com/DKiN8E
                    Я в плане "Что тут не так?" (может, у меня просто не дошли руки до F#).
                    P.S. Можно по подробнее расписать каждый шаг (что за чем делается)? Просто такая задача на СиШарпе делалась рекурсией.
                    Ответить
                    • Функция byIndex тупо выводит width символов числа index в системе счисления с основанием b (количество символов в твоём алфавите letters), только вместо привычных цифр выводятся символы твоего алфавита (любого, да).

                      В строке 4 определяем количество символов в алфавите (оно же будет основанием системы счисления).

                      В строке 5 бьём число на "цифры" (для b=10 и index=100500 получается бесконечная последовательность(IEnumerable) в духе [0, 0, 5, 0, 0, 1, 0, 0, 0, 0,...]. Вверх-ногами, да.

                      В строке 6 оставляем из них width первых, в строке 7 переворачиваем. В строке 8 конвертим "цифры" в соотв. символы твоего алфавита. Ну и в строке 9 клеим сиквенс символов в строку.
                      Ответить
                      • спасибо за информацию, буду теперь знать)))
                        P.S. Теперь с полной уверенностью можно сказать, что мой код на C# - говнокод (см. название сайта) xD
                        Ответить
                        • Рекурсивная генерация тоже имеет смысл. Например, если "словарь" в каждой позиции разный, т.е. идёт перечисление элементов декартовых произведений списков.

                          -- https://ideone.com/dkXmhL
                          cartesianProduct :: [[a]] -> [[a]]
                          cartesianProduct [] = [[]]
                          cartesianProduct (dict : dicts) = [d:rest | d <- dict, rest <- cartesianProduct dicts]
                          Ответить
                          • > Рекурсивная генерация тоже имеет смысл.
                            Нет, всё бессмысленно T____T
                            cartesianProduct :: [[a]] -> [[a]]
                            cartesianProduct = sequence


                            https://ideone.com/kF21DL
                            Ответить
                            • > всё бессмысленно
                              Да, можно быстро посчитать k-тый в лексикографическом порядке элемент декартова произведения, только мороки чуть больше.

                              > sequence
                              да я знаю, что replicateM k = sequence . replicate k, так просто менее очевидно, где рекурсия.
                              Ответить

    Добавить комментарий