Essayes le code suivant :

****

Dim Arrondie as Currency
Arrondie = Round(Valeur, NbDecimal)

****

Valeur = valeur à arrondir (tu peux passer un currency)
NbDecimal = nombre de décimales que l'on souhaite conserver
Arrondie = valeur arrondie

Cette fonction VB correspont-elle à ce que tu veux faire ?

Quand on confond 'palindrome' et 'anagramme' on n'a de conseil à donner à personne.

De plus, on trouve plusieurs définition d'un 'mot' : cela peut aussi être  "un ensemble de caractères séparés par deux blancs".

Il y a 4 fautes dans ta dernières phrases. Je comprends pourquoi tu chérie tant ton dictionnaire. Tu ferais bien de l'ouvrir plus souvent.

Tout "mot" obtenu par le mélange des lettres d'un mot est, par définition, un anagramme de ce mot.

Rien ne précise que le mot doit avoir une signification, ni dans cette définition, ni dans la tienne.

Donc trouver tous les anagrammes d'un mot revient à chercher toutes les combinaisons des lettres de ce mot.

Et tant bien même, l'algorithme était donné à titre indicatif, car ceux présents en vb.net ou autres langages sur ce site, sont beaucoup plus longs.

Il est clair pour tout le monde (sauf toi), qu'en quelques lignes, on ne peux prétendre donner des mots du dictionnaire... :) j'en ris encore

Un programme d'anagramme comme celui-ci peut servir à combiner autre chose que des lettres pour former des mots. Mais cela doit être trop subtil pour toi.

A part cela, mon français va bien merci.

Quand tu t'achéteras 'framework pour les nuls' profites-en pour prendre aussi 'réfléchir pour les nuls'. Ils font peut-être des prix de gros... nul.

Array.Reverse     inverse le tableau de <char>, mais ne calcule pas  tous les anagrammes du tableau.

anagrammes d'un mot != inverse d'un mot

Tu ferais bien de réviser ton framework 'gratuit' avant de venir critiquer, ou d'en acheter un à ta porté (puis-je te suggérer 'framework pour les nuls' ?)

using System.Console;
static void Main(string[] args)
{
   WriteLine((ReadLine()=="bonjour")?"C'est ok":"Faux!");
}

Encore + court !

l'antislash n'est pas passé : faut lire

n mod x = n - x * (n <division entière> x)

n mod x = n - x *  (n  x)

Pour travailler sur des grands nombres, il vaudrait mieux conserver ceux-ci en binaires dans des tableux d'integer, et d'ecrire une fonction ToString() pour pouvoir les afficher correctment. Ou alors, conserver 1 digit par indice, ce qui eviterait tous ces appels à left, right, ou mid qui prennent enormement de temps cpu.

J'ai jeté un coup d'oeil rapide sur les sources :

j'ai vu plusieurs points non exaustifs qui pourrait être améliorés :

1: pourquoi quand tu testes si un coup est valable, tu copies la grille completement et retourne reellement les pions, et en plus dans toutes les directions ! Regarde juste si dans au moins une direction, tu as des pions adverses suivi d'un de tes pions, et return vrai dans ce cas directement. Sans dupliquer quoi que ce soit d'ailleur.

2: Utilises plutot un tableau à une dimension (rapidité d'accès) pour stocker ton plateau de jeu. Ensuite, pour te déplacer dans une direction, additionne seulement la valeur de la direction. Entoure ton plateau d'une case supplementaire que tu initialisera à -1 pour indiquer que tu as atteint le bord. Tu peux même encore optimiser en utilisant un tableau de 91 case comme ci-dessous (x=-1, o=0 case vide):
xxxxxxxxx  indices 0,1,2,3,4,...8
xoooooooo  indices 9,10,11,...
xoooooooo
xoooooooo
xoooooooo
xoooooooo
xoooooooo
xoooooooo
xoooooooo
xxxxxxxxxx indices ...90,91

ensuite tu peux avoir un tableau de DIRECTIONS = {1,-1,8,9,10,-8,-9,-10}

void deplace(Pos& pos,int direction) // devient alors :
{ Pos+=DIRECTIONS[direction]; }

3: une dernière chose : à Othello le critère principal d'une fonction d'évaluation du jeu, en début et milieu de partie, c'est la mobilité (nombre de coups jouables), et faire en sorte d'éviter de donner un coin (le pgm ne voit pas assez loin pour savoir que c'est vraiment pas bon.). La mobilité et souvent inversement proportionnel au nombre de pions : moins tu as de pions mieux c'est ! ce n'est que quand il rest une vingtaine de coups à jouer qu'il faut optimiser son nombre de pions.
Si tu veux que ton programme soit vraiment bon, il faut utiliser l'algorithme minimax/alpha-bêta avec d'autres optimisation comme a recherche incrémental, la poursuite heuristique, les coups meurtriers, jouer sur les bornes alpha et bêta en utilisant des heuristiques... etc etc la littérature informatique foisonne d'exemples.
Déjà renseigne toi sur minimax et alpha bêta : et ton programme jouera comme un dieux : il sera imbatable par 99% des joueurs d'othello.
Il est vrai qu'utiliser un tableau à une dimension pour optimiser, n'a d'intérêt que dans le cas d'une recherche arborescente de type minimax. Cela permet de voir encore plus loin ! mais dans ton cas aujourd'hui, c'est inutile :)   Bonne continuation.

Pour trouver tous les nombres premiers de 1 à N, il y a un algorithme tres simple et tres rapide :

list.clear
redim T(1 to N) as boolean
for i=2 to N2
  for j=i+i to N step i :   t(j)=true   :  next j
next i
for i=2 to N
  if not t(i) list.add i
next i

plus rapide : pas possible !
Par contre, il faut connaitre au depart la borne maxi.

Il existe aussi une formule mathématique qui donne tous les nombres premiers les uns derrières les autres. f(x) = Xeme nombre premier. Mais elle est très complexe. Par contre, elle ne necessite pas de connaitre la borne maxi.