精华内容
下载资源
问答
  • 翻转字符串

    2020-12-22 11:58:01
    文章目录翻转字符串翻转字符串单词顺序算法思路相应代码字符串整体移动算法思路相应代码 翻转字符串 翻转字符串单词顺序 【题目】 给定一个字符类型的数组chas,请在单词间做逆序调整。只要做到单词顺序逆序即可,对...
  • 该文档是反转字符串的,很多资源只是反转英文字符串,该文档包括可以反转中文的,并且有递归和非递归的方法。仅仅只是一个cpp文件,只要新建一个新的空工程,直接加载该cpp就可以运行使用了。
  • 字符串切片反转字符串Can you write a function that reverses an inputted string without using the built-in Array#reverse method? 您是否可以编写一个无需使用内置Array#reverse方法即可反转输入字符串的函数?...

    字符串切片反转字符串

    Can you write a function that reverses an inputted string without using the built-in Array#reverse method?

    您是否可以编写一个无需使用内置Array#reverse方法即可反转输入字符串的函数?

    Let’s look at some examples. So, calling:

    让我们看一些例子。 因此,致电:

    reverseString("jake") should return "ekaj".

    reverseString("jake")应该返回"ekaj"

    reverseString("reverseastring") should return "gnirtsaesrever".

    reverseString("reverseastring")应该返回"gnirtsaesrever"

    Image for post

    This lesson was originally published at https://algodaily.com, where I maintain a technical interview course and write think-pieces for ambitious developers.

    本课程最初在 https://algodaily.com上 发布 ,我 那里维护技术面试课程,并为雄心勃勃的开发人员撰写思想著作。

    对或错? (True or False?)

    In Java, C#, JavaScript, Python and Go, strings are immutable. This means the string object's state can't be changed after creation.

    在Java,C#,JavaScript,Python和Go中,字符串是immutable 。 这意味着在创建后无法更改字符串对象的状态。

    Solution: True

    解决方案:正确

    采访者心态 (On Interviewer Mindset)

    Reversing a string is one of the most common technical interview questions that candidates get. Interviewers love it because it’s deceptively simple. After all, as a software engineer, you’d probably call the #reverse method on your favorite String class and call it a day!

    反转字符串是考生最常见的技术面试问题之一。 采访者喜欢它,因为它看似简单。 毕竟,作为一名软件工程师,您可能会在自己喜欢的String类上调用#reverse方法并每天调用它!

    So don’t overlook this one — it appears a surprising amount as a warm-up or build-up question. Many interviewers will take the approach of using an easy question like this one, and actually judge much more harshly. You’ll want to make you sure really nail this.

    因此,请不要忽视这一点-它似乎是一个令人惊讶的热身或堆积问题。 许多面试官会采用这样一个简单的问题,实际上会做出更严厉的判断。 您需要确保确实做到这一点。

    我们将如何开始解决 (How We’ll Begin Solving)

    We want the string reversed, which means that we end up with all our letters positioned backwards. If you need a quick review of strings, check out our lesson on arrays and strings.

    我们希望字符串反转 ,这意味着我们最终将所有字母都向后放置。 如果您需要快速查看 string ,请阅读 有关数组和string的课程

    We know that strings can be thought of as character arrays-- that is, each element in the array is a single character. And if we can assume that, then we know the location (array position) of each character, as well as the index when the array ends.

    我们知道string s可以被认为是字符数组-也就是说,数组中的每个元素都是单个字符。 而且,如果可以假设,那么我们就知道每个字符的位置(数组位置)以及array结束时的索引。

    There’s a caveat to thinking of strings as character arrays — it’s not always true. As readers and viewers have pointed out, a string represents text formed from graphemes (the smallest functional unit of a writing system) — formed by combining character sequences in unicode.

    需要将字符串视为字符数组,但并非总是如此。 正如读者和观众所指出的那样,字符串代表由字素(书写系统的最小功能单元)形成的文本,该字素是通过以Unicode组合字符序列而形成的。

    Though strings and arrays contain similar methods like length, concat, and character position access-- they are not identical. As an example, arrays are mutable and strings usually are not. Before we can operate on the string as an array, we'll need to separate the units (in JS by calling the .split() method, or bypass this property by generating a brand new string instead of trying to operate on the original.

    尽管字符串和数组包含类似的方法,例如lengthconcat和字符位置访问- 但它们并不相同 。 例如,数组是可变的,而字符串通常不是可变的。 在将字符串作为数组进行操作之前,我们需要分隔单元(在JS中,通过调用.split()方法,或通过生成全新的字符串来绕过此属性,而不是尝试对原始字符串进行操作)。

    However, after the split operation, we can apply that paradigm to operating on this string. Thus we can step through each of its indices. Stepping through the beginning of the string, we’ll make these observations at each point:

    但是,在split操作之后,我们可以将该范例应用于对该字符串的操作。 因此,我们可以逐步浏览其每个索引。 逐步浏览字符串的开头,我们将在每个点进行以下观察:

    Image for post
    const str = "JAKE";
    // position 0 - "J"
    // position 1 - "A"
    // ...

    Since a reversed string is just itself backwards, a brute force solution could be to use the indices, and iterate from the back to the front.

    由于反向字符串本身本身就是向后的,因此蛮力解决方案可能是使用索引,并从后向前迭代。

    See the code attached and try to run it using Run Sample Code. You'll see that we log out each character from the back of the string!

    请参阅随附的代码,并尝试使用Run Sample Code运行它。 您会看到我们从字符串的后面注销了每个字符!

    function reverseString(str) {
    let newString = '';
    // start from end
    for (let i = str.length-1; i >= 0; i--) {
    console.log('Processing ', newString, str[i]);
    // append it to the string builder
    newString = newString + str[i];
    }
    // return the string
    return newString;
    }
    console.log(reverseString('test'));

    填写 (Fill In)

    We want to console.log out:

    我们要console.log注销:

    5
    4
    3
    2
    1

    What’s the missing line here?

    这里缺少什么?

    var arr =  [1, 2, 3, 4, 5];
    for (var i = ___________; i >= 0; i--) {
    console.log(arr[i]);
    }

    Solution: arr.length — 1

    解决方案: arr.length — 1

    我们能比蛮力做得更好吗? (Can We Do Better Than Brute Force?)

    However, it wouldn’t really be an interesting algorithms question if there wasn’t a better way. Let’s see how we can optimize this, or make it run faster. When trying to make something more efficient, it helps to think of things to cut or reduce.

    但是,如果没有更好的方法,这实际上不是一个有趣的算法问题。 让我们看看如何优化它或使其运行更快。 当试图使某事更有效率时,考虑减少或减少的事情会有所帮助。

    One thing to note is that we’re going through the entire string — do we truly need to iterate through every single letter?

    需要注意的一件事是,我们要遍历整个字符串-我们是否真的需要遍历每个字母?

    Let’s examine a worst case scenario. What if the string is a million characters long? That would be a million operations to work through! Can we improve it?

    让我们研究一个最坏的情况。 如果字符串长度为一百万个字符怎么办? 这将需要进行一百万次操作! 我们可以改善吗?

    是的,具有更多指针! (Yes, With More Pointers!)

    Well, we’re only working with a single pointer right now. The iterator from our loop starts from the back, and appends each character to a new string, one by one. Having gone through The Two Pointer Technique, we may recognize that some dramatic improvements can be had by increasing the number of pointers we use.

    好吧,我们现在仅使用单个指针。 循环中的迭代器从后面开始,并将每个字符一个接一个地追加到新字符串中。 经历了两次指针技术之后 ,我们可能会认识到,通过增加使用的指针数量,可以取得一些显着的改进。

    Image for post

    By this I mean, we can cut the number of operations in half. How? What if we did some swapping instead? By using a while loop and two pointers-- one on the left and one on the right.

    我的意思是,我们可以将操作数量减少一半 。 怎么样? 如果我们进行一些交换该怎么办? 通过使用while循环和两个指针-一个在左侧,一个在右侧。

    With this in mind — the big reveal is that, at each iteration, we can swap the letters at the pointer indices. After swapping, we would increment the left pointer while decrementing the right one. That could be hard to visualize, so let's see a basic example listed out.

    考虑到这一点,最大的启示是,在每次迭代中,我们都可以在指针索引处交换字母。 交换之后,我们将增加left指针,同时减少right指针。 这可能很难想象,所以让我们看一下列出的基本示例。

    jake    // starting string
    eakj // first pass
    ^ ^
    ekaj // second pass
    ^^

    多项选择 (Multiple Choice)

    What’s a good use case for the two pointers technique?

    两个指针技术的一个好用例是什么?

    • Shifting indices to be greater at each iteration

      每次迭代的移位指数都更大
    • Reducing a solution with a nested for-loop and O(n²) complexity to O(n)

      将嵌套循环和O(n²)复杂度降低为O(n)的解决方案
    • Finding pairs and duplicates in a for-loop

      在for循环中查找对和重复项
    • None of these

      都不是

    Solution: Reducing a solution with a nested for-loop and O(n²) complexity to O(n)

    解决方案:将嵌套的for循环和O(n²)复杂度的解决方案简化为O(n)

    With two pointers, we’ve cut the number of operations in half. It’s much faster now! However, similar to the brute force, the time complexity is still O(n).

    使用两个指针,我们将操作数减少了一半。 现在要快得多! 但是,类似于蛮力,时间复杂度仍然是O(n)

    Image for post

    为什么是这样? (Why Is This?)

    Well, if n is the length of the string, we'll end up making n/2 swaps. But remember, Big O Notation isn't about the raw number of operations required for an algorithm-- it's about how the number scales with the input.

    好吧,如果n是字符串的长度,我们最终将进行n/2交换。 但是请记住, Big O表示法与算法所需的原始操作数无关,而是与输入数如何缩放有关

    So despite requiring half the number operations — a 4-character string would require 2 swaps with the two-pointer method. But an 8-character string would require 4 swaps. The input doubled, and so did the number of operations.

    因此,尽管只需要执行一半的数字运算,但一个4字符的字符串将需要使用两指针方法进行2交换。 但是8字符的字符串将需要进行4交换。 输入增加了一倍,操作数也增加了。

    最终解决方案 (Final Solution)

    function reverseString(str) {
    let strArr = str.split("");
    let start = 0;
    let end = str.length - 1; while (start <= end) {
    const temp = strArr[start];
    strArr[start] = strArr[end];
    strArr[end] = temp;
    start++;
    end--;
    } return strArr.join("");
    }

    Originally published at https://algodaily.com on August 19, 2020.

    最初于 2020年8月19日 发布在 https://algodaily.com 上。

    翻译自: https://medium.com/swlh/how-to-reverse-a-string-16a2acc1dab8

    字符串切片反转字符串

    展开全文
  • 翻转字符串里的单词 给定一个字符串,逐个翻转字符串中的每个单词。 说明: 无空格字符构成一个 单词 。 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。 如果两个单词间有多余的空格,将...
    1. 翻转字符串里的单词
      给定一个字符串,逐个翻转字符串中的每个单词。

    说明:

    无空格字符构成一个 单词 。
    输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
    如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。

    示例 1:

    输入:“the sky is blue”
    输出:“blue is sky the”
    示例 2:

    输入:" hello world! "
    输出:“world! hello”
    解释:输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
    示例 3:

    输入:“a good example”
    输出:“example good a”
    解释:如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
    示例 4:

    输入:s = " Bob Loves Alice "
    输出:“Alice Loves Bob”
    示例 5:

    输入:s = “Alice does not even like bob”
    输出:“bob like even not does Alice”

    提示:

    1 <= s.length <= 104
    s 包含英文大小写字母、数字和空格 ’ ’
    s 中 至少存在一个 单词

    思路分析:
    题意已经非常明确,就是让我们反转字符串里面的单次,只不过有些条件:

    1.如果字符串前面和后面有空格,全部去掉
    2.中间多余的空格也去掉

    很多同学可能会有一个疑惑该怎么转,如果把整个字符串反转了,那单词的顺序也不对呀,其实我们只需要将反转完成的字符串里面的单词,再次反转就行,就相当于把第一次反转完成的字符串里,在根据条件反转里面的子字符串。

    本题思路:

    1.去除前面、后面和中间多余的空格

    在这里我们可以使用双指针法,left和right,分别指向头部和尾部,如果是空格left++ ,right–;(我们在这里假设y为空,不想重新作图)
    在这里插入图片描述
    关键问题我们如何去除中间多余的空格:
    我们定义一个StringBuilder sb(因为他拼接的速度快)将去除前面和后面空格的字符串s从做到右拷贝到sb中,当s.charAt(left)不为空,我们将这个字符拷贝过去,如果为空,我们要判断上一次传入的字符是否为空,若为空跳过,不为加入到sb;
    在这里插入图片描述

    当left指针走到空格的时候判断上一个字符为k不为空,所以将空存入sb,然后left++
    在这里插入图片描述
    之后继续右走,重复以上步骤
    在这里插入图片描述
    java代码:

    public StringBuilder removeSpace(String s) {
            int left = 0 , right = s.length() - 1;
            //移除开头的空格
            while (left <= right && s.charAt(left) == ' ') {
                left++;
            }
            //移除结尾的空格
            while (left <= right && s.charAt(right) == ' ') {
                right--;
            }
            StringBuilder sb = new StringBuilder();
            //移除中间多余的空格
            while (left <= right) {
                char c = s.charAt(left) ;
                if (c != ' ') {
                    sb.append(c);
                }else if (sb.charAt(sb.length() - 1) != ' ') {
                    sb.append(c);
                }
                left++;
            }
            return sb;
        }
    

    2.反转字符串

    这个是最基础的算法了,如果有不清楚的同学,可以查看https://blog.csdn.net/qq_43413774/article/details/115082618
    Java代码:

    public void reverse(StringBuilder sb , int left , int right) {
            while (left < right) {
                char temp = sb.charAt(left);
                sb.setCharAt(left++ , sb.charAt(right));
                sb.setCharAt(right-- , temp);
            }
    
        } 
    
    

    3.反转单词

    就是将字符串里面被反转的单词分离开,分别进行反转

    判断条件就是当遇到空格的时候分离开,并进行反转
    java代码:

    public void reverseEachWord(StringBuilder sb) {
            int n = sb.length();
            int start = 0 , end = 0;
    
            while (start < n) {
                while (end < n && sb.charAt(end) != ' ') {
                    end++;
                }
    
                reverse(sb , start , end - 1);
                start = end + 1;
                end++;
            }
        }
    
    

    本题思路并不难,但是就是代码逻辑性比较强,先反转还是先去空格其实都一样,甚至你都可以先反转单词,除非你闲的没事干,给自己找麻烦。

    完整代码:

    class Solution {
        public String reverseWords(String s) {
            //去除空格
            StringBuilder newString = removeSpace(s);
            //反转所有字符串
            reverse(newString , 0 , newString.length() - 1);
            //反转每个单次
            reverseEachWord(newString);
            
            return newString.toString();
        }
    
        public StringBuilder removeSpace(String s) {
            int left = 0 , right = s.length() - 1;
            //移除开头的空格
            while (left <= right && s.charAt(left) == ' ') {
                left++;
            }
            //移除结尾的空格
            while (left <= right && s.charAt(right) == ' ') {
                right--;
            }
            StringBuilder sb = new StringBuilder();
            //移除中间多余的空格
            while (left <= right) {
                char c = s.charAt(left) ;
                if (c != ' ') {
                    sb.append(c);
                }else if (sb.charAt(sb.length() - 1) != ' ') {
                    sb.append(c);
                }
                left++;
            }
            return sb;
        }
    
        public void reverse(StringBuilder sb , int left , int right) {
            while (left < right) {
                char temp = sb.charAt(left);
                sb.setCharAt(left++ , sb.charAt(right));
                sb.setCharAt(right-- , temp);
            }
    
        } 
    
        public void reverseEachWord(StringBuilder sb) {
            int n = sb.length();
            int start = 0 , end = 0;
    		//边界,循环终止条件
            while (start < n) {
            	//
                while (end < n && sb.charAt(end) != ' ') {
                    end++;
                }
    			//当遇到空字符时,执行以下代码
                reverse(sb , start , end - 1);
                start = end + 1;
                end++;
            }
        }
    
    
    
    
    
    

    其实此题也可以用库函数做出来,就那么几行代码,不过不建议使用,因为大部分人不知道他们是如何实现的,就比如正则表达式,有人甚至没听过。

    class Solution {
        public String reverseWords(String s) {
            // 除去开头和末尾的空白字符
            s = s.trim();
            // 正则匹配连续的空白字符作为分隔符分割
            List<String> wordList = Arrays.asList(s.split("\\s+"));
            Collections.reverse(wordList);
            return String.join(" ", wordList);
        }
    }
    

    若有误,请指教!

    展开全文
  • 反转字符串

    2020-12-21 18:37:19
    反转字符串 题目 编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组char[ ]的形式给出。 不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用O(1)的额外空间解决这一问题。 你可以...
  • 反转字符串,541. 反转字符串 II,917. 仅仅反转字母。然后再看本篇反转字符串的单词。 151. 翻转字符串里的单词² 给定一个字符串,逐个翻转字符串中的每个单词。 示例 1: 输入: "the sky is blue" 输出: "blue ...

    在看本文之前,最好先看前一篇 字符串(反转问题):LeetCode题 344. 反转字符串,541. 反转字符串 II,917. 仅仅反转字母。然后再看本篇反转字符串的单词。

    151. 翻转字符串里的单词²

    给定一个字符串,逐个翻转字符串中的每个单词。

    示例 1:

    输入: "the sky is blue"
    输出: "blue is sky the"
    

    示例 2:

    输入: "  hello world!  "
    输出: "world! hello"
    解释: 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
    

    示例 3:

    输入: "a good   example"
    输出: "example good a"
    解释: 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
    

    说明:

    • 无空格字符构成一个单词。
    • 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
    • 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。

    解法:双指针(模板)

    思路也很简单,就是将所有单词先构造成一个字符串数组String[],然后再用反转模板,最后再将数组组装成字符串。

    public String reverseWords(String s) {
        	// 1.分割出单词们:将字符串去除首尾空格后,根据空格分隔
        	// 注:这里用了正则表达式 \S表空白符,+表示多个,所以 \\S+
            String[] help = s.trim().split("\\s+");
        	// 2.对分割出的单词数组翻转
            int m = 0, n = help.length - 1;
            while (m < n) {
                String tmp = help[m]; help[m++] = help[n]; help[n--] = tmp;
            }       
        	// 3.组装字符串
            String res = "";
            for (int i = 0; i < help.length; i++) 
                res += help[i] + " ";
        	// 注:最后的结构要去除最后一个空格
            return res.trim();
        }
    

    因为上面解法大量调用了库函数(split,trim)所以还能优化…

    557. 反转字符串中的单词 III¹

    给定一个字符串,你需要反转字符串中每个单词的字符顺序,同时仍保留空格和单词的初始顺序。

    示例 1:

    输入: "Let's take LeetCode contest"
    输出: "s'teL ekat edoCteeL tsetnoc" 
    

    注意:在字符串中,每个单词由单个空格分隔,并且字符串中不会有任何额外的空格。

    解法:双指针(模板)

    跟151题差不多,还是先将单词构造成字符串数组String[],然后再逐单词反转

    public String reverseWords(String s) {
        	// 1.分割出单词们
            String[] help = s.split("\\s+");
            String res = "";
        	// 2.逐个翻转单词
            for (int i = 0; i < help.length; i++) {
                char[] c = help[i].toCharArray();
                int m = 0, n = c.length - 1;
                while (m < n) {
                    char tmp = c[m]; c[m++] = c[n]; c[n--] = tmp;
                }
                // 3.组装结果
                res = res + new String(c) + " ";
            }
        	// 注:去除末尾空格
            return res.trim();
        }
    
    展开全文
  • 在JavaScript中反转字符串的三种方法

    千次阅读 2020-08-05 14:44:37
    采访者可能会要求您编写不同的方式来反转字符串,或者他们可能会要求您不使用内置方法来反转字符串,甚至会要求您使用递归来反转字符串。 There are potentially tens of different ways to do it, excluding the ...

    This article is based on Free Code Camp Basic Algorithm Scripting “Reverse a String

    本文基于Free Code Camp基本算法脚本“ Reverse a String

    Reversing a string is one of the most frequently asked JavaScript question in the technical round of interview. Interviewers may ask you to write different ways to reverse a string, or they may ask you to reverse a string without using in-built methods, or they may even ask you to reverse a string using recursion.

    反转字符串是技术面试中最常问到JavaScript问题之一。 采访者可能会要求您编写不同的方式来反转字符串,或者他们可能会要求您不使用内置方法来反转字符串,甚至会要求您使用递归来反转字符串。

    There are potentially tens of different ways to do it, excluding the built-in reverse function, as JavaScript does not have one.

    可能有数十种不同的方法可以执行此操作,但内置的反向功能除外,因为JavaScript没有。

    Below are my three most interesting ways to solve the problem of reversing a string in JavaScript.

    以下是我解决JavaScript中的字符串反转问题的三种最有趣的方法。

    算法挑战 (Algorithm Challenge)

    Reverse the provided string.

    反转提供的字符串。

    Reverse the provided string.You may need to turn the string into an array before you can reverse it.

    反转提供的字符串。 您可能需要将字符串转换为数组,然后才能将其反转。

    Reverse the provided string.You may need to turn the string into an array before you can reverse it.Your result must be a string.

    反转提供的字符串。 您可能需要将字符串转换为数组,然后才能将其反转。 您的结果必须是字符串。

    function reverseString(str) {
        return str;
    }
    reverseString("hello");

    提供的测试用例 (Provided test cases)

    • reverseString(“hello”) should become “olleh”

      reverseString(“ hello”)应该变成“ olleh”

    • reverseString(“Howdy”) should become “ydwoH”

      reverseString(“ Howdy”)应该变成“ ydwoH”

    • reverseString(“Greetings from Earth”) should return”htraE morf sgniteerG”

      reverseString(“来自地球的问候”)应该返回“ htraE morf sgniteerG”

    1.使用内置函数反转字符串 (1. Reverse a String With Built-In Functions)

    For this solution, we will use three methods: the String.prototype.split() method, the Array.prototype.reverse() method and the Array.prototype.join() method.

    对于此解决方案,我们将使用三种方法:String.prototype.split()方法,Array.prototype.reverse()方法和Array.prototype.join()方法。

    • The split() method splits a String object into an array of string by separating the string into sub strings.

      split()方法通过将字符串对象拆分为子字符串,将String对象拆分为字符串数组。
    • The reverse() method reverses an array in place. The first array element becomes the last and the last becomes the first.

      reverse()方法将数组反转到位。 第一个数组元素变为最后一个,最后一个数组变为第一个。
    • The join() method joins all elements of an array into a string.

      join()方法将数组的所有元素连接到字符串中。
    function reverseString(str) {
        // Step 1. Use the split() method to return a new array
        var splitString = str.split(""); // var splitString = "hello".split("");
        // ["h", "e", "l", "l", "o"]
     
        // Step 2. Use the reverse() method to reverse the new created array
        var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
        // ["o", "l", "l", "e", "h"]
     
        // Step 3. Use the join() method to join all elements of the array into a string
        var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
        // "olleh"
        
        //Step 4. Return the reversed string
        return joinArray; // "olleh"
    }
     
    reverseString("hello");

    将这三种方法链接在一起: (Chaining the three methods together:)

    function reverseString(str) {
        return str.split("").reverse().join("");
    }
    reverseString("hello");

    2.用递减的For循环反转字符串 (2. Reverse a String With a Decrementing For Loop)

    function reverseString(str) {
        // Step 1. Create an empty string that will host the new created string
        var newString = "";
     
        // Step 2. Create the FOR loop
        /* The starting point of the loop will be (str.length - 1) which corresponds to the 
           last character of the string, "o"
           As long as i is greater than or equals 0, the loop will go on
           We decrement i after each iteration */
        for (var i = str.length - 1; i >= 0; i--) { 
            newString += str[i]; // or newString = newString + str[i];
        }
        /* Here hello's length equals 5
            For each iteration: i = str.length - 1 and newString = newString + str[i]
            First iteration:    i = 5 - 1 = 4,         newString = "" + "o" = "o"
            Second iteration:   i = 4 - 1 = 3,         newString = "o" + "l" = "ol"
            Third iteration:    i = 3 - 1 = 2,         newString = "ol" + "l" = "oll"
            Fourth iteration:   i = 2 - 1 = 1,         newString = "oll" + "e" = "olle"
            Fifth iteration:    i = 1 - 1 = 0,         newString = "olle" + "h" = "olleh"
        End of the FOR Loop*/
     
        // Step 3. Return the reversed string
        return newString; // "olleh"
    }
     
    reverseString('hello');

    没有评论: (Without comments:)

    function reverseString(str) {
        var newString = "";
        for (var i = str.length - 1; i >= 0; i--) {
            newString += str[i];
        }
        return newString;
    }
    reverseString('hello');

    3.使用递归反转字符串 (3. Reverse a String With Recursion)

    For this solution, we will use two methods: the String.prototype.substr() method and the String.prototype.charAt() method.

    对于此解决方案,我们将使用两种方法:String.prototype.substr()方法和String.prototype.charAt()方法。

    • The substr() method returns the characters in a string beginning at the specified location through the specified number of characters.

      substr()方法以指定的字符数返回从指定位置开始的字符串中的字符。
    "hello".substr(1); // "ello"
    • The charAt() method returns the specified character from a string.

      charAt()方法从字符串中返回指定的字符。
    "hello".charAt(0); // "h"

    The depth of the recursion is equal to the length of the String. This solution is not the best one and will be really slow if the String is very long and the stack size is of major concern.

    递归的深度等于String的长度。 如果String非常长且堆栈大小是主要问题,则此解决方案不是最佳解决方案,并且会非常慢。

    function reverseString(str) {
      if (str === "") // This is the terminal case that will end the recursion
        return "";
      
      else
        return reverseString(str.substr(1)) + str.charAt(0);
    /* 
    First Part of the recursion method
    You need to remember that you won’t have just one call, you’ll have several nested calls
    
    Each call: str === "?"        	                  reverseString(str.subst(1))     + str.charAt(0)
    1st call – reverseString("Hello")   will return   reverseString("ello")           + "h"
    2nd call – reverseString("ello")    will return   reverseString("llo")            + "e"
    3rd call – reverseString("llo")     will return   reverseString("lo")             + "l"
    4th call – reverseString("lo")      will return   reverseString("o")              + "l"
    5th call – reverseString("o")       will return   reverseString("")               + "o"
    
    Second part of the recursion method
    The method hits the if condition and the most highly nested call returns immediately
    
    5th call will return reverseString("") + "o" = "o"
    4th call will return reverseString("o") + "l" = "o" + "l"
    3rd call will return reverseString("lo") + "l" = "o" + "l" + "l"
    2nd call will return reverserString("llo") + "e" = "o" + "l" + "l" + "e"
    1st call will return reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h" 
    */
    }
    reverseString("hello");

    没有评论: (Without comments:)

    function reverseString(str) {
      if (str === "")
        return "";
      else
        return reverseString(str.substr(1)) + str.charAt(0);
    }
    reverseString("hello");

    条件(三元)运算符: (Conditional (Ternary) Operator:)

    function reverseString(str) {
      return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
    }
    reverseString("hello");

    Reversing a String in JavaScript is a small and simple algorithm that can be asked on a technical phone screening or a technical interview. You could take the short route in solving this problem, or take the approach by solving it with recursion or even more complex solutions.

    在JavaScript中反转字符串是一种小型且简单的算法,可以在电话技术筛选或技术面试中询问。 您可以采用短路径解决此问题,也可以采用递归或更复杂的解决方案来解决。

    I hope you found this helpful. This is part of my “How to Solve FCC Algorithms” series of articles on the Free Code Camp Algorithm Challenges, where I propose several solutions and explain step-by-step what happens under the hood.

    希望对您有所帮助。 这是我的“如何解决FCC算法”系列文章的一部分,有关自由代码训练营算法挑战,我在其中提出了几种解决方案并逐步解释了幕后情况。

    Three ways to repeat a string in JavaScriptIn this article, I’ll explain how to solve freeCodeCamp’s “Repeat a string repeat a string” challenge. This involves…

    在JavaScript中重复字符串的三种方法 在本文中,我将解释如何解决freeCodeCamp的“重复字符串重复字符串”挑战。 这涉及…

    Two ways to confirm the ending of a String in JavaScriptIn this article, I’ll explain how to solve freeCodeCamp’s “Confirm the Ending” challenge.

    在JavaScript中确认字符串结尾的两种方法 在本文中,我将解释如何解决freeCodeCamp的“确认结尾”挑战。

    Three Ways to Factorialize a Number in JavaScriptThis article is based on Free Code Camp Basic Algorithm Scripting “Factorialize a Number”

    在JavaScript中分解数字的三种方法 本文基于Free Code Camp基本算法脚本“简化数字”

    Two Ways to Check for Palindromes in JavaScriptThis article is based on Free Code Camp Basic Algorithm Scripting “Check for Palindromes”.

    用JavaScript检查回文的两种方法 本文基于Free Code Camp基本算法脚本“检查回文”。

    Three Ways to Find the Longest Word in a String in JavaScriptThis article is based on Free Code Camp Basic Algorithm Scripting “Find the Longest Word in a String”.

    在JavaScript中查找字符串中最长单词的三种方法 本文基于Free Code Camp基本算法脚本“查找字符串中最长单词”。

    Three Ways to Title Case a Sentence in JavaScriptThis article is based on Free Code Camp Basic Algorithm Scripting “Title Case a Sentence”.

    用JavaScript给句子加标题的三种方法 本文基于Free Code Camp基本算法脚本“标题加句子”。

    If you have your own solution or any suggestions, share them below in the comments.

    如果您有自己的解决方案或任何建议,请在下面的评论中分享。

    Or you can follow me on Medium, Twitter, Github and LinkedIn, right after you click the green heart below ;-)

    或者,您也可以在单击下面的绿色心脏之后立即在Medium TwitterGithubLinkedIn上关注我;-)

    ‪#‎StayCurious‬, ‪#‎KeepOnHacking‬ & ‪#‎MakeItHappen‬!

    ‪#StayCurious‬,‪#KeepOnHacking‬和‪#MakeItHappen‬!

    翻译自: https://www.freecodecamp.org/news/how-to-reverse-a-string-in-javascript-in-3-different-ways-75e4763c68cb/

    展开全文
  • python字符串反转方法Hello everyone, in this tutorial we’ll see ... 大家好,在本教程中,我们将看到在Python中反转字符串的不同方法。 As we know, we can reverse a list using reverse() method but Py...
  • 大家都知道翻转字符串字符串算法中算是比较常见的,下面这篇文章主要介绍了Swift算法实现逐字翻转字符串的方法,文中给出了详细的示例代码,需要的朋友可以参考借鉴,下面来一起看看吧。
  • 递归 反转字符串 1.简介 在本文中,您将学习如何使用递归方法来反转字符串。 第一个程序是反转字符串,第二个程序将读取用户的输入。 在之前的文章中,我已经展示了如何不使用任何内置函数来反转字符串,以及如何...
  • 如何在Java中反转字符串

    千次阅读 2020-06-01 10:58:08
    在本文中,我们将向您展示几种在Java中反转String的方法。 StringBuilder(str).reverse() char[]循环和值交换。 byte循环和值交换。 Apache commons-lang3 为了进行开发,请始终选择标准的StringBuilder...
  • 翻转字符串中的单词

    2020-05-06 19:39:44
    给定一个字符串,你需要反转字符串中每个单词的字符顺序,同时仍保留空格和单词的初始顺序。 示例 1: 输入: “Let’s take LeetCode contest” 输出: “s’teL ekat edoCteeL tsetnoc” 注意:在字符串中,每个单词...
  • 如何在Python中反转字符串

    千次阅读 2020-05-31 08:12:04
    在Python中,反转字符串最快,最简单的方法是扩展切片[::-1] 。 print("hello world"[::-1]) # dlrow olleh 本文将向您展示几种在Python中反转字符串的方法。 [::-1]逆序切片。 (好) [::-1]切片工具作为...
  • go语言反转字符串

    2020-03-22 17:53:10
    有一道coding是反转字符串。以为是送分题,但是用go语言只ac了80%,于是记录一下。 题目:反转一个给定的字符串并输出 错误coding(只考虑了8位的编码形式,如中文的字符串输入就没有考虑): package main /** * ...
  • c++反转字符串代码

    2014-04-09 16:32:07
    c++反转字符串 简单的代码 测试可用,已经实现了方法和main函数
  • 541. 反转字符串 II 给定一个字符串和一个整数 k,你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符,则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符,则反转前...
  • 反转字符串里的单词

    2021-06-17 17:52:39
    给你一个字符串 s ,逐个翻转字符串中的所有 单词 。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。 说明: 输入...
  • 给定一个字符串,逐个翻转字符串中的每个单词。 示例 1: 输入: "the sky is blue" 输出: "blue is sky the" 示例 2: 输入: " hello world! " 输出: "world! hello" 解释: 输入字符串可以在前面或者后面包含多余的...
  • c++反转字符串

    2020-07-31 16:49:24
    输入一个字符串,输出一个反转后的字符串。 这个问题比较简单,解题思路也很多: 使用std::reverse()函数 从末尾开始读取原字符串,将其放入一个新建的字符串中 遍历字符串,首尾交换位置,奇数位的中间元素不用...
  • 解释:输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。 示例 3: 输入:"a good example" 输出:"example good a" 解释:如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一...
  • 翻转字符串里的单词

    2020-05-02 22:55:08
    给定一个字符串,逐个翻转字符串中的每个单词。 示例 1: 输入: "the sky is blue" 输出:"blue is sky the" 示例 2: 输入: " hello world! " 输出:"world! hello" 解释: 输入字符串可以在前面或者后面包含多余...
  • 题目描述 将一句话的单词进行倒置,标点不倒置。比如 I like beijing. 经过函数后变为:beijing...依次输出倒置之后的字符串,以空格分割 示例1 输入: I like beijing. 输出: beijing. like I **思路:**先通过subs...
  • C++实现反转字符串里的单词

    千次阅读 2019-09-08 09:53:03
    问题描述:给定一个字符串,逐个翻转字符串中的每个单词。
  • 给定一个字符串,逐个翻转字符串中的每个单词。 示例 1: 输入: "the sky is blue" 输出: "blue is sky the" 今天刷这道算法题的时候,感触良多。java 4行代码,每一行都很有价值。进阶之路还很漫长,加油吧!!! ...
  • 翻转字符串里的单词(C语言解决)

    千次阅读 2019-04-22 16:03:13
    给定一个字符串,逐个翻转字符串中的每个单词。 示例 1: 输入: “the sky is blue” 输出: “blue is sky the” 示例 2: 输入: " hello world! " 输出: “world! hello” 解释: 输入字符串可以在前面或者...
  • C语言反转字符串

    2021-02-23 08:45:14
    C语言反转字符串 最近看了好多开发中的奇技淫巧,于是有了这样的思路 反转字符串虽然简单但应用范围却很广,一般的套路是先用字符串数组读入字符串,然后循环并倒序输出每一位字符。 我又想到了在做链表反转时用到的...
  • ”的字符串,要求把字符串反转成“! book a is this”,反转单词倒是好说,但是要求两个单词中的空格数不一定,而且不能有缺失 思路: 先把字符串切割成一个字符串数组,按照“”进行切割。或者转成char[] 也是可以...
  • 将句子按照空格进行分隔,将字符串当做数组,数组的先后顺序就是单词之间的先后顺序 2.将数组中的每个单词进行反转 方式1: <script> //方式1 const reverseWords = str =>{ let arr = str.split...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,576
精华内容 75,430
关键字:

翻转字符串