Cursor——ChatGPT的替代品【笔记】_cursor chat

前言

2023-3-31 22:00:44

以下内容源自《笔记》
仅供学习交流使用

推荐

什么？ 你还没用过 Cursor？ 智能 AI 代码生成工具 Cursor 安装和使用介绍

Cursor AI IDE 开发者工具

Cursor——ChatGPT的替代品

下载

官网下载Cursor

登录

点击设置
点击sign in

可以使用github账号登录

使用

先别打开任何文件，就可以回答问题了

如果回答的是英文，就它让用中文回答


它能回答，编程问题

如何回答，变成以外的问题，请看后面

可以发现，它默认的是python代码

新建一个文件 main,java

输入文件名，敲回车

编写区，Ctrl+L

就写出的是java代码了

怎么让它问答一个编程以外的问题

新建一个hello.txt文件
然后写一个编程之外的问题

测试有可能不成功

提问：写一封情书

提问：西安邮电大学简介

高级

参考 Cursor AI IDE 开发者工具

以下是扫雷程序

import java.util.Scanner;
 
public class Minesweeper {
    private int[][] grid;
    private boolean[][] revealed;
    private boolean[][] mines;
    private int rows;
    private int cols;
    private int numMines;
 
    public Minesweeper(int rows, int cols, int numMines) {
        this.rows = rows;
        this.cols = cols;
        this.numMines = numMines;
        grid = new int[rows][cols];
        revealed = new boolean[rows][cols];
        mines = new boolean[rows][cols];
        placeMines();
        calculateNumbers();
    }
 
    private void placeMines() {
        int count = 0;
        while (count < numMines) {
            int row = (int) (Math.random() * rows);
            int col = (int) (Math.random() * cols);
            if (!mines[row][col]) {
                mines[row][col] = true;
                count++;
            }
        }
    }
 
    private void calculateNumbers() {
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                grid[r][c] = countAdjacentMines(r, c);
            }
        }
    }
    
    public void reveal(int row, int col) {
        if (mines[row][col]) {
            gameOver();
            return;
        }
        revealed[row][col] = true;
        if (grid[row][col] == 0) {
            for (int r = Math.max(0, row - 1); r <= Math.min(rows - 1, row + 1); r++) {
                for (int c = Math.max(0, col - 1); c <= Math.min(cols - 1, col + 1); c++) {
                    if (!revealed[r][c]) {
                        reveal(r, c);
                    }
                }
            }
        }
    }
 
    private void gameOver() {
        System.out.println("Game over!");
        System.exit(0);
    }
 
    public boolean isGameOver() {
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (mines[r][c] && !revealed[r][c]) {
                    return false;
                }
                if (!mines[r][c] && !revealed[r][c]) {
                    return false;
                }
            }
        }
        return true;
    }
 
             
    // This method returns the number of adjacent mines for a given cell
    private int countAdjacentMines(int row, int col) {
        int count = 0;
        for (int r = Math.max(0, row - 1); r <= Math.min(rows - 1, row + 1); r++) {
            for (int c = Math.max(0, col - 1); c <= Math.min(cols - 1, col + 1); c++) {
                if (mines[r][c]) {
                    count++;
                }
            }
        }
        return count;
    }
	// This method returns the current state of the game as a string
    // Each cell is represented by a single character
    // If the cell is not revealed, it is represented by '-'
    // If the cell is revealed and contains a mine, it is represented by '*'
    // If the cell is revealed and does not contain a mine, it is represented by the number of adjacent mines
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (!revealed[r][c]) {
                    sb.append("-");
                } else if (mines[r][c]) {
                    sb.append("*");
                } else {
                    sb.append(grid[r][c]);
                }
            }
            sb.append("\n");
        }
        return sb.toString();
    }
    // We need to add a main method to the Minesweeper class to continue the Minesweeper program
    // In the main method, we can create a new instance of the Minesweeper class and start the game
    // We can use a Scanner object to get input from the user and call the reveal method with the user's input
    // We can also use the isGameOver method to check if the game is over and end the game if necessary
    
    
    public static void main(String[] args) {
        Minesweeper game = new Minesweeper(10, 10, 10);
        Scanner scanner = new Scanner(System.in);
        while (!game.isGameOver()) {
            System.out.println(game.toString());
            System.out.print("Enter row and column to reveal: ");
            int row = scanner.nextInt();
            int col = scanner.nextInt();
            game.reveal(row, col);
        }
        System.out.println(game.toString());
        System.out.println("Game over!");
    }
 
 
}
 

运行结果

以下是GUI编写的扫雷程序

// Import necessary packages// The code provided does not contain any syntax errors that would prevent it from compiling. 
// If the user is experiencing compilation errors, they should check their Java environment and ensure that all necessary packages and dependencies are properly installed.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
// Create a Minesweeper class that extends JFrame and implements ActionListener
public class Minesweeper extends JFrame implements ActionListener {
  
      // Declare necessary variables
      private Container contentPane;
      private JPanel gamePanel, buttonPanel;
      private JButton[][] buttons;
      private int[][] counts;
      private int size = 10;
      private int numMines = 10;
  
      // Create a constructor for the Minesweeper class
      public Minesweeper() {
        // Set the title of the JFrame
        setTitle("Minesweeper");
        
        // Get the content pane of the JFrame
        contentPane = getContentPane();
        
        // Set the layout of the content pane to BorderLayout
        contentPane.setLayout(new BorderLayout());
        
        // Call the createGamePanel method to create the game panel
        createGamePanel();
        
        // Call the createButtonPanel method to create the button panel
        createButtonPanel();
        
        // Pack the JFrame
        pack();
        
        // Set the JFrame to be visible
        setVisible(true);
      }
  
    // Create a method to create the game panel
    private void createGamePanel() {
        // Create a new JPanel for the game panel
        gamePanel = new JPanel();
        
        // Set the layout of the game panel to GridLayout
        gamePanel.setLayout(new GridLayout(size, size));
        
        // Create a new 2D array of JButtons for the buttons
        buttons = new JButton[size][size];
        
        // Create a new 2D array of integers for the counts
        counts = new int[size][size];
        
        // Initialize the buttons and counts arrays
        for (int i = 0; i < size; i++) {
          for (int j = 0; j < size; j++) {
            buttons[i][j] = new JButton();
            buttons[i][j].addActionListener(this);
            gamePanel.add(buttons[i][j]);
            counts[i][j] = 0;
          }
        }
        
        // Add the game panel to the content pane
        contentPane.add(gamePanel, BorderLayout.CENTER);
    }
  
    // Create a method to create the button panel
    private void createButtonPanel() {
        // Create a new JPanel for the button panel
        buttonPanel = new JPanel();
        
        // Set the layout// Set the layout of the button panel to FlowLayout
        buttonPanel.setLayout(new FlowLayout());
    
        // Create a new JButton for the "New Game" button
        JButton newGameButton = new JButton("New Game");
    
        // Add an ActionListener to the "New Game" button
        newGameButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                newGame();
            }
        });
 
        // Add the "New Game" button to the button panel
        buttonPanel.add(newGameButton);
        
        // Add the button panel to the content pane
        contentPane.add(buttonPanel, BorderLayout.SOUTH);// Create a new JButton for the "Reset" button
        JButton resetButton = new JButton("Reset");
    
        // Add an ActionListener to the "Reset" button
        resetButton.addActionListener(new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            reset();
          }
        });
 
        // Add the "Reset" button to the button panel
        buttonPanel.add(resetButton);
        
        // Add the button panel to the content pane
        contentPane.add(buttonPanel, BorderLayout.SOUTH);
            
        // Create a new JButton for the "Settings" button
        JButton settingsButton = new JButton("Settings");
        
        // Add an ActionListener to the "Settings" button
        settingsButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // Call the showSettingsDialog method to show the settings dialog
                showSettingsDialog();
            }
        });
    
        // Add the "Settings" button to the button panel
        buttonPanel.add(settingsButton);
    
        // Add the button panel to the content pane
        contentPane.add(buttonPanel, BorderLayout.SOUTH);
    }
    // Create a method to generate the mines and update the counts
    private void generateMines(int row, int col) {
      // Declare necessary variables
      int mines = 0;
      int i, j;
      
      // Generate the mines
      while (mines < numMines) {
        i = (int)(Math.random() * size);
        j = (int)(Math.random() * size);
        if (counts[i][j] != -1 && !(i == row && j == col)) {
          counts[i][j] = -1;
          mines++;
        }
      }
      
      // Update the counts
      for (i = 0; i < size; i++) {
        for (j = 0; j < size; j++) {
          if (counts[i][j] == -1) {
            updateCounts(i, j);
          }
        }
      }
    }
 
    // Create a method to update the counts
    private void updateCounts(int row, int col) {
      // Declare necessary variables
      int i, j;
  
      // Update the counts
      for (i = row - 1; i <= row + 1; i++) {
        for (j = col - 1; j <= col + 1; j++) {
          if (i >= 0 && i < size && j >= 0 && j < size && counts[i][j] != -1) {
            counts[i][j]++;
          }
        }
      }
    }
 
    // Create a method to reveal the button at the specified row and column
    private void reveal(int row, int col) {
      // Check if the button is already revealed or flagged
      if (buttons[row][col].getText().length() > 0) {
        return;
      }
      
      // Check if the button contains a mine
      if (counts[row][col] == -1) {
        // Reveal all the mines and end the game
        for (int i = 0; i < size; i++) {
          for (int j = 0; j < size; j++) {
            if (counts[i][j] == -1) {
              buttons[i][j].setText("*");
            }
          }
        }
        JOptionPane.showMessageDialog(this, "You lose!");
        newGame();
        return;
      }
      
      // Reveal the button and check if the game is won
    // Reveal the button and check if the game is won
      buttons[row][col].setText(Integer.toString(counts[row][col]));
      if (checkWin()) {
        JOptionPane.showMessageDialog(this, "You win!");
        newGame();
      }
    }
 
    // Create a method to check if the game is won
    private boolean checkWin() {
      // Declare necessary variables
      int revealed = 0;
      
      // Check if all non-mine buttons are revealed
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          if (buttons[i][j].getText().length() > 0 || counts[i][j] == -1) {
            revealed++;
          }
        }
      }
      if (revealed == size * size) {
        return true;
      }
      return false;
    }
    
    // Create a method to start a new game
    private void newGame() {
      // Reset the counts and buttons arrays
      counts = new int[size][size];
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          buttons[i][j].setText("");
          counts[i][j] = 0;
        }
      }
      
      // Generate the mines and update the counts
      generateMines(-1, -1);
    }
 
    // Create a method to reset the game
    private void reset() {
      // Reset the counts and buttons arrays
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          buttons[i][j].setText("");
          counts[i][j] = 0;
        }
      }
    }
 
   
    private void showSettingsDialog() {
      // Declare necessary variables
      JTextField sizeField = new JTextField(Integer.toString(size));
      JTextField numMinesField = new JTextField(Integer.toString(numMines));
      Object[] message = {
        "Size:", sizeField,
        "Number of Mines:", numMinesField
      };
      
      // Show the settings dialog and update the settings
      int option = JOptionPane.showConfirmDialog(this, message, "Settings", JOptionPane.OK_CANCEL_OPTION);
      if (option == JOptionPane.OK_OPTION) {
        try {
          int newSize = Integer.parseInt(sizeField.getText());
          int newNumMines = Integer.parseInt(numMinesField.getText());
          if (newSize > 0 && newSize <= 30 && newNumMines >= 0 && newNumMines < newSize * newSize) {
            size = newSize;
            numMines = newNumMines;
            newGame();
          } else {
            JOptionPane.showMessageDialog(this, "Invalid input!");
          }
        } catch (NumberFormatException e) {
          JOptionPane.showMessageDialog(this, "Invalid input!");
        }
      }
    }
     // Create an actionPerformed method to handle button clicks
    public void actionPerformed(ActionEvent e) {
      // Get the button that was clicked
      JButton button = (JButton)e.getSource();
      
      // Find the row and column of the button
      int row = -1, col = -1;
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          if (buttons[i][j] == button) {
            row = i;
            col = j;
            break;
          }
        }
      }
      
      // Call the reveal method to reveal the button
      reveal(row, col);
    }
    // Create a main method to create a new Minesweeper object
    public static void main(String[] args) {
      new Minesweeper();
    }
    
    // Create a method to flag the button at the specified row and column
    private void flag(int row, int col) {
      // Check if the button is already revealed
      if (buttons[row][col].getText().length() > 0) {
        return;
      }
      
      // Check if the button is already flagged
      if (buttons[row][col].getText().equals("F")) {
        buttons[row][col].setText("");
        return;
      }
      
      // Flag the button
      buttons[row][col].setText("F");
    }
    // Create a method to handle right-clicks on buttons
    private void handleRightClick(MouseEvent e) {
      // Get the button that was clicked
      JButton button = (JButton)e.getSource();
      
      // Find the row and column of the button
      int row = -1, col = -1;
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          if (buttons[i][j] == button) {
            row = i;
            col = j;
            break;
          }
        }
      }
      
      // Call the flag method to flag the button
      flag(row, col);
    }
 
    // Override the mousePressed method to handle right-clicks on buttons
    
    public void mousePressed(MouseEvent e) {
      if (SwingUtilities.isRightMouseButton(e)) {
        handleRightClick(e);
      }
    }
    // Create a method to handle keyboard events
    
    public void keyPressed(KeyEvent e) {
      // Check if the "r" key is pressed
      if (e.getKeyCode() == KeyEvent.VK_R) {
        reset();
      }
      
      // Check if the "n" key is pressed
      if (e.getKeyCode() == KeyEvent.VK_N) {
        newGame();
      }
      
      // Check if the "s" key is pressed
      if (e.getKeyCode() == KeyEvent.VK_S) {
        showSettingsDialog();
      }
    }
 
    // Create a method to initialize the game
    private void initGame() {
      // Set the size and number of mines
      size = 10;
      numMines = 10;
      
      // Create the counts and buttons arrays
      counts = new int[size][size];
      buttons = new JButton[size][size];
      
      // Create the game panel
      gamePanel = new JPanel();
      gamePanel.setLayout(new GridLayout(size, size));
      
      // Create the buttons and add them to the game panel
      for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
          buttons[i][j] = new JButton();
          buttons[i][j].addActionListener(this);
          buttons[i][j].addMouseListener(new MouseAdapter() {
            public void mousePressed(MouseEvent e) {
              if (SwingUtilities.isRightMouseButton(e)) {
                handleRightClick(e);
              }
            }
          });
          gamePanel.add(buttons[i][j]);
        }
      }
    
      // Add the game panel to the content pane
      contentPane.add(gamePanel, BorderLayout.CENTER);
      
      // Create the button panel
      createButtonPanel();
      
      // Generate the mines and update the counts
      generateMines(-1, -1);
    }
    
   
 
 
}

运行结果

另外

VSCode软件插件Chatmoss，也可以体验，但是好像有额度。

以下是GUI的扫雷程序

最后

2023-3-31 22:43:31

祝大家逢考必过
点赞收藏关注哦