אלגוריתם סוגריים בג'אווהסקירפט.

[levil]

נבחנתי בבית והנבלות עדיין לא החזירו תשובה,
אני לא הכי מנוסה ב JS
לקח לי חצי שעה ללמוד מה צריך ולכתוב את האלגוריתם, עם טעויות סינטקס קטנות וטעות בהגדרת גבולות הלולאה, שתיקנתי יותר מאוחר,
בסה"כ חרגתי פי 2 מהזמן.
אבל יותר מענין אותי האם יש דרך אחרת יותר יעילה וקריאה יותר.
צריך לכתוב פונקציה המקבלת string ומחזירה 1 אם הסוגריים בקלט מקוננים נכון ו- 0 אחרת.
דוגמאות :

You need to consider three kinds: (), [], <> and only these kinds.


Examples:

verify("---(++++)----") -> 1
verify("") -> 1
verify("before ( middle []) after ") -> 1
verify(") (") -> 0
verify("} {") -> 1 //no, this is not a mistake.
verify("<( >)") -> 0
verify("( [ <> () ] <> )") -> 1
verify(" ( [)") -> 0

function verify(text)
{
    var  stack =  new Array();
    var  myMap =  new Map();
    myMap.set('[' ,']');
    myMap.set('(',')');
    myMap.set( '<','>');
    myMap.set('”', '”');
    var regOpen   =  /[([<"]/ ;
    var regClose  = /[\)\]\>"]/ ;
    var length=  text.length-1;
    var textArr= text.split("");
    var pop;
    console.log(length);
    for (i=0;i<=length; i++ )
    {
       if( textArr[i].match(regOpen)  )
          stack.push(textArr[i]);
       else if( textArr[i].match(regClose)  )
       {
           pop =  myMap.get(stack.pop());
           if( pop!= textArr[i] )
               return 0;
       }
    }
    return (stack.length==0 ? 1:0);
}

[קסד]

דיסקליימר :
אין לי מושג ירוק בתכנות ומה שאני עומד לכתוב כאן הם שטויות במקרה הטוב.

אז.
קודם כל בשביל העוואנטה הייתי משתמש בסינטקס של ES6.
יענו

use strict ; 
// use "let" and "const" , don't use var 

2) השימוש ברגקס מיותר.
אתה הרי מפרק את המחרוזת למערך ועובר תו תו. אז תשתמש בפונקציה indexOf
יענו

const regOpen = '[([<' ; 
if (regOpen.indexOf(textArr[i]) { textArr[i] => { stack.push(textArr[i])} }
// או שטות דומה 

3) אתה צריך להחזיק מונה של כל סוג סוגרים. כשהסוגרים פותחות הוא עולה באחד וההפך.
ברגע שאחד המונים יורד מתחת לאפס בום! Game Over ואתה צריך לעשות ברייק מהלולאה. אין טעם להמשיך בה.
אני לא מצליח לעקוב אחרי הפלואו של הקוד כדי לדעת אם זה קורה. הרצת טסטים כדי לבדוק שזה עובד?

4) האופרטור הטרנרי שלך (בסוף) אחלה. תשתמש בזה יותר.



עריכה:
3.א )
וכמובן כמובן כמובן שברגקס אתה חייב לעשות אסקייפינג לתווים מיוחדים כמו סוגריים. (איך שכחתי את זה אני לא יודע)

[levil]

1) כן אני יודע, צריך לעבור ל- let.
מצאתי דרך לבצע את השמת הערכים לאובייקט ה Map בשורה אחת :

let myMap = new Map([  ['[', ']'], ['(',')'] , ['<','>'],['”', '”']  ]);

אבל הסינטקס הזה עדיין לא עובד לי ב WEBSTORM של JETBRAIN אולי צריך למצוא גירסה מעודכנת יותר של V8.
2) איך השימוש ברגקס מיותר אם אתה משתמש בו בדוגמא שלך ?
השימוש ברגקס מאפשר לי להמנע מ- SWITCH CASE ארוך ומסורבל.
יכולתי להשתמש במונה לכל סוג סוגריים, אבל אז הקוד יהיה מסורבל הרבה פחות קריא וקשה לתחזוקה.
במקום זה אני משתמש ב HASH TABLE שבעגה של ES6 נקרא Map, כלומר משהו שמחזיק זוגות של KEY ו- VALUE

3) הקוד עובד לי פרפקט.

הפלוו של התוכנית הוא :
א) אני יוצר אובייקט של מאפ, ה KEY הוא הסוגר ימני וה VALUE הוא הסוגר השמאלי,
ב) אני עובר בלולאה על המחרוזת, תו תו,
1)בודק ע"י שימוש ברגקס REGOPEN האם התו הנוכחי הוא מסוג סוגר-שמאלי אם כן דוחף אותו למחסנית ועובר לתו הבא,
אם לא,
2) בודק האם התו הוא מסוג סוגר- ימני, אם כן, אני שולף מהמחסנית את הסוגר השמאלי האחרון שנדחף אליה
וע"י קריאה למתודת GET של MAP המקבלת כארגמונט KEY ומחזירה VALUE אני מקבל את הסוגר הימני (של הסגירה)
המתאים לסוגר השמאלי (הפותח) שנשלף מהמחסנית,
כעת אני יכול לבדוק בעצם אם הסוגר השמאלי האחרון במחרוזת מתאים לסוגר הימני , אם לא אני יוצא מהפונקציה עם אפס,
אם כן, אני ממשיך הלאה בלולאה כי ה POP שהשתמשתי לבדיקה כבר העיף לי את הסוגר השמאלי האחרון במחסנית,

ג) אחרי שיצאתי מהלולאה אני בודק האם המחסנית ריקה, אם כן הסוגריים מקוננות נכון ומחזיר 1 אחרת מחזיר 0.

לגבי הקוד: כתבתי גירסה ללא שימוש ב SPLIT והתוכנית מצליחה עם כל הטסטים שהבאתי קודם וגם אחרים.

     function verify(text){
    var  stack =  new Array(); 
   var  myMap =  new Map(); 
   myMap.set('[' ,']'); 
   myMap.set('(',')');  
  myMap.set( '<','>');
    myMap.set('”', '”');  
  var regOpen   =  /[([<"]/ ; 
   var regClose  = /[\)\]\>"]/ ; 
   var length=  text.length-1;  
  var pop; 
   for (i=0;i<=length; i++ )
    {       if( text.charAt(i).match(regOpen)  )   
       stack.push( text.charAt(i));  
     else if(  text.charAt(i).match(regClose)  )   
    {           pop =  myMap.get(stack.pop()); 
          if( pop!=  text.charAt(i) )        
       return 0;  
     }    }    return (stack.length==0 ? 1:0);} 

[קסד]

2) איך השימוש ברגקס מיותר אם אתה משתמש בו בדוגמא שלך ?

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

ובכל זאת אענה לך:
indexOf זה ממש לא רגקס. match זה ממש כן.
ואמנם זה לא תכנות רילטיים אבל אני מעדיף להשתמש בכמה פחות משאבים.

indexOf vs match





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

[levil]

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

[קסד]

סיימת לערוך? כי אם לא אני גם היבריסי קטטוני. תוסיף תוסיף.
מקריאה חוזרת אני רואה שטיפלת בנושא הסוגר סוגר לפני פותח.
עדיין ה regOpen וה regClose מאד בעייתיים ואני לא מבין איך הקוד שלך עובד לטענתך.
() ברגקס נועדו לתפוס משהו.
[] ברגקס זה הסוויץ' קייס שאתה מדבר עליו - אפשרות של כמה תווים.

אבל נמתין לשאר התכנתים שפה. אני סיימתי

[shaig]

התכוונת לייצר בודק תקינות של קוד?
כי אם כן, שכחת להתייחס לרימארקים ולמחרוזות.
בכל אופן, הכי יעיל לרוץ תו תו ולשמור על סטייט, מה שנקרא מכונת מצבים.
אבל מה אני מבין, לא סיימתי תיכון.

[levil]

התכוונת לייצר בודק תקינות של קוד?
כי אם כן, שכחת להתייחס לרימארקים ולמחרוזות.
בכל אופן, הכי יעיל לרוץ תו תו ולשמור על סטייט, מה שנקרא מכונת מצבים.
אבל מה אני מבין, לא סיימתי תיכון.

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

[shaig]

אם זה לא בודק תקינות של קוד, אז התוכנית בסדר, חוץ מזה ששכחת var i

[shaig]

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

[levil]

זה היה חלק ממבחן קבלה.

[shaig]

לויל וקסד, מחפשים אצלנו בנרות, ואני חלק מוועדת הקבלה. אתם מוזמנים לראיון.

[קסד]

לויל וקסד, מחפשים אצלנו בנרות, ואני חלק מוועדת הקבלה. אתם מוזמנים לראיון.

אני יותר בכיוון של DevOps (שמעתם? סתם שתדעו) אבל קבל ה"פ לחוצה.

[shaig]

אני יותר בכיוון של DevOps (שמעתם? סתם שתדעו) אבל קבל ה"פ לחוצה.

גם הולך

[levil]

איפה אתם נמצאים ?

זו הגירסה הנקיה של המתודה.

function verify(text)
{
   'use strict';
    let  stack =  new Array();
    let myMap = new Map([  ['[', ']'], ['(',')'], ['<','>'] ]);
    let regOpen   =  /[([<"]/ ;
    let regClose  = /[\)\]\>"]/ ;
    let length  =  text.length-1;
    var pop;
    var currentChar;
    for (var i=0;i<=length; i++ )
    {
        currentChar = text.charAt(i);
        if(  currentChar.match(regOpen)  )
            stack.push(  currentChar);
        else if(   currentChar.match(regClose)  )
        {
            pop =  myMap.get(stack.pop());
            if( pop!=  currentChar )   return 0;
        }
    }
    return (stack.length==0 ? 1:0);
}