All perguntas(coding)

Tenho um valor que foi criptografado usando PHP openssl usando a cifra AES-CBC-256, mas a senha para o valor final também foi criptografada usando o mesmo método.openssl_encrypt($key, $cipher, $passphrase, 0, $iv)

Preciso conseguir descriptografar esses dados usando Python, mas estou tendo problemas com o tamanho do bloco.

Aqui está parte do código que tenho até agora. Testei descriptografá-lo em PHP e funciona corretamente. Meu valor final neste exemplo deve ser "Jimmy".

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

localKey = base64.b64decode('Po0KPxyF')
localIv = base64.b64decode('s8W+/a4jkp9mhO3NkCL7Yg==')

encrypted_value = base64.b64decode('hl5n6Nq5QYtgKIyLEVCupA==')
encrypted_key = base64.b64decode('MGRHRFlaMzhCR0lxb2VHS1JHQXcrWkV2bkJpNWFZb3cybW9iQW5KYTlOU0xKK1FHc2pPUW1MUE9JRU5zTXN1Rg==')
encrypted_iv = base64.b64decode('J31SrExr7KKIOertYIPhpQ==')

# First need to encrypted key that uses the local key as the passphrase
cipher_key = AES.new(pad(localKey,16), AES.MODE_CBC, localIv)
decrypted_key = cipher_key.decrypt(encrypted_key)

# Then decrypted the final value using the newly decrypted key
cipher_key = AES.new(unpad(decrypted_key,16), AES.MODE_CBC, encrypted_iv)
decrypted_value = cipher_key.decrypt(encrypted_value)

Tenho um script do PowerShell para configurar um site no IIS. Ele inclui as seguintes funções:

function Set-IisWebsiteBinding (
    [Parameter(Mandatory = $true)]
    [string]$SiteName, 
    
    [Parameter(Mandatory = $true)]
    [Microsoft.Web.Administration.Site]$Website,
    
    [Parameter(Mandatory = $true)]
    [array]$WebsiteBindingSettings
)
{
    # Set up website bindings ...
}

Estou tentando escrever testes para a função no Pester. Gostaria de criar um objeto fictício $Website para passar para a função em teste. O problema é que o Microsoft.Web.Administration.Sitetipo não tem construtor. Como posso criar um objeto do tipo Microsoft.Web.Administration.Siteno PowerShell se ele não tem construtor?

Eu poderia criar um via , IISServerManager.Sites.CreateElement()mas gostaria de evitar ter que depender do uso de um IISServerManager. Alternativamente, eu poderia me livrar da coerção de tipo para o parâmetro de função $Website, para permitir que o código de teste passasse uma tabela de hash em vez de um objeto Microsoft.Web.Administration.Site. No entanto, prefiro manter a coerção de tipo para que fique óbvio para os futuros mantenedores do script qual $Websiteé o tipo do objeto.

Existe alguma maneira de contornar essa falta de um construtor sem usar um real IISServerManagerou remover a coerção de tipo?

Qual é a complexidade de tempo do seguinte código em C#?

array.Order().Take(k).ToArray();

O LINQ tratará isso como QuickSelect? Ou realizará uma ordenação completa de arrays com complexidade O(n log n) ?

Posso usar o nome da propriedade do objeto como um valor de string no objeto? Quer dizer, quero conseguir isso:

type MyObjectType = /* ... */

const myValidObject: MyObjectType = {
  a: 'a',
  b: 'b'
} // valid object of type MyObjectType

const myInvalidObject: MyObjectType = {
  a: 'a',
  b: 'c'
} // invalid object of type MyObjectType, property b should have value 'b'

Eu tentei algo assim, mas não funciona:

type MyObjectType = {
  [K: string]: `${K}`
}

Tenho uma situação em que preciso agrupar 16 bits em um número de 64 bits e depois lê-los como um número inteiro assinado no intervalo [ -32768, 32768 ). O método que escolhi para isso é calcular o número como um int assinado de 16 bits, convertê-lo imediatamente em um int não assinado de 16 bits e, em seguida, fazer o upcast para um int não assinado de 64 bits antes de executar a mudança de bit adequada para obter os 16 bits críticos no lugar apropriado.

Aqui está o pseudocódigo para criar o arranjo compactado de bits:

Given int x, y such that x - y >= -32768 and y - x < 32768;
const int MASK_POS = 45;
const unsigned short int u_s = x - y;
unsigned long long int ull_s = u_s;
ull_s <<= MASK_POS;

Aqui está o pseudocódigo para extrair a diferença nos números originais:

Given unsigned long long int ull_s with 16 bits encoding a signed integer in the 46th through 61st bits;
const unsigned short int u_s = ((ulls >> MASK_POS) & 0xffff);
const short int s_s = u_s;
const int difference_x_and_y = s_s;

Esta me parece uma maneira razoável de empacotar um número inteiro assinado e extraí-lo. Desconfio do comportamento específico da plataforma ao realizar mudanças de bits em números inteiros negativos, mas acho que converter para a forma não assinada do mesmo número de bits antes de atualizar o número de bits gerais no número e, ao contrário, extrair o não assinado inteiro com comprimento de bit desejado antes de converter para um inteiro com sinal de tamanho igual, será seguro.

(Caso alguém esteja curioso, haverá MUITO coisa acontecendo nos outros 48 bits desse número inteiro não assinado de 64 bits em que o material acaba - dos três bits mais altos aos 31 mais baixos e aos 14 do meio, tudo foi analisado. Certamente posso escrever alguns testes de unidade para garantir que esse comportamento se mantenha em qualquer arquitetura, mas se alguém puder ver uma falha agora, é melhor saber com antecedência. Obrigado!)

Você consegue adivinhar a saída deste programa trivial?

#include <vector>
#include <string>
#include <exception>
#include <iostream>
using namespace std;

int main()
{
    try { 
        struct X {
            explicit X(int) {}
            X(string) {} // Just to confuse you more...
        };
        vector<X>{"a", "b"};
    } catch (exception& x) {
        cerr << x.what();
    }
}

Bem, eu não poderia, o que me custou um dia de "pesquisa", antes de chegar aqui, finalmente destilando-o de algum código complexo da vida real (com aliases de tipo em todos os lugares, anon. uniões com não-membros do POD e mão- ctors/dtors orquestrados etc., apenas para dar uma vibe).

E... ainda não consigo ver o que está acontecendo! Alguém pode dar uma dica gentil? (Espero que seja apenas um ponto cego. Não faço mais C++ profissionalmente.)

/W4Nota: compilação limpa* com MSVC e GCC (mais recentes) -Wall; mesma saída em ambos (semanticamente).

_{* Mesmo sem a linha "confundir o leitor". Acho que vou ter pesadelos.}

(Por favor, tenha paciência comigo por tentar não estragar tudo, explicando tudo ainda mais - afinal, isso é realmente autoexplicativo como está, certo? Exceto, exatamente o oposto para mim...)

Estou seguindo o Manual de Design de Algoritmo v3 da Skiena.

Tenho visto algumas perguntas afirmando que há certos erros de digitação no livro e não tenho certeza se é um deles ou apenas porque não consigo entendê-los.

Considere o seguinte:

typedef struct edgenode {
    int y;                   /* adjacency info */
    int weight;              /* edge weight, if any */
    struct edgenode *next;   /* next edge in list */
} edgenode;

typedef struct {
    edgenode *edges[MAXV+1];  /* adjacency info */
    int degree[MAXV+1];       /* outdegree of each vertex */
    int nvertices;            /* number of vertices in the graph */
    int nedges;               /* number of edges in the graph */
    int directed;             /* is the graph directed? */
} graph;

void insert_edge(graph *g, int x, int y, bool directed) {
    edgenode *p;        /* temporary pointer */

    p = malloc(sizeof(edgenode));    /* allocate edgenode storage */

    p->weight = 0;
    p->y = y;
    p->next = g->edges[x];

    g->edges[x] = p;    /* insert at head of list */

    g->degree[x]++;

    if (!directed) {
        insert_edge(g, y, x, true);
    } else {
        g->nedges++;
    }
}

Pelo que entendi, void insert_edge(graph *g, int x, int y, bool directed)conecta dois nós no índice do array xe yos adiciona ao edgesarray.

O seguinte trecho me confunde:

p->y = y;
p->next = g->edges[x];

g->edges[x] = p;    /* insert at head of list */

Como isso está funcionando? Suponha que minha entrada seja x = 3, y = 4e esta seja a primeira entrada.

Eu esperaria algo parecido 3 -> 4com um gráfico direcionado.

1. p->y = y;faz todo o sentido, o adjacente de xé y.
2. p->next = g->edges[x];Mas a edgesmatriz é inicializada como nula. Isso não fará 3.next == NULLem vez de 3.next == 4?
3. g->edges[x] = p;O que? edges[x] == x Node, isso me confunde.

O código completo pode ser encontrado em graph.c e graph.h .

Acho que p.next = y;de alguma forma e y.next = NULLa partir de agora, ou seja, a primeira inserção. Talvez seja meu C enferrujado, mas preciso de ajuda nisso.

Eu tenho um script com uma condicional e uma pilha de verificações usando a mesma variável. Algo semelhante a isto:

my $size = "123B";
say "OK" if $size ~~ Str && $size.ends-with("B") && $size.chop >= 0;

Seria possível reescrever a linha de forma a evitar a repetição de $size?. Pensei em algo como junções que não tenho ideia de como aplicar a isso. Ou talvez outra coisa, mas mais curta da minha linha.

Tenho um sistema java comunicando que serve como gateway para diversos sistemas (java, mainframe, etc). Este sistema java recebe uma requisição usando, por exemplo, utf8 e a converte para a codificação do alvo

O problema é que existe um sistema de mainframe que está usando essa codificação obscura que não está disponível com o JDK que estamos usando (esse charset sendo o IBM-924 que é um "derivado" do IBM-1047 https: //en.wikibooks .org/wiki/Character_Encodings/Code_Tables/EBCDIC/EBCDIC_1047 ). sistema.

Pelo que vi esse charset parece vir apenas com o IBM JDK, que não é aquele que usamos ou queremos usar.

Existe uma maneira de incorporar este charset específico presente no IBM JDK em, por exemplo, um openjdk? Se não, existe alguma alternativa além de criar o charset manualmente? E em caso afirmativo, existe uma maneira de reutilizar a codificação IBM-1047 e substituir os 11 caracteres que não correspondem?

Tentei incorporar os charsets usando o charsets.jar presente no IBM JDK, mas dá problemas porque esse jar tem uma dependência de classes presentes apenas no rt.jar do IBM JDK, e com certeza não gostaria substitua o rt.jar, pois pode causar efeitos colaterais indesejados.

Você poderia sugerir alguma maneira de manter todas as chaves repetíveis (duplicadas) adicionando prefixo ou sufixo. No exemplo abaixo, a chave de endereço é duplicada 3 vezes. Pode variar (1 a 3 vezes). Eu quero obter a saída como na saída esperada com a adição de um sufixo para tornar a chave exclusiva. Atualmente, a função de atualização está substituindo o valor da chave.

list = ['name:John','age:25','Address:Chicago','Address:Phoenix','Address:Washington','email:[email protected]']
dic = {}
for i in list:
    j=i.split(':')
    dic.update({j[0]:j[1]})
print(dic)

Saída atual: {'nome': 'João', 'idade': '25', 'Endereço': 'Washington', 'email': 'Joã[email protected]'}

Saída esperada: {'name': 'John', 'age': '25', 'Address1': 'Chicago', 'Address2': 'Phoenix', 'Address3': 'Washington', 'email': 'John @email.com'}

Tentei o abaixo:

list = ['name:John','age:25','Address:Chicago','Address:Phoenix','Address:Washington','email:[email protected]']
dic = {}
for i in list:
    j=i.split(':')
    dic.update({j[0]:j[1]})
print(dic)

Saída esperada: {'name': 'John', 'age': '25', 'Address1': 'Chicago', 'Address2': 'Phoenix', 'Address3': 'Washington', 'email': 'John @email.com'}