আমার সোয়াইপ প্যাটার্ন আইনী?


154

বেশিরভাগ অ্যান্ড্রয়েড স্মার্টফোন ব্যবহারকারীকে তাদের ফোন খুলতে একটি সোয়াইপ প্যাটার্ন ব্যবহার করার অনুমতি দেয়:

প্যাটার্ন লক

কিছু নিদর্শন বৈধ এবং অন্যগুলি অসম্ভব। একটি ইনপুট সোয়াইপ প্যাটার্ন দেওয়া হয়েছে, প্রদত্ত ইনপুট প্যাটার্নটি আইনী কিনা তা প্রমাণ করে সত্যবাদী বা মিথ্যা ফিরিয়ে দিন।

ইনপুট

গ্রিডটি 1 থেকে 9 এর মধ্যে সারি অনুসারে লেবেলযুক্ত:

1 2 3   
4 5 6   
7 8 9

ইনপুটটি প্রথম থেকে শেষ পর্যন্ত পরিদর্শন করা নোডের সমন্বিত একটি সংখ্যা। উদাহরণস্বরূপ, উপরে সোয়াইপ প্যাটার্নটি 12357।

ইনপুট একটি দশমিক সংখ্যা, স্ট্রিং বা সংখ্যার তালিকা হতে পারে। এতে 0 টি থাকবে না কারণ নোড 0 নেই।

সংশোধন: 0 থেকে8 এর অনেকগুলি ভাষা সূচকের পরে সূচকটি অনুমোদিত allowed

বিধি

  • প্রতিটি নোড প্রাথমিকভাবে অপ্রত্যাশিত হিসাবে শুরু হয় এবং কেবল একবারে দেখা হতে পারে। যে কোনও প্যাটার্ন যা নোডের একাধিকবার পরিদর্শন করে তা মিথ্যাবাদী।

  • সত্যবাদী প্যাটার্নটিতে কমপক্ষে একটি সোয়াইপ থাকতে হবে, তাই সর্বনিম্ন 2 টি নোড।

  • অপরিশোধিত নোডের সাথে সরাসরি অন্যের সাথে সামঞ্জস্য রেখে এড়ানো সম্ভব নয়। উদাহরণস্বরূপ, 13 টি মিথ্যা কারণ 2 টি অনাকাঙ্ক্ষিত এবং সরাসরি লাইনে।

  • কেবলমাত্র কোনও পরিদর্শন করা নোডের উপর দিয়ে যাওয়া সম্ভব। 42631 এটির একটি উদাহরণ।

  • লাইনগুলি অন্যথায় পার হতে পারে। উদাহরণস্বরূপ, 1524 সত্য।

  • ধরুন নোড প্রস্থগুলি তাত্পর্যপূর্ণ এবং ব্যবহারিক সমস্যাগুলি (আঙুলের বেধ ইত্যাদি) উপেক্ষা করুন। সুতরাং 16 সত্যবাদী যদিও বাস্তবে এটি অর্জন করা কিছুটা কঠিন হতে পারে।

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

1 -> false     
12 -> true   
13 -> false   
16 -> true  
31 -> false   
33 -> false  
137 -> false   
582 -> true  
519 -> true  
1541 -> false  
12357 -> true    
15782 -> true   
19735 -> false  
42631 -> true   
157842 -> true  
167294385 -> true   
297381645 -> false   
294381675 -> true

এটি , তাই বাইটের সংখ্যা সবচেয়ে কম।




ইনপুট তালিকাটি নিরবধি হওয়ার নিশ্চয়তা কি?
জাগারব

@ জগারব হ্যাঁ এটা কিছুই হবে না।
stanri

সম্পর্কিত গণিতের প্রশ্ন: math.stackexchange.com/questions/205049/…
শুদ্ধফেরেট

উত্তর:


69

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

সংখ্যার অ্যারে হিসাবে ইনপুট নেয়। মিথ্যা মানগুলি 0 বা NaN হয় । সত্যবাদী মানগুলি কঠোরভাবে ইতিবাচক পূর্ণসংখ্যা।

a=>a[p=1]*a.every(n=>a[p=a[n&p&p*n%5<0|~(p-=n)==9&&p/2]&&-n]^=p)

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

কিভাবে?

প্রস্তাবনা

দুটি অঙ্ক উলম্বভাবে, অনুভূমিকভাবে বা তির্যকভাবে বিরোধী যদি:

  • তারা উভয়ই একে অপরের থেকে পৃথক এবং 5 থেকে পৃথক (চিত্র 1)
  • অথবা তারা উভয় সমান এবং তাদের যোগফল 10 (চিত্র 2)

    বিরোধী সংখ্যা

তদ্বিতীয়ত, দুটি বিপরীত সংখ্যার n এবং p এর মধ্যবর্তী অঙ্কটি (n + p) / 2 এর সমান ।

ফর্ম্যাটযুক্ত উত্স কোড

a =>
  // force a falsy result if a[1] is undefined
  a[p = 1] *
  // walk through all values n in a[]
  a.every(n =>
    // access either a[-n] or a[undefined]
    a[
      // set p to either -n or undefined
      p =
        // read either a[0] or a[in_between_digit]
        a[
          n & p & p * n % 5 < 0 | ~(p -= n) == 9
          && p / 2
        ]
        && -n
    ]
    // toggle the flag
    ^= p
  )

পূর্ববর্তী অঙ্কগুলি ট্র্যাক করে রাখা

পরিদর্শন ডিজিটের জন্য পতাকা ইনপুট অ্যারের মধ্যে নেতিবাচক সূচকের এ সংরক্ষণ করা হয় একটি , যাতে তারা তার মূল উপাদানের সঙ্গে ধাক্কা লাগা না।

  • যদি p -n তে সেট করা থাকে :

    যদি বর্তমান ডিজিট এনটি পূর্বে নির্বাচিত না হয় a[-n] ^= -nতবে পতাকাটি সেট করবে এবং every()পরবর্তী পুনরাবৃত্তির সাথে লুপটি চলতে দেবে। অন্যথায়, এটি পতাকা সাফ করবে এবং লুপটি অবিলম্বে ব্যর্থ হতে বাধ্য করবে।

  • যদি পি সেট করা হয় অনির্ধারিত :

    a[undefined] ^= undefined0 এর ফলাফল , যা লুপকে ব্যর্থ করতে বাধ্য করে।

বিরোধী অঙ্কগুলি সনাক্ত করা হচ্ছে

নিম্নলিখিত সংজ্ঞাটি পূর্বের বর্ণনায় বর্ণিত বর্তমান অংকের এন এবং পূর্ববর্তী ডিজিট- পি বিরোধী অঙ্কগুলি কিনা তা পরীক্ষা করতে ব্যবহৃত হয় :

n & p & ((p * n) % 5 < 0) | ~(p -= n) == 9

যা এর সমান:

n & p & ((p * n) % 5 < 0) | (p -= n) == -10

দ্রষ্টব্য: জেএসে, মডুলোর ফলাফলের লভ্যাংশের একই চিহ্ন রয়েছে।

এটি ব্যাখ্যা করা যেতে পারে:

(n is odd AND -p is odd AND (neither -p or n is equal to 5)) OR (n + -p = 10)

অতএব, এই এক্সপ্রেশনটি 1 প্রদান করে যদি কেবলমাত্র n এবং -p অঙ্কগুলির বিরোধিতা হয় বা তারা একই বিজোড় অঙ্ক হয়। যেহেতু একটি অঙ্ক দুটিবার নির্বাচন করা যায় না, এই পরবর্তী ক্ষেত্রে যাইহোক সঠিকভাবে যত্ন নেওয়া হয়।

যদি এই এক্সপ্রেশনটি 1 টি ফিরে আসে , আমরা 'ইন-মধ্যবর্তী অঙ্ক' পূর্বে পরিদর্শন করা হয়েছিল কিনা তা জানতে আমরা একটি [পি / 2] পরীক্ষা করি (যেখানে পি এখন অঙ্কগুলির উপেক্ষিত যোগফলের সমান)। অন্যথায়, আমরা সত্যবাদী হওয়ার নিশ্চয়তা প্রাপ্ত একটি [0] পরীক্ষা করি।

প্রথম পুনরাবৃত্তি সম্পর্কে

প্রথম পুনরাবৃত্তিটি একটি বিশেষ কেস, এতে আগের কোনও সংখ্যা নেই এবং আমরা এটি নিঃশর্ত সফল হতে চাই।

আমরা অর্জন যে আরম্ভের দ্বারা পি থেকে 1 , কারণ কোন এন মধ্যে [1 .. 9] :

  • (1 * n) % 5 নেতিবাচক হতে পারে না
  • ~(1 - n) 9 এর সমান হতে পারে না

আসল উত্তর, 90 বাইট

এই পোস্টটি থেকে সরানো হয়েছে যাতে এটি খুব ভারবস না পায়। আপনি এটি এখানে দেখতে পারেন


-1 প্রতিস্থাপনের !!a[1]&মাধ্যমে বাইট a[1]&&, যেহেতু কোনও সত্যবাদী মান ফিরে আসতে পারে
হারমান এল

@ হারমানলাউনস্টেইন ধন্যবাদ, এটি আসলেই ঠিক আছে বলে মনে হচ্ছে। (এখন, a[1]*এমনকি খাটো।)
Arnauld

1
আমি মরিয়া হয়ে এর জন্য একটি সূত্র ভাবার চেষ্টা করছিলাম has a node directly in line, আমি বুঝতে পারি নি যে এটি এত সহজ হবে ...
নিল

@ নীল এই পোস্টটির পুনর্বিবেচনার ইতিহাসটি দেখে আমি নিশ্চিত যে আপনি বলতে পারবেন যে আমি তাৎক্ষণিকভাবে বুঝতে পারি নি ... :)
আর্নাউল্ড

ভাবেন যে আপনি -1 ?a[-n]^=1:0দিয়ে প্রতিস্থাপন করতে পারেন &&a[-n]^=1, পরীক্ষা করতে পারবেন না (মোবাইলে)
স্টান স্ট্রাম

45

x86 32-বিট মেশিন কোড, 62 60 বাইট

Hexdump:

33 c0 60 8b f2 33 db 99 80 f9 02 72 2d ad 50 0f
ab c2 72 25 3b c3 77 01 93 2b c3 d1 e8 72 14 68
92 08 0e 02 0f a3 5c 04 ff 5f 73 07 03 d8 0f a3
da 73 06 5b e2 d7 61 40 c3 58 61 c3

এটি তালিকার দৈর্ঘ্য এবং এর মধ্যে ecxপ্রথম উপাদানটির একটি পয়েন্টার প্রাপ্ত করে edxএবং ফলাফলটি প্রদান করে al:

__declspec(naked) bool __fastcall check(int length, const int* list)

মাঝখানে একটি নোড রয়েছে এমন 8 টি লাইন রয়েছে:

1 - 3
4 - 6
7 - 9
1 - 7
2 - 8
3 - 9
1 - 9
3 - 7

বড় এবং ছোট সংখ্যার মধ্যে পার্থক্য অনুসারে আমি তাদের গ্রুপ করেছি।

পার্থক্য 2: 3 লাইন (1, 4 বা 7 থেকে শুরু)
    1 - 3
    4 - 6
    7 - 9
পার্থক্য 4: 1 লাইন (3 এ শুরু)
    3 - 7
পার্থক্য 6: 3 লাইন (1, 2 বা 3 থেকে শুরু)
    1 - 7
    2 - 8
    3 - 9
পার্থক্য 8: 1 লাইন (1 থেকে শুরু)
    1 - 9

তারপরে, আমি এটিকে অর্ধ-পার্থক্য এবং আরও ছোট সংখ্যার দ্বারা সূচিযুক্ত 2-ডি দেখার সারণীতে রূপান্তরিত করেছি:

76543210
--------
10010010 - half-difference 1
00001000 - half-difference 2
00001110 - half-difference 3
00000010 - half-difference 4

এটি 32 বিটের একটি "যাদু" বিটম্যাপ তৈরি করে। এটি সূচী করতে কোডটি স্ট্যাকের মধ্যে ধাক্কা দেয়। তারপরে, এটি একটি সূচক ব্যবহার করে একটি বাইট নিষ্কাশন করে এবং সেই বাইট থেকে এটি অন্য সূচকটি ব্যবহার করে কিছুটা বের করে। এই সমস্ত একটি নির্দেশ ব্যবহার করে:

bt byte ptr [esp + eax - 1], ebx; // -1 because half-difference is 1-based

যদি বিটম্যাপটি নির্দেশ করে যে মাঝখানে কোনও নোড রয়েছে তবে এটি গণনা করা সহজ - ছোট সংখ্যায় অর্ধেক পার্থক্য যুক্ত করুন।

সমাবেশ উত্স:

    xor eax, eax;   // prepare to return false
    pushad;         // save all registers
    mov esi, edx;   // esi = pointer to input list
    xor ebx, ebx;   // ebx = previously encountered number = 0
    cdq;            // edx = bitmap of visited numbers = 0

    cmp cl, 2;      // is input list too short?
    jb bad_no_pop;  // bad!

again:
    lodsd;          // read one number
    push eax;

    bts edx, eax;   // check and update the bitmap
    jc bad;         // same number twice? - bad!

    cmp eax, ebx;   // sort two recent numbers (ebx = minimum)
    ja skip1;
    xchg eax, ebx;
skip1:

    // Check whether the line crosses a node
    sub eax, ebx;   // calculate half the difference
    shr eax, 1;
    jc skip_cross;  // odd difference? - no node in the middle

    push 0x020e0892;// push magic bitmap onto stack
    bt byte ptr [esp + eax - 1], ebx; // is there a node in the middle?
    pop edi;
    jnc skip_cross; // no - skip the check

    add ebx, eax;   // calculate the node in the middle
    bt edx, ebx;    // was it visited?
    jnc bad;        // no - bad!

skip_cross:
    pop ebx;
    loop again;

    // The loop was finished normally - return true
    popad;          // restore registers
    inc eax;        // change 0 to 1
    ret;            // return

    // Return false
bad:
    pop eax;        // discard data on stack
bad_no_pop:
    popad;          // restore registers
    ret;            // return

নিস! আমি সত্যিই এটি পছন্দ bt byte ptr [esp + eax], ebx
আর্নল্ড

5
সমাবেশ সমাধান :) আপনি ব্যবহার করতে পারেন প্রতিবেদন করার সময় ঘটেছিলো cdqপরিবর্তে xor edx, edxযেমন eaxশূন্য। এছাড়াও, আপনি একই দৈর্ঘ্যের dec eaxমধ্যে ভাঁজ করতে পারেন bt [esp + eax - 1], ebxতবে তারপরে আপনাকে inc ebxপরে মুছে ফেলতে দেয় । এটি আপনার দুটি বাইট সংরক্ষণ করা উচিত।
জেস্টার

ধারণার জন্য ধন্যবাদ! গল্ফার স্বর্গে আপনি নিজের জায়গাটি সুরক্ষিত করে
রেখেছেন

5
আমি মনে করি যে আমরা সবাই একমত হতে পারি যে গল্ফার্সের স্বর্গ অন্য সবার জন্য নরক।
অ্যাডোনালসিয়াম

19

পাইথন 2 , 140 131 114 104 99 বাইট

-২ বাইট জোনাথন ফ্রেচকে
ধন্যবাদ -5 ব্যাস ধন্যবাদ চ্যাস ব্রাউনকে

v={0};k=input()
for l,n in zip(k,k[1:])or q:(2**n+~2**l)%21%15%9==5<v-{l+n>>1}==v>q;v|={l};n in v>q

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

ব্যাখ্যা:

# full program, raising a NameError for invalid input
v={0}            # set of visited nodes
k=input()        # load pattern
# iterate through adjacent pairs, if there is no pair, raise a NameError
for l,n in zip(k,k[1:])or q:
  # detect moves skipping over nodes, details below
  (2**n + ~2**l) % 21 % 15 % 9 == 5 < v - {l+n >> 1} == v > q
  v |= {l}       # add the last node to the set of visited nodes
  n in v > q     # if the current node was previously visited, raise a NameError

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

কেবল 8 জোড়া নোডের মাঝে একটি নোড থাকে। সূত্রের মাধ্যমে একজোড়া নোডকে একক পূর্ণসংখ্যার হিসাবে উপস্থাপন করা যেতে পারে 2^a-2^b-1। এই সংখ্যাটি বারবার মডুলোর দ্বারা সংক্ষিপ্ত করা যেতে পারে:

a  b  2^a-2^b-1  (2^a-2^b-1)%21%15%9
1  3         -7                    5
1  7       -127                    5
1  9       -511                    5
2  8       -253                    5
3  1          5                    5
3  7       -121                    5
3  9       -505                    5
4  6        -49                    5
6  4         47                    5
7  1        125                    5
7  3        119                    5
7  9       -385                    5
8  2        251                    5
9  1        509                    5
9  3        503                    5
9  7        383                    5

(2**n+~2**l)%21%15%9==5এইরকম জুটি উপস্থিত রয়েছে v-{l+n>>1}==vকিনা তা প্রথমে পরীক্ষা করে , তারপরে প্রদত্ত নোডটি (a+b)/2এখনও পরিদর্শন করা হয়নি এবং qএকটি নামেরর উত্থাপন করেছে কিনা তা পরীক্ষা করে । এই জোড়াগুলির মধ্যে শৃঙ্খলাবদ্ধ তুলনা ব্যবহার করে, পরবর্তী তুলনা কেবল তখনই কার্যকর করা হয় যখন পূর্ববর্তীটি ফিরে আসে True


17

জেলি ,  24 22 19  18 বাইট

-2 যেহেতু আমাদের আর খালি তালিকা হ্যান্ডেল করার দরকার নেই
-1 যোগদান থেকে স্যুইচিং j@, কনকানেটেট করার জন্য, ;(মিস করা আইটেমটি নিযুক্ত পদ্ধতিটির জন্য মাঝখানে মুখোমুখি হওয়ার দরকার নেই , ত্রয়ীর শুরুতে থাকা ভাল )
-2 থেকে সুইচিং P¬aSHকরতে oSHযেহেতু আমরা চেপ্টা (ঠিক আছে দুই ফলাফল আছে, অর্ধেক 1হয় 0.5যা বাইরে যাহাই হউক না কেন ফিল্টার করা হয়, এবং একাধিক সমান ফলাফল থাকার কোন পারেন পদ্ধতি নিযুক্ত প্রভাবিত করেছে)
-1 জনাব Xcoder ধন্যবাদ (0-ইন্ডেক্স ইনপুট অনুমোদিত)

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼

একটি মোনাডিক লিঙ্কটি পূর্ণসংখ্যার তালিকা গ্রহণ করে [0,8]এবং 1আইনী হলে সত্যবাদী মান ( ) এবং ফেরত 0না হলে মিথ্যা মান ( ) দেয়।

এটি অনলাইন চেষ্টা করুন! অথবা একটি পরীক্ষা-স্যুট দেখুন

কিভাবে?

ইনপুট তালিকার প্রতিটি 0-সূচিযুক্ত নোডের সংলগ্ন জোড়া দেখে। যদি দুটিগুলির মধ্যে তিনটির দ্বারা পূর্ণসংখ্যা বিভাগ 2 দ্বারা পৃথক হয় তবে তারা শীর্ষ এবং নীচে সারিগুলিতে থাকে, যদি দুটির মধ্যে তিনটি দ্বারা মডিউল দুটি পৃথক হয় তবে তারা বাম এবং ডান কলামে রয়েছে। দুটি দ্বারা বিভাজক হওয়া এই জাতীয় জোড়াগুলির যোগটি হয় তিন-নোড-লাইনের 0-সূচকযুক্ত মধ্য নোড বা একটি অ-পূর্ণসংখ্যার মান হয় - সুতরাং এই মানগুলি প্রথমে 0-সূচী জুটির সামনে সন্নিবেশ করা হয় এবং তারপরে যেকোনও বোগাস নোড (যেমন 0.5বা3.5) অপসারণ করা হয়, ফলাফলগুলির তালিকার তালিকাটি সমতল করে ডি-ডুপ্লিকেট করা হয় (অর্ডার-সংরক্ষিত, অনন্য এন্ট্রি প্রদান করতে) এবং শেষ পর্যন্ত ইনপুটটির সাথে তুলনা করা হয় - আইনী সোয়াইপের জন্য এগুলি সমস্ত অবৈধ থাকাকালীন শেষ হবে এগুলি মিড-নোডগুলি অনুপস্থিত যুক্ত করবে এবং / বা সদৃশ নোডগুলি মুছে ফেলবে (দ্রষ্টব্য যে কোনও দৈর্ঘ্যের ইনপুট তালিকার জন্য কোনও বিশেষ আবরণের প্রয়োজন নেই কারণ এর কোনও সংলগ্ন जोड নেই):

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼ - left input is a list of integers   e.g. [3,4,7,1,2,8,3]
          µƝ       - perform the chain to the left for adjacent pairs:
                   - e.g. for [a,b] in:   [3,4]         [4,7]         [7,1]         [1,2]         [2,8]         [8,3]
 d3                -   divmod by 3        [[1,0],[1,1]] [[1,1],[2,1]] [[2,1],[0,1]] [[0,1],[0,2]] [[0,2],[2,2]] [[2,2],[1,0]]
   Z               -   transpose          [[1,1],[0,1]] [[1,2],[1,1]] [[2,0],[1,1]] [[0,0],[1,2]] [[0,2],[2,2]] [[2,1],[2,0]]
    I              -   differences        [0,1]         [1,0]         [-2,0]        [0,1]         [2,0]         [-1,-2]
     Ị             -   abs(v)<=1          [1,1]         [1,1]         [0,1]         [1,1]         [0,1]         [1,0]
       S           -   sum (of [a,b])      7            11            8              3            10            11
      o            -   OR (vectorises)    [1,1]         [1,1]         [8,1]         [1,1]         [10,1]        [1,11]
        H          -   halve (vectorises) [0.5,0.5]     [0.5,0.5]     [4,0.5]       [0.5,0.5]     [5,0.5]       [0.5,5.5]
         ;         -   concatenate        [0.5,0.5,3,4] [0.5,0.5,4,7] [4,0.5,7,1]   [0.5,0.5,1,2] [5,0.5,2,8]   [0.5,5.5,8,3]
            F      - flatten              [0.5,0.5,3,4,  0.5,0.5,4,7,  4,0.5,7,1,    0.5,0.5,1,2,  5,0.5,2,8,    0.5,5.5,8,3]
                ¤  - nilad followed by link(s) as a nilad:
              9    -   literal nine
               Ḷ   -   lowered range = [0,1,2,3,4,5,6,7,8]
             f     - filter keep          [        3,4,          4,7,  4,    7,1,            1,2,  5,    2,8,         ,8,3]
                 Q  - deduplicate          [3,4,7,1,2,5,8]
                  ⁼ - equal to the input?  e.g. 0 (here because 5 was introduced AND because 3 was removed from the right)

পূর্ববর্তী পদ্ধতি

জেলি ,  36  35 বাইট

9s3;Z$;“Æ7a‘DZ¤;U$;©0m€2iị®oµƝFQ⁼ȧȦ

এটি অনলাইন চেষ্টা করুন! অথবা একটি পরীক্ষা-স্যুট দেখুন

কিভাবে?

উপরের মতই তবে তিনটি নোড-লাইন সম্ভাবনাগুলি তৈরি করে এবং চেহারাটি সম্পাদন করে (এটি পরীক্ষা করার জন্য ডিভোডম ব্যবহার করে পরীক্ষা করা এবং মিড-নোডের জন্য যোগফল অর্ধেক করার চেয়ে বরং পরীক্ষা করা) than

প্রথমত তিন নোড-লাইনগুলির তালিকা তৈরি করা:

9s3;Z$;“Æ7a‘DZ¤;U$;©0
9s3                   - nine (implicit range) split into threes = [[1,2,3],[4,5,6],[7,8,9]]
     $                - last two links as a monad:
    Z                 -   transpose = [[1,4,7],[2,5,8],[6,7,9]]
   ;                  -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9]]
              ¤       - nilad followed by link(s) as a nilad:
       “Æ7a‘          -   code-page index list = [13,55,97]
            D         -   decimal (vectorises) = [[1,3],[5,5],[9,7]]
             Z        -   transpose = [[1,5,9],[3,5,7]]
      ;               - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7]]
                 $    - last two links as a monad:
                U     -   upend = [[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
               ;      -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
                    0 - literal zero (to cater for non-matches in the main link since ị, index into, is 1-based and modular the 0th index is the rightmost)
                  ;   - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
                   ©  - copy the result to the register

এখন সিদ্ধান্ত গ্রহণ:

...m€2iị®oµƝFQ⁼ȧȦ - left input is a list of integers               e.g. [4,5,8,2,3,9,4]
          µƝ      - perform the chain to the left for adjacent pairs:
                  - i.e. for [a,b] in [[4,5],[5,8],[8,2],[2,3],[3,9],[9,4]]
...               -   perform the code described above = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
   m€2            -   modulo-2 slice €ach = [[1,3],[4,6],[3,9],[1,7],[2,8],[6,9],[1,9],[3,7],[3,1],[6,4],[9,7],[7,1],[8,2],[9,3],[9,1],[7,3],[0]]
      i           -   index of [a,b] in that (or 0 if not there)    e.g. [0,0,13,0,6,0]
        ®         -   recall from register = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
       ị          -   index into (1-based & modular)     e.g. [0,0,[8,5,2],0,[3,6,9],0]
         o        -   OR [a,b]           e.g. [[4,5],[5,8],[8,5,2],[2,3],[3,6,9],[9,4]]
            F     - flatten                          e.g. [4,5,5,8,8,5,2,2,3,3,6,9,9,4]
             Q    - deduplicate                                    e.g. [4,5,8,2,3,6,9]
              ⁼   - equal to the input?                            e.g. 0 (here because 6 was introduced AND because 4 was removed from the right)
                Ȧ - any and all? (0 if input is empty [or contains a falsey value when flattened - no such input], 1 otherwise)
               ȧ  - AND (to force an empty input to evaluate as 1 AND 0 = 0)

যখন ইউনিকোডের একগুচ্ছ অক্ষর রয়েছে তখন এটি 19 বাইটে কীভাবে আসে?
ইজকাটা

@ ইজকাটা জেলি তার নিজস্ব কোড-পৃষ্ঠা ব্যবহার করে, যা আপনি শিরোনামে "বাইটস" ক্লিক করে দেখতে পাবেন। এর কাঁচা বাইট-ফর্মটিতে ইউনিকোডের প্রতিটি অক্ষর আপনি সোর্স-কোডে দেখতে পাচ্ছেন কেবল একটি একক বাইট।
জোনাথন অ্যালান

15

স্ট্যাক্স , 28 বাইট

æ¡_t¿♂≥7▼├öä▒╨½╧£x╪╨┌i╒ë╖¢g•

চালাও এটা

এটি মিথ্যা জন্য 0 এবং সত্যের জন্য ধনাত্মক পূর্ণসংখ্যার উত্পাদন করে। একই প্রোগ্রামটির সংশ্লিষ্ট আসকি উপস্থাপনাটি এটি।

cu=x%v*x2BF1379E-%_|+YA=!*yhxi(#+*

সাধারণ ধারণাটি আইনী সোয়াইপ নিদর্শনগুলির জন্য বেশ কয়েকটি প্রয়োজনীয় শর্ত গণনা করা এবং সেগুলি একসাথে বহুগুণ করে।

cu=                                 First: no duplicates
   x%v*                             Second: length of input minus 1
       x2B                          Get all adjacent pairs  
          F                         For each pair, execute the rest
           1379E-%                  a) Any digits that are not 1, 3, 7, 9?
                  _|+Y              Get sum of pair, and store in Y register
                      A=!           b) Sum is not equal to 10?
                         *          c) multiply; logical and: a, b
                          yh        half of y; this will be equal to the
                                        number directly between the current
                                        pair if there is one
                            xi(#    d) has the middle number been observed yet?
                                +   e) plus; logical or: c, d
                                 *  multiply by the accumulated value so far

Yনিবন্ধের চালাক ব্যবহার ।
ওয়েইজুন চিউ

গিথুব নিয়ে আর একটি ইস্যু।
ওয়েজুন চাউ

1
আমি কাকতালীয়ভাবে ইতিমধ্যে এই বাগটি ঠিক করেছিলাম, কিন্তু এখন অবধি এটি স্থাপন করেছিলাম না। (এটা আমার প্রোগ্রাম প্রভাবিত করে না)
রিকার্সিভ

1
এটি অদ্ভুত লাগতে পারে তবে আপনি প্রথমটি বাদ দিতে পারেন vএবং 1মিথ্যা মান হিসাবে অন্তর্ভুক্ত করতে পারেন । 2এবং উপরে সত্যবাদী।
ওয়েজুন চাউ

10

জাভাস্ক্রিপ্ট, 112 বাইট

x=>/^(?!.*(.).*\1|[^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93))../.test(x)

সম্ভবত কিছু রেজেক্স ভিত্তিক ভাষা আরও খাটো হওয়া উচিত। তবে আমি জানি না।

নীলকে ধন্যবাদ, 3 বাইট সংরক্ষণ )(?!করতে পরিবর্তন করুন|


@ ওয়েইজুনঝৌ আমি 213-র জন্য সত্য হয়েছি, কী সমস্যা?
tsh

কিছুই ভুল নেই, এর জন্য দুঃখিত।
ওয়েইজুন চিউ

এখন থেকে ওপি স্পষ্ট করেছে, ব্যর্থ হয় 144
ওয়েইজুন ঝো

1
@ উইজুনঝু ঠিক করা উচিত; আরও 2 বাইট ...
tsh

আপনি যদি ভাবছিলেন, একটি রেটিনা 0.8.2 বন্দরটি 98 বাইটে কাজ করবে বলে মনে হচ্ছে।
নিল

6

রেটিনা 0.8.2 , 98 বাইট

টিএস এর উত্তরে প্রভাবিত । আমি এটির বিপরীত হতে "পুনরায় ব্যাখ্যা" করার চেষ্টা করেছি, অবৈধ সোয়াইপগুলির সাথে মিলেছে, তারপরে অ্যান্টি-গ্রেপিং।

A`(.).*\1|^([^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93)|.$)

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


6

হুশ , 25 20 বাইট

S=öufΛ¦1ΣẊ§Jzo½+em‰3

0-ভিত্তিক সূচক সহ পূর্ণসংখ্যার একটি তালিকা নেয়। 0 বা 1 ফেরত দেয় অনলাইনে চেষ্টা করুন!

ব্যাখ্যা

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

S=öufΛ¦1ΣẊ§Jzo½+em‰3  Implicit input, say [0,4,6,7,1]
                 m‰3  Divmod each by 3: L = [[0,0],[1,1],[2,0],[2,1],[0,1]]
         Ẋ§Jzo½+e     This part inserts the middle node between adjacent nodes.
         Ẋ            Do this for each adjacent pair, e.g. [1,1],[2,0]:
          §           Apply two functions and combine results with third.
            zo½+      First function:
            z         Zip with
               +      addition,
             o½       then halve: N = [3/2,1/2]
                e     Second function: pair: P = [[1,1],[2,0]]
           J          Combining function: join P with N: [[1,1],[3/2,1/2],[2,0]]
                      Result is a list of such triples.
        Σ             Concatenate: [[0,0],[1/2,1/2],[1,1],[1,1],[3/2,1/2],...,[0,1]]
    f                 Keep only those pairs
     Λ                both of whose elements
      ¦1              are divisible by 1, i.e. are integers: [[0,0],[1,1],[1,1],,...,[0,1]]
   u                  Remove duplicates: [[0,0],[1,1],[2,0],[2,1],[0,1]]
S=ö                   Is the result equal to L? Implicitly print 1 or 0.

3

সি ++, 267 256 বাইট

#define R)return 0
#define H(a,q)if(d==q&&n==a&&!m[a]R;
int v(int s[],int l){if(l<2 R;int m[10]{},i=1,p=s[0],d,n;for(;i<l;++i){m[p]=1;if(m[s[i]]R;d=(d=p-s[i])<0?-d:d;if(d%2<1){n=(p+s[i])/2;H(5,4)H(5,8)H(2,2)H(5,2)H(8,2)H(4,6)H(5,6)H(6,6)}p=s[i];}return 1;}

প্যাটার্নটি অপ্রত্যাশিত নোডটি এড়িয়ে যায় না তা পরীক্ষা করতে এটি বেশ কয়েকটি কাজ করে:

  1. বর্তমান নোড এবং শেষ নোডের মধ্যে সাংখ্যিক পার্থক্য dকোথায় গণনা করুন d
  2. যদি dবিজোড় হয় তবে চেক করার দরকার নেই, এটি কোনও নোড ছাড়তে পারে না।
  3. যদি dসমান 4বা 8, তারপর লাফ নোড মধ্যে 1-9বা 3-7, তাই নোড পরীক্ষা5
  4. যদি d2 হয়, এবং মাঝারি নোডটি (last_node + current_node)/2হয় 2,5 বা 8 হয় তবে মধ্য নোডটি পরীক্ষা করুন
  5. যদি d6 হয় তবে আগের মতো একই চেক বা সাথে 4, 5বা6

পরামিতিগুলি একটি int[]এবং এটির উপাদান গণনা। এটি এমন একটি প্রত্যাবর্তন করে intযা boolপ্রকারভেদ হিসাবে ব্যাখ্যা করা যায়


!(d%2)=> d%2<1কাজ করা উচিত।
জাকারি


আমি একটি নতুন কৌশল শিখেছি: int s[]=> int*s। আমি মনে করি এটি কাজ করবে।
জাকারি

2

পার্ল, 135 বাইট (134 + -n)

@a{split//}=1;(@{[/./g]}==keys%a&&/../)||die();for$c(qw/132 465 798 174 285 396 195 375/){$c=~/(.)(.)(.)/;/^[^$3]*($1$2|$2$1)/&&die()}

কিছুটা অবারিত সংস্করণ

@a{split//} = 1;
(@{[/./g]} == keys %a && /../) || die();
for $c (qw/132 465 798 174 285 396 195 375/) {
  $c=~/(.)(.)(.)/;
  /^[^$3]*($1$2|$2$1)/&&die()
}

প্রস্থান কোড মাধ্যমে আউটপুট। 0সত্য, অন্য যে কোনও মান মিথ্যা। মেটা sensকমত্য হিসাবে , ব্যর্থতার ক্ষেত্রে এসটিডিআরআর আউটপুট উপেক্ষা করা হবে।

সমস্ত সম্ভাবনার তালিকা তৈরির চেয়ে নিয়মটি "ওপারে ঝাঁপিয়ে উঠতে পারে না" চেক করার সম্ভবত আরও দ্রুত উপায় আছে।


2

এমএটিএল , 42 41 39 বাইট

9:IeXKi"Ky@=&fJ*+XK+y&fJ*+Em~zw0@(]z8<v

এটি উত্পাদন করে

  • সত্য- আউটপুট হিসাবে শূন্য-শূন্য সংখ্যাযুক্ত একটি খালি-খালি কলাম ভেক্টর ; অথবা
  • মিথ্যা হিসাবে কমপক্ষে শূন্যযুক্ত একটি খালি খালি কলাম ভেক্টর ।

এই আউটপুটগুলি যথাক্রমে সত্য এবং মিথ্যা কেন তা এখানে আপনি পড়তে পারেন। এটি অনলাইন চেষ্টা করুন!

অথবা পাদলেখের কোড সহ সমস্ত পরীক্ষার কেস যাচাই করুন যাতে সত্যতা / মিথ্যাচারের জন্য মানক পরীক্ষা অন্তর্ভুক্ত থাকে।


2

স্ট্যাক্স , 73 72 66 65 বাইট সিপি 437

ÉWyƒ▬ºJOTƒw-H┌↓&ⁿç↨¼<ü6π║¢S○j⌂zXΣE7≈╩╕╤ö±÷C6▒☼■iP-↑⌐¥]╩q|+zΦ4Φ·¥Ω

আনপ্যাক করা হলে by৯ বাইট,

d4{cAs-5F132396978714EEL3/{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEx%2<xu%x%=!L|+

চালান এবং অনলাইন ডিবাগ!

বা ব্যাচ পরীক্ষা চালান , যেখানে meXশিরোনাম যাতে স্ট্যাক্স মাল্টলাইন ইনপুট প্রক্রিয়া করতে পারে।

Hash.Outputs জন্য কঠোরভাবে ধনাত্মক সংখ্যা (আসলে ব্যর্থ পরীক্ষার নম্বর) ব্যবহার না করে বাস্তবায়ন falsy ক্ষেত্রে এবং 0জন্য truthy বেশী।

ব্যাখ্যা

dইনপুট স্ট্যাক সাফ করে। ইনপুটটি xযাইহোক পরিবর্তনশীল ।

4{cAs-5F মধ্য নোড তালিকার প্রথম অংশ তৈরি করে।

132396978714EE মাঝের নোড তালিকার দ্বিতীয় অংশ হার্ডকোডগুলি।

L3/প্রধান স্ট্যাকের সমস্ত উপাদান সংগ্রহ করে এবং 3 টি উপাদান যুক্ত প্রতিটি অংশে বিভক্ত করে, ফলাফলটি অ্যারে হয় aযা সমস্ত অবৈধ 3-নোড গোষ্ঠীর অ্যারে মাত্র।

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEপ্রতিটি অবৈধ নোড তালিকার জন্য, নিম্নলিখিত চেকগুলি সম্পাদন করুন। পরীক্ষার ফলাফলগুলি andব্যবহার করে এড করা হয় **। যেহেতু 8 টি অবৈধ নোডের তালিকা রয়েছে তাই এই কোডের ফলাফল 8 টি উপাদানের অ্যারে হবে ray চূড়ান্ত Eমূল স্ট্যাকের অ্যারেটিকে পৃথক উপাদানগুলিতে প্রেরণ করে।

xs:I ইনপুট অ্যারে নোড তালিকার উপাদানগুলির সূচক পান।

Bc0<A*++যদি "মিডল নোড" এর সূচক (যেমন 5নোড সেটে 1,5,9) হয় -1(যার অর্থ এটি ইনপুট অ্যারেতে নেই) তবে সূচকটি এতে পরিবর্তন করুন 9

cEd:-1=দুটি "টার্মিনাল নোড" (যেমন 1,5নোড সেটে 1,5,9) ইনপুট অ্যারেতে সংলগ্ন কিনা তা পরীক্ষা করুন।

sccHs|M= "মধ্য নোড" এর রূপান্তরিত সূচক দুটি "টার্মিনাল নোড" এর চেয়ে বড় কিনা তা পরীক্ষা করুন: "মিডল নোড" অনুপস্থিত, অথবা "মধ্য নোড" দুটি "টার্মিনাল নোড" পরে আসবে

s{U>m|A"শেষ নোডগুলির" উভয় সূচকেই ননজেটিভ কিনা তা পরীক্ষা করে। (অর্থাত্ তারা উভয়ই ইনপুটটিতে উপস্থিত হয়)।

দুটি অতিরিক্ত পরীক্ষা করা হয়,

x%2< ইনপুট অ্যারেটি সিঙ্গলটন কিনা তা পরীক্ষা করে।

xu%x%=! নোড যা দুবার পরিদর্শন করা হয়েছে তা পরীক্ষা করে।

প্রধান স্ট্যাকের জন্য 10 টি পরীক্ষার ফলাফল রয়েছে (অবৈধ নোড তালিকার প্রতিটিটির জন্য একটি, আরও দুটি অতিরিক্ত পরীক্ষার)।

L|+10 টি উপাদান সংগ্রহ করে সেগুলি যুক্ত করে। |aঅ্যারেতে কোন সত্যবাদী উপাদান রয়েছে কিনা তা যাচাই করে তা যাচাই করে তাও ব্যবহার করা যেতে পারে।

অন্তর্নির্মিত আউটপুট।


2

জাভা, 375 355 বাইট

-20 বাইট জ্যাকারিকে ধন্যবাদ ý

int v(int s[]){int[]m=new int[10];int i=1,p=s[0],d,n,l=s.length;if(l<2)return 0;for(;i<l;++i){m[p]=1;if(m[s[i]]!=0)return 0;d=(d=p-s[i])<0?-d:d;if(d%2==0){n=(p+s[i])/2;if((d==4||d==8)&&n==5&&m[5]==0)return 0;if(d==2&&(n==2&&m[2]==0||n==5&&m[5]==0||n==8&&m[8]==0))return 0;if(d==6&&(n==4&&m[4]==0||n==5&&m[5]==0||n==6&&m[6]==0))return 0;}p=s[i];}return 1;}

এটি এই উত্তরের একটি বন্দর এবং এটি একই নীতিগুলিতে কাজ করে


ওহো। আপনি জাভাতে চিন্তিত হচ্ছেন।
জাকারিয়া

int v(int s[]){int[]m=new int[10];int i=1,p=s[0],d,n,l=s.length;if(l<2)return 0;for(;i<l;++i){m[p]=1;if(m[s[i]]!=0)return 0;d=(d=p-s[i])<0?-d:d;if(d%2==0){n=(p+s[i])/2;if((d==4||d==8)&&n==5&&m[5]==0)return 0;if((d==2)&&(n==2&&m[2]==0||n==5&&m[5]==0||n==8&&m[8]==0))return 0;if(d==6&&(n==4&&m[4]==0||n==5&&m[5]==0||n==6&&m[6]==0))return 0;}p=s[i];}return 1;}কাজ করা উচিত (ক্রমের ক্রম)
জ্যাচার

আপনি ন্যায়বিচারে পরিবর্তন (d==2)করতে পারেন d==2, আমি এটি আগে উপেক্ষা করেছি।
জাকারি

d%2==0=>d%2<1
জাচারা

0

পাইথ , 33 বাইট

q{@U9.nm+mc|g1aZksd2-MC.DR3d_dC,t

পরীক্ষা স্যুট.

0-ভিত্তিক সূচক ব্যবহার করে।

ব্যাখ্যা

q {@ U9.nm + mc | g1aZksd2-MC.DR3d_dC, t -> সম্পূর্ণ প্রোগ্রাম। ইনপুট: এসটিডিআইএন থেকে একটি তালিকা এল।

                               , t -> এল এল দিয়ে প্রথম উপাদানটি ছাড়াই জোড় করুন।
                              সি -> ট্রান্সপোজ।
       মি -> জোড়ার তালিকার উপরে মানচিত্র (২-উপাদানগুলির তালিকা):
        + এমসি | g1aZksd2-MC.DR3d -> ম্যাপ করা ফাংশন (পরিবর্তনশীল: ডি):
                         আর ডি -> ডি প্রতিটি উপাদানের জন্য ...
                       .ডি 3 -> ... 3 এর দ্বারা ডিভোড নিন
                      সি -> ট্রান্সপোজ।
                    -এম -> বিয়োগ দ্বারা প্রতিটি হ্রাস করুন।
         মি -> প্রতিটি পার্থক্যের জন্য (পরিবর্তনশীল: কে):
            g1aZl -> ইস | কে | ≤ 1?
           | sd -> যদি এটি মিথ্যা হয়, তবে এটি ডি এর যোগফল দ্বারা প্রতিস্থাপন করুন।
          সি 2 -> 2 দ্বারা ভাগ করুন।
        + _d -> ম্যাপিংয়ের ফলাফলের জন্য ডি এর বিপরীত যুক্ত করুন।
     .n -> সমতল।
  @ U9 -> (ℤ ∩ [0; 9)) সাথে চৌরাস্তাটি ধরুন।
 {-> নকল ate
q -> এবং ফলাফলটি এল এর সমান কিনা তা পরীক্ষা করে দেখুন

34 বাইট জন্য বিকল্প পদ্ধতি :

q{sI#I#+Fm+,hdcR2+MCd]edCtBK.DR3QK

0

জাপট , 35 বাইট

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

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

কিছুটা নাড়িত এবং কীভাবে এটি কাজ করে

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

Implicit beginning U(input) and some arbitrary sequence conversions

UeUä@[(Xu3 aYu3)==1||X+Y ÷2XY]} c f9o)â

  Uä             Convert the input array into length-2 subsections and map...
    @[ ... ]}      function of X,Y which returns an array of...
      Xu3 aYu3==1||X+Y ÷2          (abs(X%3 - Y%3)==1||X+Y)/2,
                         XY        X, Y
  c              Flatten the result of mapping
    f9o          Intersect with range(9)
        â        Take unique elements, preserving order
Ue             Is the result the same as original array?

সম্ভাব্য জাম্প নির্ধারণে কিছুটা পার্থক্য সহ এই জেলি সমাধান থেকে ধারণাটি পোর্ট করা হয়েছে :

  • জেলি উত্তর divmod ব্যবহার করে একজোড়া 2 পার্থক্য যখন প্রয়োগ করেছে দেখতে /3বা %3
  • এই উত্তরটি কেবলমাত্র ব্যবহার করে %3এবং পার্থক্য 0 বা 2 হয় কিনা তা পরীক্ষা করে দেখায় যদি পার্থক্য 0 হয় তবে দুটি ঘরটি উল্লম্বভাবে প্রান্তিক হয় এবং নন-জাম্পগুলি এখনও এর সম্পত্তি ভাগ করে দেয় (X+Y)%2 != 0

0

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

Ovs এর উত্তরের ভিত্তিতে তবে 2 বাইট সংক্ষিপ্ত এবং কম ক্রিপ্টিক। কেবল সূচকগুলিকে 2 ডি স্থানাঙ্কে এবং পরীক্ষার সমতায় রূপান্তর করে। অনুমান 0-8 সূচক।

v={9}
s=input()
for n,l in zip(s[1:]or q,s):n/3+l/3&1|n%3+l%3&1or n+l>>1in v or q;v|={l};n in v>q

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

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.