সরলকরণ ম্যাট্রিক্স ইনপুট!


20

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

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1

এটি সম্ভবত অনেক ভাষায় একটি জটিল বিন্যাস।


চ্যালেঞ্জ:

একটি প্রোগ্রাম / ফাংশন লিখুন যা ইনপুট হিসাবে শীর্ষে দেওয়া ফর্মটিতে একটি ম্যাট্রিক্স নিতে পারে (এই পোস্ট থেকে সরাসরি অনুলিপি / আটকানো), এবং নীচে দেখানো তিনটি প্রচলিত ফর্ম্যাটের সমস্তটিতে একই ম্যাট্রিক্স আউটপুট

ইনপুট ফর্ম্যাট:

স্থানগুলিতে বিবিধ সংখ্যার দ্বারা পৃথক করা নম্বর এবং সারিগুলি উপস্থাপনের জন্য নিউলাইনগুলি (পরীক্ষার কেস দেখুন)।

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

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

স্পষ্ট করার জন্য: ধরে নিন আপনার ফাংশন / প্রোগ্রামটি কল করা হয়েছে fএবং ম্যাট্রিক্সটি হ'ল:

1 -2
3  5
6  7

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

f(1 -2
3  5
6  7)

f([1 -2
3  5
6  7])

f("""1 -2
3  5
6  7""")

যদি আপনার ভাষা, কোনওভাবেই অনুলিপি হিসাবে অনুলিপি / পেস্ট করা ম্যাট্রিক্স না নিতে পারে তবে আমি ভয় করি যে আপনাকে অন্য কোনও ভাষা বেছে নিতে হবে।


আউটপুট ফর্ম্যাট:

আপনাকে নিম্নলিখিত তিনটি ফর্ম্যাটে ম্যাট্রিক্স আউটপুট করা উচিত (অর্ডার কোনও ব্যাপার নয়):

[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]
  • আপনি চাইলে তিনটি আউটপুট আলাদা করতে পারেন (যেমন একটি নিউলাইন)
  • আপনাকে ইনপুট হিসাবে একই নির্ভুলতা ব্যবহার করে সংখ্যাগুলি আউটপুট করতে হবে (উদাহরণস্বরূপ, আপনাকে অবশ্যই দশমিকের সংখ্যা ছাঁটাইতে হবে না, আউটপুট পূর্ণসংখ্যাকেও ফ্লোট হিসাবে চিহ্নিত করতে হবে না)।
  • স্পেসগুলি বাধ্যতামূলক
  • আপনাকে অবশ্যই -নেতিবাচক সংখ্যার জন্য ব্যবহার করতে হবে , না _বা অনুরূপ।

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

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1
----
[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]

0.14778   0.27114   0.24415
0.45997   0.12287   0.67470
0.28945   0.37928   0.51887
----
[[0.14778, 0.27114, 0.24415], [0.45997, 0.12287, 0.6747], [0.28945, 0.37928, 0.51887]]
{{0.14778, 0.27114, 0.24415}, {0.45997, 0.12287, 0.6747}, {0.28945, 0.37928, 0.51887}}
[0.14778, 0.27114, 0.24415; 0.45997, 0.12287, 0.6747; 0.28945, 0.37928, 0.51887]

-0.0398301   0.2403455  -0.2253368   0.3565870   0.0605803   0.0830780
-0.3254422  -0.1185191  -0.2989537   0.1647319   0.3621135   0.2018815
-0.0022281  -0.3362287  -0.3568447   0.4419063   0.3801872  -0.2847033
---
[[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780], [-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815], [-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033],]
{{-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780}, {-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815}, {-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033},}
[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780; -0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815; -0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033]

0       4       1       0
0       0      -6       0
0       1       4      -3
2       0       0       8
0       0       0       0
----
[[0, 4, 1, 0], [0, 0, -6, 0], [0, 1, 4, -3], [2, 0, 0, 8], [0, 0, 0, 0]]
{{0, 4, 1, 0}, {0, 0, -6, 0}, {0, 1, 4, -3}, {2, 0, 0, 8}, {0, 0, 0, 0}}
[0, 4, 1, 0; 0, 0, -6, 0; 0, 1, 4, -3; 2, 0, 0, 8; 0, 0, 0, 0]

1
----
[1]     (or [[1]])
{1}     (or {{1}})
[1]     (or 1)

1 2
----
[1, 2]  (or [[1, 2]])
{1, 2}  (or {{1, 2}})
[1, 2]

4
5
----
[[4], [5]]
{{4}, {5}}
[4; 5]

আমি পুরোপুরি সচেতন আছি এই , কিন্তু এই প্রতিদ্বন্দ্বিতায়, কষ্টকর, I / O বিন্যাস পুরো বিন্দু। কিছু ভাষাতে আউটপুট ফর্ম্যাট করা সম্পর্কে চ্যালেঞ্জটি হ'ল, অন্য ইনপুট পড়ার সময় অন্য ভাষাগুলির মধ্যে সবচেয়ে শক্ত অংশ হবে।

যদি ইনপুটটি পড়া শক্ত হয় তবে নিরুৎসাহিত হবেন না, সেগুলি জমা দেওয়া সবচেয়ে মজার বিষয় হতে পারে। সংক্ষিপ্তটি অবশ্যই চিত্তাকর্ষক হিসাবে একই নয়। এবং সর্বদা হিসাবে, ব্যাখ্যা উত্সাহিত করা হয়!

উত্তর:


7

রেটিনা , 52 বাইট

এই উত্তরটি আমার পার্ল উত্তরের উপর ভিত্তি করে রেটিনার সাথে গল্ফ করার জন্য মার্টিন ইন্ডারের সহায়তায় ।

^ *
[
$
]
\s+
, 
m):`.+
[$&]
*T`[]`{}
], .
; 
^.|]$

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

আমার পার্ল উত্তরের ব্যাখ্যাটি পাওয়া যাবে। পার্থক্যগুলি হ'ল:

*
[
$
]

s/^ *(.+)/[$1]/gmউভয় পরিবর্তে নেতৃস্থানীয় স্পেসগুলি সরান এবং লাইনের চারপাশে বন্ধনী যুক্ত করুন।

^.|]$

তৃতীয় আউটপুট জন্য নেতৃস্থানীয় এবং অনুসরণযোগ্য বন্ধনী অপসারণ।


6

রেটিনা , 57 54 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

m`^ +

¶
] [
 +
, 
:`.+
[[$&]]
*T`[]`{}
], .
; 
^.|]$

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

টিআইও লিঙ্কটি বর্তমানে তিনটি বিন্যাসের মধ্যে কোনও লাইনফিড মুদ্রণ করে না কারণ এটি অস্থির প্রতিশ্রুতি ব্যবহার করে। প্রোগ্রামটি রেটিনা 0.8.2 তে মধ্যবর্তী লাইনফিডগুলি মুদ্রণ করবে।

ব্যাখ্যা

m`^ +

প্রতিটি লাইনে শীর্ষস্থানীয় স্থান থেকে মুক্তি পান।

¶
] [

এর সাথে লাইনফিডগুলি প্রতিস্থাপন করুন ] [

 +
, 

কমা এবং একটি স্থান দিয়ে সমস্ত রান স্পেস প্রতিস্থাপন করুন।

:`.+
[[$&]]

পুরো জিনিসটি মুড়ে দিন [[...]]যাতে প্রথম ফর্ম্যাটটি সম্পূর্ণ হয়। ফলাফল মুদ্রণ করুন।

*T`[]`{}

বন্ধনীগুলির সাহায্যে বন্ধনীগুলি প্রতিস্থাপন করুন এবং কার্যকারী স্ট্রিংটি পরিবর্তন না করেই ফলাফল মুদ্রণ করুন (এটি প্রথম মুদ্রণের পরে এটি পুনরুদ্ধার করা হবে)।

], .
; 

], [একটি সেমিকোলন এবং একটি লাইনফিড দিয়ে প্রতিস্থাপন করুন ।

^.|]$

প্রথম [এবং শেষ অপসারণ করুন ]। এটি তৃতীয় ফর্ম্যাটটি সম্পূর্ণ করে।


5

স্কালা, 183 181 149 বাইট

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

নতুন সংস্করণ, Stringপ্রতিস্থাপন এবং রেজিক্সগুলি ব্যবহার করে :

(x:String)=>{val d=x.replaceAll("\n *","; ").replaceAll("(?<!;) +",", ");(s"[[${d.replace("; ","], [")}]]",s"{{${d.replace("; ","}, {")}}}",s"[$d]")}

নতুন সংস্করণ একই শব্দার্থবিদ্যা এবং পুরানো সংস্করণ হিসেবে ব্যবহার ব্যবহার হয়েছে split, mapএবং mkString

পুরানো সংস্করণ ব্যবহার split, mapএবং mkString:

সম্পাদনা করুন: স্থানের জন্য অপ্রয়োজনীয় চরিত্রের শ্রেণি সরানো হয়েছে

(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

ল্যামডা। REPL এ কার্যকর করুন। ট্রিপল-কোটেড Stringপ্যারামিটার হিসাবে ইনপুট গ্রহণ করে, প্রয়োজনীয় আউটপুটগুলির 3-টিপল হিসাবে আউটপুট ফেরত দেয়। আরএপিএল কন্ঠস্বর দ্বারা সীমান্তে কমা দ্বারা বিচ্ছিন্নভাবে রেকর্ডারকে রেন্ডার করে।

ব্যাখ্যা:

নতুন সংস্করণ:

লাইনগুলিতে শীর্ষস্থানীয় স্পেসগুলি পরিচালনা করতে কৌতূহলপূর্ণ চেহারা ব্যতীত অন্যান্য রেজেক্স-ভিত্তিক উত্তরের মতো প্রায়শই একই যুক্তি।

পুরাতন রুপ:

আমরা ইনপুট ম্যাট্রিক্স উপস্থাপনাটিকে 2D Stringঅ্যারে বিভক্ত করি , তারপরে উপাদানগুলি পৃথক করে অভ্যন্তরীণ অ্যারেগুলি ভেঙে 1D অ্যারে এটিকে ম্যাপ করি ,। অবশেষে, আমরা কেবল প্রয়োজনীয় নিউলাইন বিভাজক এবং সীমানা চিহ্নিতকারী (উপসর্গ এবং প্রত্যয়) ব্যবহার করে 1 ডি অ্যারেগুলি ভেঙে বিভিন্ন আউটপুট তৈরি করি। এগুলি সবই split(পড়া), map(রূপান্তরকরণ) এবং mkString(ধসে পড়া) মাধ্যমে প্রয়োগ করা হয়েছে ।

REPL অধিবেশন উদাহরণ:

scala> val r=(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

scala> r("""16    2    3   13
     |  5   11   10    8
     |  9    7    6   12
     |  4   14   15    1""")
res12: (String, String, String) = ([[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]],{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}},[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1])

কয়েকটি-উপাদান প্রান্ত ক্ষেত্রে, এটি পছন্দসই আউটপুট সরবরাহ করে।


2
অন্যান্য স্কালার উত্তরের চেয়ে ভাল, ভাল হয়েছে!
মিঃ এক্সকোডার

4

জাপট , 63 53 বাইট

এটি 44 বাইটে এসেছিল আমি লক্ষ্য করেছিলাম যে আউটপুটে ব্যবধানটি বাধ্যতামূলক।

·®¸f
"[[{q"],["}]]
\{\{{q"},\{"}}}
[{q';}]"r",|;"_+S

এটা পরীক্ষা করো


ব্যাখ্যা

          :Implicit input of string U
·         :Split to an array on newlines.
®         :Map over the array.
¸         :Split each element to an array on spaces.
f         :Filter to remove empty elements from the subarrays.
"[[       :Start building the output string. In Japt strings, anything enclosed in {}s will be evaluated before being added to the string.
{q"],["}  :Join the array to a string using ],[ The sub-arrays will be cast to comma separated strings in the process.
]]        :That's the first line done.
\{\{      :The start of the second line. A few bytes have to be sacrificed to esapce the {s
{q"},\{"} :Join the array to a string using },{
}}        :That's the second line done.
[         :And on to the last line.
{q';}     :This time we join the array with a semi-colon.
]"        :And that's the string completed.
r         :Except we still need to replace...
",|;"     :  All occurrences of a comma or a semi-colon with...
_+S       :  Itself and a space.
          :Implicit output of resulting string.

সাবাশ. আমি যেটা করতে পেরেছিলাম তা হ'ল কোথাও
60০

3

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

কোড + -p0পতাকা 69 বাইট ।

s/^ *(.+)/[$1]/gm;s/\s+/, /g;$_="[$_]
{".y/[]/{}/r."}
".s/], \[/; /gr

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

ব্যাখ্যা

s/^ *(.+)/[$1]/gm;যোগ করা []প্রতিটি লাইনে প্রায় যখন নেতৃস্থানীয় স্পেস সরিয়ে ফেলা হয়।
s/\s+/, /g;কমা এবং একটি স্থানের সাথে দৌড়াদৌড়ি এবং নিউলাইনগুলি প্রতিস্থাপন করে।
প্রথম আউটপুট তারপর ধনুর্বন্ধনী সঙ্গে পার্শ্ববর্তী দ্বারা প্রাপ্ত হয়: [$_]
দ্বিতীয়টির জন্য বক্রবন্ধনী বন্ধনী ( y/[]/{}/rএবং) কোঁকড়া বন্ধনী দিয়ে প্রতিস্থাপন করা উচিত "{" ... "}"
তৃতীয়টির জন্য, ], [সেমিকোলন এবং একটি স্পেস ( s/], \[/; /gr) দিয়ে প্রতিস্থাপন করা হবে ।


এই সমাধানটি লেখার পরে, আমি মার্টিন ইন্ডারের রেটিনা উত্তরটি উপস্থাপন করার চেষ্টা করেছি, তবে এটি 10 ​​বাইট দীর্ঘ ( ট্রাইআইটঅনলাইন ) শেষ হয়েছিল:

s/^ +//gm;s/
/] [/g;s/ +/, /g;$_="[[$_]]
{{".y/[]/{}/r."}}
[".s/], \[/; /gr."]"

এই সংস্করণটির জন্য, ব্যাখ্যার জন্য মার্টিনের উত্তর দেখুন ।


3

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

`jtU&D32', 'XHYXw]xXhH&Zc91wh93htD[]&D{}&DXED&GxvUH&4$'; 'TD

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

আড্ডায় মাস্টারক্লাসে আমার বাইকাউন্টের এক চতুর্থাংশ শেভ করার জন্য লুইস মেন্ডোকে অনেক ধন্যবাদ।

ইনপুট আটকান, তারপরে একটি খালি লাইন।

% Act I: Taking input.

`jt             w]    % Take input line by line until an empty line is encountered.
   U                  % Convert string input to numerical row array
    &D                % Convert back to string, adding brackets and single spaces
      32', 'XHYX      % Add commas before the spaces. Store ',  ' in clipboard H.


% Act II: Nested square brackets

x                     % Discard the tab character
 Xh                   % Concatenate all strings as cell array.
   H&Zc               % Join all the strings together, using clipboard H as a separator
       91wh93h        % Wrap in square brackets (ASCII 91 and 93)
              tD      % Display a copy of the result.

% Act III: Nested curly brackets

[]&D{}&D              % Convert empty array and cell array to string.
        XE            % Use to substitute square for curly brackets.

% Act IV: MATLAB-style input.

&Gxv                  % Get all the input again, discard the tab, and concatenate vertically.
    U                 % Convert to numerical 
     &4$     TD       % Convert to string, using row- and column separators
        H'; '         % Namely, clipboard H and a semicolon.

2

05 এ বি 1 ই ,  45  44 বাইট

|„  ð:ðδÛ˜ð¡„, ý''KD…[ÿ]=„[]„{}‡,"], ["„; :=

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

প্রথম আউটপুট

|                           # push a list of the inputs
 „  ð:                      # replace any instance of 2 spaces with 1 space
      ðδÛ                   # remove any leading spaces
         ˜                  # flatten to a 1D list
          ð¡                # split on spaces
            „, ý            # merge on ", "
                ''K         # remove all single quotes
                   D        # duplicate for use in output 3
                    …[ÿ]    # interpolate between square brackets
                        =   # print without popping 

দ্বিতীয় আউটপুট

„[]„{}‡,                    # translate square brackets to curly brackets and print

তৃতীয় আউটপুট

                            # the copy from the first output is used here
 "], ["„; :                 # replace "], [" with "; "
           =                # print


2

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

-15 বাইটস @ শাগি এবং @ জাস্টিনকে ধন্যবাদ

m=>`[[${(a=m.split`
`.map(x=>x.match(/\S+/g).join`, `)).join`], [`}]]
{{${a.join`}, {`}}}
[${a.join`; `}]`

কোড স্নিপেট উদাহরণ:

f=
m=>`[[${(a=m.split`
`.map(x=>x.match(/\S+/g).join`, `)).join`], [`}]]
{{${a.join`}, {`}}}
[${a.join`; `}]`
console.log(f(
`1 -2
 3  5
 6  7`
))


পরিবর্তন করে 4 বাইট সংরক্ষণ map(x=>x.trim().replace(/ +/g,", "))করতে map(x=>x.match(/\S+/g).join`, `)
জাস্টিন মেরিনার

1

পাইথন 2 , 163 152 150 145 বাইট

-5 বাইট ধন্যবাদ ফেলিপ নারদী বাটিস্তার জন্য যারা স্প্লেটগুলি ব্যবহারের পরামর্শ দিয়েছিল (দুঃখিত, এই শব্দটি বলতে আমার কেবল একটি অজুহাত প্রয়োজন: পি)।

import re
a=str.replace
def f(s):r=a(`[re.findall('[\.\d]+',i)for i in s.split('\n')]`,"'",'');print r,a(a(r,*']}'),*'[{'),a(r[1:-1],'], [','; ')

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


আহ, ছিটিয়ে ... ধন্যবাদ!
সম্পূর্ণরূপে

1

পাইথন 3 , 184 178 174 173 169 163 * 157 * 153 বাইট

ইনপুট / আউটপুট ফর্ম্যাট: ম্যাট্রিক্সের মধ্যে একটি স্পেস এবং আউটপুট এই ফাংশন কলটির সাথে ইনপুট (টিআইওতে প্রদর্শিত হিসাবে):

g("""<paste matrix here>""")

এটি ফাংশন:

def g(s,r=str.replace):a=str([[[int,float]['.'in y](y)for y in x.split()]for x in s.split('\n')]);print(a,r(r(a,*'[{'),*']}'),'['+r(a,'], [','; ')[2:-1])

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


* @Fficialaimm (169 থেকে 163 বাইট) এর জন্য 6 বাইট সংরক্ষণ করা হয়েছে

* ফিলিপনার্ডিবাটিস্টাকে ধন্যবাদ 4 টি বাইট সংরক্ষণ করুন


আরও গল্ফ করার পরে আসার ব্যাখ্যা।


1

সি, 415 বাইট

#import<stdio.h>
#define A(a,c,o)for(l=strlen(a)-o,k=0;c[k];)a[l+k]=c[k++];
j,k,l;main(i){char s[999],a[999]="[",b[999]="{",c[999]="[",t[]=" ";for(;fgets(s,999,stdin);){A(b,"{",0)A(a,"[",0)for(i=0;s[i];++i){j=0;for(;s[i]-32&&s[i]-10&&s[i];++i){j=1;t[0]=s[i];A(c,t,0)A(b,t,0)A(a,t,0)}if(j){A(c,", ",0)A(b,", ",0)A(a,", ",0)}}A(c,"; ",2)A(b,"}, ",2)A(a,"], ",2)}A(c,"]",2)A(b,"}",2)A(a,"]",2)puts(a);puts(b);puts(c);}

এটি একটি দৈত্য এবং waaayyyy খুব দীর্ঘ, কিন্তু আমি এটি দিয়ে সম্পন্ন। সম্ভবত একটি ভিন্ন পদ্ধতির জন্য যাওয়া উচিত ছিল।

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

দ্বিতীয় পরীক্ষার মামলা | তৃতীয় পরীক্ষার মামলা | চতুর্থ পরীক্ষার মামলা | পঞ্চম পরীক্ষার মামলা | ষষ্ঠ পরীক্ষার মামলা | সপ্তম পরীক্ষার মামলা


1

জেলি , 37 বাইট

j€⁾, j⁾; ⁾[]j
ỴḲLÐf$€VµŒṘṄ“[]“{}”yṄȧÇ

একটি সম্পূর্ণ প্রোগ্রাম তিনটি লাইনে তিনটি ফর্ম্যাট মুদ্রণ করে।

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

কিভাবে?

j€⁾, j⁾; ⁾[]j - Link 1, create the 3rd format (semicolon-style): list of lists
  ⁾,          - literal [',', ' ']
j€            - join for €ach (place ", " between the elements of each row)
      ⁾;      - literal [';', ' ']
     j        - join (place "; " between the rows)
         ⁾[]  - literal ['[', ']']
            j - join (surround the whole result with a pair of brackets)

ỴḲLÐf$€VµŒṘṄ“[]“{}”yṄȧÇ - Main link: list of characters
Ỵ                       - split at newlines
     $€                 - last two links as a monad for €ach row:
 Ḳ                      -   split at spaces
   Ðf                   -   filter keep those for which the following is truthy:
  L                     -     length (this removes all the empty lists "between" spaces)
       V                - evaluate as jelly code (yields a list of lists of numbers)
        µ               - monadic chain separation, call that x
         ŒṘ             - get a Python string representation of x
           Ṅ            - print that (the 1st format) plus a newline, and yield it
            “[]“{}”     - literal [['[', ']'],['{', '}']]
                   y    - translate (converts all '[' to '{' and all ']' to '}')
                    Ṅ   - print that (the 2nd format) plus a newline, and yield it
                      Ç - call the last link as a monad with argument x
                     ȧ  - logical and
                        - implicit print of the result (the 3rd format)

1

ভি , 41 বাইট

òJé;òÓ¨ä©ó«/±, 
yss]Y.pkÓ; /], [
Ùòcs]}f[

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

ব্যাখ্যা

òJé;ò            Join all lines with `; ` (trailing single space)
     Ó¨ä©ó«/±,   :s/\v(\d)\s+/\1, /g
yss]             Surround everything with brackets (completes [x,x;x,x])
Y.pk             (Y)ank, surround with brackets again, (p)aste.  Adds [[x,x;x,x]]
    Ó; /], [     :s/; /[, ]/g (transforms to [[x,x], [x,x]])
Ù                Duplicate this line
 ò               recursively
  cs]}           (c)hange (s)urrounding [] with {}
      f[         go to the next [ until there are none

1

আর , 132 বাইট

function(x,p=paste0,g=gsub)cat(z<-p('[[',g('\n','], [',y<-g('[:blank:]',', ',x)),']]'),chartr('[]','{}',z),p('[',g('
','; ',y),']'))

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

একটি বেনামী ফাংশন। ইনপুট লাগে

f('1 -2
3 5
6 7')

এটি পরীক্ষার কেসের মতো একই ক্রমে তাদের মুদ্রণ করে তবে বিভাজকের মতো ফাঁকা জায়গা দিয়ে।

ব্যাখ্যা:

এটি প্রথমে স্থানগুলি অদলবদল ,করে এবং ফলাফলটি সংরক্ষণ করে y। তারপরে এটি নতুন লাইনের সাথে অদলবদল করে ], [, রাখে [[এবং ]]উভয় প্রান্তে, এবং এর ফলাফলটিকে সংরক্ষণ করে z

এর পরে, chartrপরিবর্তন [সঙ্গে {এবং ]সঙ্গে }মধ্যে z

অবশেষে, এটি লাগে y, নতুন লাইনগুলি অদলবদল করে ;এবং রাখে [এবং] উভয় প্রান্তে।

তারপরে সমস্ত ফলাফল সেই ক্রমে পাস করা হয় cat যা এগুলি প্রিন্ট করে, সমস্ত সুন্দরভাবে ফর্ম্যাট করে এবং একটি একক স্পেস দ্বারা পৃথক করে।

হালকা শৃঙ্খলাবদ্ধ:

function(x)
  cat(
    z<-paste0('[[',gsub('\n','], [',y<-gsub('[:blank:]',', ',x)),']]'),
    chartr('[]','{}',z),
    paste0('[',gsub('\n','; ',y),']'))

1

নেটবিয়ান 8+, 209 বাইট সহ জাভা 8

কোড থেকে গণনা 208, টিপুন দিয়ে চালানোর জন্য 1 বাইট প্লাস F6

জটিল চ্যালেঞ্জের জন্য জটিল উত্তর: পি

interface M{static void main(String[]a){String s="";s=s.trim().replaceAll(" +",", ").replaceAll("\n(, )?","; ");System.out.println("["+s+"]\n[["+s.replace("; ","], [")+"]]\n{{"+s.replace("; ","}, {")+"}}");}}

কিভাবে ব্যবহার করে?

নেটবিনের মধ্যে, ফোন করা একটি কোডে এই কোডটি পেস্ট করুন M.java। তারপরে আপনি যে ম্যাট্রিক্সটি ব্যবহার করতে চান তা অনুলিপি করুন। তারপর দুই পরপর অক্ষরের মধ্যে "", প্রেস ctrl+ +v চ্যালেঞ্জের জন্য প্রয়োজনীয় হিসাবে ।

এবার টিপুন F6! এটি কোডটি সংকলন করবে, চালাবে এবং প্রত্যাশিত ম্যাট্রিক্স উপস্থাপনাগুলি তৈরি করবে।


এই তিনটি আউটপুট বিন্যাসে থাকা প্রয়োজন হয় না?
জিউসেপ

1
সেখানে! এটাই আমি মিস করেছি! : ডি যে এখন ঠিক।
অলিভিয়ের

2
@ স্টিভিগ্রিফিন এটি ডিফল্টরূপে STDIN ব্যবহার করে এমন ভাষা বা নতুন লাইনের বিষয়ে চিন্তা করে না এমন ভাষাগুলি আমি সুবিধাজনকভাবে বলতে পারি যে কোনও প্রধান জাভা আইডিইতে "অনুলিপি / আটকানো" স্বয়ংক্রিয়ভাবে ফর্ম্যাট করে অনুলিপিটি অনুলিপি \nকরে দেয় তুমি কি দেখেছিলে. তাই আমি একেবারেই স্পষ্ট করে বলছি না: s
অলিভিয়ার গ্রাগোয়ার

@ অলিভিগ্রগ্রোয়েয়ার আমি পুরোপুরি সচেতন যে এটি কিছু ভাষার পক্ষে সুবিধা দিচ্ছে, বিশেষত যেগুলি কোনও বিশেষ প্রক্রিয়াজাতকরণ ছাড়াই বিন্যাসটি পরিচালনা করতে পারে। এমনকি আমি চ্যালেঞ্জ পাঠ্যেও স্পষ্টভাবে এটি উল্লেখ করেছি। মনে রাখবেন যে আপনি জেলি, জাভাস্ক্রিপ্ট বা পাইথনের বিরুদ্ধে প্রতিদ্বন্দ্বিতা করছেন না, আপনি জাভা ব্যবহার করছেন। এর খুব কার্যকারিতা রয়েছে এবং অন্যের সাথে মোটামুটি তুলনা করা যায় না। আমি সবসময় জটিল I / O ফর্ম্যাটগুলি এড়িয়ে চলার নিয়মগুলি অনুসরণ করি যা কিছু ভাষাকে অন্যায় সুবিধা দিতে পারে তবে এই বিশেষ চ্যালেঞ্জে ইনপুট পার্স করা এর একটি বড় অংশ।
স্টিভি গ্রিফিন

1

গণিত, 129 বাইট

s=StringSplit
r=StringReplace
Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]&@ToString@s@s[#,n="
"]&

তৃতীয় এবং চতুর্থ লাইন একসাথে ইনপুট হিসাবে একটি স্ট্রিং গ্রহণ একটি বিশুদ্ধ ফাংশন সংজ্ঞায়িত; উদাহরণস্বরূপ, যদি আমরা সেট করি f=Print...&, তবে শেষ পরীক্ষার কেস হিসাবে ডাকা হবে:

f@"4
5"

স্নিপেট

ToString@s@s[#,n="
"]

ইনপুট স্ট্রিংকে একটি ম্যাট্রিক্স হিসাবে পার্স করে (স্ট্রিংগুলির- আমরা কখনই এন্ট্রিগুলিকে সংখ্যাসূচক হিসাবে ব্যাখ্যা করার চেষ্টা করি না) এবং ফলাফলটি প্রকাশের ক্ষেত্রে আবার স্ট্রিংয়ে রূপান্তর করি; এটি স্বয়ংক্রিয়ভাবে কুঁকড়ানো ধনুর্বন্ধনী সঙ্গে আউটপুট বিন্যাস উত্পন্ন করে। তারপরে Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]সরল স্ট্রিং প্রতিস্থাপনের নিয়মগুলি ব্যবহার করে আউটপুট ফর্ম্যাটটি এবং অন্য দুটি, নতুন লাইনের দ্বারা পৃথক করে প্রিন্ট করে।


1

পিপ , 49 46 বাইট

45 বাইট কোডের, -rপতাকা জন্য +1 ।

g|>:sYP(RPg^w)R';kPyR'['{R']'}O'[OgRwkJ"; "']

স্টিডিন থেকে ইনপুট নেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

                 Preset variables used: s is " ", w is regex `\s+`, k is ", "
g                With -r flag, g is a list of lines from stdin
 |>:s            Left-strip spaces from (elements of) g and assign back to g

YP(RPg^w)R';k
     g^w         Split (elements of) g on runs of whitespace
   RP            Apply Pip's built-in repr, which wraps lists in [] and separates items
                   with ; (e.g. [[1;2];[3;4]])
  (     )R';k    Replace the semicolons with ", " to obtain format #1
YP               Print and yank into y variable

PyR'['{R']'}
 yR'['{          In y, replace [ with {
       R']'}     and ] with }
P                and print (format #2)

O'[OgRwkJ"; "']
O'[              Output [ with no newline
   O             Output with no newline:
    g              Take g (list of lines of stdin, with leading spaces stripped)
     Rwk           Replace runs of whitespace with ", "
        J"; "      and join lines on "; "
             ']  Print the final ] to complete format #3

(এই ব্যাখ্যা ফর্ম্যাটটি আমার কাছে কিছুটা বিশৃঙ্খলা বোধ করে, তাই কিছু বোঝার চেষ্টা না করলে আমাকে জানান))


1

এসসিএএলএ, 590 বাইট

কঠিন ছিল, তবে আমি মনে করি এটি শেষ করেছি

var o=s.replaceAll("  *"," ").replaceAll("\n ","\n")
var z=o.split("\n")
var h=z.length
var k=new Array[Array[String]](h)
for(i<-0 to h-1)k(i)=z(i).split(" ")
var u=k.length-1
print("{")
for(i<-0 to u){print("{")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("}")}
print("}[")
for(i<-0 to u){print("[")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("]")}
print("][")
for(i<-0 to u-1){for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("; ")}
for(j<-0 to k(k.length-1).length-2)print(k(u)(j)+", ")
print(k.last.last)
print("]")

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

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


2
এটা ভয়াবহ। আমাকে এখন একটি স্কেলার উত্তর পোস্ট করতে হবে।
তমোঘনা চৌধুরী

চেষ্টা করার জন্য একটি উত্সাহ আছে, যদিও।
তমোঘনা চৌধুরী

1
আপনি কটাক্ষপাত করা করতে চাইবেন codegolf.stackexchange.com/a/129356/48620 তা দেখতে Scala সম্ভব হতে পারে। এটির মত ব্যবহার করে 1.5-জাভা ব্যবহার করা কেবল আইসবার্গের ডগা স্ক্র্যাচ করছে।
তমোঘনা চৌধুরী

2
এছাড়াও, আপনার আউটপুটটি ভুল, যা আমাকে আমার উর্ধ্বে প্রত্যাহার করতে চায় - বন্ধনীগুলির মধ্যে কোনও কমা নেই, আউটপুট ফর্ম্যাট অনুসারে।
তমোঘনা চৌধুরী


0

05 এ বি 1 ই , 34 বাইট

|εð¡õK}€ï"ÿ"Є[]„{}‡s¦¨"], ["„; :»

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

ε...}এটি এখনও vy...})টানেনি বলে টিআইওতে প্রতিস্থাপন করা হয়েছে ।


@ জোনাথান অ্যালান ধন্যবাদ, ঠিক করা হয়েছে।
এরিক আউটগল্ফার

শীতল, এখন এটি কীভাবে এটি কাজ করে তার একটি ব্যাখ্যা দরকার :)
জোনাথন অ্যালান


0

সি # (.নেট কোর) , 214 বাইট

(s)=>{var result=Regex.Replace("[["+Regex.Replace(s.Replace("\n","], [")," +(\\d)",", $0")+"]","  +"," ").Replace("[, ","[");return$"{result}]\n{result.Replace('[','{').Replace(']','}')}}}\n[{result.Replace("[","").Replace("],",";")}";};

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

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


এই উত্তরটির পরে, আমি আরও নিশ্চিত হয়েছি যে বেস সিস্টেম ব্যতীত অন্য লাইব্রেরিগুলির জন্য ব্যবহারের বিবৃতিটি বাইটোকন্টে অন্তর্ভুক্ত করা উচিত। আমি এখনই এটির বর্তমান ফর্মটিতে রেখে দেব, তবে বিবৃতিটি using System.Text.RegularExpressionsআবশ্যক (আমার গণনা অনুসারে) অতিরিক্ত 37 বাইট যোগ করা দরকার।
কামিল দ্রাকারী

0

কাঠকয়লা , 38 বাইট

≔E⪪θ¶⪫Φ⪪ι λ, θE⪪[]{}²⪫ι⪫Eθ⪫ιλ, ⪫[]⪫θ; 

এটি অনলাইন চেষ্টা করুন! দ্রষ্টব্য: ট্রেলিং স্পেস লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। কাঠকয়ালের একটি মাল্টলাইন ইনপুট বিকল্প রয়েছে ["""এবং ব্যবহার করে ডিলিমিট """]। ব্যাখ্যা:

   θ                Input string
  ⪪ ¶               Split on newlines
 E                  Map over each line
        ι           Current line
       ⪪            Split on spaces
      Φ   λ         Filter out empty strings
     ⪫     ,        Join with `, `
≔            θ      Assign resulting array to variable

এটি ইনপুট নেয় এবং এটি লাইনগুলিতে বিভক্ত করে এবং বিভাজকগুলিকে সাধারণকরণের মাধ্যমে প্রস্তুত করে।

 ⪪[]{}²             Split `[]{}` into substrings of length 2
E                   Map over the substrings
          Eθ        Map over array from above
            ⪫ιλ     Wrap each element with the substring
         ⪫     ,    Join elements with `, `
       ⪫ι           Wrap with the substring
                    Implicitly print each result on a separate line

এটি [[ ... ], [ ... ]]এবং {{ ... }, { ... }}কেসগুলি পরিচালনা করে ।

    θ               Array from above
   ⪫ ;              Join elements with `; `
⪫[]                 Wrap result with `[]`
                    Implicitly print

এটি [ ... ; ... ]কেস পরিচালনা করে ।

উপরের সমাধানটি বন্ধ করে দেওয়ার আগে আমার দুটি 39-বাইট সমাধান ছিল; এটি অন্যটি:

⮌E⪪[]{}[]²⪫ι⪫EE⪪θ¶⪫Φ⪪λ ν, ⎇κ⪫ιλλ⁺§;,,κ 

এটি অনলাইন চেষ্টা করুন! দ্রষ্টব্য: ট্রেলিং স্পেস লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

  ⪪[]{}[]²                              Split `[]{}[]` into substrings of length 2
 E                                      Map over the substrings
                θ                       Input string
               ⪪ ¶                      Split on newlines
              E                         Map over each line
                     λ                  Current line
                    ⪪                   Split on spaces
                   Φ   ν                Filter out empty strings
                  ⪫     ,               Join with `, `
             E                          Map over each line
                          ⎇κ   λ        If outer index is zero, just use the line
                            ⪫ιλ         Otherwise wrap the line in the substring
            ⪫                   ⁺§;,,κ  Join with `; ` or `, ` per outer index
          ⪫ι                            Wrap in the substring
⮌                                       Reverse the order of the results
                                        Implicitly print each result on a separate line
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.