Відео

Beh. Non so esattamente cosa consigliarti per il semplice motivo che a me funziona (ho riscritto il codice e pure quello che ho copiato e incollato dal tuo commento)

@@valerio_afk Ciao Una cosa che non ho detto che il batch risiedeva su un'altra partizione Dal momento che mi hai detto che te funziona, l'ho fatto partire da C: E va bene cicla e da l'esito del ping Per farlo funzionare da un'altra partizione mentre i comandi dir e echo continuano a funzionare cosi', ho visto che occorre cambiare il comando ping con %WINDIR%\System32\PING.EXE Tu sai il perche' ? Grazie

Ciao Lui ha detto che per android si usa java. Cio' non toglie che la medesima applicazione si possa scrivere anche in C++, vero ?

Non penso volesse fare un commentary 😅

@@carlodaroma questo è vero, però sarebbe stato interessante.

Dunque, l'ho reimplementato in python (per adattarlo all'interfaccia) seguento passo passo gli step e, una volta eseguito, una mia intuizione e' stata confermata: fa tanti confronti (nello stesso caso dei video ne fa poco piu' di 1400. Tuttavia, fa un numero di scambi decisamente molto basso: 186. Che non e' da sottovalutare. Secondo me si dovrebbe ragionare su come ridurre il numero di scambi.

@@valerio_afk questi confronti e scambi non solo strettamente necessari al sort ....} else { if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); } if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); } pivotLeft= cursorLeft;..... ma, nelle intenzioni, dovrebbero preservare i confronti fatti, progredire nell'ordinamento delle porzioni piccole e minimizzare gli scambi... forse si può limare qualche confronto ridondante... le porzioni da 2 e 3 elementi non credo che si possano ottimizzare di più

@@valerio_afk meno confronti ma molti più scambi.. non necessari (sullo stesso indice) (il case 1 interno è meglio e andrebbe sostituito nell'originale) async function cutSort(elements) { let stack = []; let pivotLeft; let pivotRight; let cursorLeft; let cursorRight; stack.push({left: 0, right: elements.length - 1}); while(stack.length){ const{left,right} = stack.shift(); switch(right-left) { case -1: case 0: break; case 1: if(getValue(left) > getValue(right)) await swap( left, right); break; case 2: cursorLeft = left + 1; if (getValue(left) > getValue(cursorLeft)){ if (getValue(left) > getValue(right)){ if (getValue(cursorLeft) > getValue(right)){ await swap( left, right); } } await swap( left, cursorLeft); } else { if (getValue(cursorLeft) > getValue(right)){ if (getValue(left) > getValue(right)){ await swap( left, right); } await swap( cursorLeft, right); } } break; default: if(getValue(left) > getValue(right)) await swap( left, right); pivotLeft = left; pivotRight = right; cursorLeft = left + 1; cursorRight = right - 1; doBreak = 0; do { while (getValue(pivotLeft) > getValue(cursorLeft)) cursorLeft++; while (getValue(cursorRight) > getValue(pivotRight)) cursorRight--; switch(cursorRight-cursorLeft) { case -1: await swap( pivotLeft, cursorRight); await swap( cursorLeft, pivotRight); cursorRight++; cursorLeft--; doBreak = 1; break; case 0: //if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); //} //if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); //} doBreak = 1; break; case 1: if (getValue(cursorLeft) > getValue(cursorRight)){ await swap(cursorLeft, cursorRight); if (getValue(pivotLeft) <= getValue(cursorLeft) && pivotLeft < cursorLeft-1){ cursorLeft--; } if (getValue(cursorRight) <= getValue(pivotRight) && cursorRight+1 < pivotRight){ cursorRight++; } } //if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); //} //if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); //} doBreak = 1; break; default: if (getValue(cursorLeft) > getValue(cursorRight)){ await swap(cursorLeft, cursorRight); } else { pivotLeft= cursorLeft; pivotRight = cursorRight; cursorLeft++; cursorRight--; } } if (doBreak === 1) break; } while (true) stack.push({left: left, right: cursorLeft--}); stack.push({left: cursorRight++, right: right}); } } }

@@valerio_afk ultima implementazione async function cutSort(elements) { let stack = []; let pivotLeft; let pivotRight; let cursorLeft; let cursorRight; let bitmap; stack.push({left: 0, right: elements.length - 1}); while(stack.length){ const{left,right} = stack.shift(); switch(right-left) { case -1: case 0: break; case 1: if(getValue(left) > getValue(right)) await swap( left, right); break; case 2: cursorLeft = left + 1; if (getValue(left) > getValue(cursorLeft)){ if (getValue(left) > getValue(right)){ if (getValue(cursorLeft) > getValue(right)){ await swap( left, right); } } await swap( left, cursorLeft); } else { if (getValue(cursorLeft) > getValue(right)){ if (getValue(left) > getValue(right)){ await swap(left, right); } await swap(cursorLeft, right); } } break; case 3: bitmap = 0; cursorLeft = left + 1; cursorRight = right - 1; if (getValue(left) > getValue(cursorLeft)) bitmap = 1; if (getValue(cursorLeft) > getValue(cursorRight)) bitmap += 2; if (getValue(cursorRight) > getValue(right)) bitmap += 4; switch(bitmap) { case 0: break; case 1: if (getValue(left) > getValue(right)) { await swap(left, cursorLeft); await swap(cursorLeft, cursorRight); await swap(cursorRight, right); } else if (getValue(left) > getValue(cursorRight)) { await swap(left, cursorLeft); await swap(cursorLeft, cursorRight); } else { await swap(left, cursorLeft); } break; case 2: await swap(cursorLeft, cursorRight); if (getValue(left) > getValue(cursorLeft)) { await swap(left, cursorLeft); } if (getValue(cursorRight) > getValue(right)) { await swap(cursorRight, right); } break; case 3: if (getValue(left) > getValue(right)) { await swap(left, right); await swap(left, cursorRight); if (getValue(cursorLeft) > getValue(cursorRight)) { await swap(cursorLeft, cursorRight); } } else { await swap(left, cursorRight); } break; case 4: if (getValue(left) > getValue(right)) { await swap(cursorRight, right); await swap(cursorLeft, cursorRight); await swap(left, cursorLeft); } else if (getValue(cursorLeft) > getValue(right)) { await swap(cursorRight, right); await swap(cursorLeft, cursorRight); } else { await swap(cursorRight, right); } break; case 5: if (getValue(left) > getValue(cursorRight)) { await swap(left, right); if (getValue(left) > getValue(cursorLeft)) { await swap(left, cursorLeft); if (getValue(cursorLeft) > getValue(cursorRight)) { await swap(cursorLeft, cursorRight); } } } else { await swap(cursorRight, right); if (getValue(cursorLeft) > getValue(cursorRight)) { await swap(left, cursorLeft); if (getValue(cursorLeft) > getValue(cursorRight)) { await swap(cursorLeft, cursorRight); } } else { await swap(left, cursorRight); } } break; case 6: if (getValue(left) > getValue(right)) { await swap(left, right); await swap(cursorLeft, right); if (getValue(cursorLeft) > getValue(cursorRight)) { await swap(cursorLeft, cursorRight); } } else { await swap(cursorLeft, right); } break; case 7: await swap(left, right); await swap(cursorLeft, cursorRight); break; } default: if(getValue(left) > getValue(right)) await swap( left, right); pivotLeft = left; pivotRight = right; cursorLeft = left + 1; cursorRight = right - 1; doBreak = 0; do { while (getValue(pivotLeft) > getValue(cursorLeft)) cursorLeft++; while (getValue(cursorRight) > getValue(pivotRight)) cursorRight--; switch(cursorRight-cursorLeft) { case -1: await swap( pivotLeft, cursorRight); await swap( cursorLeft, pivotRight); cursorRight++; cursorLeft--; doBreak = 1; break; case 0: if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); } if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); } doBreak = 1; break; case 1: if (getValue(cursorLeft) > getValue(cursorRight)){ await swap(cursorLeft, cursorRight); if (getValue(pivotLeft) <= getValue(cursorLeft) && pivotLeft < cursorLeft-1){ cursorLeft--; } if (getValue(cursorRight) <= getValue(pivotRight) && cursorRight+1 < pivotRight){ cursorRight++; } } if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); } if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); } doBreak = 1; break; default: if (getValue(cursorLeft) > getValue(cursorRight)){ await swap(cursorLeft, cursorRight); } else { if (pivotLeft < cursorLeft-1){ await swap( pivotLeft, cursorLeft-1); } if (cursorRight + 1< pivotRight){ await swap( cursorRight+1, pivotRight); } pivotLeft= cursorLeft; pivotRight = cursorRight; cursorLeft++; cursorRight--; } } if (doBreak === 1) break; } while (true) stack.push({left: left, right: cursorLeft--}); stack.push({left: cursorRight++, right: right}); } } }

La maggior parte dei linguaggi di programmazione (python incluso) sono self-hosted (en.wikipedia.org/wiki/Self-hosting_(compilers)) - a meno che abbia frainteso il tuo punto. PS.: non ricordo esattamente il punto del video a cui ti riferisci, molto probabilmente era dovuto al fatto che non mi piace BASIC.

@@valerio_afk Accetto il fatto che non ti piace BASIC. Ma devo chiarire il mio post: I linguaggi autocompilabili sono quei linguaggi dove i sorgenti di base sono scritti nel medesimo linguaggio spiego meglio: I sorgenti di C sono scritti in C I sorgenti di C++ sono scritti in C e C++ I sorgenti di Fortran sono scritti in Fortran I sorgenti di FreeBASIC sono scritti in FreeBASIC I sorgenti di VisualBASIC sono scritti in C++ I Sorgenti di Python sono scritti in C Tornando a Python ha una sola implementazione scritta in Python è si tratta del suo compilatore JIT PYPY che serve a ottimizzare il codice in memoria e compilarlo in codice macchina prima di eseguirlo ( Come fa PHP dalla versione 8 in poi ) I Compilatori JIT hanno il vantaggio che una volta caricato e compilato il programma questo ha prestazioni pari a un programma compilato ma deve essere volta per volta caricato e compilato.

Vai sereno. Guarda il canale di EttiAviation e vedrai che Ryanair non ha mai avuto incidenti fatali

Benché possa capire il tuo sentimento e potrei pure empatizzare, (turbo) pascal è stato il mio primissimo approccio alla programmazione. Non so neanche come si usi piu ma è grazie a lui se ho imparato 😅

@@valerio_afk Scusa ma io ho iniziato con Commodore 64 BASIC e poi ANSI C per passare a C++ e derivati come PHP, JAVA, Attualmente uso solo C, C++ e FreeBASIC perchè sono compatibili tra di loro le librerie che scrivo su FreeBASIC posso usarle su C++ e viceversa, Per risparmiare tempo molti sorgenti li aggiorno per i nuovi sistemi e via ecco che applicazioni vecchie di 20 anni riprendono a funzionare.

Io l'ho usato a scuola, bellino, ma un fastidio dover dichiarare le variabili prima di poterle usare!

@@Thebasicmaker Spiegami, escludendo i linguaggi interpretati, come Python, PHP e quelli ormai obsoleti quale non richiede la dichiarazione delle variabili ? In ogni caso, dichiarare una variabile offre 3 vantaggi e nessuno svantaggio: 1) Dichiarandoli sin dall'inizio sai cosa stai usando e se puoi riutilizzarlo. 2) Dare una tipologia di variabile significa ottimizzare l'esecuzione e la memoria necessaria. 3) Eviti il verificarsi di possibili BUG's in futuro. Esempio in C: int x = 9999999; char x[8] = { "9"."9"."9"."9"."9"."9"."9"."\0"}; nel primo caso la x è una variabile numerica è occupando 4 Byte è puo conservare un valore numerico superiore a 2 miliardi Nel secondo caso occupa 8 Byte e puoi inserire 7 caratteri di vario tipo o scrivere sotto forma di stringa un valore di 9 milioni 999 mila 999. I linguaggi interpretati invece sono fatti per scrivere piccoli script dove l'uso della memoria è irrilevante perchè nel dispositivo in questione abbonda, ma non è sempre così; infatti se tu volessi scrivere un programma che deve lavorare in un ambiente ristretto come i registri di un processore oltre a non avere la possibilità di eseguire un codice interpretato è indispensabile definire ogni variabile altrimenti sarebbe impossibile allocarle in uno spazio ridotto di memoria. In ogni caso ogni linguaggio ha la sua utilità e quelli facili non sono adatti a creare cose complesse.

Ma quello lo faccio sempre! In questo caso metto una playlist e non mi andava di mettere 6 o forse più miniature 😅

Enlighten me!

@@valerio_afk Furié, senza la r finale! 😉

Il francese non è il mio forte eheheh. La prima r di fourier tra l'altro andrebbe pronunciata alla francese (simbolo ipa ʁ) che io non so pronunciare. Quindi, è meglio per me italianizzare. Diverso sarebbe stato se fosse stato un nome inglese. In quel caso, avrei potuto fare certamente di meglio :P

Non so quante persone saranno in grado di scrivere e leggere regole di firewall con indirizzi del tipo "2001:db8:abcd:0012:ffff:ffff:ffff:ffff"

@@davidglc hai ragione! Anch'io ero un po' perplesso in merito poi qualche tempo fa realizzai in video su IPv6 e devo dirti che non é cosi complicato come sembra di primo acchito

Rfc 1631 (link in descrizione). Abstract: The two most compelling problems facing the IP Internet are IP address depletion and scaling in routing

@@valerio_afk Come ho scritto sopra "il NAT è stato creato per risolvere problemi di esaurimento degli indirizzi IPv4" per risolvere i problemi dell'esaurimento degli IPV4 (ovviamente pubblici) e per aumentare la sicurezza, ma non è un walk around

@@CrazyNet poco piu sotto nell abstact: This memo proposes another short-term solution, address reuse, that complements CIDR or even makes it unnecessary. Basterebbe leggere il link nella descrizione

@@valerio_afk capisco. Ma quello che dice nel link in descrizione in sostanza Il memo propone NAT come una soluzione di breve termine per affrontare il problema della scarsità di indirizzi IP, integrandosi con CIDR. Questa soluzione offre un modo per continuare a utilizzare gli indirizzi IP esistenti senza dover ricorrere a cambiamenti significativi nell'infrastruttura di rete esistente. Soluzione a breve termine non è un walk around. Considera che negli anni 90 internet non era proprio come lo conosci oggi e quando appunto in quegli anni fu creato il NAT (infatti il documento nel link è datato May 1994) non si immaginava neppure uno sviluppo cosi rapido della rete. Per quanto rigurda IPV6 è dagli inizi del 2000 che se ne parla e dopo 24 anni stiamo ancora a ipv4

no, non c'entra niente se hai o non hai il nat solitamente i siti che rilevano la posizione sono abbastanza accurati a patto che abiliti la localizazione

non esistono indirizzi IP a 48bit esistono a 32 o 128 Bit forse fai confusione con il MAC- Adrress che è di 48Bit

@@CrazyNet grazie per la gentile risposta

@@tinnybrinca8620 figurati! Prego

In che senso?

Lo dico da esperto di sistemi informatici con a casa una FTTH DSLite. Cosa vuol dire DSLite? Sostanzialmente che il supporto dual stack (IPv4+6) è limitato per la parte IPv4 al CGNAT, ossia condividi lo stesso IP pubblico anche con altre utenze e la tua connessione riceve un indirizzo privato nel blocco 100.64.0.0/10. Tutto bene fin quando non hai dispositivi ai quali accedere da fuori, con CGNAT puoi scordartelo. Se i tuoi dispositivi di domotica richiedono accesso esterno e non sono dual stack, hai bisogno della mappatura delle porte da IPv6. Puoi sottoscrivere un servizio per una piccola somma annua oppure fare da te affittando un piccolo server virtuale ed installandoci sopra un servizio reverse proxy o tunnel 6to4 (quest'ultima è anche la maniera in cui le reti IPv4 sono accessibili da IPv6). Questo oltre a sottoscrivere un servizio DNS dinamico nel caso l'operatore cambi il prefisso IPv6 ogni notte.

Si è un titolo leggermente clickbait..

L' indirizzo IPV4 pubblico può essere solo ed esclusivamente univoco. Da qualsiasi parte del mondo sei, se qualcuno digita il tuo indirizzo IPV4 pubblico arriva al tuo router. Più che altro, molti provider fanno CGNAT, cioè assegnano un IP al LORO router al quale poi collegano i router di vari utenti. Questo significa che NON ti forniscono un IP pubblico ma che usano un IP pubblico di loro proprietà per più utenti ed un sistema che smista e rigira i vari pacchetti ai vari utenti. Il sistema funziona discretamente bene per la navigazione internet..... per altri scopi più specifici (es, condivisione di files P2P, server WEB privati, NAS, server di stampa, telecamere e teleallarmi) potrebbe NON funzionare.

@@teslacoiler corretto

Mi aggiungo alla discussione per rispondere a @TheMatps. 3 secondi di ricerca su wikipedia: Carrier-grade NAT is often used for mitigating IPv4 address exhaustion - Ora spiegami come il titolo sia "leggermente clickbait"?

@@valerio_afk Provo a spiegarlo io: Che sia leggermente clickbait lo indica il sensazionalismo della notizia (che poi tanto nuova NON lo è affatto). Però è sostanzialmente tutto vero (anche se, forse, il problema è meno grave di quello che sembrerebbe). Diciamo che leggermente clickbait.... LEGGERISSIMAMENTE..... proprio veramente pochissimo, ma quell' 1% c'è. 🙂 Ad ogni modo NON sono affatto d'accordo sull' idea di forzare il cambiamento da parte dei governi..... forzare i cambiamenti NON è mai una scelta saggia, inoltre l' UE ha fatto già fin troppi disastri (e quella percentuale di votanti inferiore al 50% è un chiarissimo sintomo del problema!!!). Il sistema funziona quel tanto che basta così com'è...... e se funziona quel tanto che basta, NON toccarlo, sennò si guasta! L' unica cosa sulla quale eventualmente i governi dovrebbero fare qualcosa è LA TRASPARENZA DELLE OFFERTE perchè: Alcuni provider ti forniscono un IPV4 pubblico dinamico (la gran parte dei provider su linee fisse). Alcuni te lo forniscono statico (es, Dimensione, Tiscali....) Alcuni ti forniscono un IP privato con CGNAT (es, Fastweb e la gran parte dei provider su connessioni cellulari) Alcuni ti forniscono un IP privato IPV4 ed offrono in contemporanea anche il completo supporto IPV6 (es, Vodafone) Alcuni ti forniscono una linea IPV6 nativa con la possibilità di ottenere in prestito un IPV4 pubblico (es, SkyWiFi) Ed infine c'è pure chi fornisce una linea IPV6 nativa con supporto parziale IPV4 condiviso tra più utenze e porte suddivise (es, Iliad) C'è un enorme differenza tra quello che può fare e NON può fare una connessione rispetto ad un altra, eppure questo dettaglio NON è chiaramente ben visibile nelle offerte di nessuno dei providers!!!!!!!

è il meme anche dei sistemisti: Funziona? Non lo toccare!

Come dar loro torto? Vedere CrowdStrike :P

@@tonnonostromo2497 Esattamente, lavoro nel settore della sicurezza informatica dal 2002. Ogni volta che è necessario effettuare aggiornamenti di qualunque genere, qualche scaramanzia per evitare che qualche servizio non si riavii c'è sempre... Con la virtualizzazione oggi si è un po' più tranquilli di poter effettuare un ripristino alla situazione originaria in tempi molto brevi.

@@davidglc santo veeam 😇😇

@@giovannisardisco4541 NAT ci sarà sempre, introduce una funzione di sicurezza non indifferente, perché con NAT solo il router è esposto ad internet e basta il suo firewall per proteggere tutta la rete locale. Senza NAT ogni dispositivo avrà bisogno di un suo firewall e ogni software che userà internet potrà essere vulnerabile.