Perguntas[arrays](coding)

Digamos que eu tenha o seguinte arquivo CSV (sample.csv)

filepath1
filepath1,filepath2
filepath1,filepath2,filepath3
filepath1,filepath2,filepath3,filepath4
filepath1,filepath2

E o programa que preciso usar usa a seguinte sintaxe:

program_im_using --file filepath1

Mas se houver vários arquivos presentes, a sintaxe para entrada é:

program_im_using --file filepath1 --file filepath2
or
program_im_using --file filepath1 --file filepath2 --file filepath3

O que eu faria para colar os valores do arquivo CSV seria algo assim:

filepath_first=( $(awk -F "\"*,\"*" '{print $1}' $sample_csv) )
filepath_second=( $(awk -F "\"*,\"*" '{print $2}' $sample_csv) )

for i in "${!filenames[@]}"; do
    program_im_using --file "${filepath_first[i]}" --file "${filepath_second[i]}"
done

Meu exemplo do que estou fazendo só funciona se eu tiver exatamente 2 colunas de valores em cada linha. Como posso generalizar de forma que, se eu tiver uma coluna, eu obtenha:

program_im_using --file filepath1

Mas se eu tiver dois

program_im_using --file filepath1 --file filepath2

etc?

Tenho uma string que contém uma matriz de objetos JSON. Usando Golang, quero remover um ou mais campos especificados de cada objeto na matriz e, em seguida, imprimir o resultado stringificado. Preciso aplicar esse processo de remoção de campo a vários formatos de entrada JSON diferentes e, portanto, não quero usar um modelo. Aqui está um código esqueleto com uma forma de entrada de exemplo e saída desejada:

package main

import (
    "fmt"
)

func functionDropSpecifiedFields(inputString string, fields []string) string {
    var outputString string

    // Need some logic here to remove each field in array 'fields'!

    return outputString
}

func main() {
    jsonArrayAsString := `[{"name":"Marlon","age":25,"created_at":"2025-02-10T08:51:14.615264Z"},{"name":"Wendy","age":31,"created_at":"2025-11-14T08:46:09.435264Z"}]`
    fieldsToRemove := []string{"created_at"}
    reducedString := functionDropSpecifiedFields(jsonArrayAsString, fieldsToRemove)
    fmt.Println(reducedString)

    // Should print: [{"name":"Marlon","age":25},{"name":"Wendy","age":31}]
}

Qual lógica na função DropSpecifiedFields conseguirá isso?

Estou usando a versão mais recente do g++ para compilar um código de teste envolvendo um array de ponteiros struct onde os structs contêm um array. A compilação falha quando tento inicializar o array de ponteiros struct em uma linha, mas se eu atribuir os structs a variáveis ​​e então pegar seus endereços ao criar o array, o g++ não reclama. Quero entender o porquê. Este é meu primeiro post, então peço desculpas se houver informações faltando.

Procurei por perguntas semelhantes e não encontrei nada tão específico.

#include <stdint.h>

typedef struct {
    uint16_t num_elements;
    uint8_t elements[];
} HasArray;

HasArray x = {.num_elements = 2, .elements = {51, 17}};
HasArray y = {.num_elements = 4, .elements = {1, 42, 88, 73}};

const HasArray* collection[] = {&x, &y};

// main() somewhere

O código acima funciona, o que eu presumo que seja porque o g++ pode alocar memória para xe yem tempo de compilação (ou algo similar). Se eu tentar inicializar collectionassim:

// HasArray cast is necessary so I can take the address, doing `&` on just the `{}`
// didn't work
// Also I would use a macro for these declarations, I know it's clunky
const HasArray* collection[] = {
    &(HasArray){.num_elements = 2, .elements = {51, 17}},
    &(HasArray){.num_elements = 4, .elements = {1, 42, 88, 73}}
};

g++ lança

test.c:16:56: error: non-static initialization of a flexible array member
   16 |     &(HasArray){.num_elements = 2, .elements = {51, 17}},
      |                                                        ^
test.c:17:63: error: non-static initialization of a flexible array member
   17 |     &(HasArray){.num_elements = 4, .elements = {1, 42, 88, 73}}
      |                                                               ^

O que torna essas situações diferentes? No meu cérebro, a segunda sintaxe ainda alocará memória em tempo de compilação, mas parece que não é o caso. Eu entendo que eu poderia alocar memória em tempo de execução com malloc(), mas a primeira situação não requer isso e eu sei o tamanho das structs em tempo de compilação, então como posso indicar o tamanho para o compilador sem criar variáveis ​​separadas para cada struct?

Editar: Eu de fato marquei a pergunta incorretamente, opa. Isso é para código c, mas tenho que usar g++ para compilá-lo. @ChrisMM forneceu uma resposta muito boa nos comentários. Para contornar o erro, atribuirei os arrays a variáveis ​​e pegarei seus endereços como na primeira situação.

Intervalo de células começando na região Sheet1.Range("A2") com fórmulas. A string "No DATA" é constante se nada for extraído conforme a fórmula e eu não quero que ela seja incluída na matriz 1-D durante a transferência da matriz 2-D. Depois que a matriz 1-D estiver pronta, eu quero colar a matriz 1-D na planilha "Result" na célula "B:2" e para baixo. Eu tentei soluções online para isso. Mas as matrizes estão ficando complicadas para mim. O novo código também está bom. Eu coletei o código abaixo de fontes diferentes.

Sub TwoD_ArrayTo_1D_Array()
    
    Dim rg As Range
    'First row is always blank, so started with cell A2 & range contains formula
    Sheet1.Range("A2").Select
    Set rg = Sheet1.Range("A2").CurrentRegion
    
    Dim arr As Variant, arr1D() As Variant
    arr = rg.Value
    
    Dim i As Long, j As Long, k As Long, rows As Long, totalrows As Long
    
    totalrows = (rg.rows.Count - 1) * (rg.Columns.Count)
    k = 1

    ReDim arr1D(1)
    
    'Convert 2D to 1D array
    For i = i To (rg.rows.Count - 1)
        For j = 1 To rg.Columns.Count
            
            If arr(i, j).Value = "No DATA" Then 'dont want to copy cell if it contains "No DATA"
                GoTo Next_Row
            Else
                arr1D(k) = arr(i, j)
                k = k + 1
                ReDim Preserve arr1D(k)

            End If
            
Next_Row: Next j

    Next i
    

    'Pasting array values in "Result" Sheet
    Dim iRw As Integer
    For iRw = LBound(arr1D) To UBound(arr1D)

      Result.Cells(iRw, 2).Value = arr1D(iRw, 1)
   Next iRw
   
End Sub 

Eu achava que arrays eram considerados estruturas de dados estáticas .

Então executamos isto:

#include <stdio.h>
#include <stdlib.h>

int main()
{
  int a[5] = {10,20,30,40,50};
  a[5] = 100;
  a[6] = 200;
  printf("Out of bounds %d, %d", a[5], a[6]);
  return 0;
}

Isso retorna Out of bounds 100 200e termina normalmente. POR QUÊ?

Por que 200 é declarado e retornado normalmente se a[5]é estático?

Tudo me leva à conclusão de que o gcc trata matrizes como estruturas de dados dinâmicas.

Estou certo? O que está acontecendo?

Posso remover facilmente o primeiro elemento de uma matriz:

SELECT (ARRAY[1,2,3])[2:]
--{2,3}

Qual é a maneira mais simples de remover o último elemento também? O tamanho é dinâmico e não é conhecido em tempo de compilação.

Tenho uma matriz de tuplas no PostgreSQL 17.

Não consegui ir SELECT...INTO...FROMtrabalhar por algum motivo:

SELECT ARRAY[(1,2)] AS a INTO temp_table;

ERROR: column "a" has pseudo-type record[] 
SQL state: 42P16

Para resolver isso, tive que convertê-lo para text:

SELECT ARRAY[(1,2)] AS a, ARRAY[(1,2)]::text AS b

Agora preciso converter column bde volta para array de tuplas, como column a. Como isso pode ser feito?

Isso é mega específico, mas preciso salvar um dicionário em um slice. A ideia é que eu possa preencher um dict (que chamo de "lookup") com valores, então salvar esses valores dentro de um slice (que chamo simplesmente de "data"), para que eu possa preencher esse mesmo dict com outros valores e salvá-los novamente. Dessa forma, posso acessar esses dicionários chamando data[0] ou data[1]

O problema é simplesmente que não tenho a mínima ideia de como fazer isso. Tentei data = append(data, lookup)depois de inicializar data como data := make([]map[string]string, 0, mas o problema é que os valores já dentro de data mudaram junto com lookup (o que significa que ele foi preenchido com, tipo, 100 cópias do mesmo dict). Também tentei fazer um tipo type data map[string]interface{}- já que outra pergunta semelhante que foi feita aqui tinha essa solução - e então data := []data{}into data = append(data, lookup)mas recebi um erro de tipo incompatível. Eu provavelmente deveria mencionar que lookup foi inicializado como lookup := make(map\[string\]string). Aqui está uma versão mais resumida:

lookup := make(map[string]string)
//this is where I'd initialize data, had I known what type I wanted. For now, I have this:
data := make([]map[string]string, 0)
//there are also a few more variables initialized here but, I don't think they're really needed for the problem at hand
//the function keeps running, filling up lookup with keys and values. Then, I've reached a point where those values need to be saved, I try:
data = append(data, lookup)
//and then reset the values of all other variables, and get lookup ready to start again
//when I print data, however, all the dicts inside it are the same, which is equal to the last value lookup had before reaching the end. I don't get why that happens - it's not like I'm saving a pointer to lookup - and if someone knows I would give you my life.

Agradeço desde já. Procurei uma resposta em todos os lugares, mas não obtive nada.

Como iniciante em Assembly, tenho praticado desmontagem e engenharia reversa em assembly Intel x86 no IDA.

O programa atual que estou tentando descobrir valida a senha fornecida pelo usuário formando sua própria "senha de validação" e comparando as duas. Se elas corresponderem, a senha fornecida pelo usuário é aceita.

A senha de validação é formada por um loop que é executado 16 vezes e os caracteres para a senha vêm de um rótulo chamado CHARACTERSque armazena o endereço da string aAbcdefghijklmn.

aAbcdefghijklmné definido como'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890'

var_40é definido como -40hexadecimal.

mov     [ebp+loop_counter], 0
loc_8049201:
cmp     [ebp+loop_counter], 0Fh ; Compare Two Operands
jge     loc_804922F     ; Jump if Greater or Equal (SF=OF)
mov     eax, CHARACTERS
mov     ecx, [ebp+loop_counter]
mov     ecx, [ebp+ecx*4+var_40]
mov     dl, [eax+ecx]
mov     eax, [ebp+loop_counter]
mov     [ebp+eax+validation_password], dl
mov     eax, [ebp+loop_counter]
add     eax, 1          ; Add
mov     [ebp+loop_counter], eax
jmp     loc_8049201     ; Jump
loc_804922F:
lea     eax, [ebp+validation_password] ; Load Effective Address
mov     ecx, [ebp+user_password]
mov     edx, esp
mov     [edx+4], ecx
mov     [edx], eax
call    _strcmp         ; Call Procedure
cmp     eax, 0          ; Compare Two Operands
jnz     loc_804925D     ; Jump if Not Zero (ZF=0)

Esta parte cria a senha de validação.

mov     eax, CHARACTERS
mov     ecx, [ebp+loop_counter]
mov     ecx, [ebp+ecx*4+var_40]
mov     dl, [eax+ecx]
mov     eax, [ebp+loop_counter]
mov     [ebp+eax+validation_password], dl
mov     eax, [ebp+loop_counter]
add     eax, 1          ; Add
mov     [ebp+loop_counter], eax
jmp     loc_8049201     ; Jump

O que não consigo entender é como o índice da 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890'string para cada loop é calculado.

O que eu entendo é que o caractere escolhido é o endereço de CHARACTERSarmazenado em eaxe o valor de [ebp+ecx*4+var_40]como o offset, criando o índice específico. Isso é então armazenado em dl.

Não sei como determinar o número do índice usando o cálculo do endereço de memória [ebp+ecx*4+var_40]em cada loop.

EDITAR:

A inicialização do array ebp+var_40é feita com _memcpy anteriormente na mesma função.

push    ebp
mov     ebp, esp
push    esi
sub     esp, 64h
mov     eax, [ebp+user_password]
xor     ecx, ecx
lea     edx, unk_804A064 ; db 3
lea     esi, [ebp+var_40]
mov     [esp], esi
mov     [esp+4], edx
mov     dword ptr [esp+8], 3Ch
mov     [ebp+var_58], eax
mov     [ebp+var_5C], ecx
call    _memcpy

unk_804A064é definido como db 3. A partir unk_804A064dos 60 bytes seguintes estão:

3, 0, 0, 0, 34h, 0, 0, 0, 38h, 0, 0, 0, 1Ah, 0, 0, 0, 2Ch, 0, 0, 0, 2Ch, 0, 0, 0, 1Eh, 0, 0, 0, 26h, 0, 0, 0, 1Bh, 0, 0, 0, 25h, 0, 0, 0, 32h, 0, 0, 0, 13h, 0, 0, 0, 37h, 0, 0, 0, 2Ch, 0, 0, 0, 0Ah, 0, 0, 0

Supondo que temos uma matriz M de tamanho N^2 x N^2 elementos (por exemplo, 9x9), qual é a maneira mais rápida de dividi-la em segmentos de 3x3 (cada um com 3x3 elementos)?

Uma maneira que me vem à mente é a seguinte:

M = magic(9);
N = 3; 

m = mat2cell(M, N * ones(1, size(M, 1) / N), ...
                N * ones(1, size(M, 2) / N));

Eu, no entanto, não prefiro o uso de células. Fiquei curioso para saber se há uma maneira de dividir a matriz e armazenar os segmentos na forma de uma matriz 3D usando uma indexação de coluna principal para os segmentos (por exemplo, o primeiro segmento m{1} se torna m(:, :, 1) e o segundo segmento m{2} se torna m(:, :, 2), e assim por diante).