प्रेम गणना

Question

एक बच्चे के रूप में मेरी बहन ने मुझे यह देखने के लिए प्यार किया कि आपको अपने क्रश के साथ एक सफल रिश्ते में कितना मौका मिलना है। आपको बस 2 नाम और एक कागज का टुकड़ा चाहिए।

• जॉन
• जेन

फिर, आप इन नामों को लव्स शब्द से अलग करते हैं । आप इसे एक लाइन पर या नई लाइनों पर लिख सकते हैं।

जॉन जेन को
प्यार करता है

फिर गणना शुरू होती है। आप यह गिनकर शुरू करते हैं कि एक वर्ण बाएं से दाएं कितनी बार आता है और यदि आप नई पंक्तियों का उपयोग ऊपर से नीचे भी करते हैं। प्रत्येक चरित्र को एक बार गिना जाता है, इसलिए जॉन के जे को गिनने के बाद आपको जेन के साथ शुरू करने पर उन्हें फिर से गिनने की आवश्यकता नहीं है। इस उदाहरण का परिणाम निम्नानुसार होगा:

J: 2 ([J] ohn | [J] ane)
O: 2 (J [o] hn | L [o] ves)
H: 1 (Jo [h] n)
N: 2 (Joh [n]] | [n] ई)
__
एल: १ ([एल] ओवेस)
ओ: स्किप की गई
वी: १ (लो [वी] ईएस)
ई: २ (लव [ई] एस | जान [ई])
एस: १ (प्यार [s] ])
__
J: स्किप्ड
A: १ (J [a] ne)
N: स्किप किया हुआ
E: स्किप
__
अंतिम परिणाम: २ २ १ १ १ १ १ २ १ १

अगला कदम बाहर से मध्य तक काम करने वाले अंकों को जोड़ना होगा।

2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 2 2 1 1 (2 + 1 = 3)
2 2 1 2 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
4 6 3
76%

ऐसा हो सकता है कि 2 अंकों का योग in 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] वर्णों की अनुमति है।
• केस असंवेदनशील है इसलिए ए == ए

आप तय करने के लिए नि: शुल्क

• विशेष पात्रों को कैसे संभालें (Ö, è, आदि)
• अंतिम नामों को हां या न में शामिल करें, रिक्त स्थान को नजरअंदाज कर दिया जाएगा
• किसी भी भाषा की अनुमति है।

28 फरवरी की 14 तारीख को वोटों से विजेता का निर्धारण किया जाएगा ।

खुश कोडिंग

Ps यह पहली बार है जब मैंने यहां कुछ डाला है, अगर इसे सुधारने का कोई तरीका है तो मुझे स्वतंत्र रूप से बताएं = 3

संपादित करें: वैलेंटाइन्स दिवस के लिए अंतिम तिथि बदली, सोचा कि इस चुनौती के लिए अधिक उपयुक्त होगा :)

Comments

आपका उदाहरण यह नहीं दिखाता कि क्या होता है जब सम संख्याओं को जोड़ने की आवश्यकता होती है, या जब आपके पास 2 अंकों के साथ एक संख्या होती है। बेहतर उन लोगों को स्पष्ट करने के लिए जोड़ें।

— केंडल फ्रे

<सोच की मात्रा = "जोर"> इसलिए गणना 91% पर रुक जाती है। अजीब। मुझे पता है कि कई मामले ऐसे हैं जहां 10% या इससे भी बेहतर 1% जारी है, और अधिक यथार्थवादी स्कोर देगा। गणना के ऐसे स्पष्ट रूप से वाणिज्यिक हेरफेर के साथ मैं शर्त लगाता हूं कि यह वास्तव में एसएमएस प्रेम कैलकुलेटर सेवाओं द्वारा उपयोग किया जाता है। </ सोच>

— मैनटवर्क

inb4 किसी के दिल के आकार में कोड पोस्ट करता है और लोकप्रियता जीतता है

— क्रंचर

@ user2509848 पहले कुछ अक्षरों पर कॉलम एक संयोग था, और आवश्यकता नहीं। आप बस पत्र की घटनाओं की संख्या की गणना करते हैं।

— डैनी

आश्चर्य है कि यदि आप नाम (और "प्रेम") को उनके ASCII पूर्णांक कोड में परिवर्तित करते हैं तो परिणाम कैसे बदलते हैं। उस मामले के लिए, यदि आप "प्यार" को "घृणा" से बदल देते हैं, तो क्या होगा - आप उम्मीद करेंगे कि 1-love_result :-)

— कार्ल विटथॉफ्ट

Answer 1

Sclipting

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

इनपुट को दो अंतरिक्ष-अलग शब्दों (जैसे John Jane) के रूप में अपेक्षित है । यह केस-असंवेदनशील है, लेकिन केवल उन पात्रों का समर्थन करता है जो विशेष रेगेक्स वर्ण नहीं हैं (इसलिए उपयोग न करें (या *आपके नाम में नहीं है!)। यह भी केवल दो शब्दों की अपेक्षा करता है, इसलिए यदि आपकी प्रेम रुचि "मेरी जेन" है, तो आपको MaryJaneएक शब्द में रखना होगा ; अन्यथा यह "YourName प्यार करता है मैरी जेन प्यार करता है" का मूल्यांकन करेगा।

व्याख्या

सबसे कठिन हिस्सा अंको की विषम संख्या के मामले को संभालना था: आपको इसे अपने साथ जोड़ने के बजाय बीच के अंक को अकेला छोड़ना होगा। मुझे लगता है कि मेरा समाधान दिलचस्प है।

글⓵닆뭶뉗밃變 | 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 के साथ रह जाते हैं, तो लूप बस समाप्त हो जाएगा, जवाब स्टैक पर होगा और इसलिए आउटपुट।

Comments

और मुझे लगा कि एपीएल को पढ़ना मुश्किल है ...

— डॉ। बेलिसियस

हाय टिमवी, मैं देख सकता हूं कि आप खेल में वापस आ गए हैं: पी अच्छा समाधान

— पियरे अरलाउड

रुको, उसने कोडगुल्फ़ के लिए अपनी भाषा का आविष्कार किया ?! यह बेइमानी है!

— मूविंग डक

असल में इस भाषा है (एक तरह से) पठनीय (आप जानते हैं कि चीनी)।

— eiennohito

@MooingDuck: नियम के बारे में मेरी समझ यह है कि आप उस भाषा का उपयोग नहीं कर सकते जो चुनौती प्रकाशित होने के बाद प्रकाशित हुई थी। इसलिए, मैं हमेशा केवल पहले दिए गए निर्देशों का उपयोग करके एक बिंदु बनाता हूं। उदाहरण के लिए, मैंने 改इस चुनौती के जवाब में (केस-इनसेटिव स्ट्रिंग-रिप्ले) पेश किया, लेकिन मैं यहां इसका उपयोग नहीं करने जा रहा हूं।

— तिमवी

Answer 2

funciton

यह कार्यक्रम एक स्थान (जैसे John Jane) द्वारा अलग किए गए इनपुट की अपेक्षा करता है । यह अक्षर AZ / az के लिए केस-असंवेदनशील है ; किसी अन्य यूनिकोड वर्ण के लिए, यह है कि बराबर जब साथ 32 (जैसे or'ed हैं "भ्रमित" दो अक्षर होगा Āऔर Ġ, या ?और _)। इसके अलावा, मुझे नहीं पता कि यह प्रोग्राम क्या करेगा यदि इनपुट में NUL ( \0) वर्ण है, तो इसका उपयोग न करें :)

इसके अलावा, चूंकि StackExchange बहुत अधिक पंक्ति रिक्ति जोड़ता है, यहाँ pastebin पर कच्चा पाठ है । वैकल्पिक रूप से, इसे ठीक करने के लिए अपने ब्राउज़र के जावास्क्रिप्ट कंसोल में निम्न कोड चलाएँ:$('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

• Ṣएक लेता है भूसे के ढेर और एक सुई और बार बार लागू होता है Ṛके सभी उदाहरणों को दूर करने के सुई । यह सभी निष्कासन के साथ-साथ किए गए निष्कासन की संख्या के बाद अंतिम परिणाम देता है।

Comments

मुझे नहीं पता कि यहां क्या हो रहा है, लेकिन यह बहुत प्रभावशाली है!

— स्क्वीश ossifrage

Answer 3

माणिक

     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
     #####            #####
   #########        #########
 ############      ############
##############    ##############
###############   ##############
#############   ################
 #############   ##############
   ############   ###########
     ########   ###########
       #######   ########
         ######   #####
           ##   #####
             #   ##
              # 

फ्रिगिंग जॉन ...

वैसे भी, यह मामला असंवेदनशील है और बहुविवाह संबंधी प्रश्नों (जैसे ruby ♥.rb Alice Bob Carol Dave) का समर्थन करता है ।

Comments

यह शुद्ध कला है :)

Answer 4

एपीएल, ,०

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

क्योंकि प्यार है प्यार कोड गोल्फ है कोड गोल्फ (तब भी जब यह नहीं है)

अप्रचलित ♥ ︎ के आकार का संस्करण:

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

गोल्फ संस्करण मुझे कुछ अनिश्चित व्यवहार देता है, क्योंकि बग के साथ ∪⍦मैं 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

Answer 5

जावास्क्रिप्ट

शायद क्लीनर हो सकता है, लेकिन यह काम करता है। क्रिया का उदाहरण

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 + "%")

Answer 6

अजगर

खैर, मुझे लगा कि यह एक कोड-गोल्फ था ...

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)) + "%"

Comments

आप संभव के रूप में कम के रूप में यह सुनिश्चित करना चाहते हैं, तो आप बदल सकते हैं reduce(list.__add__,xyz)के साथ sum(xyz,[])। :)

— flornquake

Answer 7

पीएचपी

<?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 :) !!

Answer 8

GolfScript

गोल्फस्क्रिप्ट में अनिवार्य कोड गोल्फ उत्तर:

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

इनपुट को अंतरिक्ष से अलग किए गए नामों के रूप में स्वीकार करता है

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

Answer 9

सी#

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);
        }
    }
}

Comments

q[i] + q[j]10 या अधिक होने पर क्या यह सही ढंग से काम करता है?

— डैनी

@ डैनी fn में पहली पंक्ति प्रत्येक पूर्णांक को इनपुट में लेती है, उनमें से प्रत्येक को स्ट्रिंग में परिवर्तित करती है, फिर इस स्ट्रिंग में सभी वर्णों को 0 से 9 तक पूर्णांक में परिवर्तित करती है (c - '0' भाग) और इसे लौटाती है ... IOW, यह इनपुट में प्रत्येक अंक से मिलकर पूर्णांकों की एक सरणी का निर्माण करेगा। यदि यह आवश्यकताओं को अमान्य नहीं करता है :-)

— ल्यूक

आह छूट गई।

— डैनी

Answer 10

हास्केल

मेरा संस्करण बहुत लंबा है, यह इसलिए है क्योंकि मैंने पठनीयता पर ध्यान केंद्रित करने का फैसला किया है, मुझे लगा कि कोड में अपने एल्गोरिथ्म को औपचारिक बनाना दिलचस्प होगा। मैं समग्र चरित्र को एक बाएं गुना में गिनता हूं , यह मूल रूप से उन्हें एक साथ स्नोबॉल करता है और स्ट्रिंग में उनकी घटना के क्रम में है। मैं एल्गोरिथ्म के उस हिस्से को भी बदलने में कामयाब रहा, जिसमें सामान्य रूप से सूची झुकने के साथ सरणी अनुक्रमण की आवश्यकता होगी । यह आपके एल्गोरिथ्म को मूल रूप से आधे में संख्याओं की तह सूची और एक साथ संरेखित संख्याओं को जोड़कर बताता है। झुकने के लिए दो मामले हैं, यहां तक ​​कि सूची भी बीच में विभाजित होती है, विषम सूची एक केंद्र तत्व के चारों ओर झुकती है और यह तत्व इसके अतिरिक्त भाग नहीं लेता है। विखंडन सूची ले रहा है और संख्याओं को विभाजित कर रहा है जो अब एकल अंक नहीं हैं, जैसे> = 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) ++ "%"

कुछ परिणाम:

"रोमियो" "जूलियट" 97% - अनुभवजन्य परीक्षण महत्वपूर्ण है
"रोमियो" "जूलियर" 88% - आधुनिक संक्षिप्त संस्करण ...
"होर्स्ट ड्रेपर" "जेन" 20%
"हॉर्स्ट ड्रेपर" "जेन (हार्स)" 70% - वहाँ एक विकास हुआ है ...
"शराबी शराबी रोड्रिगेज" "फेनी वेनवर्थ" 41% - शराबी कहते हैं "तह महिलाओं के लिए है!"
"फिलिप फ्राई" "तुरंगा लीला" 53% - वैसे आप देख सकते हैं कि "मारिया" "अब्राहम" - 98% "जॉन" "जेन" 76% से शादी करने में उन्हें 7 सीजन क्यों लगे।

Answer 11

माणिक

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

न्यूनतम किया गया:

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

Comments

अधिक छोटा करने के लिए, आप l=->a{...}इसके बजाय उपयोग कर सकते हैं l=lambda do|a|...end, और आप l[...]इसके बजाय भी कर सकते हैं l.call(...)।

— डोरकनॉब

अच्छा बिंदु Doorknob।

— एंड्रयू हब्स

Answer 12

अजगर ३

एक सरल समाधान जो बिना किसी मॉड्यूल का उपयोग करता है। I / O काफी सुंदर है।

जब दूसरे पुनरावर्तक की सीमा समाप्त हो जाती है, तो मैं बैकअप के रूप में त्रुटि को पकड़ता था; अगर यह पायथन की इंडेक्स एरर को पकड़ता है, तो यह मान लेता है कि 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%

Comments

यह सीधे forपर चलाने के लिए स्पष्ट नहीं होगा names?

— आइनाको 3

@Einacio फिर मुझे कैसे पता चलेगा कि कौन से इसे इतनी बारीकी से जांचना है?

— cjfaure

"मारिया" और "अब्राहम" के साथ आपका क्या परिणाम है?

— आइनाको 3

@Einacio मैं 75% मिला।

— cjfaure

मुझे 98 मिले, यह कदम हैं 25211111111.363221.485.98। मुझे लगता है कि आप कोड 5 "a"

— Einacio

Answer 13

जावा

ऐसा हो सकता है कि 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%

Comments

मुझे यह उत्तर देखकर मजा आएगा कि किक और गिगल्स के लिए गोल्फ!

— जोश

यह शून्य से 144 वर्ण और कुछ रेखाएँ बनाता है। मैं सिर्फ पठनीय और स्मृति कुशल प्रोग्राम करने के लिए उपयोग किया जाता हूं ...

— रोल्फ ツ

यही कारण है कि जावा गोल्फ को देखकर मुझे हमेशा क्रैक होता है।

— जोश

मेरे लिए यह इस गोल्फ की तरह एक भाषा बनाने में मज़ा है .. बस कल्पना कीजिए कि यह एक यादृच्छिक जावा वर्ग की कोशिश करने में कितना मज़ेदार होगा, यह कम से कम 2 गुना छोटा XD बन जाएगा

— रॉल्फ

जावा गोल्फिंग के लिए सबसे खराब भाषा है। दुर्भाग्य से यह केवल भाषा है जिसे मैं अच्छी तरह से जानता हूं, हाहा। ओह ठीक है, कम से कम मैं यहां सामान पढ़ सकता हूं।

— एंड्रयूज

Answer 14

सी

बहुत सुधार हो सकता है, लेकिन यह कोड के लिए मजेदार था।

#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;}}

Answer 15

अजगर ३

यह इनपुट के रूप में दो नाम लेगा। अतिरिक्त रिक्त स्थान स्ट्रिप करें और फिर प्यार की गणना करें। अधिक जानकारी के लिए इनपुट आउटपुट देखें।

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%

Answer 16

के, 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

Answer 17

जे

यहाँ जे में एक सीधा है:

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

Answer 18

ग्रूवी

यहां परीक्षण के साथ ग्रूवी संस्करण है।

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" अंकों के एक तार को बाहर से ** में एकत्रित अंकों को जोड़ता है ** "इकट्ठा..जो" बाहर में काम करने वाले अंकों को जोड़ देता है और उन्हें स्ट्रिंग के रूप में फिर से जोड़ता है "+ (... c] (int) len]) "सी लंबाई में एक बार फिर से मध्य अंक में फेंकता है
• "recudeToPct" खुद को जोड़े जोड़ते हुए कहता है जब तक कि यह 3 अंकों से कम नहीं हो जाता

कोडगोल्फ ग्रूवी, 213 चार

यह देखकर कोडगॉल्फ है कि हम क्लोजर को इनलाइन कर सकते हैं और इसे नीचे ला सकते हैं:

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
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%

Answer 19

जावा

यह प्रारंभ में 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 -jar LUV.jar JOHN JANE

आपको आउटपुट मिलता है

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

Answer 20

आर

कोई कॉम्पैक्टनेस पुरस्कार जीतने के लिए नहीं, लेकिन मुझे वैसे भी मज़ा था:

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=''))
}

परीक्षण किया गया: 'जॉन' और 'जेन' के लिए और 'रोमियो' और 'जूलियट' के लिए वैध। सवाल के तहत मेरी टिप्पणी के अनुसार,

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