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

@nigun כתב בכך תריצו מודל שפה חזק על המחשב הביתי שלכם:

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

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

@yyy אני רק מוסיף הערת אגב, אם הוספת את התיקייה למשתני הסביבה עם הפקודה:

PATH="$PATH:/home/ubuntu/.dotnet"

אז בהפעלה מחדש זה לא יישאר ב-PATH, כדי לשנות את זה לתמיד צריך לערוך את הקובץ etc/environment/
לדוגמא עם sudo nano /etc/environment ולהוסיף שם את הנתיב (עם הפרדה של :) ולשמור.

@אביי אם הבעיה ש-NAudio נועל את הקובץ גם אחרי ההשמעה (לא יודע למה) אז זמנית יש לי ב' פתרונות חלופיים:

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

@Y-Excel-Access כתב באלגוריתם המרת טבלה לעץ בצורה אופטימלית:

אח"כ לא ברור מה עדיף לשים, את השדה 'תאריך' כי יש כמה בכ' טבת וכמה בל'? את השדה 'שם' כי יש הרבה יהודה וזבולון? את השדה 'פעולה' כי לרוב כולם רצים או נחים?

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

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

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

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

אני נגיד הייתי כותב את זה ככה:

public static IEnumerable<int> ScanNumber(int value)
{
    for (int x = value; x > 0; x /= 10)
    {
        yield return x % 10;
    }
}

public static IEnumerable<int> ScanNumber(int value, bool reverse)
{
    var source = ScanNumber(value);
    return reverse ? source.Reverse() : source;
}

@mekev כתב בזיהוי לחיצת קליק ימני / קליק שמאלי בעכבר:

לא הצלחתי באמצעותה להגיע לקוד

אל תצפה לראות את הקוד דרך ה-die כי הקוד לא כבר לא קיים, הוא קומפל לשפת מכונה.
מה ש@yossiz התכווין זה שבאמצעות הפונקציות המיובאות לתוכנה אפשר אולי לשער באיזה שפה פיתחו אותה, אבל לא כל אחד יכול לעשות את זה, זה זן מיוחד של אנשים... (לדוגמא @yossiz ..)

@mekev כתב בזיהוי לחיצת קליק ימני / קליק שמאלי בעכבר:

אבל לפחות עזר לי להבין מדוע תוכנה אחרת לא עבדה לי בכלים האחרים

אם תרצה אפשר להסיר ספציפית את ההגנה הזאת (ועוד..) עם כלי נוסף de4dot

@ממ

שפת #C היא שפת תכנות מונחת עצמים (OOP) טהורה, ולא משנה באיזה קובץ מגדירים את המשתנה, תמיד הוא חייב להיות בתוך מחלקה (class).
אם המשתנה מוגדר כ-static אז אפשר לגשת אליו (כמובן אם הוא לא private) בלי ליצור מופע חדש של המחלקה והוא יהיה קבוע לאורך כל התוכנית, אבל אם הוא לא static אז הערך שלו משתנה בין כל מופע ומופע של ה-class והוא יהיה זמין רק דרך instance של class ולא דרך ה-class עצמו.

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

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

כנגד הכלי ש@clickone הביא אפשר אולי להתמודד ולהסתיר את הסיסמה בצורה מתוחכמת בקוד, אבל כנגד כלי דיבוג כמו dnSpy אין כמעט מה לעשות. אמנם יש המון טכניקות ל-Anti Debugging אבל זה כבר משחקי חתול ועכבר, ובדרך כלל האקר מצליח להגיע למה שהוא רוצה.

וחוץ מזה שאני לא אוהב את הדרכים האלו והם גם לא יעילות לטעמי.

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

@ממ כתב בקובץ קונפיגורציה:

אני צריכה את ההגדרה שמחברת בין C# לSQL SERVER

זה הבסיס, רק צריך לשנות את הconnectionString למה שצריך.

<?xml version='1.0' encoding='utf-8'?>  
  <configuration>  
    <connectionStrings>  
      <clear />  
      <add name="Name"
       providerName="Microsoft.Data.SqlClient"
       connectionString="Valid Connection String;" />  
    </connectionStrings>  
  </configuration>  

@dovid כתב בלמה DoForEach לא קיים ב-LINQ?:

א. ToList מצריך לולאה + משתנה. זה הרבה יותר משמעותי מלולאה נטו.

למה ToList חוסך לולאה ומשתנה? זה לכאורה עושה return new List<TSource>(enum)

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

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

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

הפילוספיה היא שזה מתודות שאפשר להשתמש בהם בבטחה בלי לחשוש שהם ישפיעו על חלקים אחרים בתכנית שלך. לעולם לא יקרה שינוי לחלק בתכנית מפעולת LINQ שלא הושמה לתוך משתנה. בתוך המתודה ToList או ToArray קורה מה שקורה, אבל זה בסקופ סגור ובלתי משפיע, וזה יוצר פלט שאתה בוחר איך להשתמש בו.

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

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

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

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

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

מה, וכי אני אשם שה-RSA משתמש בתרגיל המתמטי הפשוט הזה?!

@dovid נדמה לי שעכשיו אתה לא צריך הוכחות על הביטחון של התרגיל הזה.

@dovid כתב בתרגיל מתמטי של הסתרת מזהה רץ:

בינתיים לא הצגת קוד זהב שעושה זאת בלי שום ידע מוקדם מלבד הנקודות שהזכרת (השיטה והרצף של ה30).

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

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

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

this adds no actual security to a system; it’s obscurity, at best.

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

@dovid מצאתי פתרון אחר שקצת מזכיר את הרעיון שלך אבל הוא נראה לי יותר טוב.

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

היצירה של המפתחות בפעם הראשונה היא פעולה קצת מורכבת, אז הכנתי פונקציה ב-#C שתיצור את המפתחות.
יש שלושה מפתחות: d ,e ו - n, ה - n הוא המודולו והוא המספר המקסימלי שאפשר לערפל ולשחזר למספר המקורי.
אחרי שיש את המפתחות הערפול נעשה בצורה כזאת: id ** e % n והשחזור למספר המקורי נעשה הפוך: obfuscated ** d % n

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

זה הפונקציה ליצירת המפתחות: (GenerateKeys)

void GenerateKeys(out int n, out int e, out int d)
{
    Random random = new();

    int p = GeneratePrime(128, 512, random);
    int q = GeneratePrime(128, 512, random);

    n = p * q;
    int ef = Lcm(p - 1, q - 1);

GenerateE:
    e = random.Next(32, 512);

    if (Gcd(e, ef) != 1)
        goto GenerateE;

    d = GenerateD(ef, e);

    if (d < 0)
        goto GenerateE;
}

bool IsPrime(int num)
{
    for (int i = num - 1; i > 1; i--)
    {
        if (num % i == 0)
            return false;
    }
    return true;
}

int Gcd(int a, int b)
{
    return b == 0 ? a : Gcd(b, a % b);
}

int Gcf(int a, int b)
{
    while (b != 0)
    {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int Lcm(int a, int b)
{
    return a / Gcf(a, b) * b;
}

int GeneratePrime(int min, int max, Random random)
{
    int p;

    do
    {
        p = random.Next(min, max);
    } while (!IsPrime(p));

    return p;
}

int GenerateD(int ef, int e)
{
    int y1 = 1, y2 = 0;

    while (e > 0)
    {
        int q = ef / e;
        int y = y2 - (q * y1);
        int r = ef % e;

        ef = e;
        e = r;

        y2 = y1;
        y1 = y;
    }

    return y2;
}

בשביל למהר את הביצועים מומלץ להשתמש במפתחות עם המודולו הקטן ביותר שנצרך, לדוג' אם המספר הגבוה ביותר שצריך לעפל הוא 10,000, אז כדי לקרוא לפונקציה שיוצרת את המפתחות שוב ושוב עד שיצא מספר מקסימלי (n) הכי נמוך אבל מעל 10,000.

טסט לדוגמא ב-#C:

GenerateKeys(out var n, out var e, out var d);

Console.WriteLine($"n: {n}, e: {e}, d: {d}");

foreach (var num in Enumerable.Range(3, 15))
{
    int c = (int)(BigInteger.Pow(num, e) % n);
    int m = (int)(BigInteger.Pow(c, d) % n);

    Console.Write("num: " + num);
    Console.CursorLeft = 15;
    Console.Write("c: " + c);
    Console.CursorLeft = 30;
    Console.WriteLine("m: " + m);
}

הפלט:

n: 71219, e: 287, d: 12683

num: 3         c: 36878       m: 3
num: 4         c: 51738       m: 4
num: 5         c: 44630       m: 5
num: 6         c: 54772       m: 6
num: 7         c: 26540       m: 7
num: 8         c: 21046       m: 8
num: 9         c: 60079       m: 9
num: 10        c: 43447       m: 10
num: 11        c: 66289       m: 11
num: 12        c: 36954       m: 12
num: 13        c: 61380       m: 13
num: 14        c: 64087       m: 14
num: 15        c: 65269       m: 15

אשמח לקבל הארות ותגובות.

@dovid כתב בתרגיל: עיגול מספר לפי מערך מפתחות:

סליחה, בכל מקום שMath.Clamp יעבוד (CORE 2 ומעלה) זה בהכרח C# 7.3 לפחות.

הערת אגב: הפיצ'ר שכתבתי (arr[^1]) לא קיים ב C# 7.3, זה רק מ 9.0 או 8.0.

@dovid אמר בתרגיל מתמטי של הסתרת מזהה רץ:

זה לא רק עניין של max גבוה.
כעת ניסיתי מספר אחר נמוך בהרבה (פי עשר פחות) רק פחות עגול. וגם אולי במפתח הרנדומלי היה פשוט גבוה בהרבה.
עבור הפלט הזה
699115, 1015520, 310513, 626918, 943323, 238316, 554721, 871126, 166119, 482524, 798929, 93922, 410327, 726732, 21725
הרצתי קוד C# מקבילי (AsParallel().ForAll) על 6 ליבות של I5 11500, ניצולת של 100% מעבדים טוטלית, זה לוקח מלא מלא זמן והוא לא בכיוון.

אני הרצתי את הרצף ספרות האלו בתרד אחד והתשובה הגיעה אחרי חצי דקה.

זה הרצף:
551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565

וזה המודולו:
1021412

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

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

@dovid אמר בתרגיל מתמטי של הסתרת מזהה רץ:

לא שיערת שום דבר, הMAX היה תמיד זהה.

איך יכולתי לדעת?! (משום מה לא הצלחתי לראות את הקוד שלך)

@dovid תצטרך למצוא פתרון חדש עבור האתר, כי אני הולך להרוס לך את הרעיון עקב הבקשה של @yossiz...

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

להלן הקריטריונים שניתנו לשאלה:
א. תרגיל מתמטי פשוט
ב. פשוט וזול למעבד (בפשטות מצריך למנוע שימוש עם BigInt)
ג. עמיד בפני פורץ מיומן
ד. הפורץ יודע את התרגיל
ה. הפורץ יכול להזין 30 כניסות ברצף

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

וזה התרגיל הפשוט שעשיתי, לאחר השערה של הטווח של ה-MAX ושל המספר המפענח. נתתי למחשב לעבוד, הוא מצא את הפתרון אחרי שניה.

@ארי אין שום הגיון שתוכנה ב-32 סיביות תהיה יותר טובה מתוכנה של 64 סיביות, למעבד 64 סיביות.

אם זה יגדיל את המהירות, זה לא בטוח, אבל מה שבטוח שזה לא יאט את המהירות.

ככה לענ"ד.

@OdedDvir אמר בהתקנת חבילות Nuget במחשב לא מקוון:

@קומפיונט אם אתה עובד עם VS, תנסה להוסיף את המיקום של החבילות ל NuGet Package Manager:

זה הדבר הראשון שעשיתי...

ב"ה הצלחתי לעשות שחזור לכל החבילות באמצעות dotnet restore, אחרי הוספה של ידנית של הקובץ 'packages.config' ו 'nuget.config' לתיקיית הפרויקט, אבל כשאני מריץ 'dotnet build --no-restore' אני מקבל את השגיאה הזאת, (למרות שהקובץ project.assets.json קיים בתיקיית obj).

גם כשאני בונה את הפרויקט דרך ה-VS אני מקבל את אותה שגיאה בדיוק.

ת'אמת שכבר התייאשתי...