Gedanken zur Implementierung von Programmfunktionen und zur Codeauswahl in C#

Ich bin erst seit ein paar Tagen mit der Sprache C# vertraut. Wenn ich einen ausführlichen Forschungsartikel auf hohem Niveau schreiben möchte, es ist wahrscheinlich voller Vermutungen und einiger unlogischer Schlussfolgerungen. Bisher sind diese von den einführenden Kenntnissen der Sprache (die Eintrittszeremonie der meisten Programmierer – die Ausgabe von „Hallo Welt!“), Daten und Datentypen, Datenoperationen, Programmfunktionsimplementierungsprozessen und -schleifen, Arrays und Mengen unterteilt Vom kleinen Wissensstand bis zur serienmäßigen Anwendung des erlernten Wissens musste ich nicht allzu viele Schwierigkeiten ertragen, wie zum Beispiel die Verwendung einer beschreibenden Sprache zur Lösung von Anwendungsproblemen und das anschließende Ausdrücken dieser beschreibenden Aussagen durch Code.

　Ich erinnere mich, dass ich zu Beginn des Kurses drei interessante Fragen gestellt habe. Die erste Frage betrifft den Transport von Gras, Schafen und Wölfen über den Fluss. Die Wölfe fressen die Schafe und die Schafe fressen Gras. Es wird nichts passieren, wenn der Besitzer sich um die Situation kümmert. Er kann nur eines über den Fluss transportieren Diese Frage gibt mir das Gefühl, dass sie dazu dient, die Denkweise der Schüler zu leiten. Beobachten Sie übrigens, ob die Schüler eine klare Vorstellung von der Analyse und Beantwortung von Problemen haben, und finden Sie den entscheidenden Punkt, an dem Schafe nur alleine oder mit ihnen existieren können ihre Besitzer, damit das Problem gut gelöst werden kann. Bei der zweiten Frage geht es darum, dass drei Mönche und drei Monster den Fluss überqueren. Immer wenn die Anzahl der Monster größer ist als die Anzahl der Mönche, ist das Spiel zu Ende Die Frage ist auch ein Test, wie man über das Problem nachdenkt, aber wir müssen auch auf die Korrektheit des Transportprozesses von Monstern und Mönchen achten. Wir müssen sicherstellen, dass alle Mönche zuerst sicher die andere Seite erreichen und das Problem lösen dieses Zentrum. Die dritte Frage hinterließ bei mir einen tiefen Eindruck, als der Klassenkamerad neben mir sagte, es könne 27 Sekunden dauern, und dann versuchte ich es noch einmal (es konnte nur 29 Sekunden dauern). Die Anforderung besteht darin, ein Licht zu verwenden, das nur 30 Sekunden lang leuchten kann, um 5 Personen gleichzeitig über die Brücke zu führen. Die benötigte Zeit für die 5 Personen beträgt 1 s, 3 s, 6 s, 8 s. und 12er. Natürlich muss diese Frage verstanden werden. Der entscheidende Punkt besteht darin, zu versuchen, das 1er-Kind zu verwenden, um das Licht in die entgegengesetzte Richtung zu lenken, und der 12er-Alter und der 8er-Dicker müssen auf einmal überholt werden Bei Versuchen habe ich festgestellt, dass, solange das 1er-Kind zweimal zurückgegeben wird, das 3er-Kind einmal zurückgegeben wird. In einem Durchgang werden die beiden Ziffern, die die längste Zeit in Anspruch nehmen, auf einmal durchlaufen. Unabhängig davon, wie die anderen Sortiereinstellungen festgelegt sind, wird dies nicht der Fall sein Einfluss auf das Endergebnis haben.

Wenn wir auf diese bedeutungsvolle Eröffnungszeremonie zurückblicken und in die Welt von C# zurückkehren, haben die beiden tatsächlich viele Gemeinsamkeiten. Schreiben wir nun den gleichen Implementierungseffekt verschiedener Codes Ding!

---

Lösen Sie den Wert jeder Ziffer auf:

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++;
}

Ich habe bei der Beantwortung zwei verschiedene Methoden verwendet:

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++;
}

Die zweite Methode ist:

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++;
}

Alle oben genannten Punkte sind korrekt und erreichbar. Der Grund, warum die Codes unterschiedlich sind, liegt darin, dass sie unterschiedliche Perspektiven auf die Problemanalyse und das Denken während des Betriebs haben. Die erste besteht darin, den Inhalt nach der gesuchten Ziffernzahl zu verwerfen und dann den Rest der Zahl 10 zu nehmen, da die Einerstelle der verbleibenden Zahl nach dem Herausschneiden immer dem Wert der gesuchten Ziffernzahl entspricht. Die zweite Methode besteht ebenfalls darin, die Zahl zu teilen, den Rest der Zahl zu finden, der ein Vielfaches von 10 der gesuchten Ziffern ist, und alle Zahlen vor der gesuchten Ziffernzahl zu verwerfen. Die erste erhaltene Ziffer ist immer die Zahl von Stellen Sie den gesuchten Wert ein und verwenden Sie dann die Division, um den gewünschten Wert zu erhalten. Die dritte Methode ist eine Sackgasse: Schneiden Sie einfach den gesamten Überschuss ab und entfernen Sie ihn dann. Alles in allem haben unterschiedliche Ideen und Problemlösungsmethoden keinen Einfluss auf die Implementierung des Codes, aber die Wahl eines kurzen und eleganten Codes kann die Schönheit des gesamten Codes verbessern, was noch beachtet werden muss. Was meine eigenen Erkenntnisse betrifft, muss ich der Auswahl von Codes Vorrang geben, die ich verstehen kann, damit ich sie leicht verwenden kann. Gleichzeitig muss ich mein Wissen erweitern und mehr darüber nachdenken, wie ich verschiedene Ideen umsetzen kann.

---

Allerdings fragen sich einige Leute an dieser Stelle vielleicht, ob es sich bei dem oben Gesagten um eine mathematische Aufgabe handelt und was es mit der Idee von zu tun hat Codierung. Dann werfen wir einen Blick auf die unterschiedlichen Implementierungsideen zwischen mir und anderen. Bei diesem Problem geht es darum, ein Array zu erstellen und Werte zuzuweisen. ermöglicht es dem Benutzer, eine zu findende Nummer einzugeben und festzustellen, ob die Nummer vorhanden ist im Array.

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("数组中不存在该数");
}

Ich denke so darüber nach:

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;
}

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

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

Das obige ist der detaillierte Inhalt vonGedanken zur Implementierung von Programmfunktionen und zur Codeauswahl in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!