คำถามติดแท็ก random

พิจารณาวิธีการสุ่มองค์ประกอบในอาร์เรย์ คุณจะเขียนการทดสอบหน่วยที่เรียบง่าย แต่มีประสิทธิภาพเพื่อให้แน่ใจว่าสิ่งนี้ทำงานได้อย่างไร ฉันคิดสองแนวคิดซึ่งทั้งสองอย่างนี้มีข้อบกพร่องที่สังเกตได้: สับเปลี่ยนอาร์เรย์จากนั้นตรวจสอบให้แน่ใจว่าคำสั่งนั้นแตกต่างจากก่อนหน้า สิ่งนี้ฟังดูดี แต่ล้มเหลวหากการสลับแบบสุ่มเกิดขึ้นในลำดับเดียวกัน (น่าจะเป็นไปได้ แต่เป็นไปได้) สุ่มอาร์เรย์ด้วยเมล็ดที่มีค่าคงที่และตรวจสอบกับเอาต์พุตที่กำหนดไว้ล่วงหน้า สิ่งนี้ขึ้นอยู่กับฟังก์ชั่นการสุ่มส่งคืนค่าเดิมที่ให้เมล็ดเดียวกันเสมอ แต่นี้เป็นบางครั้งสมมติฐานที่ไม่ถูกต้อง พิจารณาฟังก์ชั่นที่สองซึ่งจำลองการทอยลูกเต๋าและส่งกลับตัวเลขสุ่ม คุณจะทดสอบฟังก์ชั่นนี้อย่างไร? คุณจะทดสอบฟังก์ชั่นนี้อย่างไร ... ไม่ส่งคืนตัวเลขภายนอกขอบเขตที่กำหนดหรือไม่ ส่งคืนตัวเลขในการแจกแจงที่ถูกต้องหรือไม่ (ชุดเดียวตายปกติสำหรับลูกเต๋าจำนวนมาก) ฉันกำลังมองหาคำตอบที่ให้ข้อมูลเชิงลึกเกี่ยวกับการทดสอบไม่เพียง แต่ตัวอย่างเหล่านี้ แต่องค์ประกอบแบบสุ่มของรหัสโดยทั่วไป การทดสอบหน่วยเป็นวิธีการแก้ปัญหาที่เหมาะสมหรือไม่ ถ้าไม่มีการทดสอบประเภทใด เพียงเพื่อความสบายใจของทุกคนฉันไม่ได้เขียนตัวสร้างตัวเลขสุ่มของฉันเอง

127 testing  unit-testing  random 

สิ่งที่ผมหมายเกี่ยวกับที่อยู่ในเกือบทุกกวดวิชาที่ฉันได้อ่านเกี่ยวกับภาษาการทำงานเป็นที่หนึ่งในสิ่งที่ดีเกี่ยวกับฟังก์ชั่นคือว่าถ้าคุณเรียกใช้ฟังก์ชันที่มีพารามิเตอร์เดียวกันสองครั้งคุณจะเสมอจบลงด้วย ผลลัพธ์เดียวกัน แล้วคุณสร้างฟังก์ชันที่รับเมล็ดเป็นพารามิเตอร์แล้วส่งกลับตัวเลขสุ่มตามเมล็ดนั้นได้อย่างไร ฉันหมายความว่าสิ่งนี้ดูเหมือนจะขัดแย้งกับหนึ่งในสิ่งที่ดีเกี่ยวกับฟังก์ชั่นใช่มั้ย หรือว่าฉันขาดอะไรบางอย่างที่นี่อย่างสมบูรณ์?

68 functional-programming  functions  random 

ยกตัวอย่างเช่นฉันมีตารางนี้ + ----------------- + | ผลไม้ | น้ำหนัก + ----------------- + | แอปเปิ้ล 4 | | ส้ม 2 | | มะนาว 1 | + ----------------- + ฉันต้องการคืนผลไม้แบบสุ่ม แต่แอปเปิ้ลควรจะเลือก 4 ครั้งบ่อยเท่ามะนาวและ 2 ครั้งบ่อยเท่าส้ม ในกรณีทั่วไปมากขึ้นควรเป็นf(weight)บ่อยครั้ง อัลกอริทึมทั่วไปที่ดีในการใช้พฤติกรรมนี้คืออะไร หรืออาจจะมีอัญมณีบางอย่างที่พร้อมใน Ruby? :) PS ฉันใช้อัลกอริทึมปัจจุบันใน Ruby https://github.com/fl00r/pickup

51 algorithms  ruby  math  random 

ฉันพยายามแก้ปัญหางานอดิเรกที่ต้องสร้างตัวเลขสุ่มนับล้าน แต่ฉันก็รู้ได้อย่างรวดเร็วว่ามันยากที่จะทำให้มันไม่เหมือนใคร ฉันหยิบคู่มือการออกแบบอัลกอริทึมขึ้นมาเพื่ออ่านเกี่ยวกับการสร้างตัวเลขสุ่ม มีย่อหน้าต่อไปนี้ที่ฉันไม่สามารถเข้าใจได้อย่างเต็มที่ น่าเสียดายที่การสร้างตัวเลขสุ่มดูง่ายกว่าที่เป็นจริงมาก อันที่จริงแล้วมันเป็นไปไม่ได้ที่จะไม่สามารถสร้างตัวเลขสุ่มอย่างแท้จริงบนอุปกรณ์ที่กำหนดค่าได้ Von Neumann [Neu63] กล่าวอย่างดีที่สุด:“ ใครก็ตามที่คิดว่าวิธีการเกี่ยวกับเลขคณิตในการสร้างตัวเลขสุ่มนั้นแน่นอนว่าอยู่ในสภาพบาป” สิ่งที่ดีที่สุดที่เราหวังคือตัวเลขสุ่มหลอกลำธารที่ปรากฏเป็น ถ้าพวกเขาถูกสร้างแบบสุ่ม ทำไมจึงเป็นไปไม่ได้ที่จะสร้างตัวเลขสุ่มอย่างแท้จริงในอุปกรณ์กำหนดค่าใด ๆ ประโยคนี้หมายความว่าอย่างไร

47 algorithms  language-agnostic  random 

โครงการปัจจุบันของฉันรวบรัดเกี่ยวข้องกับการสร้าง "เหตุการณ์แบบสุ่ม - จำกัด " ฉันกำลังสร้างตารางการตรวจสอบ บางคนขึ้นอยู่กับข้อ จำกัด ของตารางที่เข้มงวด คุณทำการตรวจสอบสัปดาห์ละครั้งในวันศุกร์เวลา 10:00 น. การตรวจสอบอื่น ๆ คือ "สุ่ม"; มีข้อกำหนดขั้นพื้นฐานที่กำหนดค่าได้เช่น "การตรวจสอบจะต้องเกิดขึ้น 3 ครั้งต่อสัปดาห์", "การตรวจสอบจะต้องเกิดขึ้นระหว่างเวลา 9.00 น. - 21.00 น." และ "ไม่ควรมีการตรวจสอบสองครั้งภายในระยะเวลา 8 ชั่วโมงเดียวกัน" แต่ ภายในข้อ จำกัด ใดก็ตามที่กำหนดค่าไว้สำหรับชุดการตรวจสอบเฉพาะวันที่และเวลาที่เกิดขึ้นไม่ควรคาดเดาได้ การทดสอบหน่วยและ TDD, IMO มีคุณค่าอย่างมากในระบบนี้เนื่องจากสามารถใช้ในการสร้างแบบเพิ่มหน่วยในขณะที่ข้อกำหนดทั้งหมดยังไม่สมบูรณ์และทำให้แน่ใจว่าฉันไม่ได้ "ทำวิศวกรรมมากเกินไป" เพื่อทำสิ่งที่ฉันทำ ตอนนี้ฉันรู้ว่าฉันต้องการ ตารางงานที่เข้มงวดเป็นงานชิ้นเอกสำหรับ TDD อย่างไรก็ตามฉันพบว่ามันยากที่จะกำหนดสิ่งที่ฉันกำลังทดสอบเมื่อฉันเขียนการทดสอบสำหรับส่วนที่สุ่มของระบบ ฉันสามารถยืนยันได้ว่าเวลาทั้งหมดที่ผลิตโดยตัวจัดตารางเวลาจะต้องตกอยู่ภายใต้ข้อ จำกัด แต่ฉันสามารถใช้อัลกอริทึมที่ผ่านการทดสอบดังกล่าวทั้งหมดโดยไม่มีเวลาที่แท้จริง "สุ่ม" มาก ในความเป็นจริงนั้นเป็นสิ่งที่เกิดขึ้นจริง …

41 algorithms  unit-testing  random 

คุณรู้หรือไม่หรือคุณคิดว่ามีอัลกอริทึม "in-head" ที่เป็นประโยชน์และเรียนรู้ได้ง่าย ๆ ที่ให้มนุษย์สร้างตัวเลขสุ่ม (ค่อนข้าง "จริง") หรือไม่? โดย "in-head" ฉันหมายถึง .. โดยเฉพาะอย่างยิ่งไม่มีเครื่องมือหรืออุปกรณ์ภายนอกใด ๆ นอกจากนี้ยังต้องการการส่งออกสูง (ตัวเลขสุ่มหลายต่อนาที) ถามในเรื่องนี้ แต่มันก็ไม่ได้รับความสนใจมากนัก บางทีนี่อาจจะเหมาะสำหรับโปรแกรมเมอร์

37 self-improvement  algorithms  random 

ฉันมีคลาสที่ตั้งใจจะสร้างรหัสผ่านแบบสุ่มที่มีความยาวซึ่งก็สุ่ม แต่ จำกัด ให้อยู่ระหว่างระยะเวลาที่กำหนดและความยาวสูงสุด ฉันกำลังสร้างการทดสอบหน่วยและวิ่งเข้าไปในอุปสรรค์เล็ก ๆ น้อย ๆ ที่น่าสนใจกับชั้นเรียนนี้ แนวคิดทั้งหมดที่อยู่เบื้องหลังการทดสอบหน่วยคือควรทำซ้ำได้ หากคุณใช้การทดสอบร้อยครั้งก็ควรให้ผลลัพธ์เดียวกันร้อยครั้ง หากคุณขึ้นอยู่กับทรัพยากรบางอย่างที่อาจมีหรือไม่มีอยู่หรืออาจจะอยู่หรืออาจไม่อยู่ในสถานะเริ่มต้นที่คุณคาดหวังจากนั้นคุณตั้งใจจะจำลองทรัพยากรที่มีปัญหาเพื่อให้แน่ใจว่าการทดสอบของคุณทำซ้ำได้เสมอ แต่สิ่งที่เกี่ยวกับในกรณีที่ SUT ควรจะสร้างผลผลิตไม่แน่นอน? หากฉันแก้ไขความยาวขั้นต่ำและความยาวสูงสุดเป็นค่าเดียวกันฉันสามารถตรวจสอบได้อย่างง่ายดายว่ารหัสผ่านที่สร้างขึ้นนั้นมีความยาวตามที่คาดหวัง แต่ถ้าฉันระบุช่วงของความยาวที่ยอมรับได้ (พูด 15 - 20 ตัวอักษร) ตอนนี้คุณมีปัญหาที่คุณสามารถรันการทดสอบได้ร้อยครั้งและได้รับ 100 ครั้ง แต่ในการวิ่งครั้งที่ 101 คุณอาจได้รับสตริงอักขระ 9 คืน ในกรณีของคลาสรหัสผ่านซึ่งค่อนข้างง่ายที่แกนกลางของมันก็ไม่ควรพิสูจน์ปัญหาใหญ่ แต่มันทำให้ฉันคิดถึงกรณีทั่วไป กลยุทธ์ที่มักได้รับการยอมรับว่าเป็นกลยุทธ์ที่ดีที่สุดเมื่อจัดการกับ SUT ที่สร้างผลลัพธ์ไม่แน่นอนโดยการออกแบบคืออะไร

37 unit-testing  random 

ฉันกำลังมองหาข้อเสนอแนะ pseudocode สำหรับจัดเรียงไฟล์ mp3 ของฉันในทางที่หลีกเลี่ยงชื่อและศิลปินซ้ำ ฉันฟัง crooners - Frank Sinatra, Tony Bennett, Ella Fitzgerald ฯลฯ ร้องเพลงมาตรฐานเก่า ศิลปินแต่ละคนบันทึกเพลงเดียวกันหลายเพลง - Fly Me To The Moon, The Way You Look Tonight, Stardust ฯลฯ เป้าหมายของฉันคือการจัดเรียงเพลง (หรือสั่งซื้อเพลย์ลิสต์) ด้วยพื้นที่สูงสุดระหว่างศิลปินและชื่อเพลง ดังนั้นถ้าฉันมี 2,000 เพลงและ 20 เพลงเป็นโดยเอลล่าฉันอยากจะได้ยินเธอเพียงครั้งเดียวในทุก ๆ 100 เพลง หากศิลปิน 10 คนร้องเพลง Fly Me To The Moon ฉันอยากได้ยินทุก …

33 c#  algorithms  sorting  random  collections 

มีใครทำวิจัยจริงเกี่ยวกับความน่าจะเป็นของการชนของ UUID โดยเฉพาะกับ UUIDs รุ่นที่ 4 (สุ่ม) เนื่องจากเครื่องกำเนิดหมายเลขสุ่มที่เราใช้นั้นไม่ได้สุ่มอย่างแท้จริงและเราอาจมีเครื่องที่เหมือนกันหลายสิบหรือหลายร้อยเครื่องทำงานด้วยรหัสเดียวกัน สร้าง UUIDs หรือไม่ เพื่อนร่วมงานของฉันพิจารณาการทดสอบว่าการชนกันของ UUID นั้นเป็นการเสียเวลาอย่างสมบูรณ์ แต่ฉันมักจะใส่รหัสเพื่อตรวจสอบข้อยกเว้นคีย์ซ้ำจากฐานข้อมูลและลองใหม่ด้วย UUID ใหม่ แต่นั่นจะไม่แก้ปัญหาถ้า UUID มาจากกระบวนการอื่นและอ้างถึงวัตถุจริง

33 random  uuid 

ฉันเพิ่งเห็นคำถามนี้ที่ math.SE มันทำให้ฉันคิด สามารถใช้ Pi เป็นเครื่องมือสร้างตัวเลขสุ่มแบบสุ่มได้หรือไม่? ฉันหมายถึงผลลัพธ์เป็นที่รู้จักกันดี (คำนวณว่า pi ได้รับมานานเท่าไหร่แล้วตอนนี้?) แต่ Pi ก็ดูเหมือนจะสุ่มเมื่อใช้ตัวเลข 1 หลักในแต่ละครั้ง สิ่งนี้สมเหตุสมผลหรือไม่?

30 algorithms  language-agnostic  math  random 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 8 ปีที่ผ่านมา ฉันแค่ไตร่ตรองเกี่ยวกับrand()ฟังก์ชั่นPHP และคิดเกี่ยวกับวิธีที่ฉันสามารถสร้างมันขึ้นมาใหม่และฉันก็ประหลาดใจอย่างสมบูรณ์ เครื่องกำเนิดตัวเลขสุ่มทำงานอย่างไร

23 random  numbers 

ฉันได้อ่านในหลาย ๆ แหล่งว่าผลลัพธ์ของ rand () ของ PHP นั้นสามารถคาดเดาได้ว่าเป็น PRNG และฉันยอมรับในความเป็นจริงเพียงเพราะฉันเห็นมันในหลาย ๆ ที่ ฉันสนใจในแนวคิดการพิสูจน์: ฉันจะไปทำนายผลของแรนด์ () ได้อย่างไร? จากการอ่านบทความนี้ฉันเข้าใจว่าตัวเลขสุ่มคือตัวเลขที่ส่งคืนจากรายการเริ่มต้นที่ตัวชี้ (เมล็ด) - แต่ฉันไม่สามารถจินตนาการได้ว่าสิ่งนี้จะคาดเดาได้อย่างไร ใครบางคนสามารถคิดว่า # สุ่มสร้างขึ้นผ่าน rand () ในช่วงเวลาที่กำหนดภายในไม่กี่พันเดา? หรือแม้แต่ 10,000 คำเดา? อย่างไร? สิ่งนี้กำลังจะเกิดขึ้นเพราะฉันเห็นห้องสมุดรับรองความถูกต้องซึ่งใช้ rand () เพื่อสร้างโทเค็นสำหรับผู้ใช้ที่มีรหัสผ่านหายไปและฉันคิดว่านี่เป็นช่องโหว่ความปลอดภัย ฉันได้แทนที่เมธอดด้วยการแฮชผสมopenssl_random_pseudo_bytes()กับรหัสผ่านแบบแฮชแบบดั้งเดิมและ microtime หลังจากทำสิ่งนี้ฉันก็รู้ว่าถ้าฉันอยู่ข้างนอกฉันก็ไม่รู้ว่าจะเดาโทเค็นได้อย่างไรแม้จะรู้ว่ามันเป็น md5 of rand ()

21 security  random 

ฉันต้องการใช้สตริงที่สร้างขึ้นแบบสุ่มสำหรับ ID ทรัพยากรของฉันดังนั้นฉันอาจมี URL ที่สั้นกว่านี้: / user / 4jz0k1 แต่ฉันไม่เคยทำเพราะฉันกังวลเกี่ยวกับการสร้างสตริงแบบสุ่มที่สร้างคำที่แท้จริงเช่น: / user / f * cker สิ่งนี้ทำให้เกิดปัญหาสองประการ: อาจทำให้ผู้ใช้สับสนหรืออาจทำให้เกิดความไม่พอใจและอาจทำให้เกิดปัญหากับ SEO ได้เช่นกัน จากนั้นฉันคิดว่าสิ่งที่ฉันต้องทำคือตั้งค่ารูปแบบคงที่เช่นเพิ่มตัวเลขทุกตัวอักษร 2 ตัว ฉันมีความสุขมากกับวิธี 'generate_safe_uuid' ของฉัน แต่แล้วฉันก็รู้ว่ามันดีกว่าสำหรับ SEO และแย่กว่าสำหรับผู้ใช้เพราะมันเพิ่มอัตราส่วนของคำที่สร้างขึ้นจริงเช่น: / user / g4yd1ck5 ตอนนี้ฉันคิดว่าฉันสามารถสร้างวิธีการ 'replace_numbers_with_letters' และตรวจสอบว่ามันไม่ได้สร้างคำใด ๆ กับพจนานุกรมหรืออะไรบางอย่าง ความคิดอื่น ๆ ? PS เมื่อฉันเขียนสิ่งนี้ฉันก็ตระหนักว่าการตรวจสอบคำในภาษามากกว่าหนึ่งภาษา (เช่น: อังกฤษและฝรั่งเศส, สเปน, ฯลฯ ) จะเป็นเรื่องยุ่งเหยิงและฉันก็เริ่มหลงรัก ID …

20 random  uuid 

เมื่อทำงานวิจัยและพัฒนาฉันมักพบว่าตัวเองกำลังเขียนโปรแกรมที่มีการสุ่มในระดับสูงในพฤติกรรมของพวกเขา ตัวอย่างเช่นเมื่อฉันทำงานในการเขียนโปรแกรมทางพันธุกรรมฉันมักจะเขียนโปรแกรมที่สร้างและรันซอร์สโค้ดแบบสุ่มโดยพลการ ปัญหาเกี่ยวกับการทดสอบรหัสดังกล่าวคือข้อผิดพลาดมักจะเป็นระยะ ๆ และอาจเป็นเรื่องยากที่จะทำซ้ำ สิ่งนี้นอกเหนือไปจากการตั้งค่าเมล็ดพันธุ์แบบสุ่มเป็นค่าเดียวกันและเริ่มต้นการดำเนินการ ตัวอย่างเช่นโค้ดอาจอ่านข้อความจาก kernal ring buffer จากนั้นทำการข้ามแบบมีเงื่อนไขกับเนื้อหาข้อความ ตามปกติสถานะของบัฟเฟอร์บัฟเฟอร์จะเปลี่ยนไปเมื่อพยายามทำซ้ำอีกครั้งในภายหลัง แม้ว่าพฤติกรรมนี้เป็นคุณสมบัติที่สามารถเรียกใช้รหัสอื่นในวิธีที่ไม่คาดคิดและมักจะพบข้อบกพร่องที่หน่วยทดสอบ (หรือผู้ทดสอบมนุษย์) ไม่พบ มีการกำหนดแนวปฏิบัติที่ดีที่สุดสำหรับระบบทดสอบประเภทนี้หรือไม่? ถ้าเป็นเช่นนั้นการอ้างอิงบางอย่างจะมีประโยชน์มาก ถ้าไม่คำแนะนำอื่น ๆ ยินดีต้อนรับ!

14 testing  unit-testing  operating-systems  random 

ฉันได้รับ / dev / random เป็นแหล่งข้อมูลที่ดีของเอนโทรปีและเป็นสิ่งที่ใช้กันทั่วไป - มันก็เหมือนกับที่ฉันอ่านบน GC อย่างน้อยใน Java ดูเหมือนว่าเป็นที่ยอมรับว่า daemon การรวบรวมขยะเรียกใช้งานแบบไม่กำหนดค่า . ถ้าเป็นจริงทำไมเราไม่ใช้เวลาของการรวบรวมขยะเป็นแหล่งของเอนโทรปีแทนที่จะเป็นตัวแปร / dev / random?

13 random  garbage-collection