რომელიც ვიპოვე DataGenetics ვებსაიტზე. გთხოვთ, გამოაგზავნოთ ყველა შეცდომა ამ სტატიაში პირად შეტყობინებებში.

ამ პრობლემაში ციხეში 100 პატიმარია, თითოეული დანომრილი 1-დან 100-მდე. ციხის მცველი გადაწყვეტს მისცეს პატიმრებს გათავისუფლების შანსი, უყვება მათ ტესტის პირობებს და თუ ყველა პატიმარი გამოცდას ჩააბარებს, შემდეგ ისინი გაათავისუფლებენ. თუ ერთ-ერთი მათგანი მაინც ვერ ჩააბარებს გამოცდას, მაშინ ყველა პატიმარი მოკვდება.

დავალება

ციხის მცველი მიდის საიდუმლო ოთახიდა ამზადებს 100 ყუთს ხუფებით. თითოეულ კოლოფზე აღნიშნავს ციფრებს 1-დან 100-მდე. შემდეგ მოაქვს 100 ქაღალდის ტაბლეტი, პატიმართა რაოდენობის მიხედვით და ნომრავს ამ ტაბლეტებს 1-დან 100-მდე. სახურავის დახურვა. პატიმრები ვერ ხედავენ, როგორ ახორციელებს ციხის მბრძანებელი ყველა ამ მოქმედებას.

შეჯიბრი იწყება, ციხის მცველმა თითოეულ პატიმარს სათითაოდ მიჰყავს ყუთებით ოთახში და ეუბნება პატიმრებს, რომ უნდა იპოვონ ყუთი, რომელშიც განთავსებული იქნება ფირფიტა პატიმრის ნომრით. პატიმრები ყუთების გახსნით ცდილობენ თავიანთი ნომრის მქონე ფირფიტის პოვნას. თითოეულს აქვს 50-მდე ყუთის გახსნის უფლება; თუ თითოეული პატიმარი იპოვის თავის ნომერს, მაშინ პატიმრები გათავისუფლდებიან, თუ ერთი მათგანი მაინც ვერ იპოვის თავის ნომერს 50 მცდელობაში, მაშინ ყველა პატიმარი მოკვდება.

იმისათვის, რომ პატიმარი გათავისუფლდნენ, ყველა პატიმარმა წარმატებით უნდა გაიაროს ტესტი.

მაშ, რა არის შანსი, რომ პატიმრები შეიწყალონ?

• მას შემდეგ, რაც პატიმარი გახსნის ყუთს და შეამოწმებს თეფშს, ის ისევ ყუთში იდება და თავსახური ისევ იხურება;
• ფირფიტების ადგილების შეცვლა შეუძლებელია;
• სასამართლო პროცესის დაწყების შემდეგ პატიმრებს არ შეუძლიათ ერთმანეთისთვის მინიშნებების დატოვება ან რაიმე სახის ურთიერთობა ერთმანეთთან;
• პატიმრებს უფლება აქვთ განიხილონ სტრატეგია სასამართლო პროცესის დაწყებამდე.

რა არის საუკეთესო სტრატეგია პატიმრებისთვის?

დამატებითი კითხვა:

თუ პატიმართა მეგობარი (არ არის ტესტის მონაწილე) შეძლებს საიდუმლო ოთახში შესვლას ტესტის დაწყებამდე, შეამოწმეთ ყველა ტაბლეტი ყველა ყუთში და (სურვილისამებრ, მაგრამ არა სავალდებულო) შეცვალეთ ორი ტაბლეტი ორი ყუთიდან. (ამ შემთხვევაში ამხანაგს არ ექნება შესაძლებლობა ორივეს აცნობოს პატიმრებს თავისი ქმედებების შედეგი), მაშინ რა სტრატეგია უნდა მიმართოს მან პატიმრების გაქცევის შანსების გაზრდას?

გამოსავალი წარმოუდგენელია?

ერთი შეხედვით, ეს ამოცანა თითქმის უიმედო ჩანს. როგორც ჩანს, თითოეულ პატიმარს თავისი პლანშეტის პოვნის შანსი მიკროსკოპულად მცირეა. გარდა ამისა, სასამართლო პროცესის დროს პატიმრები ერთმანეთს ვერ უცვლიან ინფორმაციას.

ერთი პატიმრის შანსები 50:50-ია. სულ 100 ყუთია და მას შეუძლია 50-მდე ყუთი გახსნას თავისი ნიშნის მოსაძებნად. თუ ის ხსნის ყუთებს შემთხვევით და გახსნის ყველა ყუთის ნახევარს, ის იპოვის თავის ტაბლეტს ყუთების ღია ნახევარში, ან მისი ტაბლეტი დარჩება დახურულ 50 ყუთში. მისი წარმატების შანსი არის ½.

ავიღოთ ორი პატიმარი. თუ ორივე შემთხვევით აირჩევს ყუთებს, თითოეული მათგანის შანსი იქნება ½, ხოლო ორისთვის ½x½=¼.
(ორი პატიმრისთვის წარმატება ოთხიდან ერთ შემთხვევაში იქნება).

სამი პატიმრისთვის შანსებია ½ × ½ × ½ = ⅛.

100 პატიმრისთვის შანსებია: ½ × ½ × … ½ × ½ (გამრავლება 100-ჯერ).

ეს უდრის

Pr ≈ 0.00000000000000000000000000000008

ასე რომ, ძალიან მცირე შანსია. ამ სცენარში, დიდი ალბათობით, ყველა პატიმარი მკვდარი იქნება.

წარმოუდგენელი პასუხი

თუ თითოეული პატიმარი ხსნის ყუთებს შემთხვევით, ისინი ნაკლებად სავარაუდოა, რომ გაიარონ ტესტი. არსებობს სტრატეგია, სადაც პატიმრებს შეუძლიათ წარმატების მოლოდინი 30%-ზე მეტ დროს. ეს არის განსაცვიფრებლად წარმოუდგენელი შედეგი (თუ ამის შესახებ არ გსმენიათ მათემატიკის პრობლემაადრე).

30%-ზე მეტი 100-ვე პატიმარზე! დიახ, ეს კიდევ უფრო მეტია, ვიდრე ორი პატიმრის შანსები, იმ პირობით, რომ ისინი შემთხვევით გახსნიან ყუთებს. მაგრამ როგორ არის ეს შესაძლებელი?

გასაგებია, რომ თითო პატიმარზე ერთი, შანსები არ შეიძლება იყოს 50%-ზე მეტი (ბოლოს და ბოლოს, პატიმრებს შორის კომუნიკაციის საშუალება არ არსებობს). მაგრამ არ უნდა დაგვავიწყდეს, რომ ინფორმაცია ინახება ყუთების შიგნით ფირფიტების ადგილმდებარეობაში. არავინ არ არევს ტაბლეტებს ცალკეული პატიმრების ოთახში ვიზიტებს შორის, ამიტომ ჩვენ შეგვიძლია გამოვიყენოთ ეს ინფორმაცია.

გადაწყვეტილება

ჯერ გეტყვით გამოსავალს, შემდეგ აგიხსნით რატომ მუშაობს.

სტრატეგია ძალიან მარტივია. პატიმარებიდან პირველი ხსნის ყუთს, რომელზეც ტანსაცმელზე აწერია ნომერი. მაგალითად, პატიმარი ნომერი 78 ხსნის ყუთს ნომრით 78. თუ ის აღმოაჩენს თავის ნომერს ყუთში თეფშზე, ეს შესანიშნავია! თუ არა, ის ათვალიერებს თეფშზე დატანილ ნომერს „თავის“ ყუთში და შემდეგ ხსნის ამ ნომრის შემდეგ ყუთს. მეორე ყუთის გახსნის შემდეგ, ის ათვალიერებს ტაბლეტის ნომერს ამ ყუთში და ხსნის მესამე ყუთს ამ ნომრით. შემდეგ ჩვენ უბრალოდ გადავიტანთ ამ სტრატეგიას დანარჩენ უჯრებზე. სიცხადისთვის, შეხედეთ სურათს:

საბოლოოდ, პატიმარი ან იპოვის თავის ნომერს ან მიაღწევს 50 ყუთის ლიმიტს. ერთი შეხედვით, ეს უაზრო ჩანს ყუთის შემთხვევით არჩევასთან შედარებით (და ერთი ცალკეული პატიმრისთვის ეს ასეა), მაგრამ რადგან 100-ვე პატიმარი გამოიყენებს ყუთების ერთსა და იმავე კომპლექტს, აზრი აქვს.

ამის სილამაზე მათემატიკის პრობლემა- არა მხოლოდ შედეგის ცოდნა, არამედ იმის გაგებაც რატომეს სტრატეგია მუშაობს.

რატომ მუშაობს სტრატეგია?

თითოეული ყუთი შეიცავს ერთ ფირფიტას - და ეს ფირფიტა უნიკალურია. ეს ნიშნავს, რომ ფირფიტა არის იმავე ნომრის ყუთში, ან ის მიუთითებს სხვა ყუთზე. ვინაიდან ყველა ფირფიტა უნიკალურია, თითოეული ყუთისთვის არის მხოლოდ ერთი ფირფიტა, რომელიც მიუთითებს მასზე (და მხოლოდ ერთი გზა ამ ყუთამდე მისასვლელად).

თუ დაფიქრდებით, ყუთები ქმნიან დახურულ წრიულ ჯაჭვს. ერთი ყუთი შეიძლება იყოს მხოლოდ ერთი ჯაჭვის ნაწილი, რადგან ყუთის შიგნით არის მხოლოდ ერთი მაჩვენებელი მომდევნოზე და, შესაბამისად, წინა ყუთში არის მხოლოდ ერთი მაჩვენებელი ამ უჯრაზე (პროგრამებს შეუძლიათ ნახონ ანალოგია დაკავშირებული სიებით).

თუ ყუთი არ მიუთითებს თავისკენ (ყუთის ნომერი უდრის მასში არსებული ფირფიტის ნომერს), მაშინ ის იქნება ჯაჭვში. ზოგიერთი ჯაჭვი შეიძლება შედგებოდეს ორი ყუთისგან, ზოგი უფრო გრძელია.

ვინაიდან ყველა პატიმარი იწყებს ტანსაცმლის ერთნაირი ნომრის ყუთით, ისინი, განსაზღვრებით, მოთავსებულია ჯაჭვზე, რომელიც შეიცავს მათ სახელწოდებას (ამ უჯრაზე მიუთითებს მხოლოდ ერთი სახელწოდება).

ამ ჯაჭვის გასწვრივ მდებარე ყუთების წრეში შესწავლისას, ისინი გარანტირებულია, რომ საბოლოოდ იპოვიან თავიანთ ფირფიტას.

ერთადერთი კითხვა რჩება, იპოვიან თუ არა თავიანთ ტაბლეტს 50 სვლით.

ჯაჭვის სიგრძე

იმისათვის, რომ ყველა პატიმარმა გაიაროს ტესტი, ჯაჭვის მაქსიმალური სიგრძე უნდა იყოს 50 ყუთზე ნაკლები. თუ ჯაჭვი 50 ყუთზე მეტია, ამ ჯაჭვების ნომრის მქონე პატიმრები ვერ ჩააბარებენ გამოცდას - და ყველა პატიმარი მოკვდება.

თუ ყველაზე გრძელი ჯაჭვის მაქსიმალური სიგრძე 50 ყუთზე ნაკლებია, მაშინ ყველა პატიმარი გაივლის გამოცდას!

დაფიქრდი ამაზე ერთი წამით. გამოდის, რომ ფირფიტების ნებისმიერ განლაგებაში შეიძლება იყოს მხოლოდ ერთი ჯაჭვი, რომელიც 50 ყუთზე გრძელია (ჩვენ გვაქვს მხოლოდ 100 ყუთი, ასე რომ, თუ ერთი ჯაჭვი 50-ზე გრძელია, მაშინ დანარჩენი იქნება 50-ზე მოკლე).

გრძელი ჯაჭვის ხელის შანსები

მას შემდეგ რაც დარწმუნდებით, რომ ჯაჭვის მაქსიმალური სიგრძე უნდა იყოს 50-ზე ნაკლები ან ტოლი წარმატების მისაღწევად, და შეიძლება იყოს მხოლოდ ერთი გრძელი ჯაჭვი ნებისმიერ კომპლექტში, ჩვენ შეგვიძლია გამოვთვალოთ გამოწვევის გავლის ალბათობა:

კიდევ ცოტა მათემატიკა

მაშ, რა გვჭირდება გრძელი ჯაჭვის ალბათობის გასარკვევად?

l სიგრძის ჯაჭვისთვის ალბათობა იმისა, რომ ყუთები ამ ჯაჭვის გარეთ იქნება:

არის (l-1) რიცხვების ამ კრებულში! ნიშნების მოწყობის გზები.

დარჩენილი ნიშნები შეიძლება განთავსდეს (100-ლ)! გზები (არ დაგავიწყდეთ, რომ ჯაჭვის სიგრძე არ აღემატება 50-ს).

ამის გათვალისწინებით, პერმუტაციების რაოდენობა, რომელიც შეიცავს ჯაჭვს ზუსტი სიგრძელ: (>50)

გამოდის, რომ არსებობს ფირფიტების მოწყობის 100(!) გზა, რომ l სიგრძის ჯაჭვის არსებობის ალბათობა უდრის 1/ლ-ს. სხვათა შორის, ეს შედეგი არ არის დამოკიდებული ყუთების რაოდენობაზე.

როგორც უკვე ვიცით, შეიძლება იყოს მხოლოდ ერთი შემთხვევა, როდესაც არსებობდეს ჯაჭვი სიგრძით > 50, ამიტომ წარმატების ალბათობა გამოითვლება ამ ფორმულით:

შედეგი

31,18% - ალბათობა იმისა, რომ ყველაზე გრძელი ჯაჭვის ზომა 50-ზე ნაკლები იქნება და თითოეული პატიმარი შეძლებს თავისი ფირფიტის პოვნას, 50 მცდელობის ლიმიტის გათვალისწინებით.

ალბათობა იმისა, რომ ყველა პატიმარი იპოვის თეფშს და გაივლის გამოცდას არის 31,18%.

ქვემოთ მოცემულია დიაგრამა, რომელიც აჩვენებს ალბათობას (y ღერძზე) l სიგრძის ყველა ჯაჭვისთვის (x ღერძზე). წითელი ნიშნავს ყველა "ჩავარდნას" (მოცემული მრუდი აქ არის მხოლოდ 1/ლ ნაკვეთი). მწვანე ფერინიშნავს "წარმატებას" (გრაფიკის ამ ნაწილისთვის გამოთვლა ცოტა უფრო რთულია, რადგან დადგენის რამდენიმე გზა არსებობს მაქსიმალური სიგრძე <50). Общая вероятность складывается из зеленых столбцов в 31.18% шанс на спасение.

ჰარმონიული ნომერი (სტატიის ეს ნაწილი გეიკებისთვისაა)

მათემატიკაში n-ე ჰარმონიული რიცხვი არის ბუნებრივი რიგის პირველი n ზედიზედ რიცხვების საპასუხო ჯამი.

გამოვთვალოთ ლიმიტი, თუ 100a უჯრის ნაცვლად გვაქვს თვითნებური დიდი რიცხვიყუთები (დავუშვათ, რომ სულ გვაქვს 2n ყუთი).

ეილერ-მასკერონის მუდმივა არის მუდმივი, რომელიც განისაზღვრება, როგორც სხვაობის ზღვარი ჰარმონიული რიგის ნაწილობრივ ჯამსა და რიცხვის ბუნებრივ ლოგარითმს შორის.

პატიმართა რიცხვის მატებასთან ერთად, თუ ზედამხედველი პატიმრებს საშუალებას აძლევს გახსნან ყუთების ნახევარი, მაშინ გადარჩენის შანსი 30,685%-მდეა.

(თუ თქვენ მიიღებთ გადაწყვეტილებას, რომლითაც პატიმრები შემთხვევით გამოიცნობენ ყუთებს, მაშინ როცა პატიმრების რაოდენობა იზრდება, გადარჩენის ალბათობა ნულისკენ მიისწრაფვის!)

დამატებითი კითხვა

კიდევ ვინმეს გახსოვთ დამატებითი შეკითხვა? რა შეუძლია გააკეთოს ჩვენმა დამხმარე ამხანაგმა გადარჩენის შანსების გასაზრდელად?

ახლა ჩვენ უკვე ვიცით გამოსავალი, ამიტომ სტრატეგია აქ მარტივია: მან უნდა გამოიკვლიოს ყველა ნიშანი და მოძებნოს ყუთების ყველაზე გრძელი ჯაჭვი. თუ ყველაზე გრძელი ჯაჭვი 50-ზე ნაკლებია, მაშინ მას საერთოდ არ სჭირდება ტაბლეტების შეცვლა ან შეცვლა ისე, რომ ყველაზე გრძელი ჯაჭვი 50-ზე გრძელი არ გახდეს. თუმცა, თუ ის აღმოაჩენს 50 ყუთზე მეტ ჯაჭვს, მას მხოლოდ უნდა შეცვალოს ორი ყუთის შიგთავსი ამ ჯაჭვიდან, რომ ეს ჯაჭვი ორ მოკლე ჯაჭვად დაშალოს.

ამ სტრატეგიის შედეგად არ იქნება გრძელი ჯაჭვები და ყველა პატიმარს გარანტირებული აქვს თავისი ნიშნის პოვნა და ხსნა. ასე რომ, ორი ნიშნის გაცვლით ხსნის ალბათობას 100%-მდე ვამცირებთ!

გახსოვდეთ, რომ კუბოიდის (ან ჩვეულებრივი ყუთის) მოცულობა უდრის მისი სიგრძის, სიგანისა და სიმაღლის ნამრავლს. თუ თქვენი ყუთი მართკუთხა ან კვადრატულია, ყველაფერი რაც თქვენ უნდა იცოდეთ არის მისი სიგრძე, სიგანე და სიმაღლე. მოცულობის მისაღებად საჭიროა გაზომვის შედეგების გამრავლება. გაანგარიშების ფორმულა შემოკლებული ფორმით ხშირად წარმოდგენილია შემდეგნაირად: V \u003d L x W x H.
პრობლემის მაგალითი: "თუ ყუთის სიგრძეა 10 სმ, სიგანე 4 სმ და სიმაღლე 5 სმ, მაშინ რა არის მისი მოცულობა?"
V = L x W x H
V=10სმx4სმx5სმ
V \u003d 200 სმ 3
ყუთის "სიმაღლე" შეიძლება ეწოდოს "სიღრმეს". მაგალითად, დავალება შეიძლება შეიცავდეს შემდეგ ინფორმაციას: "ყუთის სიგრძეა 10 სმ, სიგანე 4 სმ და სიღრმე 5 სმ."

2
გაზომეთ ყუთის სიგრძე. თუ ყუთს ზემოდან შეხედავთ, ის თქვენს თვალწინ მართკუთხედის სახით გამოჩნდება. ყუთის სიგრძე იქნება ამ მართკუთხედის ყველაზე გრძელი მხარე. ჩაწერეთ ამ მხარის გაზომვის შედეგი, როგორც "სიგრძის" პარამეტრის მნიშვნელობა.
დარწმუნდით, რომ გამოიყენოთ იგივე საზომი ერთეული გაზომვისას. თუ თქვენ გაზომეთ ერთი მხარე სანტიმეტრებში, მაშინ მეორე მხარეც უნდა გაიზომოს სანტიმეტრებში.

3
გაზომეთ ყუთის სიგანე. ყუთის სიგანე წარმოდგენილი იქნება ზემოდან ხილული მართკუთხედის მეორე, უფრო მოკლე გვერდით. თუ თქვენ ვიზუალურად დააკავშირებთ ყუთის გვერდებს სიგრძით და სიგანეში, მაშინ ისინი გამოჩნდებიან ასო "G"-ს სახით. ჩაწერეთ ბოლო გაზომვის მნიშვნელობა, როგორც "სიგანე".
სიგანე ყოველთვის არის ყუთის მოკლე მხარე.

4
გაზომეთ ყუთის სიმაღლე. ეს არის ბოლო პარამეტრი, რომელიც ჯერ არ გაგიზომავთ. იგი წარმოადგენს მანძილს ყუთის ზედა კიდიდან ქვემომდე. ჩაწერეთ ამ გაზომვის მნიშვნელობა, როგორც "სიმაღლე".
იმისდა მიხედვით, თუ რომელ მხარეს აყენებთ ყუთს, კონკრეტული გვერდები, რომლებსაც „სიგრძე“, „სიგანე“ ან „სიმაღლე“ ასახელებთ, შეიძლება განსხვავებული იყოს. თუმცა, არ აქვს მნიშვნელობა, თქვენ უბრალოდ გჭირდებათ გაზომვები სამი სხვადასხვა მხრიდან.

5
გაამრავლეთ სამი გაზომვის შედეგი ერთად. როგორც უკვე აღვნიშნეთ, მოცულობის გამოთვლის ფორმულა ასეთია: V = სიგრძე x სიგანე x სიმაღლე; ამიტომ, მოცულობის მისაღებად, თქვენ უბრალოდ უნდა გაამრავლოთ სამივე მხარე. დარწმუნდით, რომ მიუთითეთ ერთეულები, რომლებიც გამოიყენეთ გაანგარიშებაში, რათა არ დაგავიწყდეთ, რას ნიშნავს ეს მნიშვნელობები.

6
მოცულობის ერთეულების მითითებისას არ დაგავიწყდეთ მიუთითოთ მესამე სიმძლავრე " 3". გამოთვლილ მოცულობას აქვს რიცხვითი გამოხატულება, მაგრამ საზომი ერთეულების სწორი მითითების გარეშე, თქვენი გამოთვლები უაზრო იქნება. მოცულობის ერთეულების სწორად ასახვისთვის, ისინი უნდა იყოს მითითებული კუბში. მაგალითად, თუ ყველა მხარე გაიზომებოდა სანტიმეტრებში, მაშინ მოცულობის ერთეულები მითითებული იქნება როგორც "სმ3".
პრობლემის მაგალითი: "თუ ყუთს აქვს სიგრძე 2 მ, სიგანე 1 მ და სიმაღლე 3 მ, მაშინ რა არის მისი მოცულობა?"
V = L x W x H
V = 2 მ x 1 მ x 4 მ
V \u003d 8 მ 3
შენიშვნა: მოცულობის კუბური ერთეულის მითითება საშუალებას გაძლევთ გაიგოთ რამდენი ასეთი კუბი შეიძლება განთავსდეს ყუთში. თუ წინა მაგალითს მივმართავთ, ეს ნიშნავს, რომ ყუთში რვა კუბური მეტრია მოთავსებული.

სხვა ფორმის ყუთების მოცულობის გაანგარიშება

განსაზღვრეთ ცილინდრის მოცულობა. ცილინდრი არის მრგვალი მილი, რომელსაც აქვს წრეები ორივე ბოლოში. ცილინდრის მოცულობის დასადგენად გამოიყენება ფორმულა: V = π x r 2 x h, სადაც π = 3,14, r არის ცილინდრის მრგვალი მხარის რადიუსი და h არის მისი სიმაღლე.
კონუსის, ან პირამიდის მოცულობის დასადგენად მრგვალი ფუძით, გამოიყენება იგივე ფორმულა, მაგრამ გამრავლებული 1/3-ზე. ანუ, კონუსის მოცულობა გამოითვლება ფორმულით: V = 1/3 (π x r 2 x h)

2
დაადგინეთ პირამიდის მოცულობა. პირამიდა არის ფიგურა, რომელსაც აქვს ბრტყელი ფუძე და გვერდები ზევით ერთ წერტილში იყრის თავს. პირამიდის მოცულობის დასადგენად, თქვენ უნდა აიღოთ მისი ფუძისა და სიმაღლის ფართობის პროდუქტის 1/3. ანუ, გამოთვლის ფორმულა ასეთია: პირამიდის მოცულობა = 1/3 (ბაზის ფართობი x სიმაღლე).
უმეტეს შემთხვევაში, პირამიდებს აქვთ კვადრატული ან მართკუთხა საფუძველი. ასეთ ვითარებაში, ბაზის ფართობი გამოითვლება ბაზის სიგრძის სიგანეზე გამრავლებით.

რთული ფორმების ყუთის მოცულობის დასადგენად, დაამატეთ მისი ცალკეული ნაწილების მოცულობა. მაგალითად, შეიძლება დაგჭირდეთ ასო "L" მსგავსი ფორმის ყუთის მოცულობის გაზომვა. ამ შემთხვევაში, ყუთს უფრო მეტი მხარე ექნება გასაზომად. თუ ამ უჯრას ორ ნაწილად გაყოფთ, შეგიძლიათ ამ ორი ნაწილის მოცულობა სტანდარტულად გაზომოთ და შემდეგ დაამატოთ მიღებული მნიშვნელობები. L-ის ფორმის ყუთის შემთხვევაში გრძელი ნაწილი შეიძლება ჩაითვალოს ცალკე გრძელ ოთხკუთხა ყუთად, ხოლო მოკლე ნაწილი მასზე დამაგრებულ კვადრატულ (ან თითქმის კვადრატულ) ყუთად.
თუ თქვენს ყუთს აქვს ძალიან რთული ფორმები, მაშინ იცოდეთ, რომ არსებობს მრავალი გზა ნებისმიერი ფორმის ობიექტების მოცულობის დასადგენად.

დაწერეთ პროგრამა, რომელიც ადარებს კლავიატურიდან შეყვანილ ორ მთელ რიცხვს. პროგრამამ უნდა მიუთითოს რომელი რიცხვია მეტი, ან, თუ რიცხვები ტოლია, აჩვენოს შესაბამისი შეტყობინება.

ჩაწერეთ ორი მთელი რიცხვი და დააჭირეთ Enter.
-> 34 67
34-ით ნაკლები 67-ზე

Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურის ძირითადი არის A, B: მთელი რიცხვი; start Put_Line("შეიყვანეთ ორი მთელი რიცხვი ერთ ხაზზე და დააჭირეთ Enter."); put("->"); მიიღეთ (A); მიიღეთ (B); --შეიყვანეთ 2 რიცხვი, თუ A > B მაშინ Put(Item =>; A, Width =>; 1); put("უმეტეს"); Put( Item => B, Width => 1); ელსიფ ა< B then Put(Item =>A, სიგანე => 1); put("ნაკლები"); Put( Item => B, Width => 1); else Put ("შეყვანილი რიცხვები ტოლია!"); დაასრულე თუ; დასასრული მთავარი;

მოცემულია სამი მთელი რიცხვი. იპოვეთ მათგან ყველაზე დიდი (პროგრამამ უნდა გამოიტანოს ზუსტად ერთი მთელი რიცხვი). ყველაზე დიდი ამ პრობლემაში გაგებულია, როგორც რიცხვი, რომელიც არ არის სხვაზე ნაკლები.

• 
  -> 1 2 3
  მაქსიმუმ სამი ნომერი: 3

• Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურის ძირითადი არის A, B, C: მთელი რიცხვი; max: მთელი რიცხვი; დაწყება Put_Line( "შეიყვანეთ სამი მთელი რიცხვი ერთ ხაზზე და დააჭირეთ Enter.") ; Put("->"); მიიღეთ (A); მიიღეთ(B) ; მიიღეთ (C); -- შეიყვანეთ სამი მთელი რიცხვი max:=A; -- ნაგულისხმევიმიგვაჩნია, რომ რიცხვი A არის მაქსიმალურითუ B > max მაშინ --თუ B მეტია მაქსიმუმზე, მაშინ max:=B; --მაქსიმალური რიცხვია Bდაასრულე თუ ; თუ C > max მაშინ --თუ C მეტია მაქსიმუმზე, მაშინ max:=C; --მაქსიმალური რიცხვია Cდაასრულე თუ ; Დადება( "მაქსიმუმ სამი ნომერი:"& მთელი რიცხვი"image(max)); ბოლო მთავარი;

  Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურის ძირითადი არის A, B, C: მთელი რიცხვი; max: მთელი რიცხვი; start Put_Line("შეიყვანეთ სამი მთელი რიცხვი ერთ ხაზზე და დააჭირეთ Enter."); put("->"); მიიღეთ (A); მიიღეთ (B); მიიღეთ (C); --შეიყვანეთ მაქსიმუმ სამი მთელი რიცხვი:= A; --ნაგულისხმევად, ჩვენ ვივარაუდებთ, რომ რიცხვი A არის მაქსიმალური, თუ B > max მაშინ --თუ B მეტია მაქსიმუმზე, მაშინ max:= B; --მაქსიმალური რიცხვია B დასასრული თუ; თუ C > max მაშინ --თუ C მეტია max-ზე, მაშინ max:= C; --მაქსიმალური რიცხვი უდრის C ბოლოს თუ; Put("მაქსიმუმ სამი რიცხვი:" & მთელი"image(max)); დასასრული main;

მოცემულია სამი ნატურალური რიცხვები A, B, C. დაადგინეთ არის თუ არა სამკუთხედი ამ გვერდებთან. თუ სამკუთხედი არსებობს, დაბეჭდეთ შეტყობინება, რომ ასეთი გვერდების მქონე სამკუთხედი არსებობს, წინააღმდეგ შემთხვევაში დაბეჭდეთ, რომ სამკუთხედი არ არსებობს.

• ჩაწერეთ სამკუთხედის სამი გვერდი და დააჭირეთ Enter.
  -> 3 4 5
  არსებობს სამკუთხედი გვერდებით 3, 4, 5.

სამკუთხედი არის სამი წერტილი, რომლებიც არ დევს იმავე წრფეზე. სამკუთხედი მხოლოდ მაშინ არსებობს, თუ მისი რომელიმე ორი გვერდის ჯამი მესამეზე მეტია.

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; -- მთელი რიცხვების წასაკითხად Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; -- სტრიქონების ჩვენებაპროცედურის ძირითადი არის a, b, c: მთელი რიცხვი; დაწყება Put_Line( "შეიყვანეთ სამკუთხედის სამი გვერდი და დააჭირეთ Enter.Enter.") ; Put("->"); მიიღეთ(ა); მიიღეთ(ბ) ; მიიღეთ(c); -- წაიკითხეთ სამკუთხედის გვერდებითუ a + b > c და შემდეგ b + c > a და შემდეგ c + a > b მაშინ --შეამოწმეთ ყველა პირობა ერთ ხაზზეᲓადება( "სამკუთხედი გვერდებით"& მთელი რიცხვი"image(a) & "," & მთელი"image(b) & "," & Integer"image(c) & "არსებობს") ; else Put( "სამკუთხედი გვერდებით"& მთელი რიცხვი"image(a) & "," & Integer"image(b) & "," & Integer"image(c) & " არ არსებობს"); ბოლოს თუ ; ბოლოს მთავარი;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; --მთლიანი რიცხვების წაკითხვა Ada.Text_IO-ით; გამოიყენეთ Ada.Text_IO; --სტრიქონების დასაბეჭდად მთავარი პროცედურაა a, b, c: მთელი რიცხვი; start Put_Line("შეიყვანეთ სამკუთხედის სამი გვერდი და დააჭირეთ Enter.Enter."); put("->"); მიიღეთ (ა); მიიღეთ (ბ); მიიღეთ (გ); -- წაიკითხეთ სამკუთხედის გვერდები, თუ a + b > c და შემდეგ b + c > a და შემდეგ c + a > b შემდეგ -- შეამოწმეთ ყველა პირობა ერთ ხაზში Put("სამკუთხედი გვერდებით" & მთელი რიცხვი"image(a) & " ," & მთელი რიცხვი"სურათი(ბ) & "," & მთელი"სურათი(გ) & "არსებობს"); else Put("სამკუთხედი გვერდებით" & მთელი რიცხვი"image(a) & "," & მთელი"სურათი( ბ) & "," & მთელი რიცხვი"სურათი(გ) & " არ არსებობს"); დაასრულე თუ; დასასრული მთავარი;

მოცემულია სამი მთელი რიცხვი. დაადგინეთ რამდენი მათგანი ემთხვევა. პროგრამამ უნდა გამოიტანოს ერთი რიცხვი: 3 (თუ ყველა ერთნაირია), 2 (თუ ორი ერთნაირია) ან 0 (თუ ყველა განსხვავებულია).

• ჩაწერეთ სამი მთელი რიცხვი და დააჭირეთ Enter.
  -> 1 2 3
  0

• Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია A, B, C: მთელი რიცხვი; დაწყება Put_Line( "შეიყვანეთ სამი მთელი რიცხვი და დააჭირეთ Enter.") ; Put("->"); მიიღეთ (A); მიიღეთ(B) ; მიიღეთ (C); თუ A = B და შემდეგ A = C მაშინ --თუ სამივე რიცხვი ემთხვევა Put( Item => 3 , Width => 1 ); elsif A = B ან A = C ან B = C მაშინ --თუ ორი რიცხვი ემთხვევა Put( Item => 2 , Width => 1 ); სხვა --Თუ იგივე ნომრებიარა Put( Item => 0 , Width => 1 ); დაასრულე თუ ; endMain;

  Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია A, B, C: მთელი რიცხვი; start Put_Line("შეიყვანეთ სამი მთელი რიცხვი და დააჭირეთ Enter."); put("->"); მიიღეთ (A); მიიღეთ (B); მიიღეთ (C); თუ A = B და შემდეგ A = C მაშინ --თუ სამივე რიცხვი ემთხვევა Put(Item => 3, Width => 1); elsif A = B ან A = C ან B = C მაშინ --თუ ორი რიცხვი ემთხვევა Put(Item => 2, Width => 1); else --თუ არ არის იდენტური რიცხვები Put(Item => 0, Width => 1); დაასრულე თუ; endMain;

ჭადრაკის ღერი მოძრაობს ჰორიზონტალურად ან ვერტიკალურად. მოცემული ორი სხვადასხვა უჯრედები ჭადრაკის დაფადაადგინეთ, შეუძლია თუ არა როკს გადაადგილება პირველი უჯრედიდან მეორეზე ერთი ნაბიჯით. პროგრამა შეყვანის სახით იღებს ოთხ რიცხვს 1-დან 8-მდე, სადაც მითითებულია სვეტის ნომერი და მწკრივის ნომერი, ჯერ პირველი უჯრედისთვის, შემდეგ მეორე უჯრედისთვის. პროგრამამ უნდა დაბეჭდოს "დიახ", თუ შესაძლებელია პირველი უჯრედიდან მეორეზე მოხვედრა როკის მოძრაობით, ან "არა" წინააღმდეგ შემთხვევაში.

• 
  4 4
  5 5
  არა

• ) ; Დადება() ; მიიღეთ (A); მიიღეთ(B) ; Დადება() ; მიიღეთ (C); მიიღეთ(D); თუ A = C ან B = D მაშინ Put("YES"); else Put("NO" ); დაასრულე თუ ; endMain;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა Main არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1..8; A, B, C, D: გამშვები დაფა; start Put_Line("შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:"); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: "); მიიღეთ (A); მიიღეთ (B); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: "); მიიღეთ (C); მიიღეთ(D); თუ A = C ან B = D მაშინ Put("YES"); else Put("NO"); დაასრულე თუ; endMain;

ჭადრაკის მეფე მოძრაობს ჰორიზონტალურად, ვერტიკალურად და დიაგონალზე, მაგრამ მხოლოდ 1 კვადრატში. ჭადრაკის დაფაზე ორი განსხვავებული უჯრედის გათვალისწინებით, დაადგინეთ, შეუძლია თუ არა მეფეს ერთი სვლით პირველი უჯრედიდან მეორეზე გადასვლა. პროგრამა შეყვანის სახით იღებს ოთხ რიცხვს 1-დან 8-მდე, სადაც მითითებულია სვეტის ნომერი და მწკრივის ნომერი, ჯერ პირველი უჯრედისთვის, შემდეგ მეორე უჯრედისთვის. პროგრამამ უნდა დაბეჭდოს "დიახ", თუ შესაძლებელია მეფის სვლით პირველი უჯრედიდან მეორეზე მოხვედრა, ან სხვაგვარად "არა".

• შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
  შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 4 4
  შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 5 5
  დიახ

• "შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:") ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (A); მიიღეთ(B) ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (C); მიიღეთ(D); თუ აბს (A - C)<= 1 and then abs (B - D) <= 1 then -- abs() ბრძანება აბრუნებს აბსოლუტს -- რიცხვის მნიშვნელობა (მოდული). Put ("YES"); else Put("NO" ); დაასრულე თუ ; დასასრული მთავარი;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურის main არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1..8; A, B, C, D: გამშვები დაფა; start Put_Line("შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:"); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: "); მიიღეთ (A); მიიღეთ (B); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: "); მიიღეთ (C); მიიღეთ(D); თუ აბს (A - C)<= 1 and then abs(B - D) <= 1 then -- команда abs() возвращает абсолютное --значение (модуль) числа Put("ДА"); else Put("НЕТ"); end if; end main;

ჭადრაკის ეპისკოპოსი დიაგონალზე მოძრაობს. ჭადრაკის დაფის ორი განსხვავებული უჯრედის გათვალისწინებით, დაადგინეთ, შეუძლია თუ არა ეპისკოპოსს ერთი სვლით პირველი უჯრედიდან მეორეზე გადასვლა. პროგრამა შეყვანის სახით იღებს ოთხ რიცხვს 1-დან 8-მდე, სადაც მითითებულია სვეტის ნომერი და მწკრივის ნომერი, ჯერ პირველი უჯრედისთვის, შემდეგ მეორე უჯრედისთვის. პროგრამამ უნდა გამოაქვეყნოს "დიახ", თუ შესაძლებელია ეპისკოპოსის სვლით პირველი უჯრედიდან მეორეზე მოხვედრა, ან სხვაგვარად "არა".

• შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
  შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 4 4
  შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 5 5
  დიახ

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა main არის ქვეტიპი checkBoard არის მთელი რიცხვი დიაპაზონი 1 ..8 ; A, B, C, D: გამშვები დაფა; დაწყება Put_Line( "შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:") ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (A); მიიღეთ(B) ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (C); მიიღეთ(D); თუ abs (a - c) = abs (b - d) მაშინ Put("YES" ); else Put("NO" ); დაასრულე თუ ; დასასრული მთავარი;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურის main არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1..8; A, B, C, D: გამშვები დაფა; start Put_Line("შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:"); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: "); მიიღეთ (A); მიიღეთ (B); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: "); მიიღეთ (C); მიიღეთ(D); თუ abs(a - c) = abs(b - d) მაშინ Put("YES"); else Put("NO"); დაასრულე თუ; დასასრული მთავარი;

ჭადრაკის დედოფალი მოძრაობს დიაგონალურად, ჰორიზონტალურად ან ვერტიკალურად. ჭადრაკის დაფის ორი განსხვავებული უჯრედის გათვალისწინებით, დაადგინეთ, შეუძლია თუ არა დედოფალს ერთი სვლით პირველი უჯრედიდან მეორეზე გადასვლა.

მონაცემთა შეყვანის ფორმატი:
პროგრამა შეყვანის სახით იღებს ოთხ რიცხვს 1-დან 8-მდე, სადაც მითითებულია სვეტის ნომერი და მწკრივის ნომერი, ჯერ პირველი უჯრედისთვის, შემდეგ მეორე უჯრედისთვის.
Გამავალი ფორმატი:
პროგრამამ უნდა გამოიტანოს YES, თუ შესაძლებელია პირველი უჯრედიდან მეორეზე გადასვლა დედოფლის მოძრაობით, ან სხვაგვარად არა.

მაგალითი 1:
შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 1 1
შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 2 2
დიახ

მაგალითი 2:
შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 1 1
შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 2 3
არა

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა მთავარი არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1 ..8; A, B, C, D: გამშვები დაფა; დაწყება Put_Line( "შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:") ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (A); მიიღეთ(B) ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (C); მიიღეთ(D); თუ abs (A - C) = abs (B - D) ან A = D ან B = C, მაშინ Put("YES"); else Put("NO" ); დაასრულე თუ ; endMain;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა Main არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1..8; A, B, C, D: გამშვები დაფა; start Put_Line("შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:"); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: "); მიიღეთ (A); მიიღეთ (B); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: "); მიიღეთ (C); მიიღეთ(D); თუ abs(A - C) = abs(B - D) ან A = D ან B = C მაშინ Put("YES"); else Put("NO"); დაასრულე თუ; endMain;

ჭადრაკის ცხენი მოძრაობს ასო "G" - ორი კვადრატი ვერტიკალურად ნებისმიერი მიმართულებით და ერთი კვადრატი ჰორიზონტალურად, ან პირიქით. ჭადრაკის დაფის ორი განსხვავებული უჯრედის გათვალისწინებით, დაადგინეთ, შეუძლია თუ არა რაინდს ერთი სვლით პირველი უჯრედიდან მეორეზე გადასვლა. პროგრამა შეყვანის სახით იღებს ოთხ რიცხვს 1-დან 8-მდე, სადაც მითითებულია სვეტის ნომერი და მწკრივის ნომერი, ჯერ პირველი უჯრედისთვის, შემდეგ მეორე უჯრედისთვის. პროგრამამ უნდა გამოიტანოს YES, თუ რაინდს შეუძლია გადავიდეს პირველი უჯრედიდან მეორეზე, ან სხვაგვარად არა.

მაგალითი 1:
შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 1 1
შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 1 4
არა

მაგალითი 2:
შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:
შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: 1 1
შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: 8 8
არა

• Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა main არის ქვეტიპი checkBoard არის მთელი რიცხვი დიაპაზონი 1 ..8 ; A, B, C, D: მთელი რიცხვი; დაწყება Put_Line( "შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:") ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (A); მიიღეთ(B) ; Დადება( "შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ:") ; მიიღეთ (C); მიიღეთ(D); თუ abs (A - C) = 2 და შემდეგ abs (B - D) = 1, მაშინ Put("YES"); elsif abs (A - C) = 1 და შემდეგ abs (B - D) = 2 შემდეგ Put("YES"); else Put("NO" ); დაასრულე თუ ; დასასრული მთავარი;

  Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურის main არის ქვეტიპი checkBoard არის მთელი დიაპაზონი 1..8; A, B, C, D: მთელი რიცხვი; start Put_Line("შეიყვანეთ სვეტების და მწკრივების ნომრები ორი უჯრედისთვის:"); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები პირველი უჯრედისთვის და დააჭირეთ: "); მიიღეთ (A); მიიღეთ (B); Put("შეიყვანეთ სვეტისა და მწკრივის ნომრები მეორე უჯრედისთვის და დააჭირეთ: "); მიიღეთ (C); მიიღეთ(D); თუ abs(A - C) = 2 და შემდეგ abs(B - D) = 1 მაშინ Put("YES"); elsif abs(A - C) = 1 და შემდეგ abs(B - D) = 2 შემდეგ Put("YES"); else Put("NO"); დაასრულე თუ; დასასრული მთავარი;

შოკოლადს აქვს მართკუთხედის ფორმა დაყოფილი N×M ნაჭრებად. შოკოლადი შეიძლება დაიყოს ერთხელ სწორი ხაზით ორ ნაწილად. დაადგინეთ, შესაძლებელია თუ არა ამ გზით K ნაჭრების ამოღება შოკოლადის ფილიდან. პროგრამა შეყვანის სახით იღებს სამ რიცხვს: N, M, K. პროგრამამ უნდა გამოიტანოს ორი სიტყვიდან ერთი: "დიახ" ან "არა".

მაგალითი 1:
4
2
6
დიახ

მაგალითი 2:
ჰორიზონტალურად ნაჭრების რაოდენობა: 2
ნაჭრების რაოდენობა ვერტიკალურად: 10
რამდენი ნაჭერი უნდა გამოვყოთ: 7
არა

• Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია N, M, K: მთელი რიცხვი; დაწყება დაყენება ( "ნაჭრების რაოდენობა ჰორიზონტალურად:") ; მიიღეთ(N) ; Დადება( "ნაჭრების რაოდენობა ვერტიკალურად:") ; მიიღეთ(M) ; Დადება( "რამდენი ნაჭერი გამოვყოთ:") ; მიიღეთ(K) ; თუ K > M * N მაშინ --თუ შოკოლადის ფილას სთხოვენ უფრო მეტი გატეხვა, ვიდრე თავად შოკოლადის ფილა put ("არა"); elsif K rem N = 0 და შემდეგ K >= N მაშინ - გაწყვიტე ჰორიზონტალურად Put ("YES"); elsif K rem M = 0 და შემდეგ K >= M მაშინ - ვერტიკალურად გაწყვიტე Put ("YES"); else Put("NO" ); დაასრულე თუ ; endMain;

  Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია N, M, K: მთელი რიცხვი; start Put("ნაჭრების რაოდენობა ჰორიზონტალურად: "); მიიღეთ(N); Put("ნაჭრების რაოდენობა ვერტიკალურად: "); მიიღეთ(M); Put("რამდენი ნაჭერი უნდა გამოვყო: "); მიიღეთ(K); თუ K > M * N მაშინ --თუ შოკოლადის ფილას მოეთხოვება უფრო მეტი გაწყვეტა, ვიდრე თავად შოკოლადის ფილა Put("NO"); elsif K rem N = 0 და შემდეგ K >= N შემდეგ -- Break off ჰორიზონტალურად Put("YES"); elsif K rem M = 0 და შემდეგ K >= M შემდეგ -- Break off ვერტიკალურად Put("YES"); else Put("NO"); დაასრულე თუ; endMain;

იაშამ N × M მეტრის ზომის აუზში გადაცურა და დაიღალა. ამ დროს ის აღმოჩნდა X მეტრში ერთ-ერთი გრძელი ბორცვიდან (აუცილებლად არ არის უახლოესი) და Y მეტრი ერთ-ერთი მოკლე რაფიდან. რა არის მინიმალური მანძილი, რომელიც იაშამ უნდა იცურაოს აუზიდან გვერდზე გასასვლელად? პროგრამა შეყვანის სახით იღებს ნომრებს N, M, X, Y. პროგრამამ უნდა გამოიყვანოს მეტრის რაოდენობა, რომელიც იაშას გვერდით ცურვისთვის სჭირდება.

• აუზის სიგანე: 23
  აუზის სიგრძე: 52
  მანძილი იაშადან დიდ მხარეს: 8
  მანძილი იაშადან მოკლე მხარემდე: 43
  აუზიდან გასასვლელად მაინც უნდა იცურო: 8

შესაძლებელია, რომ პრობლემის გადასაჭრელად დაგჭირდეთ 2 ცვლადის შეცვლა. ეს ალგორითმი ასე გამოიყურება:

a, b, tmp: მთელი რიცხვი; -- ცვლადების გამოცხადება. ორი ძირითადი და ერთი დამხმარე a:= 3; --a ცვლადის ინიციალიზაცია b:= 5; --ბ ცვლადის ინიციალიზაცია --თვით ალგორითმი: tmp:= a; --ახლა tmp = 3 და a = 3 a:= b; --ახლა a = 5 და b = 5; b:=tmp; -- ახლა b = 3

• Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია N, M, X, Y: მთელი რიცხვი; -- N - მოკლე კიდე, M - გრძელი კიდე: -- X - მანძილი ერთ-ერთ გრძელ მხარეს -- Y - მანძილი ერთ-ერთ მოკლე მხარეს Tmp: მთელი რიცხვი; დაწყება დაყენება ( "აუზის სიგანე:") ; მიიღეთ(N) ; Დადება( "აუზის სიგრძე:") ; მიიღეთ(M) ; Დადება( "მანძილი იაშადან დიდ მხარეს:") ; მიიღეთ (X) ; Დადება( "მანძილი იაშადან მოკლე მხარემდე:") ; მიიღეთ(Y) ; თუ N > M მაშინ --თუ შეყვანის დროს მხარეები აირია, მაშინ ვცვლით მათ ადგილებს: Tmp:=M; - შეინახეთ M სიგრძე დროებით ცვლადში M:=N; --მიანიჭეთ M ცვლადს ახალი მნიშვნელობა N:=Tmp; --აღადგინეთ M სიგრძე N ცვლადშიდაასრულე თუ ; Tmp:=X; -- დავუშვათ, რომ მინიმალური მანძილი არის Xთუ abs (N-X)< X then --თუ მანძილი მეორე გრძელ კიდემდე X-ზე ნაკლებია, მაშინ Tmp:= N - X; --მინიმალური მანძილიუდრის მანძილს მეორე გრძელ მხარესდაასრულე თუ ; თუ Y< Tmp then --თუ მანძილი მოკლე კიდემდე ნაკლებია ვიდრე ზემოთ ნაპოვნი - მაშინ მინიმალური Tmp:=Y; --მინიმალური მანძილი არის Yდაასრულე თუ ; თუ აბს (M - Y)< Tmp then --მეორე მოკლე მხარეს თუ მიცურავ უფრო ახლოს, მაშინ Tmp:= abs (M - Y) ; --მინიმალური მანძილი უდრის მანძილს მეორე მოკლე რაფამდედაასრულე თუ ; Დადება( "აუზიდან გასასვლელად მაინც უნდა იცურო:") ; Put(Item => Tmp, Width => 1 ); endMain;

  Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; პროცედურა მთავარია N, M, X, Y: მთელი რიცხვი; -- N - მოკლე რაფა, M - გრძელი რაფა: -- X - მანძილი ერთ გრძელ რაფამდე -- Y - მანძილი ერთ მოკლე რაფამდე Tmp: მთელი რიცხვი; start Put("Pool Width:"); მიიღეთ(N); Put("აუზის სიგრძე:"); მიიღეთ(M); Put("მანძილი იაშადან გრძელ მხარეს: "); მიიღეთ (X); Put("მანძილი იაშადან მოკლე კიდემდე: "); მიიღეთ (Y); თუ N > M მაშინ --თუ შეყვანის დროს კიდეები აირია, მაშინ ვცვლით მათ ადგილებს: Tmp:= M; - შეინახეთ M სიგრძე დროებით M:= N-ში; --მიანიჭეთ ახალი მნიშვნელობა ცვლადს M N:= Tmp; --აღადგინეთ M სიგრძე ცვლადში N ბოლოს თუ; Tmp:=X; -- დავუშვათ, რომ მინიმალური მანძილი არის X, თუ ​​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, სიგანე => 1); endMain;

ელექტრონული საათი აჩვენებს დროს ფორმატში h:mm:ss (0:00:00-დან 23:59:59-მდე), ანუ ჯერ იწერება საათების რაოდენობა, შემდეგ წუთების ორნიშნა რაოდენობა სავალდებულოა. მაშინ წამების ორნიშნა რიცხვი სავალდებულოა. საჭიროების შემთხვევაში, წუთებისა და წამების რაოდენობა ჩართულია ორნიშნა რიცხვინულები. დღის დასაწყისიდან N წამი გავიდა. გამოიტანე ის, რასაც საათი აჩვენებს. შეყვანა არის ბუნებრივი რიცხვი N, რომელიც არ აღემატება 10 7-ს (10000000). გამოიტანეთ პასუხი პრობლემაზე.

შეყვანის მაგალითი 1:
3602
გამომავალი მაგალითი 1:
1:00:02

შეყვანის მაგალითი 2:
129700
გამომავალი მაგალითი 2:
12:01:40

• Ada.Long_Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Long_Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა მთავარი არის ქვეტიპი Sub_LI არის Long_Integer დიაპაზონი 1 ..10000000; N: Sub_LI; h, m, s: Long_Integer; დაწყება Get(N) ; სთ:= N / 3600 ; -საათს ვიღებთ. დანაყოფების დარჩენილი ნაწილი უგულვებელყოფილია N:= N - h * 3600 ; - მიიღეთ დარჩენილი წამები (საათების გამოკლებით)თუ h > 24 მაშინ --რადგან საათს არ შეუძლია აჩვენოს > 24, ჩვენ ყველაფერს ვდებთ წასაკითხად ფორმაშისთ:= სთ 24 ; --24-ზე გაყოფის დარჩენილი ნაწილი საათების ზუსტ რაოდენობას მოგვცემს elif h = 24 შემდეგ h:= 0 ; დაასრულე თუ ; m:= N / 60 ; -- მიიღეთ წუთი s:= N rem 60 ; --მიიღე წამი Put(Item => h, Width => 1 ); Დადება(":"); -- გამომავალი საათები და ":"თუ მ< 10 then --თუ წუთების რაოდენობა 10-ზე ნაკლებია, გამოიტანეთ წამყვანი 0 Put( Item => 0 , Width => 1 ); დაასრულე თუ ; Put( Item => m, Width => 1 ) ; Დადება(":"); -- გამომავალი წუთები და ":"თუ ს< 10 then --თუ წამების რაოდენობა 10-ზე ნაკლებია, გამოიტანეთ წამყვანი 0 Put( Item => 0 , Width => 1 ); დაასრულე თუ ; Put(Item => s, Width => 1 ); --გამომავალი წამების ბოლოს მთავარი;

  Ada.Long_Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Long_Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა Main არის ქვეტიპი Sub_LI არის Long_Integer დიაპაზონი 1..10000000; N: Sub_LI; h, m, s: Long_Integer; დაწყება Get(N); სთ:= N / 3600; -საათს ვიღებთ. გაყოფის დარჩენილი ნაწილი უქმდება N:= N - h * 3600; --მიიღეთ დარჩენილი წამები (საათების გამოკლებით) თუ h > 24, მაშინ --რადგან საათები ვერ კითხულობენ > 24, ჩადეთ ყველაფერი წასაკითხად h:= h rem 24; --24-ზე გაყოფის დარჩენილი ნაწილი მისცემს საათების ზუსტ რაოდენობას elif h = 24 შემდეგ h:= 0; დაასრულე თუ; მ:= N / 60; -- მიიღეთ წუთი s:= N rem 60; --Get seconds Put(Item => h, Width => 1); Დადება(":"); --გამომავალი საათები და ":" თუ m< 10 then --Если количество минут меньше 10, выводим ведущий 0 Put(Item =>0, სიგანე => 1); დაასრულე თუ; Put( Item => m, Width => 1); Დადება(":"); -- გამომავალი წუთები და ":" თუ s< 10 then --Если количество секунд меньше 10, выводим ведущий 0 Put(Item =>0, სიგანე => 1); დაასრულე თუ; Put( Item => s, Width => 1); --გამომავალი წამების ბოლოს მთავარი;

• მოცემულია სამი ნომერი. დაალაგეთ ისინი ზრდის მიხედვით.
• შეყვანის მაგალითი:
  1 2 1
  ნიმუშის გამომავალი:
  1 1 2

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა მთავარია A, B, C: მთელი რიცხვი; min, mid, max: მთელი რიცხვი; დაწყება Get(A) ; მიიღეთ(B) ; მიიღეთ (C); -- ვეძებთ მინიმალური ღირებულება წთ:=A; თუ ბ< min then min:= B; end if ; if C < min then min:= C; end if ; -- ვეძებთ მაქსიმალური ღირებულება max:=A; თუ B > max მაშინ max:= B; დაასრულე თუ ; თუ C > max მაშინ max:= C; დაასრულე თუ ; -- ვეძებთ საშუალო მნიშვნელობასშუაში:=A; თუ B > min და B< max then mid:= B; end if ; if C >წთ და გ< max then mid:= C; end if ; Put(Item =>წთ, სიგანე => 1); დადება(" "); Put(Item => mid, width => 1 ); დადება(" "); Put( Item => max, Width => 1 ); endMain;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა მთავარია A, B, C: მთელი რიცხვი; min, mid, max: მთელი რიცხვი; დაწყება Get(A); მიიღეთ (B); მიიღეთ (C); --ვეძებთ მინიმალურ მნიშვნელობას min:= A; თუ ბ< min then min:= B; end if; if C < min then min:= C; end if; --Ищем максимальное значение max:= A; if B >max შემდეგ max:= B; დაასრულე თუ; თუ C > max მაშინ max:= C; დაასრულე თუ; -- ვეძებთ საშუალო მნიშვნელობას mid:= A; თუ B > min და B< max then mid:= B; end if; if C >წთ და გ< max then mid:= C; end if; Put(Item =>წთ, სიგანე => 1); დადება(" "); Put( Item => mid, width => 1); დადება(" "); Put( Item => max, Width => 1); endMain;

არის ორი ყუთი, პირველი არის A1×B1×C1, მეორე არის A2×B2×C2. დაადგინეთ, შეიძლება თუ არა ერთ-ერთი ამ ყუთის მოთავსება მეორის შიგნით, იმ პირობით, რომ ყუთები შეიძლება შემობრუნდეს მხოლოდ 90 გრადუსით კიდეების გარშემო. პროგრამა შეყვანის სახით იღებს ნომრებს A1, B1, C1, A2, B2, C2. პროგრამამ უნდა გამოსცეს შემდეგი ხაზიდან ერთ-ერთი:
- "ყუთები თანაბარია", თუ ყუთები ერთნაირია,
- "პირველი ყუთი წამზე ნაკლებითუ პირველი ყუთი შეიძლება განთავსდეს მეორეში,
- "პირველი ყუთი წამზე მეტითუ მეორე ყუთი შეიძლება მოთავსდეს პირველში.

მაგალითი 1:
პირველი ყუთის ზომები: 1 2 3
მეორე ყუთის ზომები: 3 2 1
ყუთები თანაბარია

მაგალითი 2:
პირველი ყუთის ზომები: 2 2 3
მეორე ყუთის ზომები: 3 2 1
პირველი ყუთი მეორეზე დიდია

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურის მთავარია A1, B1, C1, A2, B2, C2: მთელი რიცხვი; min, max, mid, tmp: მთელი რიცხვი; დაწყება Get(A1); მიიღეთ(B1) ; მიიღეთ (C1) ; მიიღეთ (A2) ; მიიღეთ(B2) ; მიიღეთ (C2) ; --მიიტანეთ სახეები სიგრძეებთან A1 => A2, B1 => B2, C1 => C2: --A1 და A2 ყველაზე გრძელია, C1 და C2 ყველაზე მოკლეა -- „დაატრიალეთ“ პირველი ყუთი:წთ:=A1; შუა:=B1; max:=C1; თუ B1< min then mid:= min; min:= B1; end if ; if C1 < min then max:= min; min:= C1; end if ; if mid >max შემდეგ tmp:= mid; შუა:=მაქს; max:=tmp; დაასრულე თუ ; A1:=წთ; B1:=შუაში; C1:=მაქს; -- „დაატრიალეთ“ მეორე ყუთი:წთ:=A2; შუა:=B2; max:=C2; თუ B2< min then mid:= min; min:= B2; end if ; if C2 < min then max:= min; min:= C2; end if ; if mid >max შემდეგ tmp:= mid; შუა:=მაქს; max:=tmp; დაასრულე თუ ; A2:=წთ; B2:=შუაში; C2:=მაქს; -- ყუთების შესაბამისობის შემოწმება და შედეგის ჩვენება:თუ A1 = A2 და შემდეგ B1 = B2 და შემდეგ C1 = C2 მაშინ Put_Line("უჯრები ტოლია" ); elsif A1 >= A2 და შემდეგ B1 >= B2 და შემდეგ C1 >= C2 შემდეგ Put_Line( "პირველი ყუთი მეორეზე დიდია") ; Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("პირველი ყუთი მეორეზე პატარაა") ; დაასრულე თუ ; დასასრული მთავარი;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურის მთავარია A1, B1, C1, A2, B2, C2: მთელი რიცხვი; min, max, mid, tmp: მთელი რიცხვი; დაწყება Get(A1); მიიღეთ (B1); მიიღეთ (C1); მიიღეთ (A2); მიიღეთ (B2); მიიღეთ (C2); --მოიტანეთ კიდეები სიგრძეებთან A1 => A2, B1 => B2, C1 => C2: --A1 და A2 - ყველაზე გრძელი, C1 და C2 - უმოკლესი -- "მოატრიალეთ" პირველი ყუთი: წთ. := A1 ; შუა:=B1; max:=C1; თუ B1< min then mid:= min; min:= B1; end if; if C1 < min then max:= min; min:= C1; end if; if mid >max შემდეგ tmp:= mid; შუა:=მაქს; max:=tmp; დაასრულე თუ; A1:=წთ; B1:=შუაში; C1:=მაქს; -- „დაატრიალეთ“ მეორე ყუთი: min:= A2; შუა:=B2; max:=C2; თუ B2< min then mid:= min; min:= B2; end if; if C2 < min then max:= min; min:= C2; end if; if mid >max შემდეგ tmp:= mid; შუა:=მაქს; max:=tmp; დაასრულე თუ; A2:=წთ; B2:=შუაში; C2:=მაქს; --შეამოწმეთ ემთხვევა თუ არა უჯრები და გამოიტანეთ შედეგი: თუ A1 = A2 და შემდეგ B1 = B2 და შემდეგ C1 = C2 მაშინ Put_Line("ყუთები ტოლია"); elsif A1 >= A2 და შემდეგ B1 >= B2 და შემდეგ C1 >= C2 შემდეგ Put_Line("პირველი ყუთი მეორეზე დიდია"); Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Первая коробка меньше второй"); end if; end main;

დაწერეთ პროგრამა, რომელიც გამოთვლის საქალაქთაშორისო სატელეფონო საუბრის ღირებულებას (ერთი წუთის ფასი განისაზღვრება ქალაქამდე მანძილით, სადაც აბონენტი მდებარეობს). პროგრამის საწყისი მონაცემებია რეგიონის კოდი და ზარის ხანგრძლივობა. ქვემოთ მოცემულია ზოგიერთი ქალაქის კოდები და რეკომენდებული ეკრანის ხედვა პროგრამის გაშვებისას:

• გამოთვალეთ სატელეფონო საუბრის ღირებულება.
  შეიყვანეთ საწყისი მონაცემები:
  ქალაქის კოდი -> 423
  ხანგრძლივობა (მთლიანი წუთები) -> 3
  ქალაქი ვლადივოსტოკი
  ფასი წუთში: 4 რუბლი.
  ზარის ღირებულება: 12 რუბლი.

• Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა მთავარი არისკოდი, Len: მთელი რიცხვი; დაიწყოს Put_Line („სატელეფონო საუბრის ღირებულების გაანგარიშება“.) ; Put_Line ("შეიყვანეთ საწყისი მონაცემები:") ; Დადება ("ქალაქის კოდი ->") ; მიიღეთ (კოდი ) ; Დადება ("ხანგრძლივობა (მთლიანი წუთები) ->") ; მიიღეთ (ლენ ) ; საქმეკოდი არის როდესაც 423 => Put_Line ("ქალაქი ვლადივოსტოკი") ; Put_Line ("წუთის ფასი: 4 რუბლი.") ; Დადება ("ზარის ღირებულება:") ; Დადება (ელემენტი => len * 4 , სიგანე=> 1 ) ; Put_Line ("რუბში".) ; როდესაც 095 => Put_Line ("მოსკოვი ქალაქი") ; Put_Line ("წუთის ფასი: 2 რუბლი.") ; Დადება ("ზარის ღირებულება:") ; Დადება (ელემენტი => len * 2 , სიგანე=> 1 ) ; Put_Line ("რუბში".) ; როდესაც 815 => Put_Line ("ქალაქი: მურმანსკი") ; Put_Line ("წუთის ფასი: 3 რუბლი.") ; Დადება ("ზარის ღირებულება:") ; Დადება (ელემენტი => len * 3 , სიგანე=> 1 ) ; Put_Line ("რუბში".) ; როდესაც 846 => Put_Line ("ქალაქი სამარა") ; Put_Line ("წუთის ფასი: 1 რუბლი.") ; Დადება ("ზარის ღირებულება:") ; Დადება (ელემენტი => len, სიგანე => 1 ) ; Put_Line ("რუბში".) ; როდესაც სხვები=> დადეთ ("ბაზაში ამ კოდის მქონე ქალაქი არ არის! სცადეთ ხელახლა.") ; დასასრული საქმე; დასასრულიმთავარი;

  Ada.Integer_Text_IO-თან ერთად; გამოიყენეთ Ada.Integer_Text_IO; Ada.Text_IO-თან ერთად; გამოიყენეთ Ada.Text_IO; პროცედურა Main არის კოდი, Len: Integer; start Put_Line ("სატელეფონო ზარის ღირებულების გამოთვლა."); Put_Line ("შეიყვანეთ საწყისი მონაცემები:"); Put("ქალაქის კოდი -> "); კოდის მიღება); Put("ხანგრძლივობა (მთლიანი წუთები) -> "); მიიღეთ(ლენ); case Code არის როდესაც 423 => Put_Line("ქალაქი: ვლადივოსტოკი"); Put_Line ("ფასი წუთში: 4 რუბლი."); Put("ზარის ღირებულება:"); Put(Item => len * 4, Width => 1); Put_Line ("რუბ."); როდესაც 095 => Put_Line ("ქალაქი: მოსკოვი"); Put_Line ("ფასი წუთში: 2 რუბლი."); Put("ზარის ღირებულება:"); Put(Item => len * 2, Width => 1); Put_Line ("რუბ."); when 815 => Put_Line ("ქალაქი: მურმანსკი"); Put_Line ("ფასი წუთში: 3 რუბლი."); Put("ზარის ღირებულება:"); Put(Item => len * 3, Width => 1); Put_Line ("რუბ."); when 846 => Put_Line ("ქალაქი: Samara"); Put_Line ("ფასი წუთში: 1 რუბლი."); Put("ზარის ღირებულება:"); Put( Item => len, Width => 1); Put_Line ("რუბ."); when others => Put(" მონაცემთა ბაზაში ამ კოდის მქონე ქალაქი არ არის! სცადეთ ხელახლა."); ბოლო საქმე; endMain;

განყოფილება მოკლედ აღწერს ოპერატორებს თუდა საქმე, ფუნქცია abs ()და ცვლადების გაცვლის ალგორითმი.

განმარტება.

ეს არის ექვსკუთხედი, რომლის ფუძეები ორია თანაბარი კვადრატი, ხოლო გვერდითი სახეები თანაბარი ოთხკუთხედია

გვერდითი ნეკნი- ეს საერთო მხარეორი მიმდებარე გვერდითი სახე

პრიზმის სიმაღლე- ეს გაჭრაა ბაზების პერპენდიკულარულიპრიზმები

პრიზმის დიაგონალი- სეგმენტი, რომელიც აკავშირებს ფუძის ორ წვეროს, რომლებიც არ მიეკუთვნება ერთსა და იმავე სახეს

დიაგონალური თვითმფრინავიარის სიბრტყე, რომელიც გადის პრიზმის დიაგონალზე და მის გვერდითი ნეკნები

დიაგონალური განყოფილება - პრიზმისა და დიაგონალური სიბრტყის გადაკვეთის საზღვრები. რეგულარული ოთხკუთხა პრიზმის დიაგონალური მონაკვეთი არის მართკუთხედი

პერპენდიკულარული მონაკვეთი (ორთოგონალური მონაკვეთი)- ეს არის პრიზმისა და მისი გვერდითი კიდეების პერპენდიკულარულად დახატული სიბრტყის კვეთა

რეგულარული ოთხკუთხა პრიზმის ელემენტები

ნახატზე ნაჩვენებია ორი რეგულარული ოთხკუთხა პრიზმა, რომლებიც აღნიშნულია შესაბამისი ასოებით:

• ფუძეები ABCD და A 1 B 1 C 1 D 1 ტოლია და ერთმანეთის პარალელურია
• გვერდითი სახეები AA 1 D 1 D, AA 1 B 1 B, BB 1 C 1 C და CC 1 D 1 D, რომელთაგან თითოეული არის მართკუთხედი
• გვერდითი ზედაპირი- პრიზმის ყველა მხარის ფართობების ჯამი
• მთლიანი ზედაპირი - ყველა ბაზისა და გვერდითი ზედაპირის ფართობის ჯამი (გვერდითი ზედაპირისა და ფუძის ფართობის ჯამი)
• გვერდითი ნეკნები AA 1 , BB 1 , CC 1 და DD 1 .
• დიაგონალი B 1 D
• ბაზის დიაგონალი BD
• დიაგონალური მონაკვეთი BB 1 D 1 D
• პერპენდიკულარული მონაკვეთი A 2 B 2 C 2 D 2 .

რეგულარული ოთხკუთხა პრიზმის თვისებები

• ფუძეები ორი თანაბარი კვადრატია
• ფუძეები ერთმანეთის პარალელურია
• გვერდები მართკუთხედია.
• გვერდითი სახეები ერთმანეთის ტოლია
• გვერდითი სახეები ბაზების პერპენდიკულარულია
• გვერდითი ნეკნები ერთმანეთის პარალელურია და თანაბარია
• პერპენდიკულური მონაკვეთი პერპენდიკულარული ყველა გვერდითი ნეკნებისა და ბაზების პარალელურად
• კუთხეები პერპენდიკულარული მონაკვეთი- სწორი
• რეგულარული ოთხკუთხა პრიზმის დიაგონალური მონაკვეთი არის მართკუთხედი
• პერპენდიკულური (ორთოგონალური მონაკვეთი) ფუძეების პარალელურად

რეგულარული ოთხკუთხა პრიზმის ფორმულები

ინსტრუქციები პრობლემების გადასაჭრელად

თემის პრობლემების გადაჭრისას " სწორი ოთხკუთხა პრიზმა "იგულისხმება, რომ:

სწორი პრიზმა- პრიზმა, რომლის ძირში დევს რეგულარული მრავალკუთხედიდა გვერდითი კიდეები პერპენდიკულარულია საბაზისო სიბრტყეზე. ანუ, რეგულარული ოთხკუთხა პრიზმა შეიცავს მის ძირში კვადრატი. (იხილეთ ზემოთ რეგულარული ოთხკუთხა პრიზმის თვისებები) შენიშვნა. ეს არის გაკვეთილის ნაწილი გეომეტრიის დავალებებით (განყოფილება მყარი გეომეტრია - პრიზმა). აქ არის ამოცანები, რომლებიც სირთულეებს იწვევს ამოხსნაში. თუ თქვენ გჭირდებათ პრობლემის გადაჭრა გეომეტრიაში, რომელიც აქ არ არის - დაწერეთ ამის შესახებ ფორუმზე. ამოღების მოქმედების მითითება კვადრატული ფესვისიმბოლო გამოიყენება პრობლემის გადაჭრაში√ .

დავალება.

რეგულარული ოთხკუთხა პრიზმაში ფუძის ფართობია 144 სმ 2 და სიმაღლე 14 სმ. იპოვეთ პრიზმის დიაგონალი და ფართობი. სრული ზედაპირი.

გადაწყვეტილება.
რეგულარული ოთხკუთხედი არის კვადრატი.
შესაბამისად, ბაზის მხარე ტოლი იქნება

√144 = 12 სმ.
საიდან მოდის ფუძის დიაგონალი? მართკუთხა პრიზმატოლი იქნება
√(12 2 + 12 2 ) = √288 = 12√2

დიაგონალი მარჯვენა პრიზმაფორმები ფუძის დიაგონალთან და პრიზმის სიმაღლესთან მართკუთხა სამკუთხედი. შესაბამისად, პითაგორას თეორემის მიხედვით, მოცემული რეგულარული ოთხკუთხა პრიზმის დიაგონალი ტოლი იქნება:
√((12√2) 2 + 14 2 ) = 22 სმ

უპასუხე: 22 სმ

დავალება

იპოვეთ რეგულარული ოთხკუთხა პრიზმის მთლიანი ფართობი, თუ მისი დიაგონალი არის 5 სმ, ხოლო გვერდითი სახის დიაგონალი 4 სმ.

გადაწყვეტილება.
ვინაიდან რეგულარული ოთხკუთხა პრიზმის ფუძე არის კვადრატი, მაშინ ფუძის მხარე (აღნიშნული როგორც a) გვხვდება პითაგორას თეორემით:

A 2 + a 2 = 5 2
2a 2 = 25
a = √12.5

გვერდითი სახის სიმაღლე (აღნიშნულია როგორც h) მაშინ იქნება ტოლი:

H 2 + 12.5 \u003d 4 2
სთ 2 + 12,5 = 16
სთ 2 \u003d 3.5
სთ = √3.5

მთლიანი ზედაპირის ფართობი ტოლი იქნება გვერდითი ზედაპირის ფართობის ჯამის და ბაზის ფართობის ორჯერ

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 სმ 2.

პასუხი: 25 + 10√7 ≈ 51.46 სმ 2.

მანქანები მექანიკური გადაცემათა კოლოფით, რომელიც შემოკლებით არის მექანიკური ტრანსმისია, ბოლო დრომდე შეადგენდა აბსოლუტური უმრავლესობასხვა მანქანებს შორის განსხვავებული.

უფრო მეტიც, მექანიკური (მექანიკური) ყუთი დღეს რჩება საკმაოდ გავრცელებულ მოწყობილობად ძრავის ბრუნვის შეცვლისა და გადაცემისთვის. შემდეგი, ვისაუბრებთ იმაზე, თუ როგორ არის მოწყობილი და მუშაობს "მექანიკა", როგორ გამოიყურება ამ ტიპის გადაცემათა კოლოფის სქემა და ასევე რა დადებითი და უარყოფითი მხარეები აქვს ამ გადაწყვეტას.

წაიკითხეთ ამ სტატიაში

მექანიკური გადაცემის დიაგრამა და მახასიათებლები

დასაწყისისთვის, ამ ტიპის გადაცემათა კოლოფს უწოდებენ მექანიკურს, იმის გამო, რომ ასეთი განყოფილება გულისხმობს გადაცემათა მექანიკურ შეცვლას. სხვა სიტყვებით რომ ვთქვათ, მექანიკური გადაცემის მქონე მანქანებზე, მძღოლი თავად ცვლის გადაცემათა კოლოფს.

ჩვენ უფრო შორს მივდივართ. "მექანიკის" ყუთი საფეხურიანია, ანუ ბრუნი იცვლება ნაბიჯებით. ბევრმა მძღოლმა იცის, რომ გადაცემათა კოლოფს რეალურად აქვს გადაცემათა კოლოფი და ლილვები, მაგრამ ყველას არ ესმის, როგორ მუშაობს განყოფილება.

ასე რომ, ეტაპი (ის ასევე არის გადაცემათა კოლოფი) არის გადაცემათა წყვილი (სამართავი და ამოძრავებული მექანიზმი), რომლებიც ურთიერთობენ ერთმანეთთან. თითოეული ასეთი ეტაპი უზრუნველყოფს ბრუნვას ამა თუ იმ კუთხური სიჩქარით, ანუ მას აქვს საკუთარი გადაცემათა კოეფიციენტი.

გადაცემათა კოეფიციენტის ქვეშ უნდა გვესმოდეს, როგორც ამოძრავებული მექანიზმის კბილების რაოდენობის თანაფარდობა წამყვანი მექანიზმის კბილების რაოდენობასთან. ამ შემთხვევაში, ყუთის სხვადასხვა საფეხური იღებს სხვადასხვა გადაცემათა კოეფიციენტს. ყველაზე დაბალი გადაცემათა კოეფიციენტი (დაბალი გადაცემათა კოლოფი) აქვს ყველაზე დიდი გადაცემათა კოეფიციენტი და ყველაზე მეტი მაღალი ნაბიჯი(upshift) აქვს ყველაზე პატარა გადაცემათა კოეფიციენტი.

ირკვევა, რომ ნაბიჯების რაოდენობა უდრის გადაცემათა რაოდენობას კონკრეტულ კოლოფზე (ოთხსაფეხურიანი გადაცემათა კოლოფი, ხუთსაფეხურიანი და ა.შ.) ადრე 4 სიჩქარიანი. მექანიკური ყუთებიმექანიზმი თანდათან ფონზე გადავიდა.

მექანიკური გადაცემის მოწყობილობა

ასე რომ, მიუხედავად იმისა, რომ შეიძლება არსებობდეს ასეთი ყუთის მრავალი დიზაინი გარკვეული მახასიათებლებით, თუმცა, საწყისი ეტაპიშეიძლება განვასხვავოთ ორი ძირითადი ტიპი:

• სამი ლილვის გადაცემათა კოლოფი;
• ორი ლილვის ყუთები;

სამ ლილვის მექანიკური გადაცემათა კოლოფი ჩვეულებრივ დამონტაჟებულია უკანა ამძრავიან მანქანებზე, ხოლო ორი ლილვის კოლოფი - წინა ამძრავიან სამგზავრო მანქანებზე. ამავდროულად, როგორც პირველი, ასევე მეორე ტიპის მექანიკური გადაცემათა კოლოფის მოწყობილობა შეიძლება მნიშვნელოვნად განსხვავდებოდეს.

დავიწყოთ სამი ლილვის მექანიკური ყუთით. ეს ყუთი შეიცავს:

• წამყვანი ლილვი, რომელსაც ასევე უწოდებენ პირველადს;
• შუალედური ლილვის გადაცემათა კოლოფი;
• ამოძრავებული ლილვი (მეორადი);

ლილვებზე დამონტაჟებულია გადაცემათა კოლოფი სინქრონიზატორებით. გადაცემათა კოლოფში შედის გადაცემათა გადაცემის მექანიზმიც. დაზუსტებულია შემადგენელი ელემენტებიმდებარეობს გადაცემათა კოლოფის კორპუსში, რომელსაც ასევე უწოდებენ გადაცემათა კოლოფის კორპუსს.

წამყვანი ლილვის ამოცანაა შექმნას კავშირი გადაბმულობასთან. ამძრავ ლილვს აქვს სლოტები გადაბმულობის დისკისთვის. რაც შეეხება ბრუნვას, მითითებული ბრუნი შეყვანის ლილვიდან გადადის გადაცემათა კოლოფის მეშვეობით, რომელიც მყარად არის ჩართული მასთან.

შუალედური ლილვის მუშაობაზე ზემოქმედებით, ეს ლილვი განლაგებულია გადაცემათა კოლოფის შეყვანის ლილვის პარალელურად, მასზე დამონტაჟებულია გადაცემათა ჯგუფი, რომელიც მყარ ჩართულობაშია. თავის მხრივ, ამოძრავებული ლილვი დამონტაჟებულია იმავე ღერძზე, როგორც წამყვანი ლილვი.

ასეთი ინსტალაცია ხორციელდება წამყვანი ლილვის ბოლო საკისრის გამოყენებით. ეს საკისარი მოიცავს ამოძრავებულ ლილვს. გადაცემათა ჯგუფს (გადაცემათა ბლოკი) ამოძრავებულ ლილვზე არ აქვს ხისტი ჩართულობა თავად ლილვთან და ამიტომ თავისუფლად ბრუნავს მასზე. ამ შემთხვევაში, შუალედური ლილვის მექანიზმების ჯგუფი, ამოძრავებული ლილვი და ამძრავი ლილვის მექანიზმი მუდმივ ჩართულობაშია.

ამოძრავებული ლილვის გადაცემათა კოლოფებს შორის დამონტაჟებულია სინქრონიზატორები (სინქრონიზატორის შეერთებები). მათი ამოცანაა ხახუნის ძალის მეშვეობით ამოძრავებული ლილვის მექანიზმების კუთხური სიჩქარეების გასწორება თავად ლილვის კუთხურ სიჩქარესთან.

სინქრონიზატორები მჭიდროდ არიან ჩართული ამოძრავებულ ლილვთან და ასევე აქვთ უნარი გადაადგილდნენ ლილვის გასწვრივ გრძივი მიმართულებით სლაინ კავშირის გამო. თანამედროვე გადაცემათა კოლოფებს აქვთ სინქრონიზატორის ჩამკეტები ყველა გადაცემათა კოლოფში.

თუ გავითვალისწინებთ გადაცემათა გადაცემის მექანიზმს სამ ლილვის გადაცემათა კოლოფზე, ხშირად ეს მექანიზმი დამონტაჟებულია დანაყოფის კორპუსზე. დიზაინში შედის საკონტროლო ბერკეტი, სლაიდერები და ჩანგლები.

კოლოფის კორპუსი (კარტკანი) დამზადებულია ალუმინის ან მაგნიუმის შენადნობებისგან, აუცილებელია ლილვების დაყენება გადაცემათა და მექანიზმებით, ასევე რიგი სხვა ნაწილებით. გადაცემათა კოლოფის კორპუსში ასევე არის გადაცემათა კოლოფის ზეთი.

• იმის გასაგებად, თუ როგორ მუშაობს სამი ლილვის ტიპის მექანიკური (მექანიკური) გადაცემათა კოლოფი, მოდით ზოგადი თვალსაზრისითმოდით შევხედოთ როგორ მუშაობს. როდესაც გადაცემათა ბერკეტი ნეიტრალურ მდგომარეობაშია, არ ხდება ბრუნვის გადაცემა ძრავიდან ავტომობილის ამძრავ ბორბლებზე.

მას შემდეგ, რაც მძღოლი ამოძრავებს ბერკეტს, ჩანგალი ამოძრავებს ამა თუ იმ მექანიზმის სინქრონიზატორს. ამის შემდეგ სინქრონიზატორი გასწორდება კუთხური სიჩქარეებისასურველი მექანიზმი და ამოძრავებული ლილვი. შემდეგ გადაცემათა კოლოფის რგოლი ჩაერთვება ანალოგიური გადაცემათა რგოლთან, რაც უზრუნველყოფს მექანიზმის ჩაკეტვას ამოძრავებულ ლილვზე.

აქვე დავამატებთ, რომ მანქანის უკანა გადაცემათა კოლოფის უკუს გადაცემათა კოლოფი უზრუნველყოფს. ამ შემთხვევაში, ცალკე ღერძზე დამონტაჟებული უკუ უსაქმური მექანიზმი იძლევა ბრუნვის მიმართულების შეცვლას.

ორი ლილვის მექანიკური გადაცემათა კოლოფი: მოწყობილობა და მუშაობის პრინციპი

რაც შეეხება იმას, თუ რისგან შედგება სამი ლილვის გადაცემათა კოლოფი, მოდით გადავიდეთ ორ ლილვის გადაცემათა კოლოფზე. ამ ტიპისგადაცემათა კოლოფს აქვს ორი ლილვი თავის მოწყობილობაში: პირველადი და მეორადი. შეყვანის ლილვი არის მამოძრავებელი, მეორადი არის ამოძრავებული. გადაცემათა კოლოფი და სინქრონიზატორები ფიქსირდება ლილვებზე. ასევე ყუთის კარკასში არის მთავარი მექანიზმი და დიფერენციალი.

ამძრავი ლილვი პასუხისმგებელია გადაბმულობასთან დაკავშირებაზე, ასევე ლილვზე არის გადაცემათა ბლოკი ლილვთან ხისტი ჩართულობით. ამოძრავებული ლილვი მდებარეობს ამძრავის ლილვის პარალელურად, ხოლო ამოძრავებული ლილვის გადაცემათა კოლოფი მუდმივ კავშირშია წამყვანი ლილვის მექანიზმებთან და ასევე თავისუფლად ბრუნავს თავად ლილვზე.

ასევე, მთავარი მექანიზმის წამყვანი მექანიზმი მყარად არის დამაგრებული ამოძრავებულ ლილვზე, ხოლო სინქრონიზატორის შეერთებები განლაგებულია ამოძრავებული ლილვის გადაცემათა კოლოფებს შორის. ჩვენ ვამატებთ, გადაცემათა კოლოფის ზომის შესამცირებლად, ასევე გადაცემათა კოლოფის გაზრდის მიზნით, თანამედროვე გადაცემათა კოლოფში ხშირად შეიძლება დამონტაჟდეს 2 ან თუნდაც 3 ლილვი ერთი ამოძრავებული ლილვის ნაცვლად.

თითოეულ ასეთ ლილვზე, ძირითადი მექანიზმის მექანიზმი მკაცრად არის დამაგრებული, ხოლო ასეთ მექანიზმს აქვს ხისტი ჩართულობა ამოძრავებულ მექანიზმთან. გამოდის, რომ დიზაინი რეალურად ახორციელებს 3 ძირითად მექანიზმს.

თავად მთავარი მექანიზმი, ისევე როგორც დიფერენციალი გადაცემათა კოლოფში, გადასცემს ბრუნვას მეორადი ლილვიდან წამყვანი ბორბლებისკენ. ამ შემთხვევაში, დიფერენციალს შეუძლია უზრუნველყოს ბორბლების ასეთი ბრუნვა, როდესაც წამყვანი თვლები ბრუნავს სხვადასხვა კუთხური სიჩქარით.

რაც შეეხება გადაცემათა გადაცემის მექანიზმს, ორ ლილვის გადაცემათა კოლოფზე იგი ცალ-ცალკე ამოღებულია, ანუ კორპუსის გარეთ. ყუთი დაკავშირებულია გადართვის მექანიზმთან კაბელებით ან სპეციალური წნელებით. ყველაზე გავრცელებული კავშირი არის კაბელებთან.

თავად 2 ლილვის კოლოფის გადართვის მექანიზმს აქვს ბერკეტი, რომელიც კაბელებით უკავშირდება ამომრჩევის ბერკეტს და გადაცემათა კოლოფის ბერკეტს. ეს ბერკეტები დაკავშირებულია ცენტრალური გადართვის ღეროსთან, რომელსაც ასევე აქვს ჩანგლები.

• თუ ვსაუბრობთ ორი ლილვის მექანიკური გადაცემათა კოლოფის მუშაობის პრინციპზე, ის მსგავსია სამი ლილვის გადაცემათა კოლოფის პრინციპის მსგავსი. განსხვავებები იმაში მდგომარეობს, თუ როგორ მუშაობს გადაცემათა კოლოფის მექანიზმი. მოკლედ, ბერკეტს შეუძლია განახორციელოს როგორც გრძივი, ისე განივი მოძრაობები მანქანის ღერძთან შედარებით. დროს განივი მოძრაობაგადაცემათა კოლოფის არჩევა ხდება, რადგან ძალა ვრცელდება გადაცემათა არჩევის კაბელზე, რომელიც მოქმედებს გადაცემათა არჩევის ბერკეტზე.

გარდა ამისა, ბერკეტი მოძრაობს გრძივად და ძალა მიდის გადაცემათა კოლოფის კაბელზე. შესაბამისი ბერკეტი ჰორიზონტალურად მოძრაობს ღეროს ჩანგლებით, ღეროზე ჩანგალი ანაცვლებს სინქრონიზატორს, რაც იწვევს ამოძრავებული ლილვის მექანიზმის დაბლოკვას.

და ბოლოს, ჩვენ აღვნიშნავთ, რომ ასევე მექანიკური ყუთები განსხვავებული ტიპებიაქვს დამატებითი დამბლოკავი მოწყობილობები, რომლებიც ხელს უშლიან ერთდროულად ორი მექანიზმის ჩართვას ან მექანიზმის მოულოდნელ გამორთვას.

ასევე წაიკითხეთ

ძრავის ჩართვამდე გადაბმულობის დაჭერა: როდის და რა შემთხვევებში არ არის რეკომენდებული ამის გაკეთება. სასარგებლო მინიშნებებიდა რეკომენდაციები.

გაშვებულ ძრავზე სიჩქარის რთული გადართვის მიზეზები. გადაცემათა კოლოფის ზეთი და დონე გადაცემათა კოლოფში, სინქრონიზატორებისა და კოლოფის გადაცემათა ცვეთა, კლაჩი.