It's not too terrible, especially for a first program, but there are a number of things that you might improve.

Decompose your program into functions

Almost all of the logic here is in main in one rather long and repetitive chunk of code in main. It would be better to decompose this into separate functions.

Use only necessary #includes

Restricting #includes to those that are really needed is good practice. In particular there is nothing used from <cstdio> and the using std::getchar is not necessary either.

Be careful with using

Although you have avoided the bad habit of putting using namespace std at the top of your program, one could simply omit those entirely and use the explicit std:: prefix everywhere. It makes it clear to readers of the code that you're using the std version and doesn't really clutter up the code very much.

Don't use std::endl if you don't really need it

The difference betweeen std::endl and '\n' is that '\n' just emits a newline character, while std::endl actually flushes the stream. This can be time-consuming in a program with a lot of I/O and is rarely actually needed. It's best to only use std::endl when you have some good reason to flush the stream and it's not very often needed for simple programs such as this one. Avoiding the habit of using std::endl when '\n' will do will pay dividends in the future as you write more complex programs with more I/O and where performance needs to be maximized.

Use string concatenation and operator chaining

The code includes these lines:

cout << "The computer chose rock. Draw." << endl;
cout << "Score: " << endl;
cout << "You: " << playerScore << endl;
cout << "Computer: " << CPUscore << endl;

Each of those is a separate call to operator<< but they don't need to be. Another way to write that would be like this:

std::cout << "The computer chose rock. Draw.\n"
    "Score: \n"
    "You: " << playerScore << "\n"
    "Computer: " << CPUscore << "\n";

Consecutive strings in C++ (and in C, for that matter) are automatically concatenated into a single string by the compiler and the return type for the stream operator<< is std::ostream& so you can chain them together like this to make the code a bit easier to read.

Consider using a better random number generator

You are currently using

short CPUchoice = (rand() % 3) + 1;

There are two problems with this approach. One is that the low order bits of the random number generator are not particularly random, so neither is CPUchoice. On my machine, there's a slight but measurable bias toward 1 with that. The second problem is that it's not thread safe because rand stores hidden state. A better solution, if your compiler and library supports it, would be to use the C++11 std::uniform_int_distribution. It looks complex, but it's actually pretty easy to use.

Avoid "magic numbers"

The code includes this line in two places:

std::cout << "\033[2J\033[1;1H";

Better would be to give this constant a name to suggest what it means or to factor it out into a function such as clear() to make it a lot more obvious what is happening.

Don't Repeat Yourself (DRY)

The code includes this:

if (CPUscore > playerScore) {
    std::cout << "You lose the match :(\n";
    std::cout << "Score: \n";
    std::cout << "You: " << playerScore << endl;
    std::cout << "Computer: " << CPUscore << endl;
} else if (playerScore > CPUscore) {
    std::cout << "You win the match!!\n";
    std::cout << "Score: \n";
    std::cout << "You: " << playerScore << endl;
    std::cout << "Computer: " << CPUscore << endl;
} else if (CPUscore == playerScore) {
    std::cout << "Match drawn. \n";
    std::cout << "Score: \n";
    std::cout << "You: " << playerScore << endl;
    std::cout << "Computer: " << CPUscore << endl;
}

Instead of repeating code, it's generally better to make common code into a function or separate things out. This, for example, could be written like this:

if (CPUscore > playerScore) {
    std::cout << "You lose the match :(\n";
} else if (playerScore > CPUscore) {
    std::cout << "You win the match!!\n";
} else if (CPUscore == playerScore) {
    std::cout << "Match drawn. \n";
}
std::cout << "Score: \n";
std::cout << "You: " << playerScore << endl;
std::cout << "Computer: " << CPUscore << endl;

Use a function to evaluate win/loss/draw

Both the computer and the human choose either "rock", "paper" or "scissors" and the rules for which combination wins, loses or draws are clear. One could separate that out into a function like this:

enum class Result { win, lose, draw};

Result evaluateRound(int computer, int human) {
    if (computer == human) {
        return Result::draw;
    } else if (human == computer + 1 || human == 1 && computer == 3) {
        return Result::win;
    }
    return Result::lose;
}

Now we can use this like this:

    int playerTurn{playerPlay()};
    int CPUturn{CPUplay()};
    auto result{evaluateRound(CPUturn, playerTurn)};
    std::cout << "The computer chose " << text(CPUturn);
    if (result == Result::win) {
        std::cout << " You win this round!\n";
        ++playerScore;
    } else if (result == Result::draw) {
        std::cout << " Draw.\n";
    } else {
        std::cout << " You lose this round :(.\n";
        ++CPUscore;
    }
    std::cout << "Score: \n"
        "You: " << playerScore << "\n"
        "Computer: " << CPUscore << "\n"
        "Press enter to continue... ";
    std::cin.ignore();
    std::cin.get();
}

I imagine that you can figure out what the text() function does and how to write it. A further enhancement would be to use an enum class for the guesses, too.

Use consistent capitalization

We have both CPUscore and playerScore in the program. In one case Score is capitalized and the other place not. In one case, the name begins with a capital letter and the other place not. Consistency can aid readability, and so one possibility would be to use CpuScore and PlayerScore even though "CPU" in English is properly all capitalized.

seed once

    srand(time(nullptr) + num);

You're seeding the PRNG on each call. Don't do that. One time, in main, suffices.

As written, calling srand again 900 msec later (with same num) could deterministically generate the identical "random" number.

Fortunately, this particular code will increment num for each call. But frequent re-seeding is not a habit you'd want to get into.

no copy-n-paste

The main() routine is entirely too long.

How can we tell? Display it onscreen. Can you see the whole function all at once, without scrolling? Nope. So it is definitely Too Long.

Parameterize. Break out helpers. The {score, you, computer} lines, at the very least, could appear in a helper function. You would benefit from adding an adjudicate(playerChoice, computerChoice) function that tells us who won.

cin.ignore()

        cin.ignore(1000, '\n');

That seems inconvenient.

Consider requesting a line of text at a time (which includes \n newline), and then turn those characters into an integer value. Bury the details in a helper function.

Make use of the latest standard

C++ is an evolving language, and a new version of the C++ standard is released every 3 years or so. Each new version aims to make life simpler and better for the programmer. Try to make use of newer functions where appropriate.

Using a better random number generator has already been mentioned. But since C++23 there's also std::print(), which makes printing formatted output both type safe and nice:

std::print("You: {}\n", playerScore);

While using the latest and greatest features might not always be a good idea (for example, if your project needs to be able to be compiled on systems with older compilers), it's a good exercise to use them if you don't have these restrictions. Also note that there are often libraries backporting new features onto older standards; the {fmt} library for example will allow you to use std::print() with older versions of the C++ standard.

Prefer '\n' instead of std::endl

Prefer using '\n' instead of std::endl; the latter is equivalent to the former but also forces the output to be flushed, which is usually unnecessary and has a potential negative impact on performance.

Create structs to group related information

If you see you have variables that are often passed together to other functions, they are probably related to each other in some way. It often makes sense to group those variables into a struct. For example:

struct Score {
    int player;
    int CPU;
};

You already got the advice to create functions to reduce code duplication. For example, you print scores very often. So consider writing:

void print(const Score& score) {
    std::print("Score:\n"
               "You: {}\n"
               "Computer: {}\n",
               score.player, score.CPU);
}

And then elsewhere you have:

Score score;
…
print(score);

• Make it a habit to comment your program. What does it do, when did you write it, what are the prerequisites, what is the target system, how do you build it?

• Make it a habit to comment your functions. I'm not a fan of rigid rules; do not write obvious things. Commenting is more important in large programs written by a team. But the comment should contain what a maintainer in five years (often yourself!) would find useful: If the function does more than fits in the title, what is it actually doing? Any preconditions? What are the argument ranges and restrictions (how robust is it)? What is the error reaction? What does it return, what is the return value range, and is it guaranteed?

• Use enums instead of 1,2,3. Always remember Stroustrup's principle: If you see a comment, ask yourself whether you could express it in code! Instead of

  case 3: // When player chose scissors
  

  you'd have

  case SCISSORS:
  

  That is more readable and less error-prone.

• Consider using a function to convert strings to those enums; that function could make the comparison more robust (compare case-insensitive, for example, or ignore minor speling errors).

• Instead of

  cin >> numRounds;
      while (!cin) {
  

  write a do/while loop. And yes, reduce the code duplication; you are not paid per line ;-).

And I agree that your input handling is fishy. Not sure why you'd need cin.ignore() at all — don't you just read words? Is it important whether they are on a single line or 3 lines? Can they come from a text file for test purposes?

And the line cout << "\033[2J\033[1;1H"; warrants a comment; it is a terminal control sequence, but what does it do? Best would be to put it in a const string on top of the program (aptly named: remember Stroustrup!) so that it can be found and changed easily when the need arises because the program is compiled for a different environment. Better still, make an effort to cater to the environment. ANSI sequences are probably a good bet, but you could try to obtain the environment variable TERM and choose proper control codes for some common ones.

In C++, there are two ways to import C headers.

If you do #include <cstdlib>, then you need to write std::srand(...) because it is not guaranteed that srand() exists in the global namespace.

If you do #include <stdlib.h>, then you need to write srand(...), not std::srand(...).

See:

• https://stackoverflow.com/questions/32606023/when-using-c-headers-in-c-should-we-use-functions-from-std-or-the-global-na
• https://stackoverflow.com/questions/29897661/when-using-standard-c-functions-in-c-is-the-std-prefix-required