C# / VB.NET - da stringa a float e calcolo distanza punti su un piano cartesinano

Non avevi specificato il vincolo di poter usare solo i float, né avevi detto che si trattava di un esercizio scolastico (cosa che, come vedi, avevo comunque intuito). E, dato che il regolamento specifica che non si possono chiedere risoluzioni di esercizi, è lecito che io ti dia solo un'idea di come fare, senza entrare nel dettaglio.

Per quanto riguarda la prima domanda, sì, la conversione è implicita (tutte le conversioni sono implicite quando il tipo di assegnamento è diverso dal tipo restituito dall'espressione). Ovviamente se l'utente introduce una sequenza alfanumerica, il programma crasha, ma speriamo che non sia così crudele.

Per la seconda domanda... in realtà tu mi stai chiedendo l'algoritmo. Non è questione di VB.NET o C#, il problema è di fondo: non sai trovare l'algoritmo giusto. E, dato che questo è il fine principale degli esercizi, mi sembra di non commettere un torto verso di te se decido di non risponderti.

io nel regolamento non ho trovato scritto che non si può chiedere aiuto per un esercizio (se mi dici dove è scritto mi faresti un favore) e se non ci fosse scritto sei libero di non aiutarmi.
comunque l'esercizio è stato assegnato per casa da il prof. di laboratorio che abbiamo da poco e non sa cosa abbiamo fatto l'anno scorso e uno arriva a casa per fare l'esecizio con le idee un pò confuse perchè certe cose magari non ci sono state spiegate.
l'esercizio non è urgente però io ho chiesto aiuto qui perchè mi piace programmare e quando ho dei dubbi preferisco levarmeli subito senza dover aspettare di avere lezione con questo prof.
se non mi vuoi chiarire le idee tu (o non puoi per via del regolamento) avrò le idee chiare la prossima lezione.

ps:per la domanda delle combinazioni ho risolto oggi a scuola grazie al prof. di teoria.

Il regolamento per questa sezione lo ha scritto lui dubito che possa sbagliarsi...

ma io non ho chiesto nulla di pronto... ho semplicemente chiesto che ragionamento logico fare visto che in questo forum c'è tantissima gente che ha conoscenze di programmazione molto superiori di quelle che ho io che studio informatica da poco più di un anno...
anche perchè avessi avuto il codice sorgente pronto per il copia e incolla non avrei imparato niente e io mi sono iscritto a questo forum per imparare qualcosa da chi ha maggiori conoscenze delle mie.

il tuo ragionamento fila, peccato che non hai considerato l'assoluta semplicità dell'esercizio, riguardo al quale basta concentrarsi 10 minuti e si risolve da solo.

cmq le conversioni implicite sono il male, questo è il modo corretto di convertire una stringa in un float in C#:

string sStr = ...;

try {

    float fNum = float.parse(sStr);

    [...]

} catch(FormatException ex) {
    Console.WriteLine(" !> Formato numero non riconosciuto");
}

ringrazio nuovamenti chi si è interessato al mio problema... ma ora c'hanno cambiato la consegna del compito il vettore e del tipo della strutture con 2 campi di tipo int, uno per x e uno per y... non ho problemi nella logico del programma... ho finito il codice ma nel debug a volte mi trovo il valore "non un numero reale" nel vettore delle distanze...
per esempio da utente specifico che nello spazio ci devono essere 3 punti con le seguenti coordinate: (1,1) (2,2) (3,3).

mentre altre volte non mi viene considerata la parte di codice in cui voglio far visualizzare il contenuto del vettore che registra le distanze.
ecco il codice che ho sviluppato...sapere aiutarmi?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace punti_sul_piano_cartesiano
{
    class Program
    {
        //creo la struttura per il vettore
        struct coordinate
        {
            public int x;
            public int y;
        }
        static void Main(string[] args)
        {
            //imposto la lunghezza del vettore e il numero dei punti
            int n;
            Console.WriteLine("inserire il numero di punti presenti nel piano cartesiano");
            n = Convert.ToInt32(Console.ReadLine());

            //dichiaro la variabile contatore
            int k = 0;

            //dichiaro e carico il vettore
            coordinate[] punti = new coordinate[n];
            Console.WriteLine("Coordinate punti");
            for (k = 0; k < n; k++)
            {
                Console.WriteLine("Inserire la coordinata x del " + (k + 1) + "° punto");
                punti[k].x = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine("Inserire la coordinata y del " + (k + 1) + "° punto");
                punti[k].y = Convert.ToInt32(Console.ReadLine());
            }

            //calcolo la lunghezza del vettore delle distanza e il numero delle combinazioni dei punti presi 2 a 2
            int combinazioni;
            combinazioni = n * (n - 1) / 2;

            //dichiaro e carico il vettore delle distanze
            double[] distanze = new double[combinazioni];
            for (k = 0; k < combinazioni; k++)
            {
                int z;

                for (z = k+1; z < combinazioni; z++)
                {
                    if (punti[k].x == punti[z].x && punti[k].y == punti[z].y)
                    {
                        distanze[k] = 0;
                    }

                    if (punti[k].x != punti[z].x && punti[k].y == punti[z].y)
                    {
                        if (punti[k].x > punti[z].x)
                        {
                            distanze[k] = punti[k].x - punti[z].x;
                        }
                        else
                        {
                            distanze[k] = punti[z].x - punti[k].x;
                        }
                    }

                    if (punti[k].x == punti[z].x && punti[k].y != punti[z].y)
                    {
                        if (punti[k].y > punti[z].y)
                        {
                            distanze[k] = punti[k].y - punti[z].y;
                        }
                        else
                        {
                            distanze[k] = punti[z].y - punti[k].y;
                        }
                    }

                    if (punti[k].x != punti[z].x && punti[k].y != punti[z].y)
                    {
                        distanze[k] = Math.Sqrt(((punti[k].x - punti[z].x) ^ 2) + ((punti[k].y - punti[z].y) ^ 2));
                    }
                }
            }
            
            //visualizzo il contenuto del valore delle distanze
            Console.WriteLine("Distanze");
            for (k = 0; k < combinazioni; k++)
            {
                for (int z = k+1; z < combinazioni; z++)
                {
                    Console.WriteLine("La distanza dal punto " + (k + 1) + " al punto " + (z+1) + " è di " + distanze[k]);
                }
            }

            Console.ReadLine();

        }
    }
}

Non ho capito certe cose...

Se i punti li prendi a due a due, l'array delle distanze dovrebbe avere n-1 elementi, e non (n-1)*n/2 (che equivale alla somma degli interi da 1 a n-1). Infatti, quando n=4, le combinazioni sono 6, e tenti di accedere, ad esempio, a punti[5], che non esiste. Il fatto che non ti abbia dato errore indica che hai tentato con 3 o meno punti.

Inoltre, tutto il codice degli if, può essere ridotto a:
if ((punti[k].x == punti[z].x) || (punti[k].y == punti[z].y))
{
distanze[k] = Math.Abs(punti[k].x - punti[z].x) + Math.Abs(punti[k].y - punti[z].y);
}

Il valore NaN (not a number) deriva da operazioni come 0/0, radici di numeri negativi od operazioni con altri valori NaN. Credo sia il secondo caso.

Comunque dovresti aprire una nuova discussione per questo argomento, dato che è diverso dal post iniziale.

quando dici che l'array delle distanza dovrebbe avere n-1 elementi intendi n-1 celle?
perchè la formula del calcolo delle combinazioni di n elementi presi 2 a 2 è uguale a: n(n-1)/2... quindi considerando che il vettore delle distanze deve memorizzare tutte le combinazioni io ho creato un tot di celle pari a n+(n-1)/2.

per quanto riguarda il problema nel "non numero reale" cosa mi consigli di fare?... anche secondo me è dovuto al fatto dei numeri negativi

usando il tuo codice degli if mi da sempre 0
e poi sbaglio o ci vorrebbe comnque un' else con l'esecuzione del teorema di pitagora?