דילוג לתוכן
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום
כיווץ
תחומים

תחומים - פורום חרדי מקצועי

💡 רוצה לזכור קריאת שמע בזמן? לחץ כאן!
  1. דף הבית
  2. תכנות
  3. ארכיון code613m
  4. קוד לגימטריה ב javascript / Hebrew Gematriah code in js

קוד לגימטריה ב javascript / Hebrew Gematriah code in js

מתוזמן נעוץ נעול הועבר ארכיון code613m
14 פוסטים 4 כותבים 1.2k צפיות
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • רחמיםר מנותק
    רחמיםר מנותק
    רחמים מורחק
    כתב ב נערך לאחרונה על ידי
    #2

    יש לי ב C# כמה שינויים קטנים וזה מתאים ל JS

    public class גימטריה
    {
    
    	public static int גימטריה_פשוטה(string aValue)
    	{
    		int Result = 0;
    		CharEnumerator ce = aValue.GetEnumerator();
    
    		while (ce.MoveNext()) {
    			switch (ce.Current) {
    				case "א":
    					Result = Result + 1;
    					break;
    				case "ב":
    					Result = Result + 2;
    					break;
    				case "ג":
    					Result = Result + 3;
    					break;
    				case "ד":
    					Result = Result + 4;
    					break;
    				case "ה":
    					Result = Result + 5;
    					break;
    				case "ו":
    					Result = Result + 6;
    					break;
    				case "ז":
    					Result = Result + 7;
    					break;
    				case "ח":
    					Result = Result + 8;
    					break;
    				case "ט":
    					Result = Result + 9;
    					break;
    				case "י":
    					Result = Result + 10;
    					break;
    				case "כ":
    					Result = Result + 20;
    					break;
    				case "ך":
    					Result = Result + 20;
    					break;
    				case "ל":
    					Result = Result + 30;
    					break;
    				case "מ":
    					Result = Result + 40;
    					break;
    				case "ם":
    					Result = Result + 40;
    					break;
    				case "נ":
    					Result = Result + 50;
    					break;
    				case "ן":
    					Result = Result + 50;
    					break;
    				case "ס":
    					Result = Result + 60;
    					break;
    				case "ע":
    					Result = Result + 70;
    					break;
    				case "פ":
    					Result = Result + 80;
    					break;
    				case "ף":
    					Result = Result + 80;
    					break;
    				case "צ":
    					Result = Result + 90;
    					break;
    				case "ץ":
    					Result = Result + 90;
    					break;
    				case "ק":
    					Result = Result + 100;
    					break;
    				case "ר":
    					Result = Result + 200;
    					break;
    				case "ש":
    					Result = Result + 300;
    					break;
    				case "ת":
    					Result = Result + 400;
    					break;
    			}
    		}
    		return Result;
    	}
    
    	public static int גימטריה_סופיות(string aValue)
    	{
    		int Result = 0;
    		CharEnumerator ce = aValue.GetEnumerator();
    
    		while (ce.MoveNext()) {
    			switch (ce.Current) {
    				case "א":
    					Result = Result + 1;
    					break;
    				case "ב":
    					Result = Result + 2;
    					break;
    				case "ג":
    					Result = Result + 3;
    					break;
    				case "ד":
    					Result = Result + 4;
    					break;
    				case "ה":
    					Result = Result + 5;
    					break;
    				case "ו":
    					Result = Result + 6;
    					break;
    				case "ז":
    					Result = Result + 7;
    					break;
    				case "ח":
    					Result = Result + 8;
    					break;
    				case "ט":
    					Result = Result + 9;
    					break;
    				case "י":
    					Result = Result + 10;
    					break;
    				case "כ":
    					Result = Result + 20;
    					break;
    				case "ל":
    					Result = Result + 30;
    					break;
    				case "מ":
    					Result = Result + 40;
    					break;
    				case "נ":
    					Result = Result + 50;
    					break;
    				case "ס":
    					Result = Result + 60;
    					break;
    				case "ע":
    					Result = Result + 70;
    					break;
    				case "פ":
    					Result = Result + 80;
    					break;
    				case "צ":
    					Result = Result + 90;
    					break;
    				case "ק":
    					Result = Result + 100;
    					break;
    				case "ר":
    					Result = Result + 200;
    					break;
    				case "ש":
    					Result = Result + 300;
    					break;
    				case "ת":
    					Result = Result + 400;
    					break;
    				case "ך":
    					Result = Result + 500;
    					break;
    				case "ם":
    					Result = Result + 600;
    					break;
    				case "ן":
    					Result = Result + 700;
    					break;
    				case "ף":
    					Result = Result + 800;
    					break;
    				case "ץ":
    					Result = Result + 900;
    					break;
    			}
    		}
    		return Result;
    	}
    
    	public static int גימטריה_קטנה(string aValue)
    	{
    		int Result = גימטריה_פשוטה(aValue);
    		Result = Result % 9;
    		if (Result == 0) {
    			Result = 9;
    		}
    		return Result;
    	}
    
    	public static string גימטריה_במילוי(string aValue)
    	{
    		int Result = 0;
    		CharEnumerator ce = aValue.GetEnumerator();
    
    		while (ce.MoveNext()) {
    			switch (ce.Current) {
    				case "א":
    					Result = Result + גימטריה_פשוטה("אלף");
    					break;
    				case "ב":
    					Result = Result + גימטריה_פשוטה("בית");
    					break;
    				case "ג":
    					Result = Result + גימטריה_פשוטה("גימל");
    					break;
    				case "ד":
    					Result = Result + גימטריה_פשוטה("דלת");
    					break;
    				case "ה":
    					Result = Result + גימטריה_פשוטה("הא");
    					break;
    				case "ו":
    					Result = Result + גימטריה_פשוטה("וו");
    					break;
    				case "ז":
    					Result = Result + גימטריה_פשוטה("זין");
    					break;
    				case "ח":
    					Result = Result + גימטריה_פשוטה("חית");
    					break;
    				case "ט":
    					Result = Result + גימטריה_פשוטה("טת");
    					break;
    				case "י":
    					Result = Result + גימטריה_פשוטה("יוד");
    					break;
    				case "כ":
    					Result = Result + גימטריה_פשוטה("כף");
    					break;
    				case "ך":
    					Result = Result + גימטריה_פשוטה("כף");
    					break;
    				case "ל":
    					Result = Result + גימטריה_פשוטה("למד");
    					break;
    				case "מ":
    					Result = Result + גימטריה_פשוטה("מם");
    					break;
    				case "ם":
    					Result = Result + גימטריה_פשוטה("מם");
    					break;
    				case "נ":
    					Result = Result + גימטריה_פשוטה("נון");
    					break;
    				case "ן":
    					Result = Result + גימטריה_פשוטה("נון");
    					break;
    				case "ס":
    					Result = Result + גימטריה_פשוטה("סמך");
    					break;
    				case "ע":
    					Result = Result + גימטריה_פשוטה("עין");
    					break;
    				case "פ":
    					Result = Result + גימטריה_פשוטה("פא");
    					break;
    				case "ף":
    					Result = Result + גימטריה_פשוטה("פא");
    					break;
    				case "צ":
    					Result = Result + גימטריה_פשוטה("צדיק");
    					break;
    				case "ץ":
    					Result = Result + גימטריה_פשוטה("צדיק");
    					break;
    				case "ק":
    					Result = Result + גימטריה_פשוטה("קוף");
    					break;
    				case "ר":
    					Result = Result + גימטריה_פשוטה("ריש");
    					break;
    				case "ש":
    					Result = Result + גימטריה_פשוטה("שין");
    					break;
    				case "ת":
    					Result = Result + גימטריה_פשוטה("תו");
    					break;
    			}
    		}
    		return Result;
    	}
    
    }
    

    פורסם במקור בפורום CODE613 ב23/12/2013 17:47 (+02:00)

    תגובה 1 תגובה אחרונה
    0
    • א מנותק
      א מנותק
      ארכיטקט
      כתב ב נערך לאחרונה על ידי
      #3

      תודה

      לדעתי קוד גס מידי הייתי מצפה לאיזה אלגוריתם נעים ומסודר.

      אבל חוץ מזה המטרה שלי היא הפוכה אני עושה לולאה שעוברת על int ואני צריך להפוך אותה ל string כאן נתת string שהופך ל int.

      פורסם במקור בפורום CODE613 ב23/12/2013 18:33 (+02:00)

      אידיאולוגיות גדולות נכנסות למטחנה של עולם המעשה ויוצאות ממנו בפירורים (ווינסטון צ'רצ'יל, סתם סתם, זה שלי)

      תגובה 1 תגובה אחרונה
      0
      • רחמיםר מנותק
        רחמיםר מנותק
        רחמים מורחק
        כתב ב נערך לאחרונה על ידי
        #4

        אז יש את זה שממיר מספר לאותיות כמו למשל 774 ל תשעד

        public object HebrewNum(int n)
        {
        	int nX = 0;
        	string sHundred = null;
        	string sTen = null;
        	string sOne = null;
        
        	n = n % 1000;
        	nX = n - (n % 100);
        	switch (nX) {
        		case 900:
        			sHundred = Tuf_() + Tuf_() + Raish_();
        			break;
        		case 800:
        			sHundred = Tuf_() + Tuf_() + Kuf_();
        			break;
        		case 700:
        			sHundred = Tuf_() + Shin_();
        			break;
        		case 600:
        			sHundred = Tuf_() + Raish_();
        			break;
        		case 500:
        			sHundred = Tuf_() + Kuf_();
        			break;
        		case 400:
        			sHundred = Tuf_();
        			break;
        		case 300:
        			sHundred = Shin_();
        			break;
        		case 200:
        			sHundred = Raish_();
        			break;
        		case 100:
        			sHundred = Kuf_();
        			break;
        	}
        	n = n - nX;
        	if (n == 15) {
        		sTen = Tes_();
        		sOne = Vav_();
        	} else if (n == 16) {
        		sTen = Tes_();
        		sOne = Ziyon_();
        	} else {
        		nX = n - (n % 10);
        		switch (nX) {
        			case 90:
        				sTen = Tzodi_();
        				break;
        			case 80:
        				sTen = Pai_();
        				break;
        			case 70:
        				sTen = Iyin_();
        				break;
        			case 60:
        				sTen = Samech_();
        				break;
        			case 50:
        				sTen = Nun_();
        				break;
        			case 40:
        				sTen = Mem_();
        				break;
        			case 30:
        				sTen = Lamed_();
        				break;
        			case 20:
        				sTen = Chaf_();
        				break;
        			case 10:
        				sTen = Yud_();
        				break;
        		}
        		nX = n - nX;
        		switch (nX) {
        			case 9:
        				sOne = Tes_();
        				break;
        			case 8:
        				sOne = Ches_();
        				break;
        			case 7:
        				sOne = Ziyon_();
        				break;
        			case 6:
        				sOne = Vav_();
        				break;
        			case 5:
        				sOne = Hai_();
        				break;
        			case 4:
        				sOne = Daled_();
        				break;
        			case 3:
        				sOne = Gimmel_();
        				break;
        			case 2:
        				sOne = Bais_();
        				break;
        			case 1:
        				sOne = Alef_();
        				break;
        		}
        	}
        
        	return sHundred + sTen + sOne;
        }
        
        
        public object Alef_()
        {
        	return Strings.ChrW(1488);
        }
        
        public object Bais_()
        {
        	return Strings.ChrW(1489);
        }
        
        public object Gimmel_()
        {
        	return Strings.ChrW(1490);
        }
        
        public object Daled_()
        {
        	return Strings.ChrW(1491);
        }
        
        public object Hai_()
        {
        	return Strings.ChrW(1492);
        }
        
        public object Vav_()
        {
        	return Strings.ChrW(1493);
        }
        
        public object Ziyon_()
        {
        	return Strings.ChrW(1494);
        }
        
        public object Ches_()
        {
        	return Strings.ChrW(1495);
        }
        
        public object Tes_()
        {
        	return Strings.ChrW(1496);
        }
        
        public object Yud_()
        {
        	return Strings.ChrW(1497);
        }
        
        public object Chaf_End_()
        {
        	return Strings.ChrW(1498);
        }
        
        public object Chaf_()
        {
        	return Strings.ChrW(1499);
        }
        
        public object Lamed_()
        {
        	return Strings.ChrW(1500);
        }
        
        public object Mem_End_()
        {
        	return Strings.ChrW(1501);
        }
        
        public object Mem_()
        {
        	return Strings.ChrW(1502);
        }
        
        public object Nun_End_()
        {
        	return Strings.ChrW(1503);
        }
        
        public object Nun_()
        {
        	return Strings.ChrW(1504);
        }
        
        public object Samech_()
        {
        	return Strings.ChrW(1505);
        }
        
        public object Iyin_()
        {
        	return Strings.ChrW(1506);
        }
        
        public object Pai_End_()
        {
        	return Strings.ChrW(1507);
        }
        
        public object Pai_()
        {
        	return Strings.ChrW(1508);
        }
        
        public object Tzodi_End_()
        {
        	return Strings.ChrW(1509);
        }
        
        public object Tzodi_()
        {
        	return Strings.ChrW(1510);
        }
        
        public object Kuf_()
        {
        	return Strings.ChrW(1511);
        }
        
        public object Raish_()
        {
        	return Strings.ChrW(1512);
        }
        
        public object Shin_()
        {
        	return Strings.ChrW(1513);
        }
        
        public object Tuf_()
        {
        	return Strings.ChrW(1514);
        }
        

        פורסם במקור בפורום CODE613 ב23/12/2013 19:54 (+02:00)

        תגובה 1 תגובה אחרונה
        0
        • dovidD מנותק
          dovidD מנותק
          dovid ניהול
          כתב ב נערך לאחרונה על ידי
          #5

          למה המתודות בקוד האחרון מוגדרות לאובייקט במקום מחרוזת או תו?

          פורסם במקור בפורום CODE613 ב23/12/2013 21:05 (+02:00)

          מנטור אישי למתכנתים (ולא רק) – להתקדם לשלב הבא!

          בכל נושא אפשר ליצור קשר dovid@tchumim.com

          תגובה 1 תגובה אחרונה
          0
          • M מנותק
            M מנותק
            magicode
            כתב ב נערך לאחרונה על ידי
            #6

            יש לי משהו שכתבתי בעבר.

            http://jsfiddle.net/uTcs9/

            function gimatria(num) {
            
            	var g = {
            			100 : "קרשת",
                        10 : "יכלמנסעפצ",
                        1 : "אבגדהוזחט"
            		};
            
            	var str = "";
            
            	for ( var key = 100; key >= 1; key /= 10) {
            
            		for ( var i = g[key].length; i > 0; i--) {
            			var v = i * key;
            			while (num >= v) {
            				str += g[key].charAt(i - 1);
            				num -= v;
            			}
            
            		}
            	}
            
            	str = str.replace("י" + "ה", "טו");
            	str = str.replace("י" + "ו", "טז");
            
            	/*
            	 * 'רעב'=>'רבע' 'רצח'=>'רחצ'
            	 */
            
            	if (str.length > 1)
            		str = str.substring(0, str.length - 1) + "\""
            				+ str.substring(str.length - 1);
            	else if (1 == str.length)
            		str = str + "'";
            
            	return str;
            }
            

            פורסם במקור בפורום CODE613 ב23/12/2013 21:09 (+02:00)

            תגובה 1 תגובה אחרונה
            2
            • רחמיםר מנותק
              רחמיםר מנותק
              רחמים מורחק
              כתב ב נערך לאחרונה על ידי
              #7

              magicode , תודה רבה, כמו תמיד קצר וקולע, [ואפי' הקפדת על שם השם שלא יופיע אפי' שזה רק על המסך.]

              דוד, הקוד האחרון שהבאתי הוא לא שלי העתקתי אותו מכאן.

              פורסם במקור בפורום CODE613 ב23/12/2013 22:05 (+02:00)

              תגובה 1 תגובה אחרונה
              0
              • dovidD מנותק
                dovidD מנותק
                dovid ניהול
                כתב ב נערך לאחרונה על ידי
                #8

                @רחמים

                [ואפי' הקפדת על שם השם שלא יופיע אפי' שזה רק על המסך.]

                לא בגלל ההקפדה אלא בשביל לא לקבל תוצאה שגוייה.

                פורסם במקור בפורום CODE613 ב23/12/2013 22:24 (+02:00)

                מנטור אישי למתכנתים (ולא רק) – להתקדם לשלב הבא!

                בכל נושא אפשר ליצור קשר dovid@tchumim.com

                תגובה 1 תגובה אחרונה
                0
                • רחמיםר מנותק
                  רחמיםר מנותק
                  רחמים מורחק
                  כתב ב נערך לאחרונה על ידי
                  #9

                  התכוונתי לשתי שורות האלו

                  str = str.replace("י" + "ה", "טו");
                      str = str.replace("י" + "ו", "טז");
                  

                  פורסם במקור בפורום CODE613 ב23/12/2013 22:35 (+02:00)

                  תגובה 1 תגובה אחרונה
                  0
                  • dovidD מנותק
                    dovidD מנותק
                    dovid ניהול
                    כתב ב נערך לאחרונה על ידי
                    #10

                    גם אני התכוונתי אליהם,
                    אם אתה מתכוון לזה שהוא שרשר במקום לכתוב ברצף הוא יכל לכתוב "הי" במקום שרשור, וכן למה ב"יו" יש בעיה.

                    פורסם במקור בפורום CODE613 ב23/12/2013 23:09 (+02:00)

                    מנטור אישי למתכנתים (ולא רק) – להתקדם לשלב הבא!

                    בכל נושא אפשר ליצור קשר dovid@tchumim.com

                    תגובה 1 תגובה אחרונה
                    0
                    • רחמיםר מנותק
                      רחמיםר מנותק
                      רחמים מורחק
                      כתב ב נערך לאחרונה על ידי
                      #11

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

                      בכל מקרה מה ההבדל בין לשרשר לבין לכתוב ביחד?

                      פורסם במקור בפורום CODE613 ב23/12/2013 23:21 (+02:00)

                      תגובה 1 תגובה אחרונה
                      0
                      • M מנותק
                        M מנותק
                        magicode
                        כתב ב נערך לאחרונה על ידי
                        #12

                        @דוד ל.ט.

                        @רחמים
                        [ואפי' הקפדת על שם השם שלא יופיע אפי' שזה רק על המסך.]

                        לא בגלל ההקפדה אלא בשביל לא לקבל תוצאה שגוייה.

                        הוא צודק עשיתי את זה מפני כבוד השם.

                        כאילו היה לי קשה ( אני לא יודע מה ההלכה בנושא ) לכתוב את זה בפרוש אז כתבתי ככה.

                        פורסם במקור בפורום CODE613 ב23/12/2013 23:44 (+02:00)

                        תגובה 1 תגובה אחרונה
                        0
                        • dovidD מנותק
                          dovidD מנותק
                          dovid ניהול
                          כתב ב נערך לאחרונה על ידי
                          #13

                          רק עכשיו קלטתי שהפונקציה של magicode היא ממספר לטקסט.
                          זה מה שארכיטקט רצה?

                          פורסם במקור בפורום CODE613 ב24/12/2013 12:43 (+02:00)

                          מנטור אישי למתכנתים (ולא רק) – להתקדם לשלב הבא!

                          בכל נושא אפשר ליצור קשר dovid@tchumim.com

                          תגובה 1 תגובה אחרונה
                          0
                          • רחמיםר מנותק
                            רחמיםר מנותק
                            רחמים מורחק
                            כתב ב נערך לאחרונה על ידי
                            #14

                            כן, גם אני התבלבלי בהתחלה בהבנת בקשתו כי אני רגיל לחשוב על גימטריה כהמרה של מילים למספרים לא להיפך.

                            פורסם במקור בפורום CODE613 ב24/12/2013 14:22 (+02:00)

                            תגובה 1 תגובה אחרונה
                            0

                            בא תתחבר לדף היומי!
                            • התחברות

                            • אין לך חשבון עדיין? הרשמה

                            • התחברו או הירשמו כדי לחפש.
                            • פוסט ראשון
                              פוסט אחרון
                            0
                            • דף הבית
                            • קטגוריות
                            • פוסטים אחרונים
                            • משתמשים
                            • חיפוש
                            • חוקי הפורום