All perguntas(coding)

Tenho uma referência e sequências de consulta:

ref_seq <- "ATTT"
df <- data.frame(V1=c("AATT", "TTTT", "GGTT"))

Gostaria de retornar as posições incompatíveis na sequência para cada consulta em comparação com a referência:

seqdiff <- function(seq1, seq2) {
  seq <- strsplit(c(seq1, seq2), split= '')
  mismatches <- which(seq[[1]] != seq[[2]])
  return(mismatches)
}
    
apply(X=df, MARGIN=2, function(x) seqdiff(x, ref_seq))

#      V1
# [1,]  1
# [2,]  2

Resultado esperado:

#      V1
# [1,]  2
# [2,]  1
# [3,]  1 2

No C17 temos isto (6.7.6.2 #3):

Se, na declaração “ T D1”, D1tiver uma das formas:

 D [ lista de qualificadores de tipo _opt expressão de atribuição _opt ]
 D [ lista de qualificadores de tipo _opt expressão de atribuição ]
 D [ lista de qualificadores de tipo static expressão de atribuição ]
 D [ lista de qualificadores de tipo _opt ]

e o tipo especificado para ident na declaração “ T D” é “ derived-declarator-type-list T ”, então o tipo especificado para ident é “ derived-declarator-type-list array of T ”. ¹⁴⁴⁾ (Veja 6.7.6.3 para o significado dos qualificadores de tipo opcionais e da palavra-chave static.)

Derivado não é float, ou int, ou char, é "matriz de", ou "ponteiro para".

Por exemplo, temos int name [2][3], aqui Testá int, e D1é A[2][3], com a forma D[3]onde Dé A[2], então T Dé int A[2], ou "matriz de 2 int". Então o tipo declarado de Aé "matriz de 2 matriz de 3 int".

Mas e quanto a int * name[4]?

Aqui, a " lista de tipos de declaradores derivados T " será int * name. E, ao que parece, o " array de lista de tipos de declaradores derivados de T " será um ponteiro para um array de 4 elementos?

No fim das contas, isso está errado, porque int *name[4]é um array de 4 ponteiros. Por favor, me explique.

Tenho uma animação que estou declarando e reproduzindo usando JS, mas quando a animação é reproduzida, meu ouvinte de eventos não dispara.

Aqui está o arquivo HTML:

let anim = document.getElementById("anim");

const animkeyFrames = new KeyframeEffect(
  anim,
  [{
      transform: `translate3d(0px, 0px, 0px)`
    }, // keyframe
    {
      transform: `translate3d(0px, ${200}px, 0px)`
    },
  ], {
    // keyframe options
    duration: 1000,
    iterations: "1",
  },
);
let animation = new Animation(animkeyFrames, document.timeline);

anim.addEventListener('animationstart', () => {
  console.log("STARTED");
})

animation.play();

#anim {
  top: 10px;
  left: 10px;
  width: 100px;
  height: 100px;
  background-color: black;
  position: absolute;
}

<div id="anim"></div>

Quero que "STARTED" seja registrado quando a animação for reproduzida, mas nada acontecer.

Tenho um UInt64 armazenado em uma string. Para fins de argumentação, vamos usar o valor máximo, 18446744073709551615. Como o PHP não suporta UInt64, não posso converter isso em um número, caso contrário, bits serão perdidos.

Então minha abordagem inicial foi fazer as malas:

$number = "18446744073709551615";
$packed = pack('J', $number);
$value1 = unpack('N', substr($packed, 0, 4))[1];
$value2 = unpack('N', substr($packed, 4, 4))[1];
var_dump($packed); // 7fffffffffffffff

Então isso não está totalmente certo. Internamente, ele ainda foi convertido para um Int64.

Posso compactar com N para obter metade do valor, mas não consigo descobrir como obter a outra metade:

$number = "18446744073709551615";
$packed = pack('N', $number);
$value1 = ??;
$value2 = unpack('N', $packed)[1];

Pedir repetições com N* ou NN não ajuda. Meu cérebro quer deslocar o valor para a direita, mas, novamente, não consigo converter para um inteiro, então nada de operações bit a bit.

Sinto que estou esquecendo algo muito simples. Como obtenho a outra UInt32?

Em uma caixa, tenho um wrapper de uso geral para arquivos temporários:

pub struct TempFile {
    // ...
}

Em outra caixa, tenho um wrapper de repetição assíncrona de uso geral:

pub async fn retry<F, R>(mut func: F) -> Result<(), String>
where
    F: FnMut() -> R,
    R: Future<Output = Result<(), String>>
{
    for _ in 0..5 {
        if func().await.is_ok() {
            return Ok(());
        }
    }
    Err("failed".to_owned())
}

Na terceira caixa, tenho uma função de download de uso geral que baixa para um arquivo temporário:

async fn download(output: &mut TempFile) -> Result<(), String> {
    // ...
}

Agora quero adicionar uma função de nova tentativa de download como esta:

async fn download_with_retry(output: &mut TempFile) -> Result<(), String> {
    retry(|| { download(output) }).await
}

Entretanto, isso não compila:

error: captured variable cannot escape `FnMut` closure body
  --> src/lib.rs:16:20
   |
15 |     async fn download_with_retry(output: &mut TempFile) -> Result<(), String> {
   |                                  ------ variable defined here
16 |         retry(|| { download(output) }).await
   |                -   ^^^^^^^^^------^
   |                |   |        |
   |                |   |        variable captured here
   |                |   returns an `async` block that contains a reference to a captured variable, which then escapes the closure body
   |                inferred to be a `FnMut` closure
   |
   = note: `FnMut` closures only have access to their captured variables while they are executing...
   = note: ...therefore, they cannot allow references to captured variables to escape

Entendo por que isso está acontecendo: embora a retryfunção sempre espere functerminar antes de invocá-la novamente, o compilador não consegue ver isso e tem que assumir que múltiplas invocações paralelas são possíveis, levando a múltiplos empréstimos mutáveis ​​simultâneos de output.

Sei que posso contornar isso passando Rc<RefCell<TempFile>>para download_with_retry, mas isso significa que ele vaza para a API pública dessa função sem nenhum bom motivo.

Existe outra solução? Idealmente, modificando apenas a implementação de retrye/ou download_with_retry, mantendo as assinaturas?

Link do playground

Primeiro, pego uma string codificada em base64 e a decodifico:

local base64_str="OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="
echo "${base64_str}" | base64 --decode > foo.txt

O tamanho do arquivo binário é 32 bytes com base em:wc -c < foo.txt

Eu costumo xxdcodificar o valor no arquivo para o formato hexadecimal:

xxd -p ./foo.txt ./foo.hex.txt

O valor hexadecimal no arquivo foo.hex.txt é:

3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66a
c13c

O tamanho do arquivo hash codificado é de 66 bytes usandowc -c < foo.hex.txt

Gostaria de pegar a string base64 e convertê-la para hexadecimal de modo que ela permaneça uma string de 32 bytes que eu possa usar com o openssl para criptografar e descriptografar usando cifras aes-256.

local iv_hex=$(base64_to_hex "${iv}")
local key_hex=$(base64_to_hex "${key}")

openssl enc -aes-256-ctr -K "${key_hex}" -iv "${iv_hex}" -in "${input_file}" -out "${output_file}"

Tenho duas versões da mesma função usando std::any_ofe std::find_ifpara verificar se intexiste em um vetor (retornado de g.getEdges()).

Entretanto, quando executo repetidamente o std::any_ofvalor de retorno é inconsistente, enquanto std::find_ifé.

Ambas as versões são as seguintes ( g.getEdges()retorna um intvetor, enquanto this->sé um int):

bool Search::marked(const int &v) {
    return std::any_of(begin(g.getEdges(v)), end(g.getEdges(v)), [this](const int &w) { return w == this->s; });
}

bool Search::marked(const int &v) {
    auto it = std::find_if(begin(g.getEdges(v)), end(g.getEdges(v)), [this](const auto &w) { return w == this->s; });
    return it != end(g.getEdges(v));
}

Em ambas as classes, adjo vetor está sendo iterado:

class Graph {
  public:
    Graph() : vertex(0), edges(0) {
      adj = std::make_unique<std::vector<std::vector<int>>>(0);
    }
    const std::vector<int> getEdges(int v) { return (*adj)[v]; }
  // ... rest of public
  private:
    std::shared_ptr<std::vector<std::vector<int>>> adj; // Shared for Search class
}

class Search {
  public:
    Search(Graph &g_, int s_) : g(g_), s(s_) {}
    int count();
    bool marked(const int &v);

  private:
    Graph &g;
    int s;
};

A função gtest que usei para verificar o código:

TEST(searchClassTest, HandlesPositiveInput) {
    // ... init myGraph ...
    Search mySearch(myGraph, 2);  // 2 is s!
    EXPECT_EQ(mySearch.count(), 2);
    EXPECT_EQ(mySearch.marked(1), true);
    EXPECT_EQ(mySearch.marked(3), true);
}

Por que estou obtendo resultados inconsistentes?

Link para o exemplo mínimo reproduzível: https://godbolt.org/z/9TnGq3Wbs

Essa pessoa brilhante Jborean93 criou um script do PowerShell que por sua vez gera um .exe chamado "noGui.exe" aqui

Vou citar o código para que você não precise procurá-lo:

Add-Type -OutputType WindowsApplication -OutputAssembly NoGui.exe -TypeDefinition @'
using System;
using System.Runtime.InteropServices;
using System.Text;

namespace NoGui
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public int dwProcessId;
            public int dwThreadId;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct STARTUPINFOW
        {
            public Int32 cb;
            public IntPtr lpReserved;
            public IntPtr lpDesktop;
            public IntPtr lpTitle;
            public Int32 dwX;
            public Int32 dwY;
            public Int32 dwXSize;
            public Int32 dwYSize;
            public Int32 dwXCountChars;
            public Int32 dwYCountChars;
            public Int32 dwFillAttribute;
            public Int32 dwFlags;
            public Int16 wShowWindow;
            public Int16 cbReserved2;
            public IntPtr lpReserved2;
            public IntPtr hStdInput;
            public IntPtr hStdOutput;
            public IntPtr hStdError;
        }

        [DllImport("Kernel32.dll", SetLastError = true)]
        public static extern bool CloseHandle(
            IntPtr hObject);

        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern bool CreateProcessW(
            [MarshalAs(UnmanagedType.LPWStr)] string lpApplicationName,
            StringBuilder lpCommandLine,
            IntPtr lpProcessAttributes,
            IntPtr lpThreadAttributes,
            bool bInheritHandles,
            int dwCreationFlags,
            IntPtr lpEnvironment,
            [MarshalAs(UnmanagedType.LPWStr)] string lpCurrentDirectory,
            ref STARTUPINFOW lpStartupInfo,
            out PROCESS_INFORMATION lpProcessInformation);

        [DllImport("Kernel32.dll")]
        public static extern IntPtr GetCommandLineW();

        static void Main()
        {
            IntPtr cmdLinePtr = GetCommandLineW();
            string cmdLine = Marshal.PtrToStringUni(cmdLinePtr);
            int cmdLineArgsIdx = cmdLine.IndexOf(" -- ");
            StringBuilder newCmdLine = new StringBuilder(cmdLine.Substring(cmdLineArgsIdx + 4));

            STARTUPINFOW si = new STARTUPINFOW()
            {
                cb = Marshal.SizeOf<STARTUPINFOW>(),
                dwFlags = 0x00000001, // STARTF_USESHOWWINDOW
                wShowWindow = 0, // SW_HIDE
            };
            PROCESS_INFORMATION pi;
            bool res = CreateProcessW(
                null,
                newCmdLine,
                IntPtr.Zero,
                IntPtr.Zero,
                true,
                0x00000410,  // CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT
                IntPtr.Zero,
                null,
                ref si,
                out pi
            );

            if (res)
            {
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
            }
        }
    }
}
'@

Quando o NoGui.exe é executado, ele permite que (no meu caso, o PowerShell, mas pode ser qualquer processo) seja executado sem nenhuma janela/shell/prompts/qualquer coisa aparecendo na tela (e funciona).

É quase exatamente o que eu preciso. Mas, pelo que posso perceber, ele não espera que o processo que você solicitou seja encerrado antes de ser encerrado.

Preciso disso porque se eu for usar isso no Microsoft Intune para executar um script do PowerShell, não sei se o Intune detectaria o processo filho do PowerShell e esperaria sua conclusão.

Imagine por um momento que o script do PowerShell gerado pelo NoGui.exe pode levar muito tempo para ser concluído, mas o Intune pensa "ah, bem, o noGui.exe foi concluído, então a instalação deve ser feita". Mas não é o caso.

Então como podemos modificá-lo para:

1. ele espera que o processo filho termine antes de terminar a si mesmo.

2. Pontos adicionais, eu acho, se conseguirmos obter o código de saída para retornar ao processo pai e gerar a saída lá. O script do PowerShell explodiu por algum motivo? Tudo bem, o Intune recebeu o código de saída do Nogui.exe, então sabemos o que aconteceu.

Estou ciente de que existem wrappers do VBScript que ocultam a execução do PowerShell, mas não quero usá-los, pois o VBScript será desativado em algum momento no futuro.

Tenho um modelo que estou passando com sucesso TextTabs e CheckboxTabs; no entanto, meus NumberTabs não estão sendo exibidos. Estou lendo sobre Tabulações Numéricas vs. Tabulações Numéricas. Verifiquei novamente e parece que o modelo está configurado com Number. Consigo ver o valor antes de enviar para o DocuSign. Mas quando o envelope é aberto, ele não está lá.

Devo usar Numérico? Alguma outra ideia do que está faltando?

Atualização: Testei Numérico e funcionou. Nova pergunta: Como posso saber se era Numérico no modelo?

   Number n = new Number
   {
        TabLabel = kvp.Key,// name of DS field, e.g. amount
        Value = kvp.Value //e.g. 25.53
   };

   List<Number>? numTabs = [];
   numTabs.Add(n);

   tabs ??= new Tabs();
   tabs.NumberTabs = numTabs ;

   //continue to populate envelope/signer information in envelope definition

Esta é a definição do meu campo de modelo DocuSign, por exemplo, valor:

Tenho um comando legado fooque aceita arbitrariamente muitos parâmetros de entrada (com nomes idênticos), cada um prefixado por --input. A partir de cmd.exe, posso executar:

C:\> foo --input "first" --input "second" --input "third" file.dat

e três valores de entrada são usados ​​para processar file.dat.

Estou tentando chamar fooum script do Powershell no qual posso calcular uma matriz que tem valores/tipos que podem ser equivalentes a esses valores constantes.

$my_args = @(
  "first",
  "second",
  "third"
)

Quero poder chamar foo para que os argumentos --include <value>sejam repetidos para cada item em $my_args. Eu poderia usar:

foo --input $my_args[0] --input $my_args[1] --input $my_args[2] filename.dat

Mas isso não funcionaria se $my_argsnão contivesse exatamente 3 itens. Qual seria uma expressão do PowerShell interessante para fazer isso?