728. Self Dividing Numbers。

A self-dividing number is a number that is divisible by every digit it contains.

For example, 128 is a self-dividing number because 128 % 1 == 0, 128 % 2 == 0, and 128 % 8 == 0.

Also, a self-dividing number is not allowed to contain the digit zero.

Given a lower and upper number bound, output a list of every possible self dividing number, including the bounds if possible.

Example 1:

Input:
left = 1, right = 22
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]

原文:https://leetcode.com/problems/self-dividing-numbers/description/


依题所示,如果一个数字可以整除它所有位上的数字,那么就称为self-dividing number,我们需要设计一个算法来求出指定范围内满足的所有数字。


题目并不难,只需要不断使用当前数字除以不同位上的数字即可,但是需要注意的是self-dividing number中不含有0的,像10这种的肯定不行了,因为number中一旦包含0就无法让number本身除以0这一位了。

那么问题就转换成如果判断数字中是否含0,对于像10、20、100、300 这种的可以直接让其本身对10取模,观察余数是否为0即可,像101、203这种的,让其除以10,然后再取模运算判断。

那么很快便能写出如下解:

class Solution {
public:
    vector<int> selfDividingNumbers(int left, int right) {
        int temp = left;
        vector<int> result;
        for(int num=left;num<=right;num++) {// 在指定范围内循环
            temp = num;
            if(!(temp%10)) { // 判断是否属于10、20、300类型
                continue;
            }
            while(temp && num%(temp%10) == 0) {// 如果当前位数满足条件就继续试探下一位
                temp /= 10;
                if(temp%10==0){ // 判断是否属于101、203这种的
                    break;
                }
            }
            if(temp == 0) {
                result.push_back(num);
            }
        }
        return result;
    }
};

这种是可以AC的,但是可以看到其中有不少冗余的代码,那么就需要优化一下减少冗余的代码。可以看出其中temp%10的取模运算重复了,那就可以使用一个mod变量直接保存。而100和101这种类型的可以统一放在一起判断。

代码如下:

class Solution {
public:
    vector<int> selfDividingNumbers(int left, int right) {
        int temp = left;
        int mod;
        vector<int> result;
        for(int num=left;num<=right;num++) {// 在指定范围内循环
            temp = num;

            while(temp) {
                mod = temp%10; // 求出此时的余数
                if(mod==0 || num%mod!=0)// 如果此时余数等于0说明是10的倍数则退出,如果此时不满足条件也退出
                    break;
                temp /= 10;
            }

            if(temp == 0) {
                result.push_back(num);
            }
        }
        return result;
    }
};
### Linear Complexity Self-Attention Implementation and Optimization Self-attention mechanisms have been pivotal in advancing the capabilities of deep learning models, especially within natural language processing tasks. Traditional self-attention has a quadratic time complexity relative to input length due to its computation involving all pairs of positions in an input sequence[^1]. However, linear complexity self-attention aims at reducing this computational burden. #### Efficient Implementations One approach towards achieving linear complexity involves approximating or restructuring how attentions scores are computed between tokens. For instance, instead of computing full pairwise interactions, one could use locality-sensitive hashing (LSH), which groups similar items into buckets without explicitly comparing every item against each other. This method significantly reduces the number of required comparisons while maintaining performance quality[^3]. Another technique utilizes random projections where high-dimensional vectors representing token embeddings get projected onto lower dimensions through structured matrices like Fastfood transforms. Such transformations preserve distances well enough so that subsequent operations remain effective yet require fewer resources than standard methods do[^4]. ```python import torch from performer_pytorch import PerformerLM model = PerformerLM( num_tokens=20000, dim=512, depth=6, heads=8, causal=True, feature_redraw_interval=1000, generalized_attention=True, kernel_fn='relu' ) text = "The quick brown fox jumps over the lazy dog" tokens = tokenizer.encode(text).ids # assuming you've defined `tokenizer` elsewhere input_tensor = torch.tensor([tokens]) output = model(input_tensor) print(output.shape) # should output something like torch.Size([1, seq_len, vocab_size]) ``` This code snippet demonstrates implementing efficient self-attention via the Performer architecture from PyTorch library, leveraging fast Fourier transform-based kernels for reduced complexity computations during training phases. #### Optimizations Techniques Optimizing these implementations often revolves around exploiting hardware acceleration features such as GPU tensor cores optimized specifically for matrix multiplications involved in attention calculations. Additionally, mixed precision arithmetic can further enhance speed by performing some parts of forward/backward passes using half-precision floating-point numbers when possible without sacrificing much accuracy. Memory efficiency gains come not only from algorithmic improvements but also architectural choices like chunked processing schemes dividing long sequences into smaller manageable chunks processed independently before being recombined later on. These strategies help mitigate memory overhead associated with large-scale transformer architectures operating under constrained environments[^2]. --related questions-- 1. How does Locality-Sensitive Hashing contribute to making self-attention computationally feasible? 2. What role do random projections play in optimizing self-attention algorithms? 3. Can you explain how specific hardware optimizations impact the performance of linear-complexity self-attention models? 4. In what ways might chunked processing improve both runtime and resource utilization compared to traditional approaches?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值