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

• จอห์น
• เจน

จากนั้นคุณแยกชื่อเหล่านี้ด้วยคำว่ารัก คุณสามารถเขียนสิ่งนี้ในหนึ่งบรรทัดหรือในบรรทัดใหม่

จอห์น
รัก
เจน

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

J: 2 ([J] ohn | [J] ane)
O: 2 (J [o] hn | L [o] ves)
H: 1 (Jo [h] n)
N: 2 (Joh [n] | Ja [n] e)
__
L: 1 ([L] oves)
O: ข้าม
V: 1 (แท้จริง [v] es)
E: 2 (Lov [e] s | Jan [e])
S: 1 (รัก [s ])
__
J: ข้าม
A: 1 (J [a] ne)
N: ข้าม
E: ข้าม
__
ผลสุดท้าย: 2 2 1 2 1 1 2 1 1 1

ขั้นตอนต่อไปจะเป็นการเพิ่มตัวเลขที่ทำงานจากภายนอกเข้าสู่กลาง

2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 1 1 2 1 1 (1 + 2 = 3)
2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 2 1 1 (1)
__
ผล: 3 3 3 3 1

คุณจะทำเช่นนี้ต่อไปจนกว่าคุณจะมีจำนวนเต็มเหลือน้อยกว่าหรือเท่ากับ 100

3 3 3 3 1 1
4 6 3
76%

อาจเกิดขึ้นได้ว่าผลรวมของตัวเลข 2 หลักกลายเป็น≥ 10 ในกรณีนี้ตัวเลขจะถูกแบ่งเป็น 2 ในแถวถัดไป
ตัวอย่าง:

5 3 1 2 5 4 1 8
13 (จะใช้เป็น 1 3)
1 3 4 5 7
8 8 4 (8 + 4 = 12 ใช้เป็น 1 2)
1 2 8
92%

ความต้องการ

• โปรแกรมของคุณควรจะยอมรับชื่อใด ๆ ที่มีความยาวพอสมควร (100 ตัวอักษร)
• อนุญาตให้ใช้อักขระ [A..Z, a..z]
• กรณีตายดังนั้น A == a

ฟรีสำหรับคุณที่จะตัดสินใจ

• วิธีจัดการกับอักขระพิเศษ (Ö, èเป็นต้น)
• รวมนามสกุลใช่หรือไม่ช่องว่างจะถูกละเว้น
• ภาษาใดก็ได้ที่ได้รับอนุญาต

ผู้ชนะจะได้รับการพิจารณาโหวตใน วันที่ 28กุมภาพันธ์

การเข้ารหัสที่มีความสุข

ป.ล. นี่เป็นครั้งแรกที่ฉันวางบางสิ่งบางอย่างที่นี่ถ้ามีวิธีปรับปรุงให้รู้สึกอิสระที่จะแจ้งให้เราทราบ = 3

แก้ไข:เปลี่ยนวันที่สิ้นสุดเป็นวันวาเลนไทน์คิดว่าจะเหมาะสมกว่าสำหรับความท้าทายนี้ :)

Sclipting

글⓵닆뭶뉗밃變充梴⓶壹꺃뭩꾠⓶꺐合合替虛終梴⓷縮⓶終併❶뉀大套鈮⓶充銻⓷加⓶鈮⓶終併❶뉀大終깐

คาดว่าอินพุตเป็นคำสองคำที่คั่นด้วยช่องว่าง (เช่นJohn Jane) เป็นตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ แต่รองรับเฉพาะอักขระที่ไม่ใช่อักขระ regex พิเศษ (ดังนั้นอย่าใช้(หรือ*ในชื่อของคุณ!) นอกจากนี้ยังคาดว่าจะมีเพียงสองคำเท่านั้นดังนั้นหากความรักที่คุณสนใจคือ“ แมรี่เจน” คุณต้องใส่MaryJaneคำเดียว มิฉะนั้นจะประเมินว่า "YourName รัก Mary รัก Jane"

คำอธิบาย

ส่วนที่ยากที่สุดคือการจัดการกับจำนวนตัวเลขคี่: คุณต้องปล่อยให้อยู่ตรงกลางหลักเพียงอย่างเดียวแทนที่จะเพิ่มด้วยตัวเอง ฉันคิดว่าทางออกของฉันน่าสนใจ

글⓵닆뭶뉗밃變 | replace space with "loves"
充 | while non-empty...
    梴 | get length of string
    ⓶壹 | get first character of string (let’s say it’s “c”)
    꺃뭩꾠⓶꺐合合 | construct the regex “(?i:c)”
    替虛終 | replace all matches with empty string
    梴 | get new length of that
    ⓷縮 | subtract the two to get a number
    ⓶ | move string to front
終 | end while
併 | Put all the numbers accrued on the stack into a single string
❶뉀大 | > 100
套 | while true...
    鈮⓶ | chop off the first digit
    充 | while non-empty... (false if that digit was the only one!)
        銻⓷加 | chop off last digit and add them
        ⓶鈮⓶ | chop off the first digit again
                 (returns the empty string if the string is empty!)
    終 | end while
    併 | Put all the numbers (± an empty string ;-) ) on the stack into a single string
    ❶뉀大 | > 100
終 | end while
깐 | add "%"

เมื่อคุณเหลืออะไรสักอย่าง≤ 100, ลูปก็จะจบลง, คำตอบจะอยู่ที่สแต็คและเอาท์พุท

funciton

โปรแกรมนี้คาดว่าอินพุตจะถูกคั่นด้วยช่องว่าง (เช่นJohn Jane) เป็นตัวพิมพ์เล็กและตัวพิมพ์ใหญ่สำหรับตัวอักษร AZ / az; สำหรับอักขระ Unicode อื่นใดมันจะ "สร้างความสับสน" ให้กับอักขระสองตัวที่มีค่าเท่ากันเมื่อ or'ed ด้วย 32 (เช่นĀและĠหรือหรือ?และ_) นอกจากนี้ฉันไม่ทราบว่าโปรแกรมนี้จะทำอย่างไรถ้าอินพุตมีอักขระ NUL ( \0) ดังนั้นอย่าใช้ :)

นอกจากนี้ตั้งแต่ StackExchange เพิ่มระยะห่างระหว่างบรรทัดมากเกินไปนี่คือข้อความดิบบน Pastebin หรือเรียกใช้รหัสต่อไปนี้ในคอนโซล JavaScript ของเบราว์เซอร์เพื่อแก้ไขได้ที่นี่:$('pre').css('line-height',1)

                               ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖
                               ║ Ḷ ║┌╢ Ọ ╟┐║ Ṿ ║ ║ Ẹ ║┌╢ Ṛ ╟┐║ Ṣ ╟┐
                               ╙─┬─╜│╙───╜│╙─┬─╜ ╙─┬─╜│╙─┬─╜│╙─┬─╜│
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  └───────────┐
                                 │  │     │  │     │  │  │  │  └─────────────┐│
                         ┌───────┘  │     │  │     │  │  │  └───────────────┐││
                         │┌─────────┘     │  │     │  │  └─────────────────┐│││
                         ││┌──────────────┘  │     │  └───────────────────┐││││
                         │││     ┌───────────┘     └──────────────────┐   │││││
                         │││ ┌───┴───┐  ┌─────────────────────────────┴─┐ │││││
                         │││ │ ╔═══╗ │  │                               │ ││││└─────────┐
                         │││ │ ║ 2 ║ │  │     ┌───┐   ┌───┐             │ │││└─────────┐│
                         │││ │ ║ 1 ║ │  │    ┌┴┐  │  ┌┴┐  │             │ ││└─────────┐││
                         │││ │ ║ 1 ║ │  │    └┬┘  │  └┬┘  │             │ │└─────────┐│││
┌────────────────────────┘││ │ ║ 1 ║ │  │   ┌─┴─╖ │ ┌─┴─╖ │     ┌───╖   │ └─────────┐││││
│┌────────────────────────┘│ │ ║ 0 ║ │  │   │ ♯ ║ │ │ ♯ ║ ├─────┤ ℓ ╟───┴─┐         │││││
││┌────────────────────────┘ │ ║ 6 ║ │  │   ╘═╤═╝ │ ╘═╤═╝ │     ╘═══╝   ┌─┴─╖       │││││
│││                    ┌─────┘ ║ 3 ║ │  │    ┌┴┐  │  ┌┴┐  └─────────────┤ · ╟──────┐│││││
│││┌───────────────────┴┐┌───╖ ║ 3 ║ │  │    └┬┘  │  └┬┘                ╘═╤═╝      ││││││
││││                   ┌┴┤ = ╟─╢ 3 ║ │  │ ┌───┘   └───┴─────┐         ┌───┴───┐    ││││││
││││      ╔════╗ ┌───╖ │ ╘═╤═╝ ║ 1 ║ │  │ │ ╔═══╗         ┌─┴─╖       │ ╔═══╗ │    ││││││
││││      ║ 37 ╟─┤ ‼ ╟─┘ ┌─┘   ║ 9 ║ │  │ │ ║ 1 ║ ┌───────┤ · ╟─┐     │ ║ 0 ║ │    ││││││
││││      ╚════╝ ╘═╤═╝  ┌┴┐    ║ 6 ║ │  │ │ ╚═╤═╝ │       ╘═╤═╝ ├─────┘ ╚═╤═╝ │    ││││││
││││ ┌───╖ ┌───╖ ┌─┴─╖  └┬┘    ║ 3 ║ │  │ │ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │    ││││││
│││└─┤ Ẹ ╟─┤ Ṿ ╟─┤ ? ╟───┤     ║ 3 ║ │  │ └─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘    ││││││
│││  ╘═══╝ ╘═══╝ ╘═╤═╝  ┌┴┐    ║ 7 ║ │  │   ╘═╤═╝   ╚═══╝ ╘═╤═╝   ╚═══╝ ╘═╤═╝      ││││││
│││                │    └┬┘    ╚═══╝ │  │     │  ┌──────────┘             └──────┐ ││││││
│││              ╔═══╗ ┌─┴─╖ ┌───╖   │  │     │  │ ┌─────────╖ ┌───╖ ┌─────────╖ │ ││││││
│││              ║ 3 ╟─┤ > ╟─┤ ℓ ╟───┘  │     │  └─┤ str→int ╟─┤ + ╟─┤ str→int ╟─┘ ││││││
│││              ╚═══╝ ╘═══╝ ╘═══╝      │     │    ╘═════════╝ ╘═╤═╝ ╘═════════╝   ││││││
││└───────────────────────────────────┐ │     │             ┌────┴────╖            ││││││
│└───────────────────────────────┐    │ │     │             │ int→str ║            ││││││
│          ╔═══╗                 │    │ │     │ ┌───╖ ┌───╖ ╘════╤════╝            ││││││
│          ║ 0 ║                 │    │ │     └─┤ Ẹ ╟─┤ ‼ ╟──────┘                 ││││││
│          ╚═╤═╝                 │    │ │       ╘═══╝ ╘═╤═╝   ┌────────────────────┘│││││
│    ╔═══╗ ┌─┴─╖                 │    │ │             ┌─┴─╖ ┌─┴─╖ ╔═══╗             │││││
│    ║ 1 ╟─┤ ʃ ╟─────────────────┴┐   │ └─────────────┤ ? ╟─┤ ≤ ║ ║ 2 ║             │││││
│    ╚═══╝ ╘═╤═╝                  │   │               ╘═╤═╝ ╘═╤═╝ ╚═╤═╝             │││││
│          ┌─┴─╖                  │   │                 │     └─────┘               │││││
│        ┌─┤ Ṣ ╟──────────────────┴┐  │    ╔═══╗   ┌────────────────────────────────┘││││
│        │ ╘═╤═╝                   │  │    ║   ║   │  ┌──────────────────────────────┘│││
│        │ ┌─┴─╖                   │  │    ╚═╤═╝   │  │    ┌──────────────────────────┘││
│        └─┤ · ╟─────────────┐     │  │    ┌─┴─╖   │┌─┴─╖┌─┴─╖                         ││
│          ╘═╤═╝             │     │  │    │ Ḷ ║   └┤ · ╟┤ · ╟┐                        ││
│      ┌─────┴───╖         ┌─┴─╖ ┌─┴─╖│    ╘═╤═╝    ╘═╤═╝╘═╤═╝│                        ││
│      │ int→str ║ ┌───────┤ · ╟─┤ · ╟┴┐     │      ┌─┴─╖  │  │                        ││
│      ╘═════╤═══╝ │       ╘═╤═╝ ╘═╤═╝ │           ┌┤ · ╟──┘  │                        ││
│            │   ┌─┴─╖ ┌───╖ │     │   │         ┌─┘╘═╤═╝   ┌─┴─╖                      ││
│            │   │ ‼ ╟─┤ Ọ ╟─┘     │   │         │ ┌──┴─────┤ · ╟───────┐              ││
│            │   ╘═╤═╝ ╘═╤═╝       │   │         │ │ ╔════╗ ╘═╤═╝ ╔═══╗ │              ││
│            └─────┘     │         │   │         │ │ ║ 21 ║   │   ║ 2 ║ │              ││
│                ┌───╖ ┌─┴─╖       │   │  ┌──────┘ │ ╚═══╤╝   │   ║ 0 ║ │              ││
│            ┌───┤ Ṿ ╟─┤ ? ╟───────┘   │  │┌───╖ ┌─┴─╖ ┌─┴──╖ │   ║ 9 ║ │              ││
│            │   ╘═══╝ ╘═╤═╝           │ ┌┴┤ ♯ ╟─┤ Ṛ ╟─┤ >> ║ │   ║ 7 ║ │              ││
│            │           │             │ │ ╘═══╝ ╘═╤═╝ ╘══╤═╝ │   ║ 1 ║ │              ││
│            └─────────┐   ┌───────────┘ │ ╔═══╗ ┌─┴─╖    ├───┴─┬─╢ 5 ║ │              ││
└───────────────────┐  └───┘             │ ║ 0 ╟─┤ ? ╟────┘     │ ║ 1 ║ │              ││
╔════╗              │                    │ ╚═══╝ ╘═╤═╝   ┌──────┤ ╚═══╝ │              ││
║ 21 ║              │                    │       ┌─┴─╖ ┌─┴─╖ ╔══╧══╗    │              ││
╚═╤══╝              │                    └───────┤ ? ╟─┤ ≠ ║ ║ −33 ║    │              ││
┌─┴─╖ ┌────╖        │                            ╘═╤═╝ ╘═╤═╝ ╚══╤══╝   ┌┴┐             ││
│ × ╟─┤ >> ╟────────┴────────────┐                 │     └──────┤      └┬┘             ││
╘═╤═╝ ╘═╤══╝ ┌───╖   ╔═════════╗ │                              └───────┘              ││
┌─┴─╖   └────┤ ‼ ╟───╢ 2224424 ║ │                ┌────────────────────────────────────┘│
│ ♯ ║        ╘═╤═╝   ║ 4396520 ║ │                │    ┌────────────────────────────────┘
╘═╤═╝        ┌─┴─╖   ║ 1237351 ║ │                │    │    ┌─────────────────────┐
  └──────────┤ · ╟─┐ ║ 2814700 ║ │                │  ┌─┴─╖  │     ┌─────┐         │
             ╘═╤═╝ │ ╚═════════╝ │              ┌─┴──┤ · ╟──┤     │    ┌┴┐        │
 ╔═══╗ ┌───╖ ┌─┴─╖ │   ╔════╗    │            ┌─┴─╖  ╘═╤═╝┌─┴─╖   │    └┬┘        │
 ║ 0 ╟─┤ Ọ ╟─┤ ‼ ║ │   ║ 32 ║    │   ┌────────┤ · ╟────┴──┤ Ṛ ╟───┤   ┌─┴─╖       │
 ╚═══╝ ╘═╤═╝ ╘═╤═╝ │   ╚═╤══╝    │   │        ╘═╤═╝       ╘═╤═╝   │   │ ♯ ║       │
         │   ┌─┴─╖ ├─┐ ┌─┴─╖     │ ┌─┴─╖      ┌─┴─╖       ╔═╧═╗   │   ╘═╤═╝       │
           ┌─┤ ʃ ╟─┘ └─┤ ʘ ║     │┌┤ · ╟──────┤ · ╟───┐   ║ 1 ║   │    ┌┴┐        │
           │ ╘═╤═╝     ╘═╤═╝     ││╘═╤═╝      ╘═╤═╝   │   ╚═══╝   │    └┬┘        │
           │ ╔═╧═╗       ├───────┘│  │       ┌──┴─╖ ┌─┴─╖ ┌───╖ ┌─┴─╖ ┌─┴─╖ ╔═══╗ │
           │ ║ 0 ║       │        │  │       │ >> ╟─┤ Ṣ ╟─┤ ‼ ╟─┤ · ╟─┤ ʃ ╟─╢ 0 ║ │
           │ ╚═══╝       │        │  │       ╘══╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╚═══╝ │
           └─────────────┘        │  │ ╔════╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┘     ├─────────┘
                                  │  │ ║ 21 ╟─┤ × ╟─┤ · ╟─┤ · ╟─┴─┐     │
                                  │  │ ╚════╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝   │     │
                                  │  └────────────────┘   ┌─┴─╖   │     │
                                  │                   ┌───┤ ? ╟───┴┐    │
                                  │                   │   ╘═╤═╝    │    │
                                  │           ┌───╖ ┌─┴─╖   │    ┌─┴─╖  │
                                  └───────────┤ ♯ ╟─┤ · ╟─┐   ┌──┤ ? ╟─ │
                                              ╘═══╝ ╘═╤═╝ └───┘  ╘═╤═╝  │
                                                      │          ╔═╧═╗  │
                                                      │          ║ 0 ║  │
                                                      │          ╚═══╝  │
                                                      └─────────────────┘

คำอธิบายด่วน

• โปรแกรมเพิ่งใช้เวลา STDIN และโทรḶด้วย

• Ḷพบว่าพื้นที่เป็นครั้งแรกในสตริงแทนที่มันด้วยและส่งผลให้lovesỌ

• Ọใช้อักขระตัวแรกจากสตริงอินพุตซ้ำ ๆ เรียกใช้Ṣพร้อมกันและเชื่อมหมายเลขที่เกิดขึ้นเข้ากับสตริงผลลัพธ์ เมื่อสตริงอินพุตว่างมันจะเรียกṾพร้อมกับสตริงผลลัพธ์

• Ṿเรียกซ้ำ ๆẸจนกระทั่งได้รับผลลัพธ์ที่เท่ากับ"100"หรือมีความยาวน้อยกว่า 3 ( 100สามารถเกิดขึ้นจริง: พิจารณาอินพุตlovvvv eeeeeess) เมื่อเป็นเช่นนั้นมันจะเพิ่ม"%"และส่งคืนนั้น

• Ẹคำนวณหนึ่งซ้ำที่สมบูรณ์ของอัลกอริทึมการคำนวณความรัก; เช่นจะใช้สตริงของตัวเลขและส่งกลับสตริงของตัวเลขถัดไป

• Ṛใช้กองหญ้าและเข็มและค้นหาดัชนีการเกิดขึ้นครั้งแรกของเข็มในกองหญ้าโดยใช้เกณฑ์ตัวพิมพ์เล็กและใหญ่ ( or 32)

• Ṣยิงกองหญ้าและเข็มซ้ำแล้วซ้ำอีกจะนำไปใช้Ṛในการลบทุกกรณีของเข็ม มันจะส่งคืนผลลัพธ์สุดท้ายหลังจากการลบทั้งหมดรวมถึงจำนวนการลบที่ทำ

ทับทิม

     f=IO.         read(
   __FILE__)     .gsub(/[^
 \s]/x,?#);s=   $**'loves';s
.upcase!;i=1;a =s.chars.uniq.
map{|c|s.count(c)};loop{b='';
b<<"#{a.shift.to_i+a.pop.to_i
 }"while(a.any?);d=b.to_i;a=
   b.chars;d<101&&abort(d>
     50?f:f.gsub(/^.*/){
       |s|i=13+i%3;s[\
         i...i]=040.
           chr*3;s
             })}
              V

พิมพ์หัวใจถ้าโอกาสของความสัมพันธ์มากกว่า 50%

$ ruby ♥.rb sharon john
     #####         #####
   #########     #########
 ############   ############
############## ##############
#############################
#############################
 ###########################
   #######################
     ###################
       ###############
         ###########
           #######
             ###
              #

และพิมพ์หัวใจที่แตกสลายถ้าโอกาสต่ำกว่า 50% :(

$ ruby ♥.rb sharon epidemian
     #####            #####
   #########        #########
 ############      ############
##############    ##############
###############   ##############
#############   ################
 #############   ##############
   ############   ###########
     ########   ###########
       #######   ########
         ######   #####
           ##   #####
             #   ##
              # 

จอห์น Frigging ...

ยังไงก็ตามมันเป็นกรณีตายและสนับสนุนการสอบถามภรรยาหลายคน (เช่นruby ♥.rb Alice Bob Carol Dave)

APL, 80

{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}

เพราะความรักคือความรัก โค้ดกอล์ฟคือโค้ดกอล์ฟ (แม้ว่าจะไม่ใช่)

ข้อผูกพัน♥รุ่นที่มีรูปร่าง shaped:

    {f←{m←  2÷⍨≢⍵
  n←+/(⌊m)↑[1]⍵,⍪⌽⍵
n←⍎∊⍕¨n,(⍵[⌈m]/⍨m≠⌊m)
n≤100:n⋄∇⍎¨⍕n}⋄u←⎕UCS
   s←u⍺,'Loves',⍵
       f∪⍦32|s
          }

เวอร์ชัน golfed ทำให้ฉันมีพฤติกรรมที่เอาแน่เอานอนไม่ได้เพราะมีข้อบกพร่อง∪⍦ที่ฉันกำลังตรวจสอบกับนักพัฒนาของ NARS:

      'John'{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
VALUE ERROR

แต่ฉันสามารถเรียกใช้งานแบบตามลำดับและรับผลลัพธ์ที่ถูกต้อง:

      'John'{∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
2 2 1 2 1 1 2 1 1
      {n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}2 2 1 2 1 1 2 1 1
76

จาวาสคริ

อาจจะสะอาดกว่า แต่ก็ใช้งานได้ ตัวอย่างที่ชัดเจน

function z(e) {
    for (var t = 0, c = '', n = e.length - 1; n >= t; n--, t++) {
        c += n != t ? +e[t] + (+e[n]) : +e[t];
    }
    return c
}
for (var s = prompt("Name 1").toLowerCase() + "loves" + prompt("Name 2").toLowerCase(),b = '', r; s.length > 0;) {
    r = new RegExp(s[0], "g");
    b+=s.match(r).length;
    s = s.replace(r, "")
}
for (; b.length > 2; b = z(b)) {}
console.log("Chances of being in love are: " + b + "%")

หลาม

ฉันคิดว่ามันเป็นรหัสกอล์ฟ ...

a=filter(str.isalpha,raw_input()+"loves"+raw_input()).lower();a=[x[1]for x in sorted(set(zip(a,map(str.count,[a]*len(a),a))),key=lambda(x,y):a.index(x))]
while reduce(lambda x,y:x*10+y,a)>100:a=reduce(list.__add__,map(lambda x: x<10 and[x]or map(int,str(x)),[a[n]+a[-n-1]for n in range(len(a)/2)]+(len(a)%2 and[a[len(a)/2]]or[])))
print str(reduce(lambda x,y:x*10+y,a))+"%"

Ungolfed:

a = filter(str.isalpha,
           raw_input() + "loves" + raw_input()).lower()

a = [x[1] for x in sorted(set(zip(a,
                                  map(str.count, [a] * len(a), a))),
                          key=lambda (x, y): a.index(x))]

while reduce(lambda x, y: x * 10 + y, a) > 100:
    a = reduce(list.__add__,
               map(lambda x: x < 10 and [x] or map(int, str(x)), 
                   [a[n] + a[-n - 1] for n in range(len(a) / 2)] + (len(a) % 2 and [a[len(a) / 2]] or [])))

print str(reduce(lambda x, y: x * 10 + y, a)) + "%"

PHP

<?php

$name1 = $argv[1];
$name2 = $argv[2];

echo "So you think {$name1} and {$name2} have any chance? Let's see.\nCalculating if \"{$name1} Loves {$name2}\"\n";

//prepare it, clean it, mince it, knead it
$chances = implode('', array_count_values(str_split(preg_replace('/[^a-z]/', '', strtolower($name1.'loves'.$name2)))));
while(($l = strlen($chances))>2 and $chances !== '100'){
    $time = time();
    $l2 = intval($l/2);
    $i =0;
    $t = '';
    while($i<$l2){
        $t.=substr($chances, $i, 1) + substr($chances, -$i-1, 1);
        $i++;
    }
    if($l%2){
        $t.=$chances[$l2];
    }
    echo '.';
    $chances = $t;
    while(time()==$time){}
}

echo "\nTheir chances in love are {$chances}%\n";
$chances = intval($chances);
if ($chances === 100){
    echo "Great!!\n";
}elseif($chances > 50){
    echo "Good for you :) !!\n";
}elseif($chances > 10){
    echo "Well, it's something.\n";
}else{
    echo "Ummm.... sorry.... :(\n";
}

ผลตัวอย่าง

$ php loves.php John Jane
So you think John and Jane have any chance? Let's see.
Calculating if "John Loves Jane"
...
Their chances in love are 76%
Good for you :) !!

GolfScript

คำตอบรหัสกอล์ฟบังคับใน GolfScript:

' '/'loves'*{65- 32%65+}%''+:x.|{{=}+x\,,}%{''\{)\(@+@\+\.(;}do 0+{+}*+{[]+''+~}%.,((}do{''+}%''+

ยอมรับอินพุตเป็นชื่อที่คั่นด้วยช่องว่างเช่น

echo 'John Jane' | ruby golfscript.rb love.gs
-> 76

C #

using System;
using System.Collections.Generic;
using System.Linq;

namespace LovesMeWhat
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 2) throw new ArgumentException("Ahem, you're doing it wrong.");

            Func<IEnumerable<Int32>, String> fn = null;
            fn = new Func<IEnumerable<Int32>, String> (input => {
                var q = input.SelectMany(i => i.ToString().Select(c => c - '0')).ToArray();

                if (q.Length <= 2) return String.Join("", q);

                IList<Int32> next = new List<Int32>();
                for (int i = 0, j = q.Length - 1; i <= j; ++i, --j)
                {
                    next.Add(i == j ? q[i] : q[i] + q[j]);
                }
                return fn(next);
            });

            Console.Write(fn(String.Concat(args[0], "LOVES", args[1]).ToUpperInvariant().GroupBy(g => g).Select(g => g.Count())));
            Console.Write("%");
            Console.ReadKey(true);
        }
    }
}

Haskell

เวอร์ชันของฉันค่อนข้างยาวเพราะฉันตัดสินใจมุ่งเน้นไปที่ความสามารถในการอ่านฉันคิดว่ามันน่าสนใจที่จะทำให้อัลกอริทึมของคุณเป็นโค้ดเป็นระเบียบ ฉันรวมตัวละครนับเป็นครึ่งทางซ้ายโดยพื้นฐานแล้วมันจะรวมก้อนหิมะเข้าด้วยกันและลำดับคือลำดับของการเกิดขึ้นในสตริง ฉันจัดการเพื่อแทนที่ส่วนของอัลกอริทึมที่โดยปกติจะต้องมีการทำดัชนีอาเรย์ด้วยการดัดลิสต์ ปรากฎว่าอัลกอริทึมของคุณนั้นเกี่ยวข้องกับการพับรายการตัวเลขครึ่งหนึ่งและเพิ่มตัวเลขที่จัดชิดเข้าด้วยกัน มีสองกรณีสำหรับการดัดงอแม้จะแยกรายการไว้ตรงกลางรายการแปลก ๆ จะโค้งอยู่รอบ ๆ องค์ประกอบกลางและองค์ประกอบนั้นจะไม่เข้าร่วม ฟิชชันกำลังจดรายการและแยกตัวเลขที่ไม่ใช่ตัวเลขหลักอีกต่อไปเช่น> = 10 ฉันต้องเขียนตัวเองออกมาฉันไม่แน่ใจว่ามันเป็นตัวจริงหรือเปล่าแต่ดูเหมือนว่าจะทำสิ่งที่ฉันต้องการ สนุก.

import qualified Data.Char as Char
import qualified System.Environment as Env

-- | Takes a seed value and builds a list using a function starting 
--   from the last element
unfoldl :: (t -> Maybe (t, a)) -> t -> [a]
unfoldl f b  =
  case f b of
   Just (new_b, a) -> (unfoldl f new_b) ++ [a]
   Nothing -> []

-- | Builds a list from integer digits
number_to_digits :: Integral a => a -> [a]
number_to_digits n = unfoldl (\x -> if x == 0 
                                     then Nothing 
                                     else Just (div x 10, mod x 10)) n

-- | Builds a number from a list of digits
digits_to_number :: Integral t => [t] -> t
digits_to_number ds = number
  where (number, _) = foldr (\d (n, p) -> (n+d*10^p, p+1)) (0,0) ds

-- | Bends a list at n and returns a tuple containing both parts 
--   aligned at the bend
bend_at :: Int -> [a] -> ([a], [a])
bend_at n xs = let 
                 (left, right) = splitAt n xs
                 in ((reverse left), right)

-- | Takes a list and bends it around a pivot at n, returns a tuple containing 
--   left fold and right fold aligned at the bend and a pivot element in between
bend_pivoted_at :: Int -> [t] -> ([t], t, [t])
bend_pivoted_at n xs
  | n > 1 = let 
              (left, pivot:right) = splitAt (n-1) xs
              in ((reverse left), pivot, right)

-- | Split elements of a list that satisfy a predicate using a fission function
fission_by :: (a -> Bool) -> (a -> [a]) -> [a] -> [a]
fission_by _ _ [] = []
fission_by p f (x:xs)
  | (p x) = (f x) ++ (fission_by p f xs)
  | otherwise = x : (fission_by p f xs)

-- | Bend list in the middle and zip resulting folds with a combining function.
--   Automatically uses pivot bend for odd lists and normal bend for even lists
--   to align ends precisely one to one
fold_in_half :: (b -> b -> b) -> [b] -> [b]
fold_in_half f xs
  | odd l = let 
              middle = (l-1) `div` 2 + 1
              (left, pivot, right) = bend_pivoted_at middle xs
              in pivot:(zipWith f left right)
  | otherwise = let 
                  middle = l `div` 2
                  (left, right) = bend_at middle xs
                  in zipWith f left right
  where 
    l = length xs

-- | Takes a list of character counts ordered by their first occurrence 
--   and keeps folding it in half with addition as combining function
--   until digits in a list form into any number less or equal to 100 
--   and returns that number
foldup :: Integral a => [a] -> a
foldup xs
  | n > 100 = foldup $ fission $ reverse $ (fold_in_half (+) xs)
  | otherwise = n
  where 
    n = (digits_to_number xs)
    fission = fission_by (>= 10) number_to_digits 

-- | Accumulate counts of keys in an associative array
count_update :: (Eq a, Integral t) => [(a, t)] -> a -> [(a, t)]
count_update [] x = [(x,1)]
count_update (p:ps) a
  | a == b = (b,c+1) : ps
  | otherwise = p : (count_update ps a)
  where
    (b,c) = p

-- | Takes a string and produces a list of character counts in order 
--   of their first occurrence
ordered_counts :: Integral b => [Char] -> [b]
ordered_counts s = snd $ unzip $ foldl count_any_alpha [] s
  where 
    count_any_alpha m c
      | Char.isAlpha c = count_update m (Char.toLower c)
      | otherwise = m

-- | Take two names and perform the calculation
love_chances n1 n2 =  foldup $ ordered_counts (n1 ++ " loves " ++ n2) 

main = do
   args <- Env.getArgs
   if (null args) || (length args < 2)
     then do
            putStrLn "\nUSAGE:\n"
            putStrLn "Enter two names separated by space\n"
     else let 
            n1:n2:_ = args 
            in putStrLn $ show (love_chances n1 n2) ++ "%"

ผลลัพธ์บางส่วน:

"Romeo" "Juliet" 97% - การทดสอบเชิงประจักษ์เป็นสิ่งสำคัญ
"Romeo" "Julier" 88% - รุ่นย่อที่ทันสมัย ​​...
"Horst Draper" "Jane" 20%
"Horst Draper" "Jane (Horse)" 70% - มีการพัฒนา ...
"Bender Bender Rodriguez" "Fenny Wenchworth" 41% - Bender พูดว่า "การพับเป็นสำหรับผู้หญิง!"
"Philip Fry" "Turanga Leela" 53% - คุณจะเห็นได้ว่าทำไมต้องใช้เวลา 7 ฤดูกาลในการแต่งงานกับ
"Maria" "Abraham" - 98%
"John" "Jane" 76%

ทับทิม

math = lambda do |arr|
  result = []
  while arr.any?
    val = arr.shift + (arr.pop || 0)
    result.push(1) if val >= 10
    result.push(val % 10)
  end
  result.length > 2 ? math.call(result) : result
end
puts math.call(ARGV.join("loves").chars.reduce(Hash.new(0)) { |h, c| h[c.downcase] += 1; h }.values).join

minified:

l=->{|a|r=[];while a.any?;v=a.shift+(a.pop||0);r.push(1) if v>=10;r.push(v%10) end;r[2]?l[r]:r}
puts l[ARGV.join("loves").chars.reduce(Hash.new(0)){|h, c| h[c.downcase]+=1;h}.values].join

เรียกมันว่า:

$ ruby love.rb "John" "Jane"
76

Python 3

ทางออกง่ายๆที่ไม่ใช้โมดูล I / O สวยพอ

ฉันใช้ข้อผิดพลาดที่จับได้เป็นตัวสำรองเมื่อตัววนซ้ำตัวที่สองอยู่นอกขอบเขต ถ้ามันจับข้อผิดพลาดของดัชนี Python ก็ถือว่า 1 แปลก แต่มันทำงานได้

names = [input("Name 1: ").lower(), "loves", input("Name 2: ").lower()]
checkedLetters = []

def mirrorAdd(n):
    n = [i for i in str(n)]
    if len(n) % 2:
        n.insert(int(len(n)/2), 0)
    return(int(''.join([str(int(n[i]) + int(n[len(n)-i-1])) for i in range(int(len(n)/2))])))

cn = ""

positions = [0, 0]
for i in [0, 1, 2]:
    checkAgainst = [0, 1, 2]
    del checkAgainst[i]
    positions[0] = 0
    while positions[0] < len(names[i]):
        if not names[i][positions[0]] in checkedLetters:
            try:
                if names[i][positions[0]] in [names[checkAgainst[0]][positions[1]], names[checkAgainst[1]][positions[1]]]:
                    positions[1] += 1
                    cn = int(str(cn) + "2")
                else:
                    cn = int(str(cn) + "1")
            except:
                cn = int(str(cn) + "1")
            checkedLetters.append(names[i][positions[0]])
        positions[0] += 1

print("\n" + str(cn))

while cn > 100:
    cn = mirrorAdd(cn)
    print(cn)

print("\n" + str(cn) + "%")

นี่คือตัวอย่างการเรียกใช้:

Name 1: John
Name 2: Jane

221211211
33331
463
76

76%

ชวา

อาจเกิดขึ้นได้ว่าผลรวมของตัวเลข 2 หลักมากกว่า 10 ในกรณีนี้ตัวเลขจะถูกแบ่งเป็น 2 ในแถวถัดไป

เกิดอะไรขึ้นถ้าจำนวนเท่ากับ 10? ฉันเพิ่งเพิ่ม 1 และ 0 ถูกต้องไหม

ฉันตัดสินใจที่จะไม่สนใจกรณี

public class LoveCalculation {
    public static void main(String[] args) {
        String chars = args[0].toLowerCase() + "loves" + args[1].toLowerCase();
        ArrayList<Integer> charCount = new ArrayList<Integer>();
        HashSet<Character> map = new HashSet<Character>();
        for(char c: chars.toCharArray()){
            if(Pattern.matches("[a-z]", "" + c) && map.add(c)){
                int index = -1, count = 0;
                while((index = chars.indexOf(c, index + 1)) != -1)
                    count++;
                charCount.add(count);
            }
        }
        while(charCount.size() > 2){
            ArrayList<Integer> numbers = new ArrayList<Integer>();
            for(int i = 0; i < (charCount.size()/2);i++)
                addToArray(charCount.get(i) + charCount.get(charCount.size()-1-i), numbers);
            if(charCount.size() % 2 == 1){
                addToArray(charCount.get(charCount.size()/2), numbers);
            }
            charCount = new ArrayList<Integer>(numbers);
        }
        System.out.println(Arrays.toString(charCount.toArray()).replaceAll("[\\]\\[,\\s]","") + "%");
    }
    public static ArrayList<Integer> addToArray(int number, ArrayList<Integer> numbers){
        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        while (!stack.isEmpty())
            numbers.add(stack.pop());
        return numbers;
    }
}

การป้อนข้อมูล:

Maria
Abraham

เอาท์พุท:

98%

การป้อนข้อมูล:

Wasi
codegolf.stackexchange.com

เอาท์พุท:

78%

C

อาจมีการปรับปรุงมากมาย แต่นี่สนุกกับการเขียนโค้ด

#include <stdio.h>
#include <string.h>
int i, j, k, c, d, r, s = 1, l[2][26];
char a[204], *p, *q;

main(int y, char **z) {
    strcat(a, z[1]);
    strcat(a, "loves");
    strcat(a, z[2]);
    p = a;
    q = a;
    for (; *q != '\0'; q++, p = q, i++) {
        if (*q == 9) {
            i--;
            continue;
        }
        l[0][i] = 1;
        while (*++p != '\0')
            if ((*q | 96) == (*p | 96)&&*p != 9) {
                (l[0][i])++;
                *p = 9;
            }
    }
    for (;;) {
        for (j = 0, k = i - 1; j <= k; j++, k--) {
            d = j == k ? l[r][k] : l[r][j] + l[r][k];
            if (d > 9) {
                l[s][c++] = d % 10;
                l[s][c++] = d / 10;
            } else l[s][c++] = d;
            if (k - j < 2)break;
        }
        i = c;
        if (c < 3) {
            printf("%d", l[s][0]*10 + l[s][1]);
            break;
        }
        c = r;
        r = s;
        s = c;
        c = 0;
    }
}

และแน่นอนรุ่นบังคับกอล์ฟ: 496

#include <stdio.h>
#include <string.h>
int i,j,k,c,d,r,s=1,l[2][26];char a[204],*p,*q;main(int y,char **z){strcat(a,z[1]);strcat(a,"loves");strcat(a,z[2]);p=q=a;for(;*q!='\0';q++,p=q,i++){if(*q==9){i--;continue;}l[0][i]=1;while(*++p!='\0')if((*q|96)==(*p|96)&&*p!=9){(l[0][i])++;*p=9;}}for(;;){for(j=0,k=i-1;j<=k;j++,k--){d=j==k?l[r][k]:l[r][j]+l[r][k];if(d>9){l[s][c++]=d%10;l[s][c++]=d/10;}else l[s][c++]=d;if(k-j<2)break;}i=c;if(c<3){printf("%d",l[s][0]*10+l[s][1]);break;}c=r;r=s;s=c;c=0;}}

Python 3

วิธีนี้จะใช้ชื่อสองชื่อเป็นอินพุต ตัดช่องว่างเพิ่มเติมแล้วคำนวณความรัก ตรวจสอบอินพุตเอาต์พุตสำหรับรายละเอียดเพิ่มเติม

s=(input()+'Loves'+input()).strip().lower()
a,b=[],[]
for i in s:
    if i not in a:
        a.append(i)
        b.append(s.count(i))
z=int(''.join(str(i) for i in b))
while z>100:
    x=len(b)
    t=[]
    for i in range(x//2):
        n=b[-i-1]+b[i]
        y=n%10
        n//=10
        if n:t.append(n)
        t.append(y)
    if x%2:t.append(b[x//2])
    b=t
    z=int(''.join(str(i) for i in b))
print("%d%%"%z)

การป้อนข้อมูล:

Maria
Abraham

เอาท์พุท:

98%

หรือลองอันนี้;)

การป้อนข้อมูล:

Wasi Mohammed Abdullah
code golf

เอาท์พุท:

99%

k, 80

{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}

นี่คือการวิ่งของมัน:

{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}["john";"jane"]
7 6

J

นี่คือหนึ่งใน J:

r=:({.+{:),$:^:(#>1:)@}:@}.
s=:$:^:(101<10#.])@("."0@(#~' '&~:)@":"1)@r
c=:10#.s@(+/"1@=)@(32|3&u:@([,'Loves',]))
exit echo>c&.>/2}.ARGV

ใช้ชื่อบนบรรทัดคำสั่งเช่น:

$ jconsole love.ijs John Jane
76

Groovy

นี่คือเวอร์ชั่น Groovy พร้อมการทดสอบ

countChars = { res, str -> str ? call(res+str.count(str[0]), str.replace(str[0],'')) : res }
addPairs = { num -> def len = num.length()/2; (1..len).collect { num[it-1].toInteger() + num[-it].toInteger() }.join() + ((len>(int)len) ? num[(int)len] : '') }
reduceToPct = { num -> /*println num;*/ num.length() > 2 ? call( addPairs(num) ) : "$num%" }

println reduceToPct( countChars('', args.join('loves').toLowerCase()) )

assert countChars('', 'johnlovesjane') == '221211211'
assert countChars('', 'asdfasdfateg') == '3222111'
assert addPairs('221211211') == '33331'
assert addPairs('33331') == '463'
assert addPairs('463') == '76'
assert addPairs('53125418') == '13457'
assert addPairs('13457') == '884'
assert addPairs('884') == '128'
assert addPairs('128') == '92'
assert reduceToPct( countChars('','johnlovesjane') ) == '76%'

คำอธิบาย:

• "countChars" เพียงเรียกซ้ำและลบออกในขณะที่สร้างสตริงตัวเลข
• "addPairs" ใช้เวลาหนึ่งสายของตัวเลขเพิ่มตัวเลขจากด้านนอกใน ** "collect..join" ไม่เพิ่มตัวเลขทำงานนอกในและเข้าร่วมเป็นสตริง ** ที่ "+ (... c [ (int) len]) "ขว้างที่กึ่งกลางอีกครั้งเมื่อ c คือความยาวคี่
• "recudeToPct" เรียกตัวเองเพิ่มคู่จนกว่ามันจะได้รับลงไปน้อยกว่า 3 หลัก

CodeGolf Groovy, 213 ถ่าน

การเห็นสิ่งนี้เป็นcodegolfเราสามารถอินไลน์การปิดและทำให้มันเป็นแบบนี้:

println({c->l=c.length()/2;m=(int)l;l>1?call((1..m).collect{(c[it-1]as int)+(c[-it]as int)}.join()+((l>m)?c[m]:'')):"$c%"}({r,s->s?call(r+s.count(s[0]),s.replace(s[0],'')):r}('',args.join('loves').toLowerCase())))

บันทึกเป็น lovecalc.groovy เรียกใช้ "groovy lovecalc john jane"

เอาท์พุท:

$ groovy lovecalc john jane
76%
$ groovy lovecalc romeo juliet
97%
$ groovy lovecalc mariah abraham
99%
$ groovy lovecalc maria abraham
98%
$ groovy lovecalc al bev
46%
$ groovy lovecalc albert beverly
99%

ชวา

ใช้พารามิเตอร์ 2 สตริงในการเริ่มต้นและพิมพ์จำนวนของอักขระแต่ละตัวและผลลัพธ์

import java.util.ArrayList;
import java.util.LinkedHashMap;

public class LUV {
    public static void main(String[] args) {
        String str = args[0].toUpperCase() + "LOVES" + args[1].toUpperCase();
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < str.length(); i++) {
            if (!map.containsKey(String.valueOf(str.charAt(i)))) {
                map.put(String.valueOf(str.charAt(i)), 1);
            } else {
                map.put(String.valueOf(str.charAt(i)), map.get(String.valueOf(str.charAt(i))).intValue() + 1);
            }
        }
        System.out.println(map.toString());
        System.out.println(addValues(new ArrayList<Integer>(map.values()))+"%");
    }

    private static int addValues(ArrayList<Integer> list) {
        if ((list.size() < 3) || (Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))) + String.valueOf(list.get(2))) == 100)) {
            return Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))));
        } else {
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            int size = list.size();
            for (int i = 0; i < size / 2; i++) {
                int temp = list.get(i) + list.get(list.size() -1);
                if (temp > 9) {
                    list2.add(temp/10);
                    list2.add(temp%10);
                } else {
                    list2.add(temp);
                }
                list.remove(list.get(list.size()-1));
            }
            if (list.size() > list2.size()) {
                list2.add(list.get(list.size()-1));
            }
            return addValues(list2);
        }
    }
}

ไม่ใช่อันที่สั้นที่สุด (มันคือ Java) แต่เป็นอันที่ชัดเจนและอ่านง่าย

ดังนั้นถ้าคุณโทร

java -jar LUV.jar JOHN JANE

คุณได้รับผลลัพธ์

{J=2, O=2, H=1, N=2, L=1, V=1, E=2, S=1, A=1}
76%

R

จะไม่ชนะรางวัลความเป็นปึกแผ่น แต่ฉันก็สนุกอยู่ดี:

problove<-function(name1,name2, relation='loves') {
sfoo<-tolower( unlist( strsplit(c(name1,relation,name2),'') ) )
startrow <- table(sfoo)[rank(unique(sfoo))]
# check for values > 10 . Not worth hacking an arithmetic approach
startrow <- as.integer(unlist(strsplit(as.character(startrow),'')))
while(length(startrow)>2 ) {
    tmprow<-vector()
    # follow  by tacking on middle element if length is odd
    srlen<-length(startrow)
     halfway<-trunc( (srlen/2))
    tmprow[1: halfway] <- startrow[1:halfway] + rev(startrow[(srlen-halfway+1):srlen])
    if ( srlen%%2) tmprow[halfway+1]<-startrow[halfway+1]
    startrow <- as.integer(unlist(strsplit(as.character(tmprow),'')))
    }
as.numeric(paste(startrow,sep='',collapse=''))
}

ทดสอบแล้ว: ใช้ได้สำหรับ 'john' & 'jane' และสำหรับ 'romeo' & 'juliet' ตามความคิดเห็นของฉันภายใต้คำถาม

Rgames> problove('john','jane','hates')
[1] 76
Rgames> problove('romeo','juliet','hates')
[1] 61