কোন তার কাটা

29

এই টাস্কটি শর্তাবলীর একটি ক্রম সংকোচন এবং প্রক্রিয়াজাতকরণ সম্পর্কে।

গেম টকিং অ্যান্ড নোবি বিস্ফোরণে গেমটিতে বোমা ডিফিউজারকে অবশ্যই বোমা বিস্ফোরিত করতে হবে বোমা ডিফিউসাল ম্যানুয়ালের সাথে পরামর্শকারীদের দ্বারা পরামর্শ দেওয়া পরামর্শের সাহায্যে । এই চ্যালেঞ্জটি ম্যানুয়ালটির 5 পৃষ্ঠায় ব্যাখ্যা করা "তারের বিষয়গুলির উপর" মডিউলটি নিয়ে কাজ করে। Defuser রঙিন তারের একটি অ্যারে সঙ্গে উপস্থাপন করা হয়। তাদের মধ্যে একটিই কাটা নিরাপদ - বাকিরা বোমাটি বিস্ফোরণ করে।

"ওয়্যার কাটার বিধি" এর অধীনে পুনঃনির্মাণ ম্যানুয়ালটিতে থাকা নির্দেশাবলী অনুসারে আপনার কোডগুলি তারের সংখ্যা এবং রঙের ভিত্তিতে কোন তারটি কাটা উচিত তা নির্ধারণ করতে বিশেষজ্ঞ হিসাবে কাজ করে।

ইনপুট: বড় হাতের অক্ষর দ্বারা উপস্থাপিত 3, 4, 5, বা 6 টি তারের বর্ণের একটি অর্ডার করা তালিকার বা স্ট্রিং:

  • B: কালো
  • U: নীল
  • R: লাল
  • W: সাদা
  • Y: হলুদ

নীল হয় Uনা, নোট করুন B।

বোমের ক্রমিক সংখ্যাটির শেষ সংখ্যাটি বিজোড়, কিছু নিয়মে ব্যবহৃত হওয়া শর্তের জন্য ইনপুটটিতে কিছুটা (সত্য / মিথ্যা বা 0/1) অন্তর্ভুক্ত রয়েছে।

আপনার তারের সংখ্যা পৃথক ইনপুট হিসাবে নেওয়া উচিত নয়, তবে এটি রঙের তালিকা বা স্ট্রিং থেকে নেওয়া। রঙগুলির পরে আপনার তালিকায় বা স্ট্রিংয়ের একটি টার্মিনেটর উপাদান থাকতে পারে, সম্ভবত আপনার ভাষা এটি দীর্ঘকাল বলতে না পারলে। এই টার্মিনেটরটি একটি নির্দিষ্ট মান হওয়া উচিত যা অতিরিক্ত তথ্য এনকোড করে না।

আউটপুট: 1 থেকে 6 নম্বর, কোনটি তার কাটা হবে তা নির্দেশ করে। এটি শূন্য-সূচকযুক্ত নাও হতে পারে।

ওয়্যার কাটার নিয়ম: এই নিয়মগুলি Defusal ম্যানুয়ালটির পৃষ্ঠা 5 থেকে পুনরুত্পাদন করা হয়

3 wires:
  If there are no red wires, cut the second wire.
  Otherwise, if the last wire is white, cut the last wire.
  Otherwise, if there is more than one blue wire, cut the last blue wire.
  Otherwise, cut the last wire.

4 wires:
  If there is more than one red wire and the last digit of the serial number is odd, cut the last red wire.
  Otherwise, if the last wire is yellow and there are no red wires, cut the first wire.
  Otherwise, if there is exactly one blue wire, cut the first wire.
  Otherwise, if there is more than one yellow wire, cut the last wire.
  Otherwise, cut the second wire.

5 wires:
  If the last wire is black and the last digit of the serial number is odd, cut the fourth wire.
  Otherwise, if there is exactly one red wire and there is more than one yellow wire, cut the first wire.
  Otherwise, if there are no black wires, cut the second wire.
  Otherwise, cut the first wire.

6 wires:
  If there are no yellow wires and the last digit of the serial number is odd, cut the third wire.
  Otherwise, if there is exactly one yellow wire and there is more than one white wire, cut the fourth wire.
  Otherwise, if there are no red wires, cut the last wire.
  Otherwise, cut the fourth wire.

রেফারেন্স সমাধান ( টিআইও )

এই কোডটি পাইথনে রয়েছে।

def wire_to_cut(wires, serial_odd):
    """Return the index of the wire to cut, one-indexed. This is a number 1 to 6.
    wires: A list of 3 through 6 color characters from BURWY
    serial_odd: A Boolean for whether the last digit of the serial is odd.

    >>> wire_to_cut(['R', 'B', 'R', 'W'], True):
    3
    """
    num_wires = len(wires)
    last_wire = wires[-1]

    if num_wires == 3:
        if wires.count('R') == 0:
            return 2
        elif last_wire == 'W':
            return num_wires
        elif wires.count('U') > 1:
            # Last blue wire
            return ''.join(wires).rindex('U') + 1
        else:
            return num_wires

    elif num_wires == 4:
        if wires.count('R') > 1 and serial_odd:
            # Last red wire
            return ''.join(wires).rindex('R') + 1
        elif last_wire == 'Y' and wires.count('R') == 0:
            return 1
        elif wires.count('U') == 1:
            return 1
        elif wires.count('Y') > 1:
            return num_wires
        else:
            return 2

    elif num_wires == 5:
        if last_wire == 'B' and serial_odd:
            return 4
        elif wires.count('R') == 1 and wires.count('Y') > 1:
            return 1
        elif wires.count('B') == 0:
            return 2
        else:
            return 1

    elif num_wires == 6:
        if wires.count('Y') == 0 and serial_odd:
            return 3
        elif wires.count('Y') == 1 and wires.count('W') > 1:
            return 4
        elif wires.count('R') == 0:
            return num_wires
        else:
            return 4

    else:
        raise ValueError("Wrong number of wires.")

পরীক্ষার মামলা

যেমন (input, output)যেখানে input = (wires, odd_serial)।

((['B', 'B', 'B'], False), 2)
((['B', 'B', 'Y'], True), 2)
((['B', 'R', 'R'], False), 3)
((['B', 'W', 'U'], True), 2)
((['U', 'B', 'B'], True), 2)
((['U', 'B', 'Y'], False), 2)
((['U', 'U', 'R'], True), 2)
((['U', 'U', 'U'], False), 2)
((['U', 'R', 'R'], True), 3)
((['U', 'Y', 'Y'], False), 2)
((['R', 'B', 'U'], False), 3)
((['R', 'B', 'Y'], False), 3)
((['R', 'U', 'B'], False), 3)
((['R', 'R', 'U'], False), 3)
((['R', 'W', 'U'], True), 3)
((['W', 'B', 'W'], False), 2)
((['W', 'B', 'Y'], True), 2)
((['W', 'R', 'U'], True), 3)
((['W', 'W', 'B'], True), 2)
((['W', 'W', 'U'], True), 2)
((['W', 'Y', 'W'], True), 2)
((['Y', 'U', 'B'], True), 2)
((['Y', 'U', 'W'], False), 2)
((['Y', 'R', 'U'], False), 3)
((['Y', 'Y', 'B'], False), 2)
((['Y', 'Y', 'B'], True), 2)
((['B', 'B', 'U', 'U'], True), 2)
((['B', 'B', 'R', 'W'], True), 2)
((['B', 'B', 'R', 'Y'], True), 2)
((['B', 'U', 'B', 'R'], False), 1)
((['B', 'U', 'R', 'W'], False), 1)
((['B', 'U', 'W', 'R'], True), 1)
((['B', 'U', 'W', 'Y'], True), 1)
((['B', 'U', 'Y', 'R'], False), 1)
((['B', 'R', 'U', 'B'], True), 1)
((['B', 'R', 'R', 'B'], True), 3)
((['B', 'R', 'Y', 'W'], True), 2)
((['B', 'R', 'Y', 'Y'], True), 4)
((['B', 'W', 'R', 'U'], True), 1)
((['B', 'W', 'Y', 'B'], False), 2)
((['B', 'Y', 'R', 'U'], False), 1)
((['B', 'Y', 'R', 'R'], False), 2)
((['U', 'B', 'R', 'W'], False), 1)
((['U', 'B', 'W', 'Y'], False), 1)
((['U', 'B', 'Y', 'W'], True), 1)
((['U', 'U', 'R', 'W'], True), 2)
((['U', 'U', 'W', 'B'], False), 2)
((['U', 'U', 'W', 'Y'], False), 1)
((['U', 'R', 'B', 'U'], False), 2)
((['U', 'R', 'Y', 'U'], True), 2)
((['U', 'R', 'Y', 'W'], False), 1)
((['U', 'R', 'Y', 'Y'], False), 1)
((['U', 'W', 'U', 'Y'], False), 1)
((['U', 'W', 'W', 'W'], False), 1)
((['U', 'Y', 'B', 'B'], False), 1)
((['U', 'Y', 'B', 'W'], True), 1)
((['U', 'Y', 'U', 'R'], True), 2)
((['U', 'Y', 'R', 'W'], False), 1)
((['R', 'B', 'R', 'R'], False), 2)
((['R', 'U', 'B', 'B'], True), 1)
((['R', 'U', 'W', 'B'], False), 1)
((['R', 'R', 'B', 'R'], True), 4)
((['R', 'R', 'W', 'R'], True), 4)
((['R', 'R', 'W', 'W'], True), 2)
((['R', 'R', 'Y', 'Y'], False), 4)
((['R', 'R', 'Y', 'Y'], True), 2)
((['R', 'W', 'U', 'W'], True), 1)
((['R', 'W', 'W', 'U'], False), 1)
((['R', 'W', 'Y', 'W'], False), 2)
((['R', 'Y', 'R', 'U'], False), 1)
((['R', 'Y', 'Y', 'W'], False), 4)
((['W', 'B', 'U', 'R'], False), 1)
((['W', 'B', 'U', 'Y'], False), 1)
((['W', 'U', 'B', 'Y'], False), 1)
((['W', 'U', 'U', 'W'], True), 2)
((['W', 'U', 'R', 'W'], False), 1)
((['W', 'W', 'R', 'U'], False), 1)
((['W', 'Y', 'R', 'R'], False), 2)
((['W', 'Y', 'Y', 'U'], False), 1)
((['W', 'Y', 'Y', 'Y'], True), 1)
((['Y', 'B', 'B', 'R'], True), 2)
((['Y', 'B', 'W', 'U'], False), 1)
((['Y', 'B', 'W', 'W'], False), 2)
((['Y', 'U', 'R', 'Y'], False), 1)
((['Y', 'R', 'B', 'R'], False), 2)
((['Y', 'R', 'U', 'R'], True), 4)
((['Y', 'R', 'R', 'Y'], False), 4)
((['Y', 'R', 'W', 'U'], False), 1)
((['Y', 'R', 'Y', 'B'], False), 4)
((['Y', 'R', 'Y', 'B'], True), 4)
((['Y', 'W', 'U', 'B'], False), 1)
((['Y', 'W', 'R', 'R'], True), 4)
((['Y', 'W', 'W', 'R'], True), 2)
((['Y', 'W', 'W', 'Y'], True), 1)
((['Y', 'W', 'Y', 'U'], False), 1)
((['Y', 'Y', 'B', 'B'], True), 4)
((['Y', 'Y', 'R', 'R'], True), 4)
((['B', 'B', 'B', 'R', 'W'], False), 1)
((['B', 'B', 'R', 'R', 'W'], False), 1)
((['B', 'U', 'B', 'W', 'U'], True), 1)
((['B', 'R', 'R', 'U', 'R'], True), 1)
((['B', 'R', 'R', 'W', 'W'], False), 1)
((['B', 'R', 'Y', 'Y', 'R'], False), 1)
((['B', 'W', 'B', 'W', 'B'], False), 1)
((['B', 'W', 'U', 'B', 'U'], True), 1)
((['B', 'W', 'R', 'U', 'W'], True), 1)
((['B', 'W', 'R', 'W', 'B'], False), 1)
((['B', 'W', 'W', 'R', 'U'], False), 1)
((['B', 'W', 'W', 'R', 'U'], True), 1)
((['B', 'W', 'W', 'W', 'B'], False), 1)
((['B', 'W', 'Y', 'R', 'Y'], True), 1)
((['B', 'Y', 'B', 'W', 'U'], True), 1)
((['B', 'Y', 'U', 'W', 'B'], True), 4)
((['B', 'Y', 'U', 'Y', 'W'], False), 1)
((['U', 'B', 'R', 'W', 'Y'], False), 1)
((['U', 'B', 'W', 'B', 'R'], False), 1)
((['U', 'B', 'W', 'B', 'W'], False), 1)
((['U', 'B', 'W', 'Y', 'R'], False), 1)
((['U', 'B', 'Y', 'U', 'B'], True), 4)
((['U', 'B', 'Y', 'U', 'Y'], False), 1)
((['U', 'B', 'Y', 'R', 'W'], False), 1)
((['U', 'U', 'B', 'B', 'U'], True), 1)
((['U', 'U', 'R', 'U', 'W'], True), 2)
((['U', 'U', 'Y', 'U', 'R'], True), 2)
((['U', 'U', 'Y', 'U', 'W'], False), 2)
((['U', 'R', 'B', 'Y', 'Y'], False), 1)
((['U', 'R', 'U', 'B', 'Y'], False), 1)
((['U', 'R', 'W', 'W', 'B'], False), 1)
((['U', 'R', 'Y', 'Y', 'W'], False), 1)
((['U', 'W', 'B', 'U', 'B'], True), 4)
((['U', 'W', 'U', 'U', 'B'], True), 4)
((['U', 'W', 'R', 'U', 'Y'], True), 2)
((['U', 'W', 'R', 'R', 'R'], True), 2)
((['U', 'W', 'R', 'R', 'W'], False), 2)
((['U', 'W', 'R', 'Y', 'W'], True), 2)
((['U', 'W', 'W', 'Y', 'R'], True), 2)
((['U', 'Y', 'B', 'W', 'Y'], False), 1)
((['U', 'Y', 'U', 'R', 'W'], True), 2)
((['U', 'Y', 'R', 'R', 'U'], False), 2)
((['U', 'Y', 'Y', 'B', 'W'], False), 1)
((['U', 'Y', 'Y', 'R', 'B'], True), 4)
((['U', 'Y', 'Y', 'Y', 'R'], False), 1)
((['R', 'B', 'B', 'W', 'U'], False), 1)
((['R', 'B', 'U', 'B', 'Y'], False), 1)
((['R', 'B', 'R', 'R', 'Y'], True), 1)
((['R', 'B', 'W', 'W', 'R'], True), 1)
((['R', 'B', 'W', 'W', 'W'], False), 1)
((['R', 'U', 'U', 'B', 'U'], True), 1)
((['R', 'U', 'U', 'R', 'Y'], False), 2)
((['R', 'U', 'R', 'B', 'W'], False), 1)
((['R', 'U', 'R', 'Y', 'R'], True), 2)
((['R', 'R', 'B', 'U', 'U'], True), 1)
((['R', 'R', 'B', 'R', 'W'], True), 1)
((['R', 'R', 'W', 'B', 'Y'], True), 1)
((['R', 'R', 'Y', 'Y', 'B'], False), 1)
((['R', 'W', 'U', 'Y', 'W'], False), 2)
((['R', 'W', 'Y', 'B', 'U'], True), 1)
((['R', 'Y', 'B', 'U', 'U'], True), 1)
((['R', 'Y', 'B', 'R', 'Y'], True), 1)
((['R', 'Y', 'B', 'W', 'R'], True), 1)
((['R', 'Y', 'R', 'U', 'U'], False), 2)
((['R', 'Y', 'Y', 'W', 'B'], True), 4)
((['R', 'Y', 'Y', 'W', 'W'], True), 1)
((['W', 'B', 'R', 'R', 'R'], False), 1)
((['W', 'U', 'U', 'U', 'B'], False), 1)
((['W', 'U', 'U', 'R', 'B'], False), 1)
((['W', 'U', 'R', 'B', 'R'], False), 1)
((['W', 'U', 'W', 'W', 'R'], True), 2)
((['W', 'U', 'Y', 'R', 'W'], True), 2)
((['W', 'R', 'R', 'B', 'Y'], True), 1)
((['W', 'W', 'U', 'B', 'W'], True), 1)
((['W', 'W', 'U', 'W', 'R'], False), 2)
((['W', 'W', 'W', 'W', 'B'], False), 1)
((['W', 'W', 'W', 'W', 'W'], False), 2)
((['W', 'W', 'Y', 'W', 'U'], True), 2)
((['W', 'W', 'Y', 'Y', 'R'], False), 1)
((['W', 'Y', 'R', 'B', 'B'], False), 1)
((['W', 'Y', 'W', 'B', 'W'], True), 1)
((['W', 'Y', 'Y', 'W', 'U'], True), 2)
((['Y', 'B', 'U', 'R', 'B'], True), 4)
((['Y', 'B', 'U', 'Y', 'R'], False), 1)
((['Y', 'B', 'R', 'Y', 'Y'], False), 1)
((['Y', 'B', 'W', 'U', 'B'], True), 4)
((['Y', 'B', 'Y', 'R', 'R'], False), 1)
((['Y', 'U', 'U', 'U', 'U'], False), 2)
((['Y', 'U', 'R', 'W', 'B'], False), 1)
((['Y', 'U', 'W', 'U', 'Y'], True), 2)
((['Y', 'U', 'Y', 'Y', 'W'], False), 2)
((['Y', 'R', 'R', 'R', 'Y'], False), 2)
((['Y', 'R', 'R', 'Y', 'R'], False), 2)
((['Y', 'R', 'W', 'W', 'U'], False), 2)
((['Y', 'W', 'B', 'R', 'U'], True), 1)
((['Y', 'W', 'U', 'U', 'W'], True), 2)
((['Y', 'W', 'U', 'R', 'B'], False), 1)
((['Y', 'W', 'R', 'R', 'R'], True), 2)
((['Y', 'W', 'R', 'Y', 'R'], False), 2)
((['Y', 'W', 'W', 'B', 'U'], True), 1)
((['Y', 'W', 'W', 'W', 'B'], False), 1)
((['Y', 'Y', 'R', 'Y', 'U'], False), 1)
((['B', 'B', 'B', 'B', 'R', 'U'], False), 4)
((['B', 'B', 'B', 'R', 'R', 'R'], True), 3)
((['B', 'B', 'R', 'U', 'W', 'Y'], False), 4)
((['B', 'B', 'R', 'R', 'R', 'B'], True), 3)
((['B', 'B', 'W', 'U', 'B', 'B'], False), 6)
((['B', 'B', 'W', 'U', 'B', 'U'], True), 3)
((['B', 'B', 'W', 'W', 'B', 'R'], True), 3)
((['B', 'B', 'Y', 'Y', 'W', 'R'], False), 4)
((['B', 'U', 'B', 'B', 'W', 'U'], False), 6)
((['B', 'U', 'U', 'W', 'W', 'Y'], True), 4)
((['B', 'U', 'U', 'Y', 'Y', 'R'], False), 4)
((['B', 'U', 'R', 'R', 'B', 'Y'], True), 4)
((['B', 'U', 'W', 'B', 'W', 'Y'], True), 4)
((['B', 'U', 'Y', 'R', 'R', 'R'], False), 4)
((['B', 'U', 'Y', 'R', 'Y', 'B'], False), 4)
((['B', 'R', 'U', 'B', 'U', 'B'], True), 3)
((['B', 'R', 'R', 'R', 'Y', 'B'], True), 4)
((['B', 'R', 'R', 'W', 'B', 'R'], True), 3)
((['B', 'R', 'Y', 'B', 'R', 'W'], False), 4)
((['B', 'R', 'Y', 'W', 'B', 'Y'], False), 4)
((['B', 'W', 'U', 'Y', 'U', 'W'], False), 4)
((['B', 'W', 'R', 'U', 'Y', 'Y'], True), 4)
((['B', 'W', 'R', 'Y', 'U', 'W'], False), 4)
((['B', 'W', 'W', 'Y', 'U', 'R'], False), 4)
((['B', 'W', 'Y', 'R', 'B', 'R'], False), 4)
((['B', 'W', 'Y', 'W', 'Y', 'U'], False), 6)
((['B', 'Y', 'B', 'R', 'B', 'R'], True), 4)
((['B', 'Y', 'U', 'B', 'Y', 'U'], False), 6)
((['B', 'Y', 'R', 'U', 'Y', 'U'], True), 4)
((['B', 'Y', 'R', 'R', 'W', 'W'], True), 4)
((['B', 'Y', 'W', 'W', 'U', 'B'], True), 4)
((['U', 'B', 'B', 'W', 'R', 'R'], True), 3)
((['U', 'B', 'W', 'B', 'W', 'U'], False), 6)
((['U', 'B', 'Y', 'U', 'B', 'R'], False), 4)
((['U', 'U', 'B', 'B', 'W', 'Y'], False), 6)
((['U', 'U', 'B', 'W', 'B', 'B'], True), 3)
((['U', 'U', 'B', 'Y', 'Y', 'Y'], False), 6)
((['U', 'U', 'U', 'B', 'U', 'Y'], True), 6)
((['U', 'U', 'U', 'B', 'Y', 'Y'], False), 6)
((['U', 'U', 'U', 'Y', 'W', 'B'], False), 6)
((['U', 'U', 'R', 'U', 'W', 'R'], True), 3)
((['U', 'U', 'Y', 'W', 'W', 'U'], True), 4)
((['U', 'U', 'Y', 'Y', 'B', 'R'], False), 4)
((['U', 'R', 'B', 'R', 'Y', 'R'], False), 4)
((['U', 'R', 'B', 'R', 'Y', 'Y'], True), 4)
((['U', 'R', 'R', 'B', 'U', 'R'], False), 4)
((['U', 'R', 'W', 'B', 'B', 'B'], False), 4)
((['U', 'R', 'W', 'Y', 'U', 'U'], True), 4)
((['U', 'R', 'Y', 'U', 'B', 'Y'], True), 4)
((['U', 'W', 'B', 'B', 'B', 'U'], False), 6)
((['U', 'W', 'B', 'R', 'W', 'Y'], True), 4)
((['U', 'W', 'R', 'R', 'B', 'R'], True), 3)
((['U', 'W', 'R', 'W', 'Y', 'B'], True), 4)
((['U', 'W', 'W', 'B', 'Y', 'R'], True), 4)
((['U', 'W', 'W', 'W', 'R', 'W'], False), 4)
((['U', 'W', 'W', 'W', 'R', 'Y'], True), 4)
((['U', 'Y', 'B', 'Y', 'R', 'W'], False), 4)
((['U', 'Y', 'U', 'R', 'U', 'Y'], False), 4)
((['U', 'Y', 'U', 'R', 'Y', 'W'], False), 4)
((['U', 'Y', 'R', 'W', 'U', 'U'], False), 4)
((['U', 'Y', 'R', 'Y', 'Y', 'U'], False), 4)
((['U', 'Y', 'Y', 'B', 'W', 'Y'], True), 6)
((['U', 'Y', 'Y', 'R', 'R', 'Y'], True), 4)
((['R', 'B', 'B', 'U', 'U', 'W'], False), 4)
((['R', 'B', 'B', 'Y', 'R', 'U'], False), 4)
((['R', 'B', 'R', 'Y', 'B', 'R'], True), 4)
((['R', 'B', 'W', 'B', 'R', 'B'], False), 4)
((['R', 'B', 'W', 'W', 'U', 'U'], True), 3)
((['R', 'B', 'Y', 'R', 'Y', 'W'], False), 4)
((['R', 'U', 'B', 'B', 'B', 'W'], True), 3)
((['R', 'U', 'B', 'B', 'R', 'W'], False), 4)
((['R', 'U', 'U', 'U', 'R', 'Y'], False), 4)
((['R', 'U', 'U', 'Y', 'U', 'W'], False), 4)
((['R', 'U', 'R', 'W', 'W', 'R'], False), 4)
((['R', 'U', 'R', 'W', 'W', 'W'], False), 4)
((['R', 'U', 'R', 'Y', 'R', 'U'], False), 4)
((['R', 'U', 'W', 'U', 'Y', 'W'], False), 4)
((['R', 'U', 'W', 'W', 'Y', 'Y'], True), 4)
((['R', 'U', 'W', 'Y', 'W', 'Y'], False), 4)
((['R', 'R', 'B', 'W', 'U', 'W'], False), 4)
((['R', 'R', 'B', 'W', 'W', 'U'], True), 3)
((['R', 'R', 'U', 'B', 'B', 'U'], False), 4)
((['R', 'R', 'U', 'W', 'R', 'B'], True), 3)
((['R', 'R', 'U', 'Y', 'Y', 'R'], False), 4)
((['R', 'R', 'W', 'U', 'W', 'W'], True), 3)
((['R', 'R', 'W', 'W', 'B', 'W'], False), 4)
((['R', 'R', 'Y', 'U', 'B', 'W'], False), 4)
((['R', 'R', 'Y', 'Y', 'U', 'Y'], True), 4)
((['R', 'W', 'B', 'Y', 'R', 'B'], True), 4)
((['R', 'W', 'U', 'B', 'U', 'R'], True), 3)
((['R', 'W', 'U', 'Y', 'U', 'Y'], False), 4)
((['R', 'W', 'W', 'U', 'B', 'Y'], True), 4)
((['R', 'W', 'Y', 'B', 'W', 'Y'], False), 4)
((['R', 'W', 'Y', 'U', 'B', 'Y'], False), 4)
((['R', 'W', 'Y', 'W', 'U', 'U'], False), 4)
((['R', 'Y', 'B', 'W', 'W', 'R'], False), 4)
((['R', 'Y', 'U', 'R', 'B', 'W'], False), 4)
((['R', 'Y', 'U', 'Y', 'R', 'U'], False), 4)
((['R', 'Y', 'R', 'R', 'U', 'R'], True), 4)
((['R', 'Y', 'Y', 'B', 'U', 'R'], False), 4)
((['R', 'Y', 'Y', 'B', 'R', 'W'], False), 4)
((['R', 'Y', 'Y', 'B', 'Y', 'R'], True), 4)
((['R', 'Y', 'Y', 'Y', 'Y', 'R'], False), 4)
((['W', 'B', 'B', 'B', 'R', 'U'], True), 3)
((['W', 'B', 'B', 'R', 'Y', 'Y'], False), 4)
((['W', 'B', 'B', 'Y', 'Y', 'R'], False), 4)
((['W', 'B', 'R', 'R', 'U', 'U'], True), 3)
((['W', 'B', 'R', 'W', 'R', 'Y'], False), 4)
((['W', 'B', 'Y', 'U', 'Y', 'Y'], True), 6)
((['W', 'B', 'Y', 'R', 'R', 'U'], False), 4)
((['W', 'U', 'U', 'B', 'R', 'W'], True), 3)
((['W', 'U', 'U', 'R', 'W', 'R'], False), 4)
((['W', 'U', 'R', 'U', 'B', 'W'], True), 3)
((['W', 'U', 'R', 'U', 'U', 'Y'], True), 4)
((['W', 'U', 'R', 'U', 'R', 'W'], True), 3)
((['W', 'U', 'R', 'U', 'R', 'Y'], False), 4)
((['W', 'U', 'R', 'R', 'U', 'R'], False), 4)
((['W', 'U', 'W', 'U', 'U', 'Y'], True), 4)
((['W', 'U', 'W', 'Y', 'B', 'R'], True), 4)
((['W', 'U', 'Y', 'R', 'B', 'W'], True), 4)
((['W', 'R', 'B', 'B', 'U', 'W'], False), 4)
((['W', 'R', 'B', 'B', 'U', 'Y'], True), 4)
((['W', 'R', 'B', 'Y', 'W', 'R'], False), 4)
((['W', 'R', 'U', 'B', 'W', 'B'], True), 3)
((['W', 'R', 'U', 'Y', 'Y', 'Y'], True), 4)
((['W', 'R', 'R', 'B', 'W', 'Y'], False), 4)
((['W', 'R', 'R', 'R', 'U', 'B'], False), 4)
((['W', 'R', 'R', 'W', 'W', 'Y'], True), 4)
((['W', 'R', 'W', 'B', 'B', 'W'], True), 3)
((['W', 'R', 'Y', 'U', 'B', 'B'], True), 4)
((['W', 'R', 'Y', 'R', 'R', 'R'], True), 4)
((['W', 'W', 'B', 'R', 'R', 'Y'], True), 4)
((['W', 'W', 'B', 'Y', 'U', 'U'], True), 4)
((['W', 'W', 'U', 'W', 'R', 'U'], True), 3)
((['W', 'W', 'U', 'W', 'Y', 'B'], True), 4)
((['W', 'W', 'U', 'Y', 'Y', 'B'], True), 6)
((['W', 'W', 'R', 'R', 'R', 'W'], True), 3)
((['W', 'W', 'W', 'U', 'W', 'Y'], False), 4)
((['W', 'Y', 'R', 'B', 'W', 'U'], False), 4)
((['W', 'Y', 'R', 'W', 'U', 'W'], True), 4)
((['W', 'Y', 'R', 'Y', 'R', 'B'], True), 4)
((['W', 'Y', 'W', 'U', 'U', 'B'], True), 4)
((['W', 'Y', 'Y', 'Y', 'R', 'B'], False), 4)
((['Y', 'B', 'B', 'R', 'W', 'R'], False), 4)
((['Y', 'B', 'R', 'R', 'U', 'B'], True), 4)
((['Y', 'B', 'R', 'Y', 'W', 'R'], False), 4)
((['Y', 'B', 'W', 'Y', 'B', 'R'], True), 4)
((['Y', 'B', 'Y', 'W', 'W', 'Y'], True), 6)
((['Y', 'U', 'B', 'U', 'B', 'U'], False), 6)
((['Y', 'U', 'B', 'U', 'U', 'U'], False), 6)
((['Y', 'U', 'B', 'U', 'Y', 'Y'], False), 6)
((['Y', 'U', 'B', 'W', 'R', 'Y'], True), 4)
((['Y', 'U', 'U', 'B', 'R', 'W'], False), 4)
((['Y', 'U', 'R', 'B', 'W', 'U'], False), 4)
((['Y', 'U', 'Y', 'R', 'Y', 'Y'], True), 4)
((['Y', 'R', 'B', 'B', 'U', 'R'], False), 4)
((['Y', 'R', 'B', 'B', 'U', 'W'], True), 4)
((['Y', 'R', 'B', 'B', 'R', 'B'], False), 4)
((['Y', 'R', 'B', 'R', 'B', 'W'], False), 4)
((['Y', 'R', 'U', 'U', 'U', 'R'], False), 4)
((['Y', 'R', 'R', 'U', 'B', 'W'], True), 4)
((['Y', 'R', 'R', 'W', 'B', 'W'], True), 4)
((['Y', 'R', 'R', 'W', 'U', 'W'], False), 4)
((['Y', 'R', 'W', 'B', 'Y', 'B'], True), 4)
((['Y', 'R', 'W', 'Y', 'Y', 'R'], False), 4)
((['Y', 'R', 'Y', 'B', 'Y', 'B'], False), 4)
((['Y', 'W', 'B', 'R', 'W', 'W'], False), 4)
((['Y', 'W', 'U', 'R', 'W', 'W'], False), 4)
((['Y', 'W', 'R', 'B', 'Y', 'U'], False), 4)
((['Y', 'W', 'R', 'U', 'U', 'Y'], False), 4)
((['Y', 'W', 'R', 'R', 'W', 'B'], True), 4)
((['Y', 'W', 'W', 'U', 'Y', 'W'], True), 6)
((['Y', 'W', 'Y', 'U', 'U', 'U'], True), 6)
((['Y', 'W', 'Y', 'R', 'B', 'B'], False), 4)
((['Y', 'Y', 'B', 'B', 'B', 'B'], True), 6)
((['Y', 'Y', 'B', 'B', 'W', 'R'], True), 4)
((['Y', 'Y', 'B', 'R', 'W', 'Y'], False), 4)
((['Y', 'Y', 'B', 'Y', 'Y', 'B'], False), 6)
((['Y', 'Y', 'R', 'B', 'Y', 'W'], False), 4)
((['Y', 'Y', 'R', 'Y', 'U', 'W'], True), 4)

এই পাইথন কোডটি সমস্ত 39000 সম্ভাব্য ইনপুট ( টিআইও ) উত্পন্ন করে ।

import itertools

def generate_all_inputs():
    colors = ['B', 'U', 'R', 'W', 'Y']

    for num_wires in [3, 4, 5, 6]:
        for wires in itertools.product(colors, repeat=num_wires):
            for serial_odd in [False, True]:
                yield (list(wires), serial_odd)

লিডারবোর্ড

কোড স্নিপেট দেখান

code-golf  game  compression 
— xnor
সূত্র
5
... সুতরাং যখন তারা "নীল তারে কখনও কাটবেন না" বলে তখন তাদের সত্যই বলা উচিত "পঞ্চম তারটি কখনও কাটবে না" (সূচকে "কাটতে তারের সংখ্যা" 4453, 2359, 4252, 22045, 0, 5891:)।
— জোনাথন অ্যালান
@ নটস 90 UURএই একমাত্র সংমিশ্রণের জন্য এটি গুরুত্বপূর্ণ, তাই না? আমি এটি পরীক্ষার কেসগুলিতে যুক্ত করব।
— xnor
সি এর মতো ভাষার জন্য আমরা কি অক্ষরের ইনপুট ছাড়াও তারের সংখ্যা নিতে পারি?
— কনর
1
Complicated Wiresকখন? : পি
— CAD97
2
আমি মনে করি যে 3 টি তারের অকেজো যেখানে রয়েছে সেখানে দ্বিতীয় দ্রষ্টব্য বিবেচনা করে সমস্ত সমাধান কয়েকটি বাইট সংরক্ষণ করতে পারে: যদি সেই ক্ষেত্রে ট্রিগার করা উচিত তবে কমপক্ষে একটি লাল এবং একটি সাদা তার রয়েছে, সুতরাং একাধিক নীল তার থাকতে পারে না , এবং ডিফল্ট কেস এটি যত্ন নেবে।
— নুর

উত্তর:

9

জাভাস্ক্রিপ্ট (ES6), 210 203 199 187 180 বাইট

নোর ধন্যবাদ 7 বাইট সংরক্ষণ করা ।

পুতুল এর তালিকা লাগে wএবং পতাকাঙ্কিত oসিনট্যাক্স সংবাহন মধ্যে (w)(o)।

w=>o=>(([,,C,D,E,F]=w).map(c=>eval(c+`=${++i}+`+c),i=B=U=R=W=Y=''),F?!Y&o?3:7/Y&7&&W>7||R?4:6:E?E<'C'&o?4:7/R&7&&Y>7||B?1:2:D?R>7&o?+R[0]:D>'X'&!R|7/U&7?1:Y>7?4:2:!R?2:U<7?3:+U[0])

কিভাবে?

প্রতিটি রঙের জন্য, আমরা 1-ভিত্তিক সূচকের তালিকার প্রতিনিধিত্ব করে একটি স্ট্রিং তৈরি করি যেখানে শেষ থেকে প্রথম অবস্থানে এই রঙটি পাওয়া যায়।

উদাহরণস্বরূপ, শেষ পরীক্ষার কেসটি ['Y', 'Y', 'R', 'Y', 'U', 'W']অনুবাদ হবে:

  • খ = ''
  • ইউ = '5'
  • আর = '3'
  • ডাব্লু = '6'
  • Y = '421'

এই ভেরিয়েবলগুলি নিয়মযুক্ত সংক্ষিপ্ত আকারে সমস্ত বিধিগুলি প্রক্রিয়াজাত করতে পর্যাপ্ত তথ্য সরবরাহ করে, নির্দিষ্ট তারগুলিতে পরীক্ষাগুলি ব্যতীত যা কাঠামোগত ইনপুট তালিকায় সঞ্চালিত হয় [, , C, D, E, F]।

Rule                              | Code
----------------------------------+---------------------------------------------------
no X wires                        | !X
more than one X wire              | X>7
exactly one X wire                | 7/X&7
position of last X wire (1-based) | +X[0]
(N+1)th wire is X (1-based)       | w[N]=='X' (where w[N] is replaced by C, D, E or F)

পরীক্ষার মামলা

কোড স্নিপেট দেখান

সমস্ত সম্ভাব্য ইনপুট

এটি সম্পূর্ণ হতে এক বা দুই সেকেন্ড সময় নিতে হবে, বেশিরভাগ কারণ ইভাল () ধীর হয়।

কোড স্নিপেট দেখান

— Arnauld
সূত্র
এই কারিটিং সিনট্যাক্সটি বেশ চমৎকার একটি বাইট-সেভার।
— চার্লি
আমার টিআইও দ্বারা উত্পাদিত 39000 ইনপুটগুলির সম্পূর্ণ সেটটিতে এটি পরীক্ষা করা সম্ভব হবে?
— xnor
@ এক্সনর আমি আপনার পাইথন কোডের একটি বন্দরের বিরুদ্ধে একটি বিস্তৃত পরীক্ষা যুক্ত করেছি।
— আর্নৌল্ড
অভিনন্দন, আমি তারের একটি চালাক দক্ষতার সাথে অনুসন্ধানযোগ্য প্রতিনিধিত্ব সহ, একটি ভাল-অনুকূলিতকরণ সমাধানের জন্য আপনাকে পুরষ্কার প্রদান করেছি। এটি এবং জোনাথন অ্যালানের পাইথন সমাধানের মধ্যে একটি ঘনিষ্ঠ সিদ্ধান্ত ছিল ।
— xnor
5

পাইথন 2 ,  300  214 বাইট

-12 বাইট নোর দ্বারা করা একটি মন্তব্যে ধন্যবাদ (3 দৈর্ঘ্যের জন্য শেষ তারের সাদা পরীক্ষা অপ্রয়োজনীয়!)

def f(w,o):e=w[-1];r,u,y,x=map(w.count,'RUYW');g=r>0;return[2+(u<2or'R'<e)*g,[1+(e<'Y'or g)*(1+2*(y>1))*(u!=1),`w`.rfind('R')/5+1][(r>1)*o],[2-(y>r==1or'B'in w),4][(e<'C')*o],3*o*(y<1)or[6-2*g,4][x>y==1]][len(w)-3]

এটি অনলাইন চেষ্টা করুন! (সমস্ত পরীক্ষা জোর দেওয়ার চেষ্টা করে এবং সম্পূর্ণ বা ত্রুটির পরে একটি বার্তা মুদ্রণ করে))

বিট-টুইডলিং ব্যবহার করার এবং একটি সংক্ষিপ্ত সমাধান পাওয়ার জন্য খুব সুন্দর উপায় থাকতে পারে।

ম্যানুয়ালটির চেয়ে বোঝার জন্য অবশ্যই শক্ত!

— জোনাথন অ্যালান
সূত্র
দেখে মনে হচ্ছে দৈর্ঘ্য -৩ ফলাফলগুলির মধ্যে কিছু সম্ভাব্য ইনপুটগুলির পুরো সেটটিতে ভুল।
— xnor
এটি এটির সাথে for টি স্থির করে u<2- u<2or'R'<e(চারটি ব্যর্থতার ক্ষেত্রে যখন দুটি নীল তার এবং একটি লাল তার ছিল এবং শেষটি নীল ছিল, যখন এটি 3 এর পরিবর্তে 2 ফিরে আসবে)।
— জোনাথন অ্যালান
4

সি (জিসিসি) , 264 237 233 বাইট

s,i,r,u,y,b,w,z,x,t,q,p;f(S,o)char*S;{for(;s=S[i++];b+=t=s==66,r+=s==82&&(p=i),u+=s==85&&(q=i),y+=x=s==89,w+=z=s==87);S=i==4?r?z?3:u>1?q:3:2:i==5?r*o>1?p:x*!r||u==1?1:y<2?2:4:i==6?t*o?4:r==1&y>1||b?1:2:i==7?!y*o?3:y==1&w>1||r?4:6:0;}

এটি অনলাইন চেষ্টা করুন!

গ্লোবাল এবং নন-পোর্টেবল রিটার্ন ট্রিক, 264 বাইট ছাড়াই সংস্করণ:

f(S,o)char*S;{int s,i,r,u,y,b,w,z,x,t,q,p=q=t=x=z=w=b=y=u=r=i=0;for(;s=S[i++];b+=t=s==66,r+=s==82&&(p=i),u+=s==85&&(q=i),y+=x=s==89,w+=z=s==87);return i==4?r?z?3:u>1?q:3:2:i==5?r*o>1?p:x*!r||u==1?1:y<2?2:4:i==6?t*o?4:r==1&y>1||b?1:2:i==7?!y*o?3:y==1&w>1||r?4:6:0;}

চলক উল্লেখ (আমি যদি ভুল না করি):

  • r: # তারের # টি
  • u: # নীল তারের
  • y: হলুদ তারের # টি
  • খ: # কালো তারের #
  • ডাব্লু: সাদা তারের #
  • z: শেষ তারটি সাদা (0 বা 1)
  • x: শেষ তারটি হলুদ (0 বা 1)
  • টি: শেষ তারটি কালো (0 বা 1)
  • প্রশ্ন: শেষ নীল তারের সূচি (1-সূচকযুক্ত)
  • পি: সর্বশেষ লাল তারের সূচি (1-সূচকযুক্ত)
— dbandstra
সূত্র
আপনি প্রতিস্থাপন 5 বাইট সংরক্ষণ করতে পারবেন return i==4...সঙ্গে S=i==4...। এটি অনলাইন চেষ্টা করুন!
— কনর
@ কনরও ব্রায়েন এর পরিবর্তে সি (জিসিসি) এর কম সাধারণ ভাষার প্রয়োজন। এটি মোটেও কাজ করবে না, যেমন ঝনঝন ।
— FryAmTheEggman
1
@ ফ্রাইআমডেজিগম্যান কেবল জিসিসি নয়, এটি টিসিসিতেও কাজ করে । বেশিরভাগ সংকলকগণ সেভাবে এটি করেন, আমি মনে করি ঝাঁকুনি কেবল একটি অদ্ভুত সংকলক। তবে হ্যাঁ, এটি মানক নয়।
— কনর
4

জাভাস্ক্রিপ্ট (ES6), 237 222 বাইট

(a,o,[b,u,r,w,y]=[..."BURWY"].map(c=>a.filter(x=>x==c).length),q="lastIndexOf")=>[!r?2:a[2]=="W"|u<2?3:a[q]("U")+1,r>1&o?a[q]("R")+1:a[3]>"X"&!r|u==1?1:y>1?4:2,a[4]<"C"&o?4:r==1&y>1|b?1:2,!y&o?3:y==1&w>1|r?4:6][a.length-3]

পরীক্ষার স্নিপেট

f=
(a,o,[b,u,r,w,y]=[..."BURWY"].map(c=>a.filter(x=>x==c).length),q="lastIndexOf")=>[!r?2:a[2]=="W"|u<2?3:a[q]("U")+1,r>1&o?a[q]("R")+1:a[3]>"X"&!r|u==1?1:y>1?4:2,a[4]<"C"&o?4:r==1&y>1|b?1:2,!y&o?3:y==1&w>1|r?4:6][a.length-3]
<div oninput="O.value=I.value.length>2?f([...I.value],C.checked):''">Wires: <input id="I"> Odd serial? <input type="checkbox" id="C"></div>
Result: <input id="O" disabled size="2">
স্নিপেট প্রসারিত করুন

টেস্ট

চ্যালেঞ্জ থেকে টেস্টগুলি এখানে অনুকরণ করা হয় ।

— জাস্টিন মেরিনার
সূত্র
4

হাস্কেল , 315 301 295 284 277 বাইট

7 বাইট সংরক্ষণের জন্য নোর ধন্যবাদ

c o s|l<4=z|l<5=x|l<6=q|l<7=p where b:u:r:w:y:_="BURWY";t=last s;l=length s;m=n r;k=n y;f c=[i|(x,i)<-zip s[1..],x==c];n=length.f;z|m<1=2|n u>1,t/=u=2|1>0=3;x|o,m>1=last(f r)|t==y,m<1=1|n u==1=1|k>1=4|1>0=2;q|o,t==b=4|m==1,k>1=1|n b<1=2|1>0=1;p|o,k<1=3|k==1,n w>1=4|m<1=6|1>0=4

এটি অনলাইন চেষ্টা করুন!

হাস্কেলের একটি সম্পূর্ণ অবাস্তব সমাধান।

Ungolfed 

c o s
    | l<4=z -- different function for each length; no funny business
    | l<5=x
    | l<6=q
    | l<7=p 
    where 
        b:u:r:w:y:_="BURWY" -- saving space on the quotes
        t=last s -- last is often used
        l=length s
        m=n r
        k=n y -- caching the number of reds and yellows
        f c=[i|(x,i)<-zip s[1..],x==c] -- find 1-indexed indices of the character c in the string s
        n=length.f
        z
            | m<1=2
            | n u>1,t/=u=2
            | 1>0=3
        x
            | o, m>1=last(f r)
            | t==y,m<1=1
            | n u==1=1
            | k>1=4
            | 1>0=2
        q
            | o, t==b=4
            | m==1,k>1=1
            | n b<1=2
            | 1>0=1
        p
            | o, k<1=3
            | k==1,n w>1=4
            | m<1=6
            | 1>0=4
— vroomfondel
সূত্র
3

পাইথন 2 , 193 বাইট

def f(s,o):b,u,w,r,y=map(s.count,'BUWRY');l=s[-1];return+[2+(r>0<s!='UUR'),[r<1<l>'X'or u==1or y/2*2+2,1+s.rfind('R')][o*r>1],[r==1<y or-~0**b,4][l<'C'*o],[4+2*(1>r+(y==1<w)),3][y<o]][len(s)-3]

এটি অনলাইন চেষ্টা করুন!

দ্বিতীয় তিনটি তারের শর্তটি কোনও বিবেচনা করে না তা নির্দেশ করার জন্য নোরকে ধন্যবাদ ।

3 wires: 2+(r>0<s!='UUR')
4 wires: [r<1<l>'X'or u==1or y/2*2+2,1+s.rfind('R')][o*r>1]
5 wires: [r==1<y or-~0**b,4][l<'C'*o]
6 wires: [4+2*(1>r+(y==1<w)),3][y<o]

শর্ত যুক্তি করতে অনেক কৌশল একত্রিত হয়:

— xnor
সূত্র
2

রেটিনা , 297 বাইট

^[^R]{3}\d
2
^..W\d
3
^BB.\d
2
^...\d
3
^(?=(.*R){2,})(?=.{4}\d)(.)+(?<2>R).*1
$#2
^[^R]{3}Y\d
1
^(?=.{4}\d)[^U]*U[^U]*\d
1
^(?=.{4}\d)(.*Y){2,}.*\d
4
^.{4}\d
2
^.{4}B1
4
^(?=.{5}\d)(?=[^R]*R[^R]*\d)(.*Y){2,}.*\d
1
^[^B]{5}\d
2
^.{5}\d
1
^[^Y]+1
3
^(?=[^Y]*Y[^Y]*\d)(.*W){2,}.*.
4
^[^R]+.
6
^.+.
4

এটি অনলাইন চেষ্টা করুন!

একটা ভয়াবহ জগাখিচুড়ি! বিজোড়ের জন্য একটি 1 এবং সমান শূন্যের পরে কোনও ডিলিমিটারযুক্ত তালিকাভুক্ত তারগুলি সাথে ইনপুট নেয় akes আমি যাচাই করেছি যে এটি দেওয়া সমস্ত পরীক্ষার কেসের সাথে মেলে। বর্তমানে প্রতিটি পর্যায়ে (লাইনের জোড়) বেশ কয়েকটি মাত্র একটি নিয়মকে এনকোড করে। মূল সংরক্ষণটি তৃতীয় পর্যায়ে যেখানে সর্বশেষ নীল তারের তৃতীয় তারের ক্ষেত্রে "অন্য" শর্ত দ্বারা সংরক্ষণ করা যায়।

— FryAmTheEggman
সূত্র
দুঃখিত, আপনার 3-নীল তারের বোমাটি কেবল ফুঁপেছে কারণ আপনি ডান হাতের তারের পরিবর্তে মাঝের তারটি কেটেছিলেন।
— নিল
@ নীল এ 3 নীল তারের বোমার কোনও লাল তার নেই, তাই মাঝের তারটি সঠিক! আমি কিছু ভুল না পড়লে?
— ফ্রাইআম TheEggman
আমি কেবল নিজেই এই সিদ্ধান্তে পৌঁছেছি। মিথ্যা এলার্ম জন্য দুঃখিত!
— নিল
1

পাইথন 2 , 486 474 464 , 421 বাইট

রেফারেন্স উদাহরণ হিসাবে শুরু (1953 মূলত বাইট!) পাইথন সম্ভবত যতটা অপঠনযোগ্য তা হতে পারে।

-10 বাইটগুলি স্ট্রিং-এ প্রি- জয়েনিং
করে -৩৩ বাইটস সমস্ত এক লাইনে পাওয়ার জন্য ওভিএসকে ধন্যবাদ ।

def f(w,o):n=len(w);l=w[-1];s=''.join(w);return[2if not'R'in w else n if l=='W'else s.rindex('U')+1if'UU'in s else n,s.rindex('R')+1if w.count('R')>1and o else 1if l=='Y'and not'R'in w else 1if w.count('U')==1else n if w.count('Y')>1else 2,4if l=='B'and o else 1if w.count('R')==1and w.count('Y')>1else 2if not'B'in w else 1,3if not'Y'in w and o else 4if w.count('Y')==1and w.count('W')>1else n if not'R'in w else 4][n-3]

এটি অনলাইন চেষ্টা করুন!

— Notts90
সূত্র
আপনি মামলাগুলি একটি ডিকের মধ্যে এনে এবং evalএগুলিকে এনে আরও 20 থেকে 444 টি কেটে নিতে পারেন । টিআইও: goo.gl/pvSjoi
— ভোরফোনডেল
2
কেন এই নন-কেপেটিং?
— orlp
@orlp যখন আমি শুরু করেছিলাম তখন সমস্ত জায়গা সাদা জায়গা সরিয়ে পুনরায় সাজানো ছিল উদাহরণ থেকে বিবৃতি দেওয়া হলেও, আমি এ মুহূর্তে বিশেষ বা প্রতিযোগিতামূলক কিছু মনে করি নি তবে আরও কিছু করতে পারব বলে আশা করি। এখন আমি অতিরিক্ত বিটগুলি করেছি আমার ধারণা এটি প্রতিযোগিতামূলক হতে পারে।
— নোটস 90
1

আর, 407 বাইট

গল্ফ কোড 

pryr::f(a,n,{r=a=='R';u=a=='U';l=paste(length(a));s=sum;R=s(r);Y=s(a=='Y');v=4;switch(l,'3'={v=3;if(R<1){v=2}else if(s(u)>1){v=tail(which(u),1)}else{}},'4'={if(R>1&&n){v=tail(which(r),1)}else if(a[4]=='Y'&&R<1||s(u)==1){v=1}else if(Y>1){}else{v=2}},'5'={v=1;if(a[5]=='B'&&n){v=4}else if(R==1&&Y>1){}else if((a=='B')<1){v=2}else{}},'6'={if(Y<1*1){v=3}else if(Y==1&&s(a=='W')<2){}else if(R<1){v=6}else{}});v})

Ungolfed 

function(a,n){
   r=a=='R'
   u=a=='U'
   l=paste(length(a))
   s=sum
   R=s(r)
   Y=s(a=='Y')
   v=4
   switch(l,'3'={
   v=3
   if(R<1){
     v=2
   }else if(s(u)>1){
     v=tail(which(u),1)
   }else{}
   },'4'={
   if((R>1)*n){
      v=tail(which(r),1)
   }else if((a[4]=='Y')*(R<1)||s(u)==1){
      v=1
   }else if(Y>1){
   }else{
     v=2
   }
   },'5'={
     v=1
   if((a[5]=='B')*n){
     v=4
   }else if(R==1&&Y>1){
   }else if((a=='B')<1){
     v=2
   }else{}
   },{
   if((Y<1)*n){
     v=3
   }else if((Y==1)*(s(a=='W')<2)){
   }else if(R<1){
     v=6
   }else{}
 })
 v}

ব্যাখ্যা

এটি ধরে নিয়েছে যে ইনপুটটি একটি আদেশযুক্ত তালিকা হবে।

রেড এবং ব্লু ওয়্যারগুলি কোথায় ছিল তার লজিকাল অ্যারে সংরক্ষণ করে বাইটস সংরক্ষণ করা। লজিক্যাল অ্যারেটি সেই রঙের তারগুলির সংখ্যা গণনা করতে এবং সর্বশেষ লাল এবং শেষ নীল তারের সূচকটি খুঁজে পেতে ব্যবহৃত হতে পারে।

যে পরিমাণ বার বলা হয়েছিল তার কারণে ফাংশন যোগফলকে সেভ বাইট হিসাবে সংরক্ষণ করে।

স্যুইচ স্টেটমেন্টের জন্য তারের সংখ্যাকে একটি চরিত্রে রূপান্তরকরণ পেস্ট ব্যবহার করে করা হয়েছিল যা as.character () এর চেয়ে কম বাইট

ভেরিয়েবল ভি, আরম্ভের তারের সংখ্যাটি 4 টি শুরু করে, সুইচ স্টেটমেন্টের আগে আমাকে তার জন্য প্রতিবার তারের সংখ্যা 4 হয়বারে সেই বিবৃতিটি যুক্ত না করার অনুমতি দেয়।

4 দৈর্ঘ্যের জন্য দ্বিতীয় এবং তৃতীয় শর্তগুলি একটি বা স্টেটমেন্টের সাথে একত্রিত হতে পারে যদি তারা ইফলেসের সংখ্যা হ্রাস করতে পারে তবে তারা কাটাতে একই তারের মূল্যায়ন করে।

— Shayne03
সূত্র
আপনি এই টিপটি দেখতে চাইবেন । এটি বেশ কয়েকটি বাইট শেভ করতে সহায়তা করবে। যেমন "if"(R<1,v=2,"if"(s(u)>1,v=tail(which(u),1),))বনামif(R<1){v=2}else if(s(u)>1){v=tail(which(u),1)}else{}
— মিকিটি
আমার মনে হয় আপনি পার পেয়ে যাবে |এবং &বদলে ||এবং &&আপনার কন্ডিশন হবে। আপনি যদি স্যুইচটিতে ডিফল্ট ব্যবহার না করে থাকেন তবে আপনি পূর্ণসংখ্যায় যেতে পারেন। আপনার অব্যক্ত মনে হচ্ছে এটি ডিফল্ট ব্যবহার করে তবে আপনার গল্ফড কোডটি ব্যবহার করে না
— মিকিটি
1

এক্সেল ভিবিএ, 521 446 419 বাইট

ফুল সাবরুটিন যে প্রত্যাশিত ধরনের ইনপুট নেয় Arrayএবং Boolean (or Truthy/Falsy)এবং আউটপুট যা টেলিগ্রাম আপনি পরিসীমা কাটা উচিত [A4]।

Sub c(x,s)
i=UBound(x)
[A1].Resize(1,i+1)=x
[A2].Resize(1,5)=Split("B U R W Y")
[A3]="=COUNTIF(1:1,A2)"
[A3].AutoFill[A3:E3]
j=x(i)
B=[A3]
u=[B3]
R=[C3]
W=[D3]
y=[E3]
[A4]=Choose(i-1,IIf(R,IIf(j="U",i+1,IIf(U>1,InStrRev(Join(x,""),"U"),i)),2),IIf(s*(R>1),InStrRev(Join(x,""),"R"),IIf((j="Y")*(R=0)Or u=1,1,IIf(y>1,i,2))),IIf(s*(j=8),4,IIf((r=1)*(y>1),1,IIf(b,1,2))),IIf((y=0)*s,3,IIf((y=1)*(w>1),4,IIf(r,4,i))))
End Sub

উদাহরণ I / O

দ্রষ্টব্য: ভিবিএতে একটি অ্যারে পাস করার জন্য কোনও অ্যারে বা বিভক্ত বিবৃতি ব্যবহার করা প্রয়োজন

c Array("B","R","R"),FALSE 
 3
— টেলর স্কট
সূত্র
0

জাভাস্ক্রিপ্ট (ES6), 252 244 বাইট

পরীক্ষার কেসগুলি এই কোডেনটিতে দেখা যায় ।

d=(a,o,[b,u,r,y,w]=[..."BURYW"].map(i=>a.filter(t=>t==i).length),q="lastIndexOf")=>[!r?2:a[2]=='W'?3:u>1?a[q]('U')+1:3,r>1&&o?a[q]('R')+1:a[3]=='Y'&&!r?1:u==1?1:y>1?4:2,a[4]=='B'&&o?4:r==1&&y>1?1:!b?2:1,!y&&o?3:y==1&&w>1?4:!r?6:4][a.length-3];
— ajxs
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.