Perguntas[arrays](coding)

Aqui estão os dados de resposta

array:3 [▼ // app\Http\Controllers\DataSend.php:38
  "status" => 200
  "message" => "Consignment has been created successfully."
  "consignment" => array:11 [▼
    "consignment_id" => 139732775
    "invoice" => "fddf51213"
    "tracking_code" => "854272742CC"
    "recipient_name" => "APi Test"
    "recipient_phone" => "01900110011"
    "recipient_address" => "address is here"
    "cod_amount" => 1
    "status" => "in_review"
    "note" => "Handle with care"
    "created_at" => "2025-04-21T05:53:11.000000Z"
    "updated_at" => "2025-04-21T05:53:11.000000Z"
  ]
]

Quero inserir esses dados no meu banco de dados.

todos os dados na $responsesvariável

foreach ($responses as $response) {
    $curDatains = new CurrierData();
    $curDatains->orderId = 1;
    $curDatains->orderInvoice = $response->invoice;
    $curDatains->consignment_id = $response->consignment_id;
    $curDatains->tracking_code = $response->tracking_code;
    $curDatains->status = $response->status;
    $curDatains->save();
}

no meu código eu enfrento o erro

Tentar ler a propriedade "fatura" em int

Estou tentando inicializar um array que é declarado em C struct.

O objetivo é usar um array e passá-lo como um argumento para uma função, que então copia cada elemento do array passado e o atribui a um array dentro de uma struct.

#include <stdio.h>


typedef struct {
    int v;
    int arrayInStruct[];
} TEST;

void ProblemCode1(){
    TEST test1; //Array Declared after struct declaration.
    int array[5] = {1,2,3,4,5};
    for(int i = 0; i < 5; i++){
        test1.arrayInStruct[i] = array[i];
        printf("%d", test1.arrayInStruct[i]);
    }
    return;
}

void ProblemCode2(int a[]){
    //Array Pass by Value and elements assigned to struct array.
    TEST test2;
    test2.arrayInStruct[5] = 0;
    for(int i = 0; i < 5; i++){
        test2.arrayInStruct[i] = a[i];
        printf("%d", test2.arrayInStruct[i]);
    }
    return;
}


void ProblemCode3(int a[]){
    //Array Pass by Value and elements assigned to struct array 
    //and struct array initilzation missing as compared to ProblemCode2.
    TEST test2;
    for(int i = 0; i < 5; i++){
        test2.arrayInStruct[i] = a[i];
        printf("%d", test2.arrayInStruct[i]);
    }
    return;
}

void WorkingCode1(){
    int array[5] = {1,2,3,4,5};
    TEST test1; //Array Created Before Declaration of Struct and not passed via function.
    for(int i = 0; i < 5; i++){
        test1.arrayInStruct[i] = array[i];
        printf("%d", test1.arrayInStruct[i]);
    }
    printf("\n");
    return;
}

void WorkingCode2(){
    int array1[5] = {1,2,3,4,5};
    int array2[5] = {0};
    for(int i = 0; i < 5; i++){
        array2[i] = array1[i];
        printf("%d", array2[i]);
    }
    printf("\n");
    return;
}

int main(){
    //int passbyValue[] = {1,2,3,4,5};
    //ProblemCode1();
    //ProblemCode2(passbyValue);
    //ProblemCode3(passbyValue);
    WorkingCode1();
    WorkingCode2();
    return 0;
}

Alguém poderia explicar por que certas funções funcionam e outras não?

Eu escrevo alguns pequenos programas que fazem a mesma coisa em diversas linguagens de programação. Comparo o desempenho e o consumo de RAM. Este é um dos programas que escrevi para teste.

Ambos os programas leem o mesmo arquivo. O arquivo contém dados concatenados com os caracteres \t(tab) e \n(enter). O conteúdo é semelhante ao seguinte.

aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh

O arquivo que criei tem 14 colunas e 63 linhas. Esses números podem mudar. Isso não é importante, pois estou testando.

Obtenho as linhas com split('\n'). E obtenho os campos na linha com split('\t'). Uma desserialização bem simples. O programa lê o arquivo uma vez e o desserializa 200.000 vezes. Em seguida, imprime a hora no console.

Ir:

package main

import (
    "fmt"
    "os"
    "strings"
    "time"
)

type Datatable struct {
    id   int
    rows [][]string
}

func main() {
    start := time.Now()

    dat, err := os.ReadFile("C:\\Temp\\test1.txt")
    if err != nil {
        panic("file not found")
    }
    str := string(dat)

    count := 200_000
    tables := make([]Datatable, count)

    for i := 0; i < count; i++ {
        table := Datatable{i, nil}
        var lines []string = strings.Split(str, "\n")
        table.rows = make([][]string, len(lines))
        for j, l := range lines {
            table.rows[j] = strings.Split(l, "\t")
        }
        tables[i] = table
    }

    end := time.Now()
    elapsed := end.Sub(start)
    fmt.Println("Time: ", elapsed)

    var b []byte = make([]byte, 1)
    os.Stdin.Read(b)
}

Ferrugem:

use std::fs;
use std::time::SystemTime;
use std::io::{self, BufRead};

struct Table<'a>{
    id: usize,
    rows: Vec<Vec<&'a str>>,
}
fn main() {
    let start = SystemTime::now();
    let str = fs::read_to_string("C:\\Temp\\test1.txt")
        .expect("read_to_string: failed");

    let count = 200_000;
    let mut tables = Vec::with_capacity(count);
    for i in 0..count {
        let lines = str.split('\n');
        let mut table = Table {
            id : i,
            rows : Vec::with_capacity(lines.size_hint().0),
        };
        for item in lines {
            table.rows.push(item.split('\t').collect::<Vec<&str>>());
        }
        tables.push(table);
    }
    println!("Time: {}", start.elapsed().expect("elapsed: failed").as_millis());

    let mut line = String::new();
    let stdin = io::stdin();
    stdin.lock().read_line(&mut line).expect("read_line: failed");
}

• vá versão go1.24.2 windows/amd64
• rustc 1.85.1 (4eb161250 2025-03-15)
• SO: Windows 11

Comandos de construção:

go build -ldflags "-s -w"
cargo build --release

Os resultados no meu computador são os seguintes:

Ir:

Time     : 4510 milis
RAM usage: 3217 MB

Ferrugem

Time     : 5845 milis
RAM usage: 3578 MB

Tentei escrever o código o mais simples possível. Você pode tentar copiando e colando.

O código Rust funciona. Mas é mais lento que o Go e consome mais RAM. Antes de escrever o código, eu esperava que o Rust fosse mais rápido. Talvez haja algo que eu não saiba.

Usar arrays em structs em Rust pode torná-lo mais rápido. Mas não tenho certeza se isso é possível. O que eu quero saber é como posso escrever esse código em Rust para torná-lo mais rápido?

Meu objetivo é ajustar a seguinte função aos meus dados:

def P(t, CP, Pan, tau):
    P_val = CP + Pan / (1 + t / tau)
    P_val = np.where(t >= 900, P_val - 0.8 * np.log(t / 900), P_val)
    return P_val

e, em seguida, plotar esta função. No entanto, gostaria de usar duas cores diferentes para os casos t<900e t>=900. Assim, decidi plotar as duas partes da curva separadamente, como mostrado abaixo. No entanto, isso resultou em duas curvas com um pequeno espaço entre elas, mesmo ao tentar forçar explicitamente a incorporação de t=900nas matrizes de tempo usadas para plotar as duas partes da curva. Algo como aqui:

Se forçarmos a inclusão de t=900, o problema da lacuna pode ser resolvido, mas o resto se desfaz, e obtenho duas curvas plotadas:

Como devo resolver esse problema ou existe uma solução alternativa/outra abordagem (por exemplo, linhas multicoloridas) para obter uma curva contínua com duas cores diferentes, que eu possa usar aqui? De acordo com a documentação do Matplotlib , LineCollectionpode ser útil, mas infelizmente não me sinto confortável com isso matplotlib.collections.

Aqui está meu código completo:

import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt

# Data
t2 = np.array([
    80,
    160,
    200,
    320,
    400,
    640,
    800,
    900,
    1000,
    1280,
    2000,
])

P_t2 = np.array([
    4.64,
    3.97,
    3.79,
    3.48,
    3.36,
    3.18,
    3.11,
    3.08,
    3.06,
    3.01,
    2.94,
])

t_min = 0 
t_cutoff = 7500  

mask = (t2 >= t_min) & (t2 <= t_cutoff)

t_filtered = t2[mask]
P_t_filtered = P_t2[mask]

def P(t, CP, Pan, tau):
    P_val = CP + Pan / (1 + t / tau)
    P_val = np.where(t >= 900, P_val - 0.8 * np.log(t / 900), P_val)
    return P_val

initial_guesses = [3.0, 4.0, 50.0]
bounds = ([1.35, 0, 0], [np.inf, np.inf, np.inf])

popt2, pcov2 = curve_fit(P, t_filtered, P_t_filtered, p0=initial_guesses, bounds=bounds, maxfev=5000)


t_fit2 = np.linspace(1, max(t2), 500)
P_fit2 = P(t_fit2, *popt2)


t_fit2_middle = t_fit2[(t_fit2 >= 80) & (t_fit2 <= 900)]
t_fit2_middle = np.append(t_fit2_middle, 900)               # include 900 explicitly

t_fit2_over = t_fit2[t_fit2 >= 900]
#t_fit2_over = np.append(t_fit2_over, 900)               # include 900 explicitly

P_fit2_middle = P(t_fit2_middle, *popt2)
P_fit2_over1 = P(t_fit2_over, *popt2)

#plotting
plt.plot(t_fit2_middle, P_fit2_middle, color='green', linewidth=2)
plt.plot(t_fit2_over, P_fit2_over1, color='red', linewidth=2)

plt.fill_between(t_fit2_middle, 0, P_fit2_middle, color='green', alpha=0.3, hatch='//')
plt.fill_between(t_fit2_over, P_fit2_over1, color='red', alpha=0.3, hatch='//')

plt.xlim(1, 1250)
plt.ylim(0, 8)
plt.minorticks_on()

ax = plt.gca()
ax.tick_params(labelbottom=False, labelleft=False)

plt.tight_layout()
plt.show()

Estou tentando resolver o seguinte problema algorítmico:

Todos os dias, Bob vai trabalhar e realiza uma das 26 tarefas possíveis. As tarefas são codificadas com as letras do alfabeto inglês de A a Z. Às vezes, Bob realiza tarefas atribuídas por seu chefe e, às vezes, pode escolher qual das 26 tarefas possíveis realizará ele mesmo. Esses dias são marcados com o símbolo !. O chefe definiu o plano de trabalho de Bob para os próximos N dias. Bob realmente não gosta de realizar a mesma tarefa por vários dias seguidos e, para mostrar ao chefe como está entediado, decidiu contar o número de maneiras de escolher um segmento contínuo de pelo menos dois dias durante o qual realizará a mesma tarefa todos os dias.

Ou seja, Bob considera todos os segmentos possíveis do dia L ao dia R, onde L < R, e se ele puder escolher seu trabalho de forma que as tarefas em todos os dias desse segmento sejam as mesmas, então ele considera esse segmento chato.

Ajude Bob a determinar o número de segmentos chatos no plano de trabalho para os próximos N dias enquanto ele estiver entediado.

Formato de entrada

É inserida uma única linha, que é uma sequência de caracteres composta por letras maiúsculas do inglês e o símbolo ! — o plano de trabalho para os próximos N (1 ≤ N ≤ 1000000) dias.

Formato de saída

Produza um único número — o número de segmentos de perfuração no plano.

Exemplo 1

Entrada:a!b!c

Saída: 5

Exemplo 2

Entrada:a!

Saída: 1

Notas

Todos os segmentos possíveis no primeiro exemplo estão entre |e|

|a!|b!c
a|!b|!c
a|!b!|c
a!|b!|c
a!b|!c|

Formalizei a tarefa da seguinte forma:

Problema

Dado um plano de trabalho para N dias como uma sequência composta por letras maiúsculas (de 'a' a 'z') e pontos de exclamação ('!'), conte o número de segmentos contínuos de pelo menos dois dias (ou seja, do dia L ao dia R, onde 1 ≤ L < R ≤ N) de forma que seja possível para Bob realizar a mesma tarefa em todos os dias dentro do segmento. Um segmento é considerado "chato" se:

• Todos os caracteres dentro do segmento são o mesmo caractere não-'!'.

• O segmento contém pelo menos um ponto de exclamação ('!').

Entrada

Uma única sequência representando o plano de trabalho para N dias.

A sequência consistirá apenas de letras maiúsculas em inglês (de 'a' a 'z') e pontos de exclamação ('!').

O comprimento da string N estará entre 1 e 1.000.000, inclusive (1≤N≤10 ⁶ ).

Saída

Um único inteiro representando o número total de segmentos "chatos" no plano de trabalho fornecido.

Meu Código

func solve() {
  guard let plan = readLine() else { return }
  let n = plan.count
  let planArray = Array(plan)
  var boringSegmentCount = 0
  for i in 0..<n {
    var nonWildcards = Set<Character>()
    for j in i..<n {
      if planArray[j] != "!" {
        nonWildcards.insert(planArray[j])
      }
      if j > i && nonWildcards.count <= 1 {
        boringSegmentCount += 1
      }
    }
  }
  print(boringSegmentCount)
  
}

O código Swift fornecido tem como objetivo resolver o problema iterando por todos os segmentos contínuos possíveis da string de entrada plan.

Ele usa loops aninhados para iterar por todos os segmentos contínuos possíveis da string:

• O loop externo ( i) determina o índice inicial do segmento.
• O loop interno ( j) determina o índice final do segmento.

Para cada segmento (do índice iaté j):

• Ele cria uma Setchamada nonWildcardspara armazenar caracteres únicos que não são '!'.
• Ele itera pelos caracteres dentro do segmento atual.
• Se um caractere não for '!', ele o adiciona ao nonWildcardsconjunto.
• Ele verifica se o comprimento do segmento é maior que 1 ( j > i) e se o número de caracteres não curinga exclusivos no segmento é no máximo 1 ( nonWildcards.count <= 1).
• Se ambas as condições forem verdadeiras, ele incrementa o boringSegmentCount.

O principal problema com esse algoritmo é sua complexidade de tempo quadrática, O(n²), portanto, para valores grandes de n(até 1.000.000, conforme declarado no problema), esse algoritmo pode ser muito lento e levar a um erro de limite de tempo excedido.

Minha pergunta

É possível propor um algoritmo com assintóticas mais baixas para esta tarefa? Suponho que seja possível resolver este problema em tempo linear, mas, para minha vergonha, ainda não consegui encontrar uma lógica adequada.

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.

Encontrei uma ocorrência estranha ao trabalhar com Ngrx Store e Angular. Basicamente, o objetivo da minha tarefa é mostrado neste exemplo com cerca de 10 mil entradas em Person[]:

Meu objetivo é mostrar certas pessoas com sobrenomes específicos. Esta é a primeira revisão que fiz, que é bem lenta:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => citizensState.people ?? []
);

export const selectPeopleWithSurname = createSelector(
  selectPerson,
  selectSelectedSurnames,
  (people: Person[], surnames: string[]) => {
    if (surnames.length === 0) {
      return people;
    }
    return people.filter((person) => surnames.includes(person.surname));
  }
);

Eu criei isso por acidente e é muito mais rápido que o código acima:

export const selectPerson = createSelector(
  selectCitizensState,
  (citizensState: CitizensState): Person[] => [...(citizensState.people ?? [])]
);

Por que isso acontece? Estou apenas criando uma cópia superficial da propriedade store. Imagino que tenha algo a ver com a detecção de alterações do Ngrx ou algo assim, mas não tenho certeza.

Então, tenho feito alguns projetos de aprendizagem em C e estou começando a ficar mais confortável com ponteiros. No entanto, me deparei com alguns fenômenos sobre os quais não consigo encontrar muitas informações.

Basicamente, eu crio um array, para simplificar, estou começando com um array de inteiros:

int x[2] = {1, 3};

Agora, se eu quiser modificar o conteúdo deste array, descobri que posso criar uma função que recebe um ponteiro inteiro como parâmetro, passa xcomo argumento e desreferencia xespecificando um índice.

#include <stdio.h>

void foo(int* input){
    input[0] = 2;
    input[1] = 4;
}

int main(){
    int x[2] = {1, 3};
    printf("x[0] before: %d\nx[1] before: %d\n", x[0], x[1]);
    foo(x);
    printf("x[0] after: %d\nx[1] after: %d\n", x[0], x[1]);
}

saída

x[0] before: 1
x[1] before: 3
x[0] after: 2
x[1] after: 4

o que é interessante, mas não vejo isso sendo feito com frequência, então não tenho certeza se é aceitável.

Agora, para a questão maior, por algum motivo, sempre que quero alterar o endereço para o qual o próprio ponteiro aponta, especificando um novo valor e ponteiro e, em seguida, definindo o argumento para esse novo ponteiro, isso só parece funcionar quando eu faço o seguinte:

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

void foo(int** input){
    int x[3] = {2, 4};
    int** ptr = x;
    *input = *ptr;
}

int main(){

    int x[2];
    x[0] = 1;
    x[1] = 3;
    printf("x[0] before: %d\n", x[0]);
    printf("x[1] before: %d\n", x[1]);
    foo(x);
    printf("x[0] after: %d\n", x[0]);
    printf("x[1] after: %d\n", x[1]);

    return 0;
}

Saída:

x[0] before: 1
x[1] before: 3
x[0] after: 2
x[1] after: 4

Então, tenho várias perguntas para as quais não consigo encontrar uma resposta, provavelmente devido à minha falta de vocabulário técnico:

1: Sempre que passo o array com e sem referência como argumento, por que o argumento se comporta como um array de ponteiros, sem inicializar um array de ponteiros e defini-lo primeiro para o endereço do array? Há alguma consequência não intencional em fazer isso?

2: Se o argumento for um ponteiro, em vez de um ponteiro para um ponteiro, é aceitável passar um ponteiro como argumento para uma função que recebe um ponteiro duplo como parâmetro, como eu fiz? Existe algum comportamento indefinido ao fazer isso que eu deva saber?

3: Por que isso funciona?

Estou aprendendo Go e agora cheguei ao ponto de estudar arrays e slices. Estou me referindo a Effective Go e A Tour of Go nesta questão. Tenho algumas dúvidas na formulação da capacidade do slice. Veja os comentários no código abaixo.

package main

import "fmt"

func main() {

    // let's say I need to implement 5x5 picture with 2D slice
    // and I have two ways to do that in acc. with
    // https://go.dev/doc/effective_go#two_dimensional_slices

    // that said:
    // 1. six slices - six underlying arrays
    picture := make([][]uint8, 5)
    for i := range picture {
        picture[i] = make([]uint8, 5)
    }

    // 2. six slices - two* underlying arrays
    // *I THOUGHT the efficiency is hiding in number of arrays
    picture = make([][]uint8, 5)
    pixels := make([]uint8, 25)
    for i := range picture {
        // every iteration pixels[5:] allocates new array...
        picture[i], pixels = pixels[:5], pixels[5:]
        // ...but in the new iteration it's deleted
        // leaving slice of initial pixels array in picture[i]...
    }
    // ...and here we have only two arrays...
    // ...         ^^^ B5t ^^^

    // there are six arrays anyway
    // but their capacity is 5 for picture and
    // 25, 20...5 respectively for its contents
    fmt.Print(cap(picture), " ")
    for i := range picture {
        fmt.Print(cap(picture[i]), " ")
    }
    fmt.Println()
    // if you don't understand let me explain my position
    // capacity is characteristic of underlying array rather than
    // of slice itself

    // in acc. with https://go.dev/tour/moretypes/11
    // "The capacity of a slice is the number of
    // elements in the underlying array..."

    // I believe that capacity of array is immutable one and
    // one array cannot have different cap's at the same time

    picture = make([][]uint8, 5)
    for i := range picture {
        picture[i] = make([]uint8, 5)
    }

    // here we have six arrays but capacity of each is 5
    // so the first solution works efficiently than second one
    //                  I believe
    fmt.Print(cap(picture), " ")
    for i := range picture {
        fmt.Print(cap(picture[i]), " ")
    }
    fmt.Println()

}

A saída deste código é:

5 25 20 15 10 5 
5 5 5 5 5 5 

Alguém pode me explicar onde está escondida a eficiência de usar um método de alocação?

Vejo muitas perguntas e respostas sobre como converter uma matriz de bytes em string, mas meu caso é bem diferente e não consigo encontrar uma maneira de fazer o que preciso.

Eu gero um conjunto de resultados de uma determinada API e o coloco em uma variável $jobandtasklist

Em seguida, escolho as propriedades que desejo e exporto para um arquivo csv

$jobandtasklist | select Group, Name, Active, Taskname, ExitCodeResult, DatelastExecution, Description, TaskStdOutput, TaskErrOutput | Export-Csv c:\temp\ErrorReport.csv

Em seguida, importo o arquivo csv

$csvresults = Import-Csv -Path 'C:\temp\ErrorReport.csv' 

TaskStdOutput e TaskErrOutput têm valores semelhantes aos abaixo

69 120 99 101 112 116 105 111 110 32 105 110 32 84 97 115 107 58 32 78 111 32 102 105 108 101 40 115 41 32 102 111 117 110 100

Quero que esses valores de bytes sejam convertidos em seus equivalentes em string (gostaria que a saída fosse legível aos olhos humanos, basicamente)

Eu tento o seguinte

foreach ($result in $csvresults) {
    If ($result.TaskStdOutput -gt 1 ) {
        $result.TaskstdOutput = [System.Text.Encoding]::UTF8.GetString($result.TaskStdOutput)

        }

        else {
        
        if ($result.TaskErroutput -gt 1) {

        $result.TaskErrOutput = [System.Text.Encoding]::UTF8.GetString($result.TaskErrOutput)
    } } }

mas gera o erro abaixo

Não é possível converter o argumento "bytes", com o valor: "92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 46 120 109 108 32 62 32 92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 50 48 49 55 48 54 48 57 49 54 49 55 46 120 109 108", para "GetString" digitar "System.Byte[]": "Não é possível converter o valor "92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 46 120 109 108 32 62 32 92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 50 48 49 55 48 54 48 57 49 54 49 55 46 120 109 108" para digitar "System.Byte[]". Erro: "Não é possível converter o valor "92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 46 120 109 108 32 62 32 92 92 80 65 82 70 79 82 65 80 48 48 50 92 97 112 120 36 92 120 109 108 92 114 101 113 117 101 115 116 50 48 49 55 48 54 48 57 49 54 49 55 46 120 109 108" para digitar "System.Byte". Erro: "A sequência de caracteres de entrada não estava no formato correto."

O que estou fazendo errado aqui?

Por exemplo, usar [System.Text.Encoding]::UTF8.GetString($jobandtasklist.TaskErrOutput) retornará todos os valores de bytes como string, como eu quero, mas isso é inútil para mim, pois preciso que eles sejam convertidos por resultado para que tenham algum significado (sejam associados ao trabalho específico, por exemplo) em vez de todos os TaskStdOutput e TaskErrOutput combinados em um único blob gigante.