33

ডুডিয়াডিক টাইলগুলি বিভিন্ন ধরণের স্কোয়ার ফাংশন ব্লক যা দুটি ইনপুট নেয়, একটি তাদের উপরের দিক থেকে এবং একটি বাম দিক থেকে এবং দুটি আউটপুট থাকে, একটি তার ডানদিকে এবং একটি নীচের দিকে থাকে। তাদের প্রতিটি আউটপুট তাদের উভয় ইনপুটগুলির একটি পৃথক ফাংশন।

উদাহরণস্বরূপ, যদি #একটি জেনেরিক টালি প্রতিনিধিত্ব করে, ডান আউটপুট Rএকটি ফাংশন fইনপুট Tএবং L, এবং নীচে আউটপুট Bঅন্য ফাংশন gএর Tএবং L:

 T
L#R         R = f(T, L)
 B          B = g(T, L)

^{(দুটি ফাংশন হওয়ায় টাইলসটিকে "দ্বৈত" এবং উভয় ফাংশন থেকেই "ডায়াডিক" বলা হয় দুটি যুক্তি রয়েছে বলে ।)}

টাইলসটি তখন গ্রিডে এক সাথে রচনা করা যায়, এক টাইলের আউটপুটগুলি প্রতিবেশীদের সরাসরি টাইলগুলির ইনপুটগুলিতে যায়। এখানে উদাহরণস্বরূপ, বামের ডান আউটপুট ডানদিকে বাম #ইনপুটটিতে যায় #:

 AB         D = f(f(A, C), B)
C##D        E = g(A, C)
 EF         F = g(f(A, C), B)

আপনি কল্পনা করতে পারেন যে duodyadic টাইলস একটি সেট দেওয়া, নির্দিষ্ট কার্যকারিতা, জটিল (এবং সম্ভাব্য দরকারী) রচনা সঙ্গে প্রতিটি তৈরি করা যেতে পারে।

এই চ্যালেঞ্জে আমরা কেবলমাত্র দশটি লজিক ভিত্তিক ডুডিয়াডিক টাইলের চিরাচরিত সেট নিয়ে উদ্বিগ্ন থাকব, যেখানে সমস্ত ইনপুট এবং আউটপুটগুলি একক বিট বাইনারি সংখ্যা (শূন্য বা একক) হয়। প্রতিটি ধরণের টাইল বোঝাতে আমরা একটি পৃথক ASCII অক্ষর ব্যবহার করব।

টাইল অক্ষর এবং তাদের ইনপুট-আউটপুট সম্পর্কগুলি নিম্নরূপ:
( Tশীর্ষের ইনপুট Lজন্য, বাম ইনপুট Rজন্য, ডান আউটপুট জন্য,B নীচে আউটপুট।)

শূন্য: 0বা (স্থান)R = 0 ,B = 0
এক: 1→R = 1 ,B = 1
ক্রস: +→R = L ,B = T
আয়না: \→R = T ,B = L
কেবল শীর্ষ: U→R = T ,B = T
কেবলমাত্র বাম: )→ R = L,B = L
নয়: !→ R = not L,B = not T
এবং: &→ R = L and T,B = L and T
বা: |→ R = L or T,B = L or T
জোর: ^→ R = L xor T,B = L xor T

চ্যালেঞ্জ

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন 0 1+\U)!&|^যা দশটি লজিক ভিত্তিক ডুডিয়াডিক টাইলস ব্যবহার করে তৈরি করা "সার্কিট" উপস্থাপন করে এমন অক্ষরগুলির একটি আয়তক্ষেত্রাকার গ্রিড গ্রহণ করে । এছাড়াও আপনি দুটি স্ট্রিং গ্রহণ করা প্রয়োজন 0's এবং 1এর; একটি হ'ল বাম ইনপুট কলাম এবং অন্যটি শীর্ষ ইনপুট সারি হবে। আপনার প্রোগ্রাম / ফাংশনটি নীচের আউটপুট সারি এবং ডান আউটপুট কলামটি ( 0'এর এবং এর মধ্যেও 1) মুদ্রণ / ফিরিয়ে আনতে হবে ।

উদাহরণস্বরূপ, এই গ্রিডে

+++
+++

সমস্ত ইনপুট সরাসরি গ্রিড জুড়ে আউটপুটগুলিতে প্রবাহিত হয়

 ABC
D+++D
E+++E
 ABC

সুতরাং 010/ এর একটি ইনপুট 01আউটপুট 010/ হবে 01:

 010
0+++0
1+++1
 010

আপনার প্রোগ্রাম সঠিক আউটপুট হবে [bottom output row]\n[right output column]বা [bottom output row]/[right output column]:

010
01

অথবা

010/01

যদি আপনি কোনও ফাংশন লিখে থাকেন তবে আপনি দুটি স্ট্রিং একটি টিপল বা তালিকায় (বা এখনও এগুলি মুদ্রণ করতে পারেন) ফেরত দিতে পারেন।

বিস্তারিত

স্ট্রিং হিসাবে যেকোন যুক্তিসঙ্গত উপায়ে তিনটি ইনপুট নিন (সাধারণত অর্ডার গ্রিডে, শীর্ষ সারিতে, বাম কলামে): কমান্ড লাইন, পাঠ্য ফাইল, এসডিটিন, ফাংশন আর্গ।
আপনি ধরে নিতে পারেন ইনপুট সারি এবং কলামের দৈর্ঘ্য গ্রিডের মাত্রাগুলির সাথে মিলবে এবং কেবলমাত্র 0'গুলি এবং 1' গুলি থাকবে।
আপনার গ্রিডে অবশ্যই যথাযথ অক্ষর ব্যবহার করা উচিত ( 0 1+\U)!&|^)। এটি মনে রাখবেন 0এবং একই জিনিসটি বোঝান।

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

(I / O হিসাবে top/ left→ bottom/ right। পড়ুন)

নন্দ:

&!

00/ 0→ 01/ 1
00/ 1→ 01/ 1
10/ 0→ 01/ 1
10/ 1→ 11/0

সমস্তগুলি:

1111
1\+\
1+\+
1\+\

কোন ইনপুট ফলে উচিত 1111/ 1111।

নন্দ থেকে জোর: (স্থানের স্থানের কলামটি নোট করুন)

\)+\ 
U&!& 
+! ! 
\&!& 
   !

00000/ 00000→ 00000/ 00000
00000/ 10000→ 00010/ 00000
10000/ 00000→ 00010/ 00000
10000/ 10000→ 00000/00000

জিগ জাগ:

+++\00000000
000\!!!!\000
00000000\+++

বাম ইনপুটটির প্রথম বিটটি ডান আউটপুটের শেষ বিট হয়ে যায়। আর সব কিছু0 ।

000000000000/ 000→ 000000000000/ 000
000000000000/ 100→ 000000000000/001

প্রসারণ:

)))
UUU
U+U
U+U
UUU

বাম ইনপুটটির প্রথম বিট সমস্ত আউটপুটগুলিতে যায়।

000/ 00000→ 000/ 00000
000/ 10000→ 111/11111

সমস্ত 1 × 1 গ্রিড পরীক্ষার কেসগুলির একটি পেস্টবিন এখানে।

স্কোরিং

বাইটস মধ্যে সংক্ষিপ্ততম জমা জয়।

বোনাস: আপনি কোন দুর্দান্ত "সার্কিট" তৈরি করতে পারেন?

^{পিএস গুগলিংকে "ডুডিয়াডিক টাইলস" বিরক্ত করবেন না। আমি গতকাল এগুলি তৈরি করেছি; ডি}
^{আপনি যদি এই ধারণাটিকে একটি পূর্ণাঙ্গ প্রোগ্রামিং ভাষায় প্রসারিত করতে চান তবে এই চ্যাটরুমে আসুন ।}

code-golf grid logic-gates

— ক্যালভিনের শখ
সূত্র

11

একটি দুর্দান্ত চ্যালেঞ্জের জন্য +1 কিন্তু এটির কারণ আপনি ডুডিয়্যাডিক টাইলস আবিষ্কার করেছেন যা সত্যিই দুর্দান্ত।

— অ্যালেক্স এ।

3

+1 এটি গুগল করা সত্যিই সম্পূর্ণ অকেজো: goo.gl/zuqfdW । দুর্দান্ত চ্যালেঞ্জ!

— ব্রেইনস্টিল

আমি তাদের সাথে আছি আমি এই নির্দিষ্ট গল্ফ চ্যালেঞ্জের চেয়ে প্রোগ্রামিং ভাষা হিসাবে আপনার টাইলগুলিতে অনেক বেশি আগ্রহী। PS: এখানে 16 টি টাইলস রয়েছে, সুতরাং অন্য ছয়টির জন্য চিঠি / নাম নিয়ে আসা ঝরঝরে হবে।

— স্পার

বিভিন্ন দিক থেকে আউটপুট / ইনপুটগুলি থাকা ব্লকগুলি রাখা আকর্ষণীয় হবে কারণ অন্যথায় আপনি কোনও ল্যাচ তৈরি করতে পারবেন না কারণ সমস্ত কিছু নীচে-ডানদিকে প্রবাহিত হয়।

— Sp3000

2

আপনি টি / বি কে ইউ (পি) / ডি (নিজস্ব) এ পরিবর্তন করতে পারেন, যাতে আমরা রুবিকের কিউব স্বরলিখনের সাথে একত্রে F / B রাখতে পারি এবং তারপরেও। । । ত্রিদ্রাবাদী কিউব?

— সোহম চৌধুরী

8

পাইথ, 122

এক দানব ধরনের। কেবল পুনরাবৃত্তি ব্যবহার করে, ডায়নামিক প্রোগ্রামিংয়ের মতো অভিনব কোনও কিছুই নেই।

D:NGHR@Cm+d[1HG&GH|GHxGH0),[GH!G)[HG!H)x"+\\!1U)&|^"N#aYw)M:@@YGH?hgGtHHv@eYG?egtGHGv@ePYHjkm+0egtleYklePYjkm+0hgbtlePYleY

অনলাইন বিক্ষোভ ।

ইনপুট নিম্নলিখিত পদ্ধতিতে রয়েছে: প্রথমে গ্রিড (কোনও পালানোর উপায় নেই, কোনও অতিরিক্ত চিহ্ন নয়) এবং তারপরে ইনপুট দুটি লাইন, যেমন (জিগ জাগ)

+++\00000000
000\!!!!\000
00000000\+++
000000000000
100

— Jakube
সূত্র

8

গণিত, 331 276 270 267 264 262 252 250 বাইট

Print@@@{#[[2;;,-1,2]],#[[-1,2;;,1]]}&@MapIndexed[h=Characters;({r@#2,b@#2}=<|##|>&@@Thread[h@"0 1+\\)U!&|^"->{0,0,1,i={##},{#2,#},##,1-i,1##,Max@i,(#-#2)^2}]&[r[#2-{1,0}],b[#2-{0,1}]]@#{1,1})&,Join[h@{"0"<>#3},h@StringSplit[#2<>"
"<>#,"
"]],{2}]&

একটি বেসরকারি ব্যবহারযোগ্য ইউনিকোড অক্ষর যা ম্যাথামেটিকাল একটি সুপারস্ক্রিপ্ট যেমন ব্যবহার করে T, অর্থাত্ এটা পক্ষান্তরণ অপারেটর আছে।

এখানে আরও পাঠযোগ্য সংস্করণ:

Print @@@ {#[[2 ;;, -1, 2]], #[[-1, 2 ;;, 1]]} &@
  MapIndexed[h = Characters;
   (
     {r@#2, b@#2} = <|##|> & @@ Thread[
            h@"0 1+\\)U!&|^" -> {
              0,
              0,
              1,
              i = {##},
              {#2, #},
              ##,
              1 - i,
              1 ##,
              Max@i,
              (# - #2)^2
              }] & [
          r[#2 - {1, 0}],
          b[#2 - {0, 1}]
          ] @ # {1, 1}
     ) &,
   Join[
    h@{"0" <> #3},
    h@StringSplit[#2 <> "\n" <> #, "\n"]\[Transpose]
   ],
   {2}] &

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

ব্যাখ্যা

আসুন এই ধাপে ধাপে ধাপে (আমি কোনও গণিত জ্ঞান অনুমান করার চেষ্টা করব না)। আপনার সাজানোর জন্য সামনের দিকে কোডটি পড়া দরকার। বেসিক অ্যালগরিদম কেবল প্রতিটি ফাংশন গণনা করে ফলাফলগুলি fপরবর্তী টাইলস দ্বারা অ্যাক্সেস করার জন্য সঞ্চার করে through

ইনপুট প্রক্রিয়াজাতকরণ

এই বিট:

Join[
  h@{"0" <> #3},
  h@StringSplit[#2 <> "\n" <> #, "\n"]\[Transpose]
]

এটি কেবল অক্ষরগুলির নেস্টেড তালিকায় গ্রিডকে বিভক্ত করে (নোট করুন যে আমি কোডের কোথাও hএকটি নাম হিসাবে সংজ্ঞায়িত করেছি Character) এবং তারপরে ইনপুটগুলির সাথে একটি সারি এবং একটি কলাম যুক্ত করে। এটি কাজ করে, কারণ 1এবং 0ধ্রুবক-ফাংশন টাইলগুলির নামও তাই প্রকৃতপক্ষে এগুলি প্রয়োগ করা ম্যানুয়ালি ইনপুটগুলিকে খাওয়ানোর মতোই প্রভাব ফেলে। যেহেতু এগুলি ফাংশন তাই তারা প্রযুক্তিগতভাবে গ্রিডের বাইরে থেকে তাদের ইনপুট নেবে, তবে যেহেতু তারা ধ্রুবক কার্যকরী হয় তাতে কিছু আসে যায় না। উপরের বাম কোণটি একটি পায়0 তবে এটি মোটামুটি স্বেচ্ছাচারী কারণ যে টাইলের ফলাফল কখনও ব্যবহার হয় না।

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

গ্রিড সমাধান

(এই বিভাগটি কিছুটা পুরানো।

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

আমরা প্রতিটি ঘরের ফলাফলের জন্য টেবিল হিসাবে ভেরিয়েবল r( bight) এবং (নীচে) ব্যবহার করি। আমাদের বেনামে ফাংশনটির বর্তমান সমন্বয় রয়েছে #2, তাই আমরা কোনও কক্ষে ইনপুট পাই

r[#2 - {1, 0}],
b[#2 - {0, 1}]

মনে রাখবেন যে প্রথম সারিতে এবং কলামে এটি rএবং এর অপরিবর্তিত মানগুলিতে অ্যাক্সেস করবেb । ম্যাথেমেটিকায় এটির সাথে আসলেই সমস্যা নেই এবং পরিবর্তে আপনাকে আপনার স্থানাঙ্কগুলি ফিরিয়ে দেব, তবে আমরা এই ফলাফলটিকে যাইহোক বাতিল করে দিই, কারণ সেই সারি / কলামের সমস্ত টাইলই ধ্রুবক কাজ।

এখন এই জিনিস:

<|##|> & @@ Thread[
  h@"0 1+\\U)!&|^" -> {
     z = {0, 0}, z, o = 1 + z, {##}, ...
  }] &

একটি গল্ফ ফর্ম হয়

<|"0" -> (z = {0, 0}), " " -> z, "1" -> (o = 1 + z), "+" -> {##}, ... |> &

যার ফলস্বরূপ একটি ফাংশন যা দুটি টাইল ইনপুট দেয়, একটি সমিতি প্রদান করে (আপনি এটিকে হ্যাশম্যাপ বা অন্য ভাষায় একটি টেবিল বলতে চাইবেন), যাতে এই দুটি ইনপুটগুলির জন্য সমস্ত সম্ভাব্য টাইলের ফলাফল রয়েছে। সমস্ত ফাংশন কীভাবে বাস্তবায়িত হয় তা বোঝার জন্য, আপনাকে জানতে হবে যে এই জাতীয় ফাংশনের প্রথম যুক্তিটি দিয়ে #এবং দ্বিতীয়টি দিয়ে প্রবেশ করা যেতে পারে #2। তদ্ব্যতীত, ##আপনাকে উভয় আর্গুমেন্টের একটি ক্রম দেয় যা আর্গুমেন্টগুলিকে "স্প্ল্যাট" করতে ব্যবহৃত হতে পারে।

0: সহজবোধ্য, আমরা কেবল একটি ধ্রুবক ফিরে আসি {0, 0}এবং এটি zভবিষ্যতের ব্যবহারের জন্যও বরাদ্দ করি (যেমন স্পেস টাইলের মধ্যে)।
1: মূলত ন্যায়সঙ্গত {1,1}, তবে এটি zহ'ল সংক্ষিপ্ত করা 1+z। আমরা এটিকেও সংরক্ষণ করিo কারণ এটি সমস্ত টাইলগুলির জন্য কার্যকর হবে যেখানে উভয় আউটপুট অভিন্ন।
+: এখানে আমরা ক্রমটি ব্যবহার করি। {##}হিসাবে একই {#,#2}এবং উভয় ইনপুট অপরিবর্তিত মাধ্যমে পাস।
\: আমরা দুটি যুক্তি অদলবদল করি, {#2,#} ,।
U: এখন আমরা এর ব্যবহার করতে পারি o।o#2মানে{1,1}*#2 আমরা উভয় আউটপুটে কেবল শীর্ষ যুক্তি রেখেছি।
): বাম আর্গুমেন্টের জন্য একত্রে: o#।
!: তাত্পর্যপূর্ণভাবে ম্যাথমেটিকায় বিরক্তিকর নয়, তবে যেহেতু আমাদের কেবল কখনও ছিল 0এবং 1আমরা কেবল উভয় ইনপুটগুলি থেকে বিয়োগ করতে পারি1 (যার ফলে এটি উল্টে) এবং তা পাস করতে পারি:1-{##} ।
&: এই এক বেশ নিফটি। আমরা প্রথমে যে bitwise লক্ষ্য এবং জন্য 0এবং 1গুণ অভিন্ন। তদ্ব্যতীত,o## হিসাবে একইo*#*#2 ।
|: আবারও আমরা একটি সমতুল্য ফাংশন ব্যবহার করি। বিটওয়াইস বা Maxএই ক্ষেত্রে হিসাবে একই , তাই আমরা Maxইনপুট আর্গুমেন্ট প্রয়োগ এবং ফলাফল মধ্যে গুন{1,1} ।
^: আমি জোরের সংক্ষিপ্ততমটি খুঁজে পেয়েছি তা হ'ল পার্থক্যটি নিয়ে এটি বর্গাকার করা (ইতিবাচকতা নিশ্চিত করতে), সুতরাং আমরা পেয়েছি o(#-#2)^2।

এই ফাংশন সমাপ্ত হবে এবং আয় পূর্ণ সমিতি আমরা বর্তমান ঘরের চরিত্র ব্যবহার উপাদান আমরা প্রতি আগ্রহ দেখিয়েছেন বাইরে টেনে আনি এবং এ সঞ্চয় পরে rএবং b। দ্রষ্টব্য যে এটি ব্যবহৃত বেনামী ফাংশনের রিটার্ন মানওMapIndexed তাই ম্যাপিংটি আমাকে সমস্ত ফলাফলের গ্রিড দেবে।

আউটপুট প্রক্রিয়াজাতকরণ

MapIndexedএকটি 3D গ্রিড প্রদান করে, যেখানে প্রথম মাত্রা অনুভূমিক গ্রিড স্থানাঙ্কের সাথে সামঞ্জস্য করে (পূর্ববর্তী স্থানান্তর মনে রাখবেন), দ্বিতীয় মাত্রা উল্লম্ব গ্রিড স্থানাঙ্কের সাথে সামঞ্জস্য করে এবং তৃতীয়টি সূচিত করে যে আমরা একটি নীচে বা বাম আউটপুট পেয়েছি কিনা indicates নোট করুন যে এটিতে ইনপুট সারি এবং কলাম রয়েছে যা আমাদের পরিত্রাণ পেতে হবে। সুতরাং আমরা নীচে সারি নীচের আউটপুট অ্যাক্সেস

#[[2;;,-1,2]]

এবং চূড়ান্ত কলামের ডান আউটপুট সঙ্গে

#[[-1,2;;,1]]

মনে রাখবেন যে 2;; এটি দ্বিতীয় থেকে শেষ উপাদান পর্যন্ত একটি ব্যাপ্তি।

শেষ অবধি, আমরা Printউভয়কেই ( @@@দ্বিতীয় স্তরের সিনট্যাকটিক চিনির মতো ব্যবহার করে) প্রয়োগ করি Apply, যা কেবলমাত্র তার সমস্ত আর্গুমেন্টকে পিছনে পিছনে মুদ্রণ করে (এবং যেহেতু এটি দুটি পৃথক অভিব্যক্তিতে প্রয়োগ করা হয়, নীচে এবং এর মধ্যে একটি নতুন লাইন থাকবে ডান আউটপুট)।

— মার্টিন ইন্ডার
সূত্র

8

সি, 332 309 272 270 266 259 247 225 বাইট

#define C(x)*c-x?
i,k,T,L,m;f(c,t,l)char*c,*t,*l;{while(L=l[i]){for(k=0;T=t[k];c++)L=C(49)C(43)C(92)C(85)C(41)C(33)C(38)C('|')C(94)T=48:(T^=L-48):(T|=L):(T&=L):(T^=1,L^1):(T=L):T:(m=T,T=L,m):L:(T=49),t[k++]=T;c++;l[i++]=L;}}

এখানে অনলাইনে ফলাফল দেখুন !

এটি একটি ফাংশন সংজ্ঞায়িত করে void f(char*, char*, char*), যা বোর্ডকে তার প্রথম ইনপুট, তারপরে ইনপুটটির শীর্ষ সারি এবং তারপরে ইনপুটটির বাম সারি হিসাবে নেওয়া উচিত।

আমি এটি যা পরীক্ষা করতাম তা এখানে:

#include "stdio.h"
int main() {
    char buf[1024],top[33],left[33];
    /* Copy and paste an example circuit as the first input,
       and put a 'Q' immediately after it. 
       Note that the Q is never touched by the function f, and is used
       solely as a delimiter for input. */
    scanf("%[^Q]Q ",buf);
    /* Then enter your top inputs */
    scanf("%[01]%*[^01]", top);
    /* Then your left ones */
    scanf("%[01]", left);
    /* OUTPUT: Bottom\nRight */
    f(buf, top, left);
    return 0;
}

সুতরাং, Sp3000 এর 2-বিট গুণককে ইনপুট দিয়ে:

UUUU))))
UU++)))&
UUU+)  U
UU++&))U
U++&+)^U
U)&\&)UU
   U+^UU
   \&UUUQ
11110000
00000000

আমরা পেতে:

00001001
11111111

অন্য নোটে, স্প 3000 এর অর্ধেক অ্যাডারের কথা মাথায় রেখে, আমি একটি পূর্ণ অ্যাড্রেয়ার দেখতে চাই ... আপনারা একজন এটি করেছেন! আমি মনে করি না যে সিস্টেমটি নিজেরাই একটি প্রোগ্রামিং ভাষা হিসাবে দাঁড়িয়ে আছে তবে এটি খুব আকর্ষণীয় হয়েছে। এটি মেটাগল্ফের জন্য দুর্দান্ত টার্গেটের মতো বলে মনে হচ্ছে, যদিও!

একটি সংক্ষিপ্ত ব্যাখ্যা:

এখানে অবমুক্ত করা, মন্তব্য করা কোড:

/* We define the first half of the ?: conditional operator because, well,
   it appears over and over again. */
#define C(x)*c-x?
/* i,k are counting variables
   T,L are *current* top and left inputs */
i,k,T,L,m;
f(c,t,l)char*c,*t,*l;{
    /* The outer loop iterates from top to bottom over l and c */
    while(L=l[i]){
        /* Inner loop iterates from left to right over t and c */
        for(k=0;T=t[k];c++)
            /* This line looks awful, but it's just a bunch of character
            comparisons, and sets T and L to the output of the current c */
            L=C(49)C(43)C(92)C(85)C(41)C(33)C(38)C('|')C(94)T=48:(T^=L-48):(T|=L):(T&=L):(T^=1,L^1):(T=L):T:(m=T,T=L,m):L:(T=49),
            /* Write our output to our input, it will be used for the next row */
            t[k++]=T;
        c++; /*Absorbs the newline at the end of every row */
        /* Keep track of our right-most outputs, 
        and store them in the handy string passed to the function. */
        l[i++]=L;
    }
    /* Bottom output is now stored entirely in t, as is right output in l */        
}

আমরা cবাম থেকে ডানে (তারপরে উপরে থেকে নীচে) উপরে পুনরাবৃত্তি করব, tপ্রতিবার ইনপুটগুলি পুনর্লিখন করে এবং ডান-সর্বাধিক আউটপুটটি পুশ করি যা lস্ট্রিংয়ের মধ্যে সজ্জিত । আমরা এর শীর্ষ সারিটি এর এবং এর cসাথে প্রতিস্থাপন হিসাবে কল্পনা করতে পারি10 ' এর পুনরাবৃত্তির এবং ডানদিকে বাইরে বের করা বিটগুলি ট্র্যাক করে রেখে ।

এখানে সারি সারি এক আরও চাক্ষুষ সিকোয়েন্স রয়েছে:

 111                                  
1&+^  =>  110 ->0  =>     ->0  =>     0 Thus, "01" has been written to l,
1+&+     1+&+         110 ->1         1
                                  110   And "110" is stored currently in t.

এটি স্পষ্টতই বিভিন্ন চিহ্ন এবং আকারের সাথে আরও জটিল হয়ে ওঠে, তবে কেন্দ্রীয় ধারণাটি ধারণ করে। এটি কেবলমাত্র কাজ করে কারণ ডেটা কখনও প্রবাহিত হয় না বা বাম হয় না।

— BrainSteel
সূত্র

গল্ফিংয়ের অনেক সম্ভাবনা! শিরোলেখ পরিবর্তন করে শুরু fকরতে f(c,t,l)char*c,*t,*l(রিটার্ন টাইপ সম্পর্কে একটি বিষ্ঠা দিতে হবে না না)।

— FUZxxl

@FUZxxl কেউ আড্ডায় এটি উল্লেখ করেছেন, তবে আমি এটি কাজে লাগাতে পারিনি। এই আচরণ কি মান? এলএলভিএম সেই লাইনের সাথে কমপক্ষে 2 টি ত্রুটি ছুড়ে ফেলে।

— ব্রেইনস্টিল

দুঃখিত। হওয়া উচিত ছিল f(c,t,l)char*c,*t,*l;। সি 11 মোডে সংকলন করবেন না, যেহেতু অন্তর্নিহিত ইনট বিধি যা আমাদের রিটার্নের ধরণটি ফেলে দিতে দেয় সেই সংশোধনীতে বাদ দেওয়া হয়েছে।

— FUZxxl

@FUZxxl এটি C99 এও ব্যর্থ বলে মনে হচ্ছে। আসলে, আমি প্রতিটি মোড সংকলক সেট করেছি সেই কোডটিকে প্রত্যাখ্যান করেছে।

— ব্রেইনস্টিল

আপনি ঠিক পরে সেমিকোলন যুক্ত করেছেন *l? এটি আমার মেশিনে সি 99 মোডে সংকলন করে।

— FUZxxl

7

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

এই ফাংশনটি 10 টাইল ল্যাম্বদা ফাংশন তৈরি করে, তারপরে গ্রিড যদিও পুনরাবৃত্তি করে লজিকের অবস্থা আপডেট করে। চূড়ান্ত উল্লম্ব এবং অনুভূমিক যুক্তিযুক্ত রাজ্যগুলি তখন মুদ্রিত হয়।

def b(d,j,g):
 h=enumerate;e=dict((s[0],eval('lambda T,L:('+s[1:]+')'))for s in' 0,0#00,0#11,1#+L,T#\\T,L#UT,T#)L,L#!1-L,1-T#&T&L,T&L#|T|L,T|L#^T^L,T^L'.split('#'));j=list(j+'\n');g=list(g)
 for y,k in h(d.split('\n')):
  L=g[y]
  for x,c in h(k):T=j[x];L,B=e[c](int(T),int(L));j[x]=`B`
  g[y]=`L`
 print''.join(j+g)

পরীক্ষাগুলি সহ অব্যক্ত কোড:

def logic(grid, top, left):
    loop = enumerate;
    func = dict((s[0], eval('lambda T,L:('+s[1:]+')')) for s in ' 0,0#00,0#11,1#+L,T#\\T,L#UT,T#)L,L#!1-L,1-T#&T&L,T&L#|T|L,T|L#^T^L,T^L'.split('#'));
    top = list(top+'\n');
    left = list(left)
    for y,row in loop(grid.split('\n')):
        L = left[y]
        for x,cell in loop(row) :
            T = top[x];
            L, B = func[cell](int(T), int(L));
            top[x] = `B`
        left[y] = `L`
    print ''.join(top + left)

import re
testset = open('test.txt', 'rt').read().strip()
for test in testset.split('\n\n'):
    if test.endswith(':'):
        print '------------------\n'+test
    elif re.match('^[01/\n]+$', test, re.S):
        for run in test.split():
            top, left = run.split('/')
            print 'test', top, left
            logic(grid, top, left)
    else:
        grid = test

test.txt(Sp3000 2 অন্যান্য পরীক্ষা সহ) ফাইল:

Nand:

&!

00/0
00/1
10/0
10/1

All ones:

1111
1\+\
1+\+
1\+\

1001/1100

Xor from Nand (note the column of trailing spaces):

\)+\ 
U&!& 
+! ! 
\&!& 
   ! 

00000/00000
00000/10000
10000/00000
10000/10000

Half adder:

+))
U&+
U+^

000/000
000/100
100/000
100/100

Right shift:

\\\
\++
\++

001/110
010/101
101/100

পরীক্ষার ফলাফল:

------------------
Nand:
test 00 0
01
1
test 00 1
01
1
test 10 0
01
1
test 10 1
11
0
------------------
All ones:
test 1001 1100
1111
1111
------------------
Xor from Nand (note the column of trailing spaces):
test 00000 00000
00000
00000
test 00000 10000
00010
00000
test 10000 00000
00010
00000
test 10000 10000
00000
00000
------------------
Half adder:
test 000 000
000
000
test 000 100
001
101
test 100 000
101
001
test 100 100
110
110
------------------
Right shift:
test 001 110
000
111
test 010 101
101
010
test 101 100
010
110

— লজিক নাইট
সূত্র

7

পাইথন 2, 384 338 325 বাইট

def f(G,T,L):
 def g(x,y):
  if x>-1<y:l=g(x-1,y)[1];t=g(x,y-1)[0];r=l,t,1-l,0,0,1,t,l,l&t,l|t,l^t;i="+\\!0 1U)&|^".index(G[y*-~W+x]);return((t,l,1-t)+r[3:])[i],r[i]
  return(int((y<0)*T[x]or L[y]),)*2
 H=G.count("\n")+1;W=len(G)/H;return eval('"".join(map(str,[g(%s]for _ in range(%s)])),'*2%('_,H-1)[0','W','W-1,_)[1','H'))

সিরিয়াসলি সিএইচ, যদি এটি ইতিমধ্যে কোনও খেলনা না হয় তবে আপনার কিছু খেলনা কারখানার কাজ শুরু করা উচিত।

এখন আরও গল্ফড এবং আরও কম দক্ষ, তবে এখনও কার্পেট পাইথনে ধরা পড়েনি। ইনপুট লাইক f("1111\n1\\+\\\n1+\\+\n1\\+\\","0101","1010"), আউটপুট দুটি স্ট্রিং এর একটি tuple হয়। নিশ্চিত হয়ে নিন যে বোর্ডের পেছনের নতুন লাইন নেই, যা জিনিসগুলিকে ভেঙে দেবে।

পরীক্ষা প্রোগ্রাম

def f(G,T,L):
 def g(x,y):
  if x>-1<y:l=g(x-1,y)[1];t=g(x,y-1)[0];r=l,t,1-l,0,0,1,t,l,l&t,l|t,l^t;i="+\\!0 1U)&|^".index(G[y*-~W+x]);return((t,l,1-t)+r[3:])[i],r[i]
  return(int((y<0)*T[x]or L[y]),)*2
 H=G.count("\n")+1;W=len(G)/H;return eval('"".join(map(str,[g(%s]for _ in range(%s)])),'*2%('_,H-1)[0','W','W-1,_)[1','H'))


import itertools

G = r"""
+))
U&+
U+^
""".strip("\n")

def test(T, L):
    print f(G, T, L)

def test_all():
    W = len(G[0])
    H = len(G)

    for T in itertools.product([0, 1], repeat=len(G.split("\n")[0])):
        T = "".join(map(str, T))

        for L in itertools.product([0, 1], repeat=len(G.split("\n"))):
            L = "".join(map(str, L))

            print "[T = %s; L = %s]" % (T, L)
            test(T, L)
            print ""

test("000", "000")
test("000", "100")
test("100", "000")
test("100", "100")

আপনি সমস্ত সম্ভাব্য কেসগুলির সাথেও পরীক্ষা করতে পারেন test_all()।

অতিরিক্ত পরীক্ষার মামলা

অর্ধ সংযোজক

এখানে আধা সংযোজক যা আউটপুটটিংয়ে উপরের বাম বিটগুলি যুক্ত করে <input bit> <carry> <sum>:

+))
U&+
U+^

পরীক্ষা:

000 / 000  ->  000 / 000
000 / 100  ->  001 / 101
100 / 000  ->  101 / 001
100 / 100  ->  110 / 110

ইনপুটগুলির দ্বিতীয় / তৃতীয় বিটগুলি পরিবর্তন করা হলেও আউটপুট একই হওয়া উচিত।

ডান শিফট

দেওয়া হয়েছে abc / def, এই ফলাফলগুলি fab / cde:

\\\
\++
\++

পরীক্ষা:

001 / 110 -> 000 / 111
010 / 101 -> 101 / 010
101 / 100 -> 010 / 110

3 বিট বাছা

শীর্ষের প্রথম তিনটি বিট নীচের শেষ তিনটি বিটকে সাজায়। ডান আউটপুট জাঙ্ক হয়।

UUU)))
UU)U U
U&UU U
U+|&)U
\UU++|
 \)&UU
  \+|U
   UUU

পরীক্ষা:

000000 / 00000000 -> 000000 / 00000000
001000 / 00000000 -> 000001 / 11111111
010000 / 00000000 -> 000001 / 00001111
011000 / 00000000 -> 000011 / 11111111
100000 / 00000000 -> 000001 / 00001111
101000 / 00000000 -> 000011 / 11111111
110000 / 00000000 -> 000011 / 00001111
111000 / 00000000 -> 000111 / 11111111

2 বিট 2 বিট গুণক দ্বারা

প্রথম সংখ্যা হিসাবে শীর্ষের 1 ম / দ্বিতীয় বিট এবং দ্বিতীয় সংখ্যা হিসাবে শীর্ষের তৃতীয় / চতুর্থ বিট নেয়। নীচের শেষ চার বিট আউটপুট। ডান আউটপুট জাঙ্ক হয়।

UUUU))))
UU++)))&
UUU+)  U
UU++&))U
U++&+)^U
U)&\&)UU
   U+^UU
   \&UUU

সম্পাদনা করুন: কলাম এবং দুটি সারি গল্ফ করেছেন।

পরীক্ষা:

00000000 / 00000000 -> 00000000 / 00000000
00010000 / 00000000 -> 00000000 / 10000000
00100000 / 00000000 -> 00000000 / 00000000
00110000 / 00000000 -> 00000000 / 10000000
01000000 / 00000000 -> 00000000 / 00000000
01010000 / 00000000 -> 00000001 / 11111111
01100000 / 00000000 -> 00000010 / 00000000
01110000 / 00000000 -> 00000011 / 11111111
10000000 / 00000000 -> 00000000 / 00000000
10010000 / 00000000 -> 00000010 / 10000000
10100000 / 00000000 -> 00000100 / 00000000
10110000 / 00000000 -> 00000110 / 10000000
11000000 / 00000000 -> 00000000 / 00000000
11010000 / 00000000 -> 00000011 / 11111111
11100000 / 00000000 -> 00000110 / 00000000
11110000 / 00000000 -> 00001001 / 11111111

— Sp3000
সূত্র

1

আর, 524 517

এই মুহুর্তে এটি হ্রাস করার জন্য সম্ভবত প্রচুর জায়গা, তবে এটি করা সত্যিই আকর্ষণীয় হয়েছে। দুটি কাজ আছে। ফাংশন ডি কর্মী এবং চ এর তুলনামূলক।

ফাংশনটি 3 টি স্ট্রিং, গেটস, শীর্ষ এবং বামে ডাকা হয়। গেটগুলি প্রস্থ দ্বারা নির্ধারিত একটি ম্যাট্রিক্সে রাখা হয়।

I=strtoi;S=strsplit;m=matrix;f=function(L,T,G){O=I(c(0,1,L,T,!L,!T,L&T,L|T,xor(L,T)));X=which(S(' 01+\\U)!&|^','')[[1]]==G);M=m(c(1,1,1,2,1,1,3,2,2,4,3,4,5,4,3,6,4,4,7,3,3,8,5,6,9,7,7,10,8,8,11,9,9),nrow=3);return(c(O[M[2,X]],O[M[3,X]]))};d=function(G,U,L){W=nchar(U);H=nchar(L);U=c(list(I(S(U,'')[[1]])),rep(NA,H));L=c(list(I(S(L,'')[[1]])),rep(NA,W));G=m((S(G,'')[[1]]),nrow=W);for(i in 1:H)for(n in 1:W){X=f(L[[n]][i],U[[i]][n],G[n,i]);L[[n+1]][i]=X[1];U[[i+1]][n]=X[2]};cat(U[[H+1]],' / ',L[[W+1]],sep='',fill=T)}

কিছুটা ফরম্যাটেড

I=strtoi;S=strsplit;m=matrix;
f=function(L,T,G){
    O=I(c(0,1,L,T,!L,!T,L&T,L|T,xor(L,T)));
    X=which(S(' 01+\\U)!&|^','')[[1]]==G);
    M=m(c(1,1,1,2,1,1,3,2,2,4,3,4,5,4,3,6,4,4,7,3,3,8,5,6,9,7,7,10,8,8,11,9,9),nrow=3);
    return(c(O[M[2,X]],O[M[3,X]]))
};
d=function(G,U,L){
    W=nchar(U);H=nchar(L);
    U=c(list(I(S(U,'')[[1]])),rep(NA,H));
    L=c(list(I(S(L,'')[[1]])),rep(NA,W));
    G=m((S(G,'')[[1]]),nrow=W);
    for(i in 1:H)
        for(n in 1:W){
            X=f(L[[n]][i],U[[i]][n],G[n,i]);
            L[[n+1]][i]=X[1];
            U[[i+1]][n]=X[2]
        };
    cat(U[[H+1]],' / ',L[[W+1]],sep='',fill=T)
}

কিছু পরীক্ষা

> d('&!','00','0')
01 / 1
> d('&!','00','1')
01 / 1
> d('&!','10','0')
01 / 1
> d('&!','10','1')
11 / 0
> d('\\)+\\ U&!& +! ! \\&!&    ! ','00000','00000')
00000 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','00000','10000')
00010 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','10000','00000')
00010 / 00000
> d('\\)+\\ U&!& +! ! \\&!&    ! ','10000','10000')
00000 / 00000
> d('+++\\00000000000\\!!!!\\00000000000\\+++','000000000000','100')
000000000000 / 001
> d('+++\\00000000000\\!!!!\\00000000000\\+++','000000000000','000')
000000000000 / 000
> d('+))U&+U+^','000','000')
000 / 000
> d('+))U&+U+^','000','100')
001 / 101
> d('+))U&+U+^','100','000')
101 / 001
> d('+))U&+U+^','100','100')
110 / 110

— MickyT
সূত্র

গ্রিড ভিত্তিক ডিজিটাল লজিক (ডুডিয়াডিক টাইলস)

চ্যালেঞ্জ

বিস্তারিত

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

স্কোরিং

পাইথ, 122

গণিত, 331 276 270 267 264 262 252 250 বাইট

ব্যাখ্যা

ইনপুট প্রক্রিয়াজাতকরণ

গ্রিড সমাধান

আউটপুট প্রক্রিয়াজাতকরণ

সি, 332 309 272 270 266 259 247 225 বাইট

একটি সংক্ষিপ্ত ব্যাখ্যা:

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

পাইথন 2, 384 338 325 বাইট

পরীক্ষা প্রোগ্রাম

অতিরিক্ত পরীক্ষার মামলা

অর্ধ সংযোজক

ডান শিফট

3 বিট বাছা

2 বিট 2 বিট গুণক দ্বারা

আর, 524 517