প্রেমের গণনা

39

ছোটবেলায় আমার বোন আমাকে এই ছোট্ট প্রেমের হিসাব দেখিয়েছিল তা দেখতে আপনার ক্রাশের সাথে সফল সম্পর্কের ক্ষেত্রে আপনার কতটা সুযোগ রয়েছে see আপনার যা দরকার তা হ'ল 2 নাম এবং এক টুকরো কাগজ।

  • জন
  • জেন

তারপরে, আপনি এই শব্দগুলিকে ভালবাসা শব্দটি দিয়ে আলাদা করুন । আপনি এটি এক লাইনে বা নতুন লাইনে লিখতে পারেন।

জন জেনকে
ভালবাসে

তারপরে গণনা শুরু হয়। বাম থেকে ডানে কোনও চরিত্র কতবার আসে এবং আপনি উপরে থেকে নীচে পর্যন্ত নতুন লাইন ব্যবহার করেন আপনি তা গণনা করেই শুরু করবেন। প্রতিটি চরিত্র একবারে গণনা করা হয়, সুতরাং জন জে জনের গণনা করার পরে জেনের সাথে শুরু করার সাথে আপনাকে এগুলি আবার গণনা করতে হবে না। এই উদাহরণের ফলাফল নিম্নলিখিত হবে:

জে: ২ ([জে] ওহান | [জে] আনি)
ও: ২ (জে [ওঃ एचএন | এল [ও] ভেস)
এইচ: ১ (জো [এইচ] এন)
এন: ২ (জো [এন] [এন] ই)
__
ল: 1 ([এল] ওভস)
ও: এড়িয়ে যাওয়া
ভি: 1 (লো [ভি] এস)
ই: 2 (লভ [ই] এস | জান [ই])
এস: 1 (প্রেম [গুলি] ])
__
জে: এনিড
এ: 1 (জে [এ] নে)
এন: এড়িয়ে যাওয়া
ই: এড়িয়ে গেছে
__
চূড়ান্ত ফলাফল: 2 2 1 2 1 1 2 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 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 সংখ্যার যোগফল 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 তম ফেব্রুয়ারি 14।

শুভ কোডিং

পিএস এই প্রথম আমি এখানে কিছু রাখলাম, যদি উন্নতির কোনও উপায় থাকে তবে আমাকে বিনা দ্বিধায় জানাতে = =

সম্পাদনা করুন: ভালোবাসা দিবসে শেষের তারিখ পরিবর্তিত হয়েছে, ভেবেছিলেন যে এই চ্যালেঞ্জের জন্য আরও উপযুক্ত হবে :)

popularity-contest 
— টিউন প্রোঙ্ক
সূত্র
আপনার উদাহরণটি দেখায় না যে কী সংখ্যক সংখ্যার যোগ করার দরকার হয় বা যখন আপনার 2 নম্বর সহ একটি সংখ্যা থাকে what এগুলি পরিষ্কার করার জন্য আরও ভাল।
— কেন্ডল ফ্রে
5
<ভলিউম = "জোরে জোরে"> সুতরাং গণনা 91% এ থামে। স্ট্রেঞ্জ। আমি বেশিরভাগ ক্ষেত্রে জানি যেখানে 10% বা আরও ভাল 1% অব্যাহত রাখার ফলে আরও বাস্তবসম্মত স্কোর পাওয়া যাবে। গণনার এমন স্পষ্টভাবে বাণিজ্যিক
— হেরফের দিয়ে
8
ইনব 4 কেউ হৃদয়ের আকারে কোড পোস্ট করে এবং জনপ্রিয়তা অর্জন করে
— ক্রাঙ্কার
1
@ ব্যবহারকারী2509848 প্রথম কয়েকটি বর্ণের কলামগুলি কাকতালীয় ছিল, প্রয়োজনের নয়। আপনি কেবল চিঠির সংখ্যার সংখ্যা গণনা করুন।
— ড্যানি
3
যদি আপনি নামগুলি (এবং "প্রেম") তাদের ASCII পূর্ণসংখ্যার কোডগুলিতে রূপান্তর করেন তবে কীভাবে ফলাফল পরিবর্তন হবে তা অবাক করুন। এই বিষয়টির জন্য, আপনি যদি "প্রেম" কে "ঘৃণা" দিয়ে প্রতিস্থাপন করেন তবে কি হবে - আপনি আশা করবেন 1-love_result :-)
— কার্ল উইথথফট

উত্তর:

35

Sclipting

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

দুটি স্পেস-বিভাজিত শব্দ (উদাহরণস্বরূপ John Jane) হিসাবে ইনপুটটি প্রত্যাশা করে । এটি কেস-সংবেদনশীল, তবে কেবলমাত্র এমন চরিত্রগুলিকে সমর্থন করে যা বিশেষ রেজেক্স অক্ষর নয় (সুতরাং ব্যবহার (বা *আপনার নামে ব্যবহার করবেন না !)। এটি কেবলমাত্র দুটি শব্দ প্রত্যাশা করে, সুতরাং আপনার ভালবাসার আগ্রহ যদি "মেরি জেন" হয় তবে আপনাকে MaryJaneএকটি শব্দ রাখতে হবে; অন্যথায় এটি মূল্যায়ন করবে "আপনার নামটি মেরিকে ভালবাসে জেনকে"।

ব্যাখ্যা

সবচেয়ে কঠিন অংশটি হ'ল বিজোড় সংখ্যার কেসটি হ্যান্ডেল করা: আপনি নিজের সাথে যুক্ত করার পরিবর্তে আপনাকে মাঝারি সংখ্যাটি একা রেখে যেতে হবে। আমি মনে করি আমার সমাধানটি আকর্ষণীয়।

글⓵닆뭶뉗밃變 | 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 "%"

আপনি যখন ১০০ ডলার দিয়ে রেখে যান, তখন লুপটি শেষ হবে, উত্তরটি স্ট্যাকের উপর থাকবে এবং তাই আউটপুট।

— Timwi
সূত্র
46
এবং আমি ভেবেছিলাম এপিএল পড়া কঠিন ছিল ...
— ডঃ বেলিসারিয়াস
5
হাই টিমভি, আমি দেখতে পাচ্ছি আপনি খেলায় ফিরে এসেছেন: পি চমৎকার সমাধান
— পিয়ের আরলাড
12
অপেক্ষা করুন, তিনি কোডগল্ফের জন্য নিজের ভাষা আবিষ্কার করেছিলেন ?! এটাই প্রতারণা!
— মাকিং হাঁস
2
আসলে এই ভাষা হল (ধরণের) পাঠযোগ্য (আপনি যদি চীনা)।
— eiennohito
8
@ মুভিংডাক: আমার এই বিধি সম্পর্কে আমার বোঝাপড়াটি হ'ল চ্যালেঞ্জ প্রকাশের পরে প্রকাশিত হয়েছিল এমন কোনও ভাষা আপনি ব্যবহার করতে পারবেন না । অতএব, আমি সর্বদা আমি আগে নির্দেশিত কেবলমাত্র নির্দেশাবলী ব্যবহার করার জন্য একটি পয়েন্ট করি। উদাহরণস্বরূপ, আমি 改এই চ্যালেঞ্জের প্রতিক্রিয়া হিসাবে (কেস-সংবেদনশীল স্ট্রিং-রিপ্লেসমেন্ট) প্রবর্তন করেছি , তবে আমি এখানে এটি ব্যবহার করতে যাচ্ছি না।
— টিমউই
29

Funciton

এই প্রোগ্রামটি প্রত্যাশা করে একটি ইনপুট কোনও স্থান দ্বারা পৃথক করা (উদাঃ John Jane)। এটি এজেড / এজেড অক্ষরের ক্ষেত্রে সংবেদনশীল নয়; অন্য যে কোনও ইউনিকোড চরিত্রের জন্য, এটি দু'টি অক্ষরকে "বিভ্রান্ত" করবে যা 32 বা (যেমন Āএবং এবং Ġ, ?এবং _) এর সাথে সমান হয় । তদ্ব্যতীত, ইনপুটটিতে কোনও NUL ( \0) অক্ষর থাকলে এই প্রোগ্রামটি কী করবে তা আমার কোনও ধারণা নেই , সুতরাং এটি ব্যবহার করবেন না :)

এছাড়াও, যেহেতু স্ট্যাকএক্সচেঞ্জ খুব বেশি লাইন ব্যবধান যুক্ত করেছে, তাই এখানে পেস্টবিনের কাঁচা পাঠ্য রয়েছে । বিকল্পভাবে, আপনার ব্রাউজারের জাভাস্ক্রিপ্ট কনসোলে এটি ঠিক করার জন্য নিম্নলিখিত কোডটি এখানে চালান:$('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 ║  │
                                                      │          ╚═══╝  │
                                                      └─────────────────┘

দ্রুত ব্যাখ্যা

  • প্রোগ্রামটি কেবল এসটিডিএন নেয় এবং Ḷএটির সাথে কল করে।

  • Ḷস্ট্রিংয়ে প্রথম স্থান আবিষ্কার করে, এটি এর সাথে প্রতিস্থাপন করে lovesএবং ফলাফলটি পাস করে Ọ।

  • Ọইনপুট স্ট্রিং থেকে বারবার প্রথম অক্ষরটি নিয়ে যায়, Ṣএটির সাথে কল করে এবং ফলাফলের স্ট্রিংয়ের সাথে সংখ্যার সংমিশ্রণ ঘটায়। যখন ইনপুট স্ট্রিংটি খালি থাকে, তখন Ṿএটি ফলাফল স্ট্রিংয়ের সাথে কল করে।

  • Ṿবারবার ফোন করে Ẹএটির ফলাফল না পাওয়া পর্যন্ত যা হয় হয় সমান "100"বা তার দৈর্ঘ্য কম হয় 3. ( 100প্রকৃতপক্ষে ঘটতে পারে: ইনপুটটি বিবেচনা করুন lovvvv eeeeeess)) এটি যখন করা হয়, এটি যুক্ত করে "%"এবং তা ফেরত দেয়।

  • Ẹভালবাসা-গণনা অ্যালগরিদমের একটি সম্পূর্ণ পুনরাবৃত্তি গণনা করে; অর্থাত্ এটি সংখ্যার একটি স্ট্রিং নেয় এবং অঙ্কগুলির পরবর্তী স্ট্রিং প্রদান করে।

  • Ṛএকটি সময় লাগে খড়ের গাদা এবং একটি সুই এবং প্রথম ঘটনার সূচক খুঁজে বের করে সুই মধ্যে খড়ের গাদা ভুল কেস-insensitivity নির্ণায়ক ব্যবহার ( or 32)।

  • Ṣএকটি সময় লাগে খড়ের গাদা এবং একটি সুই এবং বারবার প্রযোজ্য Ṛসমস্ত উদাহরণ মুছে ফেলার জন্য সুই । এটি সমস্ত অপসারণের পাশাপাশি চূড়ান্ত ফলাফলগুলি তৈরির পরে চূড়ান্ত ফলাফল প্রদান করে।

— Timwi
সূত্র
12
এখানে কী চলছে আমার কোনও ধারণা নেই তবে এটি দেখতে খুব চিত্তাকর্ষক!
— চিকিত্সা ওসিফরেজ
27

চুনি

     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) সমর্থন করে ।

— epidemian
সূত্র
1
এটি খাঁটি শিল্প :)
11

এপিএল, 80

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

কারণ প্রেম প্রেম কোড-গলফ হয় কোড-গলফ (এমনকি যখন এটা না)

বাধ্যতামূলক ♥ ped আকৃতির সংস্করণ:

    {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
— Tobia
সূত্র
8

জাভাস্ক্রিপ্ট

সম্ভবত ক্লিনার হতে পারে, কিন্তু এটি কার্যকর। ভার্বোজ উদাহরণ

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 + "%")
— ড্যানি
সূত্র
7

পাইথন

ঠিক আছে, আমি ভেবেছিলাম এটি একটি কোড-গল্ফ ...

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)) + "%"
— Oberon
সূত্র
আপনি যদি এটি যথাসম্ভব সংক্ষিপ্ত করতে চান তবে আপনি এটির reduce(list.__add__,xyz)সাথে প্রতিস্থাপন করতে পারেন sum(xyz,[])। :)
— flornquake
5

পিএইচপি

<?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 :) !!
— Einacio
সূত্র
4

GolfScript

গল্ফস্ক্রিপ্টে বাধ্যতামূলক কোড গল্ফ উত্তর:

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

স্থানকে পৃথক করা নাম হিসাবে ইনপুট গ্রহণ করে যেমন

echo 'John Jane' | ruby golfscript.rb love.gs
-> 76
— বেন রেখ
সূত্র
4

সি শার্প

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);
        }
    }
}
— লুক
সূত্র
q[i] + q[j]10 বা তার বেশি হলে এই কাজটি সঠিকভাবে হয়?
— ড্যানি
@ ড্যানি এফএন-এর প্রথম লাইন প্রতিটি সংখ্যাকে ইনপুটতে নিয়ে যায়, তাদের প্রত্যেককে স্ট্রিংয়ে রূপান্তর করে, তারপরে এই স্ট্রিংয়ের সমস্ত অক্ষরকে 0 থেকে 9 (সি - '0' অংশ) পর্যন্ত পূর্ণসংখ্যায় রূপান্তর করে এবং ... IOW, এটি ইনপুটটিতে প্রতিটি অঙ্ক নিয়ে পূর্ণসংখ্যার একটি অ্যারে তৈরি করবে। যদি এটি প্রয়োজনীয়তাগুলি অবৈধ হয় না :-)
— লুস
আহ যে মিস।
— ড্যানি
4

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

কিছু ফলাফল:

"রোমিও" "জুলিয়েট" 97% - অভিজ্ঞতাগত পরীক্ষা গুরুত্বপূর্ণ
"রোমিও" "জুলিয়ার" 88% - আধুনিক সংক্ষিপ্ত সংস্করণ ...
"হার্স্ট ড্রাগার" "জেন" 20%
"হার্স্ট ড্রপার" "জেন (ঘোড়া)" 70% - একটি বিকাশ হয়েছে ...
"বেন্ডার বেন্ডার রদ্রিগেজ" "ফেনি ওয়েঞ্চওয়ার্থ" 41% - বেন্ডার বলেছেন "ফোল্ডিং মহিলাদের জন্য!"
"ফিলিপ ফ্রাই" "তুরঙ্গা লীলা" 53% - ভাল আপনি দেখতে পাচ্ছেন যে কেন তাদের "মারিয়া" "আব্রাহাম" - 98% "জন" "জেন" 76% বিয়ে করার জন্য তাদের 7 মরশুম লেগেছিল?

— vlsh
সূত্র
3

চুনি

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
— অ্যান্ড্রু হাবস
সূত্র
1
আরো অল্প করা করার জন্য, আপনাকে ব্যবহার করতে পারে l=->a{...}পরিবর্তে l=lambda do|a|...end, এবং আপনি কাজ করতে পারে l[...]পরিবর্তে l.call(...)।
— ডুরকনব
শুভ পয়েন্ট ডোরকনব।
— অ্যান্ড্রু হাবস 31'14
2

পাইথন ঘ

একটি সাধারণ সমাধান যা কোনও মডিউল ব্যবহার করে না। I / O যথেষ্ট যথেষ্ট।

দ্বিতীয় পুনরুক্তি সীমা ছাড়িয়ে গেলে আমি ব্যাকআপ হিসাবে ধরা ত্রুটি ব্যবহার করেছি; যদি এটি পাইথনের সূচক ত্রুটিটি ধরা দেয় তবে এটি ১ টি অদ্ভুত বলে ধরে নেয় তবে এটি কার্যকর হয়।

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%
— cjfaure
সূত্র
এটি চালানোর জন্য পরিষ্কার হবে না forউপর namesসরাসরি?
— আইনাসিও
@ আইনাসিও তাহলে আমি কীভাবে জানব যে কোনটি এটিকে সংক্ষেপে পরীক্ষা করতে হবে?
— সিজেফুরে
"মারিয়া" এবং "আব্রাহাম" এর সাথে আপনার ফলাফল কী?
— আইনাসিও
@ আইনাসিও আমি পেয়েছি 75%।
— সিজেফুরে
আমি পেয়েছিলাম 98, এই পদক্ষেপ 25211111111.363221.485.98। আমি মনে করি আপনি কোডটি "" এ "যুক্ত করতে ব্যর্থ হয়েছেন
— আইনাসিও
2

জাভা

এটি ঘটতে পারে যে 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%
— রল্ফ ツ
সূত্র
এই উত্তরটি কিক্স এবং গিগলসের জন্য গল্ফ করা দেখে আমি উপভোগ করব!
— জোশ
এটি বিয়োগ 144 টি অক্ষর এবং কয়েকটি লাইন তৈরি করে। আমি কেবল পঠনযোগ্য এবং স্মৃতিশক্তির দক্ষ প্রোগ্রাম করার
— রল্ফ
এজন্য জাভা গল্ফড দেখে আমাকে সর্বদা ক্র্যাক করে ফেলে।
— জোশ
আমার জন্য এই গল্ফযুক্তদের মতো ভাষা তৈরি করার মজা .. কল্পনা করুন যে এলোমেলো জাভা ক্লাসটি গল্ফ করার চেষ্টা করা কত মজাদার হবে এটি কমপক্ষে 2 গুণ ছোট এক্সডি হয়ে উঠবে
— রল্ফ ツ
1
জাভা গল্ফিংয়ের জন্য সবচেয়ে খারাপ ভাষা। দুর্ভাগ্যক্রমে এটি আমি কেবল ভাল ভাষা জানি ভাষা, হা। ওহ ভাল, কমপক্ষে আমি এখানে জিনিস পড়তে পারেন।
— অ্যান্ড্রু গিজ
2

সি

প্রচুর উন্নতি হতে পারে তবে কোডটি মজাদার ছিল।

#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;}}
— Allbeert
সূত্র
2

পাইথন ঘ

এটি ইনপুট হিসাবে দুটি নাম নেবে। অতিরিক্ত স্থান ফাঁকা এবং তারপর প্রেম গণনা। আরও তথ্যের জন্য ইনপুট আউটপুট দেখুন।

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%
— Wasi থেকে
সূত্র
2

কে, 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
— mollmerx
সূত্র
2

জে

এখানে জে সরল একটি:

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
— সামুদ্রিক
সূত্র
2

খাঁজকাটা

পরীক্ষাগুলি সহ এখানে গ্রুভি সংস্করণ।

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

ব্যাখ্যা:

  • "কাউন্টচর্স" ​​অঙ্কগুলির স্ট্রিং তৈরি করার সময় কেবল পুনরাবৃত্তি করে এবং সরান
  • "অ্যাডপেইজস" বাইরে থেকে অঙ্কগুলি যুক্ত করে একটি সংখ্যার স্ট্রিং নেয় ** "সংগ্রহ করুন ... যোগ করুন" বাইরে কাজ করা অঙ্কগুলির সংযোজন করে এবং স্ট্রিং হিসাবে আবার যোগদান করে ** "+ (... সি [ (int) লেন]) "গ এর বিজোড় দৈর্ঘ্য হলে আবার মাঝের অঙ্কে ফেলে দেয়
  • "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%
— Krs
সূত্র
1

জাভা

এটি শুরুতে 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%
— ওবল টোবল
সূত্র
1

আর

কোনও কমপ্যাক্টনেস অ্যাওয়ার্ড জিততে যাচ্ছি না, তবে যাইহোক আমি মজা করেছি:

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
— কার্ল উইথফট
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.