----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

' Esta macro AutoCAD VBA mostra como selecionar uma linha
' na área de desenho do AutoCAD e retornar suas coordenadas
' iniciais e finais
Sub CoordenadasLinha()
  ' vamos declarar um variável para receber a linha
  ' selecionada
  Dim linha As AcadLine
  ' e também a localização da linha
  Dim localizacao As Variant
  ' para guardar o ponto inicial
  Dim ponto_inicial As Variant
  ' para guardar o ponto final
  Dim ponto_final As Variant
   
  ' caso haja algum erro
  On Error Resume Next
   
  ' agora pedimos para o usuário selecionar a linha
  ThisDrawing.Utility.GetEntity linha, localizacao, _
    "Selecione uma linha"
   
  ' vamos obter o ponto inicial da linha
  ponto_inicial = linha.StartPoint
  ' vamos obter o ponto final da linha
  ponto_final = linha.EndPoint
   
  ' e mostramos as coordenadas iniciais e finais da linha
  ThisDrawing.Utility.Prompt "As coordenadas iniciais são: X = " _
    & ponto_inicial(0) & "; Y = " & ponto_inicial(1) & "; Z = " _
    & ponto_inicial(2)
  ThisDrawing.Utility.Prompt vbCrLf & "As coordenadas finais são: X = " _
    & ponto_final(0) & "; Y = " & ponto_final(1) & "; Z = " _
    & ponto_final(2)
End Sub

Piano Timbres:

 1	Acoustic Grand Piano
 2	Bright Acoustic Piano
 3	Electric Grand Piano
 4	Honky-tonk Piano
 5	Rhodes Piano
 6	Chorused Piano
 7	Harpsichord
 8	Clavinet

Chromatic Percussion:
 9	Celesta
10	Glockenspiel
11	Music Box
12	Vibraphone
13	Marimba
14	Xylophone
15	Tubular Bells
16	Dulcimer

Organ Timbres:
17	Hammond Organ
18	Percussive Organ
19	Rock Organ
20	Church Organ
21	Reed Organ
22	Accordion
23	Harmonica
24	Tango Accordion
 
Guitar Timbres:
25	Acoustic Nylon Guitar
26	Acoustic Steel Guitar
27	Electric Jazz Guitar
28	Electric Clean Guitar
29	Electric Muted Guitar
30	Overdriven Guitar
31	Distortion Guitar
32	Guitar Harmonics

Bass Timbres:
33	Acoustic Bass
34	Fingered Electric Bass
35	Plucked Electric Bass
36	Fretless Bass
37	Slap Bass 1
38	Slap Bass 2
39	Synth Bass 1
40	Synth Bass 2

String Timbres:
41	Violin
42	Viola
43	Cello
44	Contrabass
45	Tremolo Strings
46	Pizzicato Strings
47	Orchestral Harp
48	Timpani
 
Ensemble Timbres:
49	String Ensemble 1
50	String Ensemble 2
51	Synth Strings 1
52	Synth Strings 2
53	Choir "Aah"
54	Choir "Ooh"
55	Synth Voice
56	Orchestral Hit

Brass Timbres:
57	Trumpet
58	Trombone
59	Tuba
60	Muted Trumpet
61	French Horn
62	Brass Section
63	Synth Brass 1
64	Synth Brass 2

Reed Timbres:
65	Soprano Sax
66	Alto Sax
67	Tenor Sax
68	Baritone Sax
69	Oboe
70	English Horn
71	Bassoon
72	Clarinet
 
Pipe Timbres:
73	Piccolo
74	Flute
75	Recorder
76	Pan Flute
77	Bottle Blow
78	Shakuhachi
79	Whistle
80	Ocarina

Synth Lead:
81	Square Wave Lead
82	Sawtooth Wave Lead
83	Calliope Lead
84	Chiff Lead
85	Charang Lead
86	Voice Lead
87	Fifths Lead
88	Bass Lead

Synth Pad:
89	New Age Pad
90	Warm Pad
91	Polysynth Pad
92	Choir Pad
93	Bowed Pad
94	Metallic Pad
95	Halo Pad
96	Sweep Pad
 
Synth Effects:
 97	Rain Effect
 98	Soundtrack Effect
 99	Crystal Effect
100	Atmosphere Effect
101	Brightness Effect
102	Goblins Effect
103	Echoes Effect
104	Sci-Fi Effect

Ethnic Timbres:
105	Sitar
106	Banjo
107	Shamisen
108	Koto
109	Kalimba
110	Bagpipe
111	Fiddle
112	Shanai

Sound Effects:
113	Tinkle Bell
114	Agogo
115	Steel Drums
116	Woodblock
117	Taiko Drum
118	Melodic Tom
119	Synth Drum
120	Reverse Cymbal
 
Sound Effects:
121	Guitar Fret Noise
122	Breath Noise
123	Seashore
124	Bird Tweet
125	Telephone Ring
126	Helicopter
127	Applause
128	Gun Shot

A especificação MIDI define que o canal 10 seja reservado
para os kits de percussão. Os instrumentos abaixo possuem
os números de notas a serem enviados neste canal.

35	Acoustic Bass Drum
36	Bass Drum 1
37	Side Stick
38	Acoustic Snare
39	Hand Clap
40	Electric Snare
41	Low Floor Tom
42	Closed High Hat
43	High Floor Tom
44	Pedal High Hat
45	Low Tom
46	Open High Hat
47	Low Mid Tom
48	High Mid Tom
49	Crash Cymbal 1
50	High Tom
51	Ride Cymbal 1
52	Chinese Cymbal
53	Ride Bell
54	Tambourine
55	Splash Cymbal
56	Cowbell
57	Crash Cymbal 2
58	Vibraslap
59	Ride Cymbal 2
60	High Bongo
61	Low Bongo
62	Mute High Conga
63	Open High Conga
64	Low Conga
65	High Timbale
66	Low Timbale
67	High Agogo
68	Low Agogo
69	Cabasa
70	Maracas
71	Short Whistle
72	Long Whistle
73	Short Guiro
74	Long Guiro
75	Claves
76	High Wood Block
77	Low Wood Block
78	Mute Cuica
79	Open Cuica
80	Mute Triangle
81	Open Triangle

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <windows.h>

using namespace std;

int main(int argc, char *argv[]) {
  unsigned int erro; // guarda o erro caso algo dê errado
  HMIDIOUT saida; // handle para o dispositivo de saída MIDI.

  // vamos abrir o dispositivo de saída MIDI
  erro = midiOutOpen(&saida, MIDI_MAPPER, 0, 0, CALLBACK_NULL);
  if (erro != MMSYSERR_NOERROR) {
    printf("Não foi possível abrir o mapeador MIDI: %d\n", erro);
  }
  else {
    printf("Mapeador MIDI aberto com sucesso\n");
  }

  // vamos definir o instrumento como Overdriven Guitar
  // no canal 1
  midiOutShortMsg(saida, 0x00001DC0);

  // vamos tocar o dó central com velocidade 100
  midiOutShortMsg(saida, 0x00643C90);
  Sleep(1000); // a nota vai durar 1 segundo
  // dispara a mensagem Note-off
  midiOutShortMsg(saida, 0x00643C80);

  // agora vamos fechar o dispositivo de saída MIDI
  midiOutClose(saida);

  system("PAUSE");
  return EXIT_SUCCESS;
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos{
  public static void main(String[] args){
    // vamos usar a classe Scanner para ler os dados
    Scanner entrada = new Scanner(System.in);
    
    // vamos ler as coordenadas do primeiro ponto
    System.out.print("Coordenada x do primeiro ponto: ");
    double x1 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do primeiro ponto: ");
    double y1 = Double.parseDouble(entrada.nextLine());
    
    // vamos ler as coordenadas do segundo ponto
    System.out.print("Coordenada x do segundo ponto: ");
    double x2 = Double.parseDouble(entrada.nextLine());
    System.out.print("Coordenada y do segundo ponto: ");
    double y2 = Double.parseDouble(entrada.nextLine());
    
    String sinal = "+";
    // vamos calcular o coeficiente angular da reta
    double m = (y2 - y1) / (x2 - x1);
    // vamos calcular o coeficiente linear
    double n = y1 - (m * x1);
 
    // coeficiente linear menor que zero? O sinal será negativo
    if (n < 0){
      sinal = "-";
      n = n * -1;
    }
  
    // mostra a equação reduzida da reta
    System.out.println("Equação reduzida: y = " + m + "x" 
      + " " + sinal + " " + n);
    
    System.exit(0);
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

>> y = (-0.75 * 3) + 8.75
y = 6.5000

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  // vamos declarar um vetor de 10 inteiros
  int valores[10];
  int i;

  // agora vamos solicitar ao usuário que informe os 10 valores para
  // os elementos do vetor. O mais recomendável neste caso é usar um
  // laço for que repetirá 10 vezes e, a cada repetição, solicitaremos
  // um valor
  for(i = 0; i < 10; i++){
    printf("Informe o valor %d: ", (i + 1));
    scanf("%d", &valores[i]);
  }

  // para finalizar vamos exibir os valores informados pelo usuário e
  // presentes nos elementos do vetor
  printf("\nOs valores informados foram:\n");

  for(i = 0; i < 10; i++){
    printf("O valor %d foi: %d\n", (i + 1), valores[i]);
  }
  
  system("PAUSE");	
  return 0;
}

Informe um número inteiro: 16
O número informado foi: 16
O antecessor é 15
O sucessor é: 17

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;

namespace Estudos {
  class Principal {
    static void Main(string[] args) {
      // vamos pedir ao usuário que informe um número inteiro
      Console.Write("Informe um número inteiro: ");
      int numero = Int32.Parse(Console.ReadLine());

      // vamos calcular o sucessor do número informado
      int sucessor = numero + 1;

      // vamos calcular o antecessor do número informado
      int antecessor = numero - 1;

      // e agora mostramos os resultados
      Console.WriteLine("O número informado foi: {0}", numero);
      Console.WriteLine("O antecessor é {0}", antecessor);
      Console.WriteLine("O sucessor é: {0}", sucessor);

      Console.WriteLine("\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

x: 11.111111
y: 5.5555556

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar as ferramentas necessárias
from pulp import LpMinimize, LpProblem, LpVariable

# método principal
def main():
  # vamos criar o modelo
  modelo = LpProblem(name="Pesquisa Operacional em Python", sense=LpMinimize)

  # agora inicializamos as variáveis de decisão
  x = LpVariable(name="x", lowBound=0)
  y = LpVariable(name="y", lowBound=0)

  # vamos adicionar as restrições de acordo com a formulação do problema
  modelo += (40 * x + 100 * y >= 1000, "R1")
  modelo += (150 * x + 60 * y >= 2000, "R2")
  modelo += (3 * x + 8 * y >= 50, "R3")

  # definimos a função objetivo e a adicionamos ao modelo
  funcao_objetivo = 1500 * x + 1200 * y
  modelo += funcao_objetivo

  # e tentamos resolver o problema
  modelo.solve()
  
  # assumindo que o problema foi resolvido com sucesso, vamos
  # mostrar os valores das variáveis x e y
  for var in modelo.variables():
    print(f"{var.name}: {var.value()}")

if __name__== "__main__":
  main()