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

[יידל]

וועט זיך לכאורה אויך ווענדן צו די קאמפיוטער נוצט א CISC אדער RISC סי פי יו, ניין?

[פארוואס?]

וועט זיך לכאורה אויך ווענדן צו די קאמפיוטער נוצט א CISC אדער RISC סי פי יו, ניין?

קטונתי מלהבין בעניינים נשגבים הללו.

[פארוואס?]

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

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

            1000  *
            1001
            ____
            1000
           0000
          0000
         1000
         _______
         1001000

[/left]

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

[יאיר]

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

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

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

[קול דודי]

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

א לופ איז טאקע נישט אזוי גוט דא, ווייל עס נעמט 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 בלע"ז), נאר דער טריק איז וועלכע אינדעקס צו נוצן פאר וועלכע חלק. אי"ה מארגן וועל איך ארויפלייגן די קאוד זעלבסט.

[berlbalaguleh]

ווי האט עטץ ענק געלערנט קוידס? איז דאס א קאמפלאצירטע לימוד?

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

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

[פארוואס?]

[tag]יידל[/tag] דא האסטו אין 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
קוק נאר:
[left]

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

            1000  *
            1001
            ____
            1000
           0000
          0000
         1000
         _______
         1001000

[/left]

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

[בארא פארק עסקן]

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

[פארוואס?]

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

[tag]יידל[/tag] [tag]קול דודי[/tag]

[טאמבל סאס]

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

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

אנדערש האב איך עס געזען אזוי: וויפיל ליינס אף אינטער-קאמיוניקעישן אויב ס'איז דא 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

[טרויבן88]

איך האב איך 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 לענגוויטש, און ס'וועט ארבעטן.

https://repl.it/repls