ce inseamna matematica m1 si m2?
e chiar m1, m2, m3 si sunt nivelele de matematica in functie de profilul de liceu. m1 la mate info, m2 la stiinte, m3 la filologie.
Evident ca gresesti.Obtii ceva de genul kg2 etc. ce inseamna micuta?unde este?si ce diferenta? Valoarea sumei (s) se obtine scazand din suma tuturor numerelor de la n+1 la 2n (elemente "superioare", notate mai departe prin "s" cu diversi indici) pe cea a tuturor numerelor de la 1 la n ("inferioare" - "i" cu diversi indici), adica [(n+1+2n)n]/2 minus n(n+1)/2, care, intr-adevar, da n2.

Daca, din cele n "a"-uri (fie A multimea lor) k sunt "inferioare" si n-k sunt "superioare", atunci, implicit, multimea "b"-urilor (B) va contine k elemente "superioare" si n-k "inferioare". Atunci, ordonate crescator, elementele lui A s-ar scrie: i1<i2<...<ik<s1<s2...<sn-k, iar cele din B, ordonate descrescator: sn-k+1>sn-k+2>...sn>ik+1>ik+2...>in, tinandu-se cont ca, evident, orice "i" este mai mic decat orice "s". Atunci, eplicitand fiecare modul din suma s, ea devine s=sn-k+1-i1+sn-k+2-i2+...+sn-ik+s1-ik+1+s2-ik+2+...sn-k-in, adica suma "s"-urilor minus cea a "i"-urilor.

Problema draguta. Multumesc! Din punct de vedere fizic, ceva exista sau nu. Un numar irational e ceva ce nu exista; neavind o marime definita. **UPDATE**


Acest răspuns este destul de vechi, și așa descrie ceea ce a fost 'bine' la momentul respectiv, care a fost inteligent indicii furnizate de Impuls bibliotecă. Deoarece C++11, biblioteca standard a furnizat suficiente smart pointeri de tipuri, și așa ar trebui să favorizeze utilizarea [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr), [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr) și [`std::weak_ptr`](http://en.cppreference.com/w/cpp/memory/weak_ptr). 


Acolo a fost, de asemenea, [`std::auto_ptr`](http://en.cppreference.com/w/cpp/memory/auto_ptr). A fost foarte mult ca o luneta pointer, cu excepția faptului că a avut, de asemenea, "speciale" periculoase capacitatea de a fi copiate — care, de asemenea, în mod neașteptat transferă dreptul de proprietate.
**S-a depreciat în C++11 și eliminate în C++17**, deci nu ar trebui't-l folosească.



```
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
```






**RĂSPUNS VECHI**


Un smart pointer este o clasa care se infasoara un 'prime' (sau 'gol') C++ pointer, pentru a gestiona durata de viață a obiectului de a fi subliniat. Nu există nici un singur inteligente de tip pointer, dar toate dintre ele încerca să rezumat o primă pointer într-un mod practic.


Smart pointeri ar trebui să fie de preferat peste prime indicii. Dacă simțiți că aveți nevoie pentru a utiliza pointeri (ia în considerare mai întâi dacă într-adevăr ** face), ar fi normal să doriți să utilizați un smart pointer deoarece acest lucru poate atenua multe dintre problemele cu prime indicii, în principal, uitând să ștergeți obiectul și scurgeri de memorie.


Cu prime indicii, programatorul trebuie să specifice în mod explicit distruge obiectul atunci când acesta nu mai este util.



```
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
```

Un smart pointer prin comparație definește o politică ca atunci când obiectul este distrus. Tu încă mai au pentru a crea un obiect, dar nu mai trebuie să vă faceți griji despre distrugerea ei.



```
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception
```

Cea mai simplă politica de utilizare implică domeniul de aplicare de smart pointer obiect înveliș, cum ar fi puse în aplicare până la [`boost::scoped_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/scoped_ptr.htm) sau [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr). 



```
void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}
```

Notă: std::unique\_ptr` cazuri nu pot fi copiate. Acest lucru previne pointer de a fi șterse de mai multe ori (în mod incorect). Cu toate acestea, puteți trece referiri la aceasta în jurul valorii de la alte funcții-ai sunat.


`std::unique\_ptr sunt utile atunci când doriți pentru a lega de viata a obiectului la un anumit bloc de cod, sau dacă încorporat ca date membre în interiorul altui obiect, durata de viata de care alt obiect. Obiectul există până conțin bloc de cod este ieșit, sau până la obiect este distrus.


Mai complex smart pointer politică implică numărare de referință indicatorul. Acest lucru permite ca indicatorul să fie copiate. Când ultima "de referință" la obiectul este distrus, obiectul este șters. Această politică este implementată de [`boost::shared_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm) și [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr).



```
void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.
```

Referință numărat indicii sunt foarte utile atunci când durata de viață a obiectului este mult mai complicat, și nu este legat direct la o anumită secțiune de cod sau de la un alt obiect.


Există un dezavantaj de referință numărat pointer — posibilitatea de a crea o marionetă de referință:



```
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
```

O altă posibilitate este crearea de referințe circulare:



```
struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
```

Pentru a rezolva această problemă, atât Stimula și C++11 au definit o `weak_ptr` pentru a defini un slab (nenumărate) de referință la un `shared_ptr`. Informal:a, b, d, i, k, l, m  

Restul  sunt formal Am transmis întrebarea ta mai departe și ai mai jos răspunsul oficial, al cuiva din stafful Duolingo: 



> 
> ”On average, there are 2 forward challenges (en2ro) for 1 reverse challenge (ro2en). We are working on an optimization process of our lesson generation (with an algorithm), in order to give our users the best amount of each type of exercise, depending on which course they are taking.”
> 
> 
> Confundați două mărimi fizice distincte: forța și puterea. La un magnet aveți o forță de atracție sau respingere, iar caii-putere măsoară cîtă energie mecanică se transferă de la ceva la altceva într-o secundă.  

  

 Dacă forța magnetului nu produce nici o mișcare, adică dacă sistemul e în repaus, atunci nu transmite nici o energie, deci aveți 0 cai-putere.  

  

 Dacă în schimb magnetul produce deplasarea unui corp, atunci înmulțiți forța cu distanța parcursă și obțineți lucrul mecanic (energia consumată pentru a mișca corpul acela). Apoi împărțiți lucrul mecanic la durata mișcării pentru a afla puterea. Iar în final puteți transforma puterea din wați în cai-putere, dacă vă place mai mult așa.  

  

 Observați deci că puterea *P* obținută depinde de doi parametri pe care nu i-ați precizat: distanța *d* pe care se mișcă un corp sub acțiunea magnetului și durata *t* a acelei mișcări. Iată formula: *P* = *F* * *d* / *t*. În formula asta *F* * *d* este lucrul mecanic efectuat *L*, iar *d* / *t* este viteza *v* a corpului pus în mișcare. Deci mai puteți scrie formula și ca *P* = *L* / *t* sau *P* = *F* * *v*.  

  

 Dar probabil e prea devreme pentru formule. Mai întîi încercați să înțelegeți noțiunile. b)Am facut o noua imagine in programul Geogebra ca sa vedem mai clar ce se intampla:


![](https://i.imgur.com/tQREF8B.png)


Daca imaginea nu apare la o dimensiune corespunzatoare, o poti vedea mai bine aici:


<https://i.imgur.com/tQREF8B.png>.


Deoarece P este simetricul lui M fata de AB,  rezulta ca unghiurile MFB si BFP sunt ambele drepte si ca laturile MF si FP sunt congruente. Triunghiurile MFB si PFB mai au si o latura comuna(FB), deci sunt congruente. Rezulta ca unghiurile PBF si MBF sunt congruente. Observam si ca unghiul MBF este acelasi cu unghiul ABC.


Analog, din congruenta triunghiurilor CHN si CHR, avem ca unghiurile HCN si HCR sunt congruente, HCN fiind echivalent cu unghiul ACB..


![m(\angle PBC)+m(\angle RCB)=2(m(\angle ABC)+m(\angle ACB))=2(180-m(\angle BAC))](http://latex.codecogs.com/gif.latex?m(\angle&space;PBC)+m(\angle&space;RCB)=2(m(\angle&space;ABC)+m(\angle&space;ACB))=2(180-m(\angle&space;BAC)))


Dar cum triunghiul este ascutitunghic, inseamna ca ![m(\angle BAC)<90](http://latex.codecogs.com/gif.latex?m(\angle&space;BAC)<90), deci ![-m(\angle BAC)>-90](http://latex.codecogs.com/gif.latex?-m(\angle&space;BAC)>-90), apoi ![180-m(\angle BAC)>180-90=90](http://latex.codecogs.com/gif.latex?180-m(\angle&space;BAC)>180-90=90), si in final ![2(180-m(\angle BAC))>180](http://latex.codecogs.com/gif.latex?2(180-m(\angle&space;BAC))>180), adica:


![m(\angle PBC)+m(\angle RCB)>180](http://latex.codecogs.com/gif.latex?m(\angle&space;PBC)+m(\angle&space;RCB)>180), ceea ce inseamna ca laturile QB si SC nu se pot intalni deasupra lui BC, dar nici nu sunt paralele(altfel suma unghiurilor ar fi de 180), deci se intalnesc sub BC in punctul T.  Cum A este deasupra lui BC(asa am convenit in desen), rezulta ca A si T se afla de o parte si de alta a lui BC. in marele oras toulouse din franta, cartier cu bloc nou, lux, gata sa locuiesti, 136 m2 cu garaj subsol si tersase de aprox 200 m2 este la pret total 500.000 euro, deci 1 m2 se poate calcula... 
cautati pe internet e simplu