精华内容
下载资源
问答
  • newcoder

    2019-09-08 21:29:24
    1. function reserve(str){ str=str.split(' '); str=str.reverse() console.log(str.join(' ')) } reserve("it's a dog") 2.两数之和 /** * @param {number[]} nums * @param {number} ...* @return {nu...

    1.

    function reserve(str){

    str=str.split(' ');

    str=str.reverse()

    console.log(str.join(' '))

    }

    reserve("it's a dog")

    2.两数之和

    /**
     * @param {number[]} nums
     * @param {number} target
     * @return {number[]}
     */
    function ee(nums, target) {
        let len=nums.length,
            flag,
            sonarr,
            parentarr=[];
        if(len<2)
            return
        else{
            for(let i=0;i<len-1;i++){
                for(let j=i+1;j<len;j++){
                    flag=nums[i]+nums[j]==target?1:0;
                    if(flag){
                        sonarr=[i,j]
                        parentarr.push(sonarr);
                    }
                }

            }
            parentarr.map(item=>{
                console.log(item)
            })
        }

    };
    let nums=[1,3,5,2,4];
    ee(nums,5)

    var twoSum = function(nums, target) {
        let res = {} 
        for(let i = 0; i < nums.length; i++) {
            if(res[nums[i]] !== undefined)
                return [res[nums[i]], i]
            else
                res[target - nums[i]] = i
        }
    }

    遍历一遍  所有的数

    首先判断 我自己是不是被需要的数  不是  那我就记下 我需要的数,并且  记下我的索引

    res{ 我需要的数: 我的索引 }

    展开全文
  • Newcoder练习题

    2019-02-18 18:12:11
    Newcoder 练习题 Programming language: Python 2.7.x 剑指offer66题 (更新中…) 孩子们的游戏 思路:每次拿到小礼品的孩子的位置为 (上一个小孩子的位置+m-1)%(小孩总数),依次循环,直到列表中只有一个元素,输出...

    Newcoder 练习题

    Programming language: Python 2.7.x

    剑指offer66题 (更新中…)

    孩子们的游戏

    思路:每次拿到小礼品的孩子的位置为 (上一个小孩子的位置+m-1)%(小孩总数),依次循环,直到列表中只有一个元素,输出即可

    求1+2…+n

    思路:采用递归的形式进行求解

    第一个只出现一次的字符

    思路:遍历字符串,若在该字符的前后都没有出现该字符,将该字符输出,遍历结束后若返回-1

    数组中只出现一次的字符

    思路:遍历数组,每次遍历时都新建一个没有当前字符的暂时数组,若当前字符在暂时数组中找不到与之相同的字符,将其添加至结果列表中,直到结果列表中的字符为2

    斐波那契数列

    思路:做法十分简单,a[n] = a[n-1] + a[n-2]

    数值的n次方

    思路:调用python内置的 ** 进行幂运算

    跳台阶

    思路:与斐波那契数列做法相似

    变态跳台阶

    思路:a[n] = a[0] + … + a[n-1]

    替换空格

    思路:使用python内置的对于str的replace()方法

    整数中1出现的次数

    思路:将整数变为字符串,遍历字符串

    构建乘积数组

    思路:对于B中的每个元素,构建一个去掉A中对应该下标元素的数组temp,将temp中的所有元素进行乘积后赋值给B中对应位置的元素即可

    翻转单词序列

    思路:调用python内置的reverse()方法进行翻转

    数据流中的中位数

    思路:遍历原始列表,依次向temp列表中添加元素,再调用sorted()方法对temp列表进行排序再进行中位数的计算(代码可以得到正确结果,但是再newcoder这里通过不了)

    其他练习题

    汽水瓶

    思路:每次将手中的水瓶对3进行取余,将取余后的空水瓶加上换来的水瓶再进行兑换,直到手中的水瓶数量小于2,等于2时+1
    思路:空水平数量/2,向下取整

    大整数相乘

    思路:python支持大整数

    最大乘积

    思路:排序后将首位四个数进行三个为组进行乘积操作,输出数值最大的数(该方法可以输出正确结果,但是nowcoder这里通不过)

    去重排序

    思路:新建一个列表,每次从原始列表中向新建列表中添加元素时先检测是否有相同的元素,有则不添加,没有则反之,添加完后调用sort()进行排序

    展开全文
  • newcoder【链表分割】

    2019-07-22 16:05:31
    newcoder【链表分割】 题目描述: 编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前。 给定一个链表的头指针 ListNode* pHead,请返回重新排列后的链表的头指针。注意:分割...

    newcoder【链表分割】

    题目描述:
    编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前。
    给定一个链表的头指针 ListNode* pHead,请返回重新排列后的链表的头指针。注意:分割以后保持原来的数据顺序不变。
    来源:牛客(newcoder)
    链接https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId
    思路:
    给定一个指针cur,如果cur->val<x,把cur指向的元素存入lesshead,如果cur->val>x,
    把cur指向的元素存入greaterhead,遍历完后让lesstail->next=greaterhead->next。
    代码实现:

    /*
    struct ListNode {
        int val;
        struct ListNode *next;
        ListNode(int x) : val(x), next(NULL) {}
    };*/
    class Partition {
    public:
        ListNode* partition(ListNode* pHead, int x) {
            // write code here
             if(pHead == NULL)
                return NULL;
            
            struct ListNode* lessHead, *lessTail,*greaterHead, *greaterTail;
            lessHead = lessTail = (struct ListNode*)malloc(sizeof(struct ListNode));
            greaterHead = greaterTail = (struct ListNode*)malloc(sizeof(struct ListNode));
            struct ListNode* cur = pHead;
            while(cur)
            {
                if(cur->val < x)
                {
                    lessTail->next = cur;
                    lessTail = lessTail->next;
                }
                else
                {
                    greaterTail->next = cur;
                    greaterTail = greaterTail->next;
                }
                cur = cur->next;
            }
            
            lessTail->next = greaterHead->next;
            greaterTail->next = NULL;
            
            pHead = lessHead->next;
            free(lessHead);
            free(greaterHead);
            
            return pHead;
        }
    };
    

    环境:
    c语言

    展开全文
  • NewCoder算法基础 Class 1

    2018-10-22 16:54:40
    NewCoder算法基础 Class 1 时间复杂度 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;[1]只要高阶项,不要低阶项 &amp;nbsp...

    NewCoder算法基础 Class 1

    • 时间复杂度

            [1]只要高阶项,不要低阶项

            [2]不要高阶项系数

    例题1: 一个有序数组A,另一个无序数组B,请打印B中的所有不在A中的数,A数组长度为N,B数组长度为M。

    [ 1 ] 方法一:对于数组B中的每一个数,都在A中通过遍历的方式找一下

    int Search(int arrA[], int arrB[], int ALength, int BLength){
        int *help=(int *)malloc(sizeof(int)*BLength);
        int k=0;
        for(int i=0; i<BLength; i++){
            for(int j=0; j<ALength; j++){
                if(arrB[i]==arrA[j]){
                    break;
                }
                if(j==ALength){
                    help[k++]=arrB[i];
                }
            }
        }
    }
    

    [ 2 ] 方法二:对于数组B中的每一个数,都在A中通过二分的方式找一下

    int BinarySearch(int arr[], int L, int R, int key){
        int L=0, R=arr.size()-1;
        while(L<=R){
            mid=(L+R)/2;
            if(arr[mid]==key){
                return mid;
            }
            else if(arr[mid]>key){
                R=mid-1;
            }
            else{
                L=mid+1;
            }
        }
        return -1;
    }
    

    Note:

    mid=(L+R)/2   这种写法中L+R容易造成越界,所以可以写成L+(R-L)>>1

    [ 3 ] 方法三:先把数组B排序,然后用类似外排的方式打印所有在A中出现的数

          i
      A 1 2 4 6 7
          j
      B 3 6 9

    过程:
    1) 1<3   i++
    2)2<3   i++
    3)4>3   print arrB[j]   j++
    4)4<6   i++
    5)6=6   j++
    6)6<9   i++
    7)7<9   i++   print arrB[j]
    (i, j 任意一方越界循环停止)

    int External(int arrA[], int arrB[]){
        int ALength=arrA.size();
        int BLength=arrB.size();
        int *help=(int *)malloc(sizeof(int)*BLength);
        int i=0,j=0,k=0;
        while(i<ALength && j<BLength){
            if(arrB[j]>arrrA[i]){
                i++;
            }
            else{
                if(arrB[j]<arrA[i]){
                    help[k++]=arrB[j++];
                }
                else{
                    j++;
                }
            }
        }
    }
    
    • 冒泡排序

    3 2 0 4 7
    3 2 0 4 7--->2 3 0 4 7--->2 0 3 4 7--->2 0 3 4 7

    int BubbleSort(int arr[], int len){
        for(int i=0; i<len; i++){
            for(int j=0; j<len-1-i; j++){
                if(arr[j]>arr[j+1]){
                    swap(a[j], a[j+1]);
                }
            }
        }
    }
    
    int BubbleSort(int arr[], int len){
        for(int end=len-1; end>=0; end--){
            for(int i=0; i<end ;i++){
                if(arr[j]>arr[j+1]){
                    swap(a[j], a[j+1]);
                }
            }
        }
    }
    

    T(n)=n+(n-1)+(n-2)+......+1=(1+n)*n/2
               =O(n^2)

    • 选择排序

    下标: 0~~~~~~~~~~~~~~~~~~~~~~~n-1
               min
                      1~~~~~~~~~~~~~~~~~~~~~n-1
                   min'
                          2~~~~~~~~~~~~~~~~~~~n-1
                        min''

    int SelectionSort(int arr[], int len){
        for(int i=0; i<len; i++){
            int min=arr[i];
            for(int j=i+1; j<len; j++){
                if(arr[j]<min){
                    swap(arr[j], min);
                }
            }
        }
    }
    
    int SelectionSort(int arr[], int len){
        for(int i=0; i<len; i++){
            int min=INT_MAX;//INT_MAX为正无穷
            for(int j=i; j<len; j++){
                if(arr[j]<min){
                    swap(arr[j], min);
                }
            }
        }
    }
    

        T(n)=n+(n-1)+(n-2)+......+1=(1+n)*n/2
               =O(n^2)

    • 插入排序

    5 3 4 0 6
    5 | 3 4 0 6
                              swap(5, 3)
    5 3 | 4 0 6   ---> 5 3 | 4 0 6 ---> 3 5 | 4 0 6
                              swap(5, 4)
    3 5 4 | 0 6   ---> 3 5 4 | 0 6   ---> 3 4 5 | 0 6 ---> 3 4 5 | 0 6
                              swap(5, 0)         swap(4, 0)         swap(3, 0)
    3 4 5 0 | 6   ---> 3 4 5 0 | 6   ---> 3 4 0 5 | 6 ---> 3 0 4 5 | 6 ---> 0 3 4 5 | 6
    0 3 4 5 6 ---> 0 3 4 5 6 --->0 3 4 5 6 ---> 0 3 4 5 6 ---> 0 3 4 5 6 ---> 0 3 4 5 6

    int InsertSort(int arr[], int len){
        for(int i=1; i<len; i++){
            for(int j=i-1; j>=0; j--){
                if(arr[j]>a[j+1]){
                    swap(a[j], a[j+1]);//此处也可使用三目运算符
                }
            }
        }
    }
    

        最好情况:O(n)
        最坏情况:O(n^2)

    • 对数器

    1. 无OJ线上测试,可以验证自己写的是否正确
    2. 小样本正确,大样本WA 希望依然使用小样本检测问题
    3. 贪心策略 用对数器无需证明

    对数器构造

    1. 产生堆积样本的发生器
    2. 寻找一个完全准确的方法(容易实现,无需考虑时间复杂度)
    3. 数据完全拷贝两份,分别传递到测试函数和完全正确的函数中,进行结果比较

    对数器的概念和使用

    1. 有一个你想要测的方法a
    2. 实现一个绝对正确但是复杂度不好的方法b
    3. 实现一个随机样本产生器
    4. 实现比对的方法
    5. 把方法a和方法b比对很多次来验证方法a是否正确。
    6. 如果有一个样本使得比对出错,打印样本分析是哪个方法出错
    7. 当样本数量很多时比对测试依然正确,可以确定方法a已经正确。
    • 递归行为的实质

    递归思想(例如数组中找最大值)
                        L        |        R
                   max_L        max_R
                 Max(max_L, max_R)

    int getMax(int arr[], int L, int R){
        if(L==R){
            return arr[L];
        }
        int mid=L+(R-L)>>1;
        int maxLeft=getMax(arr, L, mid);
        int maxRight=getMax(arr, mid+1, R);
        return max(maxLeft, maxRight);
    }
    

          max(arr, 0, 3)
                    mid=1
                    max(arr, 0, 1)
                          mid=0
                          max(arr, 0, 0)
                                return


          max(arr, 0, 3)
                    mid=1
                    max(arr, 0, 1)
                          mid=0    maxLeft=4

    Note:

            在递归的过程中,系统会将代码行、形参、局部变量等信息压入系统栈中,当遇到return后将栈顶信息弹出还原现场并将值带回,然后执行接下来的语句
            任何递归行为都可以改成非递归(无需系统压栈,自己手动压栈)---> 从递归改为迭代

    • 计算递归行为的时间复杂度Master公式

    T(n)=aT(n/b)+O(n^d)

            比如二分查找    T(n)=2T(n/2)+O(1)

    Master公式

    logba&gt;d&gt;O(nlogba)\log_ba&gt;d \kern{10px} ---&gt; \kern{10px} O(n^{log_ba})

    logba=d&gt;O(ndlogba)\log_ba=d \kern{10px} -&gt; \kern{10px} O(n^d*{log_ba})

    logba&lt;d&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&MediumSpace;&gt;O(nd)\log_ba&lt;d \:\:\:\:\:\:\:\:\:---&gt; \kern{10px} O(n^d)

    • 归并排序

    Merge过程
        5 3 6 | 2 0 1
        3 5 6 | 0 1 2
         i        |  j
        将小的数值填入到辅助数组help中,对应区域指针向后移一位

    void MergeSort(int arr[], int L, int R){
        if(L==R){
            return ;
        }
        int mid=L+(R-L)>>1;
        MergeSort(arr, L, mid);
        MergeSort(arr, mid+1, R);
        merge(arr, L, mid, R);
    }
    
    void merge(int arr[], int L, int mid, int R){
        int i=L, j=mid+1, k=0;
        int *help=(int *)malloc(sizeof(int)*(R-L+1));
        //两个有且只有一个越界
        while(i<=mid && j<=R){
            help[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
        }
        while(i<=mid){
            help[k++]=arr[i++];
        }
        while(j<=R){
            help[k++]=arr[j++];
        }
    }
    

    例题2:小和问题
            在一个数组中,每一个数左边比当前数小的数累加起来,叫做这个数组的小和。求一个数组的小和。

    例子: [1,3,4,2,5]
        1左边比1小的数,没有;
        3左边比3小的数,1;
        4左边比4小的数,1、3;
        2左边比2小的数,1;
        5左边比5小的数,1、3、4、2;
        所以小和为1+1+3+1+1+3+4+2=16

    [ 1 ] 方法一:暴力 遍历所有比current小的数进行累和

    int function(int arr[], int len){
        int sum=0;
        for(int i=1; i<len; i++){
            for(int j=0; j<i; j++){
                if(arr[j]<arr[i]){
                    sum+=arr[j];
                }
            }
        }
    }
    

    [ 2 ] 方法二:在归并过程中计算小和

                                         1 3 4 | 2 5
                                             /          \
                                      1 3 | 4     2 | 5
                                       /
                                   1 | 3

           1)1 | 3 归并成 1 3 产生小和1
           2)2 | 5 归并成 2 5 产生小和2
           3)1 3 | 4 归并成 1 3 4 产生小和1 3
               i        j    arr[i]

    Note:

    merge过程加速了累和(原因:有效地利用循环过程
        注:位运算运算速度快于基本运算

    展开全文
  • newcoder-oj 牛客题霸-算法篇-程序员面试高频题(c ++)
  • Newcoder 贝伦卡斯泰露(DFS) 题意:给n个元素组成的数组(n为偶数),问能否分成两个长度n/2的相同子序列. 思路:DFS,确立好参数,分两种情况:当前元素匹配(序列C中要与序列B匹配的数)则将该元素加入到C,继续DFS,...
  • 题目描述: 输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含...重建二叉树 newcoder 链接 以下为 2019.6.5 更新 /** * Definition for binary tree ...
  • 替换空格----newcoder

    2018-11-23 19:21:36
    newcoder 题目链接 题解: 拿到这个题,先分析题意,需要把所有的空格都替换为 “%20”,很明显这个&quot;%20&quot;是一个字符串,不是一个字符,要替换全部空格,字符串的长度肯定会增加,所以必定要...
  • 跳台阶 ----newcoder

    2018-11-23 20:57:57
    newcoder 题目链接 题解 台阶不应该为负数,但这是题目,万一有个负数测试用例呢,所以我们避免一下 如果台阶只有一级,那肯定只有一种方法 如果台阶有两级,就有两种办法,一次跳一步,和一步跳两级 如果有...
  • newcoder【链表中倒数第k个结点】 题目描述: 输入一个链表,输出该链表中倒数第k个结点。 来源:牛客(newcoder) 链接:https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId 思路: 使用...
  • newcoder 题目链接 题解 方法一:递归 所谓镜像就是把左右子树交换嘛 拿到一棵树的根节点,如果非空,就交换左右孩子节点 然后递归交换左子树,再递归交换右子树 下面附上代码: /* struct TreeNode { ...
  • newcoder - 小米

    2021-04-20 11:23:47
    1. 字符串类 1.1 反转字符串 (1)直接使用java api 方法 实现1.1-1: public static String solve1(String str) { return new StringBuffer(str).reverse().toString() } // StringBuilder同StringBuffer ...
  • newcoder在线编程2题目描述给定一个句子(只包含字母和空格), 将句子中的单词位置反转,单词用空格分割, 单词之间只有一个空格,前后没有空格。 比如: (1) “hello xiao mi”-> “mi xiao hello”输入描述:输入...
  • 题目描述: 输入一个链表,按链表值从尾到头的顺序返回一个ArrayList...newcoder 网页链接 以下为 2019.06.05 更新 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x...
  • newcoder比赛打卡

    2020-12-02 10:02:19
    C. 后缀表达式计算 # # 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可 # 给定一个后缀表达式,返回它的结果 # @param str string字符串 # @return long长整型 # ...
  • Newcoder 14301 K-th Number(二分) 题目描述 Alice are given an array A[1…N] with N numbers. Now Alice want to build an array B by a parameter K as following rules: Initially, the array B is empty. ...
  • newcoder 题目链接 题解 栈大家都熟悉了,push 和 pop 操作都不难,但是要实现一个 min 函数,还要求时间复杂度0(1) 根据栈的特性,只能弹出栈顶元素,所以用来实现这个 min 函数的数据结构需要多加思量,0...
  • newcoder 剪绳子

    2020-02-17 15:27:33
    给你一根长度为n的绳子,请把绳子剪成整数长的m段(m、n都是整数,n>1并且m>1),每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]xk[1]x...xk[m]可能的最大乘积是多少?例如,当绳子的长度是8时,我们把它剪...
  • newcoder 题目链接 题解 拿到这个题,我想到的第一种解法就是这个了,用位运算 考虑到 1 &amp; 1 == 1 1 &amp; 0 == 0 所以只需要把 1 左移 n 位然后进行按位与运算,就可以知道这个数的第 n 位是 0 ...
  • newcoder 题目链接 题解 我们换个名字,叫做二叉树的层序遍历 这个名字熟悉吧 在树这个模块,用的最多的就是递归了吧,但这个层序遍历递归解决不了,需要借助队列来解决。 考虑队列的特性先进先出, 如果树...
  • 题目描述 在一个二维数组中(每...newcoder 题目链接 题解: 拿到这个题,第一种思路就是遍历一遍 这是一个时间复杂度为 O(n2) 的办法 代码如下: #include &amp;lt;iostream&amp;gt; #in...
  • newcoder 题目链接 题解 首先我们先回忆一下二叉搜索树, 对二叉搜索树的根节点,根节点的左子树上所有元素的值都比根节点的值小,根节点右子树上所有元素的值都比根节点元素的值大 在回忆一下后序遍历 后序...
  • 题目描述: 用两个栈来实现一个队列,完成队列...用两个栈实现一个队列 newcoder 题目链接 以下为 2019.06.05 更新 class Solution { public: void push(int node) { /** * 先考虑栈和队列的特性 * 栈:...
  • newcoder 统计字符

    2018-10-04 10:38:36
    题目描述 给定一个英文字符串,请写一段代码找出这个字符串中首先出现三次的那个英文字符(需要区分大小写)。 输入描述: 输入数据一个字符串,包括字母,数字等。 输出描述: 输出首先出现三次的那个英文字符 ...
  • NewCoder小定律

    2018-09-26 21:21:39
    NowCoder小定律 时间限制 1000 ms 内存限制 32768 KB 代码长度限制 100 KB 判断程序 Standard (来自 小小) 题目描述 对于表达式n^2+n+41,当n在(x,y)范围内取整数值时(包括x,y)(-39&...
  • 题目描述 输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否可能为该栈的弹出顺序。 假设压入栈的所有数字均不...newcoder 题目链接 题解 什么意思呢?简单的说就是给你序列,让你通过一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 819
精华内容 327
关键字:

newcoder