ขึ้นอยู่กับก้อนกับมู Strings

Squiggles /\_/\/\__/\/\/\/\_/\_/\สนุกที่จะทำบนคีย์บอร์ดเมื่อคุณเบื่อจริงๆ แต่ไม่ได้สร้าง squiggles ทั้งหมดเท่ากัน squiggles บางคนมีความเรียบเนียนเหมือนและบางก้อนเช่น\___/ /\/\/\/\บางคนก็แตกหักเหมือนกัน////_\\\

ภายในNตัวละครทุกตัวมีN-1การแยกตัวอักษร แต่ละแยกเป็นประเภทหนึ่งในสามประเภท squiggle:

• เรียบ (มุม> "90 องศา"):

  \_ __ _/

• หนา (มุม = "90 องศา")

  /\ \/

• แตก (สิ่งที่ไม่ได้เชื่อมต่อ)

  // \\ /_ _\

ลองกำหนดความเรียบเนียนให้เป็นสัดส่วนของรอยต่อที่ราบรื่นด้วยความหนาและความแตกหักที่กำหนดไว้ในทำนองเดียวกัน แต่ละค่าช่วงระหว่างและ0 1ผลรวมของความนุ่มนวล, ความอ้วนและความแตกหักของ squiggle เท่ากับ 1 เสมอ

ตัวอย่างเช่น squiggle /\/\\_//\_มีทางแยกเรียบ 3 จุด, ทางแยกแบบอ้วน 4 อันและทางแยกย่อย 2 จุด มันจึง0.3333ราบรื่น, เป็น0.4444ก้อนและ0.2222หัก

สตริงว่างและสตริงที่มีอักขระเพียงตัวเดียวเท่านั้นที่มีค่าที่ไม่ได้กำหนดอินพุตทั้งหมดจะมีความยาวอย่างน้อย 2 ตัวอักษร

ท้าทาย

เขียนโปรแกรมที่ใช้ความยาวโดยพลการและกำหนดค่าความเรียบความหนาและความแตกหักสองค่า

• คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นที่มีอินพุตผ่าน STDIN, บรรทัดคำสั่งหรือเป็นอาร์กิวเมนต์สตริง
• คุณอาจสันนิษฐานว่าอินพุตมีความยาวอย่างน้อย> = 2และประกอบด้วยอักขระที่/\_มีบรรทัดขึ้นต่อท้ายที่เป็นตัวเลือกเท่านั้น
• พิมพ์ (หรือส่งคืนถ้าฟังก์ชัน) ทั้งสองลอยไปที่ความแม่นยำอย่างน้อย 4 ทศนิยมปัดเศษหรือตัดทอน หากมูลค่าที่แท้จริงคือ2/3ค่าที่ยอมรับได้ประกอบด้วยค่าใด ๆ ระหว่าง0.6666และแม้สิ่งที่ต้องการ0.6667 0.666637104หากค่าที่แน่นอนคือ1/3คำตอบใด ๆ ที่มี0.3333อยู่ถูกต้อง คุณอาจปล่อยค่าศูนย์ต่อท้ายหรือศูนย์นำหน้าถ้าค่าน้อยกว่าหนึ่ง
• เอาต์พุตคู่ใด ๆ ของสามค่าตามที่คุณต้องการเพียงแค่ให้แน่ใจว่าได้ระบุว่าสองและในลำดับใด

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ตัวอย่าง

/\/\\/\//\\→ความนุ่มนวลความ0หนาความ0.7แตกหัก0.3

_/\\_/\\/__/\\\//_→ความนุ่มนวลความ0.29411764705หนาความ0.29411764705แตกหัก0.41176470588

//\\__/_\/→ความนุ่มนวลความ0.3333333หนาความ0.2222222แตกหัก0.4444444

คำถามโบนัส: สิ่งใดที่คุณชอบ squiggles เรียบหรือเป็นก้อนหรือแตก?

Pyth, 25 ไบต์

mcl@.:d2.:z2tlzc2"\__//\/

ชุดทดสอบ

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

Japt, 42 ไบต์

U=U¬ä@2+"\\/\\__/"bX+Y)f2};[T2]£U¬fX l /Ul

ความร้าวฉานเอาท์พุท ลองออนไลน์!

มันทำงานอย่างไร

            // Implicit: U = input string
U=UŠ@   }  // Set U to U split into chars, with each pair mapped by this function:
"..."bX+Y)  // Take the index in this string of the two chars concatenated.
            // This is 0-1 for chunky, 2-4 for smooth, and -1 for broken.
2+    f2    // Add two and floor to the nearest multiple of 2.
            // This is now 2 for chunky, 4 or 6 for smooth, and 0 for broken.
[T2]£       // Map each item X in [0,2] through this function:
U¬fX l      //  Count the occurances of X in U.
/Ul         //  Divide by U.length.
            // Implicit: output last expression

รุ่นที่ไม่ใช่การแข่งขัน 36 ไบต์

U=Uä@2+"\\/\\__/"bZ)f2};[T2]£UèX /Ul

ทำงานโดยทั่วไปเหมือนกับวิธีอื่นโดยมีการเปลี่ยนแปลงเล็กน้อย:

• äตอนนี้ทำงานบนสตริง (X, Y, X+Y)ตัวอักษรจะถูกส่งผ่านเข้าสู่ฟังก์ชั่นในการสั่งซื้อ
• è นับจำนวนการเกิดขึ้นของอาร์กิวเมนต์ในสตริง / อาร์เรย์

Python 3, 149 ไบต์

สิ่งนี้ให้ผลลัพธ์ที่ราบรื่นและเป็นก้อน

def f(s):
 for i in"012":s=s.replace("\_/"[int(i)],i)
 a=len(s)-1;t=["bscbssbbc"[int(s[i:i+2],3)]for i in range(a)]
 for x in"sc":print(t.count(x)/a)

Ungolfed:

def f(s):
    for i in "012":
        s = s.replace("\_/"[int(i)], i)
    a = len(s) - 1
    t = []
    for i in range(a):
        t.append("bscbssbbc"[int(s[i:i+2],3)])
    for x in "sc":
        print(t.count(x) / a)

ทับทิม, 71

ให้ผลลัพธ์ที่ราบรื่นและเป็นก้อน

ใช้สตริงที่ราบรื่นและเป็นก้อนน้อยที่สุดแล้วค้นหาสตริงสองอักขระทุกตัวในสตริงเริ่มต้น

ขอบคุณKevin Lauสำหรับ EIGHT bytes!

->x{%w{\\__/ /\\/}.map{|t|(0..n=x.size-2).count{|i|t[x[i,2]]}/(n+1.0)}}