Käsivaihteisto: laite, tyypit, ominaisuudet. Luonnon fysikaalisiin ilmiöihin liittyviä arvoituksia

Löysin DataGeneticsin verkkosivuilta. Lähetä kaikki tämän artikkelin virheet yksityisviesteinä.

Tässä ongelmassa vankilassa on 100 vankia, jokainen numeroitu 1-100. Vanginvartija päättää antaa vangeille mahdollisuuden vapautua, hän kertoo heille kokeen ehdot, ja jos kaikki vangit läpäisevät kokeen, sitten ne vapautetaan. Jos ainakin yksi heistä läpäisee kokeen, kaikki vangit kuolevat.

Tehtävä

Vanginvartija menee salainen huone ja valmistaa 100 kannellista laatikkoa. Jokaiseen laatikkoon hän merkitsee numerot 1 - 100. Sitten hän tuo 100 paperitaulua vankien lukumäärän mukaan ja numeroi nämä tabletit 1 - 100. Sen jälkeen hän sekoittaa 100 tablettia ja asettaa yhden tabletin jokaiseen laatikkoon. kannen sulkeminen. Vangit eivät näe, kuinka vanginvartija suorittaa kaikki nämä toimet.

Kilpailu alkaa, vanginvartija vie jokaisen vangin yksitellen huoneeseen, jossa on laatikot ja kertoo vangeille, että heidän on löydettävä laatikko, jossa on lautanen vangin numerolla. Vangit yrittävät löytää levyn numeroineen avaamalla laatikoita. Jokainen saa avata enintään 50 laatikkoa; jos jokainen vanki löytää numeronsa, vangit vapautetaan, jos vähintään yksi heistä ei löydä numeroaan 50 yrityksellä, kaikki vangit kuolevat.

Jotta vangit voidaan vapauttaa, KAIKKIEN vankien on läpäistävä koe.

Mikä on siis mahdollisuus, että vangit saavat armahduksen?

  • Kun vanki on avannut laatikon ja tarkastanut levyn, se asetetaan takaisin laatikkoon ja kansi suljetaan uudelleen;
  • Levyjen paikkoja ei voi muuttaa;
  • Vangit eivät voi jättää toisilleen johtolankoja tai olla vuorovaikutuksessa keskenään millään tavalla oikeudenkäynnin alettua;
  • Vangit saavat keskustella strategiasta ennen oikeudenkäynnin alkamista.

Mikä on paras strategia vangeille?

Lisäkysymys:

Jos vankien ystävä (ei osallistuja kokeeseen) pääsee salaiseen huoneeseen ennen kokeen alkua, tutki kaikki tabletit kaikissa laatikoissa ja (valinnainen, mutta ei pakollinen) vaihda kaksi tablettia kahdesta laatikosta (tässä tapauksessa toverilla ei ole mahdollisuutta ilmoittaa vangeille tekojensa tuloksista), minkä strategian hänen tulisi sitten käyttää lisätäkseen vankien mahdollisuuksia paeta?

Ratkaisu epätodennäköinen?

Ensi silmäyksellä tämä tehtävä näyttää melkein toivottomalta. Näyttää siltä, ​​että jokaisen vangin mahdollisuus löytää tablettinsa on mikroskooppisen pieni. Lisäksi vangit eivät voi vaihtaa tietoja keskenään oikeudenkäynnin aikana.

Yhden vangin todennäköisyys on 50:50. Laatikoita on yhteensä 100 ja hän voi avata jopa 50 laatikkoa etsiessään merkkiään. Jos hän avaa laatikot satunnaisesti ja avaa puolet kaikista laatikoista, hän löytää tablettinsa laatikoiden avoimesta puoliskosta tai hänen tablettinsa jää suljettuihin 50 laatikkoon. Hänen onnistumismahdollisuutensa on ½.

Otetaan kaksi vankia. Jos molemmat valitsevat laatikot satunnaisesti, todennäköisyys kummallekin on ½ ja kahdelle ½x½=¼.
(kahdelle vangille menestys on yksi tapaus neljästä).

Kolmen vangin kertoimet ovat ½ × ½ × ½ = ⅛.

100 vangin kertoimet ovat: ½ × ½ × … ½ × ½ (kerrotaan 100 kertaa).


Tämä vastaa

Pr ≈ 0,000000000000000000000000000008

Joten se on hyvin pieni mahdollisuus. Tässä skenaariossa kaikki vangit ovat todennäköisesti kuolleita.

Uskomaton vastaus

Jos jokainen vanki avaa laatikot satunnaisesti, he eivät todennäköisesti läpäise koetta. On olemassa strategia, jossa vangit voivat odottaa menestyvänsä yli 30 % ajasta. Tämä on hämmästyttävän uskomaton tulos (jos et ole kuullut tästä matemaattinen ongelma aiemmin).

Yli 30 % kaikille 100 vangille! Kyllä, tämä on jopa enemmän kuin kahden vangin mahdollisuus, jos he avaavat laatikot satunnaisesti. Mutta miten tämä on mahdollista?

On selvää, että yksi kutakin vankia kohden, todennäköisyys ei voi olla suurempi kuin 50% (eihän vankien välistä kommunikointia ole mahdollista). Mutta älä unohda, että tiedot tallennetaan laatikoiden sisällä olevien levyjen sijaintiin. Kukaan ei sekoita tabletteja yksittäisten vankien huonekäyntien välillä, joten voimme käyttää näitä tietoja.

Ratkaisu

Ensin kerron ratkaisun, sitten selitän, miksi se toimii.

Strategia on erittäin helppo. Ensimmäinen vangeista avaa laatikon, jossa on numero, joka on kirjoitettu hänen vaatteisiinsa. Esimerkiksi vanki numero 78 avaa laatikon numerolla 78. Jos hän löytää numeronsa laatikon sisällä olevasta kilvestä, se on hienoa! Jos ei, hän katsoo "omassa"-laatikossaan olevan levyn numeroa ja avaa sitten seuraavan laatikon, jossa on tämä numero. Avattuaan toisen laatikon hän katsoo tämän laatikon sisällä olevan tabletin numeroa ja avaa kolmannen tällä numerolla varustetun laatikon. Sitten yksinkertaisesti siirrämme tämän strategian jäljellä oleviin laatikoihin. Selvyyden vuoksi katso kuvaa:


Lopulta vanki joko löytää numeronsa tai saavuttaa 50 laatikon rajan. Ensi silmäyksellä tämä näyttää turhalta verrattuna laatikon valitsemiseen satunnaisesti (ja yhdelle yksittäiselle vangille se tekee), mutta koska kaikki 100 vankia käyttävät samaa laatikkosarjaa, se on järkevää.

Tämän kauneus matemaattinen ongelma- ei vain tietää tulos, vaan myös ymmärtää miksi tämä strategia toimii.

Joten miksi strategia toimii?

Jokainen laatikko sisältää yhden lautasen - ja tämä levy on ainutlaatuinen. Tämä tarkoittaa, että levy on laatikossa, jossa on sama numero, tai se osoittaa eri laatikkoon. Koska kaikki lautaset ovat ainutlaatuisia, kutakin laatikkoa kohti on vain yksi levy, joka osoittaa siihen (ja vain yksi tapa päästä kyseiseen laatikkoon).


Jos ajattelet sitä, laatikot muodostavat suljetun pyöreän ketjun. Yksi laatikko voi olla osa vain yhtä ketjua, koska laatikon sisällä on vain yksi osoitin seuraavaan ja vastaavasti edellisessä laatikossa on vain yksi osoitin tähän laatikkoon (ohjelmoijat voivat nähdä analogian linkitettyjen luetteloiden kanssa).

Jos laatikko ei osoita itseään (laatikon numero on sama kuin siinä oleva kilpi), se on ketjussa. Jotkut ketjut voivat koostua kahdesta laatikosta, jotkut ovat pidempiä.


Koska kaikki vangit alkavat laatikosta, jossa on sama numero vaatteissaan, he asetetaan määritelmän mukaan ketjuun, joka sisältää heidän nimikilvensä (tähän laatikkoon viittaa vain yksi nimikilpi).

Tutkimalla tämän ketjun laatikoita ympyrässä, he varmasti löytävät lopulta merkkinsä.

Ainoa kysymys on, löytävätkö he tablettinsa 50 liikkeellä.


Ketjun pituus

Jotta kaikki vangit läpäisivät kokeen, ketjun enimmäispituuden on oltava alle 50 laatikkoa. Jos ketju on pidempi kuin 50 laatikkoa, vangit, joilla on numerot näistä ketjuista, epäonnistuvat kokeessa - ja kaikki vangit ovat kuolleita.

Jos pisimmän ketjun enimmäispituus on alle 50 laatikkoa, kaikki vangit läpäisevät kokeen!

Mieti tätä hetki. Osoittautuu, että missä tahansa levyasetelmassa voi olla vain yksi yli 50 laatikkoa pidempi ketju (meillä on vain 100 laatikkoa, joten jos yksi ketju on pidempi kuin 50, niin loput ovat yhteensä lyhyempiä kuin 50).


Pitkän ketjun käsikertoimet

Kun olet vakuuttunut siitä, että ketjun maksimipituuden on oltava pienempi tai yhtä suuri kuin 50 onnistuakseen ja missä tahansa sarjassa voi olla vain yksi pitkä ketju, voimme laskea haasteen läpäisemisen todennäköisyyden:

Lisää matematiikkaa

Mitä tarvitsemme pitkän ketjun todennäköisyyden selvittämiseksi?

Jos ketjun pituus on l, todennäköisyys, että laatikot ovat tämän ketjun ulkopuolella, on:

Tässä numerokokoelmassa on (l-1)! tapoja järjestää kyltit.

Loput kyltit löytyvät (100-l)! tavoilla (älä unohda, että ketjun pituus ei ylitä 50).

Tämän huomioon ottaen ketjun sisältävien permutaatioiden määrä tarkka pituus l: (>50)


Osoittautuu, että on 100(!) tapaa järjestää levyt siten, että l:n pituisen ketjun olemassaolon todennäköisyys on 1/l. Muuten, tämä tulos ei riipu laatikoiden määrästä.

Kuten jo tiedämme, voi olla vain yksi tapaus, jossa on ketju, jonka pituus on > 50, joten onnistumisen todennäköisyys lasketaan tällä kaavalla:

Tulos

31,18 % - todennäköisyys, että pisimmän ketjun koko on alle 50 ja jokainen vanki löytää tablettinsa, kun otetaan huomioon 50 yrityksen raja.

Todennäköisyys, että kaikki vangit löytävät levynsä ja läpäisevät testin, on 31,18 %

Alla on kaavio, joka näyttää todennäköisyydet (y-akselilla) kaikille l-pituisille ketjuille (x-akselilla). Punainen tarkoittaa kaikkia "virheitä" (tässä käyrä on vain 1/l käyrä). Vihreä väri tarkoittaa "menestystä" (laskenta on hieman monimutkaisempi tässä kaavion osassa, koska on useita tapoja määrittää enimmäispituus <50). Общая вероятность складывается из зеленых столбцов в 31.18% шанс на спасение.


Harmoninen numero (tämä artikkelin osa on nörteille)

Matematiikassa n:s harmoninen luku on luonnollisen sarjan ensimmäisen n peräkkäisen luvun käänteislukujen summa.


Lasketaan raja, jos meillä on 100a laatikoiden sijasta mielivaltainen suuri määrä laatikoita (oletetaan, että meillä on yhteensä 2n laatikkoa).


Euler-Mascheronin vakio on vakio, joka määritellään harmonisen sarjan osasumman ja luvun luonnollisen logaritmin välisen eron rajaksi.

Vankien määrän kasvaessa, jos valvoja sallii vankien avata puolet kaikista laatikoista, pelastumisen mahdollisuus on yleensä 30,685 %.

(Jos teit päätöksen, jossa vangit arvaavat satunnaisesti laatikot, niin vankien määrän kasvaessa todennäköisyys pelastua on nolla!)

Lisäkysymys

Muistaako kukaan muu lisäkysymystä? Mitä avulias toverimme voi tehdä parantaakseen selviytymismahdollisuuksiamme?

Nyt tiedämme jo ratkaisun, joten strategia tässä on yksinkertainen: hänen on tutkittava kaikki merkit ja löydettävä pisin laatikkoketju. Jos pisin ketju on alle 50, hänen ei tarvitse vaihtaa tabletteja ollenkaan tai muuttaa niitä niin, että pisin ketju ei tule 50:tä pitemmäksi. Jos hän kuitenkin löytää ketjun, joka on pidempi kuin 50 laatikkoa, hänen tarvitsee vain vaihtaa kahden laatikon sisältö ketjusta katkaistakseen ketjun kahdeksi lyhyemmäksi ketjuksi.

Tämän strategian seurauksena ei tule pitkiä ketjuja ja kaikki vangit löytävät merkkinsä ja pelastuksensa. Joten vaihtamalla kaksi merkkiä, vähennämme pelastuksen todennäköisyyden 100 prosenttiin!


Muista, että kuution (tai tavallisen laatikon) tilavuus on yhtä suuri kuin sen pituuden, leveyden ja korkeuden tulo. Jos laatikkosi on suorakaiteen tai neliön muotoinen, sinun tarvitsee vain tietää sen pituus, leveys ja korkeus. Tilavuuden saamiseksi on tarpeen kertoa mittaustulokset. Laskentakaava lyhennetyssä muodossa esitetään usein seuraavasti: V \u003d P x L x K.
Ongelmaesimerkki: "Jos laatikon pituus on 10 cm, leveys 4 cm ja korkeus 5 cm, mikä on sen tilavuus?"
V = P x L x K
V = 10 cm x 4 cm x 5 cm
V \u003d 200 cm 3
Laatikon "korkeutta" voidaan kutsua "syvyydeksi". Tehtävä voi sisältää esimerkiksi seuraavat tiedot: "Laatikon pituus on 10 cm, leveys 4 cm ja syvyys 5 cm."

2
Mittaa laatikon pituus. Jos katsot laatikkoa ylhäältä, se ilmestyy silmiesi eteen suorakulmion muodossa. Laatikon pituus on tämän suorakulmion pisin sivu. Kirjaa tämän puolen mittauksen tulos "pituus"-parametrin arvoksi.
Muista käyttää samaa mittayksikköä mittauksissa. Jos mittasit yhden puolen senttimetreinä, myös muut sivut on mitattava senttimetreinä.

3
Mittaa laatikon leveys. Laatikon leveyttä edustaa ylhäältä näkyvän suorakulmion toinen, lyhyempi sivu. Jos yhdistät visuaalisesti laatikon sivut pituuden ja leveyden mukaan, ne näkyvät kirjaimen "G" muodossa. Kirjoita viimeisen mittauksen arvo "leveyteen".
Leveys on aina laatikon lyhyempi puoli.

4
Mittaa laatikon korkeus. Tämä on viimeinen parametri, jota et ole vielä mitannut. Se edustaa etäisyyttä laatikon yläreunasta pohjaan. Kirjaa tämän mittauksen arvo arvoksi "korkeus".
Riippuen siitä, kummalle puolelle asetat laatikon, tietyt sivut, jotka määrität "pituudeksi", "leveydeksi" tai "korkeudeksi", voivat olla erilaisia. Sillä ei kuitenkaan ole väliä, tarvitset vain mitat kolmelta eri puolelta.

5
Kerro kolmen mittauksen tulokset yhteen. Kuten jo mainittiin, tilavuuden laskentakaava on seuraava: V = pituus x leveys x korkeus; siksi äänenvoimakkuuden saamiseksi sinun on yksinkertaisesti kerrottava kaikki kolme puolta. Muista määrittää laskennassa käyttämäsi yksiköt, jotta et unohda, mitä arvot tarkalleen tarkoittavat.

6
Kun ilmoitat tilavuusyksiköitä, älä unohda ilmoittaa kolmatta tehoa " 3 ". Lasketulla tilavuudella on numeerinen lauseke, mutta ilman mittayksiköiden oikeaa ilmaisua laskelmasi ovat merkityksettömiä. Tilavuusyksiköiden näyttämiseksi oikein ne on määritettävä kuutiossa. Jos esimerkiksi kaikki sivut mitataan senttimetreinä, tilavuusyksiköiksi määritettäisiin "cm3".
Esimerkki ongelmasta: "Jos laatikon pituus on 2 m, leveys 1 m ja korkeus 3 m, mikä on sen tilavuus?"
V = P x L x K
V = 2 m x 1 m x 4 m
V \u003d 8 m 3
Huomautus: Tilavuuden kuutioyksiköiden määrittäminen auttaa ymmärtämään, kuinka monta tällaista kuutiota voidaan sijoittaa laatikon sisään. Jos viitataan edelliseen esimerkkiin, tämä tarkoittaa, että laatikkoon laitetaan kahdeksan kuutiometriä.

Muun muotoisten laatikoiden tilavuuden laskeminen

Määritä sylinterin tilavuus. Sylinteri on pyöreä putki, jonka molemmissa päissä on ympyröitä. Sylinterin tilavuuden määrittämiseen käytetään kaavaa: V = π x r 2 x h, missä π = 3,14, r on sylinterin pyöreän sivun säde ja h on sen korkeus.
Kartion tai pyöreäpohjaisen pyramidin tilavuuden määrittämiseksi käytetään samaa kaavaa, mutta kerrotaan 1/3:lla. Eli kartion tilavuus lasketaan kaavalla: V = 1/3 (π x r 2 x h)

2
Määritä pyramidin tilavuus. Pyramidi on hahmo, jolla on litteä pohja ja sivut, jotka yhtyvät ylhäältä yhteen pisteeseen. Pyramidin tilavuuden määrittämiseksi sinun on otettava 1/3 sen pohjan ja korkeuden pinta-alan tulosta. Eli laskentakaava on seuraava: Pyramidin tilavuus = 1/3 (pohjapinta-ala x korkeus).
Useimmissa tapauksissa pyramidilla on neliön tai suorakaiteen muotoinen pohja. Tällaisessa tilanteessa alustan pinta-ala lasketaan kertomalla pohjan pituus leveydellä.

Voit määrittää monimutkaisen muotoisen laatikon tilavuuden lisäämällä sen yksittäisten osien tilavuudet. Saatat esimerkiksi joutua mittaamaan L-kirjaimen muotoisen laatikon tilavuuden. Tässä tapauksessa laatikolla on enemmän sivuja mitattavaksi. Jos jaat tämän laatikon kahteen osaan, voit mitata näiden kahden osan tilavuuden normaalilla tavalla ja lisätä sitten saadut arvot. L-muotoisen laatikon tapauksessa pidempää osaa voidaan pitää erillisenä pitkänä suorakaiteen muotoisena laatikkona ja lyhyempi osa siihen kiinnitettynä neliönmuotoisena (tai lähes neliönmuotoisena) laatikkona.
Jos laatikollasi on hyvin monimutkaisia ​​muotoja, tiedä, että on monia tapoja määrittää minkä tahansa muotoisten esineiden tilavuus.

    Kirjoita ohjelma, joka vertaa kahta näppäimistöltä syötettyä kokonaislukua. Ohjelman on ilmoitettava kumpi luku on suurempi, tai jos numerot ovat yhtä suuret, näytettävä asianmukainen viesti.

    Kirjoita kaksi kokonaislukua ja paina Enter.
    -> 34 67
    34 vähemmän kuin 67

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; proseduurin pää on A, B: Kokonaisluku; begin Put_Line("Syötä kaksi kokonaislukua yhdelle riville ja paina Enter."); put("-> "); Saada); Hanki(B); --Syötä 2 numeroa, jos A > B sitten Put(Kohde =>; A, Leveys =>; 1); put("suurempi kuin"); Laita(Tuote => B, Leveys => 1); elsif A< B then Put(Item =>A, leveys => 1); put("vähemmän kuin"); Laita(Tuote => B, Leveys => 1); else Put("Syötetyt luvut ovat yhtä suuret!"); loppu Jos; pää lopussa;

    Kolme kokonaislukua annetaan. Etsi niistä suurin (ohjelman tulee tulostaa tasan yksi kokonaisluku). Suurin tässä ongelmassa ymmärretään numerona, joka ei ole pienempi kuin mikään muu.


  • -> 1 2 3
    Enintään kolme numeroa: 3
  • kanssa Ada.Text_IO ; käytä Ada.Text_IO ; kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; proseduurin pää on A, B, C: Kokonaisluku; max: Kokonaisluku; begin Put_Line( "Syötä kolme kokonaislukua yhdelle riville ja paina Enter.") ; Laita("-> "); Saada); Hanki(B); Hanki(C); -- Syötä kolme kokonaislukua max:=A; --oletus katsomme, että luku A on suurin jos B > max --Jos B on suurempi kuin maksimi, niin max:=B; -- enimmäismäärä on B loppu Jos ; jos C > max --Jos C on suurempi kuin maksimi, niin max:=C; -- suurin luku on C loppu Jos ; Laittaa( "Enintään kolme numeroa:"& Kokonaisluku"image(max) ); end main;

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; proseduurin pää on A, B, C: Kokonaisluku; max: Kokonaisluku; begin Put_Line("Syötä kolme kokonaislukua yhdelle riville ja paina Enter."); put("-> "); Saada); Hanki(B); Hanki(C); --Syötä kolme kokonaislukua max:= A; --oletuksena oletetaan, että luku A on suurin jos B > max niin --Jos B on suurempi kuin maksimi, niin max:= B; --maksimiluku on B end if; jos C > max, niin --Jos C on suurempi kuin max, niin max:= C; --maksimiluku on yhtä suuri kuin C end if; Put("Enintään kolme numeroa:" & Kokonaisluku"image(max)); end main;

    Annettu kolme luonnolliset luvut A, B, C. Selvitä, onko kolmio olemassa näiden sivujen kanssa. Jos kolmio on olemassa, tulosta viesti, että kolmio, jolla on tällaiset sivut, on olemassa, muussa tapauksessa tulosta, että kolmiota ei ole olemassa.

  • Kirjoita kolmion kolme sivua ja paina Enter.
    -> 3 4 5
    On olemassa kolmio, jonka sivut ovat 3, 4, 5.

    • Kolmio on kolme pistettä, jotka eivät ole samalla suoralla. Kolmio on olemassa vain, jos minkä tahansa sen kahden sivun summa on suurempi kuin kolmas.

  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; -- Kokonaislukujen lukemiseen kanssa Ada.Text_IO ; käytä Ada.Text_IO ; --Näytä merkkijonot proseduuri main on a, b, c: Kokonaisluku; begin Put_Line( "Syötä kolmion kolme sivua ja paina Enter.Enter.") ; Laita("-> "); Saada); Hanki(b) ; Hanki(c); --Lue kolmion sivut jos a + b > c ja sitten b + c > a ja sitten c + a > b sitten -- Tarkista kaikki ehdot yhdeltä riviltä Laittaa( "Kolmio sivuilla"& Kokonaisluku"kuva(a) & "," & Kokonaisluku"kuva(b) & "," & Kokonaisluku"kuva(c) & " olemassa" ) ; else Laita( "Kolmio sivuilla"& Kokonaisluku"kuva(a) & "," & Kokonaisluku"kuva(b) & "," & Kokonaisluku"kuva(c) & " ei ole olemassa" ) ; end if ; end main;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; -- Kokonaislukujen lukeminen Ada.Text_IO:lla; käytä Ada.Text_IO; -- Merkkijonojen tulostaminen proseduurin pää on a, b, c: Kokonaisluku; begin Put_Line("Syötä kolmion kolme sivua ja paina Enter.Enter."); put("-> "); saada); saada(b); get(c); --Lue kolmion sivut jos a + b > c ja sitten b + c > a ja sitten c + a > b sitten --tarkista kaikki ehdot yhdeltä riviltä Put("Kolmio sivuilla" & Kokonaisluku"image(a) & " ," & Kokonaisluku"kuva(b) & "," & Kokonaisluku"kuva(c) & " olemassa"); else Put("Kolmio sivuilla" & Kokonaisluku"image(a) & "," & Kokonaisluku"image( b) & "," & Kokonaisluku"kuva(c) & " ei ole olemassa"); loppu Jos; pää lopussa;

    Kolme kokonaislukua annetaan. Selvitä, kuinka monta niistä vastaa. Ohjelman tulee tulostaa yksi numeroista: 3 (jos kaikki ovat samoja), 2 (jos kaksi ovat samoja) tai 0 (jos kaikki ovat erilaisia).

  • Kirjoita kolme kokonaislukua ja paina Enter.
    -> 1 2 3
    0
  • kanssa Ada.Text_IO ; käytä Ada.Text_IO ; kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; menettely Main on A, B, C: Kokonaisluku; begin Put_Line( "Syötä kolme kokonaislukua ja paina Enter.") ; Laita("-> "); Saada); Hanki(B); Hanki(C); jos A = B ja sitten A = C niin --Jos kaikki kolme numeroa täsmäävät Laita(Kohde => 3 , Leveys => 1 ) ; elsif A = B tai A = C tai B = C silloin --Jos kaksi numeroa täsmää Laita(Kohde => 2 , Leveys => 1 ) ; muu --Jos samat numerot Ei Laita(Tuote => 0 , Leveys => 1 ) ; loppu Jos ; endMain;

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; menettely Main on A, B, C: Kokonaisluku; begin Put_Line("Syötä kolme kokonaislukua ja paina Enter."); put("-> "); Saada); Hanki(B); Hanki(C); jos A = B ja sitten A = C niin --Jos kaikki kolme numeroa vastaavat Put(Kohde => 3, Leveys => 1); elsif A = B tai A = C tai B = C niin --Jos kaksi numeroa vastaavat Put(Kohde => 2, Leveys => 1); else --Jos identtisiä numeroita ei ole Laita(Item => 0, Width => 1); loppu Jos; endMain;

    Shakkitorni liikkuu vaaka- tai pystysuunnassa. Annettu kaksi erilaisia ​​soluja shakkilauta, määrittää, voiko torni siirtyä ensimmäisestä solusta toiseen yhdellä liikkeellä. Ohjelma vastaanottaa syötteenä neljä numeroa 1-8, joista jokainen määrittää sarakkeen numeron ja rivinumeron ensin ensimmäiselle solulle ja sitten toiselle solulle. Ohjelman tulee tulostaa "KYLLÄ", jos ensimmäisestä solusta on mahdollista päästä toiseen soluun tornia liikuttamalla, tai "EI" muuten.


  • 4 4
    5 5
    EI
  • ) ; Laita() ; Saada); Hanki(B); Laita() ; Hanki(C); Hanki(D); jos A = C tai B = D niin Laita("KYLLÄ" ) ; else Laita("EI" ); loppu Jos ; endMain;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely Main on alatyyppi checkBoard on Kokonaislukualue 1...8; A, B, C, D: valintataulu; begin Put_Line("Anna sarake- ja rivinumerot kahdelle solulle:"); Put("Syötä sarake- ja rivinumerot ensimmäiselle solulle ja paina: "); Saada); Hanki(B); Put("Syötä toisen solun sarake- ja rivinumerot ja paina: "); Hanki(C); Hanki(D); jos A = C tai B = D niin Laita("KYLLÄ"); else Laita("EI"); loppu Jos; endMain;

    Shakkikuningas liikkuu vaakasuunnassa, pystysuunnassa ja vinottain, mutta vain 1 ruutu. Kun shakkilaudalla on kaksi eri solua, päätä, pääseekö kuningas ensimmäisestä solusta toiseen yhdellä siirrolla. Ohjelma vastaanottaa syötteenä neljä numeroa 1-8, joista jokainen määrittää sarakkeen numeron ja rivinumeron ensin ensimmäiselle solulle ja sitten toiselle solulle. Ohjelman tulee tulostaa "KYLLÄ", jos ensimmäisestä solusta on mahdollista päästä toiseen kuninkaan liikkeellä, tai "EI" muuten.

  • Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 4 4
    Syötä toisen solun sarake- ja rivinumerot ja paina: 5 5
    JOO
  • "Syötä sarake- ja rivinumerot kahdelle solulle:") ; Laittaa( "Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: ") ; Saada); Hanki(B); Laittaa( "Syötä toisen solun sarake- ja rivinumerot ja paina: ") ; Hanki(C); Hanki(D); jos vatsat (A-C)<= 1 and then abs (B - D) <= 1 then -- komento abs() palauttaa absoluuttisen -- luvun arvo (moduuli). Laita("KYLLÄ"); else Laita("EI" ); loppu Jos ; pää lopussa;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely main on alatyyppi checkBoard on Kokonaislukualue 1..8; A, B, C, D: valintataulu; begin Put_Line("Anna sarake- ja rivinumerot kahdelle solulle:"); Put("Syötä sarake- ja rivinumerot ensimmäiselle solulle ja paina: "); Saada); Hanki(B); Put("Syötä toisen solun sarake- ja rivinumerot ja paina: "); Hanki(C); Hanki(D); jos abs(A-C)<= 1 and then abs(B - D) <= 1 then -- команда abs() возвращает абсолютное --значение (модуль) числа Put("ДА"); else Put("НЕТ"); end if; end main;

    Shakkipiispa liikkuu vinottain. Kun otetaan huomioon shakkilaudan kaksi eri solua, päätä, pääseekö piispa ensimmäisestä solusta toiseen yhdellä siirrolla. Ohjelma vastaanottaa syötteenä neljä numeroa 1-8, joista jokainen määrittää sarakkeen numeron ja rivinumeron ensin ensimmäiselle solulle ja sitten toiselle solulle. Ohjelman tulee tulostaa "KYLLÄ", jos ensimmäisestä solusta on mahdollista päästä toiseen piispan liikkeellä, tai "Ei" muuten.

  • Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 4 4
    Syötä toisen solun sarake- ja rivinumerot ja paina: 5 5
    JOO
  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; menettely main on alatyyppi checkBoard on Kokonaislukualue 1 ..8 ; A, B, C, D: valintataulu; begin Put_Line( "Syötä sarake- ja rivinumerot kahdelle solulle:") ; Laittaa( "Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: ") ; Saada); Hanki(B); Laittaa( "Syötä toisen solun sarake- ja rivinumerot ja paina: ") ; Hanki(C); Hanki(D); jos abs (a - c) = abs (b - d) niin Laita("KYLLÄ" ) ; else Laita("EI" ); loppu Jos ; pää lopussa;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely main on alatyyppi checkBoard on Kokonaislukualue 1..8; A, B, C, D: valintataulu; begin Put_Line("Anna sarake- ja rivinumerot kahdelle solulle:"); Put("Syötä sarake- ja rivinumerot ensimmäiselle solulle ja paina: "); Saada); Hanki(B); Put("Syötä toisen solun sarake- ja rivinumerot ja paina: "); Hanki(C); Hanki(D); jos abs(a - c) = abs(b - d) sitten Put("KYLLÄ"); else Laita("EI"); loppu Jos; pää lopussa;

    Shakkikuningatar liikkuu vinosti, vaakasuunnassa tai pystysuunnassa. Kun otetaan huomioon shakkilaudan kaksi eri solua, määritä, pääseekö kuningatar ensimmäisestä solusta toiseen yhdellä siirrolla.

    Syötetietojen muoto:
    Ohjelma vastaanottaa syötteenä neljä numeroa 1-8, joista jokainen määrittää sarakkeen numeron ja rivinumeron ensin ensimmäiselle solulle ja sitten toiselle solulle.
    Tulostusmuoto:
    Ohjelman tulee tulostaa KYLLÄ, jos on mahdollista päästä toiseen soluun ensimmäisestä solusta kuningattaren liikkeellä, tai EI muuten.

    Esimerkki 1:
    Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 1 1
    Syötä toisen solun sarake- ja rivinumerot ja paina: 2 2
    JOO

    Esimerkki 2:
    Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 1 1
    Syötä toisen solun sarake- ja rivinumerot ja paina: 2 3
    EI

  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; menettely Main on alatyyppi checkboard on Kokonaislukualue 1...8; A, B, C, D: valintataulu; begin Put_Line( "Syötä sarake- ja rivinumerot kahdelle solulle:") ; Laittaa( "Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: ") ; Saada); Hanki(B); Laittaa( "Syötä toisen solun sarake- ja rivinumerot ja paina: ") ; Hanki(C); Hanki(D); jos abs (A - C) = abs (B - D) tai A = D tai B = C, niin Laita("KYLLÄ" ) ; else Laita("EI" ); loppu Jos ; endMain;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely Main on alatyyppi checkBoard on Kokonaislukualue 1...8; A, B, C, D: valintataulu; begin Put_Line("Anna sarake- ja rivinumerot kahdelle solulle:"); Put("Syötä sarake- ja rivinumerot ensimmäiselle solulle ja paina: "); Saada); Hanki(B); Put("Syötä toisen solun sarake- ja rivinumerot ja paina: "); Hanki(C); Hanki(D); jos abs(A - C) = abs(B - D) tai A = D tai B = C niin Laita("KYLLÄ"); else Laita("EI"); loppu Jos; endMain;

    Shakkihevonen liikkuu kirjaimella "G" - kaksi ruutua pystysuunnassa mihin tahansa suuntaan ja yksi ruutu vaakasuunnassa tai päinvastoin. Kun otetaan huomioon shakkilaudan kaksi eri solua, määritä, pääseekö ritari ensimmäisestä solusta toiseen yhdellä siirrolla. Ohjelma vastaanottaa syötteenä neljä numeroa 1-8, joista jokainen määrittää sarakkeen numeron ja rivinumeron ensin ensimmäiselle solulle ja sitten toiselle solulle. Ohjelman tulee tulostaa KYLLÄ, jos ritari voi siirtyä ensimmäisestä solusta toiseen, tai EI muuten.

    Esimerkki 1:
    Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 1 1
    Syötä toisen solun sarake- ja rivinumerot ja paina: 1 4
    EI

    Esimerkki 2:
    Syötä sarake- ja rivinumerot kahdelle solulle:
    Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: 1 1
    Syötä toisen solun sarake- ja rivinumerot ja paina: 8 8
    EI

  • kanssa Ada.Text_IO ; käytä Ada.Text_IO ; kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; menettely main on alatyyppi checkBoard on Kokonaislukualue 1 ..8 ; A, B, C, D: kokonaisluku; begin Put_Line( "Syötä sarake- ja rivinumerot kahdelle solulle:") ; Laittaa( "Syötä ensimmäisen solun sarake- ja rivinumerot ja paina: ") ; Saada); Hanki(B); Laittaa( "Syötä toisen solun sarake- ja rivinumerot ja paina: ") ; Hanki(C); Hanki(D); jos abs (A - C) = 2 ja sitten abs (B - D) = 1, niin Laita("KYLLÄ" ) ; elsif abs (A - C) = 1 ja sitten abs (B - D) = 2 sitten Put("KYLLÄ" ) ; else Laita("EI" ); loppu Jos ; pää lopussa;

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; menettely main on alatyyppi checkBoard on Kokonaislukualue 1..8; A, B, C, D: kokonaisluku; begin Put_Line("Anna sarake- ja rivinumerot kahdelle solulle:"); Put("Syötä sarake- ja rivinumerot ensimmäiselle solulle ja paina: "); Saada); Hanki(B); Put("Syötä toisen solun sarake- ja rivinumerot ja paina: "); Hanki(C); Hanki(D); jos abs(A - C) = 2 ja sitten abs(B - D) = 1, niin Laita("KYLLÄ"); elsif abs(A - C) = 1 ja sitten abs(B - D) = 2 sitten Put("KYLLÄ"); else Laita("EI"); loppu Jos; pää lopussa;

    Suklaa on suorakulmion muotoinen, ja se on jaettu N × M viipaleisiin. Suklaa voidaan jakaa kerran suoraan kahteen osaan. Selvitä, voiko suklaapatukosta tällä tavalla irrottaa tarkalleen K viipaletta. Ohjelma saa kolme numeroa syötteenä: N, M, K. Ohjelman tulee tulostaa yksi kahdesta sanasta: "YES" tai "No".

    Esimerkki 1:
    4
    2
    6
    JOO

    Esimerkki 2:
    Viipaleiden lukumäärä vaakasuunnassa: 2
    Viipaleiden lukumäärä pystysuunnassa: 10
    Kuinka monta viipaletta erotetaan: 7
    EI

  • kanssa Ada.Text_IO ; käytä Ada.Text_IO ; kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; menettely Main on N, M, K: Kokonaisluku; Aloita Put( "Sivujen määrä vaakatasossa:") ; Hanki(N); Laittaa( "Sivujen lukumäärä pystysuunnassa:") ; Hanki(M); Laittaa( "Kuinka monta viipaletta erotettava:") ; Hanki(K); jos K > M * N niin --Jos suklaapatukkaa pyydetään katkeamaan enemmän kuin itse suklaapatukka laittaa("EI"); elsif K rem N = 0 ja sitten K >= N sitten - Katkaise vaakatasossa Laita("KYLLÄ"); elsif K rem M = 0 ja sitten K >= M sitten - Katkaise pystysuoraan Laita("KYLLÄ"); else Laita("EI" ); loppu Jos ; endMain;

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; menettely Main on N, M, K: Kokonaisluku; begin Put("Sivujen lukumäärä vaakasuunnassa: "); Hanki(N); Put("Sivujen lukumäärä pystysuunnassa: "); Hanki(M); Put("Kuinka monta viipaletta erotetaan: "); Hanki(K); jos K > M * N sitten --Jos suklaapatukkaa pyydetään katkeamaan enemmän kuin itse suklaapatukka Laita("EI"); elsif K rem N = 0 ja sitten K >= N sitten -- Katkaise vaakatasossa Laita("KYLLÄ"); elsif K rem M = 0 ja sitten K >= M sitten -- Katkaise pystysuunnassa Laita("KYLLÄ"); else Laita("EI"); loppu Jos; endMain;

    Yasha ui N × M metrin altaassa ja väsyi. Tässä vaiheessa hän huomasi olevansa X metrin päässä yhdestä pitkästä reunasta (ei välttämättä lähimmästä) ja Y metrin päässä yhdestä lyhyestä reunasta. Mikä on vähimmäisetäisyys, joka Yashan on uida päästäkseen altaalta sivulle? Ohjelma saa syötteenä numerot N, M, X, Y. Ohjelman tulee tulostaa kuinka monta metriä Yasha tarvitsee uidakseen sivulle.

  • Altaan leveys: 23
    Altaan pituus: 52
    Etäisyys Yashasta pitkälle sivulle: 8
    Etäisyys Yashasta lyhyelle puolelle: 43
    Sinun täytyy uida ainakin päästäksesi pois altaalta: 8

    • On mahdollista, että ongelman ratkaisemiseksi sinun on vaihdettava 2 muuttujaa. Tämä algoritmi näyttää suunnilleen tältä:

    a, b, tmp: Kokonaisluku; -- Muuttujien ilmoittaminen. Kaksi pää- ja yksi apu a:= 3; --muuttujan a alustus b:= 5; --Muuttujan b alustus --Algoritmi itse: tmp:= a; -- Nyt tmp = 3 ja a = 3 a:= b; -- Nyt a = 5 ja b = 5; b:=tmp; -- Nyt b = 3

  • kanssa Ada.Text_IO ; käytä Ada.Text_IO ; kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; menettely Main on N, M, X, Y: Kokonaisluku; -- N - lyhyt reuna, M - pitkä reuna: -- X - Etäisyys yhteen pitkistä sivuista -- Y - Etäisyys yhteen lyhyistä sivuista Tmp: Kokonaisluku; Aloita Put( "Altaan leveys:") ; Hanki(N); Laittaa( "Altaan pituus:") ; Hanki(M); Laittaa( "Etäisyys Yashasta pitkälle sivulle:") ; Hanki(X) ; Laittaa( "Etäisyys Yashasta lyhyelle puolelle:") ; Hanki(Y) ; jos N > M niin --Jos sivut sekoittuvat syötteen aikana, vaihdamme niiden paikkoja: Tmp: = M; --Tallenna pituus M väliaikaiseen muuttujaan M: = N; --Määritä muuttujalle M uusi arvo N:=Tmp; -- Palauta pituus M muuttujassa N loppu Jos ; Tmp:=X; -- Oletetaan, että vähimmäisetäisyys on X jos abs (N-X)< X then --Jos etäisyys toiseen pitkään reunaan on pienempi kuin X, niin Tmp: = N - X; --minimietäisyys yhtä suuri kuin etäisyys toiseen pitkään sivuun loppu Jos ; jos Y< Tmp then --Jos etäisyys lyhyeen reunaan on pienempi kuin yllä -- Minimi siis Tmp:=Y; -- Minimietäisyys on Y loppu Jos ; jos vatsat (M - Y)< Tmp then --Jos uit lähemmäksi toista lyhyttä puolta, niin Tmp: = abs (M - Y); --minimietäisyys on yhtä suuri kuin etäisyys toiseen lyhyeen reunaan loppu Jos ; Laittaa( "Sinun täytyy uida ainakin päästäkseen pois altaalta:") ; Laita(Tuote => Tmp, Leveys => 1 ) ; endMain;

    kanssa Ada.Text_IO; käytä Ada.Text_IO; kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; menettely Main on N, M, X, Y: Kokonaisluku; -- N - lyhyt reunus, M - pitkä reunus: -- X - Etäisyys yhteen pitkistä reunuksista -- Y - Etäisyys yhteen lyhyeen reunaan Tmp: Kokonaisluku; begin Put("Altaan leveys: "); Hanki(N); Put("Altaan pituus: "); Hanki(M); Put("Etäisyys Yashasta pitkälle sivulle: "); Hanki(X); Put("Etäisyys Yashasta lyhyeen reunaan: "); Hanki(Y); jos N > M niin --Jos reunat sekoittuvat syötteen aikana, niin vaihdamme niiden paikkoja: Tmp:= M; --Tallenna pituus M tilapäiseen muuttujaan M:= N; --Anna uusi arvo muuttujalle M N:= Tmp; --Palauta pituus M muuttujassa N end if; Tmp:=X; -- Oletetaan, että vähimmäisetäisyys on X, jos 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, leveys => 1); endMain;

    Elektroninen kello näyttää ajan muodossa h:mm:ss (0:00:00 - 23:59:59), eli ensin kirjataan tuntien määrä, sitten kaksinumeroinen minuuttimäärä on pakollinen, silloin kaksinumeroinen sekuntimäärä on pakollinen. Tarvittaessa minuuttien ja sekuntien lukumäärä täytetään kaksinumeroinen luku nollia. N sekuntia on kulunut päivän alusta. Näytä mitä kello näyttää. Syöte on luonnollinen luku N, joka ei ylitä 10 7 (10000000). Esitä vastaus ongelmaan.

    Syöteesimerkki 1:
    3602
    Tulosesimerkki 1:
    1:00:02

    Syöteesimerkki 2:
    129700
    Tulosesimerkki 2:
    12:01:40

  • kanssa Ada.Long_Integer_Text_IO ; käytä Ada.Long_Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; menettely Main on alatyyppi Sub_LI on Long_Integer alue 1 ..10000000 ; N: Sub_LI; h, m, s: pitkä_kokonaisluku; alkaa Get(N) ; h:= N/3600; - Saamme kellon. Loput jaosta hylätään N: = N - h* 3600; - Hanki jäljellä olevat sekunnit (miinus tuntia) jos h > 24 niin --Koska kello ei voi näyttää > 24, laitamme kaiken luettavaan muotoon h:= h rem 24; --Jäljellä oleva jakaminen 24:llä antaa tarkan tuntimäärän elsif h = 24 sitten h:= 0; loppu Jos ; m: = N/60; -- Hanki minuutteja s: = N rem 60; -- Ota sekuntia Laita(Kohde => h, Leveys => 1 ) ; Laittaa(":"); --Tunnit ja ":" jos m< 10 then --Jos minuuttien lukumäärä on pienempi kuin 10, syötä alussa 0 Laita(Tuote => 0 , Leveys => 1 ) ; loppu Jos ; Laita(Kohde => m, Leveys => 1 ); Laittaa(":"); --Tulosta minuutit ja ":" jos s< 10 then --Jos sekuntien määrä on pienempi kuin 10, syötä alussa 0 Laita(Tuote => 0 , Leveys => 1 ) ; loppu Jos ; Laita(Kohde => s, Leveys => 1 ) ; -- Lähtö sekunti loppu Main;

    kanssa Ada.Long_Integer_Text_IO; käytä Ada.Long_Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely Main on alatyyppi Sub_LI on Long_Integer alue 1..10000000; N: Sub_LI; h, m, s: pitkä_kokonaisluku; alkaa Get(N); h: = N/3600; - Saamme kellon. Jaon loppuosa hylätään N:= N - h * 3600; --Saa jäljellä olevat sekunnit (miinustunnit), jos h > 24 niin --Koska kellot eivät osaa lukea > 24, laita kaikki luettavaan muotoon h:= h rem 24; -- 24:llä jakamisen loppuosa antaa tarkan tuntimäärän, jos h = 24 sitten h:= 0; loppu Jos; m: = N/60; --Hae minuutit s:= N rem 60; -- Hanki sekuntia Laita(Kohde => h, Leveys => 1); Laittaa(":"); --Tulostustunnit ja ":", jos m< 10 then --Если количество минут меньше 10, выводим ведущий 0 Put(Item =>0, leveys => 1); loppu Jos; Laita(Kohde => m, Leveys => 1); Laittaa(":"); --Tulosta minuutit ja ":", jos s< 10 then --Если количество секунд меньше 10, выводим ведущий 0 Put(Item =>0, leveys => 1); loppu Jos; Laita(Kohde => s, Leveys => 1); -- Lähtö sekunti loppu Main;

  • Kolme numeroa annetaan. Järjestä ne nousevaan järjestykseen.
  • Syöteesimerkki:
    1 2 1
    Näytetulostus:
    1 1 2
  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; menettely Main on A, B, C: Kokonaisluku; min, mid, max: Kokonaisluku; alkaa Get(A) ; Hanki(B); Hanki(C); --Etsivät minimiarvo min:=A; jos B< min then min:= B; end if ; if C < min then min:= C; end if ; --Etsivät enimmäisarvo max:=A; jos B > max niin max:= B; loppu Jos ; jos C > max niin max:= C; loppu Jos ; --Etsitään keskiarvoa mid:=A; jos B > min ja B< max then mid:= B; end if ; if C >min ja C< max then mid:= C; end if ; Put(Item =>min, Leveys => 1 ); laittaa(" "); Laita(Tuote => keski, leveys => 1 ) ; laittaa(" "); Laita(Tuote => max, Leveys => 1 ) ; endMain;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely Main on A, B, C: Kokonaisluku; min, mid, max: Kokonaisluku; alkaa Get(A); Hanki(B); Hanki(C); --Etsitään minimiarvoa min:= A; jos B< min then min:= B; end if; if C < min then min:= C; end if; --Ищем максимальное значение max:= A; if B >max sitten max:= B; loppu Jos; jos C > max niin max:= C; loppu Jos; --Etsitään keskiarvoa mid:= A; jos B > min ja B< max then mid:= B; end if; if C >min ja C< max then mid:= C; end if; Put(Item =>min, leveys => 1); laittaa(" "); Laita(Tuote => keski, leveys => 1); laittaa(" "); Laita(Tuote => max, Leveys => 1); endMain;

    Laatikoita on kaksi, ensimmäinen on A1×B1×C1, toinen A2×B2×C2. Selvitä, voidaanko yksi näistä laatikoista sijoittaa toisen sisään edellyttäen, että laatikoita voidaan kääntää vain 90 astetta reunojen ympäri. Ohjelma vastaanottaa syötteenä numerot A1, B1, C1, A2, B2, C2. Ohjelman tulee tulostaa jokin seuraavista riveistä:
    - "Laatikot ovat samanarvoisia", jos laatikot ovat samat,
    - "Ensimmäinen laatikko alle sekunti"jos ensimmäinen laatikko voidaan sijoittaa toiseen,
    - "Ensimmäinen laatikko enemmän kuin sekunti"jos toinen laatikko voidaan sijoittaa ensimmäisen sisään.

    Esimerkki 1:
    Ensimmäisen laatikon mitat: 1 2 3
    Toisen laatikon mitat: 3 2 1
    Laatikot ovat samanarvoisia

    Esimerkki 2:
    Ensimmäisen laatikon mitat: 2 2 3
    Toisen laatikon mitat: 3 2 1
    Ensimmäinen laatikko on suurempi kuin toinen

  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; proseduurin pää on A1, B1, C1, A2, B2, C2: Kokonaisluku; min, max, mid, tmp: Kokonaisluku; alkaa Get(A1) ; Hanki(B1); Get(C1); Hanki(A2); Hanki(B2); Get(C2) ; -- Tuo kasvot linjaan pituuksien A1 => A2, B1 => B2, C1 => C2 kanssa: --A1 ja A2 ovat pisimmät, C1 ja C2 ovat lyhyimmät -- "Pyörä" ensimmäinen laatikko: min:=A1; keski: = B1; max:=C1; jos B1< min then mid:= min; min:= B1; end if ; if C1 < min then max:= min; min:= C1; end if ; if mid >max sitten tmp:= mid; mid:=max; max:=tmp; loppu Jos ; A1:=min; B1:=keski; C1: = max; -- "Pyörä" toista laatikkoa: min: = A2; keski: = B2; max:=C2; jos B2< min then mid:= min; min:= B2; end if ; if C2 < min then max:= min; min:= C2; end if ; if mid >max sitten tmp:= mid; mid:=max; max:=tmp; loppu Jos ; A2:=min; B2:=keski; C2: = max; -- Laatioiden vastaavuuden tarkistaminen ja tuloksen näyttäminen: jos A1 = A2 ja sitten B1 = B2 ja sitten C1 = C2 sitten Put_Line("Laatikot ovat yhtä suuret" ) ; elsif A1 >= A2 ja sitten B1 >= B2 ja sitten C1 >= C2 sitten Put_Line( "Ensimmäinen laatikko on suurempi kuin toinen") ; Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Ensimmäinen laatikko on pienempi kuin toinen") ; loppu Jos ; pää lopussa;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; proseduurin pää on A1, B1, C1, A2, B2, C2: Kokonaisluku; min, max, mid, tmp: Kokonaisluku; alkaa Get(A1); Hanki(B1); Hanki(C1); Hanki(A2); Hanki(B2); Hanki(C2); -- Tuo reunat kohdakkain pituuksilla A1 => A2, B1 => B2, C1 => C2: --A1 ja A2 - pisin, C1 ja C2 - lyhin -- "Kierrä" ensimmäinen laatikko: min := A1 ; keski: = B1; max:=C1; jos B1< min then mid:= min; min:= B1; end if; if C1 < min then max:= min; min:= C1; end if; if mid >max sitten tmp:= mid; mid:=max; max:=tmp; loppu Jos; A1:=min; B1:=keski; C1: = max; -- "Spin" toinen laatikko: min:= A2; keski: = B2; max:=C2; jos B2< min then mid:= min; min:= B2; end if; if C2 < min then max:= min; min:= C2; end if; if mid >max sitten tmp:= mid; mid:=max; max:=tmp; loppu Jos; A2:=min; B2:=keski; C2: = max; --Tarkista, täsmäävätkö laatikot ja tulosta tulos: jos A1 = A2 ja sitten B1 = B2 ja sitten C1 = C2, niin Put_Line("Laatikot ovat yhtä suuret"); elsif A1 >= A2 ja sitten B1 >= B2 ja sitten C1 >= C2 sitten Put_Line("Ensimmäinen laatikko on suurempi kuin toinen"); Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Первая коробка меньше второй"); end if; end main;

    Kirjoita ohjelma, joka laskee kaukopuhelun kustannukset (minuutin hinta määräytyy etäisyyden mukaan kaupunkiin, jossa tilaaja sijaitsee). Ohjelman lähtötiedot ovat suuntanumero ja puhelun kesto. Alla on joidenkin kaupunkien koodit ja suositeltu näyttö ohjelman ollessa käynnissä:

  • Laske puhelinkeskustelun hinta.
    Syötä alkutiedot:
    Kaupunkikoodi -> 423
    Kesto (kokonaisluku minuuttia) -> 3
    Vladivostokin kaupunki
    Hinta per minuutti: 4 ruplaa.
    Puhelun hinta: 12 ruplaa.
  • kanssa Ada.Integer_Text_IO ; käytä Ada.Integer_Text_IO ; kanssa Ada.Text_IO ; käytä Ada.Text_IO ; menettely Pää On Koodi, Len: Kokonaisluku; alkaa Put_Line ("Puhelinkeskustelun kustannusten laskeminen.") ; Put_Line ("Anna alkutiedot:") ; Laittaa ("Kaupunkikoodi ->") ; Saada ( Koodi ) ; Laittaa ("Kesto (kokonaisluku minuuttia) -> ") ; Saada ( len ) ; tapaus Koodi On kun 423 => Put_Line ("Vladivostok kaupunki") ; Put_Line ("Minuutin hinta: 4 ruplaa.") ; Laittaa ("Puheluhinta:") ; Laittaa ( Tuote => len * 4 , Leveys=> 1 ) ; Put_Line ("hankaa.") ; kun 095 => Put_Line ("Moskovan kaupunki") ; Put_Line ("Minuutin hinta: 2 ruplaa.") ; Laittaa ("Puheluhinta:") ; Laittaa ( Tuote => len * 2 , Leveys=> 1 ) ; Put_Line ("hankaa.") ; kun 815 => Put_Line ("Kaupunki: Murmansk") ; Put_Line ("Minuutin hinta: 3 ruplaa.") ; Laittaa ("Puheluhinta:") ; Laittaa ( Tuote => len * 3 , Leveys=> 1 ) ; Put_Line ("hankaa.") ; kun 846 => Put_Line ("Samaran kaupunki") ; Put_Line ("Minuutin hinta: 1 hiero.") ; Laittaa ("Puheluhinta:") ; Laittaa ( Tuote => len, Leveys => 1 ) ; Put_Line ("hankaa.") ; kun muut=> Laita ("Tietokannassa ei ole kaupunkia, jolla on tämä koodi! Yritä uudelleen.") ; loppu tapaus; loppu tärkeimmät;

    kanssa Ada.Integer_Text_IO; käytä Ada.Integer_Text_IO; kanssa Ada.Text_IO; käytä Ada.Text_IO; menettely Main on Koodi, Len: Kokonaisluku; begin Put_Line("Puhelun hinnan laskeminen."); Put_Line("Anna alkutiedot:"); Put("Kaupunkikoodi -> "); Hanki koodi); Put("Kesto (kokonaisluku minuuttia) -> "); get(len); tapauskoodi on kun 423 => Put_Line("Kaupunki: Vladivostok"); Put_Line("Hinta per minuutti: 4 ruplaa."); Put("Puhelun hinta: "); Laita(Tuote => len * 4, Leveys => 1); Put_Line(" hiero."); when 095 => Put_Line("Kaupunki: Moskova"); Put_Line("Hinta per minuutti: 2 ruplaa."); Put("Puhelun hinta: "); Laita(Tuote => len * 2, Leveys => 1); Put_Line(" hiero."); kun 815 => Put_Line("Kaupunki: Murmansk"); Put_Line("Hinta per minuutti: 3 ruplaa."); Put("Puhelun hinta: "); Laita(Tuote => len * 3, Leveys => 1); Put_Line(" hiero."); kun 846 => Put_Line("Kaupunki: Samara"); Put_Line("Hinta per minuutti: 1 hiero."); Put("Puhelun hinta: "); Laita(Tuote => len, Leveys => 1); Put_Line(" hiero."); when others => Put("Tietokannassa ei ole tätä koodia sisältävää kaupunkia! Yritä uudelleen."); loppukotelo; endMain;

Kohdassa kuvataan lyhyesti operaattoreita jos ja tapaus, toiminto abs() ja algoritmi muuttujien vaihtamiseksi.

Määritelmä.

Tämä on kuusikulmio, jonka kantaa on kaksi yhtä suuri neliö, ja sivupinnat ovat yhtä suuria suorakulmioita

Sivujousi- Tämä on yhteinen puoli kaksi vierekkäistä sivupintaa

Prisman korkeus- tämä on leikkaus kohtisuoraan kantaan nähden prismat

Prisma diagonaali- segmentti, joka yhdistää kaksi kantaa, jotka eivät kuulu samaan pintaan

Diagonaalinen taso on taso, joka kulkee prisman ja sen lävistäjän läpi kylkiluut

Diagonaalinen leikkaus - prisman ja diagonaalitason leikkauspisteen rajat. Säännöllisen nelikulmaisen prisman diagonaalileikkaus on suorakulmio

kohtisuora leikkaus (ortogonaalinen leikkaus)- tämä on prisman ja sen sivureunoihin nähden kohtisuoraan piirretyn tason leikkauspiste

Säännöllisen nelikulmaisen prisman elementit

Kuvassa on kaksi säännöllistä nelikulmaista prismaa, jotka on merkitty vastaavilla kirjaimilla:

  • Kannat ABCD ja A 1 B 1 C 1 D 1 ovat yhtä suuret ja yhdensuuntaiset toistensa kanssa
  • Sivukasvot AA 1 D 1 D, AA 1 B 1 B, BB 1 C 1 C ja CC 1 D 1 D, joista jokainen on suorakulmio
  • Sivupinta- prisman kaikkien sivupintojen pinta-alojen summa
  • Kokonaispinta - kaikkien alustojen ja sivupintojen pinta-alojen summa (sivupinnan ja pohjan pinta-alojen summa)
  • Sivurivat AA 1 , BB 1 , CC 1 ja DD 1 .
  • Diagonaali B 1 D
  • Pohjan diagonaali BD
  • Diagonaalileikkaus BB 1 D 1 D
  • Kohtisuora leikkaus A 2 B 2 C 2 D 2 .

Säännöllisen nelikulmaisen prisman ominaisuudet

  • Pohjat ovat kaksi yhtä suurta neliötä
  • Pohjat ovat yhdensuuntaiset toistensa kanssa
  • Sivut ovat suorakulmioita.
  • Sivupinnat ovat samanarvoisia keskenään
  • Sivupinnat ovat kohtisuorassa pohjaan nähden
  • Lateraaliset kylkiluut ovat samansuuntaiset ja samansuuntaiset
  • Pystysuora leikkaus kohtisuorassa kaikkiin sivuriviin nähden ja yhdensuuntainen kantaan nähden
  • kulmat kohtisuora leikkaus- suora
  • Säännöllisen nelikulmaisen prisman diagonaalileikkaus on suorakulmio
  • Pystysuora (ortogonaalinen leikkaus) yhdensuuntainen kantaan nähden

Kaavat säännölliseen nelikulmaiseen prismaan

Ohjeita ongelmien ratkaisemiseen

Kun ratkaiset aiheeseen liittyviä ongelmia" oikea nelikulmainen prisma " tarkoittaa, että:

Oikea prisma- prisma, jonka pohjassa on säännöllinen monikulmio, ja sivureunat ovat kohtisuorassa perustasoihin nähden. Toisin sanoen säännöllinen nelikulmainen prisma sisältää pohjassaan neliö-. (katso yllä säännöllisen nelikulmaisen prisman ominaisuudet) Merkintä. Tämä on osa oppituntia, jossa on geometrian tehtäviä (leikkaus solid geometry - prisma). Tässä on tehtävät, jotka aiheuttavat vaikeuksia ratkaista. Jos sinun on ratkaistava geometrian ongelma, jota ei ole täällä - kirjoita siitä foorumille. Osoittaa purkamisen neliöjuuri symbolia käytetään ongelmanratkaisussa√ .

Tehtävä.

Säännöllisen nelikulmaisen prisman pohjan pinta-ala on 144 cm 2 ja korkeus 14 cm. Selvitä prisman lävistäjä ja pinta-ala koko pinta.

Ratkaisu.
Säännöllinen nelikulmio on neliö.
Vastaavasti pohjan sivu on yhtä suuri

√144 = 12 cm.
Mistä pohjan diagonaali tulee? suorakaiteen muotoinen prisma tulee olemaan yhtä suuri kuin
√(12 2 + 12 2 ) = √288 = 12√2

Diagonaalinen oikea prisma muodostaa pohjan diagonaalin ja prisman korkeuden suorakulmainen kolmio. Vastaavasti Pythagoraan lauseen mukaan tietyn säännöllisen nelikulmaisen prisman diagonaali on yhtä suuri:
√((12√2) 2 + 14 2 ) = 22 cm

Vastaus: 22 cm

Tehtävä

Laske säännöllisen nelikulmaisen prisman kokonaispinta-ala, jos sen lävistäjä on 5 cm ja sivupinnan diagonaali on 4 cm.

Ratkaisu.
Koska säännöllisen nelikulmaisen prisman kanta on neliö, niin kannan sivu (merkitty a) löydetään Pythagoraan lauseella:

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

Sivupinnan korkeus (merkitty h:lla) on tällöin yhtä suuri:

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

Kokonaispinta-ala on yhtä suuri kuin sivupinta-alan ja kaksinkertaisen peruspinta-alan summa

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.

Vastaus: 25 + 10√7 ≈ 51,46 cm 2.

Autoja, joissa on manuaalivaihteisto, joka on lyhennetty manuaalivaihteistoksi, oli viime aikoihin asti ehdoton enemmistö muiden ajoneuvojen joukossa eri .

Lisäksi mekaaninen (manuaalinen) laatikko on edelleen melko yleinen laite moottorin vääntömomentin vaihtamiseen ja siirtämiseen nykyään. Seuraavaksi puhumme siitä, kuinka "mekaniikka" on järjestetty ja toimii, miltä tämän tyyppinen vaihdelaatikko näyttää sekä mitä etuja ja haittoja tällä ratkaisulla on.

Lue tästä artikkelista

Manuaalivaihteistokaavio ja ominaisuudet

Aluksi tämän tyyppistä vaihdelaatikkoa kutsutaan mekaaniseksi, koska tällainen yksikkö sisältää manuaalisen vaihteenvaihdon. Toisin sanoen manuaalivaihteistolla varustetuissa autoissa kuljettaja vaihtaa itse vaihteet.

Menemme pidemmälle. "Mekaniikka" -laatikko on porrastettu, eli vääntömomentti muuttuu portaittain. Monet autoilijat tietävät, että vaihteistossa on itse asiassa vaihteet ja akselit, mutta kaikki eivät ymmärrä yksikön toimintaa.

Joten vaihe (se on myös vaihteisto) on vaihdepari (ajo- ja vetovaihde), jotka ovat vuorovaikutuksessa toistensa kanssa. Jokainen tällainen vaihe tarjoaa pyörimisen yhdellä tai toisella kulmanopeudella, eli sillä on oma välityssuhde.

Välityssuhteella tulee ymmärtää käytettävän hammaspyörän hampaiden lukumäärän suhde vetopyörän hampaiden lukumäärään. Tässä tapauksessa laatikon eri vaiheet saavat erilaiset välityssuhteet. Alimmalla vaihteella (matalalla vaihteella) on suurin välityssuhde ja suurin korkea askel(ylösvaihteella) on pienin välityssuhde.

On selvää, että portaiden lukumäärä on sama kuin vaihteiden lukumäärä tietyssä laatikossa (nelivaihteinen vaihteisto, viisi vaihdetta jne.), joka oli aiemmin 4-vaihteinen mekaaniset laatikot varusteet häipyivät vähitellen taustalle.

Manuaalivaihteisto laite

Joten vaikka tällaisesta laatikosta voi olla monia malleja tietyillä ominaisuuksilla, alkuvaiheessa voidaan erottaa kaksi päätyyppiä:

  • kolmen akselin vaihdelaatikot;
  • kahden akselin laatikot;

Kolmiakselinen manuaalivaihteisto asennetaan yleensä takavetoisiin autoihin, kun taas kaksiakselinen vaihteisto sijoitetaan etuvetoisiin henkilöautoihin. Samanaikaisesti sekä ensimmäisen että toisen tyypin mekaanisten vaihdelaatikoiden laite voi erota huomattavasti.

Aloitetaan kolmiakselisesta mekaanisesta laatikosta. Tämä laatikko sisältää:

  • käyttöakseli, jota kutsutaan myös ensisijaiseksi;
  • väliakselin vaihdelaatikko;
  • vetävä akseli (toissijainen);

Akseleille on asennettu tahdistusvaihteet. Vaihteistoon kuuluu myös vaihdemekanismi. Määritetty osatekijät sijaitsee vaihdelaatikon kotelossa, jota kutsutaan myös vaihteistokoteloksi.

Vetoakselin tehtävänä on luoda yhteys kytkimeen. Vetoakselissa on kolot kytkinlevylle. Mitä tulee vääntömomenttiin, määrätty vääntömomentti tuloakselilta välittyy vaihteen kautta, joka on jäykässä kytkennässä sen kanssa.

Vaikuttaen väliakselin toimintaan, tämä akseli sijaitsee yhdensuuntaisesti vaihteiston tuloakselin kanssa, siihen on asennettu vaihteistoryhmä, joka on jäykässä kytkennässä. Vetävä akseli puolestaan ​​on asennettu samalle akselille kuin käyttöakseli.

Tällainen asennus toteutetaan käyttöakselin päätylaakerilla. Tämä laakeri sisältää käytettävän akselin. Vetävällä akselilla olevalla hammaspyöräryhmällä (vaihdelohko) ei ole jäykkää yhteyttä itse akseliin ja siksi se pyörii vapaasti sen päällä. Tässä tapauksessa väliakselin hammaspyöräryhmä, vetoakseli ja käyttöakselin hammaspyörä ovat jatkuvassa yhteydessä.

Synkronisaattorit (synkronisaattorikytkimet) asennetaan käytettävän akselin hammaspyörien väliin. Niiden tehtävänä on kohdistaa vetoakselin hammaspyörien kulmanopeudet itse akselin kulmanopeuteen kitkavoiman avulla.

Synkronoijat ovat jäykässä kytkennässä käytettävän akselin kanssa, ja niillä on myös mahdollisuus liikkua akselia pitkin pituussuunnassa rihlakytkennän ansiosta. Nykyaikaisissa vaihteistoissa on synkronointikytkimet kaikissa vaihteissa.

Jos tarkastellaan kolmiakselisten vaihteistojen vaihteistomekanismia, tämä mekanismi asennetaan usein yksikön runkoon. Suunnittelu sisältää ohjausvivun, liukusäätimet ja haarukat.

Laatikon runko (kampikammio) on valmistettu alumiinista tai magnesiumseoksista, se on välttämätön akselien asennuksessa vaihteilla ja mekanismeilla sekä useilla muilla osilla. Vaihteistokotelossa on myös vaihteistoöljyä (vaihteistoöljyä).

  • Ymmärtääksemme, kuinka kolmiakselinen mekaaninen (manuaalinen) vaihteisto toimii, katsotaanpa yleisesti ottaen Katsotaanpa, miten se toimii. Kun vaihdevipu on vapaa-asennossa, vääntömomentti ei siirry moottorista ajoneuvon vetopyörille.

Kun kuljettaja on siirtänyt vipua, haarukka siirtää yhden tai toisen vaihteen synkronointikytkintä. Synkronoija kohdistaa sitten kulmanopeudet haluttu vaihde ja vetoakseli. Sitten kytkimen hammasrengas kytkeytyy samanlaisen hammaspyörän kanssa, mikä varmistaa, että vaihde on lukittu käytettävälle akselille.

Lisäämme myös, että auton peruutusvaihde tarjoaa vaihdelaatikon peruutusvaihde. Tässä tapauksessa erilliseen akseliin asennettu peruutustyhjäkäyntivaihde mahdollistaa pyörimissuunnan vaihtamisen.

Kaksiakselinen manuaalivaihteisto: laite ja toimintaperiaate

Kun on käsitelty, mistä kolmiakselinen vaihteisto koostuu, siirrytään kaksiakselisiin vaihdelaatikoihin. Tämä tyyppi Vaihteistossa on kaksi akselia: ensisijainen ja toisio. Syöttöakseli on käyttöakseli, toisioakseli on käytettävä. Vaihteet ja synkronointilaitteet on kiinnitetty akseleihin. Myös laatikon kampikammiossa on päävaihde ja tasauspyörästö.

Vetoakseli on vastuussa kytkimeen kytkemisestä, ja akselilla on myös vaihteistolohko jäykässä kytkennässä akselin kanssa. Vetävä akseli sijaitsee samansuuntaisesti käyttöakselin kanssa, kun taas käytetyn akselin vaihteet ovat jatkuvassa kytkennässä käyttöakselin hammaspyörien kanssa ja pyörivät myös vapaasti itse akselilla.

Myös päävaihteen vetopyörä on jäykästi kiinnitetty käytettävälle akselille, ja synkronointikytkimet sijaitsevat vetävän akselin hammaspyörien välissä. Lisäämme vaihteiston koon pienentämiseksi ja vaihteiden lukumäärän lisäämiseksi nykyaikaisiin vaihteistoihin usein 2 tai jopa 3 akselia yhden vetoakselin sijasta.

Jokaisessa tällaisessa akselissa päävaihteen hammaspyörä on jäykästi kiinnitetty, kun taas sellaisella hammaspyörällä on jäykkä kytkentä käytettävään vaihteeseen. Osoittautuu, että suunnittelu todella toteuttaa 3 päävaihdetta.

Itse päävaihde sekä vaihteistolaitteen tasauspyörästö välittävät vääntömomentin toisioakselilta vetopyörille. Tässä tapauksessa tasauspyörästö voi myös aikaansaada tällaisen pyörien pyörimisen, kun vetopyörät pyörivät eri kulmanopeuksilla.

Mitä tulee vaihdemekanismiin, kaksiakselisissa vaihteistoissa se poistetaan erikseen, eli rungon ulkopuolelle. Laatikko on kytketty kytkentämekanismiin kaapeleilla tai erikoistangoilla. Yleisin liitäntä on kaapeleita.

Itse 2-akselisen laatikon vaihdemekanismissa on vipu, joka on kytketty kaapeleilla valintavivulle ja vaihdevivulle. Nämä vivut on kytketty keskivaihdetankoon, jossa on myös haarukat.

  • Jos puhumme kaksiakselisen manuaalisen vaihteiston toimintaperiaatteesta, se on samanlainen kuin kolmiakselisen vaihteiston periaate. Erot ovat siinä, kuinka vaihdemekanismi toimii. Lyhyesti sanottuna vipu voi suorittaa sekä pitkittäisiä että poikittaisia ​​liikkeitä suhteessa auton akseliin. Aikana poikittaisliike vaihteen valinta tapahtuu, kun voima kohdistetaan vaihteenvalitsinkaapeliin, joka vaikuttaa vaihteenvalitsinvipuun.

Lisäksi vipu liikkuu pituussuunnassa ja voima menee vaihdevaijeriin. Vastaava vipu siirtää karaa vaakasuunnassa haarukoiden kanssa, karassa oleva haarukka siirtää synkronointia, mikä johtaa vetoakselin vaihteiston tukkeutumiseen.

Lopuksi huomautamme, että myös mekaaniset laatikot eri tyyppejä niissä on ylimääräisiä estolaitteita, jotka estävät kahden vaihteen kytkemisen samanaikaisesti tai vaihteen odottamattoman poiskytkemisen.

Lue myös

Kytkimen painaminen ennen moottorin käynnistämistä: milloin kytkintä painetaan ja missä tapauksissa sitä ei suositella. Auttavia vihjeitä ja suosituksia.

  • Syitä vaikeaan vaihteenvaihtoon käynnissä olevassa moottorissa. Vaihteiston öljy ja taso vaihteistossa, laatikon synkronoijien ja vaihteiden kuluminen, kytkin.



    • AIHEESEEN LIITTYVÄT ARTIKKELIT