¡Claro! Aquí tienes un programa en Python que simula un sistema planetario.

```python
import numpy as np
import matplotlib.pyplot as plt

G = 6.67430e-11 # gravitational constant

def update_positions(positions, velocities, masses, time_step):
    n_bodies = len(masses)
    forces = np.zeros((n_bodies, 2))

    # calculate forces
    for i in range(n_bodies):
        for j in range(n_bodies):
            if i != j:
                r = positions[j] - positions[i]
                f = G * masses[i] * masses[j] / np.linalg.norm(r)**2
                forces[i] += f * r / np.linalg.norm(r)

    # update positions and velocities
    acceleration = forces / masses
    velocities += acceleration  * time_step
    positions  += velocities * time_step

    return positions, velocities

def simulate(n_bodies):
    if n_bodies == 2:
      masses     = 100*np.array([1, 1])
      velocities = np.array([[-0.05, 0.5], [0.05, 0.5]])
      positions  = np.array([[0.5, 0], [-0.5, 0]])

    else:
      # ask for input
      masses = np.zeros(n_bodies)
      velocities = np.zeros((n_bodies, 2))
      positions = np.zeros((n_bodies, 2))

      for i in range(n_bodies):
          masses[i] = float(input(f"\nEnter mass of body {i+1}: "))
          velocities[i] = [float(input(f"Enter velocity in x direction of body {i+1}: ")), 
                           float(input(f"Enter velocity in y direction of body {i+1}: "))]
          positions[i] = [float(input(f"Enter x position of body {i+1}: ")), 
                          float(input(f"Enter y position of body {i+1}: "))]

    # run simulation
    time_step = 1.0 # in seconds
    n_steps = 10000
    positions_history = np.zeros((n_steps+1, n_bodies, 2))
    positions_history[0] = positions.copy()
    for i in range(n_steps):
        positions, velocities = update_positions(positions, velocities, masses, time_step)
        positions_history[i+1] = positions.copy()

    # set up plotting
    colors = plt.cm.rainbow(np.linspace(0, 1, n_bodies))
    fig, ax = plt.subplots()
    for j in range(n_bodies):
        ax.plot(positions_history[:,j,0], positions_history[:,j,1], color=colors[j], linewidth=0.5)
        ax.plot(positions_history[-1,j,0], positions_history[-1,j,1], color=colors[j], marker='o', markersize=3)

    # show the plot
    plt.show()

if __name__ == '__main__':
    simulate(n_bodies = int(input("Enter number of bodies: ")))
```

El programa funciona de la siguiente manera:

1. Primero definimos la constante gravitatoria G.

2. La función *update_positions* actualiza las posiciones y velocidades de los cuerpos en función de sus masas y fuerzas gravitatorias.

3. La función *simulate* pide al usuario los datos de entrada (masas, velocidades y posiciones de cada cuerpo), configura el trazado, ejecuta la simulación durante 10000 pasos (cada paso es un segundo) y traza las trayectorias de los cuerpos.

4. En el bloque ```python if __name__ == '__main__' ```: pedimos al usuario el número de cuerpos a simular y llamamos a la función simulate.

Para ejecutar el programa, guarde el código como un archivo Python (por ejemplo, n_body_simulation.py) y ejecútelo desde la línea de comandos. Se le pedirá que introduzca el número de cuerpos y, a continuación, para cada cuerpo, tendrá que introducir su masa, velocidad en la dirección x, velocidad en la dirección y, posición x y posición y. Después de ejecutar la simulación, el programa mostrará un gráfico de las trayectorias de los cuerpos.
ชัดเจน! นี่คือโปรแกรม Python ที่จำลองระบบดาวเคราะห์ ```python นำเข้า numpy เป็น np นำเข้า matplotlib.pyplot เป็น plt G = 6.67430e-11 # ค่าคงที่แรงโน้มถ่วง def update_positions(ตำแหน่ง, ความเร็ว, มวล, time_step): n_bodies = len(มวล) แรง = np.zeros((n_bodies, 2)) # คำนวณแรงสำหรับฉันในช่วง (n_bodies): สำหรับ j อยู่ในช่วง (n_bodies): ถ้า i != j: r = ตำแหน่ง[j] - ตำแหน่ง[i] f = G * มวล[i] * มวล[ j] / np.linalg.norm(r)**2 แรง[i] += f * r / np.linalg.norm(r) # อัปเดตตำแหน่งและความเร็ว การเร่งความเร็ว = แรง / ความเร็วมวล += ความเร่ง * ตำแหน่ง time_step + = ความเร็ว * ตำแหน่งส่งคืน time_step, ความเร็วจำลอง (n_bodies): ถ้า n_bodies == 2: มวล = 100*np.array([1, 1]) ความเร็ว = np.array([[-0.05, 0.5], [0.05 , 0.5]]) ตำแหน่ง = np.array([[0.5, 0], [-0.5, 0]]) else: # ถามหามวลอินพุต = np.zeros(n_bodies) ความเร็ว = np.zeros((n_bodies, 2 )) ตำแหน่ง = np.zeros((n_bodies, 2)) สำหรับ i อยู่ในช่วง (n_bodies): มวล[i] = float(input(f"\nป้อนมวลของร่างกาย {i+1}: ")) ความเร็ว[i ] = [float(input(f"ป้อนความเร็วในทิศทาง x ของร่างกาย {i+1}: ")), float(input(f"ป้อนความเร็วในทิศทาง y ของร่างกาย {i+1}: "))] ตำแหน่ง [i] = [float(input(f"Enter x ตำแหน่งของร่างกาย {i+1}: ")), float(input(f"ป้อน y ตำแหน่งของร่างกาย {i+1}: "))] # รันการจำลอง time_step = 1.0 # เป็นวินาที n_steps = 10,000position_history = np.zeros((n_steps+1, n_bodies, 2))positions_history[0] =position.copy() สำหรับฉันในช่วง (n_steps): ตำแหน่ง, ความเร็ว = update_positions(ตำแหน่ง , ความเร็ว, มวล, time_step)position_history[i+1] =position.copy() # set up plotting colours = plt.cm.rainbow(np.linspace(0, 1, n_bodies)) fig, ax = plt.subplots( ) สำหรับ j อยู่ในช่วง (n_bodies): ax.plot(positions_history[:,j,0],positions_history[:,j,1], color=colors[j], linewidth=0.5) ax.plot(positions_history[-1 ,j,0],positions_history[-1,j,1], color=colors[j], marker='o', markersize=3) # แสดงโครงเรื่อง plt.show() ถ้า __name__ == '__main__': simulate(n_bodies = int(input("Enter number of bodies: "))) ``` โปรแกรมทำงานดังนี้: 1. ก่อนอื่นเรากำหนดค่าคงที่แรงโน้มถ่วง G 2. ฟังก์ชัน *update_positions* จะอัปเดตตำแหน่งและความเร็วของ วัตถุขึ้นอยู่กับมวลและแรงโน้มถ่วง 3. ฟังก์ชัน *จำลอง* จะขอให้ผู้ใช้ป้อนข้อมูล (มวล ความเร็ว และตำแหน่งของแต่ละวัตถุ) กำหนดค่าพล็อต รันการจำลอง 10,000 ขั้นตอน (แต่ละขั้นตอนคือหนึ่งวินาที) และวางแผนวิถีการเคลื่อนที่ของวัตถุ 4. ในบล็อก ```python if __name__ == '__main__' ```: เราขอให้ผู้ใช้ระบุจำนวนเนื้อหาที่จะจำลองและเรียกใช้ฟังก์ชันจำลอง หากต้องการรันโปรแกรม ให้บันทึกโค้ดเป็นไฟล์ Python (เช่น n_body_simulation.py) และรันจากบรรทัดคำสั่ง คุณจะถูกขอให้ป้อนจำนวนวัตถุ จากนั้นสำหรับแต่ละวัตถุ คุณจะต้องป้อนมวล ความเร็วในทิศทาง x ความเร็วในทิศทาง y ตำแหน่ง x และตำแหน่ง y หลังจากรันการจำลองแล้ว โปรแกรมจะแสดงกราฟวิถีการเคลื่อนที่ของวัตถุ
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence