在这篇文章中，我们将为您详细介绍为什么Javaswitchoncontiguousints似乎在添加案例时运行得更快？的内容，并且讨论关于switch例子java的相关问题。此外，我们还会涉及一些关于

在这篇文章中，我们将为您详细介绍为什么 Java switch on contiguous ints 似乎在添加案例时运行得更快？的内容，并且讨论关于switch例子java的相关问题。此外，我们还会涉及一些关于.contiguous() 在 PyTorch 中做了什么？、19.1.2 Switch Virtual Interface Configuration、525. Contiguous Array、994.Contiguous Array 邻近数组的知识，以帮助您更全面地了解这个主题。

• 为什么 Java switch on contiguous ints 似乎在添加案例时运行得更快？（switch例子java）
• .contiguous() 在 PyTorch 中做了什么？
• 19.1.2 Switch Virtual Interface Configuration
• 525. Contiguous Array
• 994.Contiguous Array 邻近数组

为什么 Java switch on contiguous ints 似乎在添加案例时运行得更快？（switch例子java）

double multiplyByPowerOfTen(final double d,final int exponent) {
   switch (exponent) {
      case 0:
         return d;
      case 1:
         return d*10;
      case 2:
         return d*100;
      // ... same pattern
      case 9:
         return d*1000000000;
      case 10:
         return d*10000000000L;
      // ... same pattern with long literals
      case 18:
         return d*1000000000000000000L;
      default:
         throw new ParseException("Unhandled power of ten " + power,0);
   }
}

.contiguous() 在 PyTorch 中做了什么？

x.contiguous()张量有什么作用x？

答案1

PyTorch 中有一些对张量的操作不会改变张量的内容，但会改变数据的组织方式。这些操作包括：

narrow(), view(),expand()和transpose()

例如： 当您调用 时transpose()，PyTorch
不会生成具有新布局的新张量，它只是修改张量对象中的元信息，以便偏移量和步幅描述所需的新形状。在这个例子中，转置张量和原始张量共享相同的内存：

x = torch.randn(3,2)y = torch.transpose(x, 0, 1)x[0, 0] = 42print(y[0,0])# prints 42

这就是 连续 的概念出现的地方。在上面的例子中，x是连续的，但y不是因为它的内存布局与从头开始制作的相同形状的张量的内存布局不同。请注意，
“连续” 这个词有点误导，因为张量的内容并不是散布在不连贯的内存块周围。这里字节仍然分配在一块内存中，但元素的顺序不同！

当您调用 时contiguous()，它实际上会复制张量，使其元素在内存中的顺序与使用相同数据从头开始创建的顺序相同。

通常你不需要担心这个。您通常可以安全地假设一切都会正常工作，并等到您得到RuntimeError: input is notcontiguousPyTorch 期望连续张量添加对contiguous().

19.1.2 Switch Virtual Interface Configuration

To access the switch remotely, an IP address and a subnet mask must be configured on the switch virtual interface (SVI). To configure an SVI on a switch, use the interface vlan 1 global configuration command. Vlan 1 is not an actual physical interface but a virtual one. Next, assign an IPv4 address using the ip address ip-address subnet-mask interface configuration command. Finally, enable the virtual interface using the no shutdown interface configuration command.

After the switch is configured with these commands, the switch has all the IPv4 elements ready for communication over the network.

Note: Similar to Windows hosts, switches configured with an IPv4 address will typically also need to have a default gateway assigned. This can be done using the ip default-gateway ip-address global configuration command. The ip-address parameter would be the IPv4 address of the local router on the network, as shown in the example. However, in this topic you will only be configuring a network with switches and hosts. Routers will be configured later.

525. Contiguous Array

Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.

Example 1:

Input: [0,1]
Output: 2
Explanation: [0, 1] is the longest contiguous subarray with equal number of 0 and 1.

Example 2:

Input: [0,1,0]
Output: 2
Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.

Note: The length of the given binary array will not exceed 50,000.

public class Solution {
    public int findMaxLength(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        for(int i=0; i<nums.length; i++){
            if(nums[i] == 0){
                nums[i] = -1; //先把所有的0变成-1，这样就是求sum为0的最大区间
            }
        }
        int sum = 0, max = 0;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(0, -1);
        for(int i=0; i<nums.length; i++){
            sum += nums[i];
            if(!map.containsKey(sum)){
                map.put(sum, i);
            }else{
                max = Math.max(max, i-map.get(sum));
            }
        }
        return max;
    }
}

994.Contiguous Array 邻近数组

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int res = 0,n = nums.size(),sum = 0;
        unordered_map<int,int> m{{0,-1}};
        for (int i = 0; i < n; ++i) {
            sum += (nums[i] == 1) ? 1 : -1;
            if (m.count(sum)) {
                res = max(res,i - m[sum]);
            } else {
                m[sum] = i;
            }
        }
        return res;
    }
};

关于为什么 Java switch on contiguous ints 似乎在添加案例时运行得更快？和switch例子java的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于.contiguous() 在 PyTorch 中做了什么？、19.1.2 Switch Virtual Interface Configuration、525. Contiguous Array、994.Contiguous Array 邻近数组的相关知识，请在本站寻找。