27

এই চ্যালেঞ্জের মধ্যে আপনার দুটি শব্দ উত্তীর্ণ হয়েছে: আপনার কাজ সেগুলি সংলগ্ন কিনা তা নির্ধারণ করা ।

দুটি অক্ষর সংলগ্ন যদি:

তারা একই চিঠি, বা
এগুলি ডিক্সিকোগ্রাফিকভাবে সংলগ্ন।

উদাহরণস্বরূপ, জে কেবলমাত্র আমি , জে এবং কে এর সংলগ্ন । জেড A এর সংলগ্ন নয়

দুটি শব্দ সংলগ্ন যদি:

তারা একই দৈর্ঘ্য, এবং
প্রতিটি বর্ণ অন্য শব্দটির একটি অনন্য বর্ণের সংলগ্ন।

উদাহরণস্বরূপ, ক্যাটটি এসএডি সংলগ্ন , সি> ডি, এ> এ, টি> এস হিসাবে ।
বিনামূল্যে সংলগ্ন নয় GRRD (প্রতিটি ই এর সাথে যুক্ত করতে একটি চিঠি প্রয়োজন) ।

ইনপুট আউটপুট

আপনি দুটি স্ট্রিং পাস করেছেন এবং আপনার যদি সত্যসংগত মানগুলি সংলগ্ন হয় তবে আপনাকে অন্যথায় মিথ্যা মান দিতে হবে। নীচের সমস্ত পরীক্ষার ক্ষেত্রে আপনার এক মিনিটের মধ্যে ফিরে আসা উচিত।

আপনি ধরে নিতে পারেন যে স্ট্রিংগুলিতে কেবল বড় হাতের অক্ষর, বর্ণমালা থাকবে।

দুটি স্ট্রিং একটি তালিকা হিসাবে পাস করা যেতে পারে, বা কনটেটেটেড, উদ্ধৃতি সহ বা ছাড়াই।

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

Truthy:

A A
A B
C B
DD CE
DE FC
ABCD BCDE
AACC DBBB
DJENSKE FDJCLMT
DEFGHIJKL HJLEHMCHE
IKLIJJLIJKKL LJLJLJLJLJHI
ACEGIKMOQSUWY BLNPRDFTVHXJZ
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS

Falsy:

A C
A Z
B J
JK J
CC BA
CE D
DJENSKE GDJCLMT
DEFGHIJKL HJLHMCHE
IJKLIJKLKIJL LIJLLHJLJLLL 
AWSUKMEGICOQY RSHXBLJLNQDFZ
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS

এটি কোড-গল্ফ , তাই সংক্ষিপ্ততম বৈধ উত্তরটি জয়ী!

code-golf sequence decision-problem

— নাথান মেরিল
সূত্র

ইনপুটটিতে কি চারপাশে উক্তি থাকতে পারে "A A"?

— তানমাথ

স্থির পরীক্ষার কেস। উদ্ধৃতি ঠিক আছে।

— নাথান মেরিল

ইনপুটটি কি কেবল বড় হবে?

— তানমাথ

আপনি ধরে নিতে পারেন, হ্যাঁ।

— নাথান মেরিল

আমি মনে করি আপনার চ্যালেঞ্জ পাঠ্যে উল্লেখ করা উচিত যা আপনি উদ্ধৃতি সহ ইনপুট স্ট্রিংগুলি সংজ্ঞায়িত করার অনুমতি দেন। ফর্মের একটি একক অ্যারের {'string1' 'string2'}পাশাপাশি গ্রহণযোগ্য হবে?

— লুইস মেন্ডো

11

সিজেম, 14 13 12 বাইট

r$r$.-:)3,-!

এটি অনলাইন চেষ্টা করুন! বা একবারে সমস্ত পরীক্ষার কেস যাচাই করুন ।

অ্যালগরিদম

আসুন গুলি এবং টন দুই হতে সাজানো একই দৈর্ঘ্যের শব্দ। জন্য গুলি এবং টন lexicographically সংলগ্ন হতে (এলএ), এটা প্রয়োজনীয় এবং যথেষ্ট যে তার সংশ্লিষ্ট অক্ষরের সবকিছুর যুগল এছাড়াও এলএ হয়।

শর্তটি সমস্ত শব্দের জন্য স্পষ্টভাবে যথেষ্ট এবং 1 দৈর্ঘ্যের শব্দের জন্য প্রয়োজনীয় ।

এখন, অনুমান গুলি এবং টন দৈর্ঘ্য আছে এন> 1 , এবং দিন একটি এবং খ , প্রথম অক্ষরের হতে রেস্প।, এর গুলি এবং টন ।

যেহেতু গুলি এবং টন এলএ হয়, কিছু bijective ম্যাপিং হয় φ এর অক্ষরের মধ্যে গুলি এবং অক্ষর T যেমন যে এক্স এবং φ (x) এর সব জন্য এলএ হয় এক্স মধ্যে গুলি , যার মানে হল | এক্স - φ (x) এর | ≤ 1 সকলের জন্য এক্স মধ্যে গুলি ।

যাক গ = φ (ক) এবং D = φ ^-1 (খ) । কারণ একটি 's এবং খ এর minimality, একটি ≤ ঘ (1) এবং খ ≤ গ (2) ।

তদতিরিক্ত, যেহেতু খ এবং ডি , এবং এ এবং সি , এবং এলএ, ডি 1 বি + 1 (3) এবং সি-এ + 1 (4) ।

(1) এবং (3) , এবং (2) এবং (4) একত্রিত করে আমরা পাই যে a ≤ d ≤ b + 1 এবং b ≤ c ≤ a + 1 , যেখান থেকে আমরা সেই একটি - 1 ≤ বি ≤ a +1 এবং, অতএব, যে একটি এবং খ এলএ হয়।

এখন, (1) এবং (4) , এবং (2) এবং (3) একত্রিত করে , আমরা সেই সিটি পাই - 1 ≤ a and d এবং d - 1 ≤ b ≤ c , যেখান থেকে আমরা সেই সি - 1 ≤ d কে ছাড় করি + C + 1 এবং, সুতরাং যে সি এবং ডি এলএ হয়।

সুতরাং, আমরা যদি φ দ্বারা φ (a) = b এবং φ (d) = গ , | এক্স - φ (এক্স) | ≤ 1 এখনও সবার জন্য রাখা হবে এক্স মধ্যে গুলি , এবং, বিশেষ করে সবার জন্য এক্স মধ্যে এর [1:] ।

এইভাবে, s [0] = a এবং t [0] = b , এবং s [1:] এবং t [1:] , এল এ এল।

যেহেতু s [1:] এর দৈর্ঘ্য n - 1 রয়েছে তাই এটি প্রযোজনার দ্বারা প্রয়োজনীয়তা প্রমাণ করে।

কোড

r               e# Read the first word from STDIN.
 $              e# Sort its characters.
  r             e# Read the second word from STDIN.
   $            e# Sort its characters.
    .-          e# Perform vectorized subtraction.
                e# This pushes either the difference of char codes of two
                e# corresponding characters or a character that has no does not
                e# correspond to a character in the other, shorter word.
      :)        e# Increment all results.
                e# In particular, this maps [-1 0 1] to [0 1 2].
        3,      e# Push the range [0 1 2].
          -     e# Perform set difference, i.e., remove all occurrences of 0, 1 and
                e# 2 from the array of incremented differences.
           !    e# Apply logical NOT. This gives 1 iff the array was empty iff
                e# all differences gave -1, 0 or 1.

— ডেনিস
সূত্র

আমি মনে করি একটি সহজ যুক্তি আছে - দুটি জিনিস যখন ক্রস করে তখন C->Y, D->Xকেবল মিলগুলি সাজানো ক্রমকে লঙ্ঘন করতে পারে এবং সেগুলি কেবল সঙ্কোচিত হতে পারে।

— xnor

@ এক্সনর মূলত যা আমি লিখেছিলাম। শুধু সঙ্গে অনেক বেশি শব্দ। : পি

— ডেনিস

4

এমএটিএল , 10 12 17 বাইট

c!S!odXl2<

এটি ডেনিসের পদ্ধতির ব্যবহার করে : প্রথমে বাছাই করুন এবং মিলের অবস্থানগুলিতে অক্ষরের তুলনা করুন।

ফর্ম্যাট সহ ইনপুট স্ট্রিংগুলির একটি অ্যারে {'CAT 'SAD'}।

আউটপুট শূন্য এবং এর একটি অ্যারে। ফলাফলটি সত্যবাদী হয় যদি এতে সমস্ত থাকে (এটি সত্য হতে সম্মত হয়)।

বর্তমান প্রকাশ (10.2.1) ব্যবহার করে , যা এই চ্যালেঞ্জের চেয়ে আগের।

সম্পাদনা করুন: ফাংশন Xlথেকে নাম পরিবর্তন করা হয়েছে |ভাষার নতুন সংস্করণে (এবং oপ্রয়োজনীয় এখন আর নেই)। নীচের লিঙ্কটিতে সেই পরিবর্তনগুলি অন্তর্ভুক্ত রয়েছে।

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

ব্যাখ্যা :

c         % implicitly cell array of strings and convert to 2D char array. 
          % This pads with spaces if needed
!S!       % sort each row
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

পুরানো পদ্ধতির, যা পৃথক ইনপুট হিসাবে স্ট্রিং গ্রহণ করে: 12 বাইট :

SiSXhcodXl2<

সম্পাদনা করুন : লিঙ্কের কোডটি ভাষার পরিবর্তনের অনুসারে সংশোধন করা হয়েছে; উপরে মন্তব্য দেখুন।

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

ব্যাখ্যা :

S         % implicitly input first string and sort
iS        % input second string and sort
Xh        % build cell array with these two strings
c         % convert to 2D char array. This pads with spaces if needed
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

— লুইস মেন্ডো
সূত্র

1

সুতরাং [1 0 1]এমএটিএল এ অ্যারেটি মিথ্যা। এটি দরকারী।

— ডেনিস

@ ডেনিস অন্যান্য ভাষায়ও কি এটি মিথ্যা নয়? মতলব / অকটাভেতে এটি সেভাবে কাজ করে: সমস্ত উপাদান ননজারো হতে হবে

— লুইস মেন্ডো

1

না। আসলে, আমি অন্য ভাষা জানি না যা এইভাবে আচরণ করে। পাইথন এবং সিজেমে যেমন, অ্যারেগুলি সত্যই যদি তারা খালি না থাকে। জাভাস্ক্রিপ্ট এবং রুবিতে, উদাহরণস্বরূপ, সমস্ত অ্যারেটি সত্য।

— ডেনিস

@ ডেনিস এটি আমার মতলব চিন্তাভাবনার পক্ষে অদ্ভুত। পাইথনে তাই একটি অ্যারে [0 0]সত্য?

— লুইস মেন্ডো

1

হ্যাঁ, কারণ এটির ইতিবাচক দৈর্ঘ্য রয়েছে। গল্ফ করার সময় এটি সাধারণত বিরক্তিকর।

— ডেনিস

2

সি, 233 বাইট

#include <stdlib.h>
#include <string.h>
#define h char
#define r return
int c(void*a,void*b){r*(h*)a-*(h*)b;}int a(h*s,h*t){int l=strlen(s),m=strlen(t);if(l!=m)r 0;qsort(s,l,1,c);qsort(t,m,1,c);while(l--)if(abs(s[l]-t[l])>1)r 0;r 1;}

আপনি এটি সংরক্ষণ adj.hকরে এবং তারপর এই adj.cফাইলটি ব্যবহার করে এটি পরীক্ষা করতে পারেন :

#include <stdio.h>
#include "adj.h"

int main() {
  char aa[] = "A", A[] = "A";
  char b[] = "A", B[] = "B";
  char cc[] = "C", C[] = "B";
  char d[] = "DD", D[] = "CE";
  char e[] = "DE", E[] = "FC";
  char f[] = "ABCD", F[] = "BCDE";
  char g[] = "AACC", G[] = "DBBB";
  char hh[] = "DJENSKE", H[] = "FDJCLMT";
  char i[] = "DEFGHIJKL", I[] = "HJLEHMCHE";
  char j[] = "IKLIJJLIJKKL", J[] = "LJLJLJLJLJHI";
  char k[] = "ACEGIKMOQSUWY", K[] = "BLNPRDFTVHXJZ";
  char l[] = "QQSQQRRQSTTUQQRRRS", L[] = "PQTTPPTTQTPQPPQRTP";
  char m[] = "ELKNSDUUUELSKJFESD", M[] = "DKJELKNSUELSDUFEUS";
  char n[] = "A", N[] = "C";
  char o[] = "A", O[] = "Z";
  char p[] = "B", P[] = "J";
  char q[] = "JK", Q[] = "J";
  char rr[] = "CC", R[] = "BA";
  char s[] = "CE", S[] = "D";
  char t[] = "DJENSKE", T[] = "GDJCLMT";
  char u[] = "DEFGHIJKL", U[] = "HJLHMCHE";
  char v[] = "IJKLIJKLKIJL", V[] = "LIJLLHJLJLLL";
  char w[] = "AWSUKMEGICOQY", W[] = "RSHXBLJLNQDFZ";
  char x[] = "QQSQQRRQSTTUQQQRRS", X[] = "PQTTPPTTQTPQPPQRTT";
  char y[] = "ELKNSDUVWELSKJFESD", Y[] = "DKJELKNSUELSDUFEUS";
  char *z[] = {aa,b,cc,d,e,f,g,hh,i,j,k,l,m,n,o,p,q,rr,s,t,u,v,w,x,y};
  char *Z[] = {A ,B,C ,D,E,F,G,H ,I,J,K,L,M,N,O,P,Q,R ,S,T,U,V,W,X,Y};

  for(int _=0;_<25;_++) {
    printf("%s %s: %s\r\n", z[_], Z[_], a(z[_], Z[_]) ? "true" : "false");
  }

  return 0;
}

তারপরে ব্যবহার করে সংকলন করুন gcc adj.c -o adj। আউটপুটটি হ'ল:

A A: true
A B: true
C B: true
DD CE: true
DE CF: true
ABCD BCDE: true
AACC BBBD: true
DEEJKNS CDFJLMT: true
DEFGHIJKL CEEHHHJLM: true
IIIJJJKKKLLL HIJJJJJLLLLL: true
ACEGIKMOQSUWY BDFHJLNPRTVXZ: true
QQQQQQQRRRRRSSSTTU PPPPPPPQQQQRTTTTTT: true
DDEEEFJKKLLNSSSUUU DDEEEFJKKLLNSSSUUU: true
A C: false
A Z: false
B J: false
JK J: false
CC AB: false
CE D: false
DEEJKNS CDGJLMT: false
DEFGHIJKL HJLHMCHE: false
IIIJJJKKKLLL HIJJJLLLLLLL: false
ACEGIKMOQSUWY BDFHJLLNQRSXZ: false
QQQQQQQQRRRRSSSTTU PPPPPPQQQQRTTTTTTT: false
DDEEEFJKKLLNSSSUVW DDEEEFJKKLLNSSSUUU: false

— প্যাট্রিক রবার্টস
সূত্র

2

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

lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

সরল বেনামে ফাংশন, দৈর্ঘ্যের জন্য আমার একটি পৃথক চেক থাকতে zipহবে কারণ এটি কেবল সংশ্লেষ করবে। itertools( zip_longest) এর মধ্যে একটি অনুরূপ ফাংশন রয়েছে যা খালি স্ট্রিংগুলি প্যাড করবে তবে এটি ব্যয়বহুল হবে।

দিয়ে পরীক্ষা হচ্ছে

f=lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

for case in testCases.split('\n'):
    print case, f(*case.split())

সৃষ্টি করে:

A A True
A B True
C B True
DD CE True
DE FC True
ABCD BCDE True
AACC DBBB True
DJENSKE FDJCLMT True
DEFGHIJKL HJLEHMCHE True
IKLIJJLIJKKL LJLJLJLJLJHI True
ACEGIKMOQSUWY BLNPRDFTVHXJZ True
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP True
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS True
A C False
A Z False
B J False
JK J False
CC BA False
CE D False
DJENSKE GDJCLMT False
DEFGHIJKL HJLHMCHE False
IJKLIJKLKIJL LIJLLHJLJLLL  False
AWSUKMEGICOQY RSHXBLJLNQDFZ False
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT False
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS False

— wnnmaw
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 86 90 94

সম্পাদনা করুন 4 বাইট সংরক্ষিত ধন্যবা @Neil
সম্পাদনা 2 4 বাইট ধন্যবা @ Mwr247 সংরক্ষণ

(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

দ্রষ্টব্য: একজোড়া চিঠি সংলগ্নতা চেক। একটি বেস 36 নম্বর হিসাবে যুগল নিন এন , যদি চিঠি সমান হয়, তখন n = a*36+a = a*37। যদি 1 এর পার্থক্য থাকে তবে n = a*36+a+1 = a*37+1বা n = a*36+a-1 = a*37-1। সুতরাং n % 37অবশ্যই 0, 1 বা 36 n%37%36হতে হবে And এবং 0 বা 1 হওয়া আবশ্যক।

নোট 2: a এবং b একই দৈর্ঘ্য কিনা তা নিশ্চিত করতে যুক্ত '0' ব্যবহার করা হয়। এটি তখন ছোটa.length==b.length

F=(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

console.log=x=>O.textContent+=x+'\n';

testOK=[['A','A'],['A','B'],['C','B'],['DD','CE'],['DE','FC'],
['ABCD','BCDE'],['AACC','DBBB'],['DJENSKE','FDJCLMT'],
['DEFGHIJKL','HJLEHMCHE'],['IKLIJJLIJKKL','LJLJLJLJLJHI'],
['ACEGIKMOQSUWY','BLNPRDFTVHXJZ'],
['QQSQQRRQSTTUQQRRRS','PQTTPPTTQTPQPPQRTP'],
['ELKNSDUUUELSKJFESD','DKJELKNSUELSDUFEUS']];
testFail=[['A','C'],['A','Z'],['B','J'],['JK','J'],['CC','BA'],['CE','D'],
['DJENSKE','GDJCLMT'],['DEFGHIJKL','HJLHMCHE'],
['IJKLIJKLKIJL','LIJLLHJLJLLL',''],
['AWSUKMEGICOQY','RSHXBLJLNQDFZ'],
['QQSQQRRQSTTUQQQRRS','PQTTPPTTQTPQPPQRTT'],
['ELKNSDUVWELSKJFESD','DKJELKNSUELSDUFEUS']];

console.log('TRUE')
testOK.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})  
console.log('FALSE')
testFail.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})

<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

আমি মনে করি আপনি ''প্রথমটির জায়গায় ব্যবহার করতে পারেন '0'কারণ এটি পার্সের মান পরিবর্তন করে না।

— নীল

@ নীল ঠিক, আবার চিন্তা করা আরও ভাল even আমি সংখ্যা 0 এবং 0 ব্যবহার করতে পারি যখন কোনও স্ট্রিংয়ে যোগ করার পরে এটি যাইহোক স্ট্রিং হয়ে যায়, এবং সংখ্যা 0 0 0 এখনও 0 মোড হয়

— edc65

আমি বিশ্বাস করি আপনি bচরিত্রের রেফারেন্স সহ আপনার (a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

— সাজ্টটি

@ Mwr247 চালাক ধন্যবাদ

— edc65

1

জাভাস্ক্রিপ্ট ES6, 117 বাইট 116 বাইট 111 বাইট 109 বাইট

(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2)

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

a=(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2);
// true
console.log('A A:', a('A', 'A'));
console.log('A B:', a('A', 'B'));
console.log('C B:', a('C', 'B'));
console.log('DD CE:', a('DD', 'CE'));
console.log('DE FC:', a('DE', 'FC'));
console.log('ABCD BCDE:', a('ABCD', 'BCDE'));
console.log('AACC DBBB:', a('AACC', 'DBBB'));
console.log('DJENSKE FDJCLMT:', a('DJENSKE', 'FDJCLMT'));
console.log('DEFGHIJKL HJLEHMCHE:', a('DEFGHIJKL', 'HJLEHMCHE'));
console.log('IKLIJJLIJKKL LJLJLJLJLJHI:', a('IKLIJJLIJKKL', 'LJLJLJLJLJHI'));
console.log('ACEGIKMOQSUWY BLNPRDFTVHXJZ:', a('ACEGIKMOQSUWY', 'BLNPRDFTVHXJZ'));
console.log('QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP:', a('QQSQQRRQSTTUQQRRRS', 'PQTTPPTTQTPQPPQRTP'));
console.log('ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUUUELSKJFESD', 'DKJELKNSUELSDUFEUS'));

// false
console.log('A C:', a('A', 'C'));
console.log('A Z:', a('A', 'Z'));
console.log('B J:', a('B', 'J'));
console.log('JK J:', a('JK', 'J'));
console.log('CC BA:', a('CC', 'BA'));
console.log('CE D:', a('CE', 'D'));
console.log('DJENSKE GDJCLMT:', a('DJENSKE', 'GDJCLMT'));
console.log('DEFGHIJKL HJLHMCHE:', a('DEFGHIJKL', 'HJLHMCHE'));
console.log('IJKLIJKLKIJL LIJLLHJLJLLL:', a('IJKLIJKLKIJL', 'LIJLLHJLJLLL'));
console.log('AWSUKMEGICOQY RSHXBLJLNQDFZ:', a('AWSUKMEGICOQY', 'RSHXBLJLNQDFZ'));
console.log('QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT:', a('QQSQQRRQSTTUQQQRRS', 'PQTTPPTTQTPQPPQRTT'));
console.log('ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUVWELSKJFESD', 'DKJELKNSUELSDUFEUS'));

<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

স্নিপেট প্রসারিত করুন

ধার

@ rink.attendant.6 5 বাইট বন্ধ চাঁচা
@ ব্যবহারকারী 81655 2 বাইট বন্ধ চাঁচা

— প্যাট্রিক রবার্টস
সূত্র

আপনি কি [...s]পরিবর্তে ব্যবহার করতে পারেন s.split('')?

— rink.attendant.6

@ rink.attendant.6, হ্যাঁ, আপনাকে ধন্যবাদ। এখনও ES6 এর সাথে অভ্যস্ত হয়ে যাচ্ছি এবং এটি আমার মনে রাখা দরকার একটি শর্টকাট!

— প্যাট্রিক রবার্টস

1

পাইথ, 37 31 বাইট

&qZ-FmldK.zqY-m.a-FdCmmCkSdK[Z1

সমস্ত পরীক্ষার ক্ষেত্রে এটি অনলাইনে চেষ্টা করুন!

সংক্ষিপ্ত হ্রাস সংকেত ( -Fপরিবর্তে .U-bZ) ব্যবহার করে 6 বাইট বন্ধ

সমাধান ডেনিস দ্বারা অনুপ্রাণিত

কোডগল্ফের প্রথম জমা!

ব্যাখ্যা

আমরা এক্সপ্রেশনটিকে দুটি অংশে বিভক্ত করতে পারি, যা &ফলাফলের সাথে ফলাফলের সাথে তুলনা করা হয়। আমি কিছু ছদ্ম-পাইথন লিখে ব্যাখ্যা করার চেষ্টা করব

প্রথমে আমরা পরীক্ষা করে দেখি যে দুটি শব্দের দৈর্ঘ্য একই

mldK.z         lengths = map(lambda d: len(d), K=all_input())
.U-bZmldK.z    diff = reduce(lambda b, Z: b - Z, lengths)
qZ.U-bZmldK.z  diff == 0

তারপরে, আমরা ডেনিসের পদ্ধতিটি প্রয়োগ করি:

       K                                                      # ['CAT', 'SAD']
 m   SdK           sort = map(lambda d: sorted(d), K)         # ['ACT', 'ADS']
 mmCkSdK           ascii = map(lambda d: sorted(d), map(lambda k: ord(k), K))
                                                              # [[65, 67, 84], [65, 68, 83]]
CmmCkSdK           zipped = zip(*ascii)                       # [[65, 65], [67, 68], [84, 83]]
m.U-bZd CmmCkSdK   map(lambda d: d[0] - d[1], zipped)         # [0, -1, 1]
m.a.U-bZd CmmCkSdK map(lambda d: abs(d[0] - d[1]), zipped)    # [0, 1, 1]

তারপরে আমরা -সেই তালিকার সমস্ত উপাদানগুলিতে [Z1( [0, 1]) না থাকা ফিল্টার করতে অপারেটরটি ব্যবহার করি , এবং ফলাফলটি খালি তালিকার সাথে পরীক্ষা করে দেখুনqY

— Tenchi2xh
সূত্র

1

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

(a,b)=>![...a].sort().some((d,i)=>(d[c='charCodeAt']()-([...b].sort()[i]||c)[c]())/2|0)

একটি শূন্যকেন্দ্রিক প্রতিসম রেঞ্জ চেক ব্যবহার করে সর্বাধিক মান দ্বারা ভাগ করে, তারপর কিছুটা "বা" ( |) দিয়ে কাটা হয় । দুটি চেক করা বা তার সাথে একটি করার চেয়ে কম Math.abs()।

— Mwr247
সূত্র

1

হাস্কেল, 67 63 বাইট

import Data.List
f a=any(null.(a\\)).mapM(\x->[pred x..succ x])

ব্যবহারের উদাহরণ: f "FREE" "GRRD"-> False।

এটি কীভাবে কাজ করে (দ্রষ্টব্য: fআংশিকভাবে বিন্দু মুক্ত এবং দ্বিতীয় প্যারামিটার bসংজ্ঞাতে উপস্থিত হয় না):

mapM(\x->[pred x..succ x])      -- for each letter of b make a list of the
                                -- predecessor, the letter itself and the successor.
                                -- Make a list of every possible combination
                                -- thereof, e.g "dr" ->
                                -- ["cq","cr","cs","dq","dr","ds","eq","er","es"] 
any(null.(a\\))                 -- see if the difference between any of the
                                -- combinations and the other parameter a is
                                -- empty, i.e. they have the same elements

সম্পাদনা করুন: @ xnor সংরক্ষণ করতে 4 বাইট পেয়েছে। ধন্যবাদ!

— nimi
সূত্র

কি id xশুধু x? বা কেমন [pred x..succ x]?

— xnor

@ এক্সনর: আমি শুরু করেছিলাম \x->map($x)[pred,id,succ], তাই idকেবল একটি অবশিষ্ট ছিল। অবশ্যই ..সব মারে। ধন্যবাদ!

— নিমি

0

সি, 172 বাইট

#define q(x)qsort(x,strlen(x),1,c)
c(x,y)char*x,*y;{return*x-*y;}main(a,v,w)char**v,*w,*a;{for(q(w=v[1]),q(a=v[2]);*w&&*a&&abs(*w-*a)<2;w++,a++);printf("%d",abs(*w-*a)<2);}

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

$ bash -x test.sh
+ bash -x test.sh
+ ./a.out A A
1+ ./a.out A B
1+ ./a.out C B
1+ ./a.out DD CE
1+ ./a.out DE FC
1+ ./a.out ABCD BCDE
1+ ./a.out AACC DBBB
1+ ./a.out DJENSKE FDJCLMT
1+ ./a.out DEFGHIJKL HJLEHMCHE
1+ ./a.out IKLIJJLIJKKL LJLJLJLJLJHI
1+ ./a.out ACEGIKMOQSUWY BLNPRDFTVHXJZ
1+ ./a.out QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
1+ ./a.out ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS
1+ ./a.out A C
0+ ./a.out A Z
0+ ./a.out B J
0+ ./a.out JK J
0+ ./a.out CC BA
0+ ./a.out CE D
0+ ./a.out DJENSKE GDJCLMT
0+ ./a.out DEFGHIJKL HJLHMCHE
0+ ./a.out IJKLIJKLKIJL LIJLLHJLJLLL
0+ ./a.out AWSUKMEGICOQY RSHXBLJLNQDFZ
0+ ./a.out QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
0+ ./a.out ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS
0++

— কোল ক্যামেরন
সূত্র

0

পাওয়ারশেল, 140 বাইট

param($a,$b)(($a=[char[]]$a|sort).Count-eq($b=[char[]]$b|sort).Count)-and(($c=0..($a.Count-1)|%{+$a[$_]-$b[$_]}|sort)[0]-ge-1-and$c[-1]-le1)

এই সংক্ষিপ্ত পেতে সম্ভব হতে পারে। এটি বর্তমানে পাইথন বা জাভাস্ক্রিপ্টের সাথে প্রতিযোগিতামূলক নয়, তবে এটি কিছুটা ভিন্ন পদ্ধতির ব্যবহার করে, তাই আমি বুঝতে পেরেছিলাম যে আমি এটি পোস্ট করব।

ব্যাখ্যা

এই কোডটি কারও জন্য পাওয়ারশেলের সাবলীল না হওয়ার জন্য সত্যিই বিভ্রান্তিকর, তাই আমি এটিকে ইংরাজীতে ভাঙ্গার চেষ্টা করব যতটা সম্ভব আমি ...

আমরা ইনপুটটিকে param($a,$b)স্বাভাবিক হিসাবে নেওয়া শুরু করি ।

কোডের পুরো অংশটি আসলে একটি বিবৃতি, এবং অপারেটরের (...)-and(...)সাথে দুটি বুলিয়ান বিবৃতি পরীক্ষা করার জন্য ভাঙা যায় -and।

(... -eq ...)দুটি বস্তুর সাম্য পরীক্ষা করতে বাম-হাতের পেরেন্সগুলি ভেঙে ফেলা যায়। এই উদাহরণস্বরূপ, বস্তুগুলি .Countদুটি নতুন চর-অ্যারের গুলি (যা দৈর্ঘ্য)। প্রতিটি অভ্যন্তরীণ পেরেন ($a=[char[]]$a|sort)আসল ইনপুট শব্দটি গ্রহণ করে, এটিকে চার-অ্যারে হিসাবে পুনরায় কাস্ট করে, তারপরে বাছাই করে আবার একই চলকটিতে পুনরায় সংরক্ষণ করে। আমরা $aএবং এটি উভয়ের জন্যই করি $b। বাম-দিকটি এইভাবে যাচাই করে যে ইনপুট শব্দগুলি একই দৈর্ঘ্য। যদি তারা একই দৈর্ঘ্য না হয় তবে বাইরের বুলিয়ান বিবৃতিটির এই অর্ধেকটি ব্যর্থ Falseহবে এবং আউটপুট হবে।

ডানদিকের দিকে সরানো, আমরা আবার দুটি বুলিয়ান বিবৃতি দিয়ে পরীক্ষা করছি (... -and ...)। বাম-হাতটি পরীক্ষা করে something ণাত্মক 1 এর চেয়ে বড় বা সমান-সমান কিছু বেশি কিনা তা পরীক্ষা করে -ge-1। কিছু একটি নির্মাণ অ্যারের zeroth-উপাদান $c, যা দ্বারা নির্মিত হয়:

অনুমোদিত সূচকগুলির একটি পরিসর নেওয়া 0..($a.count-1)
একটি লুপ মধ্যে পাইপ |%{...}
লুপের প্রতিটি পুনরাবৃত্তি, আমরা ইনডেক্সড অক্ষরের $aASCII মান গ্রহণ করি এবং ইনডেক্সেড অক্ষরের ASCII মান বিয়োগ করি$b
যা তখন |sortসাংখ্যিক মান দ্বারা সম্পাদিত হয়

বিবৃতিটির অন্য দিকটি $c[-1]অ্যারের সর্বাধিক মান নেয় এবং নিশ্চিত করে যে এটি 1 এর সাথে কম-বা সমান হবে -le1।

সুতরাং, যদি দুটি ইনপুট স্ট্রিং সত্যই সংলগ্ন হয়, $cঅ্যারের মতো কিছু হবে @(-1,-1,-1...0,0,0...1,1,1)। সুতরাং প্রথম উপাদানটি হবে -1এবং শেষ উপাদানটি হবে 1। যদি তারা সংলগ্ন না হয় তবে একটি নির্দিষ্ট জুটির জন্য ASCII মানগুলির মধ্যে পার্থক্য হয় < -1বা হয় > 1, সুতরাং বাইরের বুলিয়ান পরীক্ষার এই অর্ধেকটি ব্যর্থ হবে, এবং Falseআউটপুট হবে।

উভয় পক্ষের পাস Trueহলেই আউটপুট হবে এবং স্ট্রিংগুলি তাই ল্যা।

— AdmBorkBork
সূত্র

0

মরিচা, ~~269~~ 264 বাইট

fn a(w:&str,x:&str)->bool{if w.len()==x.len(){return{let mut c:Vec<char>=w.chars().collect();let mut d:Vec<char>=x.chars().collect();c.sort();d.sort();for(e,f)in c.iter().zip(d.iter()){if(((*e as u8)as f64)-((*f as u8)as f64)).abs()>1f64{return false}}true}}false}

সম্প্রসারিত:

fn are_adjacent(w: &str, x: &str)->bool{

    if w.len() == x.len(){

        return {

            let mut c : Vec<char> = w.chars().collect();
            let mut d : Vec<char> = x.chars().collect();

            c.sort();
            d.sort();

            for (e,f) in c.iter().zip(d.iter()){
                if (((*e as u8) as f64) - ((*f as u8) as f64)).abs() > 1f64{
                    return false
                } 
            }

            true
        }
    }

    false
}

পরীক্ষার কেস:

fn main(){
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("C","B"));
    assert_eq!(true,are_adjacent("DD","CE"));
    assert_eq!(true,are_adjacent("DE","FC"));
    assert_eq!(true,are_adjacent("ABCD","BCDE"));
    assert_eq!(true,are_adjacent("AACC","DBBB"));
    assert_eq!(true,are_adjacent("DJENSKE","FDJCLMT"));
    assert_eq!(true,are_adjacent("DEFGHIJKL","HJLEHMCHE"));
    assert_eq!(true,are_adjacent("IKLIJJLIJKKL","LJLJLJLJLJHI"));
    assert_eq!(true,are_adjacent("ACEGIKMOQSUWY","BLNPRDFTVHXJZ"));
    assert_eq!(true,are_adjacent("QQSQQRRQSTTUQQRRRS","PQTTPPTTQTPQPPQRTP"));
    assert_eq!(true,are_adjacent("ELKNSDUUUELSKJFESD","DKJELKNSUELSDUFEUS"));

    assert_eq!(false,are_adjacent("A","C"));
    assert_eq!(false,are_adjacent("A","Z"));
    assert_eq!(false,are_adjacent("B","J"));
    assert_eq!(false,are_adjacent("JK","J"));
    assert_eq!(false,are_adjacent("CC","BA"));
    assert_eq!(false,are_adjacent("CE","D"));
    assert_eq!(false,are_adjacent("DJENSKE","GDJCLMT"));
    assert_eq!(false,are_adjacent("DEFGHIJKL","HJLHMCHE"));
    assert_eq!(false,are_adjacent("IJKLIJKLKIJL","LIJLLHJLJLLL"));
    assert_eq!(false,are_adjacent("AWSUKMEGICOQY","RSHXBLJLNQDFZ"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("ELKNSDUVWELSKJFESD","DKJELKNSUELSDUFEUS"));
}

— সপ্তাহ
সূত্র

0

এপিএল, 59 বাইট (অক্ষর)

(61 যদি আমাদের f with সহ {এবং}, 63 সরবরাহ করতে হয়)

আমি সবচেয়ে বড় এপিএল নই, তবে এটি খুব মজাদার।

(0=+/2≤|¨∊-/{⎕av⍳⍵}¨(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵])∧=/⍴¨∊¨⍺⍵

=/⍴¨∊¨⍺⍵ ইনপুট সমান দীর্ঘ হয়?

∧ এবং নীচের সমস্ত

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] উভয় ইনপুটগুলি বাছাই করুন এবং এগুলির দু'টির দীর্ঘতম হিসাবে আকার দিন (আপনি যদি তাদের তুলনায় আরও দীর্ঘ করেন তবে তারা চারপাশে लपेटুন)

|¨∊-/{⎕av⍳⍵} উভয় চর ভেক্টরকে তাদের ascii মানগুলির int ভেক্টরে রূপান্তর করুন, একটি ভেক্টর বিয়োগ করুন এবং সমস্ত মানকে পরম করুন

0=+/2≤ দুটি এর চেয়ে বড় বা সমান মানগুলি যোগ করুন এবং ফলাফলটি 0 এর সমান কিনা তা পরীক্ষা করুন

— Koneke
সূত্র

0

কে (ওকে) , 27 বাইট

সমাধান:

2>|/x*x:-/(|/#:'x)$x@'<:'x:

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

উদাহরণ:

2>|/x*x:-/(|/#:'x)$x@'<:'x:("QQSQQRRQSTTUQQRRRS";"PQTTPPTTQTPQPPQRTP")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("DEFGHIJKL";"HJLHMCHE")
0
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AAA")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AA")
0

ব্যাখ্যা:

প্রথমে প্রতিটি স্ট্রিং বাছাই করুন, তারপরে একই দৈর্ঘ্যের জন্য প্যাড করুন, তারপরে অন্যটির থেকে একটি নিন (অক্ষরের ASCII মান), বর্গ-ফলাফল যেমন কোনও অন্তর্নির্মিত নেই abs, সর্বাধিক পার্থক্য নিন এবং এটি 2 এর চেয়ে কম কিনা তা পরীক্ষা করুন।

2>|/x*x:-/(|/#:'x)$x@'<:'x: / the solution
                         x: / save input to variable x
                      <:'   / ascending sorted indices (<:) for each (') list
                   x@'      / apply (@) each (') of these indices to the input (x)                             
          (      )$         / pad
             #:'x           / count (#:) each (') list (x)
           |/               / max (|) over (/) to get maximum
        -/                  / subtract (-) over (/) to take 2nd list from 1st
      x:                    / save in variable x
    x*                      / multiply by x (so square)
  |/                        / max over to get maximum distance
2>                          / is 2 greater than (>) to this maximum? returns 1 (true) or 0 (false)

— streetster
সূত্র

0

জে, 27 বাইট

[:*/@(2>|)[:-/,:&(3&u:@/:~)

ungolfed

[: */@(2 > |) [: -/ ,:&(3&u:@/:~)

ব্যাখ্যা

&(3&u:@/:~) উভয় যুক্তি বাছাই করে, এবং তাদেরকে ascii সংখ্যায় রূপান্তর করে
,: একটি 2 xn ম্যাট্রিক্স তৈরি করে, যেখানে n টি অর্গের অক্ষরের সংখ্যা
-/ সংশ্লিষ্ট বর্ণগুলির দূরত্ব উপস্থাপন করে দৈর্ঘ্য n এর একটি তালিকা প্রদান করে, একটি থেকে অন্য সারির বিয়োগ করে
(2>|) দূরত্বের পরম মান 2, 0 এর চেয়ে কম হলে 1 প্রদান করে
*/এই সমস্ত 0গুলি এবং 1গুলিকে এক সাথে গুণিত করে: অতএব, চূড়ান্ত ফলাফল 1 হয় যদি সমস্ত সংযুক্ত অক্ষরের সংলগ্ন হয়।

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

— দুর্ভাগ্যআনয়নকারী
সূত্র

সংলগ্ন শব্দগুলির সাথে মিলছে

ইনপুট আউটপুট

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

সিজেম, 14 13 12 বাইট

অ্যালগরিদম

কোড

এমএটিএল , 10 12 17 বাইট

সি, 233 বাইট

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

জাভাস্ক্রিপ্ট (ES6), 86 90 94

জাভাস্ক্রিপ্ট ES6, 117 বাইট 116 বাইট 111 বাইট 109 বাইট

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

ধার

পাইথ, 37 31 বাইট

ব্যাখ্যা

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

হাস্কেল, 67 63 বাইট

সি, 172 বাইট

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

পাওয়ারশেল, 140 বাইট

ব্যাখ্যা

এপিএল, 59 বাইট (অক্ষর)

কে (ওকে) , 27 বাইট

জে, 27 বাইট

ungolfed

ব্যাখ্যা