আয়তক্ষেত্র সনাক্তকরণ

21

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা 0'গুলি এবং এর ' র বহুবিধ স্ট্রিংয়ের সাথে নিয়ে থাকে 1। অন্য কোনও অক্ষর স্ট্রিংতে থাকবে না এবং স্ট্রিংটি সর্বদা আয়তক্ষেত্রাকার হবে (সমস্ত রেখার অক্ষর একই সংখ্যার হবে) মাত্রা 1 × 1 এর মতো ছোট, তবে অন্যথায় 0এর এবং 1এরগুলি নির্বিচারে সাজানো যেতে পারে।

আপনি অনুমান হতে পারে স্ট্রিং একটি ঐচ্ছিক চিহ্ন সম্পর্কে newline আছে, এবং ইচ্ছা হলে আপনি কোন দুটি স্বতন্ত্র ব্যবহার করতে পারেন মুদ্রণযোগ্য হওয়া ASCII স্থানে অক্ষর 0এবং 1।

স্ট্রিংয়ের উভয় এবং এর সমস্ত পথ সংযুক্ত অঞ্চলের সমস্ত শক্ত আয়তক্ষেত্র হয়01 , অন্যথায় একটি মিথ্যা মানটি আউটপুট করে যদি সত্যবাদী মান প্রিন্ট করুন বা প্রত্যাবর্তন করুন ।

একটি পাথ সংযুক্ত অঞ্চল এর 0'র মানে যে কোনো এক থেকে 0অঞ্চলে অন্যান্য সমস্ত 0' র কেবল চলন্ত দ্বারা পৌঁছে যেতে পারে, নিচে, বাম এবং ডান অপরের 0এর (এবং না তির্যকভাবে চলন্ত, না কোন চলন্ত 1এবং স্ট্রিং সীমানা বাইরে চলন্ত না )। একই ধারণাটি 1পথ সংযুক্ত অঞ্চলে প্রযোজ্য ।

একটি কঠিন আয়তক্ষেত্র এর 0'র মানে আয়তক্ষেত্র সমগ্র এলাকা দিয়ে পূর্ণ 0s' এর কোন 1'র। একই ধারণাটি 1শক্ত আয়তক্ষেত্রগুলিতে প্রযোজ্য ।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। টাইব্রেকার এর আগের উত্তর।

(নোট করুন যে স্ট্রিংটি টোরয়েডাল সীমানা শর্তের সাথে প্রায় আবৃত হয় না )

উদাহরণ

1) এই ইনপুট স্ট্রিংটিতে 3 টি পথ সংযুক্ত অঞ্চল রয়েছে (2 এর জন্য 0এবং 1 টি 1)। কেবল নীচের অংশের ডান 00অঞ্চলটি যদিও একটি শক্ত আয়তক্ষেত্র, সুতরাং আউটপুট মিথ্যা হবে।

0011
0111
0100

2) এই ইনপুট স্ট্রিংটিতে 4 টি পথ সংযুক্ত অঞ্চল রয়েছে (উভয়র জন্য 0এবং 2 1)। এগুলির সবগুলিই শক্ত আয়তক্ষেত্রাকার তাই আউটপুট সত্য হবে।

0011
0011
1100

3) এই ইনপুটটিতে 2 টি পথ সংযুক্ত অঞ্চল রয়েছে তবে তাদের মধ্যে কেবল একটিই একটি শক্ত আয়তক্ষেত্র, সুতরাং আউটপুটটি মিথ্যা হবে।

00000000
01111110
00000000

4) এই ইনপুটটিতে কেবল 1 টি পথ সংযুক্ত অঞ্চল রয়েছে এবং তুচ্ছভাবে একটি শক্ত আয়তক্ষেত্র হয়, সুতরাং আউটপুট সত্য।

11111111
11111111
11111111

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

একটি Tমাত্র ইনপুট স্ট্রিং মানে truthy নীচে Fউপায়ে falsy।

0
T

1
T

00
T

01
T

10
T

11
T

0000000
T

1111111
T

011100100100101100110100100100101010100011100101
T

00
11
T

01
10
T

01
11
F

00
01
F

11
11
T

110
100
F

111
000
T

111
101
111
F

101
010
101
T

1101
0010
1101
0010
T

1101
0010
1111
0010
F

0011
0111
0100
F

0011
0011
1100
T

00000000
01111110
00000000
F

11111111
11111111
11111111
T

0000001111
0000001111
T

0000001111
0000011111
F

0000001111
1000001111
F

1000001111
1000001111
T

1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111
F
code-golf  string  geometry  grid 
— ক্যালভিনের শখ
সূত্র

উত্তর:

5

জেলি , 7 বাইট

ṣ⁷µ=ḢZE

এটি @ লেভেলরিভারস্টের রুবি উত্তর হিসাবে একই অ্যালগরিদম ব্যবহার করে । আসল অ্যালগরিদম শেষ 4 বাইটে ফিট করে; ইনপুট ফর্ম্যাটটি বিশ্লেষণের জন্য প্রথম 3 বাইটের প্রয়োজন।

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

কিভাবে এটা কাজ করে

ṣ⁷µ=ḢZE  Main link. Argument: t (string)

ṣ⁷       Split t at linefeeds..
  µ      Begin a new, monadic link. Argument: A (list of strings)
    Ḣ    Pop the first string of A.
   =     Compare all other strings in A with the first.
         = compares characters, so this yields a list of Booleans for each string.
         For a truthy input, all pairs of lines now have been transformed in lists
         of only 1's or only 0's. That means all columns must be equal.
     Z   Zip; transpose rows with columns.
      E  Check if all rows (former columns) are equal to each other.
— ডেনিস
সূত্র
16

জেলি , 11 10 বাইট

ṣ⁷^2\⁺€FS¬

@ ডেনিসকে এটির মূল আকার থেকে অর্ধেক নেমে যাওয়ার (অদ্বন্ধিত বৈশিষ্ট্যগুলির মাধ্যমে) প্রচুর ধন্যবাদ।

এটি অনলাইন চেষ্টা করুন ! দ্রষ্টব্য যে ট্রিপল উদ্ধৃতিগুলি বহু লাইন স্ট্রিংয়ের জন্য।

ব্যাখ্যা

বেসিক অ্যালগরিদমটি হ'ল: প্রতি 2x2 সাবগ্রিডে 1 এস (বা, সমতুল্য, 0 সে) এর সমান সংখ্যক থাকে তবে সত্যটি ফেরান।

এটি স্পষ্ট যে 1-এর একটি বিজোড় সংখ্যা কেন কাজ করতে পারে না, যেহেতু আমাদের নিম্নলিখিতগুলির মধ্যে একটি থাকবে:

10  01  00  00  01  10  11  11
00  00  01  10  11  11  10  01

মনে রাখবেন যে প্রথম 4টি একই জিনিসটির আবর্তন এবং শেষ 4 এর জন্য ডিট্টো।

অন্য কথায়, সমস্ত 2x2 সাবগ্রিডগুলি নিম্নলিখিতগুলির মধ্যে একটি হতে হবে:

00  00  11  01  10  01  10  11
00  11  00  01  10  10  01  11

যা আমরা যদি সীমানার দিকে লক্ষ্য করি তবে নিম্নলিখিত "ধাঁধা টুকরো" হিসাবে কল্পনা করা যায়:

 ___    ___    ___    ___
|   |  | | |  |   |  | | |
|   |  | | |  |---|  |-|-|
|___|  |_|_|  |___|  |_|_|

এবং সেই ধাঁধা টুকরাগুলির সাথে একটি অ-আয়তক্ষেত্র গঠনের চেষ্টা করুন :) (শেষগুলি সমাপ্ত হওয়া পর্যন্ত)

আসল বাস্তবায়নটি হ'ল:

ṣ⁷               Split input by newlines to give rows
  ^2\            Taking overlapping sets of 2 rows at a time: accumulate rows by XOR
                 Note that strings cast to integers automatically for bitwise operators
     ⁺€          Repeat the previous link (⁺), on each (€) element in the resulting array
       F         Flatten the array
        S        Sum (effectively reducing by OR)
         ¬       Logical negation of the result

উদাহরণস্বরূপ, ইনপুট জন্য

100
010
000
101

আমাদের আছে:

  ṣ⁷: ["100", "010", "000", "101"]
 ^2\: [[1, 1, 0], [0, 1, 0], [1, 0, 1]]    (e.g. first entry is "100" ^ "010")
^2\€: [[0, 1], [1, 1], [1, 1]]             (e.g. the first entry is [1^1, 1^0] - this
                                            gives the counts of 1s in each subgrid, mod 2)
   F: [0, 1, 1, 1, 1, 1]
   S: 5                                    (this gives the number of invalid 2x2 subgrids,
                                            which is indeed all but the top left)
   ¬: 0
— Sp3000
সূত্র
1
আপনি যে বৈশিষ্ট্যগুলি ব্যবহার করেছেন তা দয়া করে নথিভুক্ত করতে পারেন? মানুষ যদি তা করে তবে ডকুমেন্টেশন হবে!
— ক্যালকুলেটরফলাইন
তোমার কি চ্যাপ্টা দরকার?
— ক্যালকুলেটরফলাইন
@ ক্যাটস এয়ারফ্লুফি যদি আপনি সমতল না করেন, জেলি ভেক্টরগুলির একটি তালিকা যোগ করার চেষ্টা করে এবং ফলস্বরূপ আপনি একটি ভেক্টর পান
— Sp3000
শুধু যোগফল এবং যোগফল - এটি আরও ভাল!
— ক্যালকুলেটরফলাইন
4
"Undocumented বৈশিষ্ট্য" - আহা! সুতরাং যে কিভাবে ডেনিস outgolfs সবাই! : ডি
— অ্যাডমবার্কবার্ক
12

রুবি, 76

->s{j=!r=1
s.lines{|t|i=t.to_i(2)
j&&r&&=(j^i)%t.tr(?0,?1).to_i(2)<1
j=i}
r}

সম্পূর্ণ আয়তক্ষেত্রগুলি সমন্বিত যে কোনও গ্রিডে প্রতিটি লাইন অবশ্যই রেখার সমান হওয়া উচিত, বা সমস্ত বিটগুলি 0 থেকে 1 এবং উল্টোদিকে উল্টানো উচিত।

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

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

আমি অবাক হয়েছি এখনও পর্যন্ত উত্তরগুলি এটি লক্ষ্য করে নি।

আমি মনে করি এই অ্যালগরিদমটি অন্য কোনও ভাষায় খুব ছোট হওয়া উচিত।

পরীক্ষা প্রোগ্রামে অসম্পূর্ণ

f=->s{
  j=!r=1                              #r = truthy, j=falsy
  s.lines{|t|                         #for each line
    i=t.to_i(2)                       #i = value of current line, converted to a number in base 2 (binary)
    j&&                               #if j is truthy (i.e this is not the first line)
      r&&=(j^i)%t.tr(?0,?1).to_i(2)<1 #XOR i with the previous line. Take the result modulo (current line with all 0 replaced by 1)
                                      #if the result of the XOR was all 0 or all 1, the modulo == zero (<1). Otherwise, it will be a positive number.   
j=i}                                  #j = value of current line (always truthy in ruby, even if zero)
r}                                    #return 1 or true if all the modulo calculations were zero, else false.



#text to print after test case to check answer is as desired
T='T

'
F='F

'

#test cases
puts f['0'],T

puts f['1'],T

puts f['00
'],T

puts f['01'],T

puts f['10'],T

puts f['11
'],T

puts f['0000000'],T

puts f['1111111'],T

puts f['011100100100101100110100100100101010100011100101'],T

puts f['00
11'],T

puts f['01
10'],T


puts f['01
11'],F

puts f['00
01'],F

puts f['11
11
'],T

puts f['110
100'],F

puts f['111
000'],T

puts f['111
101
111'],F

puts f['101
010
101
'],T

puts f['1101
0010
1101
0010'],T

puts f['1101
0010
1111
0010'],F

puts f['0011
0111
0100
'],F

puts f['0011
0011
1100'],T

puts f['00000000
01111110
00000000'],F

puts f['11111111
11111111
11111111'],T

puts f['0000001111
0000001111'],T

puts f['0000001111
0000011111'],F

puts f['0000001111
1000001111'],F

puts f['1000001111
1000001111'],T

puts f['1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111'],F
— স্তর নদী সেন্ট
সূত্র
আমি বাজি ব্যবহার s.scan(/^?.*\n/)বাইট সংরক্ষণ করতে সাহায্য করবে।
— চার্লস
3

শামুক , 20 বাইট

!{to{\0w`3\1|\1w`3\0

গ্রিডের অঞ্চলটি 3 জিরো এবং একটি বা 3 বা একটি এবং 0একটি শূন্যযুক্ত 2x2 বর্গক্ষেত্র না থাকলে , বা যদি এই জাতীয় 2x2 বর্গ বিদ্যমান থাকে তবে মুদ্রিত করুন।

— feersum
সূত্র
3

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

Ybc2thYCs2\~

@ Sp3000 এর দুর্দান্ত উত্তর হিসাবে একই অ্যালগরিদম ।

মাল্টলাইন ইনপুটটিকে মঞ্জুরি দেওয়ার জন্য, এমএটিএলকে নিউলাইনের 10জন্য অক্ষর ব্যবহার করে স্পষ্টভাবে বিল্ড করা সারি চর অ্যারে (স্ট্রিং) প্রয়োজন । সুতরাং চারটি উদাহরণের ইনপুটটি []হ'ল (দ্রষ্টব্য এটি সংক্ষিপ্তকরণ , সুতরাং এগুলির প্রতিটি অক্ষরের সারি অ্যারে):

['0011' 10 '0111' 10 '0100']
['0011' 10 '0011' 10 '1100']
['00000000' 10 '01111110' 10 '00000000']
['11111111' 10 '11111111' 10 '11111111']

এবং শেষ তিনটি পরীক্ষার মামলা হচ্ছে

['0000001111' 10 '1000001111']
['1000001111' 10 '1000001111']
['1110100110101010110100010111011101000101111' 10 '1010100100101010100100010101010101100101000' 10 '1110100110010010110101010111010101010101011' 10 '1010100100101010010101010110010101001101001' 10 '1010110110101010110111110101011101000101111']

সত্যবাদী আউটপুট হল এমন একটি অ্যারে যা কেবল থাকে।

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

ব্যাখ্যা

এটি অক্ষরের সমতুল্যতা '0'এবং '1'সংখ্যার সমান 0এবং 1এইভাবে চরটি থেকে যে অঙ্কটি উপস্থাপন করে তা রূপান্তর করার দরকার নেই এই বিষয়টি ব্যবহার করে

Yb     % split implicit input by whitespace. Gives a cell array
c      % concatenate cell contents into 2D char array
2th    % push array [2 2]
YC     % get 2×2 sliding blocks and arrange as columns
s      % sum of each column
2\     % modulo 2 of each sum
~      % negate. Implicit display
— লুইস মেন্ডো
সূত্র
ইনপুটটির একটি স্ট্রিং হওয়া দরকার
— ক্যালভিনের
@ হেলকাহোম্বা এমএটিএল মাল্টিলাইন স্ট্রিং ইনপুটটিকে অনুমতি দেয় না ... ইনপুটটি ফর্মের একটি সারি অ্যারে হতে হবে ['first line' 10 'second llne'], যেখানে 10নিউলাইনের জন্য ASCII রয়েছে। এটা কি গ্রহণযোগ্য?
— লুইস মেন্ডো
@ হেলকাহোম্বা আমি এটি আপডেট করা উত্তরে ব্যবহার করেছি। বিকল্পভাবে, নতুন লাইনের পরিবর্তে স্থান ব্যবহার করা যাবে? প্রথম উদাহরণটি স্ট্রিং হবে'0011 0111 0100'
— লুইস মেন্ডো
@ লুইস মেন্ডো আমি এই চিন্তাকে প্রশংসা করি, তবে আমি মনে করি যে রুবি উত্তরটি সম্ভবত এখানে সাধারণভাবে গল্ফায়ার হতে পারে :)
— Sp3000
@ Sp3000 ওহ, আমি সেটিকে দেখিনি। খুব চালাকও
— লুইস মেন্ডো
2

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

s=>!s.split`
`.some((t,i,u)=>[...t].some((v,j)=>v^t[0]^u[0][j]^s[0]))

আমি বিশ্বাস করি যে পথ সংযোগের আয়তক্ষেত্রের মাপদণ্ডটি যে কোনও চারটি পয়েন্ট দেওয়া হয়েছে যা একটি স্বেচ্ছাসেদী আয়তক্ষেত্রের কোণকে গঠন করে যে এটির একটি এমনকি সংখ্যারও সমান 1। নোট করুন যে আয়তক্ষেত্রের সমতা (0, খ), (x, y) (0, খ), (ক, ই) ^(ক, বি), (x, y) এর সমান তাই আমাকে কেবল পরীক্ষা করতে হবে যাদের আয়তক্ষেত্রগুলি শীর্ষ বাম কোণে (0, 0) হয়। এছাড়াও ডি মরগানের আইন অনুসারে, !.some()একই রকম .every(!)যা আমাকে কয়েকটা বাইট সংরক্ষণ করে।

সম্পাদনা: আমি লক্ষ্য করেছি যে জেলি দ্রবণটি সমস্ত 2 × 2 আয়তক্ষেত্রগুলির কোণগুলির সমতা পরীক্ষা করে, যা সমতুল্য হিসাবে দেখানো যেতে পারে।

— নিল
সূত্র
প্রায় 7 বার, তবে +1
— edc65
2

জাভাস্ক্রিপ্ট (ES6), 79

@ Sp3000 থেকে জেলি এর একই অ্যালগরিদম (এবং এটি কাজ করে প্রমাণিত করতে না পেরে খুশি)। মাত্র 8 গুন লম্বা

s=>[...s].every((x,i)=>[++i,i+=s.search`
`,i+1].some(p=>!(x^=p=s[p],p>`
`))|!x)

কম গল্ফড

s=>[...s].every((x,i)=> // repeat check for every sub square
     [++i,                  // array of position for next char in row
      i+=s.search`\n`, i+1] // and 2 chars at same column in next row
       .some(p=> // for each position 
          !( 
            x^=s[p],  // xor current value with value at position p
            s[p]>`\n` // true if value at position p is valid
           ) // the condition is negated
       ) // if any value scanned is not valid, .some return true
         // else, we must consider the check for current square
       | !x // x can be 0 or 1, to be valid must be 0
   )

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

f=s=>[...s].every((x,i)=>[++i,i+=s.search`
`,i+1].some(p=>!(x^=p=s[p],p>`
`))|!x) 

testData=`
0
T

1
T

00
T

01
T

10
T

11
T

0000000
T

1111111
T

011100100100101100110100100100101010100011100101
T

00
11
T

01
10
T

01
11
F

00
01
F

11
11
T

110
100
F

111
000
T

111
101
111
F

101
010
101
T

1101
0010
1101
0010
T

1101
0010
1111
0010
F

0011
0111
0100
F

0011
0011
1100
T

00000000
01111110
00000000
F

11111111
11111111
11111111
T

0000001111
0000001111
T

0000001111
0000011111
F

0000001111
1000001111
F

1000001111
1000001111
T

1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111
F`

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

testData.split('\n\n').forEach(t=>{
  var k=t.slice(-1)=='T',
      r=f(t.slice(0,-1))
  console.log(t+' '+r+ (k==r?' OK\n':' KO\n'))
})  
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
1
এখন ৮ গুন লম্বা!
— নীল
1

গ্রিম ভি0.1, 31 বাইট

E=\0+|\1+
N=.+&E!
e`(E/N|N/E)#!

ছাপে 1ম্যাচের জন্য এবং 0কোনো মিল জন্য। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

গ্রিম আমার 2 ডি প্যাটার্নের সাথে মেলে ভাষা। আমি আজ এটি সংশোধন করেছি, তবে কেবল একটি সিনট্যাক্স উপাদানটির `পরিবর্তে ( পরিবর্তে ,), যাতে এটি আমার স্কোরকে প্রভাবিত করে না।

আমি এসপি 3000 এর মতো অনুরূপ পন্থা ব্যবহার করছি : যদি একটি ইনপুট মিথ্যা হয় তবে এতে 2 2 N আয়তক্ষেত্র থাকে যার এক সারিতে উভয় থাকে 0এবং 1অন্য সারিতে থাকে না।

E=             Define a nonterminal E, which matches
  \0+|           a horizontal run of one or more 0s, OR
      \1+        a horizontal run of one or more 1s.
N=             Define a nonterminal N, which matches
  .+             a horizontal run of one or more characters,
    &E!          which is NOT matched by E (so contains both 0 and 1).
e`             Match entire input to this pattern:
            !    not
           #     contains
  (E/N|N/E)      E on top of N, or N on top of E
— Zgarb
সূত্র
1

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

s=>(a=s.split`
`).every(l=>l==a[0]|l==a[0].replace(/./g,n=>n^1))

@ লেভেলরিভারস্টস্টের পর্যবেক্ষণের ভিত্তিতে প্রতিটি লাইন অবশ্যই প্রথমটির বিপরীতে বা একই রকম হতে হবে।

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