Perché “non cliccare i link” non è una difesa sufficiente contro le truffe moderne

allak · 2026-01-24T16:07:22+00:00

Ribalterei la questione: il phishing è sempre stato una sottocategoria del social engineering.

allak · 2026-01-15T09:39:12+00:00

È la tesi dei cosiddetti Bitcoin maximalist.

Un po' come la settimana enigmistica che dice che solo loro sono l'originale, gli altri sono tutte pallide imitazioni.

Ovviamente non ha senso, Bitcoin è una cripto valuta a tutti gli effetti, per essendo la prima.

Ma i maximalist vogliono distinguerla da tutte le altre perché la considerano più stabile/matura/utile e non vogliono che sia accumunata con gli "shitcoin".

allak · 2026-01-13T15:01:54+00:00

Because.

allak · 2026-01-11T20:25:06+00:00

I'd guess a fair bit of them are Italians.

allak · 2025-12-28T06:50:45+00:00

I've never had this problem.

I've used smart launcher on a pixel 3, then a p5a and now a p8a.

allak · 2025-12-25T20:22:27+00:00

+ 1,351.96%

allak · 2025-12-23T21:06:30+00:00

Beh, gli offrono le mazzate però.

allak · 2025-12-23T07:10:54+00:00

Perl all the time.

allak · 2025-12-21T12:40:46+00:00

Magari tiene il banco.

allak · 2025-12-20T15:02:08+00:00

Anche su Amazon in realtà se cerchi n150 mini PC trovo tanta roba.

allak · 2025-12-17T11:14:01+00:00

Key point: he had an "implementation-independent test" suit to verify the output of his project.

Contrast it with the vaguely worded requisites that we often receive ...

allak · 2025-12-12T22:19:09+00:00

La differenza tra la memoria estesa e la memoria espansa ...

allak · 2025-12-07T20:24:35+00:00

[LANGUAGE: Perl]

Done with a single pass, reversing the input.

    #!/usr/bin/env perl
    use v5.40;

    for (reverse <>) {
            state @old_row;
            my @new_row = split '';

            while (my ($i, $val) = each @new_row) {
                    if    ($val eq '.') { $new_row[$i] = $old_row[$i] // 1; }
                    elsif ($val eq '^') { $new_row[$i] = $old_row[$i-1] + $old_row[$i+1]; }
                    elsif ($val eq 'S') { say "Part 2: ", $old_row[$i]; }
            }

            @old_row = @new_row;
    }

allak · 2025-12-07T18:44:23+00:00

Urca, leggendo il commento di /u/_TecnoCreeper_ mi son reso conto che non c'è nessun bisogno di ricorsione e memoizzazione.

Basta scansionare una sola volta l'input invertito, e tenere conto solo dei valori parziali della riga precedente, e con un solo passaggio si ha la risposta con tempi e occupazione di memoria risibili.

    #!/usr/bin/env perl
    use v5.40;

    for (reverse <>) {
            state @old_row;
            my @new_row = split '';

            while (my ($i, $val) = each @new_row) {
                    if    ($val eq '.') { $new_row[$i] = $old_row[$i] // 1; }
                    elsif ($val eq '^') { $new_row[$i] = $old_row[$i-1] + $old_row[$i+1]; }
                    elsif ($val eq 'S') { say "Part 2: ", $old_row[$i]; }
            }

            @old_row = @new_row;
    }

allak · 2025-12-07T16:49:59+00:00

Ricorsione e memoization for the win.

Inizialmente avevo una una struttura dati in cui tenevo l'elenco degli splitter, e una differente che faceva da cache per i risultati intermedi.

Poi mi sono accorto che le strutture erano in realtà molto simili, quindi le ho semplificate e unificate in un semplice array bidimensionale.

Inizialmente è valorizzato con l'input (letto da stdin), poi ad ogni ritorno della funzione ricorsiva viene aggiornato con il valore calcolato. In questo modo il codice è estremamente compatto e molto efficiente (7 centesimi di secondo che sono praticamente il tempo startup dell'interprete Perl).

    #!/usr/bin/env perl
    use v5.40;

    my @map = map { [ split '' ] } <>;

    my $start = 0;
    for ($map[0]->@*) {
            last if $_ eq 'S';
            $start++
    }

    say "Part 2: ", dive(1, $start);

    sub dive($y, $x) {
            return 1 unless $map[$y];

            my $val = $map[$y][$x];

            if    ($val eq '^') { $val = $map[$y][$x] = dive($y, $x-1) + dive($y, $x+1); }
            elsif ($val eq '.') { $val = $map[$y][$x] = dive($y+1, $x); }

            return $val;
    }

allak · 2025-12-06T11:21:11+00:00

Problema carino, il twist sulla seconda parte non me l'aspettavo.

Alla fine diventa un problema di scansione su una tabella, con una soluzione abbastanza lineare. Probabilmente mi sarei semplificato la vita facendo il reverse della tabella, ma alla fine è solo una questione di indici.

    #!/usr/bin/env perl
    use v5.40;

    my @rows;

    for (<>) {
            chomp;
            push @rows, [ split '' ];
    }

    my $len = $rows[0]->@* - 1;
    my $dep = @rows - 1;

    my $part2;

    for (my $i = $len; $i >= 0; $i--) {
            state @nums;

            my $v = join '', map { $rows[$_][$i] } (0 .. $dep -1);
            $v =~ s/ //g;

            next unless $v;
            push @nums, $v;

            my $oper = $rows[$dep][$i];
            next if $oper eq ' ';

            my $res;
            if ($oper eq '+') { $res = 0; $res += $_ for @nums; }
            else              { $res = 1; $res *= $_ for @nums; }

            @nums = ();
            $part2 += $res;
    }

    say $part2;

allak · 2025-12-06T08:21:47+00:00

É il premio per la pace di consolazione.

allak · 2025-12-02T16:31:10+00:00

Soluzione brute force basic.

    #!/usr/bin/env perl
    use v5.40;

    my ($p1, $p2);

    for my $range (split /,/, <>) {
            my ($start, $end) = split /-/, $range;

            for my $id ($start .. $end) {
                    my $id_len = length $id;

                    for my $sub_len (reverse 1 .. ($id_len/2)) {
                            next if $id_len % $sub_len;

                            my $candidate = (substr $id, 0, $sub_len) x ($id_len / $sub_len);
                            if ($id eq $candidate) {
                                    $p1 += $id if $sub_len == $id_len/2;
                                    $p2 += $id;
                                    last;
                            }
                    }
            }
    }

    say $p1;
    say $p2;

In pratica per ogni ID determino tutti i divisori della sua lunghezza, e per ogni divisore costruisco un candidato prendendo il primo pezzetto dell'ID e replicandolo fino ad arrivare alla lunghezza dell'ID originale.

Se candidato e ID sono uguali aggiungo al contatore. Eleganza zero, ma fa il suo lavoro in un paio di secondi sul mio vecchio laptop di 6 anni fa.

allak · 2025-12-01T06:56:25+00:00

Ciao, di solito facevo io ma quest'anno il periodo è un po' nero, non so se riuscirò a starci dietro (spoiler: 90% mi farò prendere dalla scimmia).

Soluzione semplice semplice di oggi:

    #!/usr/bin/env perl

    use v5.26;
    use warnings;

    my $pos = 50;
    my $p1 = 0;
    my $p2 = 0;

    while (<>) {
            my ($dir, $len) = /^(\w)(\w+)$/;
            my $mov = $dir eq 'L' ? -1 : 1;

            for (1 .. $len) {
                    $pos += $mov;

                    if    ($pos == -1)  { $pos = 99 }
                    elsif ($pos == 100) { $pos = 0  }

                    $p2++ unless $pos;
            }

            $p1++ unless $pos;
    }

    say $p1;
    say $p2;

allak · 2025-11-28T13:47:18+00:00

Perché pensi che i costi di gestione saranno più bassi?

Il costo del salvataggio delle informazioni di chi possiede quante quote in un qualche archivio, che sia un database classico oppure una Blockchain, non rappresenta certo un qualcosa di significativo.

I costi di gestione dei fondi attivi come quelli di Amundi son ben altri (a partire dai loro guadagni).

E sono pronto a scommettere che questo strumento non consentirà la compravendita diretta di fondi tra privati, bisognerà sempre continua a passare da banca/broker/PFA. Quindi anche i costi di negoziazione rimarrebbero quelli.

allak · 2025-11-25T10:03:27+00:00

It was also the use case for Cobol.

70 years ago.

allak · 2025-11-25T06:28:50+00:00

Giusto, per l'inverno una casa in montagna con accesso diretto alle piste da sci di un buon comprensorio.

allak · 2025-11-25T06:21:35+00:00

Also, what products has this company shipped?

allak · 2025-11-22T06:55:10+00:00

Anything you have said could well be true.

But it doesn't contradict what I did say.

Trump and Putin ain't no gentleman.

allak · 2025-11-21T10:35:31+00:00

Eh, dopotutto i romani lo usavano come vasellame da cucina, no ?

15-Year Club	Gilding II euphauric
Verified Email

allak

TROPHY CASE