46

4x2 ব্লকগুলিতে একটি বুলিয়ান ম্যাট্রিক্স কেটে তাদের ব্রেইল অক্ষর হিসাবে রেন্ডার U+2800... U+28FF।

[[0,1,0,0,1,0],
 [1,0,0,0,0,0],
 [1,0,0,0,1,0],
 [1,1,1,1,0,0]]

⣎⣀⠅

মাত্রা 4 এবং 2 এর গুণক না হলে 0-s সহ প্যাড।

[[0,1,0],
 [1,0,0],
 [1,1,1]]

⠮⠄

সাধারণ গল্ফিং বিধিগুলি প্রয়োগ হয়, ইনপুট ফর্ম্যাটে নমনীয়। আউটপুটে হয় ম্যাট্রিক্সের কাঠামো থাকতে হবে বা ম্যাট্রিক্সের মতো দেখতে হবে, যেমন স্ট্রিংগুলির তালিকা; নতুন লাইনের সাথে একক স্ট্রিং।

ইঙ্গিত: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)ডট প্যাটার্ন

b0 b3
b1 b4
b2 b5
b6 b7

আরও বড় পরীক্ষা:

[[0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0],
 [0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1],
 [0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1],
 [1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1],
 [1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0],
 [1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0],
 [1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0],
 [1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1],
 [1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0],
 [1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0],
 [0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
 [0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0],
 [0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0]]

⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀

— ngn
সূত্র

দ্বিতীয় চ্যালেঞ্জের জন্য অভিনন্দন।

— অ্যাডাম

5

আরও ভাল বিবরণ: আপনার কাছে বুলিয়ান মানগুলির 2D অ্যারে রয়েছে যার সারিগুলিতে একটি কালো-সাদা (পিক্সেলের 1 বিট প্রতি ফ্রেম) বাফার বা গ্রাফিক্স ক্যানভাসের অনুভূমিক রাস্টার লাইনগুলি উপস্থাপিত হয়। এই ক্যানভাসের 4x2 আয়তক্ষেত্রাকার সমস্ত ব্লককে ইউনিকোড ব্রেইল অক্ষরে এনকোড করুন। প্রান্তে ভগ্নাংশের ব্লকগুলি পরিচালনা করতে ক্যানভাসের প্রস্থকে 2 এর একাধিক, এবং উচ্চতা চারটি একের সাথে জিরো দিয়ে প্যাড করুন (বা অন্যথায় সমতুল্য আউটপুটটি নিশ্চিত করুন, উপাত্তকে এতটা প্যাড করা হয়েছে এমন আচরণ করে)।

— কাজ

3

@ কাজ আমি জানি না, আমি ব্যক্তিগতভাবে এই পোস্টটি কতটা সংক্ষিপ্ত তা প্রশংসা করি। আইএমও, আরও কোনও লিখনের মাধ্যমে খুব বেশি স্পষ্টতা যুক্ত করা হবে না (কয়েকটি ছোট ছোট স্পষ্টতা ছাড়াও যে উচ্চতা 4 এর একটি সংখ্যা এবং 2 প্রস্থের হওয়া উচিত); আপনার পরামর্শটি বর্তমান পোস্টের চেয়ে পড়া আমার পক্ষে শক্ত।

— কোয়েলক্লেফ

10

জেলি , 31 30 বাইট

sz0Z
ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY

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

কিভাবে?

sz0Z - Link 1, split & right-pad with zeros: list, items; number, chunkSize
s    - split items into chunks of length chunkSize
 z0  - transpose with filler zero
   Z - transpose

ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY - Main link: list of lists of numbers (1s & 0s), M
ç€2                       - call the last link (1) as a dyad for €ach (left=M, right=2)
                          -  ((left,right) bits read left-right then top-bottom)
   Z                      - transpose the resulting list of lists of lists
                          -  ((left, right) bits read top-bottom then left-right)
    F€                    - flatten €ach
      ç€8                 - call the last link (1) as a dyad for €ach (left=^, right=8)
         Z                - transpose the resulting list of lists of lists
                          -  ("blocks" each and all read left-right top-to bottom)
               -36        - literal -36
             €€           - for €ach (block-wise row) for €ach (block)
          œ?@             -   lexicographical permutation with reversed arguments
                          -    (get the permutation at index -36 (modular) in a list of
                          -     all permutations of the indexes sorted lexicographically.
                          -     That is the 8!-36 = 40284th - equivalently the values at
                          -     indexes [8,7,6,4,2,5,3,1])
                  Ḅ       - convert from binary list to integer (vectorises)
                    ⁽$ṁ   - base 250 literal = 10240
                   +      - add
                       Ọ  - cast to character (vectorises)
                        Y - join with newlines
                          - implicit print

— জোনাথন অ্যালান
সূত্র

কি Ḅসমর্থন "ডিজিট" 1 চেয়ে বড়? ফলাফলটিতে 10240 (0x2800 - দুই বাইট) যুক্ত করার পরিবর্তে আপনি বাইনারি অঙ্কের ভেক্টরে 40 (0x28 - এক বাইট) প্রেন্ডেন্ড করতে পারেন। আমি জেলি সম্পর্কে খুব বেশি জানি না, তাই আমি নিশ্চিত নই যে এটি সত্যিই কাজ করবে কিনা।

— ngn

Ḅআপনার প্রস্তাব অনুসারে প্রকৃতপক্ষে 40 এর একটি শীর্ষস্থানীয় অঙ্কটি রূপান্তর করবে, তবে আমাদের এটিকে প্রতিটি তালিকাতে (2 গভীরতার সাথে) প্রিপেন্ড করা দরকার যা আমার মনে হয়, কোডের আরও বাইট লাগবে ( ;@€€40Ḅ)।

— জোনাথন অ্যালান

6

জাভাস্ক্রিপ্ট ES7 210 207 201 200 198 194 185 183 বাইট

a=>eval('for(y=0,c="";A=a[y];y+=4,c+=`\n`)for(x=0;A[x]+1;x+=2)c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(X,Y=3)=>(a[Y+y]||0)[X+x]|0)(k>2,k%3)*2**k")|g(0)+g(1)*2<<6)')

4 বাইট সংরক্ষিত ধন্যবাদ এনএনজি থেকে

3 বাইট লুকের জন্য ধন্যবাদ সংরক্ষণ করেছে

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

আমি কোডটি অংশগুলিতে বিভক্ত করতে যাচ্ছি এবং সেগুলি সম্পর্কে আলাদাভাবে কথা বলতে চাই:

for(y=x=0, c=""; a[y]; x+=2)
    !((a[y] || [])[x]+1) && (y+=4,x=0,c+=`\n`)

এখানেই প্রতিটি পরিবর্তনশীল ঘোষিত হয়। xএবং yএটি "কার্সর" (বর্তমান ব্রেইল অক্ষরের উপরের বাম প্রান্ত) এর অবস্থান। এক্স কোডিনেট্ট প্রতি পুনরাবৃত্তিতে 2 দ্বারা বৃদ্ধি পায় এবং এটি থেমে যায়, যখন সূচকের সাথে কোনও সারি না থাকে y(এ [এক্স] undefinedযদি এটি উপস্থিত না থাকে তবে ফিরে আসে , যা মিথ্যাতে রূপান্তরিত হয়)।

দ্বিতীয় সারিতে একাধিক কৌশল রয়েছে। (a[y] || [])[x]স্থিতিতে মানটি অনুসন্ধান করা (x, y)ত্রুটি ছুঁড়ে না তা নিশ্চিত করে ures &&স্বাভাবিক এবং অপারেটর, এবং এটা শুধুমাত্র প্রকাশের ডান দিকে রুদ্ধ করার প্রচেষ্টায় যদি বাম সত্য ছিল। এটি অনুবাদ করা যেতে পারে

if (!((a[y] || [])[x] + 1)) 
    y+=4,x=0,c+=`\n`

পরবর্তী অংশ:

c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k,N")+g(x,y+3)*64+g(x+1,y+3)*128)

String.fromCharCodeপাস করা সংখ্যাটিকে একই অক্ষর কোডের সাথে একটি ইউনিকোড অক্ষরে রূপান্তরিত করে। প্রথম বন্ধনীর মধ্যে প্রকাশটি ব্রেইল অক্ষরের সূচি গণনা করে:

for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k

অবস্থানের মধ্য দিয়ে যায়

1 4
2 5
3 6

ক্রম করুন, সেই অবস্থানগুলিতে 2 ⁱ দিয়ে মানগুলি গুণিত করুন যেখানে আমি সূচক এবং সেগুলি একসাথে যুক্ত করি। দ্য

g=(x,y)=>(a[y]||[])[x]||0

অংশটি একটি ল্যাম্বডা ফাংশন বলে g, যা একটি xএবং yস্থানাঙ্ক প্রদান করে (x, y)অবস্থানের মান বা 0 প্রদান করে যদি অবস্থানটি অ্যারের সীমানার বাইরে থাকে।

+g(x,y+3)*64+g(x+1,y+3)*128

এই অংশটি সামান্য আগে সংজ্ঞায়িত ফাংশনটি ব্যবহার করে সঠিক ওজন সহ শেষ দুটি অবস্থান যুক্ত করেছে।

সর্বশেষ কিন্তু কমপক্ষে না,

a=>eval('...')

অংশ 2 ফাংশন আছে। এটি একটি বেনাম ল্যাম্বডাকে সংজ্ঞায়িত করে এবং নিশ্চিত করে যে লুপের জন্য কোনও সমস্যা হয় না (একক লাইন ল্যাম্বদা যেমন এটি কেবল লুপের জন্য একটিও থাকতে পারে না, একটি মূল্যায়ন এটিকে পরিস্কার করে)।

— Bálint
সূত্র

কয়েকটি সহজ পরামর্শ: ||0-> |0; ~~(k/3)-> (k>2); *128-> <<7( +-s এর সাথে |-s প্রতিস্থাপন )

— ngn

আপনার প্রাথমিক সমাধান হিসাবে কেন ES7 সংস্করণ জমা করবেন না?

— শেগি

@ শেগি সবাই ইএস 7 চালাতে পারেন না, তাই এটি ব্যাকআপ

— বেলিন্ট

এটি অপ্রাসঙ্গিক 'এই অংশগুলির চারপাশে;) যতক্ষণ না একটি, একক দোভাষী (ব্রাউজার) রয়েছে যা আপনার কোডটি সঠিকভাবে চালাতে পারে, এটি এখানে বৈধ হিসাবে বিবেচিত হবে।

— শেগি

@ জিএনএন প্রথম দু'জনের জন্য ধন্যবাদ, তবে কিছুটা বদলানো মূলত যে কোনও কিছু থেকে কম অগ্রাধিকার পেয়েছে, তাই এটি কার্যকর হবে না

— বুলিন্ট

6

গণিত, 126 110 97 90

FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

এই দ্রষ্টব্যটি ম্যাট্রিক্সের উপর একটি (বিপরীত) কার্নেলকে সঙ্কলন ListCorrelate করার সুবিধা গ্রহণ করে যা মূলত একটি স্লাইডিং ম্যাট্রিক্স গুণ (বা ডট পণ্য)) এখানে একটি চাক্ষুষ ব্যাখ্যা দেখুন । প্যাডিং চতুর্থ আর্গুমেন্ট হিসাবে ব্যবহার করে করা হয়। নিম্নলিখিত উদাহরণে, আমরা ফলাফলটি উপরের ইঙ্গিতটির সাথে মেলে আশা করি:0

ListCorrelate[
  2^{{0, 3}, {1, 4}, {2, 5}, {6, 7}},
  {{b0, b3}, {b1, b4}, {b2, b5}, {b6, b7}}
]

(* returns {{b0 + 2 b1 + 4 b2 + 8 b3 + 16 b4 + 32 b5 + 64 b6 + 128 b7}} *)

নোটটি ListConvolveকোনও সংক্ষিপ্ত নয়, যেহেতু তৃতীয় যুক্তি হবে -1।

যেহেতু এটি ম্যাট্রিক্সের প্রতিটি অবস্থাতে কার্নেলটি প্রয়োগ করে, তাই আমাদের কেবল প্রতিটি চতুর্থ সারিতে এবং দ্বিতীয় কলামে উপাদানগুলি বের করতে হবে। আমরা shorthands ব্যবহার Spanএবং Part: [[;;;;4,;;;;2]]।

সহায়কভাবে, FromCharacterCodeঅক্ষর কোডের একটি ম্যাট্রিক্স নিতে পারে এবং স্ট্রিংগুলির একটি তালিকা ফিরে আসতে পারে।

এই সমাধানটি স্ট্রিংগুলির একটি তালিকা ফেরত দেয়, যা অনুমোদিত আউটপুট বিন্যাসগুলির মধ্যে একটি। Column@"ম্যাট্রিক্সের মতো দেখতে" আউটপুটটির জন্য কেবল প্রিপেন্ড করুন ।

আপনি এটি নিখরচায় একটি অনলাইন অনলাইন ম্যাথমেটিকা নোটবুকে খেলতে পারেন। এখানে যান , একটি নতুন নোটবুক তৈরি করুন ক্লিক করুন, একটি মুহুর্ত অপেক্ষা করুন, এই কোডটিতে পেস্ট করুন, তারপরে টিপুন shift+enter।

m1={{0,1,0,0,1,0},{1,0,0,0,0,0},{1,0,0,0,1,0},{1,1,1,1,0,0}};
m2={{0,1,0},{1,0,0},{1,1,1}};
m3={{0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0},{0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1},{0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1},{1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1},{1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0},{1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0},{1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0},{1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1},{1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0},{1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0},{0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},{0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0},{0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0}};

MatrixToBraille := Column@
  FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

MatrixToBraille/@{m1,m2,m3}

তারপরে আপনার এটি দেখতে হবে:

— hftf
সূত্র

5

ডায়ালগ এপিএল, 133 122 114 112 101 100 98 95 94 93 90 88 86 বাইট

অনুমান ⎕IO←0

{C⍴{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨(,b)/,⍳⍴b←{0 0≡A|⍵}¨⍳⍴S←⍵↑⍨A×C←⌈(⍴⍵)÷A←4 2}

- 8 9 12 বাইট চ্যাটে @ অ্যাডমকে ধন্যবাদ

-২ বাইটস @ জিএনএনকে ধন্যবাদ

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

কিভাবে (ইনপুট হয় `⍵`)?

A←4 2ভেক্টরটি 4 2ভেরিয়েবলে সংরক্ষণ করুনA
(⍴⍵)÷⍵দ্বারা বিভক্ত মাত্রাA
⌈, সিলিং
C←, সঞ্চিত C
A×, দ্বারা গুণিত A
⍵↑⍨, ⍵সেই মাত্রাগুলির সাথে মানানসই
S←, সঞ্চিত S
⍳⍴এর সূচী S
{0 0≡A|⍵}¨, 1যেখানে ঘরের উপরের 0বামটি অন্য কোথাও
(,b)/,⍳⍴b←, সত্যবাদী সূচি
{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, প্রতিটি উপাদানকে ব্রেলে পরিণত করুন
C⍴, মাত্রা পুনরায় আকার C

— Zachary
সূত্র

বিবেচনা করুন +/(2*0 3 1,A,4+⍳3)×something→2⊥something[⍎¨⍕76524130]

— ngn

আমি এখন এটি বদলেছি তা কি এখনও কাজ করবে ⎕IO←0?

— জাকারি

প্রকৃতপক্ষে, এটি কেবল এতে কাজ করবে ⎕IO←0:)

— ngn

আমি চেষ্টা করেছিলাম, আমি কি কিছু ভুল করছি? tio.run/…

— জাকারি

দুঃখিত, আমি এপিএলে এই বোকা জিনিস ( ⎕IO) সম্পর্কে ভুলে গেছি । জন্য ⎕IO←1, অবশ্যই আপনি 76524130. প্রতিটি অঙ্ক 1 যোগ আছে চাই

— ngn

4

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

a=>(b=a.map(x=>[]),a.map((l,i)=>l.map((c,j)=>b[i>>2][j>>1]|=c<<'01263457'[i%4+j*4%8])),b.map(l=>l.map(c=>String.fromCharCode(10240+c))))

Ngn ধন্যবাদ , বিট শিফট ব্যবহার করে 4 বাইট সংরক্ষণ করুন।

— TSH
সূত্র

আপনি বিট শিফটগুলি ব্যবহার করতে পারেন i/4|0->i>>2

— এনজিএন

c*2**কিছুটা

— শিফটও

4

পাইথন 2 + ড্রিল , 141 125 120 116 বাইট

এনজিএন এবং এল 3 জিয়াথনকে 16 বাইট সংরক্ষণ করা হয়েছে

L3viathan ধন্যবাদ 5 বাইট সংরক্ষণ করা

এনজিএনকে 4 বাইট সংরক্ষণ করা হয়েছে

from drawille import*
def a(d,c=Canvas(),e=enumerate):[c.set(j,i)for i,x in e(d)for j,y in e(x)if y];print c.frame()

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

টিওতে ড্রিল ইনস্টল নেই তাই এটি কাজ করে না

— Noskcaj
সূত্র

পাইথন ও এর ব্যাটারি! :) আমাকে অবাক করতে ব্যর্থ হয় না। আপনি যদি 120 টি বাইটের নীচে ব্যবহার করেন enumerate()এবং তালিকা বোধগম্য হন তবে আপনি এটি সঙ্কুচিত করতে পারেন ।

— ngn

ফাংশনটিকে ওয়ান লাইনার করে def b(d,c=l.Canvas()):print([c.set(j,i)for i,x in enumerate(d)for j,y in enumerate(x)if y]and c).frame()

— কয়েকটা

এটি 120 বাইটে পেয়েছেন

— L3viathan

আপনার and cকৌতূহলের দরকার নেই - বোধগম্যতা তার নিজের দ্বারা একটি বিবৃতি হতে পারে;print c.frame()

— ngn

3

এপিএল (ডায়ালগ) , 57 54 বাইট *

-3 ওপিকে ধন্যবাদ। বুলিয়ান ম্যাট্রিক্সের জন্য অনুরোধ জানানো হয়। অক্ষর ম্যাট্রিক্স মুদ্রণ।

1↓⎕UCS{2⊥40,⌽(,⍉3↑⍵),⊢⌿⍵}⌺(2 2⍴4 2)⊢0⍪⍣3⍪∘0⍣3⊢⎕,0

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

⎕,0 ডানদিকে একটি শূন্য যুক্ত করুন (কলামের সংখ্যা এমনকি যদি উপেক্ষা করা হয়)

⊢ ফলন যে (পৃথক 3এবং ⎕)

⍪∘0⍣3 নীচে তিনবার জিরো যুক্ত করুন (কারণ ⌺আংশিক উইন্ডো ড্রপ হয়)

0⍪⍣3 তিনবার শীর্ষে জিরোস স্ট্যাক করুন (কারণ ⌺উপরের বাম কোণায় শুরু হয়)

⊢ ফলন যে (প্রথম বন্ধনী এবং পৃথক 0)

{… }⌺(2 2⍴4 2) 4-সারির উল্লম্ব এবং 2 সারি অনুভূমিক পদক্ষেপ সহ প্রতিটি 4-সারি 2-কলাম উইন্ডোতে:

⊢⌿⍵ শেষ সারি (lit। উল্লম্ব ডান হ্রাস); [b6,b7]

(… ), প্রিপেন্ড:

3↑ তিনটি সারি নিন; [[b0,b3],[b1,b4],[b2,b5]]

⍉ জায়গা বদল করুন; [[b0,b1,b2],[b3,b4,b5]]

, জটিল করে তোলা; [b0,b1,b2,b3,b4,b5]

এখন আমাদের আছে [b0,b1,b2,b3,b4,b5,b6,b7]

⌽ বিপরীত; [b7,b6,b5,b4,b3,b2,b1,b0]

40, 40 প্রিপেন্ড করুন (40 × 2 ⁹ = 10240 এর জন্য);[40,b7,b6,b5,b4,b3,b2,b1,b0]

2⊥ বেস -২ (বাইনারি) হিসাবে মূল্যায়ন

⎕UCS চরিত্রে রূপান্তর করুন

1↓ প্রথম সারিটি ড্রপ করুন ( ⌺প্যাডিংয়ের কারণে অল-শূন্য )

ক্লাসিক ⌺হিসাবে , হিসাবে গণনা ⎕U233A।

— আদম
সূত্র

কয়েকটি বাইট সংরক্ষণের একটি সহজ উপায় আছে, জেলি সমাধানের অধীনে আমার মন্তব্য দেখুন।

— এনজিএন

একটি ভুল হতে হবে - টিআইও লিঙ্কটি আপনার এখানে পোস্ট করা কোডের সাথে মেলে না।

— এনজিএন

এটি শেষের কাছে শূন্য-প্যাডিং কোড: 0⍪⍣3⍪∘0⍣3⊢⎕,0বনাম0⍪∘0⍣3⊢⎕,0

— এনজিএন

ফিক্সড @ngn, কিন্তু আমি এমন একটি অনুভূতি আছে ⍪∘0⍣3এবং ,0একটি বাগ কারণে শুধুমাত্র প্রয়োজন হয় ⌺, এবং প্রথম একটিতে আপনার পরীক্ষার বিষয় জন্য প্রয়োজন হয় না।

— অ্যাডম

আমার পরীক্ষার কেসগুলি সম্পূর্ণ নয় - সমাধানটি অবশ্যই কোনও বৈধ ইনপুটটির জন্য কাজ করা উচিত। আপনি সংক্ষিপ্ত 0⍪⍣3⍪∘0⍣3⊢⍵,0করতে পারেন 0(⊖⍪)⍣6⊢⍵,0।

— এনজিএন

2

পাইথন 3 , 168 165 161 বাইট

def f(m):
 while m:
  r,m,s=[*zip(*m)],m[4:],''
  while r:s+=chr(10240+sum(q<<int(w)for(q,w)in zip((r[0]+(0,)*3)[:4]+(r+[()])[1],'01263457')));r=r[2:]
  print(s)

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

— TFeld
সূত্র

দারুণভাবে গল্ফ! [*zip(*m[:4])]কল করার পরিবর্তে আপনি তিনটি বাইট সংরক্ষণ করতে পারেন list।

— লিন

2

হাস্কেল , 145 বাইট

(a!b)c=take b$c++repeat a
r([]:_)=[]
r l=['⠀'..]!!(sum.zipWith(*)[1,8,2,16,4,32,64,128]$l>>=0!2):r(drop 2<$>l)
b[]=[]
b s=r(([]!4)s):b(drop 4s)

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

— Angs
সূত্র

1

পাইথন 3 , 169 বাইট

a=[]
y=0
for l in eval(input()):
 y-=1;a+=y%4//3*[-~len(l)//2*[10240]];x=0
 for v in l:a[-1][x//2]|=v<<(6429374>>y%4*6+x%2*3&7);x+=1
for l in a:print(*map(chr,l),sep='')

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

— লিন
সূত্র

আপনি পুনর্লিখন করতে if y%4<1:a+=-~len(l)//2*[10240],যেমন a+=(y%4<1)*[-~len(l)//2*[10240]]এবং মাপসই x=0;y+=1একই লাইনে। আমি মনে করি এটি একটি বাইট সংরক্ষণ করে।

— ngn

@ngn সেখান থেকে আরও কয়েকটি বাইট সংরক্ষণ করেছে, আপনাকে ধন্যবাদ!

— লিন

1

পার্ল 5 , 164 বাইট

163 বাইট কোডের +1 পতাকা -p

@a=eval}{for(;$r<@a;$r+=4){for($c=0;$c<@{$a[0]};$c+=2){$n="0b";map$n.=0|$a[$r+3][$c+$_],1,0;for$y(1,0){map$n.=0|$a[$r+$_][$c+$y],2,1,0}$\.=chr 0x2800+oct$n}$\.=$/}

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

প্রতিটি সারিতে কমা এক লাইনে পৃথক করে।

— Xcali
সূত্র

1

এপিএল (ডায়ালগ) , 53 বাইট

4 2∘{⎕ucs 2⊥40⍪(⍎¨⍕76531420)∘.⊃,¨⍺∘↑¨↓∘⍵¨⍺∘×¨⍳⌈⍺÷⍨⍴⍵}

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

— ngn
সূত্র

ব্রেইল গ্রাফিক্স

জেলি , 31 30 বাইট

কিভাবে?

জাভাস্ক্রিপ্ট ES7 210 207 201 200 198 194 185 183 বাইট

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

গণিত, 126 110 97 90

ডায়ালগ এপিএল, 133 122 114 112 101 100 98 95 94 93 90 88 86 বাইট

কিভাবে (ইনপুট হয় ⍵)?

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

পাইথন 2 + ড্রিল , 141 125 120 116 বাইট

এপিএল (ডায়ালগ) , 57 54 বাইট *

পাইথন 3 , 168 165 161 বাইট

হাস্কেল , 145 বাইট

পাইথন 3 , 169 বাইট

পার্ল 5 , 164 বাইট

এপিএল (ডায়ালগ) , 53 বাইট

কিভাবে (ইনপুট হয় `⍵`)?