小编Viv*_*mar的帖子

我无法掌握Hackerrank这个问题解决方案背后的逻辑,https://www.hackerrank.com/challenges/crush/problem

在讨论部分,许多人也发布了他们的解决方案,但我无法理解为什么这种逻辑有效.

以下解决方案取自相同问题的讨论部分,并具有最大数量的upvotes,

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {
    long int N,K,p,q,sum,i,j,max=0,x=0;

    cin>>N>>K;
    long int *a=new long int[N+1]();

    for(i=0;i<K;i++)
    {
        cin>>p>>q>>sum;
        a[p]+=sum;
        if((q+1)<=N) a[q+1]-=sum;
    }

    for(i=1;i<=N;i++)
    {
       x=x+a[i];
       if(max<x) max=x;

    }

    cout<<max;
    return 0;
}

有人可以解释背后的逻辑吗？非常感谢您的帮助.

看到这段代码的输出我感到很惊讶:

public class File
{
    public static void main(String[] args)
    {
        movie();
    }

    static void movie(double... x)
    {
        System.out.println("No varargs");
    }

    static void movie(int... x)
    {
        System.out.println("One argument");
    }
}

它输出,

One argument

为什么会这样？

我认为这段代码不能编译,因为调用movie()是模糊的,但运行正常并输出One argument.

如果我将代码修改为:

public class File
{
    public static void main(String[] args)
    {
        movie();
    }

    static void movie(boolean... x)  //Changed the parameter type to boolean from double
    {
        System.out.println("No varargs");
    }

    static void movie(int... x)
    {
        System.out.println("One argument");
    }
} …

我无法理解下面的代码如何打印50.0

public class Pre
{
    public static void main(String[] args)
    {
        int x=10;
        System.out.println((x > 10) ? 50.0 : 50); //output 50.0
    }
} 

它应该打印50(我猜)不是50.0

上面的代码不等于下面的代码吗？

public class Pre
{
    public static void main(String[] args)
    {
        int x=10;
        if(x>10)
            System.out.println(50.0);
        else
            System.out.println(50);//output
    }
}

如果它们是等价的,那么为什么输出的差异呢？

为什么这段代码没有显示任何编译错误？

public class Generic
{
    public static void main(String[] args)
    {
        Character[] arr3={'a','b','c','d','e','f','g'};
        Integer a=97;
        System.out.println(Non_genre.genMethod(a,arr3));
    }
}

class Non_genre
{
    static<T> boolean genMethod(T x,T[] y)
    {
        int flag=0;
        for(T r:y)
        {
            if(r==x)
                flag++;
        }
        if(flag==0)
            return false;
        return true;
    }
}

如果我们写这样的普通代码(如下所示)

public class Hello
{
    public static void main(String[] args)
    {
        Character arr=65;
        Integer a='A';
        if(arr==a)  //Compilation Error,shows Incompatible types Integer and Character
            System.out.println("True");
    }
}   

那么为什么上面的上面运行正常,T怎么可能是Integer类和T的数组同时是Character类,如果它运行那么为什么它不打印为true,'a'的ASCII vaue是97,所以它应该打印真实.

请告诉我,如果字符串是数字且数字位数相同,那么运算符对字符串的工作量是多少.这些操作符究竟如何工作？

例如,对于以下比较 -

cout<<("3" > "5")<<endl;
cout<<("31" > "25")<<endl;
cout<<("35" > "35")<<endl;
cout<<("38" > "85")<<endl;
cout<<("53" > "55")<<endl;
cout<<("36" > "35")<<endl;
cout<<("53" > "54")<<endl;

我从CodeBlocks获得的输出是 -

0
0
0
0
0
0
0

在我的应用程序中，我想通过context将应用程序的全局存储传递给子组件。为了举例，我创建了 2 个子组件，即Child1和Child2，并将计数器函数以及相应的计数器值传递increment给decrement它们。Child1负责递增counter1和child2递减counter2。当我在组件中调用增量/减量函数时，另一个组件与父组件一起毫无用处地重新渲染。我怎样才能防止这种情况发生？

请在此处找到上述用例

下面是相同的代码，

应用程序.js

import React, { useState, useCallback } from 'react';
import './style.css';
import { UserContext } from './Context.js';
import Child1 from './Child1';
import Child2 from './Child2';

export default function App() {
  const [counter1, setCounter1] = useState(0);
  const [counter2, setCounter2] = useState(0);
  const IncrementCounter = useCallback(
    () => setCounter1((prevState) => prevState + 1),
    [setCounter1]
  );
  const DecrementCounter = useCallback( …

我知道静态块是在加载类时初始化的,因为类只在程序中加载一次,所以只初始化一次.

每次创建类的实例时都会初始化IIB(实例初始化块),而构造函数则相同:它们在对象创建期间执行.

我不明白为什么在下面的程序IIB中在构造函数之前执行.码-

public class Hello {

    public static void main(String args[]) {
        C obj = new C();
    }
}

class A {

    static {
        System.out.println("Inside static block of A");
    }

    {
        System.out.println("Inside IIB of A");
    }

    A() {
        System.out.println("Inside NO-ARGS constructor of A");
    }
}

class B extends A {

    static {
        System.out.println("Inside static block of B");
    }

    {
        System.out.println("Inside IIB of B");
    }

    B() {
        System.out.println("Inside NO-ARGS constructor of B");
    }
}

class C extends B {

    static …

我正在阅读完整参考文献中的集合,然后我遇到了这个陈述

收集界面

Collection接口是构建Collections Framework的基础,因为它必须由定义集合的任何类实现.Collection是一个具有此声明的通用接口:interface Collection<E>.这里,E指定集合将容纳的对象的类型.Collection扩展了Iterable接口.这意味着所有集合都可以通过使用for-each样式for循环来循环.(回想一下,只有实现Iterable的类可以通过for循环).

在最后两行中,写入只有那些实现Iterable接口的类才能通过for循环循环.但是,我猜对象类没有实现可迭代接口,那么我们如何能够在字符串,整数等情况下使用for-each循环.

我无法理解为什么这段代码没有编译......

public class Room {
    public static void main(String[] args) {
        Double[] ar = {1.1,2.23,3.56,4.23,5.90,6.88,7.99,8.09,9.88,10.99};
        Average<Double> tt = new Average<>(ar);
        tt.summ();
    }
}

class Average<T extends Double> {
    T[] arr;
    T sum;
    Average(T[] num) {
        arr = num;
    }

    void summ() {
        for (T i : arr) {
            sum = sum + i;//Shows incompatible types
            System.out.println(sum);
        }
    }
}

编译器错误说明:

Room.java第18行出错:

类型不匹配:无法从double转换为T.

有人可以解释为什么这段代码没有编译？

我知道如果我们对字节值执行算术运算,那么隐式地将它提升为int并且结果将是int,因此我们需要将其显式转换为byte以便将结果存储在字节变量中.但我想问 -

• 从byte到int的转换是在声明它时发生的还是在我们在算术运算中使用时发生的？因为我使用的java反编译器在声明时将它从byte转换为int.因此,它是反编译器问题还是真的如此.
• 如果它确实发生在声明时,那么为什么存储超出字节范围的值会显示错误？

例如 - 代码是 -

public class Hello
{
    public static void main(String[] args)
    {
        byte a=90;

    }
}

反编译器的输出 -