All perguntas(coding)

Suponha que existam muitas cadeias binárias

x <- c("0100100010101010", "0100110010101010","0111001000","010111")

Estou procurando um método rápido em R para gerar uma matriz contendo a substring comum mais longa em pares (excluindo autocorrespondências) desde o início . Por exemplo, uma solução poderia ser assim

> mySolution(x)
    [,1]     [,2]      [,3]      [,4]
[1,] ""       "01001"   "01"     "010"
[2,] "01001"  ""        "01"     "010"
[3,] "01"     "01"      ""       "01"
[4,] "010"    "010"     "01"     ""

Por exemplo, a matriz na posição [1,2] é a maior substring comum do início de x[1]e x[2]. Note que a matriz resultante é simétrica. Então, precisamos calcular apenas metade dela.

Eu sei que isso poderia funcionar com funções como substr,sub,grepl, mas como tenho muitas strings, estou procurando uma solução muito eficiente que exija pouco tempo de computação. Talvez seja uma opção converter para números binários para melhorar o desempenho?

Considere este código ( godbolt ):

#include <iostream>

template<typename F> void call_by_val(F funct)
   {
    std::cout << "call_by_val(): ";
    funct();
   }

template<typename F> void call_by_ref(F& funct)
   {
    std::cout << "call_by_ref(): ";
    funct();
   }

template<typename F> void call_by_cref(const F& funct)
   {
    std::cout << "call_by_cref(): ";
    funct();
   }


void free_funct()
{
    std::cout << "free_funct()\n";
}


int main()
{
    call_by_val( free_funct );
    call_by_ref( free_funct );
    call_by_cref( free_funct );
}

Todas essas três chamadas funcionam como esperado. No caso de uma função livre, não tenho certeza do que está acontecendo por baixo do tapete, então estou pensando qual é a diferença entre esses três estilos, semanticamente falando. Existe uma razão objetiva para preferir um em vez dos outros?

Tenho uma classe de dados no Jetpack Compose que representa um carro:

data class Car(
    val id: Int = 0,
    val brand: String = "",
    val model: String = "",
    val year: Int = 2020
)

No meu composable, eu atualizo as propriedades de marca e modelo dessa classe de dados com base na entrada do usuário em componentes TextField. Atualmente, estou usando a função copy() toda vez que o usuário digita algo, assim:

@Composable
fun CarScreen() {
    var car by remember { mutableStateOf(Car()) }

    Column {
        TextField(
            value = car.brand,
            onValueChange = { newBrand ->
                car = car.copy(brand = newBrand) // Using `copy()`
            },
            label = { Text("Brand") }
        )

        TextField(
            value = car.model,
            onValueChange = { newModel ->
                car = car.copy(model = newModel) // Using `copy()`
            },
            label = { Text("Model") }
        )
    }
}

Preocupação:

Estou preocupado que chamar copy() em cada alteração de texto pode levar a problemas de desempenho, pois cria uma nova instância do objeto Car toda vez que o usuário digita em um TextField. Isso acontece com cada pressionamento de tecla e, em um aplicativo ou formulário maior com muitos campos, isso pode se tornar ineficiente.

Minhas perguntas:

1. Chamar copy() em cada alteração de TextField é ineficiente em termos de desempenho no Jetpack Compose? Essa criação e recomposição constantes de objetos causariam degradação perceptível de desempenho, especialmente em modelos de dados maiores ou cenários de entrada frequentes?
2. Quais são as melhores abordagens para lidar com mudanças frequentes de entrada de texto sem ter que usar copy() o tempo todo, ao mesmo tempo em que garante que o Compose possa recompor a UI quando necessário? Quero manter uma UI reativa sem criação excessiva de objetos.

E se houvesse uma maneira de, em vez de copiar o objeto, podermos alterar os valores da classe Data diretamente e compor automaticamente acionar a recomposição?

Tenho uma coluna em um conjunto de dados parecida com esta:

cluster_id
1
1
1
1
NA
1
NA
NA
2
NA
2
NA
3
NA
NA
3


cluster_id <- c("1","1","1","1","NA","1","NA","NA","2","NA","2","NA","3","NA","NA","3")

A ordem já está predefinida antes de usar uma coluna de tempo. O que eu quero é substituir os NA's que estão dentro de cada ID de cluster, ou seja, se houver uma linha com 2, depois um NA e depois um 2 novamente, eu quero que esse NA se torne 2. Os NA's entre os números permanecem como NA's. Exemplo:

cluster_id   cluster_id_new
1            1
1            1
1            1
1            1
NA           1
1            1
NA           NA
NA           NA
2            2
NA           2
2            2
NA           NA
3            3
NA           3
NA           3
3            3 

Encontrei a zoo::na.locffunção neste post , que parece estar próxima do que eu quero, mas também preciso levar em consideração o valor após o NA. Alguma ideia?

Tenho um aplicativo spring boot com uma api rest. Vou implantá-lo em um servidor Linux. E temos vários aplicativos Java implantados em vários servidores Linux que chamam essa api. Sempre que uma solicitação for feita para esse ponto final, quero que as informações do nome do host sejam validadas.

1. API - http://localhost:8000/teste
2. Segundo aplicativo spring boot em execução na porta local 9000 quando este aplicativo faz uma solicitação para http://localhost:8000/test - Eu deveria ser capaz de saber qual host fez uma solicitação. aqui - localhost:9000

Eu tentei usar HttpServletRequest. Estou recebendo apenas os cabeçalhos abaixo daquele Host, connection, user-agent, accept, content-type, content-length. Origin, referer - os cabeçalhos não estão presentes.

Código do controlador abaixo

@PostMapping("/test")

public String authenticateAndGetToken (HttpServletRequest httpServletRequest, @RequestBody Request request) {

String errorMsg = "Invalid UserName";

Log.info("origin"+httpServletRequest.getHeader(HttpHeaders.ORIGIN));

httpServletRequest.getHeaderNames().asIterator().forEachRemaining (xx->System.out.println(xx));

Log.info(httpServletRequest.getRemoteAddr());

UserDetails userDetails = userInfoService. LoadUserBy Username (request.getUsername

Aqui a origem é nula Getremoteaddr é o endereço do servidor, não do cliente

RestTemplate restTemplate1 = new RestTemplate(); HttpHeaders headers = new HttpHeaders();

headers.setContentType (MediaType.APPLICATION_JSON);

Map<String, String> map = new HashMap<>();

map.put("username", "test");

map.put("password", "test");

String jsonBody new ObjectMapper().writeValueAsString(map);

HttpEntity<String> entity = new HttpEntity<>(jsonBody, headers);

ResponseEntity<String> response = restTemplate1.exchange(url: "http://localhost:8000/test", HttpMethod.POST, entity, String.class);

Eu tenho um dataframe como:

data = {
    "a": [[1], [2], [3, 4], [5, 6, 7]],
    "b": [[], [8], [9, 10], [11, 12]],
}
df = pl.DataFrame(data)
"""
┌───────────┬───────────┐
│ a         ┆ b         │
│ ---       ┆ ---       │
│ list[i64] ┆ list[i64] │
╞═══════════╪═══════════╡
│ [1]       ┆ []        │
│ [2]       ┆ [8]       │
│ [3, 4]    ┆ [9, 10]   │
│ [5, 6, 7] ┆ [11, 12]  │
└───────────┴───────────┘
"""

Cada par de listas pode não ter o mesmo comprimento, e eu quero "truncar" a explosão para a menor das duas listas:

"""
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 2   ┆ 8   │
│ 3   ┆ 9   │
│ 4   ┆ 10  │
│ 5   ┆ 11  │
│ 6   ┆ 12  │
└─────┴─────┘
"""

Eu estava pensando que talvez eu tivesse que preencher o menor de ambas as listas com Nonepara combinar ambos os comprimentos, e então drop_nulls. Mas eu estava pensando se havia uma abordagem mais direta para isso?

Gostaria de agregar, mesclar, compactar alguns valores conforme mostrado abaixo

A entrada é uma tabela e a saída são fórmulas de matriz dinâmicas em uma única célula e tem como objetivo agregar outras colunas com base em valores exclusivos da primeira coluna

Minha entrada é uma tabela (chamada TAB)

Saída desejada usando fórmulas de matriz em uma única célula E2

A fórmula que usei está abaixo:

=LET(
    Names; TAB[Name];
    uNames; UNIQUE(Names);
    aggfunc; LAMBDA(colIdx; MAP(uNames; LAMBDA(x; BYCOL(CHOOSECOLS(TAB;colIdx); LAMBDA(col;TEXTJOIN(" / "; TRUE; UNIQUE(FILTER(col; Names=x))))))));
    HSTACK(
        uNames;
        aggfunc(2);
        aggfunc(3)
    )
)

Como você percebeu, eu hardcodei "aggfunc(x)" (x é o número da coluna da minha tabela a ser retornada). Eu gostaria de usar uma única função aggfunc(numCols)e numCols é uma matriz do número de colunas. E a fórmula deveria ser como a seguinte, mas infelizmente não funciona. Ela dá um erro " #CALC! "

=LET(
    Names; TAB[Name];
    uNames; UNIQUE(Names);
    numCols; SEQUENCE(COLUMNS(TAB[#Data]));
    aggfunc; LAMBDA(colIdx; MAP(uNames; LAMBDA(x; BYCOL(CHOOSECOLS(TAB;colIdx); LAMBDA(col;TEXTJOIN(" / "; TRUE; UNIQUE(FILTER(col; Names=x))))))));
    HSTACK(
        uNames;
        aggfunc(numCols)
    )
)

Uma fórmula alternativa que usa BYROW em vez de MAP

=LET(
     a; TAB[Name];
     b; TAB[Type];
     c; TAB[Service];
     ua; UNIQUE(a);
     HSTACK(
       ua;
       BYROW(ua; LAMBDA(x; TEXTJOIN(" / ";TRUE;UNIQUE(FILTER(b;a=x)))));
       BYROW(ua; LAMBDA(x; TEXTJOIN(" / ";TRUE;UNIQUE(FILTER(c;a=x)))))
     )
 )

Também tentei usar o PowerQuery, mas usando group by e depois adicionar colunas personalizadas, mas como tenho várias colunas, é muito difícil atingir meu objetivo. Se for do interesse de alguém, abaixo estão os passos:

1. Selecione qualquer célula na tabela
2. Selecione o menu Dados e depois Da Tabela/Intervalo (no lado esquerdo)
3. Ele abre o Editor do PowerQuery , agora você precisa selecionar a coluna Name(a primeira coluna)
4. No menu Transformar , selecione Agrupar por . Uma nova janela é aberta, e preencho os campos conforme mostrado abaixo

• Novo nome da coluna:AGGNAME
• Operação:All Rows
• Clique em OK

5. Agora você tem uma tabela com duas colunas com títulos Nome e AGGNAME (Tabela)
6. No menu Adicionar coluna , selecione Coluna personalizada . Uma nova janela é aberta e eu insiro os seguintes valores

• Novo nome da coluna:Type
• Fórmula de coluna personalizada:=Text.Combine(List.Transform(List.Distinct([AGGNAME][#"Type"]), Text.From), " / ")

7. Agora você tem 3 colunas "Nome", "AGGNAME" e "Tipo".
8. Você precisa repetir o Passo 6 e alterar o nome Type(na fórmula) de acordo com o nome da sua coluna.
9. Depois de inserir todas as novas colunas necessárias, você deve excluir a coluna AGGNAME
10. Agora vá ao menu Home e clique em Close & Load . E ele criará uma nova tabela com a mesma saída que eu preciso.

Usar o PowerQuery se torna uma tarefa difícil se os nomes da tabela de entrada mudam ou se a tabela tem várias colunas.

Minha versão do Office 365 ainda não inclui a função "GROUPBY" (Versão 2406 Build 16.0.17726.20206) 64 bits .

Muito obrigado pelo seu tempo e, por favor, não hesite em perguntar se precisar de mais informações. Atenciosamente, T.

Tenho uma variável de ID que vem de 35 hospitais diferentes, então tem arranjos diferentes da variável e, às vezes, tem o mesmo número de ID raiz com um número de linha secundário - por exemplo, -1, /a, _1 etc.

Quero remover a pontuação e tudo o que vier depois dela, deixando apenas o número de ID raiz.

No momento, consegui escrever linhas individuais de código para cada iteração diferente, mas queria saber se há uma maneira mais elegante para que, no ano que vem, quando os dados chegarem, eu não precise verificar arranjos diferentes?

Na pergunta de outra pessoa, consegui encontrar uma maneira de remover os colchetes e todo o texto dentro dos colchetes, mas não consigo descobrir como manipulá-lo para meus propósitos

df$patid<- gsub("\\s*\\([^\\)]+\\)","",df$patid)

Eu tentei esses dois códigos sem sucesso

df$patid<- gsub("\\[:punct:]s*$","", df$patid)
df$patid<- gsub("\\[:alnum:]s*$","", df$patid)

Também tentei a cleanfunção que removeu toda a pontuação, mas manteve os números/caracteres depois delas, então não foi isso.

exemplo do meu código atual (nem todas as iterações possíveis) - Estas funcionam

df$patid<- gsub("\\-1$", "", df$patid)
df$patid<- gsub("\\-2$", "", df$patid)
df$patid<- gsub("\\-3$", "", df$patid)
df$patid<- gsub("\\-a$", "", df$patid)
df$patid<- gsub("\\-A$", "", df$patid)
df$patid<- gsub("\\-b$", "", df$patid)
df$patid<- gsub("\\-B$", "", df$patid)
df$patid<- gsub("\\b", "", df$patid)
df$patid<- gsub("\\/dd", "", df$patid)

Não estou preso a gsub, estou aberto a diferentes métodos.

Exemplo de números de identificação

patid<- c("MB-13-169454", "MB-13-179455", "MB-13-212235.1", "MB-13-212235.2", "MB-13-224683", "570548260-2", "570548260-3", "1458629P-2", "1139093D-2", "8253015N/2", "8253015N/3", "M255858/1", "M255858/2", "8494392Q/2", "9296741B/2", "04152341421/A", "04152341421/B", "04152640475/B", "04152821164/A", "G140381883_1", "G140381883_2", "G140880774_1", "G140880774_2")

Peço desculpas se isso já foi respondido em algum lugar

Por que o código a seguir imprime 0?

class X {
    fun f() {
        val x = 0
        val a = object {
            val x = 1
            fun g() {
                println(x)
            }
        }
        a.g()
    }
}

fun main() {
    val x = X()
    x.f()
}

Por que a declaração de propriedade interna não sombreia a externa?

Originalmente, pensei que o primeiro era apenas uma reexportação do último, mas parece que não é o caso. Qual é a diferença entre as duas pin!macros e como decidir qual usar?