Pe care l-am găsit pe site-ul DataGenetics. Vă rugăm să trimiteți toate erorile din acest articol în mesaje private.

În această problemă, în închisoare sunt 100 de prizonieri, fiecare numărat de la 1 la 100. temnicerul decide să le dea prizonierilor șansa de a fi eliberați, le spune condițiile testului, iar dacă toți prizonierii trec testul, atunci vor fi eliberați. Dacă cel puțin unul dintre ei pică testul, atunci toți prizonierii vor muri.

O sarcină

temnicerul merge la camera secretași pregătește 100 de cutii cu capace. Pe fiecare cutie marchează numere de la 1 la 100. Apoi aduce 100 de tăblițe de hârtie, în funcție de numărul deținuților, și numere aceste tăblițe de la 1 la 100. După aceea, amestecă 100 de tăblițe și pune câte o tabletă în fiecare cutie, închiderea capacului. Prizonierii nu văd cum efectuează temnicerul toate aceste acțiuni.

Începe competiția, temnicerul duce fiecare prizonier pe rând în camera cu cutiile și le spune prizonierilor că trebuie să găsească o cutie care să conțină o plăcuță cu numărul prizonierului. Prizonierii încearcă să găsească plăcuța cu numărul lor deschizând cutiile. Fiecare are permisiunea de a deschide până la 50 de cutii; dacă fiecare dintre prizonieri își găsește numărul, atunci prizonierii vor fi eliberați, dacă cel puțin unul dintre ei nu își găsește numărul în 50 de încercări, atunci toți prizonierii vor muri.

Pentru ca prizonierii să fie eliberați, TOȚI deținuții trebuie să treacă testul cu succes.

Deci, care este șansa ca prizonierii să fie grațiați?

• După ce prizonierul deschide cutia și verifică farfuria, aceasta este pusă înapoi în cutie și capacul este închis din nou;
• Locurile plăcilor nu pot fi schimbate;
• Prizonierii nu pot lăsa indicii unul altuia sau nu pot interacționa între ei în niciun fel odată ce procesul a început;
• Deținuților li se permite să discute despre strategie înainte de începerea procesului.

Care este cea mai bună strategie pentru prizonieri?

Intrebare suplimentara:

Dacă un prieten al prizonierilor (nu este un participant la test) va putea intra în camera secretă înainte de începerea testului, examinează toate tabletele din toate cutiile și (opțional, dar nu este obligatoriu) schimbă două tablete din două cutii (în acest caz, tovarășul nu va avea ocazia să informeze atât deținuții despre rezultatul acțiunilor sale), atunci ce strategie ar trebui să ia pentru a crește șansele prizonierilor de a evada?

Soluție improbabilă?

La prima vedere, această sarcină pare aproape fără speranță. Se pare că șansa pentru fiecare dintre prizonieri de a-și găsi tableta este microscopic mică. În plus, prizonierii nu pot face schimb de informații între ei în timpul procesului.

Şansele unui prizonier sunt 50:50. Sunt 100 de cutii în total și poate deschide până la 50 de cutii în căutarea semnului său. Dacă deschide cutiile la întâmplare și deschide jumătate din toate cutiile, își va găsi tableta în jumătatea deschisă a cutiilor, sau tableta lui va rămâne în cele 50 de cutii închise. Șansele lui de succes sunt ½.

Să luăm doi prizonieri. Dacă ambii aleg casete la întâmplare, șansele pentru fiecare dintre ele vor fi ½, iar pentru două ½x½=¼.
(pentru doi prizonieri, succesul va fi într-un caz din patru).

Pentru trei prizonieri, șansele sunt ½ × ½ × ½ = ⅛.

Pentru 100 de prizonieri, șansele sunt: ​​½ × ½ × … ½ × ½ (înmulțiți de 100 de ori).

Aceasta este egală

Pr ≈ 0,0000000000000000000000000000008

Deci este o șansă foarte mică. În acest scenariu, cel mai probabil, toți prizonierii vor fi morți.

Incredibil raspuns

Dacă fiecare prizonier deschide cutiile la întâmplare, este puțin probabil să treacă testul. Există o strategie în care deținuții se pot aștepta să aibă succes mai mult de 30% din timp. Acesta este un rezultat uimitor de incredibil (dacă nu ați auzit de asta problema de matematica anterior).

Mai mult de 30% pentru toți cei 100 de prizonieri! Da, acestea sunt chiar mai mari decât șansele pentru doi prizonieri, cu condiția să deschidă cutiile la întâmplare. Dar cum este posibil acest lucru?

Este clar că câte unul pentru fiecare deținut, șansele nu pot fi mai mari de 50% (la urma urmei, nu există nicio cale de comunicare între deținuți). Dar nu uitați că informațiile sunt stocate în locația plăcuțelor din interiorul cutiilor. Nimeni nu amestecă tabletele între vizitele în cameră ale prizonierilor individuali, așa că putem folosi aceste informații.

Soluţie

În primul rând, vă voi spune soluția, apoi vă voi explica de ce funcționează.

Strategia este extrem de ușoară. Primul dintre prizonieri deschide cutia cu numărul care este scris pe haine. De exemplu, prizonierul cu numărul 78 deschide cutia cu numărul 78. Dacă își găsește numărul pe plăcuța din interiorul cutiei, e grozav! Dacă nu, se uită la numărul de pe plăcuță din caseta „lui” și apoi deschide următoarea casetă cu acel număr. După ce a deschis a doua cutie, se uită la numărul tabletei din interiorul acestei cutii și deschide a treia cutie cu acest număr. Apoi pur și simplu transferăm această strategie în casetele rămase. Pentru claritate, priviți imaginea:

În cele din urmă, prizonierul fie își va găsi numărul, fie va ajunge la limita de 50 de cutii. La prima vedere, acest lucru pare inutil în comparație cu alegerea pur și simplu a unei cutii la întâmplare (și pentru un singur prizonier este așa), dar din moment ce toți cei 100 de prizonieri vor folosi același set de cutii, are sens.

Frumusețea asta problema de matematica- nu numai pentru a cunoaște rezultatul, ci și pentru a înțelege De ce această strategie funcționează.

Deci, de ce funcționează strategia?

Fiecare cutie conține o farfurie - iar această farfurie este unică. Aceasta înseamnă că placa se află într-o cutie cu același număr sau că indică o cutie diferită. Deoarece toate plăcile sunt unice, există o singură placă pentru fiecare cutie care indică către ea (și o singură cale de a ajunge la acea cutie).

Dacă te gândești bine, cutiile formează un lanț circular închis. O casetă poate face parte dintr-un singur lanț, deoarece în interiorul casetei există doar un indicator către următorul și, în consecință, în caseta anterioară există un singur indicator către această casetă (programatorii pot vedea analogia cu listele legate).

Dacă cutia nu indică spre sine (numărul casetei este egal cu numărul plăcii din ea), atunci va fi în lanț. Unele lanțuri pot consta din două cutii, altele sunt mai lungi.

Deoarece toți prizonierii încep cu o cutie cu același număr pe haine, ei sunt, prin definiție, plasați pe lanțul care conține plăcuța lor (există o singură plăcuță care indică această casetă).

Explorând cutiile de-a lungul acestui lanț într-un cerc, ei au garantat că în cele din urmă își vor găsi semnul.

Singura întrebare rămâne dacă își vor găsi tableta în 50 de mișcări.

Lungimea lanțului

Pentru ca toți prizonierii să treacă testul, lungimea maximă a lanțului trebuie să fie mai mică de 50 de cutii. Dacă lanțul este mai lung de 50 de cutii, prizonierii cu numere din acele lanțuri vor pisa testul - și toți prizonierii vor fi morți.

Dacă lungimea maximă a celui mai lung lanț este mai mică de 50 de cutii, atunci toți prizonierii vor trece testul!

Gândește-te la asta o secundă. Se dovedește că poate exista un singur lanț mai lung de 50 de cutii în orice aspect al plăcilor (avem doar 100 de cutii, deci dacă un lanț este mai lung de 50, restul va fi mai scurt de 50 în total).

Cote de mână cu lanț lung

Odată ce te-ai convins că lungimea maximă a lanțului trebuie să fie mai mică sau egală cu 50 pentru a reuși și că poate exista doar un lanț lung în orice set, putem calcula probabilitatea de a trece provocarea:

Mai multă matematică

Deci de ce avem nevoie pentru a ne da seama de probabilitatea unui lanț lung?

Pentru un lanț de lungime l, probabilitatea ca cutiile să fie în afara acestui lanț este:

Există (l-1) în această colecție de numere! modalități de aranjare a semnelor.

Semnele rămase pot fi localizate (100-l)! modalități (nu uitați că lungimea lanțului nu depășește 50).

Având în vedere acest lucru, numărul de permutări care conțin lanțul lungimea exacta l: (>50)

Rezultă că există 100(!) moduri de aranjare a plăcilor, astfel încât probabilitatea de existență a unui lanț de lungime l este egală cu 1/l. Apropo, acest rezultat nu depinde de numărul de cutii.

După cum știm deja, poate exista un singur caz în care există un lanț cu o lungime > 50, deci probabilitatea de succes este calculată prin această formulă:

Rezultat

31,18% - probabilitatea ca dimensiunea celui mai lung lanț să fie mai mică de 50 și fiecare dintre prizonieri să-și poată găsi tableta, având în vedere limita de 50 de încercări.

Probabilitatea ca toți deținuții să-și găsească plăcuțele și să treacă testul este de 31,18%

Mai jos este un grafic care arată probabilitățile (pe axa y) pentru toate lanțurile de lungime l (pe axa x). Roșu înseamnă toate „eșecurile” (curba dată aici este doar un grafic de 1/l). Culoarea verdeînseamnă „succes” (calculul este puțin mai complicat pentru această parte a graficului, deoarece există mai multe moduri de a determina lungime maxima <50). Общая вероятность складывается из зеленых столбцов в 31.18% шанс на спасение.

Număr armonic (această parte a articolului este pentru tocilari)

În matematică, al n-lea număr armonic este suma reciprocelor primelor n numere consecutive ale seriei naturale.

Să calculăm limita dacă în loc de cutii de 100a avem un arbitrar un numar mare de cutii (să presupunem că avem 2n cutii în total).

Constanta Euler-Mascheroni este o constantă definită ca limita diferenței dintre suma parțială a unei serii armonice și logaritmul natural al unui număr.

Pe măsură ce numărul deținuților crește, dacă supraveghetorul permite prizonierilor să deschidă jumătate din toate cutiile, atunci șansa de salvare tinde la 30,685%

(Dacă luați o decizie în care prizonierii ghicesc cutiile aleatoriu, atunci pe măsură ce numărul deținuților crește, probabilitatea de a fi salvați tinde spre zero!)

Întrebare suplimentară

Îți amintește cineva de întrebarea suplimentară? Ce poate face tovarășul nostru de ajutor pentru a ne crește șansele de supraviețuire?

Acum știm deja soluția, așa că strategia de aici este simplă: trebuie să examineze toate semnele și să găsească cel mai lung lanț de cutii. Dacă cel mai lung lanț este mai mic de 50, atunci nu trebuie să schimbe deloc tabletele sau să le schimbe astfel încât cel mai lung lanț să nu devină mai lung de 50. Totuși, dacă găsește un lanț mai lung de 50 de cutii, tot ce trebuie să facă este să schimbe conținutul a două cutii din acel lanț pentru a rupe acel lanț în două lanțuri mai scurte.

Ca urmare a acestei strategii, nu vor exista lanțuri lungi și toți prizonierii au garantat să-și găsească semnul și salvarea. Deci, schimbând două semne, reducem probabilitatea de mântuire la 100%!

Amintiți-vă că volumul unui cuboid (sau al unei cutii obișnuite) este egal cu produsul dintre lungimea, lățimea și înălțimea acestuia. Dacă cutia ta este dreptunghiulară sau pătrată, tot ce trebuie să știi este lungimea, lățimea și înălțimea acesteia. Pentru a obține volumul, este necesar să se înmulțească rezultatele măsurătorilor. Formula de calcul în formă prescurtată este adesea prezentată după cum urmează: V \u003d L x W x H.
Exemplu de problemă: „Dacă lungimea cutiei este de 10 cm, lățimea este de 4 cm și înălțimea este de 5 cm, atunci care este volumul acesteia?”
V = L x l x H
V=10cmx4cmx5cm
V \u003d 200 cm 3
„Înălțimea” cutiei poate fi denumită „adâncime”. De exemplu, o sarcină ar putea conține următoarele informații: „Lungimea cutiei este de 10 cm, lățimea este de 4 cm și adâncimea este de 5 cm”.

2
Măsurați lungimea cutiei. Dacă te uiți la caseta de sus, aceasta va apărea în fața ochilor tăi sub forma unui dreptunghi. Lungimea casetei va fi cea mai lungă latură a acestui dreptunghi. Înregistrați rezultatul măsurării acestei laturi ca valoare a parametrului „lungime”.
Asigurați-vă că utilizați aceeași unitate de măsură atunci când efectuați măsurători. Dacă ați măsurat o parte în centimetri, atunci și celelalte părți trebuie măsurate în centimetri.

3
Măsurați lățimea cutiei. Lățimea casetei va fi reprezentată de cealaltă latură, mai scurtă, a dreptunghiului vizibilă de sus. Dacă conectați vizual părțile laterale ale cutiei măsurate în lungime și lățime, atunci acestea vor apărea sub forma literei „G”. Înregistrați valoarea ultimei măsurători ca „lățime”.
Lățimea este întotdeauna partea mai scurtă a cutiei.

4
Măsurați înălțimea cutiei. Acesta este ultimul parametru pe care nu l-ați măsurat încă. Reprezintă distanța de la marginea de sus a cutiei până la partea de jos. Înregistrați valoarea acestei măsurători ca „înălțime”.
În funcție de partea pe care ați pus cutia, laturile specifice pe care le desemnați drept „lungime”, „lățime” sau „înălțime” pot fi diferite. Totuși, nu contează, ai nevoie doar de măsurătorile din trei părți diferite.

5
Înmulțiți rezultatele celor trei măsurători împreună. După cum sa menționat deja, formula de calcul al volumului este următoarea: V = Lungime x Lățime x Înălțime; prin urmare, pentru a obține volumul, trebuie pur și simplu să înmulți toate cele trei părți. Asigurați-vă că includeți unitățile pe care le-ați folosit în calcul, astfel încât să nu uitați ce înseamnă valorile pe care le obțineți.

6
Când indicați unitățile de volum, nu uitați să indicați a treia putere „3”. Volumul calculat are o expresie numerică, dar fără indicarea corectă a unităților de măsură, calculele dumneavoastră vor fi lipsite de sens. Pentru a reflecta corect unitățile de volum, acestea trebuie specificate în cub. De exemplu, dacă toate laturile ar fi măsurate în centimetri, atunci unitățile de volum ar fi specificate ca „cm3”.
Un exemplu de problemă: „Dacă o cutie are o lungime de 2 m, o lățime de 1 m și o înălțime de 3 m, atunci care este volumul ei?”
V = L x l x H
V = 2m x 1m x 4m
V \u003d 8 m 3
Notă: Indicarea unităților cubice de volum vă permite să înțelegeți câte astfel de cuburi pot fi plasate în interiorul cutiei. Dacă ne referim la exemplul anterior, aceasta înseamnă că opt metri cubi sunt plasați într-o cutie.

Calculul volumului cutiilor de alte forme

Determinați volumul cilindrului. Cilindrul este un tub rotund cu cercuri la ambele capete. Pentru a determina volumul unui cilindru se folosește formula: V = π x r 2 x h, unde π = 3,14, r este raza laturii rotunde a cilindrului și h este înălțimea acestuia.
Pentru a determina volumul unui con, sau al unei piramide cu o bază rotundă, se folosește aceeași formulă, dar înmulțită cu 1/3. Adică volumul conului se calculează prin formula: V = 1/3 (π x r 2 x h)

2
Determinați volumul piramidei. O piramidă este o figură care are o bază plată și laturile convergente în partea de sus către un punct. Pentru a determina volumul unei piramide, trebuie să luați 1/3 din produsul suprafeței bazei și înălțimii. Adică, formula de calcul este următoarea: Volumul piramidei = 1/3 (Aria bazei x Înălțime).
În cele mai multe cazuri, piramidele au o bază pătrată sau dreptunghiulară. Într-o astfel de situație, aria bazei se calculează înmulțind lungimea bazei cu lățimea.

Pentru a determina volumul unei cutii de forme complexe, adăugați volumele părților sale individuale. De exemplu, poate fi necesar să măsurați volumul unei cutii în formă de litera „L”. În acest caz, cutia va avea mai multe laturi de măsurat. Dacă împărțiți această casetă în două părți, puteți măsura volumul acestor două părți în mod standard, apoi puteți adăuga valorile rezultate. În cazul cutiei în formă de L, partea mai lungă poate fi considerată ca o cutie dreptunghiulară lungă separată, iar partea mai scurtă ca o cutie pătrată (sau aproape pătrată) atașată acesteia.
Dacă cutia ta are forme foarte complexe, atunci știi că există multe modalități de a determina volumul obiectelor de orice formă.

Scrieți un program care compară două numere întregi introduse de la tastatură. Programul trebuie să indice ce număr este mai mare sau, dacă numerele sunt egale, să afișeze un mesaj corespunzător.

Tastați două numere întregi și apăsați Enter.
-> 34 67
34 mai puțin de 67

cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura principală este A, B: întreg; begin Put_Line("Introduceți două numere întregi pe o linie și apăsați Enter."); pune("-> "); Obtine o); Obține(B); --Introduceți 2 numere dacă A > B apoi Put(Articol =>; A, Lățime =>; 1); pune(„mai mare decât”); Put(Articol => B, Lățime => 1); elsif A< B then Put(Item =>A, Latime => 1); pune("mai puțin decât"); Put(Articol => B, Lățime => 1); else Put("Numerele introduse sunt egale!"); termina dacă; sfârşitul principal;

Sunt date trei numere întregi. Găsiți cel mai mare dintre ele (programul ar trebui să scoată exact un număr întreg). Cel mai mare din această problemă este înțeles ca un număr care nu este mai mic decât oricare altul.

• 
  -> 1 2 3
  Maxim de trei numere: 3

• cu Ada.Text_IO ; utilizați Ada.Text_IO ; cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; procedura principală este A, B, C: întreg; max: întreg; începe Put_Line( „Introduceți trei numere întregi pe o linie și apăsați Enter.”) ; Put("-> "); Obtine o); Obține(B); Obține(C); --Introduceți trei numere întregi max:=A; --Mod implicit considerăm că numărul A este maxim dacă B > max atunci --Dacă B este mai mare decât maximul, atunci max:=B; --numărul maxim este B termina daca; dacă C > max atunci --Dacă C este mai mare decât maximul, atunci max:=C; --numărul maxim este C termina daca; A pune( „Maximum trei numere:”& Integer"image(max)); end main;

  cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura principală este A, B, C: întreg; max: întreg; begin Put_Line ("Introduceți trei numere întregi pe o linie și apăsați Enter."); pune("-> "); Obtine o); Obține(B); Obține(C); --Introduceți trei numere întregi max:= A; --implicit, presupunem că numărul A este maxim dacă B > max atunci --Dacă B este mai mare decât maximul, atunci max:= B; --numărul maxim este B sfârşit dacă; dacă C > max atunci --Dacă C este mai mare decât max, atunci max:= C; --numărul maxim este egal cu C end if; Put("Maximum trei numere:" & Integer"imagine(max)); end main;

Dat trei numere naturale A, B, C. Determinați dacă există un triunghi cu aceste laturi. Dacă triunghiul există, tipăriți un mesaj că există un triunghi cu astfel de laturi, altfel imprimați că triunghiul nu există.

• Introduceți cele trei laturi ale triunghiului și apăsați Enter.
  -> 3 4 5
  Există un triunghi cu laturile 3, 4, 5.

Un triunghi este format din trei puncte care nu se află pe aceeași dreaptă. Un triunghi există doar dacă suma oricăror două dintre laturile sale este mai mare decât a treia.

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; --Pentru citirea numerelor întregi cu Ada.Text_IO ; utilizați Ada.Text_IO ; --Pentru a afișa șiruri procedura principală este a, b, c: întreg; începe Put_Line( „Introduceți trei laturi ale unui triunghi și apăsați Enter.Enter.”) ; Put("-> "); Obtine o); Obține(b); Obține(c); --Citiți laturile triunghiului dacă a + b > c și atunci b + c > a și atunci c + a > b atunci --Verificați toate condițiile într-o singură linie A pune( „Triunghi cu laturi”& Integer"image(a) & "," & Integer"imagine(b) & "," & Integer"imagine(c) & "există" ); else Put( „Triunghi cu laturi”& Integer"image(a) & "," & Integer"image(b) & "," & Integer"imagine(c) & "nu există" ); end if ; end main;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; --Pentru a citi numere întregi cu Ada.Text_IO; utilizați Ada.Text_IO; --Pentru a tipări șiruri de caractere, procedura principală este a, b, c: Integer; begin Put_Line("Introduceți cele trei laturi ale triunghiului și apăsați Enter.Enter."); pune("-> "); obtine o); obține(b); obține(c); --Citiți laturile triunghiului dacă a + b > c și apoi b + c > a și apoi c + a > b atunci --Verificați toate condițiile într-o singură linie Put("Triunghi cu laturi" & Întreg"imagine(a) & " ," & Integer"imagine(b) & "," & Integer"imagine(c) & "există"); else Put("Triunghi cu laturi" & Integer"imagine(a) & "," & Integer"imagine( b) & "," & Integer"imagine(c) & "nu există"); termina dacă; sfârşitul principal;

Sunt date trei numere întregi. Stabiliți câte dintre ele se potrivesc. Programul ar trebui să scoată unul dintre numerele: 3 (dacă toate sunt la fel), 2 (dacă două sunt la fel) sau 0 (dacă toate sunt diferite).

• Tastați trei numere întregi și apăsați Enter.
  -> 1 2 3
  0

• cu Ada.Text_IO ; utilizați Ada.Text_IO ; cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; procedura Principala este A, B, C: Integer; începe Put_Line( „Introduceți trei numere întregi și apăsați pe Enter”.) ; Put("-> "); Obtine o); Obține(B); Obține(C); dacă A = B și atunci A = C atunci --Dacă toate cele trei numere se potrivesc Pune(Articol => 3 , Lățime => 1 ) ; elsif A = B sau A = C sau B = C atunci --Dacă două numere se potrivesc Pune(Articol => 2 , Latime => 1 ) ; altfel --În cazul în care un aceleasi numere Nu Pune(Articol => 0 , Lățime => 1 ) ; termina daca; endMain;

  cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura Principala este A, B, C: Integer; begin Put_Line ("Introduceți trei numere întregi și apăsați Enter."); pune("-> "); Obtine o); Obține(B); Obține(C); dacă A = B și atunci A = C atunci --Dacă toate cele trei numere se potrivesc Put(Articol => 3, Lățime => 1); elsif A = B sau A = C sau B = C atunci --Dacă două numere se potrivesc Put(Articol => 2, Lățime => 1); else --Dacă nu există numere identice Pune (Articol => 0, Lățime => 1); termina dacă; endMain;

Turnul de șah se mișcă orizontal sau vertical. Dat două diferite celule tablă de şah, determinați dacă turnul se poate muta de la prima celulă la a doua într-o singură mișcare. Programul primește ca intrare patru numere de la 1 la 8 fiecare, specificând numărul coloanei și numărul rândului, mai întâi pentru prima celulă, apoi pentru a doua celulă. Programul ar trebui să afișeze „DA” dacă este posibil să ajungeți la a doua din prima celulă prin mișcarea turnului, sau „NU” în caz contrar.

• 
  4 4
  5 5
  NU

• ) ; A pune() ; Obtine o); Obține(B); A pune() ; Obține(C); Obține(D); dacă A = C sau B = D atunci Put("DA" ); else Put("NU"); termina daca; endMain;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura Main este subtipul CheckBoard este Integer interval 1..8; A, B, C, D: checkboard; begin Put_Line("Introduceți numerele coloanei și rândurilor pentru cele două celule:"); Put("Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: "); Obtine o); Obține(B); Put("Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: "); Obține(C); Obține(D); daca A = C sau B = D atunci Put("DA"); else Put("NU"); termina dacă; endMain;

Regele șahului se mișcă orizontal, vertical și diagonal, dar doar 1 pătrat. Având în vedere două celule diferite pe o tablă de șah, determină dacă regele poate trece de la prima celulă la a doua într-o singură mișcare. Programul primește ca intrare patru numere de la 1 la 8 fiecare, specificând numărul coloanei și numărul rândului, mai întâi pentru prima celulă, apoi pentru a doua celulă. Programul ar trebui să afișeze „DA” dacă este posibil să ajungi la a doua din prima celulă prin mișcarea regelui, sau „NU” în caz contrar.

• Introduceți numerele coloanei și rândurilor pentru cele două celule:
  Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 4 4
  Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 5 5
  DA

• „Introduceți numerele coloanei și rândurilor pentru cele două celule:”) ; A pune( "Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: ") ; Obtine o); Obține(B); A pune( "Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: ") ; Obține(C); Obține(D); dacă abs (A - C)<= 1 and then abs (B - D) <= 1 then -- comanda abs() returnează absolutul -- valoarea (modulul) numărului Put("DA"); else Put("NU"); termina daca; sfârşitul principal;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura principală este subtipul checkBoard este intervalul întreg 1..8; A, B, C, D: checkboard; begin Put_Line("Introduceți numerele coloanei și rândurilor pentru cele două celule:"); Put("Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: "); Obtine o); Obține(B); Put("Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: "); Obține(C); Obține(D); dacă abs (A - C)<= 1 and then abs(B - D) <= 1 then -- команда abs() возвращает абсолютное --значение (модуль) числа Put("ДА"); else Put("НЕТ"); end if; end main;

Episcopul de șah se mișcă în diagonală. Având în vedere două celule diferite ale unei table de șah, determinați dacă episcopul poate trece de la prima celulă la a doua într-o singură mișcare. Programul primește ca intrare patru numere de la 1 la 8 fiecare, specificând numărul coloanei și numărul rândului, mai întâi pentru prima celulă, apoi pentru a doua celulă. Programul ar trebui să scoată „DA” dacă este posibil să ajungeți la a doua din prima celulă prin mișcarea episcopului, sau „Nu” în caz contrar.

• Introduceți numerele coloanei și rândurilor pentru cele două celule:
  Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 4 4
  Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 5 5
  DA

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura principală este subtipul checkBoard este Interval interval 1 ..8; A, B, C, D: checkboard; începe Put_Line( „Introduceți numerele coloanei și rândurilor pentru cele două celule:”) ; A pune( "Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: ") ; Obtine o); Obține(B); A pune( "Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: ") ; Obține(C); Obține(D); if abs (a - c) = abs (b - d) atunci Put("YES" ) ; else Put("NU"); termina daca; sfârşitul principal;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura principală este subtipul checkBoard este intervalul întreg 1..8; A, B, C, D: checkboard; begin Put_Line("Introduceți numerele coloanei și rândurilor pentru cele două celule:"); Put("Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: "); Obtine o); Obține(B); Put("Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: "); Obține(C); Obține(D); daca abs(a - c) = abs(b - d) atunci Put("DA"); else Put("NU"); termina dacă; sfârşitul principal;

Regina șahului se mișcă în diagonală, orizontală sau verticală. Având în vedere două celule diferite ale unei table de șah, determinați dacă regina poate trece de la prima celulă la a doua într-o singură mișcare.

Format de date de intrare:
Programul primește ca intrare patru numere de la 1 la 8 fiecare, specificând numărul coloanei și numărul rândului, mai întâi pentru prima celulă, apoi pentru a doua celulă.
Format de iesire:
Programul ar trebui să scoată DA dacă este posibil să treci de la prima celulă la a doua prin mutarea reginei, sau NU în caz contrar.

Exemplul 1:
Introduceți numerele coloanei și rândurilor pentru cele două celule:
Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 1 1
Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 2 2
DA

Exemplul 2:
Introduceți numerele coloanei și rândurilor pentru cele două celule:
Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 1 1
Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 2 3
NU

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura Main este subtipul CheckBoard este Integer interval 1 ..8 ; A, B, C, D: checkboard; începe Put_Line( „Introduceți numerele coloanei și rândurilor pentru cele două celule:”) ; A pune( "Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: ") ; Obtine o); Obține(B); A pune( "Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: ") ; Obține(C); Obține(D); dacă abs (A - C) = abs (B - D) sau A = D sau B = C atunci Put("YES" ) ; else Put("NU"); termina daca; endMain;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura Main este subtipul CheckBoard este Integer interval 1..8; A, B, C, D: checkboard; begin Put_Line("Introduceți numerele coloanei și rândurilor pentru cele două celule:"); Put("Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: "); Obtine o); Obține(B); Put("Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: "); Obține(C); Obține(D); dacă abs(A - C) = abs(B - D) sau A = D sau B = C atunci Put("DA"); else Put("NU"); termina dacă; endMain;

Calul de șah se mișcă în litera „G” - două pătrate vertical în orice direcție și un pătrat orizontal sau invers. Având în vedere două celule diferite ale unei table de șah, determinați dacă cavalerul poate trece de la prima celulă la a doua într-o singură mișcare. Programul primește ca intrare patru numere de la 1 la 8 fiecare, specificând numărul coloanei și numărul rândului, mai întâi pentru prima celulă, apoi pentru a doua celulă. Programul ar trebui să scoată DA dacă cavalerul se poate muta de la prima celulă la a doua, sau NU în caz contrar.

Exemplul 1:
Introduceți numerele coloanei și rândurilor pentru cele două celule:
Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 1 1
Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 1 4
NU

Exemplul 2:
Introduceți numerele coloanei și rândurilor pentru cele două celule:
Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: 1 1
Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: 8 8
NU

• cu Ada.Text_IO ; utilizați Ada.Text_IO ; cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; procedura principală este subtipul checkBoard este Interval interval 1 ..8; A, B, C, D: întreg; începe Put_Line( „Introduceți numerele coloanei și rândurilor pentru cele două celule:”) ; A pune( "Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: ") ; Obtine o); Obține(B); A pune( "Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: ") ; Obține(C); Obține(D); dacă abs (A - C) = 2 și apoi abs (B - D) = 1 atunci Put("YES" ) ; elsif abs (A - C) = 1 și apoi abs (B - D) = 2 apoi Put("YES" ) ; else Put("NU"); termina daca; sfârşitul principal;

  cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura principală este subtipul checkBoard este intervalul întreg 1..8; A, B, C, D: întreg; begin Put_Line("Introduceți numerele coloanei și rândurilor pentru cele două celule:"); Put("Introduceți numerele coloanei și rândurilor pentru prima celulă și apăsați: "); Obtine o); Obține(B); Put("Introduceți numerele coloanei și rândurilor pentru a doua celulă și apăsați: "); Obține(C); Obține(D); daca abs(A - C) = 2 si apoi abs(B - D) = 1 atunci Put("DA"); elsif abs(A - C) = 1 și apoi abs(B - D) = 2 apoi Put("DA"); else Put("NU"); termina dacă; sfârşitul principal;

Ciocolata are forma unui dreptunghi împărțit în N×M felii. Ciocolata poate fi ruptă o dată în linie dreaptă în două părți. Determinați dacă exact feliile K pot fi rupte dintr-un baton de ciocolată în acest fel. Programul primește trei numere ca intrare: N, M, K. Programul trebuie să scoată unul dintre cele două cuvinte: „DA” sau „Nu”.

Exemplul 1:
4
2
6
DA

Exemplul 2:
Număr de felii pe orizontală: 2
Număr de felii pe verticală: 10
Câte felii să separă: 7
NU

• cu Ada.Text_IO ; utilizați Ada.Text_IO ; cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; procedura Principala este N, M, K: întreg; începe Pune( „Numărul de felii pe orizontală:”) ; Obține(N); A pune( „Numărul de felii pe verticală:”) ; Obține(M); A pune( „Câte felii să separă:”) ; Obține(K); dacă K > M * N atunci --Dacă i se cere unui baton de ciocolată să se rupă mai mult decât batonul de ciocolată în sine pune("NU"); elsif K rem N = 0 și apoi K >= N atunci - Rupe orizontal Put("DA"); elsif K rem M = 0 și apoi K >= M atunci - Rupe vertical Put("DA"); else Put("NU"); termina daca; endMain;

  cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura Principala este N, M, K: întreg; begin Put("Numărul de felii pe orizontală: "); Obține(N); Put("Numărul de felii pe verticală: "); Obține(M); Put("Câte felii de separat: "); Obține(K); dacă K > M * N atunci --Dacă i se cere batonului de ciocolată să se rupă mai mult decât batonul de ciocolată în sine Put("NU"); elsif K rem N = 0 și apoi K >= N apoi -- Rupere orizontal Put("YES"); elsif K rem M = 0 si apoi K >= M apoi -- Rupere vertical Put("DA"); else Put("NU"); termina dacă; endMain;

Yasha a înotat într-o piscină care măsoară N × M metri și a obosit. În acest moment, s-a trezit la X metri de una dintre marginile lungi (nu neapărat cea mai apropiată) și la Y metri de una dintre marginile scurte. Care este distanța minimă pe care Yasha trebuie să înoate pentru a ieși din piscină în lateral? Programul primește ca intrare numerele N, M, X, Y. Programul ar trebui să scoată numărul de metri de care Yasha are nevoie pentru a înota în lateral.

• Lățimea piscinei: 23
  Lungimea piscinei: 52
  Distanța de la Yasha la partea lungă: 8
  Distanța de la Yasha la o parte scurtă: 43
  Trebuie să înoți cel puțin pentru a ieși din piscină: 8

Este posibil ca pentru a rezolva problema să fie nevoie să schimbați 2 variabile. Acest algoritm arată cam așa:

a, b, tmp: întreg; -- Declararea variabilelor. Două principale și una auxiliară a:= 3; --Inițializarea variabilei a b:= 5; --Inițializarea variabilei b --Algoritmul propriu-zis: tmp:= a; --Acum tmp = 3 și a = 3 a:= b; --Acum a = 5 și b = 5; b:=tmp; --Acum b = 3

• cu Ada.Text_IO ; utilizați Ada.Text_IO ; cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; procedura Principala este N, M, X, Y: întreg; -- N - muchie scurtă, M - muchie lungă: -- X - Distanța față de una dintre laturile lungi -- Y - Distanța față de una dintre laturile scurte Tmp: întreg; începe Pune( „Lățimea piscinei:”) ; Obține(N); A pune( „Lungimea piscinei:”) ; Obține(M); A pune( „Distanța de la Yasha la o parte lungă:”) ; Obține(X) ; A pune( „Distanța de la Yasha la partea scurtă:”) ; Obține(Y); dacă N > M atunci --Dacă părțile laterale sunt amestecate în timpul introducerii, atunci le schimbăm locurile: Tmp:=M; --Salvați lungimea M într-o variabilă temporară M:=N; --Atribuiți variabilei M o nouă valoare N:=Tmp; --Restabiliți lungimea M în variabila N termina daca; Tmp:=X; --Să presupunem că distanța minimă este X dacă abs (N-X)< X then --Dacă distanța până la a doua margine lungă este mai mică decât X, atunci Tmp:= N - X; --distanta minima egală cu distanța până la a doua latură lungă termina daca; daca eu< Tmp then --Dacă distanța până la marginea scurtă este mai mică decât cea găsită mai sus -- minim, atunci Tmp:=Y; --Distanța minimă este Y termina daca; dacă abs (M - Y)< Tmp then --Dacă înoți mai aproape de a doua parte scurtă, atunci Tmp:= abs (M - Y); --distanța minimă este egală cu distanța până la a doua margine scurtă termina daca; A pune( „Trebuie să înoți măcar pentru a ieși din piscină:”) ; Put(Item => Tmp, Width => 1 ) ; endMain;

  cu Ada.Text_IO; utilizați Ada.Text_IO; cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; procedura Principala este N, M, X, Y: întreg; -- N - margine scurtă, M - margine lungă: -- X - Distanța până la una dintre marginile lungi -- Y - Distanța până la una dintre marginile scurte Tmp: Întreger; start Put("Lățimea piscinei: "); Obține(N); Put("Lungimea piscinei: "); Obține(M); Put("Distanța de la Yasha la partea lungă: "); Obține(X); Put("Distanța de la Yasha la marginea scurtă: "); Obține(Y); dacă N > M atunci --Dacă muchiile sunt amestecate în timpul introducerii, atunci le schimbăm locurile: Tmp:= M; --Salvați lungimea M într-o variabilă temporară M:= N; --Atribuiți o nouă valoare variabilei M N:= Tmp; --Restabiliți lungimea M în variabila N sfârșitul dacă; Tmp:=X; --Să presupunem că distanța minimă este X dacă abs(N - X)< X then --Если до второго длинного бортика расстояние меньше X, то Tmp:= N - X; --минимальное расстояние равно расстоянию до второго длинного бортика end if; if Y < Tmp then --Если до короткого бортика расстояние меньше найденного выше --минимального, то Tmp:= Y; --Минимальное расстояние равно Y end if; if abs(M - Y) < Tmp then --Если до второго короткого бортика плыть ближе, то Tmp:= abs(M - Y); --минимальное расстояние равно расстоянию до второго короткого бортика end if; Put("Нужно проплыть минимум, чтобы выбраться из бассейна: "); Put(Item =>Tmp, Latime => 1); endMain;

Ceasul electronic arată ora în format h:mm:ss (de la 0:00:00 la 23:59:59), adică mai întâi se înregistrează numărul de ore, apoi este obligatoriu numărul de minute din două cifre , atunci numărul de secunde din două cifre este obligatoriu. Numărul de minute și secunde, dacă este necesar, este completat număr din două cifre zerouri. Au trecut N secunde de la începutul zilei. Ieșiți ceea ce arată ceasul. Intrarea este un număr natural N, care nu depășește 10 7 (10000000). Trimiteți răspunsul la problemă.

Exemplul de intrare 1:
3602
Exemplul de ieșire 1:
1:00:02

Exemplul de intrare 2:
129700
Exemplul de ieșire 2:
12:01:40

• cu Ada.Long_Integer_Text_IO ; utilizați Ada.Long_Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura Main este subtipul Sub_LI este Long_Integer interval 1 ..10000000 ; N: Sub_LI; h, m, s: Long_Integer; începe Get(N); h:= N/3600; - Primim ceasul. Restul diviziei este aruncat N:= N-h * 3600; --Obțineți secundele rămase (minus ore) dacă h > 24 atunci --Deoarece ceasul nu poate afișa > 24, punem totul într-o formă care poate fi citită h:= h rem 24 ; - Restul împărțirii la 24 va da numărul exact de ore elsif h = 24 atunci h:= 0 ; termina daca; m:= N/60; --Ia minute s:= N rem 60; --Obțineți secunde Put(Articol => h, Lățime => 1 ) ; A pune(":"); --Ore de ieșire și „:” dacă m< 10 then --Dacă numărul de minute este mai mic de 10, scoateți un 0 inițial Pune(Articol => 0 , Lățime => 1 ) ; termina daca; Pune(Articol => m, Lățime => 1 ) ; A pune(":"); --Minute de ieșire și „:” dacă s< 10 then --Dacă numărul de secunde este mai mic de 10, scoateți un 0 inițial Pune(Articol => 0 , Lățime => 1 ) ; termina daca; Put(Articol => s, Lățime => 1 ) ; --Ieșire secunde final Main;

  cu Ada.Long_Integer_Text_IO; utilizați Ada.Long_Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura Main este subtipul Sub_LI este Long_Integer interval 1..10000000; N: Sub_LI; h, m, s: Long_Integer; începe Get(N); h:= N/3600; - Primim ceasul. Restul diviziunii este aruncat N:= N - h * 3600; --Obțineți secundele rămase (minus ore) dacă h > 24 atunci --Din moment ce ceasurile nu pot citi > 24, puneți totul în formă care poate fi citită de om h:= h rem 24; --Rămânul împărțirii la 24 va da numărul exact de ore elsif h = 24, atunci h:= 0; termina dacă; m:= N/60; --Get minute s:= N rem 60; --Obțineți secunde Put(Articol => h, Lățime => 1); A pune(":"); --Ore de ieșire și „:” dacă m< 10 then --Если количество минут меньше 10, выводим ведущий 0 Put(Item =>0, Latime => 1); termina dacă; Put(Articol => m, Lățime => 1); A pune(":"); --Minute de ieșire și „:” dacă s< 10 then --Если количество секунд меньше 10, выводим ведущий 0 Put(Item =>0, Latime => 1); termina dacă; Put(Articol => s, Lățime => 1); --Ieșire secunde final Main;

• Sunt date trei numere. Aranjați-le în ordine crescătoare.
• Exemplu de intrare:
  1 2 1
  Eșantion de ieșire:
  1 1 2

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura Principala este A, B, C: Integer; min, mijloc, max: întreg; începe Get(A) ; Obține(B); Obține(C); --Cauta valoarea minima min:=A; daca B< min then min:= B; end if ; if C < min then min:= C; end if ; --Cauta valoare maximă max:=A; dacă B > max atunci max:= B; termina daca; dacă C > max atunci max:= C; termina daca; --Se caută valoarea medie mijloc:=A; dacă B > min și B< max then mid:= B; end if ; if C >min și C< max then mid:= C; end if ; Put(Item =>min, Latime => 1 ) ; a pune(" "); Put(Articol => mijloc, lățime => 1 ) ; a pune(" "); Put(Articol => max, Lățime => 1 ) ; endMain;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura Principala este A, B, C: Integer; min, mijloc, max: întreg; începe Get(A); Obține(B); Obține(C); --Se cauta valoarea minima min:= A; daca B< min then min:= B; end if; if C < min then min:= C; end if; --Ищем максимальное значение max:= A; if B >max apoi max:= B; termina dacă; dacă C > max atunci max:= C; termina dacă; --Se caută valoarea medie mid:= A; dacă B > min și B< max then mid:= B; end if; if C >min și C< max then mid:= C; end if; Put(Item =>min, Latime => 1); a pune(" "); Put(Articol => mijloc, lățime => 1); a pune(" "); Put(Articol => max, Lățime => 1); endMain;

Există două casete, prima este A1×B1×C1, a doua este A2×B2×C2. Determinați dacă una dintre aceste cutii poate fi plasată în interiorul celeilalte, cu condiția ca cutiile să poată fi rotite doar cu 90 de grade în jurul marginilor. Programul primește numerele A1, B1, C1, A2, B2, C2 ca intrare. Programul ar trebui să scoată una dintre următoarele linii:
- „Cutiile sunt egale” dacă casetele sunt aceleași,
- „Prima cutie mai puțin de o secundă„dacă prima casetă poate fi plasată în a doua,
- „Prima cutie mai mult de o secundă" dacă a doua cutie poate fi plasată în interiorul primei.

Exemplul 1:
Dimensiunile primei cutie: 1 2 3
Dimensiuni a doua cutie: 3 2 1
Cutiile sunt egale

Exemplul 2:
Dimensiunile primei cutie: 2 2 3
Dimensiuni a doua cutie: 3 2 1
Prima cutie este mai mare decât a doua

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura principală este A1, B1, C1, A2, B2, C2: întreg; min, max, mijloc, tmp: întreg; începe Get(A1); Obține(B1); Get(C1) ; Obține(A2); Obține(B2); Get(C2) ; --Aduceți fețele în linie cu lungimile A1 => A2, B1 => B2, C1 => C2: --A1 și A2 sunt cele mai lungi, C1 și C2 sunt cele mai scurte -- „Întoarceți” prima casetă: min:=A1; mijloc:=B1; max:=C1; dacă B1< min then mid:= min; min:= B1; end if ; if C1 < min then max:= min; min:= C1; end if ; if mid >max apoi tmp:= mijloc; mijloc:=max; max:=tmp; termina daca; A1:=min; B1:=mid; C1:=max; -- „Rotiți” a doua casetă: min:=A2; mijloc:=B2; max:=C2; dacă B2< min then mid:= min; min:= B2; end if ; if C2 < min then max:= min; min:= C2; end if ; if mid >max apoi tmp:= mid; mijloc:=max; max:=tmp; termina daca; A2:=min; B2:=mid; C2:=max; --Verificarea corespondenței casetelor și afișarea rezultatului: dacă A1 = A2 și apoi B1 = B2 și apoi C1 = C2 atunci Put_Line("Cutiile sunt egale" ) ; elsif A1 >= A2 și apoi B1 >= B2 și apoi C1 >= C2 apoi Put_Line( „Prima cutie este mai mare decât a doua”) ; Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line(„Prima cutie este mai mică decât a doua”) ; termina daca; sfârşitul principal;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura principală este A1, B1, C1, A2, B2, C2: întreg; min, max, mijloc, tmp: întreg; începe Get(A1); Obține(B1); Get(C1); Obține(A2); Obține(B2); Get(C2); --Aduceți marginile în linie cu lungimile A1 => A2, B1 => B2, C1 => C2: --A1 și A2 - cea mai lungă, C1 și C2 - cea mai scurtă -- „Răsuciți” prima casetă: min := A1 ; mijloc:=B1; max:=C1; dacă B1< min then mid:= min; min:= B1; end if; if C1 < min then max:= min; min:= C1; end if; if mid >max apoi tmp:= mijloc; mijloc:=max; max:=tmp; termina dacă; A1:=min; B1:=mid; C1:=max; -- „Rotire” a doua casetă: min:= A2; mijloc:=B2; max:=C2; dacă B2< min then mid:= min; min:= B2; end if; if C2 < min then max:= min; min:= C2; end if; if mid >max apoi tmp:= mid; mijloc:=max; max:=tmp; termina dacă; A2:=min; B2:=mid; C2:=max; --Verificați dacă casetele se potrivesc și scoateți rezultatul: dacă A1 = A2 și apoi B1 = B2 și apoi C1 = C2 atunci Put_Line("Boxurile sunt egale"); elsif A1 >= A2 și apoi B1 >= B2 și apoi C1 >= C2 apoi Put_Line ("Prima casetă este mai mare decât a doua"); Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Первая коробка меньше второй"); end if; end main;

Scrieți un program care calculează costul unei convorbiri telefonice la distanță lungă (prețul unui minut este determinat de distanța până la orașul în care se află abonatul). Datele inițiale pentru program sunt prefixul și durata apelului. Mai jos sunt codurile unor orașe și vizualizarea de ecran recomandată în timp ce programul rulează:

• Calculați costul unei convorbiri telefonice.
  Introduceți datele inițiale:
  Cod oraș -> 423
  Durata (minute întregi) -> 3
  Orașul Vladivostok
  Preț pe minut: 4 ruble.
  Costul apelului: 12 ruble.

• cu Ada.Integer_Text_IO ; utilizați Ada.Integer_Text_IO ; cu Ada.Text_IO ; utilizați Ada.Text_IO ; procedura Principal este Cod, Len: Integer; ÎNCEPE Put_Line („Calculul costului unei convorbiri telefonice”.) ; Put_Line („Introduceți datele inițiale:”) ; A pune ("Codul orașului -> ") ; obține ( Cod ) ; A pune ("Durata (minute întregi) -> ") ; obține ( len ) ; caz Cod este când 423 => Put_Line („Orașul Vladivostok”) ; Put_Line („Prețul unui minut: 4 ruble”.) ; A pune („Cost apel:”) ; A pune ( Articol => len * 4 , Latime => 1 ) ; Put_Line ("frecați".) ; când 095 => Put_Line („Orașul Moscovei”) ; Put_Line („Prețul unui minut: 2 ruble”.) ; A pune („Cost apel:”) ; A pune ( Articol => len * 2 , Latime => 1 ) ; Put_Line ("frecați".) ; când 815 => Put_Line („Oraș: Murmansk”) ; Put_Line („Prețul unui minut: 3 ruble”.) ; A pune („Cost apel:”) ; A pune ( Articol => len * 3 , Latime => 1 ) ; Put_Line ("frecați".) ; când 846 => Put_Line („Orașul Samara”) ; Put_Line ("Prețul unui minut: 1 rub.") ; A pune („Cost apel:”) ; A pune ( Item => len, Width => 1 ) ; Put_Line ("frecați".) ; când alții=> Pune („Nu există niciun oraș cu acest cod în baza de date! Încercați din nou.”) ; Sfârşit caz; Sfârşit principal;

  cu Ada.Integer_Text_IO; utilizați Ada.Integer_Text_IO; cu Ada.Text_IO; utilizați Ada.Text_IO; procedura Main este Cod, Len: Integer; begin Put_Line("Calculul costului unui apel telefonic."); Put_Line("Introduceți datele inițiale:"); Put("Codul orașului -> "); obțineți codul); Put("Durata (minute întregi) -> "); obține(len); case Codul este atunci când 423 => Put_Line("Oraș: Vladivostok"); Put_Line(„Prețul pe minut: 4 ruble.”); Put("Costul apelului: "); Put(Item => len * 4, Width => 1); Put_Line(" freca."); când 095 => Put_Line("Oraș: Moscova"); Put_Line(„Prețul pe minut: 2 ruble.”); Put("Costul apelului: "); Put(Item => len * 2, Width => 1); Put_Line(" freca."); când 815 => Put_Line("Oraș: Murmansk"); Put_Line(„Prețul pe minut: 3 ruble.”); Put("Costul apelului: "); Put(Item => len * 3, Width => 1); Put_Line(" freca."); când 846 => Put_Line("Oraș: Samara"); Put_Line("Prețul pe minut: 1 rub."); Put("Costul apelului: "); Put(Item => len, Width => 1); Put_Line(" freca."); when others => Put("Nu există niciun oraș cu acest cod în baza de date! Încercați din nou."); caz final; endMain;

Secțiunea descrie pe scurt operatorii dacăși caz, funcție abs()și un algoritm pentru schimbarea variabilelor.

Definiție.

Acesta este un hexagon ale cărui baze sunt două pătrat egal, iar fețele laterale sunt dreptunghiuri egale

Coastă laterală- aceasta este latura comuna două feţe laterale adiacente

Înălțimea prismei- aceasta este o tăietură perpendicular pe baze prisme

Diagonala prismei- un segment care leagă două vârfuri ale bazelor care nu aparțin aceleiași fețe

Planul diagonal este planul care trece prin diagonala prismei și a acesteia coaste laterale

Secțiune diagonală - limitele de intersectie a prismei si a planului diagonal. Secțiunea diagonală a unei prisme patruunghiulare obișnuite este un dreptunghi

Secțiune perpendiculară (secțiune ortogonală)- aceasta este intersecția unei prisme și a unui plan desenat perpendicular pe marginile sale laterale

Elemente ale unei prisme patruunghiulare regulate

Figura prezintă două prisme patrulatere regulate, care sunt marcate cu literele corespunzătoare:

• Bazele ABCD și A 1 B 1 C 1 D 1 sunt egale și paralele între ele
• Fețe laterale AA 1 D 1 D, AA 1 B 1 B, BB 1 C 1 C și CC 1 D 1 D, fiecare fiind dreptunghi
• Suprafata laterala- suma ariilor tuturor fețelor laterale ale prismei
• Suprafața totală - suma suprafețelor tuturor bazelor și fețelor laterale (suma suprafeței și bazelor laterale)
• Nervurile laterale AA 1 , BB 1 , CC 1 și DD 1 .
• Diagonala B 1 D
• Diagonala bazei BD
• Secțiunea diagonală BB 1 D 1 D
• Secţiune perpendiculară A 2 B 2 C 2 D 2 .

Proprietățile unei prisme patruunghiulare regulate

• Bazele sunt două pătrate egale
• Bazele sunt paralele între ele
• Laturile sunt dreptunghiuri.
• Fețele laterale sunt egale între ele
• Fețele laterale sunt perpendiculare pe baze
• Coastele laterale sunt paralele între ele și egale
• Secțiune perpendiculară perpendiculară pe toate nervurile laterale și paralelă cu bazele
• colțuri sectiune perpendiculara- Drept
• Secțiunea diagonală a unei prisme patruunghiulare obișnuite este un dreptunghi
• Perpendiculară (secțiune ortogonală) paralelă cu bazele

Formule pentru o prismă patruunghiulară obișnuită

Instructiuni pentru rezolvarea problemelor

La rezolvarea problemelor pe tema " corect prismă pătrangulară " implică faptul că:

Prisma corectă- o prismă la baza căreia se află poligon regulat, iar marginile laterale sunt perpendiculare pe planurile de bază. Adică o prismă patruunghiulară obișnuită conține la bază pătrat. (vezi mai sus proprietățile unei prisme patruunghiulare obișnuite) Notă. Aceasta face parte din lecția cu sarcini de geometrie (secțiunea geometrie solidă - prismă). Iată sarcinile care provoacă dificultăți în rezolvare. Dacă trebuie să rezolvați o problemă de geometrie, care nu este aici - scrieți despre ea pe forum. Pentru a indica actiunea de extragere rădăcină pătrată simbolul este folosit în rezolvarea problemelor√ .

O sarcină.

Într-o prismă pătrangulară obișnuită, aria bazei este de 144 cm 2 și înălțimea este de 14 cm. Aflați diagonala prismei și aria suprafata intreaga.

Soluţie.
Un patrulater regulat este un pătrat.
În consecință, latura bazei va fi egală cu

√144 = 12 cm.
De unde vine diagonala bazei? prismă dreptunghiulară va fi egal cu
√(12 2 + 12 2 ) = √288 = 12√2

Diagonală prismă dreaptă forme cu diagonala bazei și înălțimea prismei triunghi dreptunghic. În consecință, conform teoremei lui Pitagora, diagonala unei prisme pătraunghiulare regulate va fi egală cu:
√((12√2) 2 + 14 2 ) = 22 cm

Răspuns: 22 cm

O sarcină

Aflați aria suprafeței totale a unei prisme patrulatere obișnuite dacă diagonala acesteia este de 5 cm și diagonala feței laterale este de 4 cm.

Soluţie.
Deoarece baza unei prisme patruunghiulare obișnuite este un pătrat, atunci latura bazei (notată cu a) este găsită de teorema lui Pitagora:

A 2 + a 2 = 5 2
2a 2 = 25
a = √12,5

Înălțimea feței laterale (notată cu h) va fi atunci egală cu:

H 2 + 12,5 \u003d 4 2
h 2 + 12,5 = 16
h 2 \u003d 3,5
h = √3,5

Suprafața totală va fi egală cu suma suprafeței laterale și de două ori suprafața de bază

S = 2a 2 + 4ah
S = 25 + 4√12,5 * √3,5
S = 25 + 4√43,75
S = 25 + 4√(175/4)
S = 25 + 4√(7*25/4)
S \u003d 25 + 10√7 ≈ 51,46 cm 2.

Răspuns: 25 + 10√7 ≈ 51,46 cm 2.

Mașini cu o transmisie manuală, care este abreviat ca transmisie manuală, până de curând se ridica la majoritate absolută printre alte vehicule cu diferite .

Mai mult, o cutie mecanică (manuală) rămâne un dispozitiv destul de comun pentru schimbarea și transmiterea cuplului motorului în prezent. În continuare, vom vorbi despre modul în care este aranjată și funcționează „mecanica”, cum arată schema cutiei de viteze de acest tip, precum și ce avantaje și dezavantaje are această soluție.

Citiți în acest articol

Diagrama transmisiei manuale și caracteristici

Pentru început, acest tip de cutie de viteze se numește mecanică datorită faptului că o astfel de unitate implică schimbarea manuală a vitezelor. Cu alte cuvinte, la mașinile cu transmisie manuală, șoferul însuși schimbă treptele.

Mergem mai departe. Cutia „mecanicilor” este treptată, adică cuplul se modifică în trepte. Mulți șoferi știu că cutia de viteze are de fapt roți dințate și arbori, dar nu toată lumea înțelege cum funcționează unitatea.

Deci, o treaptă (este și o transmisie) este o pereche de trepte de viteză (conducere și transmisie) care interacționează între ele. Fiecare astfel de treaptă oferă rotație cu una sau alta viteză unghiulară, adică are propriul său raport de transmisie.

Sub raportul de transmisie trebuie înțeles ca raportul dintre numărul de dinți ai angrenajului condus și numărul de dinți ai angrenajului de antrenare. În acest caz, diferitele etape ale cutiei primesc rapoarte diferite de transmisie. Cea mai joasă treaptă de viteză (low gear) are cel mai mare raport de viteză și cel mai mult pas înalt(upshift) are cel mai mic raport de transmisie.

Devine clar că numărul de trepte este egal cu numărul de trepte de pe o anumită cutie (cutie de viteze cu patru trepte, cu cinci trepte etc.) anterior cu 4 trepte cutii mecanice echipamentul a dispărut treptat în fundal.

Dispozitiv cu transmisie manuală

Deci, deși pot exista multe modele ale unei astfel de cutii cu anumite caracteristici, totuși, stadiul inițial se pot distinge două tipuri principale:

• cutii de viteze cu trei arbori;
• cutii cu doi arbori;

O cutie de viteze manuală cu trei arbori este de obicei instalată pe mașinile cu tracțiune spate, în timp ce o cutie de viteze cu doi arbori este plasată pe autoturismele cu tracțiune față. În același timp, dispozitivul cutiilor de viteze mecanice atât de primul cât și de cel de-al doilea tip poate diferi semnificativ.

Să începem cu o cutie mecanică cu trei arbori. Această cutie conține:

• arborele de antrenare, care se mai numește și primar;
• cutie de viteze cu arbore intermediar;
• arbore antrenat (secundar);

Pe arbori sunt instalate angrenaje cu sincronizatoare. Mecanismul de schimbare a vitezelor este de asemenea inclus în cutia de viteze. Specificat elementele constitutive situat în carcasa cutiei de viteze, care este numită și carcasa cutiei de viteze.

Sarcina arborelui de antrenare este de a crea o legătură cu ambreiajul. Arborele de antrenare are fante pentru discul de ambreiaj. În ceea ce privește cuplul, cuplul specificat de la arborele de intrare este transmis prin angrenajul, care este în angrenare rigidă cu acesta.

Afectând funcționarea arborelui intermediar, acest arbore este situat paralel cu arborele de intrare al cutiei de viteze, pe el este instalat un grup de viteze, care este în cuplare rigidă. La rândul său, arborele antrenat este montat pe aceeași axă ca și arborele antrenat.

O astfel de instalare este implementată folosind un lagăr de capăt pe arborele de antrenare. Acest rulment include arborele antrenat. Grupul de angrenaje (blocul angrenajului) de pe arborele antrenat nu are o angrenare rigidă cu arborele însuși și, prin urmare, se rotește liber pe acesta. În acest caz, grupul de angrenaje ale arborelui intermediar, arborele condus și angrenajul arborelui de antrenare sunt în angrenare constantă.

Sincronizatoarele (cuplajele de sincronizare) sunt instalate între angrenajele arborelui antrenat. Sarcina lor este de a alinia vitezele unghiulare ale angrenajelor arborelui antrenat cu viteza unghiulară a arborelui însuși prin forța de frecare.

Sincronizatoarele sunt în cuplare rigidă cu arborele antrenat și, de asemenea, au capacitatea de a se deplasa de-a lungul arborelui în direcția longitudinală datorită conexiunii canelate. Cutiile de viteze moderne au ambreiaje sincronizatoare în toate treptele.

Dacă luăm în considerare mecanismul de schimbare a vitezelor de pe cutiile de viteze cu trei arbori, adesea acest mecanism este instalat pe corpul unității. Designul include o pârghie de control, glisoare și furci.

Corpul cutiei (carterul) este fabricat din aliaje de aluminiu sau magneziu, este necesar pentru instalarea arborilor cu angrenaje și mecanisme, precum și o serie de alte piese. În carcasa cutiei de viteze există și ulei de viteze (ulei de cutie de viteze).

• Pentru a înțelege cum funcționează o cutie de viteze mecanică (manuală) de tip cu trei arbori, haideți in termeni generali Să aruncăm o privire la cum funcționează. Când maneta de viteză este în poziţia neutră, nu există nicio transmisie a cuplului de la motor la roţile motoare ale vehiculului.

După ce șoferul mută maneta, furca va mișca ambreiajul sincronizator al uneia sau alteia trepte. Sincronizatorul se va alinia apoi viteze unghiulare angrenajul dorit și arborele antrenat. Apoi, inelul dințat al ambreiajului se va cupla cu un inel dințat similar, ceea ce va asigura că angrenajul este blocat pe arborele antrenat.

Adăugăm, de asemenea, că marșarierul mașinii este asigurat de marșarierul cutiei de viteze. În acest caz, o treaptă de viteză de mers în gol, montată pe o axă separată, permite inversarea sensului de rotație.

Cutie de viteze manuală cu doi arbori: dispozitiv și principiu de funcționare

După ce ne-am ocupat de ce constă o cutie de viteze cu trei arbori, să trecem la cutiile de viteze cu doi arbori. Acest tip Cutia de viteze are doi arbori în dispozitiv: primar și secundar. Arborele de intrare este cel antrenant, secundarul este cel antrenat. Angrenajele și sincronizatoarele sunt fixate pe arbori. De asemenea, în carterul cutiei se află treapta principală și diferențial.

Arborele de antrenare este responsabil pentru conectarea cu ambreiajul și există, de asemenea, un bloc de viteze pe arbore în cuplare rigidă cu arborele. Arborele condus este situat paralel cu arborele de antrenare, în timp ce angrenajele arborelui condus sunt în angrenare constantă cu angrenajele arborelui de antrenare și, de asemenea, se rotesc liber pe arborele însuși.

De asemenea, angrenajul de antrenare al angrenajului principal este fixat rigid pe arborele condus, iar cuplajele sincronizatoare sunt situate între angrenajele arborelui antrenat. Adăugăm, pentru a reduce dimensiunea cutiei de viteze, precum și pentru a crește numărul de viteze, în cutiile de viteze moderne se pot instala adesea 2 sau chiar 3 arbori în locul unui singur arbore antrenat.

Pe fiecare astfel de arbore, angrenajul angrenajului principal este fixat rigid, în timp ce un astfel de angrenaj are o angrenare rigidă cu angrenajul condus. Se pare că designul implementează de fapt 3 trepte principale.

Angrenajul principal în sine, precum și diferențialul din dispozitivul cutiei de viteze transmit cuplul de la arborele secundar către roțile motoare. În acest caz, diferenţialul poate asigura, de asemenea, o astfel de rotaţie a roţilor atunci când roţile motoare se rotesc la viteze unghiulare diferite.

În ceea ce privește mecanismul de schimbare a vitezelor, la cutiile de viteze cu doi arbori acesta este scos separat, adică în afara caroseriei. Cutia este conectată la mecanismul de comutare prin cabluri sau tije speciale. Cea mai comună conexiune este prin cabluri.

Mecanismul de schimbare a cutiei cu 2 arbori în sine are o pârghie, care este conectată prin cabluri la maneta selectorului și la maneta schimbătorului de viteze. Aceste pârghii sunt conectate la tija centrală de schimbare, care are și furci.

• Dacă vorbim despre principiul de funcționare al unei cutii de viteze manuale cu doi arbori, este similar cu principiul unei cutii de viteze cu trei arbori. Diferențele sunt în modul în care funcționează mecanismul de schimbare a vitezelor. Pe scurt, pârghia poate efectua atât mișcări longitudinale, cât și transversale în raport cu axa mașinii. Pe parcursul mișcare transversală selecția vitezei are loc, deoarece forța este aplicată cablului selectorului de viteze, care acționează asupra pârghiei selectorului de viteze.

În plus, pârghia se mișcă longitudinal, iar forța merge către cablul schimbătorului de viteze. Pârghia corespunzătoare mișcă orizontal tija cu furcile, furca de pe tijă deplasează sincronizatorul, ceea ce duce la blocarea angrenajului arborelui antrenat.

În sfârșit, remarcăm că și cutii mecanice tipuri diferite au dispozitive suplimentare de blocare care împiedică includerea a două trepte în același timp sau o decuplare neașteptată a treptei.

Citeste si

Apăsarea ambreiajului înainte de a porni motorul: când să apăsați ambreiajul și în ce cazuri nu este recomandat să faceți acest lucru. Sfaturi utile si recomandari.

Cauze ale schimbării dificile a treptelor la un motor în funcțiune. Ulei de transmisie si nivel in cutia de viteze, uzura sincronizatoarelor si angrenajelor cutiei, ambreiaj.