איך דארף א קאוד פאר...

למעשה האב איך פראבירט זוכן ווי אזוי דער קאמפיוטער טוהט מאלטיפליקעישן, זעה איך אז ער טוהט עס זייער גרינג, לאמיר נעמען די פריערדיגע דוגמא 8*9
קוק נאר:


כאפסט? ער דארף גארנישט טוהן, חוץ פון רוקן די אויבערשטע נומער יעדן מאל מיט איין ספעיס, און אויב די אינטערשטע דידזשיט איז 0 לאזט ער די גאנצע זאך 0, און אז עס איז 1, לאזט ער עס אזוי ווי עס איז. (פונקט אזוי ווי מיר טוהן אינעם דעסימאל בעיס, אבער אין ביינארי האט ער ממש א גרינגע ארבעט, ווייל עס איז נישטא עפעס אנדערש פון 0 אדער 1), און דערנאך מאכט ער אדדישן.
און ראה זה פלא, ער קומט אויס 1001000 (טשעקינג דורך די קאוד אויבן), איז עס טאקע 72.

פארוואס? האט געשריבן:

יאיר האט געשריבן:פארוואס?, יידל רעדט פון עפעס אנדערש. דוק ותשכח.

דוקתי ולא שכחתי.
ער רעדט פון צוזאמרעכענען די סומע פון אלע קלענערע נומערן קלענער פון n. עם איי מיסינג סאמטינג?

טעיתי, ס'איז טאקע ביידע די זעלבע חשבון. וה' הטוב יכפר בעדי.

דא:
m http://www.counton.org/timeline/test-ma ... carl-gauss m

א לופ איז טאקע נישט אזוי גוט דא, ווייל עס נעמט O(N) צייט. דהיינו ווי גרעסער די נאמבער אלס לענגער נעמט עס. משא״כ די פארמולא איז אין קאנסטענט טיים, דהיינו ס׳ווערט נישט ערגער מיט גרעסערע נאמבערס.

קול דודי האט געשריבן:דא:
http://www.counton.org/timeline/test-ma ... carl-gauss

א לופ איז טאקע נישט אזוי גוט דא, ווייל עס נעמט O(N) צייט. דהיינו ווי גרעסער די נאמבער אלס לענגער נעמט עס. משא״כ די פארמולא איז אין קאנסטענט טיים, דהיינו ס׳ווערט נישט ערגער מיט גרעסערע נאמבערס.

וואס מיינסטו צו זאגן. ווען n איז גרעסער, איז די מולטיפליקעישן פראסעס נישט גרעסער?

פארוואס? האט געשריבן:וואס מיינסטו צו זאגן. ווען n איז גרעסער, איז די מולטיפליקעישן פראסעס נישט גרעסער?

יא, די מאלטיפליקעישן איז אייביג די זעלבע (ווילאנג פארשטייט זיך ס׳גייט אריין אין א machine word.

געשריבן אין Java באזירט אויף קול דודי'ס סודאקאוד. טוישט דעסימעל צו סיי וואספארא בעיס, פון 2 ביז 20. (בעצם געקענט מאכן מער, פשוט נישט געזען קיין צורך). ארבעט נישט מיט נעגאטיוו נומערן.

קאוד: וועל אויס אלע

public static void main(String[] args)
{
      Scanner s = new Scanner(System.in);

      System.out.println("enter a number");
      int input = s.nextInt();
      System.out.println("enter the base");
      boolean repeat;
      do
      {
         int base = s.nextInt();
         repeat = false;
         if (base <2)
            {
               System.out.println("Enter a base greater than one");
               repeat = true;
            }
      }while (repeat);
         String result = "";
         while (input > 0)
         {
            int binary = input%base;
            String myResult;
            if (binary >= 10)
            {
               
               switch (binary)
               {
               case 10: myResult = "A";
               break;
               case 11: myResult = "B";
               break;
               case 12: myResult = "C";
               break;
               case 13: myResult = "D";
               break;
               case 14: myResult = "E";
                  break;
               case 15: myResult = "F";
               break;
               case 16: myResult = "H";
               break;
               case 17: myResult = "!";
               break;
               case 18: myResult = "J";
               break;
               case 19: myResult = "K";
               break;
               case 20: myResult = "L";
               break;
               default: myResult = "error";
               }
            }
               else myResult = Integer.toString(binary);
      
            result = result + myResult;
               input = input/base;
            }
            String finalResult = new StringBuilder(result).reverse().toString();
            System.out.println("In base "+ base +" it is: " +finalResult);

         
   }


איז מיר אויסגעקומען צו אויסארבעטן א קאוד צו מולטיפלייען צוויי מעטריסיס (matrices בלשונם הטמאה, מטריצות בלשונינו הטמאה (משורש ההיא מטריצותא)), און די טשאלענדזש איז געווען דאס צו טון דורך אריינשטעלן אין אן ארעי (array), און דערנאך לויפן א לופ (loop) וועלכע זאל דאס אויסרעכענען.

איך שטעל זיך פאר אז עס איז דא א הויפן אלגאריטמס אנליין וויאזוי דאס צו טון, כ'האב אבער געוואלט דאס אליינס טון, וזה מה שעלה בידי בעזרת צורי וקוני.

די הלכה איז אז צו מולטיפלייען צוויי מעטריסיס, מוזן די מאס columns אין מעטריקס א' זיין די זעלבע צאל ווי די rows אין מעטריקס ב'. אבער די rows אין מעטריקס א' און די columns און מעטריקס ב' קענען זיי סיי וועלכע צאל.
די סדר וויאזוי מ'מולטיפלייט צוויי מעטריסיס איז על פי סדר זה, והוא ע"פ סוד א"ת ב"ש: מען מולטיפלייט דעם נומער וועלכע געפונט זיך אין מעטריקס א' שורה 1 קאלום 1 ביי די נומער וועלכע געפונט זיך אין מעטריקס ב' שורה 1 קאלום 1, און דערנאך מולטיפלייט מען דעם נומער וועלכע געפונט זיך אין מעטריקס א' שורה 1 קאלום 2 ביי די נומער וועלכע געפונט זיך אין מעטריקס ב' שורה 2 קאלום 1, דערנאך מולטפילייט מען דעם נומערן וועלכע געפונט זיך אין מעטריקס א' שורה 1 קאלום 3 ביי די נומער וועלכע געפונט זיך אין מעטריקס ב' שורה 3 קאלום 1, וכן על זו הדרך לויט וויפיל נומער ס'דא. דערנאך איז מען מצרף די צוויי נומערן על דרך פלא"ס, און דאס לייגט מען אריין אין א פרישע מעטריקס אין שורה 1 קאלום 1. דערנאך חזר'ט מען איבער דעם פראצעדור, נאר אנשטאט אראפגיין שורה ביי שורה פון מעטריקס ב' קאלום 1, טוט מען דאס מיט מעטריקס ב' קאלום 2. און דערנאך עוה"פ די זעלבע פראעצדור מיט קאלום 3, וכן על זו הדרך, לויט וויפיל קאלומס ס'דא. איינמאל מען איז פערטיג מיט אלע קאלומס פון שורה 1 אין מעטריקס ב', הייבט זיך דער פראצעדור אן פון פריש, נאר דאסמאל מיט שורה 2 פון מעטריקס א.

איצטער לפי זה קען מען פארשטיי די קאוד דערצו, וכמו שאבאר:

צום ערשט דארף מען דערקלערן דריי צוויי דיימענשאנעל עררעיס. דערנאך מאכט מען דריי פאר-לופס, כל אחת בתוך חברתה (nested בלע"ז), נאר דער טריק איז וועלכע אינדעקס צו נוצן פאר וועלכע חלק. אי"ה מארגן וועל איך ארויפלייגן די קאוד זעלבסט.

קול דודי האט געשריבן:

chusid האט געשריבן:ווי האט עטץ ענק געלערנט קוידס? איז דאס א קאמפלאצירטע לימוד?

נישט זייער קאמפליצירט. הלא הם כתובים בספרי קאמפיוטער פראגרעמינג ואפשר להשיגם בניקל.

מיין קאמפיוטער טעקסט בוק האט געקאס א ביסל מער פון א ניקל. אפילו מער פון א קוואדער אויך...

ATUB @יידל ATUB דא האסטו אין javascript, א קורצע סקריפט (12 שורות), כאטש עס באציהט זיך נאר אויף א ספעציעלע קעיס, קען מען עס גרינג מאכן ארבעטן פאר יעדע קעיס.

קאוד: וועל אויס אלע

var matrix1 = [[7, 8], [9, 10], [11, 12]];
var matrix2 = [[1, 2, 3],[4, 5, 6]];
var result = [];
for(var i = 0; i < matrix1[0].length; i++){
   result[i] = [];
   for(var k = 0; k < matrix2.length; k++){
      result[i][k] = 0;
      for(var j = 0; j < matrix1.length; j++){
         result[i][k] += matrix2[i][j] * matrix1[j][k];
      }
   }
};

ברוך שכיוונתי. אט איז כמעט די זעלבע אין דזשאווא (נאר איין חילוק זע איך אז דו האסט פארן ערשטן loop גענוצט i=matrix1[0].length (דאס הייסט די קאלומס) און איך האב גענוצט די rows)

קאוד: וועל אויס אלע

public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Let's multiply matrices."
                + "\nPlease Enter the number of Rows for matrix A:");
        int rowsA = sc.nextInt();
        System.out.println("Next, enter the number of Columns for matrix A:");
        int columnsA = sc.nextInt();
        System.out.println("Now enter the number of rows for matrix B:");
        int rowsB = sc.nextInt();
        System.out.println("Finally, enter the number"
                + " of columns for matrix B:");
        int columnsB = sc.nextInt();
       
        if (columnsA != rowsB)
            System.out.println("Undefined. Columns of A has to be the same"
                    + " as rows of B.");
        else
        {
            double[][] matrixA = new double[rowsA][columnsA];
            double[][] matrixB = new double[rowsB][columnsB];
            double[][] matrixAB = new double[rowsA][columnsB];
           
            System.out.println("Matrix A:");
            for (int i = 0; i < matrixA.length; i++)
            {
                for (int j = 0; j < matrixA[i].length; j++)
                {
                    System.out.println("Row " + (i+1) +", Column" + (j+1) + ":");
                    matrixA[i][j] = sc.nextDouble();
                }
            }
            System.out.println("Matrix B:");
            for (int i = 0; i < matrixB.length; i++)
            {
                for (int j = 0; j < matrixB[i].length; j++)
                {
                    System.out.println("Row " + (i+1) +", Column" + (j+1) + ":");
                    matrixB[i][j] = sc.nextDouble();
                }
            }
           
            for (int i = 0; i < matrixA.length; i++)
            {
                for (int k = 0; k < matrixB[0].length; k++) //is matrixB[k] valid?
                {
                    for (int j = 0; j < matrixB.length; j++)
                    {
                      matrixAB[i][k] +=  matrixA[i][j]*matrixB[j][k];
                    }
                   
                }
            }
            System.out.println("Matrix A times matrix B equals:");
            for (int i = 0; i < matrixAB.length; i++)
            {
                for (int j = 0; j < matrixAB[i].length; j++)
                {
                    System.out.print("Row " + (i+1) +", Column " + (j+1) + ": ");
                    System.out.printf("% -10.2f\t", matrixAB[i][j]);
                }
                System.out.println("");
            }
       
        }
    }


פארוואס? האט געשריבן:למעשה האב איך פראבירט זוכן ווי אזוי דער קאמפיוטער טוהט מאלטיפליקעישן, זעה איך אז ער טוהט עס זייער גרינג, לאמיר נעמען די פריערדיגע דוגמא 8*9
קוק נאר:

קאוד: וועל אויס אלע

            1000  *
            1001
            ____
            1000
           0000
          0000
         1000
         _______
         1001000


דוכט זיך אז דאס איז בוטה'ס אלגאריטם פאר מולטיפליקעישאן אבער דאס ארבעט נאר אויב דער קאמפיוטער נוצט two's complement notation צו רעפרעזענטירן נומערן אין ביינערי. דוכט זיך אז היינט נוצט מען א מאדיפייד ווערסיע, אפשר קען ATUB @קול דודי ATUB מבאר זיין.

איך דארף ביטע א invitation code צו mobilevids.com ביטע וואס שנעלער

ווי אזוי קענען מיר נוצן די AND, OR און NOT לאגיקל אפערעיטערס צו געבן אלע זעכצן מעגליכע ביינארי-לאגיקעל קאמבינעישנס?

ATUB @יידל ATUB ATUB @קול דודי ATUB

יאיר האט געשריבן:איך מיין דער פארמולא דארף זיין 2/(99*100).
דער הסבר פון דער פארמולא איז ווי פאלגנד:
ביי יעדער הענדשעיק זענען דא צוויי מענטשן וואס נעמען אנטייל אין דעם שפיל, דער נותן און דער מקבל. יעצט, וויפיל סארט צוזאמענשטעלן פון הענדשעיקס קענען מיר מאכן אין א צימער פון הונדערט מענטשן? דאס צו ענטפערן דארפן מיר וויסן וויפיל נותנים קענען זיין און וויפיל מקבלים קענען זיין. נותנים קענען זיין הונדערט, ווייל אזויפיל מענטשן זענען דא און יעדער קען געבן א הענדשעיק. מקבלים קענען נאר זיין ניין און ניינציג, ווייל איינמאל איין מענטש ווערט א נותן בלייבט איבער 99 וואס קענען מקבל זיין. ממילא האבן מיר א סך הכל פון 9900 הענדשעיקס וואס קענען פארקומען אין דעם שטוב. אבער אזוי ווי מיר ווילן נישט אז די זעלבע צוויי מענטשן זאלן זיך איבערגעבן שלום עליכם, דארף מען צוטיילן דעם נומער אין צוויי, וואס איז דער ענדגילטיגער סך הכל.

דאס איז ווי א קאמפליט קאננעקטעד גראף. m https://en.wikipedia.org/wiki/Complete_graph m

אנדערש האב איך עס געזען אזוי: וויפיל ליינס אף אינטער-קאמיוניקעישן אויב ס'איז דא n דעוועלאופערס אין א צימער? ענטפער: n(n-1)/2

פארוואס דעווייד ביי צוויי? ווייל פאר יעדער מענטש פון זיי, פאר יעדע ליין אף קאמיוניקעישאן וואס ער באשאפט, איז ער אויך מבטל איינע פאר'ן חבר, ד.ה. איינמאל ער איז זיך מוציא, דהיינו איינמאל ער רעדט מיט עמיצן, דארף שוין דער חבר נישט רעדן מיט עמען.

און מיט זיך דארף ער דאך נישט רעדן, במילא איז עס - 1.

א פראגרעם וואס קאנווערט א דעסימעל יאר צווישן 1 און 3999 צו רוימישע נומעראלס.

קאוד: וועל אויס אלע

/** Roman Number system class **/
import java.util.Scanner;
  class Main
{
   
    public static void main(String[] args)
    {
        System.out.println("Please enter a decimal year, between 1 and 3999, that you wish to convert to roman numerals : ");
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        if ((n>=1)&&(n<=3999)){
        int year=n;
        String romanOnes=romanDigit(n % 10, "I", "V", "X");
        n=n/10;
        String romanTens=romanDigit(n % 10, "X", "L", "C");
        n=n/10;
        String romanHundreds=romanDigit(n % 10, "C", "D", "M");
        n=n/10; 
        String romanThousands=romanDigit(n % 10, "M", "M", "M"); //M can be repeated in all 3 since we've put a cap so that 4000 cannot be converted
        // output value returned from method
        System.out.println("Year " + year + " converted to Roman numerals is " + romanThousands+romanHundreds+romanTens+romanOnes);
    }                       
        else {
         System.out.println("The year that you've entered is either less than 1 or more than 3999");
         }
       
   
    }     
       
    public static String romanDigit(int n, String one, String five, String ten){

        String roman="";   
       
                if (n==1)
                    {roman+=one;}
                else if (n==2)
                    {roman+=one+one;}
                else if (n==3)
                    {roman+=one+one+one;}   
                else if (n==4)
                    {roman+=one+five;}
                else if (n==5)
                    {roman+=five;}
                else if (n==6)
                    {roman+=five+one;}
                else if (n==7)
                    {roman+=five+one+one;}
                else if (n==8)
                    {roman+=five+one+one+one;}
                else if(n==9)
                    {roman+=one+ten;}
                else; // if n==0, roman returns empty
                               
         return roman;
             
    }
}





די סימפלעסט python פראגרעם אויסצורעכענען פריים נומערן אונטער און אינקלודינג א גיווען אינפוט פון די יוזער.

קאוד: וועל אויס אלע

integer=int(input("Please enter an integer"))
while integer>0:
  i=2
  while i<integer and integer%i!=0:
    i=i+1
  if i==integer:
    print(integer, "is a prime")
  integer=integer-1

איך האב איך collection פון קאודס צי בלאקן עדס

אזוי ווי:
@@||29ccd.v.fwmrm.net

abc.com/advertisement.js

אויב איינער האט אזעלכע קאודס זאל עס ביטע ארויפלייגן

פרינטן פעקטארס פון א נומבער מיט א דוגמא פון 18.

קאוד: וועל אויס אלע

class Main
{
  public static void main(String[] args)
  {
    String s="1";
    int n=18;
    int i=2;
      while (i<=n)
      {
        if (n%i==0)
          s=s+" "+ i;
     
        i=i+1;
      }
     System.out.println("Result:" +s);
  }
}

געגיבן א סיקווענס פון אינטעדזשערס פלאצירט אין אן עררעי, דער פראגרעם געבט צוריק די אינדיווידועל וועליוס, די סכום פון די סך הכול, די סך הכול פון די אינטעדזשערס אין די odd צעלן - די סך הכול אינטעדזשערס אין די even צעלן און די עררעי רעווערסד.

קאוד: וועל אויס אלע

import java.util.Arrays;
import java.util.Scanner;

public class Main
  {
   
    public static void main(String[] args)
     {
    final int SIZE =5;
    int[] anArray = new int[SIZE];
    int arraySum_=0;
    Scanner scan = new Scanner(System.in);
    int input, result, alternateSum;
       for (int i=0; i<anArray.length; i++){
        System.out.print("Please enter integer " + (i+1)+":");
        input=scan.nextInt();
        anArray[i]=input;
       }//for ends
    String message="The values you have entered are ";
    printArrayElements(message, anArray);
     
     arraySum_=arraySum(anArray); 
    int[] Sum = new int[1];
    Sum[0]=arraySum_;
    message="The sum of the values you have entered is ";
    printArrayElements(message,Sum);
   
    message="The sum of the values in the odd indexes - those in the even indexes is ";
    Sum[0]=altSum(anArray);//reusing the array Sum and overriding what was stored there i.e. the sum of all inputs.
    printArrayElements(message,Sum);
   
    message="The values you have entered, in reverse order are";
    anArray=reverseArray(anArray);
    printArrayElements(message,anArray);

  }//first method(main) ends
   
   
  public static void printArrayElements(String message, int[] arrayToPrint){
       if (arrayToPrint.length>1){
           System.out.println(message + " "+ Arrays.toString(arrayToPrint));}
       else 
            System.out.println(message + " "+ arrayToPrint[0]);
       
    }//second method ends
   
    public static int arraySum(int[] incomingArray)
    {
      int total=0;
 
      int l= incomingArray.length;
        if (l>0)
        for (int i=0; i<incomingArray.length; i++){
             total=total+incomingArray[i];
             }

        return total;
             
  }//third method ends

  public static int altSum(int[] incomingArray){
      int evenTotal=0;
      int oddTotal=0;
      int l= incomingArray.length;
        if (l>=2){
            for (int i=1; i<=incomingArray.length; i+=2){
                if (i<incomingArray.length){
                    evenTotal=evenTotal+incomingArray[i];
                    oddTotal=oddTotal+incomingArray[i-1];}
                else{oddTotal=oddTotal+incomingArray[i-1];}
            }

        }
            else if (l<2)
                oddTotal=incomingArray[0];
      return oddTotal-evenTotal;//for ends   
     
       }//forth method ends
       
  public static int[] reverseArray(int[] data){
    int[] arrayReversed = new int[data.length];
    int i=data.length-1;
    for(int c=0; c<data.length; c++){
      arrayReversed[c]= data[i];
      i--;
    }
    return arrayReversed;
  }//fifth method ends

       
   }//class ends

א פראגרעם וואס פרינט ביז פאווערס עקספאנענט 40 צו עני גיווען נעטשרול נומבער בעיס מיט א דוגמא פון 2.

קאוד: וועל אויס אלע

class Main {//Powers
  public static void main(String[] args) {
    long results=0;
    int base=2;
    System.out.println(base+"^0" +"="+1);//for base^0
    System.out.println(base+"^1="+ base);
    results=(base*base);
    System.out.println(base+"^2="+results);
    for (int exponent=3; exponent<=40; exponent++)
    {
         results=(results*base);
         System.out.println(base+"^" + exponent +"=" +results);
    }
  }

}


אגב, פלאגט אריין די קאוד אין דיע וועבסייט, אויסוועלענדיג java לענגוויטש, און ס'וועט ארבעטן.

m https://repl.it/repls m

א פייטאן פראגרעם פון פינף פונקשענס. קודם נעמט ער אן אינטעדזשער, טשעקד אויב סאיז העכער אדער אונטער זיראו. דערנאך נעמט ער א סטרינג , דרייט עס איבער, איז עס מחבר פון די אנדערע זייט צו די ארגינעלע, דערנאך, מיט די הילף פון די פריערדיגע פונקשענס, בעט ער פון דער יוזער פאר א סטרינג פון דיזשיטס, דרייט עס איבער, איז עס מחבר פון די אנדערע עק און איז בוק אויב ס'איז אן איווען אדער אן אדד נומבער.

קאוד: וועל אויס אלע

#returns a the original string if it is above 0 or an empty string if it is below 0
def getIntegerString():
    numString=input('Please enter an integr greater than or equal to 0 : ')
    numInteger=int(numString)
    if numInteger<0:
        return "><"
    else:
        return numString
print(getIntegerString())
print(getIntegerString())
#param a string of caracters
#retruns the string reversed
def reverse(myString):
    _reversed=""
    letter=(len(myString)-1)
    while letter>=0:
        _reversed=_reversed+myString[letter]
        letter=letter-1
    return _reversed
print(reverse('123450'))
#@param a string of caracter
#@returns the string concatenated with the reverse of that string
def mirror(myString):
    _chopped=""
    count=0
    while count<(len(myString)-1):
        _chopped=_chopped+myString[count]
        count=count+1
    return _chopped+reverse(myString)
print(mirror('12345'))



def main():
  intString=(getIntegerString())
  newIntString=(mirror(intString))
  if int(newIntString)%2==0:
    return"The number", intString, "reversed and concatenated comes to an evnen number", newIntString
  else:
    return"The number", intString, "reversed and concatenated comes to an odd number", newIntString
       
print(main())
print(main())

מ'דארף טוישן די נאמען פון די אשכול צו 'איך האב א קאוד פאר'....

טאמבל סאס האט געשריבן:אגב, פלאגט אריין די קאוד אין דיע וועבסייט, אויסוועלענדיג java לענגוויטש, און ס'וועט ארבעטן.

https://repl.it/repls

Error 500

אגב וועלכע אנדערע פראגראם שפראכן קענסטו חוץ פייטאן און זשאווא?

נאר דיע.

דו דארפסט האבן אן אקאונט, וועהל אויס פייטאן3 אדער זשאווא געוואנדן אויף וועלכן סקריפט דו האסט אויספרובירט (נישט זשאווא סקריפט) און כ'האב נישט פראוויידעט פאר מעגליכע אנדערע אינפוט. ד.ה. די אסומפשנס זענען אז דער יוזער ענטערד נישט קיין וועליוס וועלכע זענען דאטאטייפס אנדערש ווי די דעקלערטע וועריעבלס.

איך האב לעצטנס אנגעהויבן שפיהלן מיט R. ס'איז אסאך פאן און זייער פאוערפול. עס איז געמאכט בעיקר פאר מעטימאטיקאל מאדעלינג ווצבש סטאטיסטיקס, און ווערט גענוצט עקסטענסיוולי אין יוניווערסיטי לאבארטאריעס און ביי קאמפאניס וואס זענען עוסק אין ביג דאטא אנאליטיקס. די יוניווערסיטי לעקטשורס פון R זענען אנגעפאקט מיט סטודענדטן וואס ווילן אויך זיין א קיהלע דאטא סייענטיסט.

PHP איז אויך א לענגוויטש וואס צאלט זיך אויס צו קענען - דאס איז א סערווער סייד סקריפטינג לענגוויטש, צייכנט זיך אויס פאר איר זיין סעקיוריטי פוירפויסד, עס איז די קאונטערפארט פון דזשאווא-סקריפט וואס איז קליענט סייד.

קאוד מיט א לופ, צו סאלוון די באקאנטע אריטעמעטיק פראגרעשאן מעשה'לע פון Carl Gauss, און דער פארמולע תיכף דערנאך.

קאוד: וועל אויס אלע

import java.util.Scanner;

class Main {
  public static void main(String[] args) {
    Scanner listeOut = new Scanner(System.in);
    System.out.println("Please enter first int");
    int firstNum = listeOut.nextInt();
    System.out.println("Please enter second int");
    int secondNum = listeOut.nextInt();
    int i = firstNum;
    int sum = firstNum;
    while (i < secondNum) {
      sum += (i + 1);
      i++;
    }
    System.out.println(sum);
    System.out.println(((secondNum + 1) * secondNum) / 2);

  }
}