Transmissão manual: dispositivo, tipos, características. Enigmas relacionados a fenômenos físicos na natureza

Que eu encontrei no site DataGenetics. Por favor, envie todos os erros deste artigo em mensagens privadas.

Neste problema, há 100 presos na prisão, cada um numerado de 1 a 100. O carcereiro decide dar aos presos a chance de serem soltos, ele diz a eles as condições do teste, e se todos os presos passarem no teste, então eles serão liberados. Se pelo menos um deles falhar no teste, todos os prisioneiros morrerão.

Tarefa

O carcereiro vai para quarto secreto e prepara 100 caixas com tampas. Em cada caixa, ele marca números de 1 a 100. Em seguida, traz 100 tabletes de papel, de acordo com o número de presos, e numera esses tabletes de 1 a 100. Em seguida, embaralha 100 tabletes e coloca um tablet em cada caixa, fechando a tampa. Os prisioneiros não vêem como o carcereiro realiza todas essas ações.

A competição começa, o carcereiro leva cada prisioneiro um a um para a sala com as caixas e diz aos prisioneiros que eles devem encontrar uma caixa que conterá uma placa com o número do prisioneiro. Os prisioneiros estão tentando encontrar a placa com seu número abrindo as caixas. Cada um pode abrir até 50 caixas; se cada um dos prisioneiros encontrar seu número, os prisioneiros serão libertados, se pelo menos um deles não encontrar seu número em 50 tentativas, todos os prisioneiros morrerão.

Para que os prisioneiros sejam libertados, TODOS os prisioneiros devem passar no teste com sucesso.

Então, qual é a chance de que os prisioneiros sejam perdoados?

  • Depois que o prisioneiro abre a caixa e verifica a placa, ela é colocada de volta na caixa e a tampa é fechada novamente;
  • Os lugares das placas não podem ser alterados;
  • Os prisioneiros não podem deixar pistas uns para os outros ou interagir uns com os outros de qualquer forma uma vez que o julgamento tenha começado;
  • Os prisioneiros podem discutir estratégias antes do início do julgamento.

Qual é a melhor estratégia para os prisioneiros?

Pergunta adicional:

Se um amigo dos prisioneiros (não participante do teste) puder entrar na sala secreta antes do início do teste, examine todos os comprimidos em todas as caixas e (opcionalmente, mas não obrigatório) troque dois comprimidos de duas caixas (neste caso, o camarada não terá a oportunidade de informar os prisioneiros sobre o resultado de suas ações), então qual estratégia ele deve adotar para aumentar as chances dos prisioneiros escaparem?

Solução improvável?

À primeira vista, esta tarefa parece quase impossível. Parece que a chance de cada um dos prisioneiros encontrar seu tablet é microscopicamente pequena. Além disso, os presos não podem trocar informações entre si durante o julgamento.

As chances de um prisioneiro são 50:50. São 100 caixas no total e ele pode abrir até 50 caixas procurando seu signo. Se ele abrir as caixas aleatoriamente e abrir metade de todas as caixas, ele encontrará seu tablet na metade aberta das caixas, ou seu tablet permanecerá nas 50 caixas fechadas. Suas chances de sucesso são ½.

Vamos fazer dois prisioneiros. Se ambos escolherem caixas ao acaso, as chances para cada uma delas serão ½, e para duas ½x½=¼.
(para dois prisioneiros, o sucesso será em um caso em cada quatro).

Para três prisioneiros, as chances são ½ × ½ × ½ = ⅛.

Para 100 prisioneiros, as probabilidades são: ½ × ½ × … ½ × ½ (multiplicar 100 vezes).


Isso é igual

Pr ≈ 0,000000000000000000000000000008

Então é uma chance muito pequena. Nesse cenário, muito provavelmente, todos os prisioneiros estarão mortos.

Resposta incrível

Se cada prisioneiro abrir as caixas aleatoriamente, é improvável que passe no teste. Existe uma estratégia em que os prisioneiros podem esperar ter sucesso em mais de 30% das vezes. Este é um resultado incrivelmente incrível (se você ainda não ouviu falar problema de matemática anteriormente).

Mais de 30% para todos os 100 prisioneiros! Sim, isso é ainda mais do que as chances de dois prisioneiros, desde que eles abram as caixas aleatoriamente. Mas como isso é possível?

É claro que uma para cada preso, as chances não podem ser superiores a 50% (afinal, não há como haver comunicação entre os presos). Mas não esqueça que as informações ficam armazenadas no local das placas dentro das caixas. Ninguém embaralha os tablets entre as visitas de prisioneiros individuais à sala, então podemos usar essa informação.

Decisão

Primeiro, direi a solução, depois explicarei por que funciona.

A estratégia é extremamente fácil. O primeiro dos prisioneiros abre a caixa com o número que está escrito em suas roupas. Por exemplo, o prisioneiro número 78 abre a caixa com o número 78. Se ele encontrar seu número na placa dentro da caixa, ótimo! Caso contrário, ele olha para o número na placa na caixa "seu" e abre a próxima caixa com esse número. Tendo aberto a segunda caixa, ele olha para o número do tablet dentro desta caixa e abre a terceira caixa com este número. Então, simplesmente transferimos essa estratégia para as caixas restantes. Para maior clareza, observe a imagem:


Eventualmente, o prisioneiro encontrará seu número ou atingirá o limite de 50 caixas. À primeira vista, isso parece inútil comparado a simplesmente escolher uma caixa aleatoriamente (e para um prisioneiro individual), mas como todos os 100 prisioneiros usarão o mesmo conjunto de caixas, faz sentido.

A beleza deste problema de matemática- não só para saber o resultado, mas também para entender Por quê essa estratégia funciona.

Então, por que a estratégia funciona?

Cada caixa contém uma placa - e esta placa é única. Isso significa que a placa está em uma caixa com o mesmo número ou aponta para uma caixa diferente. Como todas as placas são únicas, há apenas uma placa para cada caixa apontando para ela (e apenas uma maneira de chegar a essa caixa).


Se você pensar bem, as caixas formam uma corrente circular fechada. Uma caixa pode fazer parte de apenas uma cadeia, pois dentro da caixa há apenas um ponteiro para a próxima e, portanto, na caixa anterior há apenas um ponteiro para essa caixa (os programadores podem ver a analogia com listas vinculadas).

Se a caixa não apontar para si mesma (o número da caixa é igual ao número da placa), ela estará na cadeia. Algumas correntes podem consistir em duas caixas, algumas são mais longas.


Como todos os presos começam com uma caixa com o mesmo número em suas roupas, eles são, por definição, colocados na corrente que contém sua placa de identificação (há apenas uma placa de identificação que aponta para essa caixa).

Explorando as caixas ao longo desta cadeia em um círculo, eles garantem que eventualmente encontrarão seu sinal.

A única questão permanece se eles encontrarão seu tablet em 50 movimentos.


Comprimento da cadeia

Para que todos os prisioneiros passem no teste, o comprimento máximo da corrente deve ser inferior a 50 caixas. Se a corrente tiver mais de 50 caixas, os prisioneiros com números dessas correntes serão reprovados no teste - e todos os prisioneiros estarão mortos.

Se o comprimento máximo da corrente mais longa for inferior a 50 caixas, todos os prisioneiros passarão no teste!

Pense nisso por um segundo. Acontece que só pode haver uma corrente com mais de 50 caixas em qualquer layout das placas (temos apenas 100 caixas, portanto, se uma corrente for maior que 50, o restante será menor que 50 no total).


Probabilidades de mãos de cadeia longa

Uma vez que você tenha se convencido de que o comprimento máximo da cadeia deve ser menor ou igual a 50 para ter sucesso, e que só pode haver uma cadeia longa em qualquer conjunto, podemos calcular a probabilidade de passar no desafio:

Um pouco mais de matemática

Então, o que precisamos para descobrir a probabilidade de uma cadeia longa?

Para uma cadeia de comprimento l, a probabilidade de que as caixas estejam fora dessa cadeia é:

Existe (l-1) nesta coleção de números! maneiras de organizar os sinais.

Os restantes sinais podem ser localizados (100-l)! maneiras (não esqueça que o comprimento da cadeia não excede 50).

Dado isso, o número de permutações que contêm a cadeia comprimento exato l: (>50)


Acontece que existem 100(!) maneiras de organizar as placas, de modo que a probabilidade de existência de uma cadeia de comprimento l seja igual a 1/l. A propósito, esse resultado não depende do número de caixas.

Como já sabemos, só pode haver um caso em que haja uma cadeia com comprimento > 50, então a probabilidade de sucesso é calculada por esta fórmula:

Resultado

31,18% - a probabilidade de que o tamanho da cadeia mais longa seja menor que 50 e cada um dos presos consiga encontrar seu tablet, dado o limite de 50 tentativas.

A probabilidade de que todos os presos encontrem suas placas e passem no teste é de 31,18%

Abaixo está um gráfico mostrando as probabilidades (no eixo y) para todas as cadeias de comprimento l (no eixo x). Vermelho significa todas as "falhas" (a curva dada aqui é apenas um gráfico de 1/l). Cor verde significa "sucesso" (o cálculo é um pouco mais complicado para esta parte do gráfico, pois existem várias maneiras de determinar comprimento máximo <50). Общая вероятность складывается из зеленых столбцов в 31.18% шанс на спасение.


Número harmônico (esta parte do artigo é para geeks)

Em matemática, o enésimo número harmônico é a soma dos recíprocos dos n primeiros números consecutivos da série natural.


Vamos calcular o limite se em vez de 100 caixas tivermos um um grande número de caixas (vamos supor que temos 2n caixas no total).


A constante de Euler-Mascheroni é uma constante definida como o limite da diferença entre a soma parcial de uma série harmônica e o logaritmo natural de um número.

À medida que o número de prisioneiros aumenta, se o capataz permitir que os prisioneiros abram metade de todas as caixas, então a chance de salvação tende a 30,685%.

(Se você tomar uma decisão em que os prisioneiros adivinham aleatoriamente as caixas, à medida que o número de prisioneiros aumenta, a probabilidade de ser salvo tende a zero!)

Pergunta adicional

Alguém mais se lembra da pergunta extra? O que nosso companheiro útil pode fazer para aumentar nossas chances de sobrevivência?

Agora já sabemos a solução, então a estratégia aqui é simples: ele deve examinar todos os sinais e encontrar a cadeia de caixas mais longa. Se a cadeia mais longa for menor que 50, ele não precisará trocar os comprimidos ou alterá-los para que a cadeia mais longa não seja maior que 50. No entanto, se ele encontrar uma corrente com mais de 50 caixas, tudo o que ele precisa fazer é trocar o conteúdo de duas caixas dessa corrente para quebrá-la em duas correntes mais curtas.

Como resultado dessa estratégia, não haverá longas cadeias e todos os presos terão a garantia de encontrar seu sinal e salvação. Então, trocando dois sinais, reduzimos a probabilidade de salvação para 100%!


Lembre-se que o volume de um paralelepípedo (ou de uma caixa comum) é igual ao produto de seu comprimento, largura e altura. Se a sua caixa for retangular ou quadrada, tudo o que você precisa saber é o comprimento, a largura e a altura. Para obter o volume, é necessário multiplicar os resultados das medições. A fórmula de cálculo em forma abreviada é frequentemente apresentada da seguinte forma: V \u003d L x W x H.
Exemplo de problema: "Se o comprimento da caixa é 10 cm, a largura é 4 cm e a altura é 5 cm, então qual é o seu volume?"
V = L x L x A
V = 10 cm x 4 cm x 5 cm
V \u003d 200 cm3
A "altura" da caixa pode ser chamada de "profundidade". Por exemplo, uma tarefa pode conter as seguintes informações: "O comprimento da caixa é 10 cm, a largura é 4 cm e a profundidade é 5 cm."

2
Meça o comprimento da caixa. Se você olhar para a caixa de cima, ela aparecerá diante de seus olhos na forma de um retângulo. O comprimento da caixa será o lado mais comprido deste retângulo. Registre o resultado da medição deste lado como o valor do parâmetro "comprimento".
Certifique-se de usar a mesma unidade de medida ao fazer medições. Se você mediu um lado em centímetros, os outros lados também devem ser medidos em centímetros.

3
Meça a largura da caixa. A largura da caixa será representada pelo outro lado mais curto do retângulo visível de cima. Se você conectar visualmente os lados da caixa medidos em comprimento e largura, eles aparecerão na forma da letra "G". Registre o valor da última medição como "largura".
A largura é sempre o lado mais curto da caixa.

4
Meça a altura da caixa. Este é o último parâmetro que você ainda não mediu. Ele representa a distância da borda superior da caixa até a parte inferior. Registre o valor desta medida como "altura".
Dependendo de qual lado você colocar a caixa, os lados específicos que você designar como "comprimento", "largura" ou "altura" podem ser diferentes. No entanto, não importa, você só precisa das medidas de três lados diferentes.

5
Multiplique os resultados das três medições juntos. Conforme já mencionado, a fórmula para cálculo do volume é a seguinte: V = Comprimento x Largura x Altura; portanto, para obter o volume, basta multiplicar os três lados. Certifique-se de especificar as unidades que você usou no cálculo para não esquecer o que exatamente os valores significam.

6
Ao indicar unidades de volume, não esqueça de indicar a terceira potência "3". O volume calculado tem uma expressão numérica, mas sem a indicação correta das unidades de medida, seus cálculos não terão sentido. Para refletir corretamente as unidades de volume, elas devem ser especificadas no cubo. Por exemplo, se todos os lados fossem medidos em centímetros, as unidades de volume seriam especificadas como "cm3".
Um exemplo de problema: "Se uma caixa tem 2 m de comprimento, 1 m de largura e 3 m de altura, qual é o seu volume?"
V = L x L x A
V = 2m x 1m x 4m
V \u003d 8 m 3
Nota: A especificação de unidades cúbicas de volume permite entender quantos desses cubos podem ser colocados dentro da caixa. Se nos referirmos ao exemplo anterior, isso significa que oito metros cúbicos são colocados em uma caixa.

Cálculo do volume de caixas de outras formas

Determine o volume do cilindro. O cilindro é um tubo redondo com círculos em ambas as extremidades. Para determinar o volume de um cilindro, utiliza-se a fórmula: V = π x r 2 x h, onde π = 3,14, r é o raio do lado redondo do cilindro eh é sua altura.
Para determinar o volume de um cone, ou de uma pirâmide de base redonda, utiliza-se a mesma fórmula, mas multiplicada por 1/3. Ou seja, o volume do cone é calculado pela fórmula: V = 1/3 (π x r 2 x h)

2
Determine o volume da pirâmide. Uma pirâmide é uma figura que tem uma base plana e lados convergentes no topo para um ponto. Para determinar o volume de uma pirâmide, você precisa pegar 1/3 do produto da área de base e altura. Ou seja, a fórmula de cálculo é a seguinte: Volume da pirâmide = 1/3 (Área da base x Altura).
Na maioria dos casos, as pirâmides têm uma base quadrada ou retangular. Em tal situação, a área da base é calculada multiplicando o comprimento da base pela largura.

Para determinar o volume de uma caixa de formas complexas, adicione os volumes de suas partes individuais. Por exemplo, você pode precisar medir o volume de uma caixa com a forma da letra "L". Nesse caso, a caixa terá mais lados para medir. Se você dividir essa caixa em duas partes, poderá medir o volume dessas duas partes da maneira padrão e adicionar os valores resultantes. No caso da caixa em forma de L, a parte mais longa pode ser considerada como uma caixa retangular longa separada, e a parte mais curta como uma caixa quadrada (ou quase quadrada) anexada a ela.
Se sua caixa tiver formas muito complexas, saiba que existem muitas maneiras de determinar o volume de objetos de qualquer forma.

    Escreva um programa que compare dois números inteiros digitados no teclado. O programa deve indicar qual número é maior ou, se os números forem iguais, exibir uma mensagem apropriada.

    Digite dois números inteiros e pressione Enter.
    -> 34 67
    34 menos de 67

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento principal é A, B: inteiro; begin Put_Line("Digite dois inteiros em uma linha e pressione Enter."); put("-> "); Arranje um); Obter(B); --Digite 2 números se A > B então Put(Item =>; A, Largura =>; 1); put("maior que"); Put(Item => B, Largura => 1); Elsif A< B then Put(Item =>A, Largura => 1); put("menor que"); Put(Item => B, Largura => 1); else Put("Os números digitados são iguais!"); fim se; final principal;

    Três inteiros são dados. Encontre o maior deles (o programa deve produzir exatamente um inteiro). O maior neste problema é entendido como um número que não é menor que qualquer outro.


  • -> 1 2 3
    Máximo de três números: 3
  • com Ada.Text_IO ; use Ada.Text_IO ; com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; procedimento principal é A, B, C: inteiro; máx.: inteiro; começar Put_Line( "Digite três números inteiros em uma linha e pressione Enter."); Put("-> "); Arranje um); Obter(B); Obter(C); --Digite três números inteiros máx.:=A; --predefinição consideramos que o número A é o máximo se B > max então --Se B for maior que o máximo, então máx.:=B; --número máximo é B fim se ; se C > max então --Se C é maior que o máximo, então máx.:=C; --número máximo é C fim se ; Por( "Máximo de três números:"& Integer"image(max) ); end main;

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento principal é A, B, C: inteiro; máx.: inteiro; begin Put_Line("Digite três inteiros em uma linha e pressione Enter."); put("-> "); Arranje um); Obter(B); Obter(C); --Digite três inteiros no máximo:= A; --por padrão, assumimos que o número A é o máximo se B > max então --Se B for maior que o máximo, então max:= B; --número máximo é B end if; se C > max então --Se C for maior que max, então max:= C; --número máximo é igual a C end if; Put("Máximo de três números:" & Integer"image(max)); end main;

    Dado três números naturais A, B, C. Determine se existe um triângulo com esses lados. Se o triângulo existir, imprima uma mensagem de que existe um triângulo com esses lados, caso contrário, imprima que o triângulo não existe.

  • Digite os três lados do triângulo e pressione Enter.
    -> 3 4 5
    Existe um triângulo com lados 3, 4, 5.

    • Um triângulo são três pontos que não estão na mesma linha. Um triângulo só existe se a soma de dois de seus lados for maior que o terceiro.

  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; --Para ler inteiros com Ada.Text_IO ; use Ada.Text_IO ; --Para exibir strings procedimento principal é a, b, c: inteiro; começar Put_Line( "Digite três lados de um triângulo e pressione Enter.Enter."); Put("-> "); Arranje um); Get(b); Obter(c); --Leia os lados do triângulo se a + b > c e então b + c > a e então c + a > b então --Verifica todas as condições em uma linha Por( "Triângulo com Lados"& Integer"image(a) & "," & Integer"image(b) & "," & Integer"image(c) & "existe" ); else Put( "Triângulo com Lados"& Integer"image(a) & "," & Integer"image(b) & "," & Integer"image(c) & " não existe" ); end if ; end main;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; --Para ler inteiros com Ada.Text_IO; use Ada.Text_IO; --Para imprimir strings o procedimento principal é a, b, c: Integer; begin Put_Line("Digite os três lados do triângulo e pressione Enter.Enter."); put("-> "); arranje um); obter(b); obter(c); --Lê os lados do triângulo se a + b > c e depois b + c > a e depois c + a > b depois -- Verifica todas as condições em uma linha Put("Triângulo com lados" & Integer"image(a) & " ," & Integer"image(b) & "," & Integer"image(c) & " existe"); else Put("Triângulo com lados" & Integer"image(a) & "," & Integer"image( b) & "," & Integer"imagem(c) & " não existe"); fim se; final principal;

    Três inteiros são dados. Determine quantos deles correspondem. O programa deve produzir um dos números: 3 (se todos forem iguais), 2 (se dois forem iguais) ou 0 (se todos forem diferentes).

  • Digite três números inteiros e pressione Enter.
    -> 1 2 3
    0
  • com Ada.Text_IO ; use Ada.Text_IO ; com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; procedimento Principal é A, B, C: Inteiro; começar Put_Line( "Digite três números inteiros e pressione Enter."); Put("-> "); Arranje um); Obter(B); Obter(C); se A = B e então A = C então --Se todos os três números corresponderem Put(Item => 3 , Largura => 1 ); elsif A = B ou A = C ou B = C então --Se dois números corresponderem Put(Item => 2 , Largura => 1 ); senão --Se um mesmos números Não Put(Item => 0 , Largura => 1 ); fim se ; endMain;

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento Principal é A, B, C: Inteiro; begin Put_Line("Digite três inteiros e pressione Enter."); put("-> "); Arranje um); Obter(B); Obter(C); se A = B e então A = C então --Se todos os três números corresponderem Put(Item => 3, Width => 1); elsif A = B ou A = C ou B = C então --Se dois números corresponderem Put(Item => 2, Width => 1); else --Se não houver números idênticos Put(Item => 0, Width => 1); fim se; endMain;

    A torre de xadrez se move horizontalmente ou verticalmente. Dado dois várias células tabuleiro de xadrez, determine se a torre pode se mover da primeira célula para a segunda em um movimento. O programa recebe como entrada quatro números de 1 a 8 cada, especificando o número da coluna e o número da linha, primeiro para a primeira célula, depois para a segunda célula. O programa deve imprimir "SIM" se for possível chegar à segunda da primeira célula pelo movimento da torre, ou "NÃO" caso contrário.


  • 4 4
    5 5
    NÃO
  • ); Por() ; Arranje um); Obter(B); Por() ; Obter(C); Obter d); se A = C ou B = D então Put("YES" ); else Put("NÃO"); fim se ; endMain;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento Main é o subtipo checkBoard é Integer range 1..8; A, B, C, D: Tabuleiro; begin Put_Line("Digite os números de coluna e linha para as duas células:"); Put("Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Put("Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se A = C ou B = D então Put("SIM"); else Put("NÃO"); fim se; endMain;

    O rei de xadrez se move horizontalmente, verticalmente e diagonalmente, mas apenas 1 casa. Dadas duas células diferentes em um tabuleiro de xadrez, determine se o rei pode passar da primeira célula para a segunda em um movimento. O programa recebe como entrada quatro números de 1 a 8 cada, especificando o número da coluna e o número da linha, primeiro para a primeira célula, depois para a segunda célula. O programa deve imprimir "SIM" se for possível chegar à segunda da primeira célula pelo movimento do rei, ou "NÃO" caso contrário.

  • Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 4 4
    Insira os números de coluna e linha para a segunda célula e pressione: 5 5
    SIM
  • "Digite os números de coluna e linha para as duas células:"); Por( "Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Por( "Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs (A - C)<= 1 and then abs (B - D) <= 1 then -- o comando abs() retorna o valor absoluto -- valor (módulo) do número Put("SIM"); else Put("NÃO"); fim se ; final principal;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento principal é subtipo checkBoard é intervalo inteiro 1..8; A, B, C, D: Tabuleiro; begin Put_Line("Digite os números de coluna e linha para as duas células:"); Put("Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Put("Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs(A - C)<= 1 and then abs(B - D) <= 1 then -- команда abs() возвращает абсолютное --значение (модуль) числа Put("ДА"); else Put("НЕТ"); end if; end main;

    O bispo de xadrez se move na diagonal. Dadas duas células diferentes de um tabuleiro de xadrez, determine se o bispo pode passar da primeira célula para a segunda em um movimento. O programa recebe como entrada quatro números de 1 a 8 cada, especificando o número da coluna e o número da linha, primeiro para a primeira célula, depois para a segunda célula. O programa deve emitir "SIM" se for possível chegar à segunda célula a partir da primeira célula pelo movimento do bispo, ou "Não" caso contrário.

  • Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 4 4
    Insira os números de coluna e linha para a segunda célula e pressione: 5 5
    SIM
  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento principal é subtipo checkBoard é intervalo inteiro 1 ..8 ; A, B, C, D: Tabuleiro; começar Put_Line( "Digite os números de coluna e linha para as duas células:"); Por( "Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Por( "Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs (a - c) = abs (b - d) then Put("YES" ); else Put("NÃO"); fim se ; final principal;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento principal é subtipo checkBoard é intervalo inteiro 1..8; A, B, C, D: Tabuleiro; begin Put_Line("Digite os números de coluna e linha para as duas células:"); Put("Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Put("Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs(a - c) = abs(b - d) então Put("SIM"); else Put("NÃO"); fim se; final principal;

    A rainha do xadrez se move diagonalmente, horizontalmente ou verticalmente. Dadas duas células diferentes de um tabuleiro de xadrez, determine se a rainha pode passar da primeira célula para a segunda em um movimento.

    Formato de dados de entrada:
    O programa recebe como entrada quatro números de 1 a 8 cada, especificando o número da coluna e o número da linha, primeiro para a primeira célula, depois para a segunda célula.
    Formato de saída:
    O programa deve mostrar SIM se for possível ir da primeira célula para a segunda pelo movimento da rainha, ou NÃO caso contrário.

    Exemplo 1:
    Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 1 1
    Insira os números de coluna e linha para a segunda célula e pressione: 2 2
    SIM

    Exemplo 2:
    Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 1 1
    Insira os números de coluna e linha para a segunda célula e pressione: 2 3
    NÃO

  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento Main é subtipo checkBoard é Integer range 1 ..8 ; A, B, C, D: Tabuleiro; começar Put_Line( "Digite os números de coluna e linha para as duas células:"); Por( "Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Por( "Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs (A - C) = abs (B - D) ou A = D ou B = C then Put("YES" ); else Put("NÃO"); fim se ; endMain;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento Main é o subtipo checkBoard é Integer range 1..8; A, B, C, D: Tabuleiro; begin Put_Line("Digite os números de coluna e linha para as duas células:"); Put("Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Put("Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs(A - C) = abs(B - D) ou A = D ou B = C then Put("YES"); else Put("NÃO"); fim se; endMain;

    O cavalo de xadrez se move na letra “G” - duas casas na vertical em qualquer direção e uma casa na horizontal, ou vice-versa. Dadas duas células diferentes de um tabuleiro de xadrez, determine se o cavalo pode passar da primeira célula para a segunda em um movimento. O programa recebe como entrada quatro números de 1 a 8 cada, especificando o número da coluna e o número da linha, primeiro para a primeira célula, depois para a segunda célula. O programa deve mostrar SIM se o cavaleiro puder passar da primeira célula para a segunda, ou NÃO caso contrário.

    Exemplo 1:
    Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 1 1
    Insira os números de coluna e linha para a segunda célula e pressione: 1 4
    NÃO

    Exemplo 2:
    Insira os números de coluna e linha para as duas células:
    Insira os números de coluna e linha para a primeira célula e pressione: 1 1
    Insira os números de coluna e linha para a segunda célula e pressione: 8 8
    NÃO

  • com Ada.Text_IO ; use Ada.Text_IO ; com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; procedimento principal é subtipo checkBoard é intervalo inteiro 1 ..8 ; A, B, C, D: inteiro; começar Put_Line( "Digite os números de coluna e linha para as duas células:"); Por( "Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Por( "Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs (A - C) = 2 e então abs (B - D) = 1 then Put("YES" ); elsif abs (A - C) = 1 e então abs (B - D) = 2 então Put("YES" ); else Put("NÃO"); fim se ; final principal;

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento principal é subtipo checkBoard é intervalo inteiro 1..8; A, B, C, D: inteiro; begin Put_Line("Digite os números de coluna e linha para as duas células:"); Put("Digite os números de coluna e linha para a primeira célula e pressione: "); Arranje um); Obter(B); Put("Digite os números de coluna e linha para a segunda célula e pressione: "); Obter(C); Obter d); se abs(A - C) = 2 e então abs(B - D) = 1 então Put("YES"); elsif abs(A - C) = 1 e então abs(B - D) = 2 então Put("YES"); else Put("NÃO"); fim se; final principal;

    O chocolate tem a forma de um retângulo dividido em N×M fatias. O chocolate pode ser quebrado uma vez em linha reta em duas partes. Determine se exatamente K fatias podem ser quebradas de uma barra de chocolate dessa maneira. O programa recebe três números como entrada: N, M, K. O programa deve emitir uma das duas palavras: "SIM" ou "Não".

    Exemplo 1:
    4
    2
    6
    SIM

    Exemplo 2:
    Número de fatias horizontalmente: 2
    Número de fatias verticalmente: 10
    Quantas fatias separar: 7
    NÃO

  • com Ada.Text_IO ; use Ada.Text_IO ; com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; procedimento Main é N, M, K: Inteiro; começar Colocar( "Número de fatias horizontalmente:"); Get(N); Por( "Número de fatias na vertical:"); Get(M); Por( "Quantas fatias separar:"); Get(K); se K > M * N então --Se uma barra de chocolate for solicitada a quebrar mais do que a própria barra de chocolate put("NÃO"); elsif K rem N = 0 e então K >= N então - Separar na horizontal Put("SIM"); elsif K rem M = 0 e então K >= M então - Separar verticalmente Put("SIM"); else Put("NÃO"); fim se ; endMain;

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento Main é N, M, K: Inteiro; begin Put("Número de fatias horizontalmente: "); Obter(N); Put("Número de fatias na vertical: "); Obter(M); Put("Quantas fatias separar: "); Get(K); if K > M * N then --Se a barra de chocolate for solicitada a quebrar mais do que a própria barra de chocolate Put("NO"); elsif K rem N = 0 e então K >= N então -- Interromper horizontalmente Put("YES"); elsif K rem M = 0 e então K >= M então -- Interromper verticalmente Put("YES"); else Put("NÃO"); fim se; endMain;

    Yasha nadou em uma piscina de N × M metros e se cansou. Neste ponto, ele se viu a X metros de uma das saliências longas (não necessariamente a mais próxima) e Y metros de uma das saliências curtas. Qual é a distância mínima que Yasha deve nadar para sair da piscina para o lado? O programa recebe como entrada os números N, M, X, Y. O programa deve gerar o número de metros que Yasha precisa para nadar para o lado.

  • Largura da Piscina: 23
    Comprimento da piscina: 52
    Distância de Yasha para o lado longo: 8
    Distância de Yasha a um lado curto: 43
    Você precisa nadar pelo menos para sair da piscina: 8

    • É possível que para resolver o problema você precise trocar 2 variáveis. Este algoritmo se parece com isso:

    a, b, tmp: inteiro; -- Declarando variáveis. Dois principais e um auxiliar a:= 3; --Inicialização da variável a b:= 5; --Inicialização da variável b --Próprio algoritmo: tmp:= a; --Agora tmp = 3 e a = 3 a:= b; --Agora a = 5 eb = 5; b:=tmp; --Agora b = 3

  • com Ada.Text_IO ; use Ada.Text_IO ; com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; procedimento Principal é N, M, X, Y: Inteiro; -- N - borda curta, M - borda longa: -- X - Distância a um dos lados longos -- Y - Distância a um dos lados curtos Tmp: inteiro; começar Colocar( "Largura da piscina: "); Get(N); Por( "Comprimento da piscina: "); Get(M); Por( "Distância de Yasha para um lado longo:"); Get(X); Por( "Distância de Yasha para o lado curto:"); Get(Y); se N > M então --Se os lados estiverem misturados durante a entrada, mudamos seus lugares: Tmp:=M; --Salva o comprimento M em uma variável temporária M:=N; --Atribui um novo valor à variável M N:=Tmp; --Restaura o comprimento M na variável N fim se ; Tmp:=X; --Suponha que a distância mínima é X se abs(N-X)< X then --Se a distância até a segunda borda longa for menor que X, então Tmp:= N - X; --distância mínima igual à distância até o segundo lado longo fim se ; se Y< Tmp then --Se a distância até a borda curta for menor que a encontrada acima -- mínimo, então Tmp:=Y; --Distância mínima é Y fim se ; se abs (M - Y)< Tmp then --Se você nadar mais perto do segundo lado curto, então Tmp:= abs (M - Y); --distância mínima é igual à distância até a segunda saliência curta fim se ; Por( "Você precisa nadar pelo menos para sair da piscina: "); Put(Item => Tmp, Largura => 1 ); endMain;

    com Ada.Text_IO; use Ada.Text_IO; com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedimento Principal é N, M, X, Y: Inteiro; -- N - borda curta, M - borda longa: -- X - Distância a uma das bordas longas -- Y - Distância a uma das bordas curtas Tmp: Inteiro; begin Put("Largura do conjunto: "); Obter(N); Put("Tamanho do conjunto: "); Obter(M); Put("Distância de Yasha até o lado maior: "); Get(X); Put("Distância de Yasha até a borda curta: "); Get(Y); se N > M então --Se as arestas estiverem misturadas durante a entrada, então trocamos de lugar: Tmp:= M; --Salva o comprimento M em uma variável temporária M:= N; --Atribui um novo valor à variável M N:= Tmp; --Restaura o comprimento M na variável N end if; Tmp:=X; --Suponha que a distância mínima é X se 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, Largura => 1); endMain;

    O relógio eletrônico mostra a hora no formato h:mm:ss (de 0:00:00 às 23:59:59), ou seja, primeiro é registrado o número de horas, depois o número de minutos de dois dígitos é obrigatório , o número de segundos de dois dígitos é obrigatório. O número de minutos e segundos, se necessário, são preenchidos para número de dois dígitos zeros. N segundos se passaram desde o início do dia. Saída o que o relógio mostra. A entrada é um número natural N, não superior a 10 7 (10000000). Emita a resposta para o problema.

    Exemplo de entrada 1:
    3602
    Exemplo de saída 1:
    1:00:02

    Exemplo de entrada 2:
    129700
    Exemplo de saída 2:
    12:01:40

  • com Ada.Long_Integer_Text_IO ; use Ada.Long_Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento Main é subtipo Sub_LI é Long_Integer range 1 ..10000000 ; N: Sub_LI; h, m, s: Long_Integer; começar Get(N); h:= N/3600 ; - Pegamos o relógio. O restante da divisão é descartado N:= N - h * 3600; --Obter segundos restantes (menos horas) se h > 24 então --Como o relógio não pode mostrar > 24, colocamos tudo em um formato legível h:= hrem24; --O resto da divisão por 24 dará o número exato de horas elsif h = 24 então h:= 0 ; fim se ; m:= N/60; --Obter minutos s:= Nrem 60 ; --Obter segundos Put(Item => h, Largura => 1 ); Por(":"); -- Horas de saída e ":" se m< 10 then --Se o número de minutos for menor que 10, gera um 0 inicial Put(Item => 0 , Largura => 1 ); fim se ; Put(Item => m, Largura => 1); Por(":"); -- Minutos de saída e ":" se s< 10 then --Se o número de segundos for menor que 10, gera um 0 inicial Put(Item => 0 , Largura => 1 ); fim se ; Put(Item => s, Largura => 1 ); --Saída segundos final principal;

    com Ada.Long_Integer_Text_IO; use Ada.Long_Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento Main é subtipo Sub_LI é Long_Integer range 1..10000000; N: Sub_LI; h, m, s: Long_Integer; começar Get(N); h:= N/3600; - Pegamos o relógio. O restante da divisão é descartado N:= N - h * 3600; --Obter os segundos restantes (menos horas) se h > 24 então --Como os relógios não podem ler > 24, coloque tudo na forma legível por humanos h:= h rem 24; --O resto da divisão por 24 dará o número exato de horas elsif h = 24 then h:= 0; fim se; m:= N/60; --Obter minutos s:= N rem 60; --Get segundos Put(Item => h, Largura => 1); Por(":"); --Horas de saída e ":" se m< 10 then --Если количество минут меньше 10, выводим ведущий 0 Put(Item =>0, Largura => 1); fim se; Put(Item => m, Largura => 1); Por(":"); --Output minutos e ":" se s< 10 then --Если количество секунд меньше 10, выводим ведущий 0 Put(Item =>0, Largura => 1); fim se; Put(Item => s, Largura => 1); --Saída segundos final principal;

  • Três números são dados. Organize-os em ordem crescente.
  • Exemplo de entrada:
    1 2 1
    Saída de amostra:
    1 1 2
  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento Principal é A, B, C: Inteiro; min, mid, max: inteiro; começar Get(A) ; Obter(B); Obter(C); --está procurando valor mínimo min:=A; se B< min then min:= B; end if ; if C < min then min:= C; end if ; --está procurando valor máximo máx.:=A; se B > max então max:= B; fim se ; se C > max então max:= C; fim se ; --Procurando o valor médio meio:=A; se B > min e B< max then mid:= B; end if ; if C >min e C< max then mid:= C; end if ; Put(Item =>min, Largura => 1); por(" "); Put(Item => meio, largura => 1); por(" "); Put(Item => max, Largura => 1); endMain;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento Principal é A, B, C: Inteiro; min, mid, max: inteiro; começar Get(A); Obter(B); Obter(C); --Procurando o valor mínimo min:= A; se B< min then min:= B; end if; if C < min then min:= C; end if; --Ищем максимальное значение max:= A; if B >max então max:= B; fim se; se C > max então max:= C; fim se; --Procurando o valor médio mid:= A; se B > min e B< max then mid:= B; end if; if C >min e C< max then mid:= C; end if; Put(Item =>min, Largura => 1); por(" "); Put(Item => meio, largura => 1); por(" "); Put(Item => max, Largura => 1); endMain;

    Existem duas caixas, a primeira é A1×B1×C1, a segunda é A2×B2×C2. Determine se uma dessas caixas pode ser colocada dentro da outra, desde que as caixas só possam ser giradas 90 graus em torno das bordas. O programa recebe os números A1, B1, C1, A2, B2, C2 como entrada. O programa deve gerar uma das seguintes linhas:
    - "Caixas são iguais" se as caixas forem iguais,
    - "Primeira caixa menos de um segundo"se a primeira caixa pode ser colocada na segunda,
    - "Primeira caixa mais de um segundo" se a segunda caixa pode ser colocada dentro da primeira.

    Exemplo 1:
    Dimensões da primeira caixa: 1 2 3
    Dimensões da segunda caixa: 3 2 1
    As caixas são iguais

    Exemplo 2:
    Dimensões da primeira caixa: 2 2 3
    Dimensões da segunda caixa: 3 2 1
    A primeira caixa é maior que a segunda

  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento principal é A1, B1, C1, A2, B2, C2: inteiro; min, max, mid, tmp: inteiro; começar Get(A1); Get(B1); Get(C1); Get(A2); Get(B2); Get(C2); --Alinhar as faces com os comprimentos A1 => A2, B1 => B2, C1 => C2: --A1 e A2 são os mais longos, C1 e C2 são os mais curtos -- "Girar" a primeira caixa: min:=A1; meio:=B1; máx.:=C1; se B1< min then mid:= min; min:= B1; end if ; if C1 < min then max:= min; min:= C1; end if ; if mid >max então tmp:= mid; medio:=max; max:=tmp; fim se ; A1:=min; B1:=médio; C1:=máx; -- "Girar" a segunda caixa: min:=A2; meio:=B2; máx.:=C2; se B2< min then mid:= min; min:= B2; end if ; if C2 < min then max:= min; min:= C2; end if ; if mid >max então tmp:= mid; medio:=max; max:=tmp; fim se ; A2:=min; B2:=médio; C2:=max; --Verificando a correspondência das caixas e exibindo o resultado: if A1 = A2 e então B1 = B2 e então C1 = C2 then Put_Line("As caixas são iguais" ); elsif A1 >= A2 e então B1 >= B2 e então C1 >= C2 então Put_Line( "A primeira caixa é maior que a segunda"); Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("A primeira caixa é menor que a segunda"); fim se ; final principal;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento principal é A1, B1, C1, A2, B2, C2: inteiro; min, max, mid, tmp: inteiro; começar Get(A1); Obter(B1); Obter(C1); Obter(A2); Obter(B2); Obter(C2); --Alinhar os lados com os comprimentos A1 => A2, B1 => B2, C1 => C2: --A1 e A2 - o mais longo, C1 e C2 - o mais curto -- "Torcer" a primeira caixa: min := A1 ; meio:=B1; máx.:=C1; se B1< min then mid:= min; min:= B1; end if; if C1 < min then max:= min; min:= C1; end if; if mid >max então tmp:= mid; medio:=max; max:=tmp; fim se; A1:=min; B1:=médio; C1:=máx; -- "Gira" a segunda caixa: min:= A2; meio:=B2; máx.:=C2; se B2< min then mid:= min; min:= B2; end if; if C2 < min then max:= min; min:= C2; end if; if mid >max então tmp:= mid; medio:=max; max:=tmp; fim se; A2:=min; B2:=médio; C2:=max; --Verifica se as caixas correspondem e exibe o resultado: if A1 = A2 and then B1 = B2 and then C1 = C2 then Put_Line("Boxes are equal"); elsif A1 >= A2 e então B1 >= B2 e então C1 >= C2 então Put_Line("A primeira caixa é maior que a segunda"); Elsif A1<= A2 and then B1 <= B2 and then C1 <= C2 then Put_Line("Первая коробка меньше второй"); end if; end main;

    Escreva um programa que calcule o custo de uma conversa telefônica de longa distância (o preço de um minuto é determinado pela distância até a cidade onde o assinante está localizado). Os dados iniciais do programa são o código de área e a duração da chamada. Abaixo estão os códigos de algumas cidades e a visualização de tela recomendada durante a execução do programa:

  • Calcule o custo de uma conversa telefônica.
    Insira os dados iniciais:
    Código da cidade -> 423
    Duração (minutos inteiros) -> 3
    cidade de Vladivostok
    Preço por minuto: 4 rublos.
    Custo da chamada: 12 rublos.
  • com Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; com Ada.Text_IO ; use Ada.Text_IO ; procedimento principal é Código, Len: inteiro; começar Put_Line ("Cálculo do custo de uma conversa telefônica.") ; Put_Line ("Digite os dados iniciais:") ; Por ("Código da cidade -> ") ; Obter ( Código ) ; Por ("Duração (minutos inteiros) -> ") ; Obter ( len ) ; caso Código é quando 423 => Put_Line ("Cidade de Vladivostok") ; Put_Line ("Preço de um minuto: 4 rublos.") ; Por ("Custo da chamada: ") ; Por ( Item => len * 4 , Largura=> 1 ) ; Put_Line ("esfregar.") ; quando 095 => Put_Line ("Cidade de Moscou") ; Put_Line ("Preço de um minuto: 2 rublos.") ; Por ("Custo da chamada: ") ; Por ( Item => len * 2 , Largura=> 1 ) ; Put_Line ("esfregar.") ; quando 815 => Put_Line ("Cidade: Murmansk") ; Put_Line ("Preço de um minuto: 3 rublos.") ; Por ("Custo da chamada: ") ; Por ( Item => len * 3 , Largura=> 1 ) ; Put_Line ("esfregar.") ; quando 846 => Put_Line ("Cidade de Samara") ; Put_Line ("Preço de um minuto: 1 esfregar.") ; Por ("Custo da chamada: ") ; Por ( Item => len, Largura => 1 ) ; Put_Line ("esfregar.") ; quando outros=> Colocar ("Não há cidade com este código no banco de dados! Tente novamente.") ; fim caso; fim a Principal;

    com Ada.Integer_Text_IO; use Ada.Integer_Text_IO; com Ada.Text_IO; use Ada.Text_IO; procedimento Main é Código, Len: Integer; begin Put_Line("Calculando o custo de uma chamada telefônica."); Put_Line("Digite os dados iniciais:"); Put("Código da cidade -> "); Obter código); Put("Duração (minutos inteiros) -> "); get(len); case Código é quando 423 => Put_Line("Cidade: Vladivostok"); Put_Line("Preço por minuto: 4 rublos."); Put("Custo da chamada: "); Put(Item => len * 4, Largura => 1); Put_Line(" esfregar."); when 095 => Put_Line("Cidade: Moscou"); Put_Line("Preço por minuto: 2 rublos."); Put("Custo da chamada: "); Put(Item => len * 2, Largura => 1); Put_Line(" esfregar."); when 815 => Put_Line("Cidade: Murmansk"); Put_Line("Preço por minuto: 3 rublos."); Put("Custo da chamada: "); Put(Item => len * 3, Largura => 1); Put_Line(" esfregar."); when 846 => Put_Line("Cidade: Samara"); Put_Line("Preço por minuto: 1 rub."); Put("Custo da chamada: "); Put(Item => len, Largura => 1); Put_Line(" esfregar."); when other => Put("Não há cidade com este código no banco de dados! Tente novamente."); caso final; endMain;

A seção descreve brevemente os operadores E se e caso, função abdômen() e um algoritmo para troca de variáveis.

Definição.

Este é um hexágono cujas bases são dois quadrado igual, e as faces laterais são retângulos iguais

Costela lateral- Esse lado comum duas faces laterais adjacentes

Altura do Prisma- isso é um corte perpendicular às bases prismas

Prisma Diagonal- um segmento conectando dois vértices das bases que não pertencem à mesma face

Plano diagonalé o plano que passa pela diagonal do prisma e sua costelas laterais

Seção diagonal - os limites da intersecção do prisma e do plano diagonal. A seção diagonal de um prisma quadrangular regular é um retângulo

Seção perpendicular (seção ortogonal)- esta é a interseção de um prisma e um plano desenhado perpendicularmente às suas arestas laterais

Elementos de um prisma quadrangular regular

A figura mostra dois prismas quadrangulares regulares, marcados com as letras correspondentes:

  • As bases ABCD e A 1 B 1 C 1 D 1 são iguais e paralelas entre si
  • Faces laterais AA 1 D 1 D, AA 1 B 1 B, BB 1 C 1 C e CC 1 D 1 D, cada um dos quais é um retângulo
  • Superfície lateral- a soma das áreas de todas as faces laterais do prisma
  • Superfície total - a soma das áreas de todas as bases e faces laterais (a soma da área da superfície lateral e das bases)
  • Costelas laterais AA 1 , BB 1 , CC 1 e DD 1 .
  • Diagonal B 1 D
  • Base diagonal BD
  • Seção diagonal BB 1 D 1 D
  • Seção perpendicular A 2 B 2 C 2 D 2 .

Propriedades de um prisma quadrangular regular

  • As bases são dois quadrados iguais
  • As bases são paralelas entre si
  • Os lados são retângulos.
  • As faces laterais são iguais entre si
  • As faces laterais são perpendiculares às bases
  • As costelas laterais são paralelas entre si e iguais
  • Seção perpendicular perpendicular a todas as nervuras laterais e paralela às bases
  • cantos seção perpendicular- Em linha reta
  • A seção diagonal de um prisma quadrangular regular é um retângulo
  • Perpendicular (seção ortogonal) paralela às bases

Fórmulas para um prisma quadrangular regular

Instruções para resolver problemas

Ao resolver problemas sobre o tema " correto prisma quadrangular " implica que:

Prisma correto- um prisma na base do qual se encontra polígono regular, e as arestas laterais são perpendiculares aos planos de base. Ou seja, um prisma quadrangular regular contém em sua base quadrado. (veja acima as propriedades de um prisma quadrangular regular) Observação. Isso faz parte da lição com tarefas em geometria (seção de geometria sólida - prisma). Aqui estão as tarefas que causam dificuldades na resolução. Se você precisa resolver um problema de geometria, que não está aqui - escreva sobre isso no fórum. Para indicar a ação de extrair raiz quadrada símbolo é usado na resolução de problemas√ .

Tarefa.

Em um prisma quadrangular regular, a área da base é 144 cm 2 e a altura é 14 cm. Encontre a diagonal do prisma e a área superfície cheia.

Decisão.
Um quadrilátero regular é um quadrado.
Assim, o lado da base será igual a

√144 = 12 cm.
De onde vem a diagonal da base? prisma Retângular será igual a
√(12 2 + 12 2 ) = √288 = 12√2

Diagonal prisma direito forma com a diagonal da base e a altura do prisma triângulo retângulo. Assim, de acordo com o teorema de Pitágoras, a diagonal de um dado prisma quadrangular regular será igual a:
√((12√2) 2 + 14 2 ) = 22 cm

Responda: 22cm

Tarefa

Encontre a área total de um prisma quadrangular regular se sua diagonal for 5 cm e a diagonal da face lateral for 4 cm.

Decisão.
Como a base de um prisma quadrangular regular é um quadrado, então o lado da base (indicado como a) é encontrado pelo teorema de Pitágoras:

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

A altura da face lateral (indicada como h) será então igual a:

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

A área de superfície total será igual à soma da área de superfície lateral e duas vezes a área de base

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.

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

Os carros com transmissão manual, que é abreviada como transmissão manual, até recentemente ascendiam a maioria absoluta entre outros veículos com diferentes.

Além disso, uma caixa mecânica (manual) continua sendo um dispositivo bastante comum para alterar e transmitir o torque do motor hoje. A seguir, falaremos sobre como a "mecânica" é organizada e funciona, como é o esquema de caixa de engrenagens desse tipo e também quais vantagens e desvantagens essa solução possui.

Leia neste artigo

Diagrama de transmissão manual e recursos

Para começar, esse tipo de caixa de câmbio é chamado de mecânico devido ao fato de tal unidade envolver a troca manual de marchas. Em outras palavras, em carros com transmissão manual, o próprio motorista troca de marcha.

Nós vamos mais longe. A caixa "mecânica" é escalonada, ou seja, o torque muda em etapas. Muitos motoristas sabem que a caixa de câmbio realmente possui engrenagens e eixos, mas nem todos entendem como a unidade funciona.

Assim, um estágio (também é uma transmissão) é um par de engrenagens (motor e acionado) interagindo entre si. Cada um desses estágios fornece rotação com uma ou outra velocidade angular, ou seja, possui sua própria relação de transmissão.

A relação de transmissão deve ser entendida como a relação entre o número de dentes da engrenagem movida e o número de dentes da engrenagem motriz. Neste caso, diferentes estágios da caixa recebem diferentes relações de transmissão. A marcha mais baixa (baixa marcha) tem a maior relação de transmissão e a mais passo alto(upshift) tem a menor relação de transmissão.

Fica claro que o número de etapas é igual ao número de marchas em uma caixa específica (caixa de quatro marchas, cinco marchas, etc.) anteriormente de 4 marchas caixas mecânicas engrenagem gradualmente desapareceu em segundo plano.

Dispositivo de transmissão manual

Portanto, embora possa haver muitos designs de tal caixa com certos recursos, no entanto, Estado inicial dois tipos principais podem ser distinguidos:

  • caixas de engrenagens de três eixos;
  • caixas de dois eixos;

Uma caixa de câmbio manual de três eixos é geralmente instalada em carros com tração traseira, enquanto uma caixa de câmbio de dois eixos é colocada em carros de passeio com tração dianteira. Ao mesmo tempo, o dispositivo de caixas de engrenagens mecânicas do primeiro e do segundo tipos pode diferir acentuadamente.

Vamos começar com uma caixa mecânica de três eixos. Esta caixa contém:

  • o eixo de acionamento, que também é chamado de primário;
  • caixa de engrenagens do eixo intermediário;
  • eixo acionado (secundário);

Engrenagens com sincronizadores são instaladas nos eixos. O mecanismo de mudança de marchas também está incluído na caixa de câmbio. Especificadas elementos constituintes localizado na caixa da caixa de engrenagens, que também é chamada de caixa da caixa de engrenagens.

A tarefa do eixo de acionamento é criar uma conexão com a embreagem. O eixo de acionamento possui ranhuras para o disco de embreagem. Quanto ao torque, o torque especificado do eixo de entrada é transmitido através da engrenagem, que está em engate rígido com ela.

Afetando o trabalho do eixo intermediário, este eixo está localizado paralelo ao eixo de entrada da caixa de engrenagens, um grupo de engrenagens é instalado nele, que está em engate rígido. Por sua vez, o eixo acionado é montado no mesmo eixo que o eixo de acionamento.

Tal instalação é implementada usando um rolamento de extremidade no eixo de acionamento. Este rolamento inclui o eixo acionado. O conjunto de engrenagens (bloco de engrenagens) no eixo acionado não possui um engate rígido com o próprio eixo e, portanto, gira livremente sobre ele. Neste caso, o grupo de engrenagens do eixo intermediário, o eixo acionado e a engrenagem do eixo de acionamento estão em constante engate.

Sincronizadores (acoplamentos sincronizadores) são instalados entre as engrenagens do eixo acionado. Sua tarefa é alinhar as velocidades angulares das engrenagens do eixo acionado com a velocidade angular do próprio eixo através da força de atrito.

Os sincronizadores estão em engate rígido com o eixo acionado e também têm a capacidade de se mover ao longo do eixo na direção longitudinal devido à conexão estriada. As caixas de câmbio modernas possuem embreagens sincronizadoras em todas as marchas.

Se considerarmos o mecanismo de mudança de marchas em caixas de engrenagens de três eixos, muitas vezes esse mecanismo é instalado no corpo da unidade. O design inclui uma alavanca de controle, controles deslizantes e garfos.

O corpo da caixa (cárter) é feito de ligas de alumínio ou magnésio, é necessário instalar eixos com engrenagens e mecanismos, além de várias outras peças. Há também óleo de engrenagem (óleo de caixa de engrenagens) na carcaça da caixa de engrenagens.

  • Para entender como funciona uma caixa de câmbio mecânica (manual) do tipo três eixos, vamos em termos gerais Vamos dar uma olhada em como ele funciona. Quando a alavanca de câmbio está na posição neutra, não há transmissão de torque do motor para as rodas motrizes do veículo.

Após o motorista movimentar a alavanca, o garfo movimentará a embreagem sincronizadora de uma ou outra marcha. O sincronizador irá então alinhar velocidades angulares engrenagem desejada e eixo acionado. Em seguida, o anel de engrenagem da embreagem irá engatar com um anel de engrenagem semelhante, o que garantirá que a engrenagem esteja travada no eixo acionado.

Acrescentamos também que a marcha-atrás do carro é fornecida pela marcha-atrás da caixa de velocidades. Neste caso, uma marcha lenta de ré montada em um eixo separado permite que o sentido de rotação seja invertido.

Caixa de velocidades manual de dois eixos: dispositivo e princípio de operação

Tendo lidado com o que consiste uma caixa de câmbio de três eixos, vamos passar para as caixas de câmbio de dois eixos. Esse tipo A caixa de engrenagens possui dois eixos em seu dispositivo: primário e secundário. O eixo de entrada é o acionador, o secundário é o acionado. Engrenagens e sincronizadores são fixados nos eixos. Também no cárter da caixa está a engrenagem principal e o diferencial.

O eixo de acionamento é responsável pela conexão com a embreagem, existindo também um bloco de engrenagens no eixo em engate rígido com o eixo. O eixo acionado está localizado paralelo ao eixo de acionamento, enquanto as engrenagens do eixo acionado estão em constante engate com as engrenagens do eixo de acionamento e também giram livremente no próprio eixo.

Além disso, a engrenagem de acionamento da engrenagem principal é fixada rigidamente no eixo acionado e os acoplamentos sincronizadores estão localizados entre as engrenagens do próprio eixo acionado. Adicionamos, para reduzir o tamanho da caixa de engrenagens, bem como aumentar o número de engrenagens, em caixas de engrenagens modernas, 2 ou até 3 eixos podem ser instalados em vez de um eixo acionado.

Em cada um desses eixos, a engrenagem da engrenagem principal é fixada rigidamente, enquanto essa engrenagem tem um engate rígido com a engrenagem acionada. Acontece que o design realmente implementa 3 engrenagens principais.

A própria engrenagem principal, bem como o diferencial no dispositivo da caixa de engrenagens, transmitem torque do eixo secundário para as rodas motrizes. Neste caso, o diferencial também pode proporcionar essa rotação das rodas quando as rodas motrizes giram em diferentes velocidades angulares.

Quanto ao mecanismo de mudança de marchas, nas caixas de câmbio de dois eixos, ele é retirado separadamente, ou seja, fora do corpo. A caixa é conectada ao mecanismo de comutação por cabos ou hastes especiais. A conexão mais comum é com cabos.

O mecanismo de mudança da própria caixa de 2 eixos possui uma alavanca, que é conectada por cabos à alavanca seletora e à alavanca de câmbio. Essas alavancas são conectadas à haste de mudança central, que também possui garfos.

  • Se falamos sobre o princípio de operação de uma caixa de câmbio manual de dois eixos, é semelhante ao princípio de uma caixa de câmbio de três eixos. As diferenças estão em como o mecanismo de mudança de marchas funciona. Em poucas palavras, a alavanca pode realizar movimentos longitudinais e transversais em relação ao eixo do carro. No decorrer movimento transversal a seleção de marchas ocorre, pois a força é aplicada ao cabo de seleção de marchas, que atua na alavanca seletora de marchas.

Além disso, a alavanca se move longitudinalmente e a força vai para o cabo de mudança de marchas. A alavanca correspondente move horizontalmente a haste com os garfos, o garfo na haste desloca o sincronizador, o que leva ao bloqueio da engrenagem do eixo acionado.

Por fim, notamos que também as caixas mecânicas tipos diferentes ter dispositivos de bloqueio adicionais que impeçam a inclusão de duas engrenagens ao mesmo tempo ou um desengate inesperado da engrenagem.

Leia também

Pressionar a embreagem antes de ligar o motor: quando pressionar a embreagem e em que casos não é recomendado fazê-lo. Dicas úteis e recomendações.

  • Causas de mudança de marcha difícil em um motor em funcionamento. Óleo da transmissão e nível na caixa de câmbio, desgaste dos sincronizadores e engrenagens da caixa, embreagem.



    • ARTIGOS RELACIONADOS