小编cod*_*101的帖子

#include <iostream>
using namespace std;

int main()
{
    int x=80;
    int &y=x;
    cout<<"x"<<x<<" "<<"y"<<y++; 
    return 0;
}

上面的代码给了我以下输出:

81 80

任何人都可以解释一下x变化的价值如何81？yis 的值80然后会增加到81,但它是如何反映的x？

它是否反映因为y是参考变量？然后该值应该在两个已被修改x和y？

问题:给定任意顺序的一组时间间隔,将所有重叠间隔合并为一,并输出应该只具有互斥间隔的结果.为简单起见,将间隔表示为整数对.例如,让给定的一组区间为{{1,3},{2,4},{5,7},{6,8}}.区间{1,3}和{2,4}彼此重叠,因此它们应合并成{1,4}.类似地,{5,7}和{6,8}应该合并并成为{5,8}

编写一个函数,为给定的一组区间产生一组合并区间.

我的代码:

import java.util.*;
import java.lang.*;
import java.io.*;

class Interval 
{
    int start;
    int end;

    Interval() {
        start = 0;
        end = 0;
    }

    Interval(int s, int e) 
    {
        start = s;
        end = e;
    }
}

class Ideone
{
    public ArrayList<Interval> merge(ArrayList<Interval> intervals) {

        if(intervals.size() == 0)
            return intervals;
        if(intervals.size() == 1)
            return intervals;

        Collections.sort(intervals, new IntervalComparator());

        Interval first = intervals.get(0);
        int start = first.start;
        int end = first.end;

        ArrayList<Interval> result = new ArrayList<Interval>();

        for(int i = 1; …

我遇到了以下问题:

给定一个未排序的阵列B[1 . . 2n+1]的实数,给其输出的一个排列的线性时间算法A[1..2n+1]的B,使得A一个波浪.

我基本上做了一个合并排序并改变它:

 MergeSort(a,n)
      int i=2;
     while (i ? n)
     {
       Swap(a[i?1], a[i]);
       i=i+2;
     }

但时间复杂度O(nlogn) + O(n)(分别来自排序和循环)产生O(nlogn).但我想及时做到O(n).

我应该使用计数排序/基数排序/桶排序来获得线性时间然后改变它以获得一个摇摆的数组吗？

考虑以下C函数：

int fun1 (int n)
{
    int i, j, k, p, q = 0;

    for (i = 1; i<n; ++i)
    {
        p = 0;

        for (j=n; j>1; j=j/2)
            ++p;

        for (k=1; k<p; k=k*2)
            ++q;
    }
    return q;
}

问题是要确定以下哪个最接近函数的返回值fun1？

（A）n ^ 3
（B）n（logn）^ 2
（C）nlogn
（D）nlog（logn）

这是给出的解释：

int fun1 (int n)
{
    int i, j, k, p, q = 0;

    // This loop runs T(n) time 

    for (i = 1; i < n; ++i)
    {
        p = 0; …

Integer.toString(n,8) // decimal to octal

Integer.toString(n,2) // decimal to binary

Integer.toString(n,16) //decimal to Hex

我们在java中有这些函数...我们在c ++中有这样的内置函数吗？

我打算找到一个数组的所有可能的子序列

我尝试用两种不同的方式做到这一点

1)方法1

我用数组中的值创建一个字符串

// all possible subsequences - all possible elements found by eleiminating zero or more characters

Public class StrManipulation{

public static void combinations(String suffix,String prefix){
    if(prefix.length()<0)return;
    System.out.println(suffix);
    for(int i=0;i<prefix.length();i++)
     combinations(suffix+prefix.charAt(i),prefix.substring(i+1,prefix.length()));
}

public static void main (String args[]){
    combinations("","12345");
    }
 }

问题---仅适用于单个数字字符

2)方法2

    int a[] = new int[3];
    a[0]=2;a[1]=3;a[2]=8;

  List<Integer> al= new ArrayList<Integer>();

    for(int i=0;i<3;i++)
        al.add(a[i]);

  int i, c;

  for( c = 0 ; c < 3 ; c++ )
  {

     for( i = c+1 ; i <= …