Réflexions sur l'implémentation des fonctions du programme et la sélection de code en C#

Je ne suis exposé au langage C# que depuis quelques jours. Si je souhaite écrire un article de recherche approfondi de haut niveau, il est probablement plein de conjectures et de quelques déductions illogiques. Jusqu'à présent, à partir de la connaissance d'introduction du langage (la cérémonie d'entrée de la plupart des programmeurs produisant "Bonjour tout le monde!"), les données et les types de données, les opérations sur les données, les processus et boucles de mise en œuvre des fonctions du programme, les tableaux et les ensembles, ceux-ci sont divisés en Du petit niveau de connaissances à l'application des connaissances apprises en série, je n'ai pas eu à supporter trop de difficultés, comme utiliser un langage descriptif pour résoudre des problèmes d'application, puis exprimer ces déclarations descriptives à travers du code.

　Je me souviens avoir posé trois questions intéressantes au début du cours. La première question concerne le propriétaire qui transporte de l'herbe, des moutons et des loups à travers la rivière. Les loups mangent les moutons et les moutons mangent de l'herbe. Rien ne se passera si le propriétaire prend soin de la situation. Il ne peut transporter qu'une seule chose à travers la rivière. d'ailleurs, observer si les élèves ont une idée claire pour analyser et répondre aux problèmes, et trouver le point clé selon lequel les moutons ne peuvent exister que seuls ou avec leurs propriétaires, afin que le problème puisse être bien résolu. La deuxième question concerne trois moines et trois monstres traversant la rivière. Il n'y a qu'un seul bateau vide. Le bateau peut transporter deux personnes à la fois. Chaque fois que le nombre de monstres est supérieur au nombre de moines, le jeu est terminé. La question est également un test sur la manière de réfléchir au problème, mais nous devons également prêter attention à l'exactitude du processus de transport des monstres et des moines. Nous devons d'abord nous assurer que tous les moines atteignent l'autre côté en toute sécurité et résoudre le problème aux alentours. ce centre. La troisième question m'a laissé une profonde impression. Après l'avoir terminée, le camarade de classe à côté de moi a dit que cela pouvait prendre 27 secondes, puis j'ai essayé encore et encore (cela ne pouvait prendre que 29 secondes). L'exigence est d'utiliser une lumière qui ne peut briller que pendant 30 secondes pour guider 5 personnes à travers le pont. Seules deux personnes peuvent passer avec la lumière à la fois. Le temps requis pour les 5 personnes est de 1 s, 3 s, 6 s, 8 s. et 12 ans. Bien sûr, cette question doit être comprise. Le point clé est d'essayer d'utiliser l'enfant 1 pour faire fonctionner la lumière dans la direction opposée, et le vieil homme 12 ans et le gros homme 8 ans doivent être dépassés en un seul voyage. tentatives, j'ai découvert que tant que l'enfant 1s revient deux fois, l'enfant 3s revient une fois. En un seul passage, les deux chiffres qui prennent le plus de temps sont transmis en même temps. Quelle que soit la manière dont les autres paramètres de tri sont définis, cela ne le sera pas. affecter le résultat final.

En repensant à cette cérémonie d'ouverture significative et en revenant au monde de C#, en fait, les deux ont beaucoup en commun, écrivons maintenant le même effet d'implémentation de différents codes. chose!

---

Résolvez la valeur de chaque chiffre Le code donné dans la réponse est le suivant :

int i = 100;while (i < 1000)
{    int a = i / 100 % 10;    int b = i / 10 % 10;    int c = i % 10;    if (a * a * a + b * b * b + c * c * c == i)
    {
        Console.WriteLine(i);
    }
    i++;
}

J'ai utilisé deux méthodes différentes pour répondre. La première est :

int i = 100;while (i < 1000)
{    int a = i /100;    int b = i % 10 / 10;    int c = i % 10;    if (a * a * a + b * b * b + c * c * c == i)
    {
        Console.WriteLine(i);
    }
    i++;
}

La deuxième méthode est :

int i = 100;while (i < 1000)
{    int a = i / 100;    int b = (i  - a * 100) / 10;    int c = i -a * 100 - b * 10;    if (a * a * a + b * b * b + c * c * c == i)
    {
        Console.WriteLine(i);
    }
    i++;
}

Tous les éléments ci-dessus sont corrects et réalisables. La raison pour laquelle les codes sont différents est qu'ils ont des perspectives différentes sur l'analyse des problèmes et la réflexion pendant le fonctionnement. La première consiste à supprimer le contenu après le nombre de chiffres recherché, puis à porter le reste du nombre à 10, car le chiffre des unités du nombre restant après excision correspond toujours à la valeur des chiffres recherchés. La deuxième méthode consiste à diviser le nombre, à trouver le reste du nombre qui est un multiple de 10 du nombre de chiffres recherché et à éliminer tous les nombres précédant le nombre de chiffres recherché. Le premier chiffre obtenu est toujours le nombre de chiffres. valeur recherchée, puis utilisez la division pour obtenir la valeur souhaitée. La troisième méthode est une impasse, il suffit de couper tout excédent puis de l'éliminer. Dans l'ensemble, différentes idées et méthodes de résolution de problèmes n'affecteront pas la mise en œuvre du code, mais choisir un code court et élégant peut améliorer la beauté de l'ensemble du code, ce qui doit encore être noté. En ce qui concerne mes propres connaissances, je dois donner la priorité au choix de codes que je peux comprendre, afin de pouvoir les utiliser facilement. En même temps, je dois élargir mes connaissances et réfléchir davantage à la manière de mettre en œuvre différentes idées.

---

Cependant, à ce stade, certaines personnes peuvent se demander si ce qui précède est un problème mathématique et ce que cela a à voir avec l'idée de codage. Jetons ensuite un coup d'œil aux idées d'implémentation qui sont différentes entre moi et les autres. Ce problème concerne la création d'un tableau et l'attribution de valeurs

permet à l'utilisateur de saisir un nombre à trouver et de déterminer si le nombre existe. dans le tableau.

int[] nums = { 4, 8, 12, 333, -9, 1 };bool isFind = false;for (int i = 0; i < nums.Length; i++)
{    if (nums[i] == n)
    {
        isFind = true;        break;
    }
}if (isFind)
{
    Console.WriteLine("数组中存在该数");
}else{
    Console.WriteLine("数组中不存在该数");
}

La façon dont j'y pense est la suivante :

int[] nums = { 4, 8, 12, 333, -9, 1 };
Console.Write("请输入需要查找的数字：");int input2 = int.Parse(Console.ReadLine());for (int i = 0; i < 5; i++)
 {   if (nums[i] == input2)
       Console.WriteLine("在数组中查找到该数值，该数为数组中的第" + (i + 1) + "项！");   if(i==4&&nums[i]!=input2)
       Console.WriteLine("未在数组中找到对应项！");
 }

 

　　第一种代码是通过定义一个bool类型数据isFind，如果找到，就改变isFind的数据，然后通过isFind的数据完成实现。而我在思考时，是想如果没有找到，那么循环完成后循环次数就会达到最大值，但是此时最后一位数与输入的数相同，两个输出对应条件都能满足，所以，排查到最后并且最后一位的值也不等，才能满足输出未找到结果。通过这样的分析，就写出了这两段代码。这就是不同思路采用不同代码来实现相同功能的方式。

---

 

　　关于不同代码实现相同功能，还有一个最经典的例子，是不能不提的，那就是数组和集合的排序，下面介绍三种思路：交换排序、冒泡排序和选择排序。

　　交换排序中心思想是从第一个数组项开始，固定nums[i]，依次第i+1个后面的数据进行比较，如果有比num[i]小的值，就对其进行交换。

for( int i = 0; i < arrays.Length - 1;  i++)
{    for(int  j = i+1; j < arrays.Length; j++)
   {       if(arrays[i]>arrays[j])
         {             int temp=arrays[i];
             arrays[i]=arrays[j];
             arrays[j]=temp;
         }
   }
}

 

　　冒泡排序是将最大的数沉到底部，先将最后一个位置固定，再从第一个数开始比较，每遇到一个大的数，这个数就与后一位交换，就像气泡一样，这个变动的寻找中的值越滚越大，直到最后一位。这时，再确定倒数第二位，再次进行替换。（第二个for循环中，每次循环，nums[j]的值总是逐渐变大。）实现代码如下：

 

for(int i = nums.Length - 1; i > 0; i--)
{    for(int j = 0; j < i; j++)
    {        if( nums[j] > nums[j+1] )
            {               int temp = nums[j];
               nums[j] = nums[j+1];
               nums[j+1] = temp;
            }
   }
}

 

　　选择排序从第一个数开始，先假设第一个数为最小的数，将其与后面每一个数进行比较，如果遇到小的，就记录这个数的下标，循环完成后，记录的下标对应的数一定是数据组的最小值，此时替换最小值到第一位。后面依次循环，完成排序。

for(int i = 0; i < nums.Length - 1; i++)
{    int index = 1;    for(int j = i+1; j < nums.Length; j++)
     {        if(nums[j])<nums[index])
           {
                index=j;
           }
     }     int temp = nums[i];
     nums[i] = nums[index];
     nums[index] = temp;
}

　　有上面三种排序方法可以看出，只要能够实现功能，思路和代码并不重要。只要能找到解决问题的关键点，并围绕关键点弄懂解决问题的方法，根据方法确定流程，再完成代码的编写，这样想要达到功能的实现并不难。不过为了整个代码的便于查看和修改，在使用这些代码时，在能够理解代码书写的思路前提下，尽量使用结构优良，语句简洁的语句。当然，如果一些方法难以理解，最好还是使用自己理解的代码书写，便于自己完成查看和修改，如果必要，注释也是必不可少。

　　总而言之，多观察别人的思路，多看多想多开拓，总是没有坏处。毕竟是编程，难以理解或者使用不熟练，解决的方法还是多练多敲，没有其他的捷径。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!