මගේ ස්වයිප් රටාව නීත්‍යානුකූලද?


157

බොහෝ ඇන්ඩ්‍රොයිඩ් ස්මාර්ට්ෆෝන් පරිශීලකයාට තම දුරකථනය විවෘත කිරීමට ස්වයිප් රටාවක් භාවිතා කිරීමට ඉඩ දෙයි:

රටා අගුල

සමහර රටා නීත්‍යානුකූල වන අතර අනෙක් ඒවා කළ නොහැකි ය. ආදාන ස්වයිප් රටාවක් ලබා දී, දී ඇති ආදාන රටාව නීත්‍යානුකූලද නැද්ද යන්න දක්වමින් සත්‍ය හෝ ව්‍යාජ ලෙස ආපසු එවන්න.

ආදානය

ජාලකය පේළි අනුව 1 සිට 9 දක්වා ලේබල් කර ඇත:

1 2 3   
4 5 6   
7 8 9

ආදානය යනු පළමු සිට අන්තිම දක්වා පිවිසෙන නෝඩ් වලින් සමන්විත අංකයකි. උදාහරණයක් ලෙස, ඉහත ස්වයිප් රටාව 12357 වේ.

ආදානය දශම සංඛ්‍යාවක්, නූලක් හෝ සංඛ්‍යා ලැයිස්තුවක් විය හැකිය. නෝඩ් 0 නොමැති නිසා එය 0 අඩංගු නොවේ.

සංශෝධනය: බොහෝ භාෂා දර්ශක 0 සිට 0-8 දක්වා සුචිගත කිරීමට අවසර ඇත. ඔබ 0-8 භාවිතා කරන්නේ නම්, ඔබේ පිළිතුර ආරම්භයේ දී සඳහන් කර පරීක්ෂණ අවස්ථා ඒ අනුව සකස් කිරීම අවශ්‍ය වේ.

නීති

  • සෑම නෝඩයක්ම මුලින් නොදුටු ලෙස ආරම්භ වන අතර එය නැරඹිය හැක්කේ එක් වරක් පමණි. එක් වරකට වඩා නෝඩයකට පිවිසෙන ඕනෑම රටාවක් ව්‍යාජ ය.

  • සත්‍ය රටාවකට අවම වශයෙන් එක් ස්වයිප් එකක්වත් තිබිය යුතුය, එබැවින් අවම වශයෙන් නෝඩ් 2 ක් තිබිය යුතුය.

  • අනපේක්ෂිත නෝඩයක් වෙනත් එකක් සමඟ කෙලින්ම මඟ හැරිය නොහැක. නිදසුනක් ලෙස, 13 ව්‍යාජ ය, මන්ද යත් 2 නොපෙනෙන හා කෙලින්ම පෙළ ගැසී ඇති බැවිනි.

  • කළ හැකි වන්නේ සංචාරය කළ නෝඩයක් මඟ හැරීම පමණි. 42631 මේ සඳහා උදාහරණයකි.

  • රේඛා වෙනත් ආකාරයකින් තරණය කළ හැකිය. උදාහරණයක් ලෙස, 1524 සත්‍ය වේ.

  • නෝඩ් පළල වැදගත් නොවන බව උපකල්පනය කර ප්‍රායෝගික ගැටළු නොසලකා හරින්න (ඇඟිලි thickness ණකම ආදිය). එබැවින් යථාර්ථය සාක්ෂාත් කර ගැනීම තරමක් අපහසු වුවද 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

මෙය , එබැවින් බයිට් ගණන අඩුම වේ.




ආදාන ලැයිස්තුව නිදහස් නොවන බවට සහතික වී තිබේද?
සාගර්බ්

@Zgarb ඔව්. එය නොසන්සුන් වනු ඇත.
ස්ටැන්රි

අදාළ ගණිත ප්‍රශ්නය: math.stackexchange.com/questions/205049/…
Pureferret

Answers:


69

JavaScript (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
  )

පෙර ඉලක්කම් නිරීක්ෂණය කිරීම

නරඹන ඉලක්කම් සඳහා වන ධජ ආදාන අරා a හි negative ණ දර්ශකවල ගබඩා කර ඇති අතර එමඟින් එහි මුල් මූලද්‍රව්‍ය සමඟ ගැටෙන්නේ නැත.

  • P -n ලෙස සකසා ඇත්නම් :

    වත්මන් ඉලක්කම් n මීට පෙර තෝරා නොගත්තේ නම්, a[-n] ^= -nධජය සකසා every()ඊළඟ පුනරාවර්තනය සමඟ ලූපය ඉදිරියට ගෙන යනු ඇත. එසේ නොමැති නම්, එය ධජය ඉවත් කර ලූපය වහාම අසමත් වීමට බල කරයි.

  • නම් p කිරීමට පියවර ගෙන තිබේ නිර්වචනය නොකළ :

    a[undefined] ^= undefinedප්‍රති results ල 0 වන අතර එමඟින් ලූපය අසමත් වීමට බල කරයි.

ප්‍රතිවිරුද්ධ ඉලක්කම් හඳුනා ගැනීම

පූර්විකාවෙහි අර්ථ දක්වා ඇති පරිදි වත්මන් ඉලක්කම් n සහ පෙර ඉලක්කම් -p ප්‍රතිවිරුද්ධ ඉලක්කම් දැයි පරීක්ෂා කිරීමට පහත ප්‍රකාශනය භාවිතා කරයි :

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

එය සමාන වේ:

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

සටහන: JS හි, මොඩියුලයේ ප්‍රති result ලය ලාභාංශයට සමාන ලකුණක් ඇත.

එය මෙසේ අර්ථ දැක්විය හැකිය:

(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] සත්‍යයක් බවට සහතික වන කරමු.

පළමු පුනරාවර්තනය ගැන

පළමු පුනරාවර්තනය විශේෂ අවස්ථාවකි, එහි පෙර ඉලක්කම් නොමැති අතර එය කොන්දේසි විරහිතව සාර්ථක වීමට අපට අවශ්‍යය.

අපි එය සාක්ෂාත් කරගන්නේ p සිට 1 දක්වා ආරම්භ කිරීමෙන් , [1 .. 9] හි ඕනෑම n සඳහා :

  • (1 * n) % 5 .ණ විය නොහැක
  • ~(1 - n) 9 ට සමාන විය නොහැක

මුල් පිළිතුර, බයිට් 90 යි

මෙම තනතුරෙන් ඉවත් කර ඇති අතර එමඟින් එය වාචිකව නොගැලපේ. ඔබට එය මෙහි දැකිය හැකිය .


-1 වෙනුවට බයිට !!a[1]&සමග a[1]&&කිසිදු truthy අගය ආපසු ලබා දිය හැකි බැවින්,
හර්මන් පෙළ

@ හර්මන් ලෝන්ස්ටයින් ස්තූතියි, එය ඇත්තෙන්ම හොඳයි. (දැන්, a[1]*ඊටත් වඩා කෙටි ය.)
ආර්නෝල්ඩ්

1
මම සූත්‍රයක් ගැන සිතීමට මංමුලා සහගතව උත්සාහ has a node directly in lineකළෙමි, එය එතරම් සරල වනු ඇතැයි මම නොදනිමි ...
නීල්

E නීල් මෙම ලිපියේ සංශෝධන ඉතිහාසය දෙස බැලීමෙන් මට විශ්වාසයි, මම එය වහාම තේරුම් නොගත් බව ඔබට පැවසිය හැකිය ... :)
ආර්නෝල්ඩ්

ඔබ වෙනුවට පුළුවන් කියලා ?a[-n]^=1:0සමග &&a[-n]^=1-1 සඳහා හැකි පරීක්ෂණ (ජංගම දුරකථනය) නොඑසේ නම්, ඒ
Stan Strum

46

x86 32-බිට් මැෂින් කේතය, බයිට් 62 60

හෙක්ස්ඩම්ප්:

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සහ පළමු මූලද්‍රව්‍යයට දර්ශකයක් ලබා ගන්නා අතර ප්‍රති edxresult ලය ලබා දෙන්නේ 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-D බැලීමේ වගුවකට පරිවර්තනය කළෙමි:

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පසුව. මෙය ඔබට බයිට් දෙකක් ඉතිරි කළ යුතුය.
ජෙස්ටර්

අදහස් වලට ස්තූතියි! ගොල්ෆ් ක්‍රීඩකයාගේ පාරාදීසයේ ඔබ ස්ථානයක් ලබාගෙන තිබේ නම්, එකක් තිබේ නම් :)
anatolyg

5
ගොල්ෆ් ක්‍රීඩකයින්ගේ පාරාදීසය අනෙක් සියල්ලන්ට නිරයක් බව අප සැමට එකඟ විය හැකි යැයි මම සිතමි.
මොනිකා ක්ෂමාලාපකයින්

20

පයිතන් 2 , 140 131 114 104 99 බයිට්

-2 බයිට් ජොනතන් ෆ්‍රෙච්
-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.


18

ජෙලි ,  24 22 19 18  17 බයිට්

-2 අපට තවදුරටත් හිස් ලැයිස්තුවක් හැසිරවීමට අවශ්‍ය නොවන බැවින්
-1 සම්බන්ධ වීමෙන්, සංක්ෂිප්තව මාරුවීම j@, ;(මඟ හැරුණු අයිතමය භාවිතා කරන ක්‍රමවේදය සඳහා මැදට පැමිණීමට අවශ්‍ය නොවේ , තිදෙනා ආරම්භයේදීම සිටීම හොඳයි )
-2 සිට මාරු P¬aSHකිරීමට oSH(අපි නැතත් සිට ප්රතිඵල දෙකක් ඇති හරි, හරි අඩක් 1එනම් 0.5කෙසේ හෝ අතරින් ප්රේරණය වන, හා බහු සමාන ප්රතිඵල සහිත කිසිදු එක්කෝ යොදාගත් ක්රමය මත බලපාන කර ඇත)
-1 Xcoder මහතා ස්තුති (0-සුචිගත ආදානය සඳහා අවසර ඇත)
-1 (නව) විචල්‍යතාව ඉක්මන් Ƒ, සහ පෙරහන්-ක්ෂණික අන්වර්ථය භාවිතා කරමින් Ƈ.

d3ZIỊoSH;µƝFḞƑƇQ⁼

මොනාඩික් සබැඳියක් පූර්ණ සංඛ්‍යා ලැයිස්තුවක් [0,8]ගෙන සත්‍ය වටිනාකමක් ( 1) නීත්‍යානුකූල නම් සහ වැරදි අගයක් ( 0) නොමැති නම් ආපසු ලබා දේ.

එය මාර්ගගතව උත්සාහ කරන්න! හෝ පරීක්ෂණ කට්ටලයක් බලන්න .

කොහොමද?

ආදාන ලැයිස්තුවේ එක් එක් යාබද යුගල 0 දර්ශක නෝඩ් දෙස බලයි. නිඛිල සංඛ්‍යා දෙකෙන් තුනකින් 2 කින් වෙනස් වුවහොත් ඒවා ඉහළ සහ පහළ පේළි වල වේ, මොඩියුලය දෙකෙන් තුනකින් 2 කින් වෙනස් වේ නම් ඒවා වම් සහ දකුණු තීරුවල වේ. එවැනි යුගලවල එකතුව දෙකකින් බෙදූ විට ත්‍රි-නෝඩ් රේඛාවක 0-සුචිගත කළ මැද-නෝඩ් හෝ පූර්ණ සංඛ්‍යා නොවන අගයක් වේ - එබැවින් මෙම අගයන් පළමුව 0-සුචිගත කරන ලද යුගලයට ඉදිරියෙන් ඇතුළු කරනු ලැබේ. ව්‍යාජ නෝඩ් (වැනි0.5 හෝ3.5. ඒවා අතුරුදහන් වූ මැද නෝඩ් එකතු කරන අතර / හෝ අනුපිටපත් ඉවත් කරයි (යාබද යුගල නොමැති බැවින් දිග 1 ආදාන ලැයිස්තුවක් සඳහා විශේෂ ආවරණයක් අවශ්‍ය නොවන බව සලකන්න):

d3ZIỊoSH;µƝFḞƑƇ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]
              Ƈ   - keep those for which:
             Ƒ    -   is invariant under?:
            Ḟ     -     floor            [        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⁼ȧȦ

එය මාර්ගගතව උත්සාහ කරන්න! හෝ පරීක්ෂණ කට්ටලයක් බලන්න .

කොහොමද?

ඉහත කරුණුවලට සමාන නමුත් ත්‍රි-නෝඩ්-රේඛා හැකියාවන් ගොඩනඟා බැලීමේ ක්‍රියාවලිය සිදු කරයි (එය ඩිව්මෝඩ් භාවිතා කර පරීක්ෂා කිරීම වෙනුවට මැද නෝඩ් සඳහා වන මුදල අඩකින් අඩක් කිරීම).

පළමුව ත්‍රි-නෝඩ් රේඛා ලැයිස්තුව ඉදිකිරීම:

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 කට එළියට එන්නේ කෙසේද?
ඉස්කාටා

Z ඉස්කාටා ජෙලි තමන්ගේම කේත පිටුවක් භාවිතා කරයි, එය ඔබට ශීර්ෂයේ ඇති “බයිට්” ක්ලික් කිරීමෙන් දැකිය හැකිය. එහි අමු බයිට් ස්වරූපයෙන් ඔබට ප්‍රභව කේතයේ දැකිය හැකි එක් එක් යුනිකෝඩ් අක්ෂර තනි බයිට් එකක් පමණි.
ජොනතන් ඇලන්

16

ස්ටැක්ස් , බයිට් 28 යි

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

එය ක්රියාත්මක කරන්න

එය අසත්‍ය සඳහා 0 ද සත්‍ය සඳහා ධනාත්මක නිඛිල ද නිපදවයි. එකම වැඩසටහනේ අනුරූප ascii නිරූපණය මෙයයි.

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ඉහත සත්‍යවාදී ය.
වයිජුන් ෂෝ

11

ජාවාස්ක්‍රිප්ට්, බයිට් 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 ක් ඉතිරි )(?!කිරීමට වෙනස් කරන්න |.


E වයිජුන්ෂෝ මම 213 සඳහා සත්‍ය බවට පත්විය, වැරැද්ද කුමක්ද?
tsh

කිසිවක් වැරදියි, ඒ ගැන කණගාටුයි.
වයිජුන් ෂෝ

OP පැහැදිලි කළ දා සිට දැන් අසමත් වේ 144.
වයිජුන් ෂෝ

1
E වයිජුන් ෂෝ සවි කළ යුතුය; තවත් බයිට් 2 ක් ...
tsh

ඔබ කල්පනා කරනවා නම්, රෙටිනා 0.8.2 වරාය බයිට් 98 කින් ක්‍රියා කරන බව පෙනේ.
නීල්

7

රෙටිනා 0.8.2 , බයිට් 98 යි

Tsh ගේ පිළිතුරෙන් බලපෑම් ඇති කරයි . මම එය ප්‍රතිවිරුද්ධ, ගැලපෙන අවලංගු ස්වයිප්, පසුව ප්‍රති-ග්‍රහණය කිරීමට උත්සාහ කළෙමි.

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

එය මාර්ගගතව උත්සාහ කරන්න


7

ලෙල්ල , බයිට් 25 20

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

0 මත පදනම් වූ සුචිගත කිරීම් සමඟ පූර්ණ සංඛ්‍යා ලැයිස්තුවක් ගනී. 0 හෝ 1 ලබා දෙයි. එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

මම ජොනතන් ඇලන්ගේ ජෙලි පිළිතුරෙන් අදහස් කිහිපයක් සොරකම් කළෙමි . අදහස එක හා සමානයි: එක් එක් යාබද යුගල අතර නව "සාමාන්‍ය නෝඩයක්" ඇතුළු කරන්න, සත්‍ය නෝඩ් නොවන ඒවා පෙරහන් කරන්න, අනුපිටපත් ඉවත් කර මුල් ලැයිස්තුවට සංසන්දනය කරන්න. මුල් ලැයිස්තුවේ අනුපිටපත් තිබේ නම්, ප්‍රති result ලය ව්‍යාජ ය. ලැයිස්තුව අනපේක්ෂිත නෝඩයක් මඟ හැරියහොත්, එය අනුරූප යුගල අතර සැකසූ ලැයිස්තුවේ ඇති අතර ප්‍රති result ලය ව්‍යාජ ය. ආදානය සිංගල්ටන් එකක් නම්, සැකසූ ලැයිස්තුව හිස් වන අතර ප්‍රති result ලය ව්‍යාජ ය. එසේ නොමැති නම් එය සත්‍යයකි.

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.

4

සී ++, බයිට් 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, ඒ නිසා node එකක් මතම ඊට අදාල පරීක්ෂා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. මම හිතන්නේ ඒක වැඩ කරයි.
සැකරා

3

පර්ල්, බයිට් 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සත්‍යය, වෙනත් ඕනෑම වටිනාකමක් ව්‍යාජ ය. අනුව මෙටා සම්මුතියක් , අසාර්ථක නඩුවේ STDERR ප්රතිදානය ඉවත් වේ.

සියලු හැකියාවන් ලැයිස්තුගත කරනවාට වඩා “පනින්න බැහැ” යන රීතිය පරීක්ෂා කිරීමට ඉක්මන් ක්‍රමයක් තිබේ.


3

MATL , බයිට් 42 41 39

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

මෙය නිපදවයි

  • සත්‍ය නොවන නිමැවුම් ලෙස ශුන්‍ය නොවන සංඛ්‍යා පමණක් අඩංගු හිස් නොවන තීරු දෛශිකයක් ; හෝ
  • හිස් නොවන තීරු දෛශිකයක් අවම වශයෙන් ශුන්‍යයක් ව්‍යාජ ලෙස අඩංගු වේ.

මෙම ප්‍රතිදානයන් පිළිවෙලින් සත්‍ය සහ ව්‍යාජ වන්නේ මන්දැයි මෙහිදී ඔබට කියවිය හැකිය. එය මාර්ගගතව උත්සාහ කරන්න!

නැතහොත් සත්‍යතාව / ව්‍යාජත්වය සඳහා සම්මත පරීක්ෂණය ඇතුළත් පාදක කේතය සමඟ සියලු පරීක්ෂණ අවස්ථා සත්‍යාපනය කරන්න .


3

ස්ටැක්ස් , 73 72 66 65 බයිට් CP437

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

අසුරන විට බයිට් 79 ක්,

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 මැද-නෝඩ් ලැයිස්තුවේ දෙවන කොටස දෘ c කේත.

L3/ ප්‍රධාන කොටස්වල ඇති සියලුම අංග එකතු කර මූලද්‍රව්‍ය 3 ක් අඩංගු කොටස් වලට බෙදන්න, ප්‍රති result ලය අරාවයි a ප්‍රති , එය සියලු අවලංගු 3-නෝඩ් කණ්ඩායම්වල අරාව පමණි.

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEසෑම අවලංගු නෝඩ් ලැයිස්තුවක් සඳහා, පහත චෙක්පත් සිදු කරන්න. චෙක්පත් ප්‍රති results andලවල ප්‍රති result ලය සංස්කරණය කර ඇත** . අවලංගු නෝඩ් ලැයිස්තු 8 ක් ඇති බැවින්, මෙම කේතයේ ප්‍රති result ලය මූලද්‍රව්‍ය 8 කින් සමන්විත වේ. අවසාන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%=! දෙවරක් සංචාරය කර ඇති නෝඩ් දැයි පරීක්ෂා කරයි.

ප්‍රධාන තොගයේ පරීක්ෂණ ප්‍රති result ල 10 ක් ඇත (එක් එක් අවලංගු නෝඩ් ලැයිස්තුවට එකක් සහ අතිරේක පරීක්ෂණ දෙකක්).

L|+ මූලද්රව්ය 10 එකතු කර ඒවා එකතු කරයි. |aඅරාවෙහි සත්‍යවාදී අංග තිබේද යන්න සරලව පරික්ෂා කරන ද භාවිතා කළ හැකිය.

ව්‍යංග ප්‍රතිදානය.


3

ජාවා, බයිට් 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
සකාරා

3

පයිතන් 2 , බයිට් 97 යි

Ovs පිළිතුර මත පදනම්ව නමුත් බයිට් 2 ක් කෙටි හා අඩු ගුප්ත. දර්ශක 2d ඛණ්ඩාංක බවට පරිවර්තනය කර සමානාත්මතාවය පරීක්ෂා කරන්න. 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

එය මාර්ගගතව උත්සාහ කරන්න!


1

පයිත් , බයිට් 33 යි

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

පරීක්ෂණ කට්ටලය.

0 මත පදනම් වූ සුචිගත කිරීම් භාවිතා කරයි.

පැහැදිලි කිරීම

q {@ U9.nm + mc | g1aZksd2-MC.DR3d_dC, t -> සම්පූර්ණ වැඩසටහන. ආදානය: STDIN වෙතින් L ලැයිස්තුවක්.

                               , t -> පළමු මූලද්‍රව්‍යය නොමැතිව L සමඟ L යුගල කරන්න.
                              සී -> පාරදෘශ්‍ය.
       m -> යුගල ලැයිස්තුවට ඉහළින් සිතියම (මූලද්‍රව්‍ය ලැයිස්තු 2):
        + mc | g1aZksd2-MC.DR3d -> සිතියම් ගත කළ යුතු කාර්යය (විචල්‍යය: d):
                         R d -> d හි සෑම අංගයක් සඳහාම ...
                       .D 3 -> ... එහි divmod එක 3 කින් ගන්න.
                      සී -> ට්‍රාන්ස්පෝස්.
                    -M -> අඩු කිරීමෙන් එක් එක් අඩු කරන්න.
         m -> එක් එක් වෙනස සඳහා (විචල්‍යය: k):
            g1aZl -> යනු | k | 1?
           | sd -> එය ව්‍යාජ නම්, d හි එකතුවෙන් එය ප්‍රතිස්ථාපනය කරන්න.
          c 2 -> 2 න් බෙදන්න.
        + _d -> සිතියම්ගත කිරීමේ ප්‍රති result ලයට d හි ප්‍රතිලෝම එකතු කරන්න.
     .n -> පැතලි.
  @ U9 -> (ℤ [0; 9%) සමඟ ඡේදනය කරන්න.
 {-> අඩු කිරීම.
q -> සහ ප්‍රති result ලය L ට සමානදැයි පරීක්ෂා කරන්න.

බයිට් 34 ක් සඳහා විකල්ප ප්‍රවේශය :

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

1

ජැප් , බයිට් 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?

විභව පැනීම් තීරණය කිරීමේ යම් වෙනසක් සහිතව මෙම ජෙලි විසඳුමෙන් අදහස ගෙන ආවේ :

  • ජෙලි පිළිතුර භාවිතා අයදුම් කළ විට යුගලයක් 2 වෙනසක් තිබේ නම් දකින්න divmod /3හෝ %3.
  • මෙම පිළිතුර පමණක් භාවිතා කරන %3අතර වෙනස 0 හෝ 2 දැයි පරීක්ෂා කරයි. වෙනස 0 නම්, සෛල දෙක සිරස් අතට පෙලගැසී ඇති අතර, පැනීම නොවන අය තවමත් දේපල බෙදා ගනී (X+Y)%2 != 0.

0

05AB1E , බයිට් 25 යි

ü‚εODÈ*y3‰øÆÄ2@·÷0Ky«}˜ÙQ

වරාය @ ජොනතන් ඇලන්ගේ ජෙලි පිළිතුර , ඒ නිසා ඔහුට upvote කිරීමට වග බලා ගන්න !!

0 පදනම් කරගත් ඉලක්කම් ලැයිස්තුවක් ලෙස ආදානය කරන්න.

එය මාර්ගගතව උත්සාහ කරන්න හෝ සියලු පරීක්ෂණ අවස්ථා සත්‍යාපනය කරන්න .

පැහැදිලි කිරීම:

ü‚             # Create overlapping pairs of the (implicit) input-list:
               #  i.e. [3,4,7,1,2,8,3] → [[3,4],[4,7],[7,1],[1,2],[2,8],[8,3]]
  ε            # Map each pair `y` to:
   O           #  Take the sum of the pair
               #   → [7,11,8,3,10,11]
    DÈ         #  Duplicate the sum, and check whether it's even (1 if truhy; 0 if falsey)
               #  → [0,0,1,0,1,0]
      *        #  And multiply it by the sum
               #  → [0,0,8,0,10,0]
   y           #  Push the current pair again
    3         #  Take the divmod-3 on both values
               #   → [[[1,0],[1,1]],[[1,1],[2,1]],[[2,1],[0,1]],[[0,1],[0,2]],[[0,2],[2,2]],[[2,2],[1,0]]]
      ø        #  Zip/transpose; swapping rows/columns
               #   → [[[1,1],[0,1]],[[1,2],[1,1]],[[2,0],[1,1]],[[0,0],[1,2]],[[0,2],[2,2]],[[2,1],[2,0]]]
       Æ       #  Reduce each by subtracting
               #   → [[0,-1],[-1,0],[2,0],[0,-1],[-2,0],[1,2]]
        Ä      #  Take the absolute value of each
               #   → [[0,1],[1,0],[2,0],[0,1],[2,0],[1,2]]
         2@    #  Check for each that it's >=2 (1 if truthy; 0 if falsey)
               #   → [[0,0],[0,0],[1,0],[0,0],[1,0],[0,1]]
           ·   #  Double each
               #   → [[0,0],[0,0],[2,0],[0,0],[2,0],[0,2]]
            ÷  #  (Integer-)divide the earlier sum by this,
               #  where dividing by 0 results in 0 in this 05AB1E version
               #   → [[0,0],[0,0],[4,0],[0,0],[5,0],[0,0]]
 0K            #  Remove all 0s
               #   → [[],[],[4],[],[5],[]]
   y«          #  Merge the pair to it
               #   → [[3,4],[4,7],[4,7,1],[1,2],[5,2,8],[8,3]]
             # After the map: flatten the list
               #  → [3,4,4,7,4,7,1,1,2,5,2,8,8,3]
  Ù            # Uniquify it
               #  → [3,4,7,1,2,5,8]
   Q           # And check whether it's equal to the (implicit) input-list
               #  → 0 (falsey)
               # (after which this result is output implicitly)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.