Игорь Кузьмич

char ToChar(int val)
{
    if(static_cast<unsigned>(val) <= 255)  // better to use std::numeric_limits<unsigned char>::max() instead of 255
    {
        return static_cast<char>(val);
    }
    else 
    {
        throw "trying to convert int to char with loosing of data"; // better to throw some another exception from the lib #include <stdexcept>
    }
}

#include <iostream>
#include <cassert>

using namespace std;

int main()
{
	string input;
	cin >> input;
	int unclosed_count = 0;
	for (char c : input)
	{
		if (c == '(')
		{
			++unclosed_count;
		}	
		else if (c == ')')
		{
			--unclosed_count;
			assert(unclosed_count >= 0);//не знаю как надо реагировать на неправильные скобки, но вот тут нужно отслеживать корректность.
		}
	}
}

int n;
    vector<float> maxrix(n * n, 0); // так плохо
    vector<vector<float>> matrix(n, move(vector<float>(n, 0))); // так хорошо

vector<vector<float>>& operator -=(vector<vector<float>>& Left, const vector<vector<float>>& Right) {
    assert(Left.size() == Right.size()); // #include <cassert>
    //ассерт выполняется только в режиме дебага. он делает твой код безопаснее
    for (size_t i = 0; i < Left.size(); i++)
    {
        vector<float>& line = Left[i];//принимает по ссылке, а не по значению.
        const vector<float>& r_line = Right[i];
        assert(line.size() == r_line.size()); // #include <cassert>
        for (size_t j = 0; j < line.size(); j++)
        {
            line[j] -= r_line[j];
        }
    }
    return Left;
}

vector<vector<float>> operator -(const vector<vector<float>>& Left, const vector<vector<float>>& Right) {
    auto copy = Left;
    copy -= Right;
    return copy;
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript : MonoBehaviour //дай скрипту норм назвыание а не "нью бехейвор скрипот"
{
    void Start()
    {
        axis.Normalize();
    }

    [SerializeField] Vector3 axis;//ось вращения
    [SerializeField] float rotation_speed;// градусы в секунду
    void Update()//если update или late update, то используйте deltaTime, если fixed update, то используйте fixed delta time. грубо говоря одно fixed синхронизированно с физическими событиями
    {
        transform.Rotate(axis, rotation_speed * Time.deltaTime);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript1 : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        gameObject.SetActive(false);
        rotation_axis.Normalize();
        rotated_sword = null;
    }

    [SerializeField] Transform rot_hand;
    [SerializeField] Transform usual_hand;
    [SerializeField] float rotation_speed;
    [SerializeField] Vector3 rotation_axis;
    Transform rotated_sword;
    [SerializeField] Transform current_sword;

    public void RotateSword()
    {
        RotateSword(current_sword);
    }

    void RotateSword(Transform sword)
    {
        Debug.Assert(rotated_sword == null);
        gameObject.SetActive(true);
        rotated_sword = sword;
        sword.parent = rot_hand;
        sword.localPosition = new Vector3(0, 0, 0);
        sword.localRotation = new Quaternion(0, 0, 0, 1);

    }

    public void StopRotatingSword()
    {
        Debug.Assert(rotated_sword != null);
        rotated_sword.parent = usual_hand;
        rotated_sword.localPosition = new Vector3(0, 0, 0);
        rotated_sword.localRotation = new Quaternion(0, 0, 0, 1);
        rotated_sword = null;
        gameObject.SetActive(false);
    }

    public bool IsRotatingSword()
    {
        return rotated_sword != null;
    }

    void FixedUpdate()
    {
        transform.Rotate(rotation_axis, rotation_speed * Time.fixedDeltaTime);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        public delegate double Func(double x);
        static void Main(string[] args)
        {
            Func procedure = function;

            double a, b;
            a = 0.5;
            b = 1.5;
            use_procedure_for_a_and_b(ref a, ref b, procedure);
            Console.WriteLine((a + b) / 2);
            Console.ReadLine();
        }
        static void use_procedure_for_a_and_b(ref double a, ref double b, Func procedure)
        {
            const double e = 0.001;
            while (Math.Abs(b - a) > 2 * e)
            {
                double c = (a + b) / 2;
                if (procedure(b) * procedure(c) < 0)
                {
                    a = c;
                }
                else
                {
                    b = c;
                }
            }
        }
        static double function(double x)
        {
            double tmp = Math.Pow(2, 0.5);
            return 4 * Math.Sin(3 * x - 1) - Math.Pow(x, tmp) + 1;
        }
    }
}

bool key_pressed;
void Update()
{
    key_pressed = Input.GetKeyDown(...);
}
void OnTriggerStay(Collider other)
{
    if(otrer - это не подбираемый предмет)
    {
          return;
    }

    if(key pressed)
    {
          забрать предмет в инвентарь;
    }
}

using polimorf_ptr = variant<double*, string*, bool*>;
vector<polimorf_ptr> ...; // получается у вас не void*, а polimorf_ptr

void no_destructor(void*) {}

struct PolimorfPtr
{
public:
	PolimorfPtr()
		: ptr(nullptr) //надеюсь, ты шаришь за двоеточие
	{}
	PolimorfPtr(const PolimorfPtr&) = delete;
	PolimorfPtr(PolimorfPtr&& other) //надеюсь, ны знаешь что такое r-value - ссылка
		:ptr(other.ptr),
		destructor(other.destructor)
	{
		other.ptr = nullptr;
		other.destructor = no_destructor;
	}
	//мне лень писать оператор =, оператор *, -> и вот это вот все, надеюсь ты знаешь зачем нужны эти операторы и понимаешь о чем я

	PolimorfPtr(void* pointer, void destructor_calling_function(void*) = no_destructor)
		: ptr(pointer),
		destructor(destructor_calling_function)
	{}

	void* ptr; //====================================================== тут хранится указатель
	void (*destructor)(void*) = no_destructor; //===========тут хранится указатель на деструктор (на функцию, которая вызывает деструктор)

	~PolimorfPtr()
	{
		destructor(ptr);
		ptr = nullptr;
		destructor = no_destructor;
	}
};

#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <optional>
#include <cmath>
#include <cassert>
using namespace std;

double f(double x)
{
	return x * x * x * (cosh(x)) + M_PI - 9 * M_PI * x;// (e^x+e^-x)/2 это "гиперболический косинус" aka "чосинус"
}

bool has_different_signs(double a, double b)
{
	return (a > 0) != (b > 0);
}

vector<pair<double, double>> find_sign_shanges(double from, double to, double step, double function(double))
{
	assert(from < to);
	assert(step > 0);

	vector<pair<double, double>> result;

	double last_val = function(from);
	double last_x = from;
	from += step;
	for (; from < to; last_x = from, from += step)
	{
		double current_val = function(from);
		if (has_different_signs(current_val, last_val))
		{
			result.push_back({last_x, from});
		}
		last_val = current_val;
		last_x = from;
	}
	return result;
}

optional<double> find_root_binary(double from, double to, double function(double), double precision, double slope_limit = +INFINITY)
{
	double y1 = function(from);
	double y2 = function(to);
	assert(from <= to); // не уверен что это нужно
	assert(has_different_signs(y1, y2));
	assert(slope_limit > 0);
	assert(precision > 0);

	double slope = (y2 - y1) / (to - from);
	if (abs(slope) >= slope_limit)
	{
		return nullopt; // если угол наклона граффика очень боьшой, кторее всего знак меняется не через 0, а через разрыв
	}

	double middle_x = (from + to) / 2;
	double middle_y = function(middle_x);
	if (abs(middle_y) < precision)
	{
		return middle_x;
	}
	if (has_different_signs(middle_y, y1))
	{
		return find_root_binary(from, middle_x, function, slope_limit);
	}
	else
	{
		return (find_root_binary(middle_x, to, function, slope_limit));
	}
}

vector<double> find_roots(double from, double to, double function(double), double precision, double step = 0.1)
{
	assert(precision > 0);
	auto sign_shanges = find_sign_shanges(from, to, step, function);
	vector<double> result;
	for (auto [from_mini, to_mini] : sign_shanges) // нужен c++ 17 или более поздняя версия вроде бы как для такого синтаксиса
	{
		auto root = find_root_binary(from_mini, to_mini, function, precision);
		if (root)
		{
			result.push_back(*root);
		}
	}
	return result;
}

int main()
{
	auto roots = find_roots(-10, +10, f, 0.0000001);
	for (double root : roots)
	{
		cout << root << endl;
	}
	return 0;
}