1. JavaScript / Говнокод #25699

    +1

    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
    function natRound() {
    
    	var out = []
    	    , fib = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233] // etc
    	    , _data = function() { // random values
    
    			var out = []
    				, count = Math.round( Math.random() * 100)
    			;
    
    			for(var i=0; i < count; i++ ) {
    				out.push( Math.random() * 100 ); // in km
    			}
    
    			return out.sort(function(a,b){ return a-b; });
    	    }()
    	    , roundTo = function (value) {
    			var i = fib.length;
    			while(i--) {
    				if ( value < fib[i] ) continue;
    				return i? i: value; // natural sorting
    			}
    	    }
    	;
    
    	for( var i=0; i<_data.length; i++ ) {
    		out.push( 'Value: [' + _data[i] + ']; Sort = [' + roundTo(_data[i]) + ']' );
    	}
    
    	return out;
    }

    Необходимо было учесть дискретность при сортировке расстояний в километрах.
    Например, в синтаксисе Elastic это выглядит так:

    "ranges" => [
    [ "to" => 1 ],
    [ "from" => 1, "to" => 3 ],
    [ "from" => 3, "to" => 5 ],
    [ "from" => 5],
    // etc
    ]

    Используя цепочку чисел Фибоначчи, как наиболее "человечески приятный" ряд, функция roundTo возвращает число для сортировки значений массива.

    Запостил: bot, 04 Июля 2019

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

    • Сайн байна!
      Ответить
    • Что за ебанавт так форматирует? На кол его!
      Ответить
      • Не помню где, возможно в "jQuery", такоеже форматирование.
        Ответить
      • Ну сорян.
        Ответить
        • Хорощо, на этот раз прощаю, но только из-за почки с запятой на отдельной строчке, мне это ЫЭ АщкерЭ напомнило.
          Ответить
    • господи, какой неаккуратный код, да еще и до ES6
      Ответить
      • Какой багор )))
        Ответить
      • Ебало завали, пидр несчастный. Отцени лучше кокой подход!
        Ответить
        • Ты старовер?
          Ответить
          • Ну есть такое немного. До сих пор коробит, когда люди до форматирования докапываются.
            Ответить
            • Поэтому "Конардо" против форматирования. Оно заставляет мозгам расслабляться.
              Ответить
              • Очередной встроенный в спинной мозг линтер?
                Ответить
              • Убрал мусор. Проверь:
                function natRound(){
                var out=[],fib=[0,1,2,3,5,8,13,21,34,55,89,144,233],_data=function(){
                var out=[],count=Math.round(Math.random()*100);
                for(var i=0;i<count;i++){
                out.push(Math.random()*100 );
                }
                return out.sort(function(a,b){return a-b;});
                }(),
                roundTo=function(value){
                var i=fib.length;
                while(i--){
                if(value<fib[i])continue;
                return i?i:value;
                }
                };
                for(var i=0;i<_data.length;i++){
                out.push('Value: ['+_data[i]+']; Sort = ['+roundTo(_data[i])+']');
                }
                return out;
                }
                Ответить
                • Отформатировал, не благодари
                  function natRound() {
                      var out = [], fib = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233], _data = function () {
                              var out = [], count = Math.round(Math.random() * 100);
                              for (var i = 0; i < count; i++) {
                                  out.push(Math.random() * 100);
                              }
                              return out.sort(function (a, b) {
                                  return a - b;
                              });
                          }(),
                          roundTo = function (value) {
                              var i = fib.length;
                              while (i--) {
                                  if (value < fib[i]) continue;
                                  return i ? i : value;
                              }
                          };
                      for (var i = 0; i < _data.length; i++) {
                          out.push('Value: [' + _data[i] + ']; Sort = [' + roundTo(_data[i]) + ']');
                      }
                      return out;
                  }
                  Ответить
                  • Но ведь гуро против отступов!
                    Ответить
                    • Посмотри, как прекрасен мир без наркотиков
                      "use strict";
                      
                      function natRound() {
                          const fib = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233];
                          const data = function () {
                              const out = [];
                              const count = Math.round(Math.random() * 100);
                              for (let i = 0; i < count; i++) {
                                  out.push(Math.random() * 100);
                              }
                              return out.sort((a, b) => a - b);
                          }();
                      
                          function roundTo(value) {
                              let i = fib.length;
                              while (i--) {
                                  if (value < fib[i]) continue;
                                  return i ? i : value;
                              }
                          }
                      
                          return data.map(v => `Value: [${v}]; Sort = [${roundTo(v)}]`);
                      }
                      
                      console.warn(natRound());
                      Ответить
                      • > const out;
                        > out.push

                        Какой const )))
                        Ответить
                        • Но значение переменной же не поменяли!

                          Это как char* const p в крестах.
                          Ответить
                        • const не означает неизменяемый объект, он означает переменную, которой нельзя присвоить другое значение.
                          Ответить
                        • это как файнал в жобе и рыдонли в шишарпе

                          аналога крестовово конста в акне нету
                          Ответить
                          • Почему нету? Это аналог конста на переменной (T* const p и int const p аля const int p) но не аналог конста на типе (const T* p).
                            Ответить
                            • да, референсы и примитивы могут быть константыми (зачем-то)

                              объекты -- нет (если тока фриз)
                              Ответить
                      • Ждём перевода на J.
                        Ответить
                        • Он изъебнётся, никому это нахуй не нужно, но переведёт.
                          Ответить
                          • Но ведь вы должны знать, что ваши языки сложны и многобуквенны, а пишут на них ничтожества.

                            Но не сейчас, глазки смыкаются.
                            Ответить
                        • Ладно уговорил:
                          fib =: 0 1 2 3 5 8 13 21 34 55 89 144 233
                             roundTo =: ({: @ I. @: >:&fib) ^: (>&1)
                             natRound =: verb define
                               data =. 100 * ? 0 #~ ?101
                               ('Value: ['"_ , ": , ']; Sort = ['"_ , (": @ roundTo) , ']'"_)"0 data
                             )
                             natRound ''
                          Value: [61.9591]; Sort = [9]        
                          Value: [37.0368]; Sort = [8]        
                          Value: [94.8979]; Sort = [10]       
                          Value: [30.8822]; Sort = [7]        
                          Value: [29.8876]; Sort = [7]        
                          Value: [33.5914]; Sort = [7]        
                          Value: [32.5965]; Sort = [7]        
                          Value: [40.359]; Sort = [8]         
                          Value: [38.2035]; Sort = [8]        
                          Value: [8.39306]; Sort = [5]        
                          Value: [65.8579]; Sort = [9]        
                          Value: [20.2672]; Sort = [6]        
                          Value: [16.7356]; Sort = [6]        
                          Value: [99.8528]; Sort = [10]       
                          Value: [16.0473]; Sort = [6]        
                          Value: [73.0165]; Sort = [9]        
                          Value: [66.78]; Sort = [9]          
                          Value: [5.03413]; Sort = [4]        
                          Value: [51.5032]; Sort = [8]        
                          Value: [50.3798]; Sort = [8]        
                          Value: [14.5333]; Sort = [6]        
                          Value: [18.6005]; Sort = [6]        
                          Value: [88.3352]; Sort = [9]        
                          Value: [92.0914]; Sort = [10]       
                          Value: [99.9278]; Sort = [10]       
                          Value: [73.98]; Sort = [9]          
                          Value: [7.69666]; Sort = [4]        
                          Value: [80.6723]; Sort = [9]        
                          Value: [0.450389]; Sort = [0.450389]
                          ***часть данных была удалена по требованию роскомнадзора***


                          Ко-ко-ко! Закорючки! Нечитаемо!
                          load 'primitives'
                             
                             fib =: 0 1 2 3 5 8 13 21 34 55 89 144 233
                             roundTo =: (last at indices at largerorequal bond fib) power (largerthan bond 1)
                             natRound =: verb define
                               data =. 100 * roll (roll 101) copy 0
                               ('Value: ['"_ , defaultformat , ']; Sort = ['"_ , (defaultformat at roundTo) , ']'"_)rank 0 data
                             )
                          Так то!
                          Ответить
                          • Ах да, есть же sprintf:
                            load 'format/printf'
                               natRound =: verb define
                                 data =. 100 * roll (roll 101) copy 0
                                 (cap 'Value: [%s]; Sort = [%s]' bond sprintf defaultformat ; defaultformat at roundTo)rank 0 data
                               )
                            Ответить
                        • А теперь хардкор:
                          natRound =: ('Value: ['"_,":,']; Sort = ['"_,":@({:@[email protected]:>:&0 1 2 3 5 8 13 21 34 55 89 144 233^:(>&1)),']'"_)"[email protected]*~&[email protected][email protected]#&[email protected][email protected]]&101
                             natRound ''
                          Value: [81.3439]; Sort = [9] 
                          Value: [36.5751]; Sort = [8] 
                          Value: [14.7062]; Sort = [6] 
                          Value: [15.4048]; Sort = [6] 
                          Value: [51.3564]; Sort = [8] 
                          Value: [91.2483]; Sort = [10]
                          Value: [63.0999]; Sort = [9] 
                          Value: [90.2143]; Sort = [10]
                          Value: [54.8453]; Sort = [8] 
                          Value: [73.1546]; Sort = [9] 
                          Value: [46.1227]; Sort = [8] 
                          Value: [71.8731]; Sort = [9] 
                          Value: [61.3742]; Sort = [9] 
                          Value: [22.7547]; Sort = [7] 
                          Value: [50.757]; Sort = [8]  
                          Value: [20.9873]; Sort = [6] 
                          Value: [66.757]; Sort = [9]  
                          Value: [99.2283]; Sort = [10]
                          Ответить
                      • 'use strict';
                        const wu = require("wu");
                        
                        function natRound() {
                        const fib = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233];
                        	const rnd = () => Math.random() * 100;
                            const data =  wu.count().take(Math.round(rnd())).map(rnd).toArray().sort((a, b) => a - b);
                        
                            function roundTo(value) {
                                let i = fib.length;
                                while (i--) {
                                    if (value < fib[i]) continue;
                                    return i ? i : value;
                                }
                            }
                        
                            return data.map(v => `Value: [${v}]; Sort = [${roundTo(v)}]`);
                        }
                        
                        console.warn(natRound());
                        Ответить
                        • Опять ты со своим uwu
                          Ответить
                          • ну скажи пиздато, а? ну скажи же?

                            или ты не любишь фунциональщину?
                            Ответить
                            • Хуйня какая-то нечитаемая, если честно. До этого понятней было.

                              З.Ы. На мобиле ещё и скроллить эту километровую строку надо...
                              Ответить
                              • ладно
                                а тк?

                                'use strict';
                                const wu = require("wu");
                                
                                function natRound() {
                                    const fib = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233];
                                    const rnd = () => Math.random() * 100;
                                    const data =  wu.count() 
                                			.take(Math.round(rnd()))
                                			.map(rnd)
                                			.toArray()
                                			.sort((a, b) => a - b);
                                
                                    function roundTo(value) {
                                        let i = fib.length;
                                        while (i--) {
                                            if (value < fib[i]) continue;
                                            return i ? i : value;
                                        }
                                    }
                                
                                    return data.map(v => `Value: [${v}]; Sort = [${roundTo(v)}]`);
                                }
                                
                                console.warn(natRound());
                                Ответить
                                • Так лучше.
                                  Ответить
                                  • У меня неоднозначное отношение к этой хуйне


                                    с одной стороны писать в 4 строчки приятнее, чем в восемь

                                    с другой стороны дебажить это не всегда просто
                                    Ответить
                                • Ещё fib можно в roundTo спрятать, она больше нигде не юзается.
                                  Ответить
                                  • да и раунд ту можно упростить
                                    но мне лень
                                    Ответить
                                  • То есть инициализация переменной будет использоваться каждый раз при вызове функции, вместо того, чтобы один раз проинициализироваться?
                                    Ответить
                                    • А у тебя разве по-другому?
                                      Ответить
                                      • Массив лежит в родительской области видимости.
                                        Ответить
                                        • Думаю что цена fib.length O(1), на перформансе это не сильно отразится
                                          Ответить
                                          • @guest8, в том-то и оно, что var i; в данной фунции необходимо для while. Там в любом случае, даже если в глобальной области вычислить - всё равно потом внутрь функции передавать и локально использовать. В отличие от fib, который readonly.
                                            Ответить
                                    • в js же нету static автомтически переменных как в сясях?
                                      Ответить
                        • Там кстати *100 в одном месте, не означает *100 в другом. Это просто набор данных. Иногда и *1000 нужно будет (в каком-нибудь из них)
                          Ответить
        • Фу, как грубо
          Ответить
    • А @Lure Of Chaos тут ещё? Мне его мнение очень важно.
      Ответить
      • Канул в лету.
        Ответить
      • Тебе может еще и вебкила с istem подать?
        Ответить
        • Хотя бы 1024—— подай
          Ответить
          • Анонимуса давай. Он однажды ссылку на статью в коммент скинул - не найду никак. Там про стандарты написания кода от NASA, что-то такое было. На русском статья была. Перевод вроде, или кто-то сам написал, не помню ни хрена.
            Ответить
            • ЪУЪ! @bugmenot ещё был! Охуенный чувак.
              Ответить
          • 1024 бы не помешал, кстати
            он в джаваскрипте зело рубит, это ценно
            Ответить
        • Если ты ещё и Алёша, то звони - бухать будем. Угощаю.
          Ответить
    • Где здесь C++, bot?!
      Ответить
    • Бля, что за пидоры в 5 утра лепездричество вырубают? Мне что голодным спать ложится? Во пидарасы.
      Ответить
    • > return i? i: value;
      У тебя это эквивалентно просто return i

      Какой анскилл )))
      Ответить
      • а ежели i == 0?
        Ответить
      • Там смысл в том, что если дистанция менее одного километра - то сортируем по дистанции без округления. Если больше - то сортируем по целочисленному индексу из последовательности Фибоначчи, который более или равен одному.
        Ответить
        • А, я понял. Я просто забыл что бывают плавающие петухи, надо завязывать с Фортом.
          Ответить
          • Да. Там вот так, если внятно выражаться:
            return (double) ( (i == 0) ? value : i );
            Ответить
        • Интересно, зачем. Типа, сначала сортируем по релевантности, а потом по расстоянию? Скажем, если два магазина примерно находятся примерно на одинаковом расстоянии, то выдаем тот, что оплатил услугу "выдавать выше"?
          Ответить
    • А кто-нибудь в курсе, почему и куда пропали подсветка и счётчик новых комментов в постах?
      Ответить

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