想了解iOS可以为UIImage写子类吗？的新动态吗？本文将为您提供详细的信息，此外，我们还将为您介绍关于2023-07-18：给你一个正整数数组nums，请你移除最短子数组（可以为空），使得剩余元素

想了解iOS 可以为 UIImage 写子类吗？的新动态吗？本文将为您提供详细的信息，此外，我们还将为您介绍关于2023-07-18：给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空）， 使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。 请你返回你需要移除的最短子数组的长度，如果、Android L 可以为 Nexus 5 省电 36%、BuildContext 可以为 StatefulWidget 更改吗？、C#2.0增功能04 可以为 null 的类型的新知识。

本文目录一览：

• iOS 可以为 UIImage 写子类吗？
• 2023-07-18：给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空）， 使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。 请你返回你需要移除的最短子数组的长度，如果
• Android L 可以为 Nexus 5 省电 36%
• BuildContext 可以为 StatefulWidget 更改吗？
• C#2.0增功能04 可以为 null 的类型

iOS 可以为 UIImage 写子类吗？

iOS 可以为 UIImage 写子类吗？

2023-07-18：给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空）， 使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。 请你返回你需要移除的最短子数组的长度，如果

2023-07-18：给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空），

使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。

请你返回你需要移除的最短子数组的长度，如果无法满足题目要求，返回 -1 。

子数组 定义为原数组中连续的一组元素。

输入：nums = [3,1,4,2], p = 6。

输出：1。

答案 2023-07-18：

大体过程如下：

1. 计算整个数组的和对 p 取余，得到 allMod。

2. 初始化一个空的映射 m，并将映射中键为 0，值为 - 1。该映射用于记录前缀和的某个余数最晚出现的位置。

3. 初始化一个变量 ans，表示最短子数组的长度，初值为无穷大。

4. 初始化一个变量 curMod，表示当前的前缀和余数，初值为 0。

5. 初始化一个变量 find，表示要查找的余数，初值为 0。

6. 遍历数组 nums 中的每个元素：

• 将当前元素加到 curMod 中，并对 p 取余，得到当前前缀和的余数 curMod。

• 计算要查找的余数 find = (curMod - allMod + p) % p。

• 在映射 m 中查找余数为 find 的键，如果存在则计算当前位置与查找到的位置之差，并更新 ans 为较小的值。

• 更新映射 m，将当前余数 curMod 存储到映射中。

7. 如果 ans 没有被更新，则返回 - 1，否则返回 ans。

代码的时间复杂度为 O (n)，其中 n 是数组 nums 的长度。这是因为在遍历数组 nums 的过程中，需要进行常数时间的操作，包括计算前缀和的余数、更新映射 m 等。

代码的空间复杂度为 O (n)，其中 n 是数组 nums 的长度。这是因为需要使用一个映射 m 来记录前缀和的余数及其最晚出现的位置，映射 m 的大小不会超过数组的长度 n。此外，还需要用几个额外的变量来存储一些中间结果，这些变量的空间占用也是常数级别的，不会随着输入规模 n 的增大而增加。

go 完整代码如下：

package main

import (
	"fmt"
)

func minSubarray(nums []int, p int) int {
	n := len(nums)
	// 求出整体的余数
	allMod := 0
	for _, num := range nums {
		allMod = (allMod + num) % p
	}
	if allMod == 0 {
		return 0
	}
	// 记录前缀和的某个余数，最晚出现的位置
	// 看课！然后看接下来的代码
	m := make(map[int]int)
	m[0] = -1
	ans := 1<<31 - 1
	curMod := 0
	var find int
	for i := 0; i < n; i++ {
		// 0...i 累加和的余数
		curMod = (curMod + nums[i]) % p
		// 如果p = 7，整体余数2，当前余数5，那么找之前的部分余数是3
		// 如果p = 7，整体余数2，当前余数1，那么找之前的部分余数是6
		// 整体变成下面的公式，可以自己带入各种情况验证
		find = (curMod - allMod + p) % p
		val, ok := m[find]
		if ok {
			if i != n-1 || val != -1 {
				// 防止删掉整体！
				// ...i(n-1)
				ans = min(ans, i-val)
			}
		}
		m[curMod] = i
	}
	if ans == 1<<31-1 {
		return -1
	}
	return ans
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func main() {
	nums := []int{3, 1, 4, 2}
	p := 6
	result := minSubarray(nums, p)
	fmt.Println(result)
}

rust 代码如下：

use std::collections::HashMap;

fn min_subarray(nums: Vec<i32>, p: i32) -> i32 {
    let n = nums.len();
    
    // 求出整体的余数
    let all_mod: i32 = nums.iter().sum::<i32>() % p;
    if all_mod == 0 {
        return 0;
    }
    
    // 记录前缀和的某个余数，最晚出现的位置
    let mut map: HashMap<i32, i32> = HashMap::new();
    map.insert(0, -1);
    
    let mut ans = i32::max_value();
    let mut cur_mod = 0;
    let mut find;
    
    for i in 0..n {
        // 0...i 累加和的余数
        cur_mod = (cur_mod + nums[i]) % p;
        
        // 如果p = 7，整体余数2，当前余数5，那么找之前的部分余数是3
        // 如果p = 7，整体余数2，当前余数1，那么找之前的部分余数是6
        // 整体变成下面的公式，可以自己带入各种情况验证
        find = (cur_mod - all_mod + p) % p;
        
        if map.contains_key(&find) {
            if i != n - 1 || map[&find] != -1 {
                // 防止删掉整体！
                // ...i(n-1)
                ans = ans.min(i as i32 - map[&find]);
            }
        }
        
        map.insert(cur_mod, i as i32);
    }
    
    return if ans == i32::max_value() { -1 } else { ans };
}

fn main() {
    let nums = vec![3, 1, 4, 2];
    let p = 6;
    let result = min_subarray(nums, p);
    println!("{}", result);
}

c++ 完整代码如下：

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

int minSubarray(vector<int>& nums, int p) {
    int n = nums.size();
    // 求出整体的余数
    int allMod = 0;
    for (int num : nums) {
        allMod = (allMod + num) % p;
    }
    if (allMod == 0) {
        return 0;
    }
    // 记录前缀和的某个余数，最晚出现的位置
    // 看课！然后看接下来的代码
    unordered_map<int, int> map;
    map[0] = -1;
    int ans = INT_MAX;
    int curMod = 0, find;
    for (int i = 0; i < n; i++) {
        // 0...i 累加和的余数
        curMod = (curMod + nums[i]) % p;
        // 如果p = 7，整体余数2，当前余数5，那么找之前的部分余数是3
        // 如果p = 7，整体余数2，当前余数1，那么找之前的部分余数是6
        // 整体变成下面的公式，可以自己带入各种情况验证
        find = (curMod - allMod + p) % p;
        if (map.find(find) != map.end()) {
            if (i != n - 1 || map[find] != -1) {
                // 防止删掉整体！
                // ...i(n-1)
                ans = min(ans, i - map[find]);
            }
        }
        map[curMod] = i;
    }
    return (ans == INT_MAX) ? -1 : ans;
}

int main() {
    vector<int> nums = { 3, 1, 4, 2 };
    int p = 6;
    int result = minSubarray(nums, p);
    cout << "Result: " << result << endl;
    return 0;
}

c 完整代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int minSubarray(int* nums, int numsSize, int p) {
    int n = numsSize;
    // 求出整体的余数
    int allMod = 0;
    for (int i = 0; i < n; i++) {
        allMod = (allMod + nums[i]) % p;
    }
    if (allMod == 0) {
        return 0;
    }
    // 记录前缀和的某个余数，最晚出现的位置
    // 看课！然后看接下来的代码
    int* map = (int*)malloc(sizeof(int) * p);
    for (int i = 0; i < p; i++) {
        map[i] = -1;
    }
    map[0] = -1;
    int ans = INT_MAX;
    int curMod = 0, find;
    for (int i = 0; i < n; i++) {
        // 0...i 累加和的余数
        curMod = (curMod + nums[i]) % p;
        // 如果p = 7，整体余数2，当前余数5，那么找之前的部分余数是3
        // 如果p = 7，整体余数2，当前余数1，那么找之前的部分余数是6
        // 整体变成下面的公式，可以自己带入各种情况验证
        find = (curMod - allMod + p) % p;
        if (map[find] != -1) {
            if (i != n - 1 || map[find] != -1) {
                // 防止删掉整体！
                // ...i(n-1)
                ans = (ans < i - map[find]) ? ans : i - map[find];
            }
        }
        map[curMod] = i;
    }
    free(map);
    return (ans == INT_MAX) ? -1 : ans;
}

int main() {
    int nums[] = { 3, 1, 4, 2 };
    int p = 6;
    int numsSize = sizeof(nums) / sizeof(nums[0]);
    int result = minSubarray(nums, numsSize, p);
    printf("Result: %d\n", result);
    return 0;
}

Android L 可以为 Nexus 5 省电 36%

Android L 其中一个关键的特性就是 ''Project Volta'' ，旨在大幅提升 Android 设备的省电能力。那么问题是到底能省多少电呢？

根据 Ars Technica 的测试，答应是确定的。他们在 Nexus 5 上运行 Android L Developer Preview 和 最新版本的 KitKat, 4.4.4 ，运行了 471 分钟。如果不使用 Android L 运行 345 分钟。提升了 36% 的电池续航能力。测试的过程中让手机每隔 15 秒钟通过 WIFI 刷新一个网页，直到手机完全没电。

最省电的部分其实来自于全新的 JobScheduler API，这意味着操作系统现在控制和维护各种任务，一起运行这些任务会让系统的负载变低。此外 Android 现在可更好的处理应用的数据刷新和在无网络情况下的一些功能关闭，这样可以避免应用不断的尝试网络的访问。

Source: Ars Technica | Image via Google

BuildContext 可以为 StatefulWidget 更改吗？

如何解决BuildContext 可以为 StatefulWidget 更改吗？

这样做是否安全：

initState(){
  myController(context: context);
}

然后让 myController 在状态的剩余生命周期中使用该上下文引用？

还是每次都需要同步：

build(context){
 myController.context = context;
}

C#2.0增功能04 可以为 null 的类型

　　可以为 null 的类型是 System.Nullable<T> 结构的实例。 可以为 null 的类型可表示一个基础类型的所有值 T，还可以再表示一个 null 值。 基础类型 T 可以是任何不可为 null 的值类型。 T 不能是引用类型。

例如，可以将 null 或任何整数值（从 Int32.MinValue 到 Int32.MaxValue）赋给 Nullable<int>，并可将 truefalse 或 null 赋给Nullable<bool>。

需要表示基础类型的未定义的值时，请使用可以为 null 的类型。 布尔变量只能有两个值：true 和 false。 没有“未定义”的值。 在许多编程应用程序中，尤其是数据库交互中，变量值可能未定义或缺失。 例如，数据库中的字段可能包含值 true 或 false，但它也可能根本不包含任何值。 这种情况下要使用 Nullable<bool> 类型。

可以为 null 的类型具有以下特征：

• 可以为 null 的类型表示可以向其赋与 null 值的值类型变量。 不能根据引用类型创建可以为 null 的类型 （引用类型已支持 null 值）。

• 语法 T? 是 Nullable<T> 的简写。 这两种形式是可互换的。

• 向可以为 null 的类型赋值的方法与向基础值类型赋值的方法相同：int? x = 10; 或 double? d = 4.108;。 还可赋予 null 值：int? x = null;。

• 使用 Nullable<T>.HasValue 和 Nullable<T>.Value 只读属性可测试是否存在 null 值并检索值，如以下示例所示：if (x.HasValue) y = x.Value;

  • 如果变量包含值，则 HasValue 属性返回 true；如果值为 null，则返回 false。

  • 如果 HasValue 返回 true，则 Value 属性返回值。 否则会引发 InvalidOperationException。

• 还可将 == 和 != 运算符用于可以为 null 的类型，如以下示例所示：if (x != null) y = x.Value; 如果 a 和 b 均为 null，则 a == b 的计算结果为 true。

• 从 C# 7.0 开始，可以使用模式匹配来检查和获取可以为 null 的类型的值：if (x is int valueOfX) y = valueOfX;。

• T? 的默认值是一个实例，其 HasValue 属性返回 false。

• 使用 GetValueOrDefault() 方法可返回赋予的值，如果可以为 null 的类型的值为 null，它还可返回基础值类型的默认值。

• 使用 GetValueOrDefault(T) 方法可返回赋予的值，如果可以为 null 的类型的值为 null，它还可返回提供的默认值。

• 使用 null 合并运算符 ??，基于可以为 null 的类型的值向基础类型赋值：int? x = null; int y = x ?? -1;。 在示例中，由于 x 为 null，所以 y 的结果值为 -1。

• 如果定义了（用户定义的）两种数据类型之间的转换，还可将同一转换用于这些数据类型的可为 null 的版本。

• 不得嵌套可以为 null 的类型。 不会编译下面的一行代码：Nullable<Nullable<int>> n;

有关详细信息，请参阅使用可以为 null 的类型，以及如何：标识可以为 null 的类型主题。

请参阅

• System.Nullable<T>
• System.Nullable
• ??运算符
• C# 编程指南
• C# 指南
• C# 参考
• 可以为 Null 的值类型 (Visual Basic)

 

我们今天的关于iOS 可以为 UIImage 写子类吗？的分享已经告一段落，感谢您的关注，如果您想了解更多关于2023-07-18：给你一个正整数数组 nums，请你移除 最短 子数组（可以为 空）， 使得剩余元素的 和 能被 p 整除。 不允许 将整个数组都移除。 请你返回你需要移除的最短子数组的长度，如果、Android L 可以为 Nexus 5 省电 36%、BuildContext 可以为 StatefulWidget 更改吗？、C#2.0增功能04 可以为 null 的类型的相关信息，请在本站查询。

本文标签：

• iOS
• UIImage
• 子类
• 开发