Простейшая проверка принадлежности натурального числа промежутку

#java #if #math

Как математически грамотно (желательно на Java) одним условием проверить, принадлежит
ли натуральное число b отрезку [a, c], где a и c так же натуральные числа? Условие
должно выполниться, например, при таких значениях a, b, и c соответственно: (1, 2,
3), (5, 7, 10), (17, 25, 25), но не должно выполниться, например, при таких значениях
a, b, и c соответственно: (2, 1, 3), (17, 25, 24). Условие должно быть одно, использовать
логические операторы (такие как &&, ||, и т.п.) нельзя.
    

Ответы

Ответ 1

Если точка лежит внутри отрезка, то сумма расстояний от этой точки до крайних точек
отрезка всегда равна расстоянию между крайними точками. Если точка лежит вне отрезка,
тогда сумма расстояний всегда будет больше.
Иллюстрация:


Как известно, расстояние между двумя точками на отрезке – это модуль разности координат
этих точек. 

Отсюда получаем условие:

Math.abs(b - a) + Math.abs(b - c) == c - a  // с учётом, что всегда c >= a, иначе
Math.abs(c - a)


Ответ 2

Я придумал такой вариант


Перемножить две разности: (b - a) * (c - b)
Проверить результат:


если меньше нуля, то одна из разностей отрицательна, это значит что число b не входит
в интервал [a, c]
если равно нулю, то число b равно одному из чисел a, c, т.е. входит в интервал [a, c]
если больше нуля, то число b принадлежит интервалу (a, c), что является даже более
сильным условием, чем принадлежность к [a, c]



Применительно к данной задаче, финальное условие будет выглядеть так:

boolean membership = ((b - a) * (c - b) >= 0);


Полный код программы, с которым можно поиграться:

public class Solution
{
    public static void main(String[] args)
    {
        int[][] tests =
        {
            { 1, 2, 3 },
            { 5, 7, 10 },
            { 4, 4, 11 },
            { 17, 25, 25 },
            { 2, 1, 3 },
            { 17, 25, 24 }
        };

        for (int[] v : tests)
        {
            int a = v[0], b = v[1], c = v[2];
            boolean membership = ((b - a) * (c - b) >= 0);
            System.out.format("(%d, %d, %d) => %b\n", a, b, c, membership);
        }
    }
}


Минус данного решения в том, что при больших числах возможно переполнение на умножении.

Впрочем, если входные данные имеют тип int, то от переполнения можно будет избавиться,
используя в вычислениях тип long


Ответ 3

А что, если реализовать класс Отрезок с булевым методом точка входит?
Решение получается довольно читабельным и понятным, на мой взгляд.
Если такой обход "двойного условия" не допустим условиями задачи, то решение не подходит.

    public static void main(String[] args) {
        int a=1,b=2,c=3;
        if(new Segment(a,c).isEnter(b)){
            System.out.println("Входит");
        }else{
            System.out.println("Не входит");
        }
    }


    static class Segment{
        int a,c;
        public Segment(int a, int c) {
            this.a = a;
            this.c = c;
        }

        public boolean isEnter(int b) {
            return a<=b&&c>=b;
        }
    }

Math.random, Javascript. Что-то пошло не так [дубликат]

#javascript #случайные_числа #math

        
             
                
                    
                        
                            На этот вопрос уже даны ответы здесь:
                            
                        
                    
                
                        
                            Как вернуть значение из события или из функции обратного
вызова? Или хотя бы дождаться их окончания
                                
                                    (3 ответа)
                                
                        
                                Закрыт 2 года назад.
            
                    


var GoodObj = {};

$(document).ready(function() {
    var a = Math.floor(Math.random() * 50);
    var b = Math.floor(Math.random() * 50);
    var trololo = parseInt(a + b);
    GoodObj.lala = trololo;
    document.getElementById('number').innerHTML += a;
    document.getElementById('number').innerHTML += '+';
    document.getElementById('number').innerHTML += b;
});

function myFunction (){
    var  myTrololo = GoodObj.lala;
    var stop = false;
    if (document.getElementById('timer').innerHTML == myTrololo) {
        alert('right');
        return true;
    }
    else {
        alert('false');
        return stop;
    }
}

function randomInt(min,max){
    return Math.floor(Math.random() * (max - min) + min);
}
var param = randomInt(14, GoodObj.lala);
alert(randomInt(14, GoodObj.lala));


Здесь GoodObj.lala - сума двух рандомных чисел. Не думаю, что тот кусок кода нужен.
В общем, выводит Nan. В других случаях перемещения переменной или еще чего - что
код слишком рекурсивен. Уже совсем запуталась
    

Ответы

Ответ 1

var GoodObj = {};

$(document).ready(function() {
  var a = Math.floor(Math.random() * 50);
  var b = Math.floor(Math.random() * 50);
  var trololo = parseInt(a + b);
  GoodObj.lala = trololo;
  document.getElementById('number').innerHTML += a;
  document.getElementById('number').innerHTML += '+';
  document.getElementById('number').innerHTML += b;

  var param = randomInt(14, GoodObj.lala);
  console.log(randomInt(14, GoodObj.lala));
});

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min) + min);
}

// этот кусок кода выполняется сразу, тогда, когда инициализация 
// var trololo = parseInt(a + b);
// GoodObj.lala = trololo;
// только после загрузки всего ДОМ дерева
// в итоге GoodObj.lala попросту не существует и ровняется undefined что и дает нам NaN
// просто перенесите в $(document).ready

//var param = randomInt(14, GoodObj.lala);
//console.log(randomInt(14, GoodObj.lala));

Необходимо вычислить, какое максимальное количество фигур вместится на прямоугольнике. Чем можно реализовать?

#python #алгоритм #математика #math

Необходимо написать мини-программку, которая рассчитывала бы наиболее экономичную
раскладку материала. Дано: фигура произвольной формы и прямоугольный лист материала.
Необходимо разложить максимально возможное количество данной фигуры на этом листе так,
чтобы между ними оставалось расстояние 2-3мм (можно регулировать).
В какую сторону копать? На чем можно реализовать? Хотелось бы на Python, так как
более-менее знаю только его.
    

Ответы

Ответ 1

В общем виде эта задача является труднорешаемой, и не имеет эффективного алгоритма
решения в принципе (его не существует в природе). Если материал Ваш имеет какую-то
особую форму, то ещё можно что-то сделать, а если форма произвольная, то можно попробовать
эвристики. Копайте по таким ключевым словам: "задача о плоскостном  раскрое" или "Cutting
stock problem". На русском, сразу говорю, - мало что полезного найдёте. На английском
ищите задачу Cutting stock problem на прямоугольных полосках с бесконечной длиной (или
высотой). Там суть почти всех эвристик в том, что делается попытка разместить N фигур
на прямоугольной полоске минимальной длиной (высотой) и с фиксированной высотой (длиной).
Соответственно, если у вас ширина (высота) уже заданы заранее, то задача о максимальном
числе N решается бинарным поиском. Сами же эвристики настолько объёмы по изложению,
что расписывать их здесь не смогу.

Отвечаю на второй вопрос: реализовать можно на чём угодно, когда знаешь алгоритм.
Готовые библиотеки мне лично не известны. Вообще, это серьёзная научная проблема, 
коей занимались разные институты (особенно в советское время), нужно довольно хорошо
владеть программированием, чтобы всё здесь правильно закодировать.

Деление с округлением в большую сторону

#c_sharp #деление #math

Math.Round округляет по правилу, как заставить его округлять в большую сторону, или
какую другую функцию использовать?    

Ответы

Ответ 1

Math.Ceiling - к большему целому
Math.Floor - к меньшему целому

tan и бесконечность

#cpp #math

Может ли tan возвратить бесконечность? При каком значении? pi/2 не возвращает бесконечность
(из за погрешностей, наверно).
    

Ответы

Ответ 1

Нет, tan не может вернуть бесконечность (+Inf или -Inf).

Из примечания к описанию tan в cppreference:


  У функции есть полюса при x = π(1/2 + n), однако существующие реализации чисел
с плавающей точкой не могут точно представить π/2, поэтому аргумент никогда не попадает
в полюс.


Ответ 2

Похоже, что нет.
http://en.cppreference.com/w/cpp/numeric/math/tan


  If a domain error occurs, an implementation-defined value is returned (NaN where
supported)


Перевод: в случае выхода значения за рамки допустимого диапазона, возвращаемое значение
зависит от реализации (NaN, если поддерживается)

Т.е. мы можем получить NaN (насколько я понимаю, это входит в 11-й стандарт), но не inf


Ответ 3

В дополнение к имеющимся правильным ответам: Вот значение, на котором tan перепрыгивает
через бесконечность: http://ideone.com/gfyJoD

double x = 1.57079632679489666901; // около PI/2
double y = nextafter(x, numeric_limits::max()); // в точности следующее
cout << fixed << tan(x) << endl; // 16331239353195370.000000
cout << fixed << tan(y) << endl; // -6218431163823738.000000


(разумеется, данное значение имеет смысл лишь в данной версии рантайма, так что никаких
гарантий)



Почему же разработчики стандарта решили никогда реально не возвращать бесконечность?

Причин здесь две:


Точное значение π/2 + n · π не представимо в виде числа типа double (т. к. π иррационально).
Даже если тангенс аргумента больше максимального значения double, всё равно округление
вниз даст лучшее приближение, чем бесконечная ошибка при округлении до бесконечности!
Если даже и возвращать значение «бесконечность», неясно, какую именно (положительную
или отрицательную) нужно возвращать. У double нету «просто бесконечности».


Ответ 4

Функция tan, несмотря на наличие тега c++ в вопросе, относится к функциям из библиотеки
C. Поэтому и ответ на вопросе логичнее искать в сишном Стандарте. 

И вот что говорит по этому поводу C99 (ISO/IEC 9899:1999) 7.12.4.7:


  The tan functions 
  
  Synopsis

#include  
double tan(double x); 
float tanf(float x); 
long double tanl(long double x);

  
  Description 
  
  The tan functions return the tangent of x (measured in
  radians). 
  
  Returns
  
  The tan functions return tan x.


Т.е. пока никакой ясности про бесконечность нет. Просто сказано, что функция возвращает
тангенс аргумента, заданного в радианах. 

Однако далее в приложении F, а точнее в п. F.9.1.7 описаны особые случаи:


  tan(±0) returns ±0. 
  
  tan(±∞) returns a NaN and raises the ‘‘invalid’’ floating-point exception.


Из чего можно сделать вывод, что функция tan не возвращает ∞. Но может вернуть NaN
для ∞ значения аргумента.

Другие функции, например log10 для нулевого аргумента, возвращают ∞.

Почему в Delphi MinDouble > 0?

#delphi #math

If MinDouble > 0 Then // -> всегда True
If MinDouble < 0 Then // -> всегда False


... И как с ним правильно сравнивать?

Попробую подробнее объяснить суть вопроса:
минимальное и максимальное возможное значение для того и нужно, чтобы определять
границы диапазона. Для того и заведены эти константы. И то, что минимальное значение
больше нуля это странно, т.к. отрицательные значения этому типу никто не запрещал присваивать.
На практике получается все отрицательные числа меньше минимального значения, хотя на
то оно и минимальное, чтобы меньше его ничего не было.
    

Ответы

Ответ 1

Заблуждение в том, что:


в отличии от целых чисел, где минимальное - это наиболее отрицательное значение
минимальное число типа Double (и аналогичных типов с "плавающей" точкой) - это минимальное
отличное от нуля значение.


Дело в том, что знак числа с точкой кодируется одним битом, и никак не влияет на
минимальное / максимальное представляемые этим типом значения.

Таким образом:


MinDouble = 5.0e-324; Минимальное представимое число отличное от нуля  
MaxDouble = 1.7e+308; Максимальное представимое число отличное от нуля


Положительное или отрицательное число - для этих констант не важно, вы сами добавляете
знак как вам нужно. Например, используя 4 числа и знак, получаем вот такие диапазоны:

[-MaxDouble .. -MinDouble] 0 [+MinDouble .. +MaxDouble]


P.S. И Delphi тут не при чем, в других ЯП всё так же.


Ответ 2

Потому что MinDouble определяет минимальное абсолютное значение типа double

MinDouble = 5.0e-324;

Как рассчитать рикошет?

У меня есть два тела круглой формы, они движутся на встречу друг к другу и сталкиваются. При столкновении вектора их направления движения должны измениться. Как их рассчитать? (массы одинаковые, трения нет, размер не важен) V1={x1,y1} V2={x2,y2} N={x3,y3}

Мое предположение что так:

(x1*x3+y1*y3) / sqrt(x1^2 + x3^2) * sqrt(y1^2+y3^2) = получим число F и умножим так вектор V1 - (x1*F, y1*F)
Попробовал просто сложить вектора N+V1 вроде похоже получилось

Ответ

вобщем, сперва как уже сказали в комментариях, нужно определить пересекаются ли круги - для этого нужно добавить условие
if (distBetweebCirles <= circle1.radius + circle2.radius) { // collision happened // resolve it }
в вашем случае distBetweenCirles это длина вектора N(пожалуйста, обозначьте его как то подругому, например distanceVector), а радиус можно считать эквивалентным массе при симуляции.
Далее, допустим круги сталкиваются, так как массы одинаковые, то векторы скоростей просто обменяются друг с другом. Это следует из следующей формулы (которая также применима и для случая с разнымы массами)
1)
v1 = (u1 * (m1 - m2) + 2 * m2 * u2) / (m1 + m2)
v2 = (u2 * (m1 - m2) + 2 * m1 * u1) / (m1 + m2)
где u1, u2 векторы скоростей до столкновения, а v1, v2 после. И если m1 == m2 то получаем
2)
v1 = u2
и соотвественно
v2 = u1 (как это вышло выведите сами из формулы 1))
Откуда взялась первая формула ? - при таком упругом столкновении действуют закон сохранения импульса и закон сохранения энергии
следовательно, необходимо решить систему уравнений относительно v1 и v2
m1 * u1 + m2 * u2 = m1 * v1 + m2 * v2
(m1 * u1^2) / 2 + (m2 * u2^2) / 2 = (m1 * v1^2) / 2 + (m2 * v2^2) / 2
решение которого есть формула 1)
читать подробнее про мат часть тут

Решение нелинейных систем уравнений

Сразу говорю - вопрос сложный. Есть система уравнений вида. -w -v + 44 =0 w -x + y -20.5 =0 v -y -z -11 = 0 x + z -12.5 = 0 -0.001716*(w^2) + 0.003065*(v^2) + 0.072168*(y^2) = 0 -0.057172*(x^2) + 0.072168*(y^2) + 0.038655*(z^2) = 0 Приближенные начальные значения есть и достаточно близки. Неизвестных 5. А уравнений 6. Причем с усложнением системы "разрыв" будет расти. Степень уравнений не более 2. Есть ли у кого идеи (может сталкивался) как с таким бороться (аналитический метод, к сожалению, не подходит)? Обычно, такое решается методом Ньютона, но он подходит только для квадратных матриц...

Ответ

Если приближенные методы подхоят, то можно решить численными методами. Вот несколько ссылок: Решение систем нелинейных уравнений. Численные методы. Учебное пособие.

Математика. Определитель матрицы n-го порядка

Помогите с задачей, не могу до конца додумать, что куда и как. Спасибо большое заранее!
Для начала я попытался изменить вторую строчку с помощью первой, у меня вышло:
x x+h x+2h ... x+(n-1)h 0 2x+h x+2h ... x+(n-1)h 0 -x x ... 0 ............................. 0 0 0 ... x
Если здесь что-то ещё менять то, -x из 3ей строчки не уходит, а я хочу привести матрицу к виду:
x x x x 0 x x x 0 0 x x 0 0 0 x
Чтобы можно было разложить на миноры по 1 эл-ту.
Далее я попытался вторую оставить без изменения, а 3ью строчку изменить с помощью первой, но там тоже получилась белиберда и далекая к истине матрица. Я думал может можно при помощи какого-нибудь столбца изменить другой, но тем самым больше проблем создам.
В принципе тут ещё одна идея - изменять вторую с помощью первой, третью с помощью второй и т.д., а потом выносить из каждой строчки множитель (x+h), но остаются единицы и нужному виду не придти. :(

Ответ

Ну, если я не ошибся...

Update Доказывается методом матиндукции. Для каких-нибудь 1, 2, 3 - легко посчитать.
Затем берем nxn и идем по последнему столбцу. Имеем минор для (x+nh) - получается простая матрица с одной диагональю из (-x)n, а для x в нижнем правом углу - наша формула для n. Умножаем, суммируем - все получается как надо :)
Update2

Простейшая проверка принадлежности натурального числа промежутку

Как математически грамотно (желательно на Java) одним условием проверить, принадлежит ли натуральное число b отрезку [a, c], где a и c так же натуральные числа? Условие должно выполниться, например, при таких значениях a, b, и c соответственно: (1, 2, 3), (5, 7, 10), (17, 25, 25), но не должно выполниться, например, при таких значениях a, b, и c соответственно: (2, 1, 3), (17, 25, 24). Условие должно быть одно, использовать логические операторы (такие как &&, ||, и т.п.) нельзя.

Ответ

Если точка лежит внутри отрезка, то сумма расстояний от этой точки до крайних точек отрезка всегда равна расстоянию между крайними точками. Если точка лежит вне отрезка, тогда сумма расстояний всегда будет больше. Иллюстрация:
Как известно, расстояние между двумя точками на отрезке – это модуль разности координат этих точек.
Отсюда получаем условие:
Math.abs(b - a) + Math.abs(b - c) == c - a // с учётом, что всегда c >= a, иначе Math.abs(c - a)

Math.random, Javascript. Что-то пошло не так [дубликат]

На данный вопрос уже ответили: Как вернуть значение из события или из функции обратного вызова? Или хотя бы дождаться их окончания 3 ответа
var GoodObj = {};
$(document).ready(function() { var a = Math.floor(Math.random() * 50); var b = Math.floor(Math.random() * 50); var trololo = parseInt(a + b); GoodObj.lala = trololo; document.getElementById('number').innerHTML += a; document.getElementById('number').innerHTML += '+'; document.getElementById('number').innerHTML += b; });
function myFunction (){ var myTrololo = GoodObj.lala; var stop = false; if (document.getElementById('timer').innerHTML == myTrololo) { alert('right'); return true; } else { alert('false'); return stop; } }
function randomInt(min,max){ return Math.floor(Math.random() * (max - min) + min); } var param = randomInt(14, GoodObj.lala); alert(randomInt(14, GoodObj.lala));
Здесь GoodObj.lala - сума двух рандомных чисел. Не думаю, что тот кусок кода нужен. В общем, выводит Nan. В других случаях перемещения переменной или еще чего - что код слишком рекурсивен. Уже совсем запуталась

Ответ

var GoodObj = {}; $(document).ready(function() { var a = Math.floor(Math.random() * 50); var b = Math.floor(Math.random() * 50); var trololo = parseInt(a + b); GoodObj.lala = trololo; document.getElementById('number').innerHTML += a; document.getElementById('number').innerHTML += '+'; document.getElementById('number').innerHTML += b; var param = randomInt(14, GoodObj.lala); console.log(randomInt(14, GoodObj.lala)); }); function randomInt(min, max) { return Math.floor(Math.random() * (max - min) + min); } // этот кусок кода выполняется сразу, тогда, когда инициализация // var trololo = parseInt(a + b); // GoodObj.lala = trololo; // только после загрузки всего ДОМ дерева // в итоге GoodObj.lala попросту не существует и ровняется undefined что и дает нам NaN // просто перенесите в $(document).ready //var param = randomInt(14, GoodObj.lala); //console.log(randomInt(14, GoodObj.lala));

Необходимо вычислить, какое максимальное количество фигур вместится на прямоугольнике. Чем можно реализовать?

Необходимо написать мини-программку, которая рассчитывала бы наиболее экономичную раскладку материала. Дано: фигура произвольной формы и прямоугольный лист материала. Необходимо разложить максимально возможное количество данной фигуры на этом листе так, чтобы между ними оставалось расстояние 2-3мм (можно регулировать). В какую сторону копать? На чем можно реализовать? Хотелось бы на Python, так как более-менее знаю только его.

Ответ

В общем виде эта задача является труднорешаемой, и не имеет эффективного алгоритма решения в принципе (его не существует в природе). Если материал Ваш имеет какую-то особую форму, то ещё можно что-то сделать, а если форма произвольная, то можно попробовать эвристики. Копайте по таким ключевым словам: "задача о плоскостном раскрое" или "Cutting stock problem". На русском, сразу говорю, - мало что полезного найдёте. На английском ищите задачу Cutting stock problem на прямоугольных полосках с бесконечной длиной (или высотой). Там суть почти всех эвристик в том, что делается попытка разместить N фигур на прямоугольной полоске минимальной длиной (высотой) и с фиксированной высотой (длиной). Соответственно, если у вас ширина (высота) уже заданы заранее, то задача о максимальном числе N решается бинарным поиском. Сами же эвристики настолько объёмы по изложению, что расписывать их здесь не смогу.
Отвечаю на второй вопрос: реализовать можно на чём угодно, когда знаешь алгоритм. Готовые библиотеки мне лично не известны. Вообще, это серьёзная научная проблема, коей занимались разные институты (особенно в советское время), нужно довольно хорошо владеть программированием, чтобы всё здесь правильно закодировать.

Деление с округлением в большую сторону

Math.Round округляет по правилу, как заставить его округлять в большую сторону, или какую другую функцию использовать?

Ответ

Math.Ceiling - к большему целому Math.Floor - к меньшему целому

tan и бесконечность

Может ли tan возвратить бесконечность? При каком значении? pi/2 не возвращает бесконечность (из за погрешностей, наверно).

Ответ

Нет, tan не может вернуть бесконечность (+Inf или -Inf).
Из примечания к описанию tan в cppreference
У функции есть полюса при x = π(1/2 + n), однако существующие реализации чисел с плавающей точкой не могут точно представить π/2, поэтому аргумент никогда не попадает в полюс.

Почему в Delphi MinDouble > 0?

If MinDouble > 0 Then // -> всегда True If MinDouble < 0 Then // -> всегда False
... И как с ним правильно сравнивать?
Попробую подробнее объяснить суть вопроса: минимальное и максимальное возможное значение для того и нужно, чтобы определять границы диапазона. Для того и заведены эти константы. И то, что минимальное значение больше нуля это странно, т.к. отрицательные значения этому типу никто не запрещал присваивать. На практике получается все отрицательные числа меньше минимального значения, хотя на то оно и минимальное, чтобы меньше его ничего не было.

Ответ

Заблуждение в том, что:
в отличии от целых чисел, где минимальное - это наиболее отрицательное значение минимальное число типа Double (и аналогичных типов с "плавающей" точкой) - это минимальное отличное от нуля значение.
Дело в том, что знак числа с точкой кодируется одним битом, и никак не влияет на минимальное / максимальное представляемые этим типом значения.
Таким образом:
MinDouble = 5.0e-324; Минимальное представимое число отличное от нуля MaxDouble = 1.7e+308; Максимальное представимое число отличное от нуля
Положительное или отрицательное число - для этих констант не важно, вы сами добавляете знак как вам нужно. Например, используя 4 числа и знак, получаем вот такие диапазоны:
[-MaxDouble .. -MinDouble] 0 [+MinDouble .. +MaxDouble]
P.S. И Delphi тут не при чем, в других ЯП всё так же.