1. Java / Говнокод #12982

    +79

    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
    package testapp;

public class TestApp {
    
    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 1000000; i++) {
            if (isLucky(i)) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("Total: " + count);
    }
    
    static boolean isLucky(final int n) {
        String num = Integer.toString(n);
        switch(6 - num.length()) {
            case 1: 
                num = "0".concat(num);
                break;
            case 2:
                num = "00".concat(num);
                break;
            case 3:
                num = "000".concat(num);
                break;
            case 4: 
                num = "0000".concat(num);
                break;
            case 5: 
                num = "00000".concat(num);
                break;
        }
        
        return (((getDigitAt(num, 0) + getDigitAt(num, 1) == getDigitAt(num, 2) + getDigitAt(num, 3))) & ((getDigitAt(num, 2) + getDigitAt(num, 3) == getDigitAt(num, 4) + getDigitAt(num, 5))));
    }
    
    static int getDigitAt(String number, int index) {
        return Character.getNumericValue(number.charAt(index));
    }
}

    Моё. Проверяет числа на "счастливость". Число счастливое, если в 6-значном числе сумма каждой пары соседних цифр одинакова. Т.е 211221 - счастливое, т.к. (2+1) = (1+2) = (2+1)

    Запостил: Govnocoder#0xFF, 09 Мая 2013

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

    • ava Govnocoder#0xFF 09.05.2013 15:10 # 0

      Те же яйца, только в профиль: http://pastebin.com/ctUt6USZ
      Не нравятся строки 30-32, но они оказываются самым быстрым и простым решением. Оставить или стоит заменить?
      Ответить

      • ava kipar 09.05.2013 22:52 # −1

        Java не знаю, но извращения со строками не нужны. Как-то так:
        static int getDigitAt(int number, int index) {
        return number/((int)Math.pow(10, index-1)) % 10;
        }
        Ответить

        • ava tirinox 10.05.2013 03:28 # +1

          Из разряда "не читал, но осуждаю"
          Ответить

        • ava bormand 10.05.2013 08:31 # 0

          >> извращения со строками не нужны.
          > pow
          А извращения с плавающей точкой тем более. К слову, то извращение со строками, скорее всего работало быстрее.
          bool isLucky(int n) {
    int[] d = new int[6];
    for (int i=5; i>=0; --i) {
      d[i] = a % 10;
      a /= 10;
    }
    return d[0]+d[1] == d[2]+d[3] && d[2]+d[3] = d[4]+d[5];
}
          Ответить

          • ava kipar 10.05.2013 12:47 # 0

            Ну, я и говорю что не знаю Java. Так что как там правильно целочисленную степень найти без понятия.
            Ответить

            • ava bormand 10.05.2013 13:47 # 0

              В такого рода задачах (к ним же относится преобразование числа в строку) возведение в степень так же полезно, как козе баян. Так что знание жабы тут ни на что не влияет...
              Ответить

              • ava kipar 10.05.2013 14:51 # 0

                Да, решение с последовательным проходом числа более оптимально. Мне просто хотелось показать реализацию функции getDigitAt, а не isLucky.
                Ответить

    • ava guest 09.05.2013 23:03 # −3

      Зачем вообще в функции isLucky преобразовывать число в строку? Нельзя ли просто переписать вот так:

      [code=java]
      static boolean isLucky(final int n) {
      return ((n / 100000) + ((n / 10000) % 10) == ((n / 1000) % 10) + ((n / 100) % 10)) &&
      ((n / 100000) + ((n / 10000) % 10) == ((n / 10) % 10) + (n % 10));
      }
      [/code=java]
      Ответить

      • ava guest 09.05.2013 23:03 # −4 

        static boolean isLucky(final int n) {
return ((n / 100000) + ((n / 10000) % 10) == ((n / 1000) % 10) + ((n / 100) % 10)) &&
((n / 100000) + ((n / 10000) % 10) == ((n / 10) % 10) + (n % 10));
}
        Ответить

      • ava bormand 10.05.2013 08:33 # 0

        Хоть бы в переменные разложил что-ли... Компилятору конечно похуй, и он наверное даже оптимизнет это говно как положено, но выглядит и читается оно ужасно.
        Ответить

        • ava guest 10.05.2013 22:21 # 0

          Сравнить бы по скорости этот вот говнокод четырьмя комментами выше и оригинал. И ещё варианты, которые тут предлагали.
          Ответить

          • ava bormand 11.05.2013 06:49 # 0

            Ну, если компилятор достаточно умный, и сумеет разбросать деления оптимальным образом - то скорее всего чуть-чуть быстрее чем мой вариант с циклом. Если же не оптимизнет - то даже медленнее, т.к. делений тут больше, а емнип, они и составят основную нагрузку на проц.
            Ответить

          • ava bormand 11.05.2013 07:09 # 0

            http://ideone.com/h7QuFB
            Всего в ~1.6 раза быстрее цикла.
            Ответить

    • ava guest 10.05.2013 22:03 # 0

      string s; cin >> s;
      if (s.length() % 2 > 0 || s.length() < 6) { cout << "NO"; return 0; }
      int isOk = 1;
      int tmp = -1;
      for(int i = 0, len = (int)s.length(); i < len; i+=2)
      {
      int cur = s[i]+s[i+1];
      if (tmp < 0) tmp = cur;
      isOk *= (tmp == cur);
      }
      cout << ( (isOk) ? "YES" : "NO" );
      return 0;
      Ответить

    • ava guest 10.05.2013 22:11 # +1

      ну или поиздеваться можно)) вдруг это работает
      int n; cin >> n;

      int len = (int)floor( log(n)/log(10.) ) + 1;
      if (len % 2 > 0 || len < 6) { cout << "NO"; return 0; }

      int tmp = -1;
      while (n > 0)
      {

      int first = n % 10; n /= 10;
      int second = n % 10; n /= 10;
      if (tmp < 0) tmp = second + first;
      if (tmp != second + first)
      { cout << "NO"; return 0; }

      }

      cout << "YES";
      return 0;
      Ответить

      • ava Govnocoder#0xFF 11.05.2013 19:05 # 0

        О, а вот это неплохой вариант, только 
        if (tmp < 0) tmp = second + first;

        Можно вынести из цикла.
        Ответить

    • ava eth0 11.05.2013 11:58 # +1

      Я, возможно, не понимаю чего-то. Но меня всегда удивляла конкатенация с дополнением вида 
      num = "00000".concat(num);

      с несколькими условиями в зависимости от длины.
      Если на выходе есть строка, а функции форматирования a-la printf отсутствуют или некошерны, всегда есть возможность сделать так:
      $a = substr("000000" . $a, -6);
      Ответить

      • ava movaxbx 11.05.2013 12:38 # +1

        В сишарпике вообще вот так можно
        int n = 1234;
string s = n.ToString("000000"); //"001234"


        upd. тьфу, это джава раздел
        Ответить

      • ava someone 12.05.2013 10:36 # +2 

        String num = String.format("%06d", n);


        Fixed?
        Ответить

    • ava tir 13.05.2013 15:16 # 0

      эта задача решается алгоритмом с количеством операций не более 150 :)
      Ответить

      • ava tir 13.05.2013 15:24 # 0

        Немного неправильно прочитал условие =) Имелась ввиду "классическая" задача, когда сумма первых 3-х цифр равна сумме вторых трех. Ща подумаем над данной.
        Ответить

        • ava tir 13.05.2013 15:41 # 0

          бля =))) я решал задачу нахождения КОЛИЧЕСТВА таких билетов
          Ответить

      • ava roman-kashitsyn 13.05.2013 15:49 # 0 

        http://ega-math.narod.ru/Quant/Tickets.htm
        Ответить

        • ava tir 13.05.2013 15:58 # 0

          =) хотелось бы увидеть реализацию на java
          Ответить

          • ava bormand 13.05.2013 16:52 # 0

            Так реализуйте ;)
            Ответить

            • ava tir 13.05.2013 16:58 # 0

              своя реализация у меня есть :)

              хотелось увидеть реализацию идей изложенных по ссылке.

              ПС. По данной задаче 65 итераций цикла.
              Ответить

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