全部问题(coding)

在我的 Android 应用中，我从 Room 获取数据并将其显示在地图上。我遇到了这两种获取数据的视图模型方法。

哪一个是更有效且更好的方法？

目前，我正在使用第二种方法获取数据。它工作正常。只是想知道这两者之间有什么区别。

第一种方法：

private val _visibleRegion = MutableStateFlow(defaultVisibleRegion)
private val _zoomLevel = MutableStateFlow(6f)
private val _isFavorite = MutableStateFlow(false)

val mapData: StateFlow<PagingData<MapData>> = combine(
    _visibleRegion,
    _zoomLevel,
    _isFavorite
) { region, zoom, isFav ->
    Triple(region, zoom, isFav)
}.flatMapLatest { (region, zoom, isFav) ->
    repo.getDataInBoundsPaged(
        region.southwest.latitude,
        region.northeast.latitude,
        region.southwest.longitude,
        region.northeast.longitude,
        zoom = zoom,
        isFav = isFav
    )
}.stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5000),
    initialValue = PagingData.empty()
)

fun updateVisibleRegion(region: LatLngBounds) {
    _visibleRegion.value = region
}

fun updateZoomLevel(zoom: Float) {
    _zoomLevel.value = zoom
}

fun toggleFavorite(isFavorite: Boolean) {
    _isFavorite.value = isFavorite
}

vs 第二种方法：

private val _mapData = MutableStateFlow<PagingData<MapData>>(PagingData.empty())
val mapData: StateFlow<PagingData<MapData>> = _mapData.asStateFlow()

private val defaultVisibleRegion = LatLngBounds(
    LatLng(6.792525080049721, 70.06730787456036),
    LatLng(37.411989227903604, 86.94231156259775)
)

init {
    fetchMapData()
}

fun fetchMapData(
    visibleRegion: LatLngBounds = defaultVisibleRegion,
    zoomLevel: Float = 6f,
    isFavorite: Boolean = false
) {
    viewModelScope.launch {
      
        repo.getDataInBoundsPaged(
            visibleRegion.southwest.latitude,
            visibleRegion.northeast.latitude,
            visibleRegion.southwest.longitude,
            visibleRegion.northeast.longitude,
            zoom = zoomLevel,
            isFav = isFavorite
        )
          
            .cachedIn(viewModelScope)
            .collect {
                _mapData.value = it
             
            }
    }
}

我正在编写一个函数，当输入为假时，该函数返回 undefined。在 TypeScript 5.6.2 中，我无法让以下示例通过类型检查器：

// Return type: number | "" | undefined
const f1 = (s: string, n: number) => (s || undefined) && n;

// Type 'number | "" | undefined' is not assignable to type 'number | undefined'.
//   Type 'string' is not assignable to type 'number'.(2322)
const x: number | undefined = f1("a", 1);

操场

推断的返回类型表明f1可能返回空字符串。这很烦人，因为我需要处理不可能的字符串返回类型。我认为返回类型应该是number | undefined。

当字符串和数字交换时也会发生同样的事情：

// Return type: string | 0 | undefined
const f2 = (s: string, n: number) => (n || undefined) && s;

当我使用三元运算符或强制转换为布尔值时，返回类型被正确推断：

// Return type: number | undefined
const f3 = (s: string, n: number) => (s ? true : undefined) && n;

// Return type: number | undefined
const f4 = (s: string, n: number) => (!!s || undefined) && n;

我std::unordered_set第一次使用自定义类型，我不知道我缺少什么来编译contains()我的集合。

我基本上有一个看起来像这样的课程：

class MyClass
{
// Ctor/Dtor
public:
    MyClass(const std::string& name /* + other params in my real use case */) : m_name(name) {}
    ~MyClass() = default;

// Members
private:
    std::string m_name;

// Operators
public:
    // Equal operators
    bool operator==(const MyClass &other) const
    {
        return m_name == other.m_name;
    }

    bool operator==(const std::string& other) const
    {
        return m_name == other;
    }

    bool operator==(const char* other) const
    {
        return m_name == other;
    }

// Functors
public:
    // Hash functor
    struct Hash
    {
        std::size_t operator()(const MyClass &class_) const
        {
            return std::hash<std::string>()(class_.m_name);
        }

        std::size_t operator()(const std::string &name) const
        {
            return std::hash<std::string>()(name);
        }

        std::size_t operator()(const char* name) const 
        {
            return std::hash<std::string>()(name);
        }
    };

    // Equal functor
    struct Equal
    {
        bool operator()(const MyClass &lhs, const MyClass &rhs) const
        {
            return lhs.m_name == rhs.m_name;
        }

        bool operator()(const MyClass &lhs, const std::string &rhs) const
        {
            return lhs.m_name == rhs;
        }

        bool operator()(const std::string &lhs, const MyClass &rhs) const
        {
            return lhs == rhs.m_name;
        }

        bool operator()(const MyClass &lhs, const char* rhs) const
        {
            return lhs.m_name == rhs;
        }

        bool operator()(const char* lhs, const MyClass &rhs) const
        {
            return lhs == rhs.m_name;
        }
    };

};

使用此类，我想创建一个std::unordered_set并检查名称为的元素是否key1存在。为此，我想使用以下代码：

int main()
{
    // I tried both, but none of them seem to work
    std::unordered_set<MyClass, MyClass::Hash, MyClass::Equal> set;
    // std::unordered_set<MyClass, MyClass::Hash> set;

    // Add sample elements to the set
    set.emplace("key1");
    set.emplace("key2");

    // Check if the set contains "key1"
    if (set.contains("key1")) // Compile error on this line. Why does this not work?
    {
        std::wcout << L"set contains key1." << std::endl;
    } else {
        std::wcout << L"set doesn't contain key1." << std::endl;
    }

    return 0;
}

但是我在调​​用时不断收到编译器错误contains()：

错误：没有匹配的函数来调用‘std::unordered_set<MyClass, MyClass::Hash, MyClass::Equal>::contains(const char [5])’[...]

我不知道为什么，也找不到任何有关它的资源。

我想我遗漏了一些东西，因为下面的代码使用起来没有问题std::string：

int main()
{
    std::unordered_set<std::string> set;
   
    // Add sample elements to the set
    set.emplace("key1");
    set.emplace("key2");

    // Check if the set contains "key1"
    if (set.contains("key1")) // Why does this not work?
    {
        std::wcout << L"set contains key1." << std::endl;
    } else {
        std::wcout << L"set doesn't contain key1." << std::endl;
    }

    return 0;
}

我有一个文件夹，其中包含以下名称的 .txt 文件：

A_COR_001_I
A_COR_001_II
A_COR_002_I
A_COR_002_II
A_COR_003_I
A_COR_003_II
A_COR_003_III
A_COR_004_I
A_COR_004_II
A_COR_004_III
A_COR_004_IV
...

每个字符串末尾的罗马数字表示特定文档的最终草稿，由前面的阿拉伯数字标识，如 002。我正在尝试使用 list.files() 函数仅提取具有正则表达式模式的最终草稿，但问题是每个文档的草稿数量不可预测，所以我需要一种方法将每个文档的草稿分组在一起并挑选出编号最高的草稿，因此是 A_COR_004_IV 而不是 A_COR_004_III 或任何其他。关于如何继续有什么想法吗？提前致谢！

我正在使用 Oracle APEX，并且有一个 SQL 过程，可以为客户进行预订，然后向该客户添加所需数量的表。

我面临的问题是，当我提交表单并启动程序时，没有成功消息，因此用户无法查看他们的预订是否成功。我不能在按下提交按钮后使用重定向，因为如果程序失败，它不会显示我的应用程序错误。

如您所见，我尝试实施解决方案来显示成功消息，但不起作用。请参阅IF我代码中的最后一条语句，了解我试图实现的目标。

create or replace PROCEDURE AssignTable2(
  p_KlantNaam VARCHAR2,
  p_KlantEmail VARCHAR2,
  p_KlantTelefoon NUMBER,
  p_ReservatieDatum DATE,
  p_BeginTijd TIMESTAMP,
  p_EindTijd TIMESTAMP,
  p_NumKlanten NUMBER
) AS
  v_RequiredTafels NUMBER;
  v_AssignedTafels NUMBER := 0;
  v_AvailableTafels NUMBER;
  v_TafelID NUMBER;
  v_ReservatieID NUMBER;
  v_KlantID NUMBER;
BEGIN
  v_RequiredTafels := CEIL(p_NumKlanten / 4.0);
  DBMS_OUTPUT.PUT_LINE('After selecting table: v_RequiredTafels = ' || TO_CHAR(v_RequiredTafels));
  -- Check for available tables
  -- Check for available tables
SELECT COUNT(t.id) INTO v_AvailableTafels
FROM TAFEL t
WHERE t.id NOT IN (
  SELECT rt.FK_TAFELID
  FROM RESERVATIE r
  INNER JOIN RESERVATIETAFEL rt ON r.id = rt.FK_RESERVATIEID
  WHERE r.datum = p_ReservatieDatum and t.FK_STATUS = 1
    AND (
      -- Check for overlap with existing reservations
      (p_BeginTijd < r.eind_tijd + INTERVAL '1' HOUR AND p_BeginTijd >= r.begin_tijd) 
      OR (p_EindTijd > r.begin_tijd AND p_EindTijd <= r.eind_tijd) 
      OR (r.begin_tijd >= p_BeginTijd AND r.eind_tijd <= p_EindTijd)
      -- Check for overlap with existing reservations that start before the new time slot
      OR (r.begin_tijd < p_BeginTijd AND r.eind_tijd > p_BeginTijd)
      -- Check for overlap with existing reservations that end after the new time slot
      OR (r.begin_tijd < p_EindTijd AND r.eind_tijd > p_EindTijd)
    )

);
  DBMS_OUTPUT.PUT_LINE('After selecting table: v_AvailableTafels = ' || TO_CHAR(v_AvailableTafels));
  DBMS_OUTPUT.PUT_LINE('Time slot: ' || TO_CHAR(p_BeginTijd) || ' - ' || TO_CHAR(p_EindTijd));
  IF v_AvailableTafels < v_RequiredTafels THEN
    RAISE_APPLICATION_ERROR(-20001, 'Sorry maar er zijn niet genoeg tafels op het gekozen moment met uw aantal gasten, probeer een andere tijdstip');
  ELSE
    IF p_KlantNaam IS NOT NULL THEN
      INSERT INTO EX_KLANT (naam, email, telefoon)
      VALUES (p_KlantNaam, p_KlantEmail, p_KlantTelefoon)
      RETURNING id INTO v_KlantID;
    ELSE
      RAISE_APPLICATION_ERROR(-20002, 'KlantNaam mag niet leeg zijn');
    END IF;
    IF p_ReservatieDatum IS NOT NULL THEN
     if p_ReservatieDatum > TRUNC(SYSDATE) THEN
 -- Insert a new reservation
    INSERT INTO RESERVATIE (FK_EX_KLANTID, num_klanten, datum, begin_tijd, eind_tijd)
    VALUES (v_KlantID, p_NumKlanten, p_ReservatieDatum, p_BeginTijd, p_EindTijd)
    RETURNING id INTO v_ReservatieID;
      ELSE 
 RAISE_APPLICATION_ERROR(-20004, 'Reservatiedatum mag niet de dag voor vandaag zijn');
    END IF;
    ELSE
   RAISE_APPLICATION_ERROR(-20003, 'Reservatie datum mag niet leeg zijn');
    END IF;
    -- Loop until we have assigned enough tables
WHILE v_AssignedTafels < v_RequiredTafels LOOP
    SELECT t.id INTO v_TafelID
    FROM (
      SELECT t.id, t.code
      FROM TAFEL t
      LEFT JOIN RESERVATIETAFEL rt ON t.id = rt.FK_TAFELID
      LEFT JOIN RESERVATIE r ON rt.FK_RESERVATIEID = r.id
      WHERE  t.FK_STATUS = 1 AND (r.id IS NULL OR r.datum <> p_ReservatieDatum OR r.eind_tijd < p_BeginTijd OR r.begin_tijd > p_EindTijd)
      AND NOT EXISTS (
        SELECT 1
        FROM RESERVATIETAFEL rt
        WHERE rt.FK_TAFELID = t.id
        AND rt.FK_RESERVATIEID IN (
          SELECT r.id
          FROM RESERVATIE r
          WHERE (r.datum = p_ReservatieDatum)
          AND (r.begin_tijd <= p_EindTijd)
          AND (r.eind_tijd >= p_BeginTijd)
        )
      )
      ORDER BY t.code
    ) t
    WHERE ROWNUM = 1;
    -- Insert into RESERVATIETAFEL table
    INSERT INTO RESERVATIETAFEL (FK_RESERVATIEID, FK_TAFELID)
    VALUES (v_ReservatieID, v_TafelID);
    v_AssignedTafels := v_AssignedTafels + 1;
END LOOP;
END IF;
IF v_AssignedTafels = v_RequiredTafels THEN
    --  RAISE_APPLICATION_ERROR(-20005, 'procedure succesfull!');
    APEX_APPLICATION.G_NOTIFICATION := 'Procedure successful! All ' || v_RequiredTafels || ' tafels have been assigned.';
END IF;
 END;

我可以像处理其他错误一样使用应用程序错误，但感觉不对，因为它看起来像是一条错误消息，而不是一条成功消息。

有没有办法仅在程序成功时重定向页面？我认为仅使用 SQL 是不可能做到这一点的。

在C++14中（因此没有约束require或折叠表达式，但有 SFINAE）是否有可能对类模板进行部分模板特化

template <typename ...T>
class Generic {
    using Container = std::tuple<T...>;
};

对于每个模板参数都是相同类型的情况下？我需要这个，因为通用版本将使用std::tuple容器，而专业化将使用std::array（而不是 std::vector，因为代码将在嵌入式环境中运行，所以我想避免堆分配）。

例如Generic<int,float,char>::Container应该是std::tuple<int,float,char>，而Generic<int,int,int>::Container应该是std::array<int,3>。

我已经很久没有用 Perl 编写任何代码了。现在我又开始编写代码了，在单个“.pm”文件中编写两个包时遇到了一个有趣的情况。到目前为止，我认为如果我在一个文件中定义两个包（例如 ConfigData 和 RuntimeData），我可以为每个包定义一个具有相同名称（例如 my $instance）的变量（用“my”声明），而不会发生冲突。作为示例，下面是一段最简洁的代码来说明这一点：

package Jabs::ConfigData;
use strict;
use warnings;

my $instance;
sub new {
        my ($class) = @_;
        unless (defined $instance) {
                $instance = bless {}, $class;
        }
        return $instance;
}
1;  # End of 'ConfigData'

package Jabs::RuntimeData;
use strict;
use warnings;

my $instance;
sub new {
        my ($class) = @_;
        unless (defined $instance) {
                $instance = bless {}, $class;
        }
        return $instance;
}
1;  # End of 'RuntimeData'

我调用了 perl -c test2.pm 并收到以下消息作为反馈：

"my" variable $instance masks earlier declaration in same scope at test2.pm line 27.
test2.pm syntax OK

现在我不清楚为什么范围应该相同。因为'我的 $instance 是在两个不同的包中定义的。我使用的是 Ubuntu 24.04 LTS 和 Perl5（修订版 5 版本 38 颠覆版 2）

有人能为我解释一下我的理解问题吗？

我有这个假设的数据框

  df <- data.frame(K=c(NA, NA, 3, 4,0,2,NA, NA), A=c(NA, NA, NA, 4,0,3,NA, NA), B=c(NA, 2, NA, NA,0,NA,NA,0), C=c(0, 3, 5, NA,0,5,NA,5), D=c(NA, 3, 1, 2,0,10,NA,3))
     df  
       K  A  B  C  D
    1 NA NA NA  0 NA
    2 NA NA  2  3  3
    3  3 NA NA  5  1
    4  4  4 NA NA  2
    5  0  0  0  0  0
    6  2  3 NA  5 10
    7 NA NA NA NA NA
    8 NA NA  0  5  3

我想按行查找第一个数值之前有多少个 NA（在该行中），并且我想将此信息添加为上述数据框中的最后一列

所以我想

df2 <- data.frame(K=c(NA, NA, 3, 4,0,2,NA, NA), A=c(NA, NA, NA, 4,0,3,NA, NA), B=c(NA, 2, NA, NA,0,NA,NA,0), C=c(0, 3, 5, NA,0,5,NA,5), D=c(NA, 3, 1, 2,0,10,NA,3),
        nn=c(3,2,0,0,0,0,5,2))
    df2
     
   K  A  B  C  D nn
1 NA NA NA  0 NA  3
2 NA NA  2  3  3  2
3  3 NA NA  5  1  0
4  4  4 NA NA  2  0
5  0  0  0  0  0  0
6  2  3 NA  5 10  0
7 NA NA NA NA NA  1000
8 NA NA  0  5  3  2

例如，第一行在第一个值 0 之前包含 3 个 NA。第二行在第一个值 2 之前包含 2 个 NA。第三行在第一个值 3 之前包含零个 NA，第 4-6 行也是如此。对于第七行，我们只有 NA，因此在这种情况下我只使用任意值 1000。对于第八行，在第一个值 0 之前有两个 NA。

我试过这个

DD<-apply(df,1,function(x) which(!is.na(x)))
unlist(map(DD, 1) , use.names=FALSE)-1

但它不起作用，因为我得到

3 2 0 0 0 0 2

我错过了仅包含 NA 的行。有什么想法吗？是否可以使用 dplyr 来实现这一点？

请注意，我的真实数据集包含 500 列和 200000 行。因此，更通用的代码会很有帮助。

当所有值都代表原始字节时，为什么Blob()传递 Array 和 Uint8Array 会产生不同的结果？

new Blob([[0,60,0,60]])
// Blob {size: 9, type: ''}

new Blob([new Uint8Array([0,60,0,60])])
// Blob {size: 4, type: ''}

我是CuPyCUDA/GPU 计算的新手。有人能解释一下为什么(x / y)[i]比 更快吗x[i] / y[i]？

当利用 GPU 加速计算时，是否有任何指导原则可以让我快速确定哪个操作更快？从而避免对每个操作进行基准测试。

# In VSCode Jupyter Notebook

import cupy as cp
from cupyx.profiler import benchmark

x = cp.arange(1_000_000)
y = (cp.arange(1_000_000) + 1) / 2
i = cp.random.randint(2, size=1_000_000) == 0
x, y, i

# Output:
(array([     0,      1,      2, ..., 999997, 999998, 999999], shape=(1000000,), dtype=int32),
 array([5.000000e-01, 1.000000e+00, 1.500000e+00, ..., 4.999990e+05,
        4.999995e+05, 5.000000e+05], shape=(1000000,), dtype=float64),
 array([ True, False,  True, ...,  True, False,  True], shape=(1000000,), dtype=bool))

def test1(x, y, i):
    return (x / y)[i]

def test2(x, y, i):
    return x[i] / y[i]

print(benchmark(test1, (x, y, i)))
print(benchmark(test2, (x, y, i)))

# Output:
test1: CPU: 175.164 us +/- 61.250 (min: 125.200 / max: 765.100) us  GPU-0: 186.001 us +/- 67.314 (min: 134.144 / max: 837.568) us
test2: CPU: 342.364 us +/- 130.840 (min: 223.000 / max: 1277.600) us  GPU-0: 368.133 us +/- 136.911 (min: 225.504 / max: 1297.408) us