1. 编写一个函数，接受一个字符串作为参数，并返回该字符串的反转结果。例如，输入"Hello World!“，输出”!dlroW olleH"。

function strReserve(str) {
  return str.split('').reserve().join('');
编写一个函数，接受一个数组作为参数，将数组中的元素按照从小到大的顺序进行排序，并返回排序后的数组。例如，输入[5, 3, 8, 2, 1]，输出[1, 2, 3, 5, 8]。
 
function arrSort(arr) {
  // x - y 输出[1, 2, 3, 5, 8]
  // y - x 输出[8, 5, 3, 2, 1]
  return arr.sore((x, y) => x - y);
编写一个函数，接受一个数字作为参数，并判断该数字是否为素数。素数是只能被 1 和自身整除的数字。例如，输入 7，返回 true；输入 12，返回 false。
 
function isPrime(num) {
  if (num <= 1) {
    return false;
  for (let i = 2; i <= Math.sqrt(num); i++) {
    if (num % i === 0) {
      return false;
  return true;
console.log(isPrime(7));  // 输出：true
console.log(isPrime(12));  // 输出：false
编写一个函数，接受一个数组作为参数，并返回数组中的最大值和最小值。例如，输入[2, 5, 1, 9, 3]，返回最大值 9 和最小值 1。
 
function getMinMaxNum(arr) {
  let min = arr[0];
  let max = arr[0];
  for (let key of  arr) {
    if (key < min) min = key;
    if (key > max) max = key;
  return { max, min }
编写一个函数，接受一个字符串作为参数，判断该字符串是否是回文。回文是指正向和反向拼写都相同的单词、短语或数字序列。例如，输入"level"，返回 true；输入"hello"，返回 false。
 
function isPalindrome(str) {
  return str === str.split('').reverse().join('');
编写一个函数，接受一个字符串作为参数，并返回字符串中出现次数最多的字符及其出现次数。如果存在多个字符出现次数相同且最多，则返回任意一个即可。例如，输入"abbcccddddeeeee"，返回 { char: ‘e’, count: 5 }。
 
function mostFrequentChar(str) {
  const numObj = {};
  let count = 0;
  let char = '';
  for (let key of str) {
    numObj[key] = (numObj[key] || 0) + 1;
    if (numObj[key] > count) {
      count = numObj[key];
      char = key;
  return { char, count }
编写一个函数，接受一个数组作为参数，返回一个新数组，其中的元素是原数组中的偶数，并且按照从小到大的顺序排列。例如，输入[3, 8, 2, 1, 6, 4]，返回 [2, 4, 6, 8]。
 
function oddSort(arr) {
  return arr.filter(i => !(i % 2)).sort((x, y) => x - y);
编写一个函数，接受一个字符串作为参数，判断该字符串是否是有效的括号序列。有效的括号序列指的是括号的开闭顺序正确且嵌套规则正确。例如，输入"()[]{}“，返回 true；输入”([)]"，返回 false。
 
function isValidParentheses(str) {
  const stack = [];
  const parenthesesMap = {
    '(': ')',
    '[': ']',
    '{': '}'
  for (let char of str) {
    if (char === '(' || char === '[' || char === '{') {
      stack.push(char);
    } else {
      const top = stack.pop();
      if (char !== parenthesesMap[top]) {
        return false;
  return stack.length === 0;
console.log(isValidParentheses("()[]{}"));  // 输出：true
console.log(isValidParentheses("([)]"));  // 输出：false
编写一个函数，接受一个正整数作为参数，返回一个包含斐波那契数列的数组，数组的长度为该正整数。斐波那契数列是指后一个数字是前两个数字之和的数列。例如，输入 8，返回 [0, 1, 1, 2, 3, 5, 8, 13]。
 
function fibonacciSequence(num) {
  if (num === 0) return [];
  if (num === 1) return [0];
  let retArr = [0, 1];
  for(let i = 2; i < num; i++) {
    retArr.push(retArr[i - 1] + retArr[i - 2]);
  return retArr;
编写一个函数，接受一个字符串作为参数，返回一个新的字符串，其中的单词以相反的顺序排列，但单词内部的字符顺序不变。例如，输入"The quick brown fox"，返回 “ehT kciuq nworb fox”。
 
function reverseWords(str) {
  return str.split(' ').map(word => word.split('').reverse().join('')).join(' ');
console.log(reverseWords("The quick brown fox"));  // 输出："ehT kciuq nworb xof"
编写一个函数，接受一个字符串作为参数，并返回一个新字符串，其中的每个单词的首字母都转换为大写。例如，输入"hello world"，返回 “Hello World”。
 
function capitalizeWords(str) {
  return str.replace(/\b\w/g, match => match.toUpperCase());
console.log(capitalizeWords("hello world"));  // 输出："Hello World"
正则表达式 /\b\w/g 的含义是匹配单词的首字母。
 
\b 是一个单词边界的元字符，用于匹配单词的开始或结束位置。
 \w 是一个字符类元字符，匹配任意字母、数字或下划线。
 所以，/\b\w/g 的正则表达式会匹配字符串中的每个单词的首字母。
 
编写一个函数，接受一个二维数组作为参数，将其转换为一个一维数组，并且保持原数组中所有元素的顺序不变。例如，输入[[1, 2], [3, 4], [5, 6]]，返回 [1, 2, 3, 4, 5, 6]。
 
// GPT的答案是这样的, 我觉得还不是最简单的方法。
function flattenArray(arr) {
  return arr.reduce((result, current) => result.concat(current), []);
console.log(flattenArray([[1, 2], [3, 4], [5, 6]]));  // 输出：[1, 2, 3, 4, 5, 6]
// 我认为最简单的办法
function flattenArray(arr) {
  return arr.toString().spilit(',');
编写一个函数，接受一个正整数作为参数，并返回该正整数的阶乘结果。阶乘是指从 1 到该正整数的所有整数的乘积。例如，输入 5，返回 120（1 * 2 * 3 * 4 * 5）。
 
function factorial(n) {
  if (n <= 1) {
    return 1;
  return n * factorial(n - 1);
console.log(factorial(5));  // 输出：120
编写一个函数，接受一个字符串作为参数，并返回该字符串中最长的连续数字串。如果存在多个最长的连续数字串，则返回第一个遇到的。例如，输入"abcd12345efgh6789"，返回 “12345”。
 
还是用的正则表达式啊，看来这个东西是又简便又好用，如果能学的很好可以很快的解决很多问题。
 
function findLongestDigits(str) {
  const matches = str.match(/\d+/g);
  if (!matches) {
    return "";
  return matches.reduce((longest, current) => {
    if (current.length > longest.length) {
      return current;
    return longest;
  }, "");
console.log(findLongestDigits("abcd12345efgh6789"));  // 输出："12345"
def str_change(str) :
    return str[::-1]#str[i:j:k]之中，i默认值为0，j默认为总的元素个数，k为步长，k>0时从左往右，k<0时，从右往左
str = input("输入字符串：")
print(str_change(str))
				
Transformers库中的GPT模型是一种基于Transformer架构的生成式预训练模型。GPT（Generative Pre-trained Transformer）模型是由OpenAI开发的，用于生成和理解自然语言文本。
GPT模型采用了Transformer的编码器-解码器结构，其中编码器用于对输入文本进行表示，解码器则用于生成对应的输出序列。不同于其他任务特定的模型，GPT是通过在大规模文本语料上进行无监督预训练得到的，因此它具有广泛的语言理解和生成能力。
GPT模型被广泛应用于各种自然语言处理任务，例如语言生成、文本摘要、文本分类、对话系统等。它能够生成连贯、语义合理的文本，并且可以通过fine-tuning在特定任务上进行进一步调优。
Transformers库中提供了不同版本和大小的GPT模型，如GPT、GPT2等，可以根据任务需求选择适合的模型。此外，通过加载预训练好的权重，可以使用GPT模型进行文本生成和相关自然语言处理任务。