Copy and rename in the same time (also change filename, not only path):

cp program3.cpp homework6.cpp

Rename only:

mv program3.cpp homework6.cpp

In an -exec predicate, the symbol {} represents a path that is being considered, starting at one of the starting-point directories designated in the command. Example: start/dir2/Preview.json. You can form other file names by either prepending or appending characters, but whether that makes sense depends on the details. In your case, appending produces commands such as

cp start/dir2/Preview.json start/dir2/Preview.jsonQA

which is a plausible command in the event that start/dir2/Preview.json exists. But cp does not automatically create directories in the destination path, so the result of prepending characters ...

cp start/dir2/Preview.json QAstart/dir2/Preview.json

... is not as likely to be accepted -- it depends on directory QAstart/dir2 existing.

I think what you're actually looking for may be cp commands of the form ...

cp start/dir2/Preview.json start/dir2/QAPreview.json

... but find cannot do this by itself.

For more flexibility in handling the file names discovered by find, pipe its output into another command. If you want to pass them as command-line arguments to another command, then you can interpose the xargs command to achieve that. The command on the receiving end of the pipe can be a shell function or a compound command if you wish.

For example,

# Using ./* instead of * ensures that file names beginning with - will not
# be misinterpreted as options:
find ./* -type f -name 'Preview.json' |
  while IFS= read -r name; do  # Read one line and store it in variable $name
    # the destination name needs to be computed differently if the name
    # contains a / character (the usual case) than if it doesn't:
    case "${name}" in
      */*) cp "${name}" "${name%/*}/QA${name##*/}" ;;
      *)   cp "${name}" "QA${name}" ;;
    esac
  done

Note that that assumes that none of your directory names contain newline characters (the read command would split up newline-containing filenames). That's a reasonably safe assumption, but not absolutely safe.

Of course, you would generally want to have that in a script, not to try to type it on the fly on the command line.

No need for bash here, any standard sh interpreter implementation will do:

#! /bin/sh -
ret=0
for file do
  dir=$(dirname -- "$file")
  case dir/ # handle / and // specially
  esac
  base=$(basename -- "$file")
  name=${base%.*}
  name=${name:-$base} # don't consider .bashrc the extension in /foo/.bashrc
  ext=${base#"$name"}
  new_file={name}_copyfile" "$new_file" || ret=$?
done
exit "$ret"

(assumes the file and dir names don't end in newline characters).

(of course, that will also work with bash since bash is one of those standard sh interpreters.)

For a bash-specific solution, you could try:

#! /bin/bash -
ret=0
re='^((.*/)?[^/])(([^/]*)(\.))?([^/]*)/*$'
for file do
  if [[ $file =~ $re ]]; then
    if [[ ${BASH_REMATCH[5]} ]]; then
      suffix=_copy.${BASH_REMATCH[6]}
    else
      suffix=${BASH_REMATCH[6]}_copy
    fi
    cp -- "$file" "${BASH_REMATCH[1]}${BASH_REMATCH[4]}$suffix" || ret=$?
  else
    printf >&2 '%s\n' "$0: Error: refusing to copy $file"
    ret=1
 fi
done
exit "$ret"

cp takes a one or more files as source and a destination. The if the destination is a filename and not a directory, and there is only one source file then the file is renamed.

$ mkdir /tmp/a /tmp/b
$ echo test > /tmp/a/somefile
$ cp /tmp/a/somefile /tmp/b/          # creates /tmp/b/somefile
$ cp /tmp/a/somefile /tmp/b/somefile2 # creates /tmp/b/somefile2

If your files are named a.txt, b.txt and so on, then the default collation order should allow you to do a simple filename glob expansion, rather than needing to explicitly version-sort the files. So I'd suggest doing something more like

i=1

cd "$dir"
for old in *."$ext"; do 
  printf -v new '%s%02d.%s' "$newbase" $((i++)) "$ext"
  echo mv "$old" "$new"
done

after assigning newbase="$1", ext="$2", dir="$3" (with suitable existence checks of course). Play with it and remove the echo once the printed output looks correct.

You can use the following:

for file in *
do
   name="${file%.*}"
   extension="${file##*.}"
   cp $file ${name}_my${extension}
done

Note that ${file%.*} returns the file name without extension, so that from hello.txt you get hello. By doing ${file%.*}_my.txt you then get from hello.txt -> hello_my.txt.

Regarding the extension, extension="${file##*.}" gets it. It is based on the question Extract filename and extension in bash.

You should be able to do just

cp -R /tf/Custom_App /tf/Custom_App_backups/Custom_App_2017-12-21

However, if the target directory already exists, this would append the final part of the source path to the destination path, creating /tf/Custom_App_backups/Custom_App_2017-12-21/Custom_App, and then copy the rest of the tree within that.

To prevent this, use /tf/Custom_App/. as the source. Of course, in that case you might want to rm -r /tf/Custom_App_backups/Custom_App_2017-12-21 first, if you don't want older files lying around there after the copy.

The difference between /some/dir and /some/dir/. was discussed a while back in cp behaves weirdly when . (dot) or .. (dot dot) are the source directory

Something along the lines of

for sam in */Aligned.out.sam; do \
  name=$(basename $(dirname "$sam")) \
  cp "$sam" "/home/SAM/$name.sam" \
done

might do the trick

You can use the cp command with the -a option

-a, --archive
       same as -dR --preserve=all

And then use a for loop to rename all files while copying them:

for file in Erp*etf; do
  cp -a $file destinationDirectory/${file%%-*}.etf
done

Ready. Start this command in the source directory.

Explanation: The %%-* will cut off all the characters after the first occurence of a hyphen/minus - and the .etf at the end again adds the file extension.

Well, and as a one liner, put it all in one line. :-) Like this

for file in Erp*etf; do cp -a $file destinationDirectory/${file%%-*}.etf; done