চ্যালেঞ্জ

এই প্রশ্নের জন্য আপনার কাজটি হ'ল সেই অ্যারেতে প্রতিটি পূর্ণসংখ্যার দ্বিতীয় ইভেন্টে পূর্ণসংখ্যার ইনপুট অ্যারে ভাগ করা split

যথেষ্ট পরিষ্কার না? এখানে সাহায্যের একটি উদাহরণ রয়েছে

ইনপুট অ্যারে:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

আউটপুট:

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

ব্যাখ্যা:

সাহসীভাবে হাইলাইট করা কেবলমাত্র দ্বিতীয় উপাদান সহ এখানে অ্যারে রয়েছে:

[2 1 1 2 3 2 2 4 4 5 6 7 3 7 0 5 ]

এখন আমরা এই সাহসী দ্বিতীয় ঘটনাগুলির চারপাশে বিভক্ত অ্যারে ব্লকগুলি রেখেছি:

[2 1] 1 [] 2 [3 2 2 4 5 6 7] 3 [] 7 [0] 5 []

এবং ফাইনাল পেতে এই বিভক্ত অ্যারেগুলিকে একটি অ্যারেতে মুড়িয়ে দিন

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

দ্রষ্টব্য যে যখন সংলগ্ন দ্বিতীয় ঘটনা ঘটে তখন খালি অ্যারে থাকবে।

বিধি

যথারীতি, আপনাকে একটি সম্পূর্ণ প্রোগ্রাম লিখতে হবে বা একটি ফাংশন এসটিডিএন, এআরজিভি বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট অ্যারে গ্রহণ করে।

ইনপুট

ইনপুটটি পূর্ণসংখ্যার যে কোনও সুবিধাজনক অ্যারে (বা অ্যারে-জাতীয়) বিন্যাসে অন্তর্ভুক্ত।

উদাহরণস্বরূপ, নিম্নলিখিত যে কোনওটি গ্রহণযোগ্য হবে:

2 1 1 1 4 5 6
[2 1 1 1 4 5 6]
[2, 1, 1, 1, 4, 5, 6]

আউটপুট

STDOUT এ আউটপুট দেওয়ার সময় আপনার অ্যারেটি কোনও সুবিধাজনক (নেস্টেড) অ্যারে বিন্যাসেও মুদ্রণ করা যায়, যেমন একটি

[[2 1] [1 4 5 6]]
[[2, 1], [1, 4, 5, 6]]
{{2, 1}, {1, 4, 5, 6}}

(এটি সাধারণত আপনার ভাষার অ্যারেগুলির স্থানীয় স্ট্রিং উপস্থাপনা হবে))

এছাড়াও নোট করুন যে খালি অ্যারেগুলি অনুসরণ করে অ্যারের অংশ হিসাবে মুদ্রিত করা উচিত।

স্কোরিং

এটি কোড-গল্ফ তাই বাইট জিতে সংক্ষিপ্ততম কোড!

— অপ্টিমাইজার
সূত্র

@ পিটারটেলর অনেকগুলি প্রশ্ন আউটপুট এবং ইনপুট উভয় ক্ষেত্রে বিভিন্ন বিন্যাসের অনুমতি দেয়।

— অপ্টিমাইজার

5

""খালি অ্যারে হিসাবে অনুমতি বিন্দু কি ? এটি একটি নির্দিষ্ট গল্ফিং ভাষার প্রতি অনুগ্রহের গন্ধ।

— জন ডিভোরাক

@ জনডভোরাক আড্ডার আলোচনার পরে অভিপ্রায়টি ছিল আসলে আরও বেশি অন্তর্ভুক্ত এবং সাধারণত ভাষাগুলি তাদের স্থানীয় প্রতিনিধিত্ব ব্যবহার করার অনুমতি দেয়। পরিষ্কার করার জন্য আমি এখন শব্দটির সম্পাদনা করেছি।

— মার্টিন এন্ডার

1

আমি কি শুধু আউটপুট দিতে পারি 2 1, 1 4 5 6?

— জিমি 23013

@ ব্যবহারকারী23013 আপনার চয়ন করা ভাষার উপর নির্ভর করে।

— অপ্টিমাইজার

6

এপিএল 25

1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←

উদাহরণ:

]display 1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌→──────────────────────────────────────┐
│ ┌→──┐ ┌⊖┐ ┌→────────────┐ ┌⊖┐ ┌→┐ ┌⊖┐ │
│ │2 1│ │0│ │3 2 2 4 5 6 7│ │0│ │0│ │0│ │
│ └~──┘ └~┘ └~────────────┘ └~┘ └~┘ └~┘ │
└∊──────────────────────────────────────┘

পুরোনো একটি:

{1↓¨(1,(⍳⍴⍵)∊,{1↑1↓⍵}⌸⍵)⊂1,⍵}

এটি কী অপারেটর (⌸) এর জন্য একটি দুর্দান্ত প্রশ্ন যা ডায়ালগ এপিএল ভি 14 এর সাথে প্রবর্তিত হয়েছিল। এটি বাম আর্গুমেন্ট ফাংশন নেয় ({1 ↑ 1 ↓ ⍵}) এবং এটি প্রতিটি অনন্য যুক্তির জন্য দেয়, সেই যুক্তির জন্য ভেক্টরের সূচকগুলি। এখানে আমি দ্বিতীয় সূচক নিচ্ছি, তারপরে আমি যাচাই করব যে সূচকগুলির মধ্যে এই তালিকায় উপস্থিত রয়েছে ((⍳⍴⍵) ∊) এবং আসল ভেক্টরকে বিভক্ত করার জন্য ফলস্বরূপ বুলিয়ান ব্যবহার করুন।

এখানে অনলাইনে চেষ্টা করা যেতে পারে:

http://tryapl.org

— মরিস জুকা
সূত্র

অভিশাপ। এখনও 24 এর চেয়ে কম নয়?

— অপ্টিমাইজার

@ অপ্টিমাইজার: 25 ... আমি চেষ্টা করছি ;-)

— মরিস জুকা

আমার নিজের সমাধানের পরিবর্তে এটি গ্রহণ করা হচ্ছে :)

— অপটিমাইজার

শুধুমাত্র 24, এবং একটি সঠিক ফাংশন:1↓¨{1,∨⌿<\2=+\∘.=⍨⍵}⊂1∘,

— অ্যাডম

দুর্ভাগ্যক্রমে কাজ করে না ... dfn এর ওমেগা "a" এর মতো নয়

— মরিস জুকা

9

এপিএল (ডায়ালগ 14) (31)

{1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵}

এটি এমন একটি ফাংশন যা অ্যারে নেয় এবং নেস্টেড অ্যারে প্রদান করে।

টেস্ট:

      +V← {1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵} 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌───┬┬─────────────┬┬─┬┐
│2 1││3 2 2 4 5 6 7││0││
└───┴┴─────────────┴┴─┴┘
      ⍝ this return value is a real nested array:
      ⎕←'Length: ',⍴V ⋄ (⍳⍴V){⎕←'Array #',⍺,': (', ⍵, ')'}¨V 
Length:  6
Array # 1 : ( 2 1 )
Array # 2 : ()
Array # 3 : ( 3 2 2 4 5 6 7 )
Array # 4 : ()
Array # 5 : ( 0 )
Array # 6 : ()

ব্যাখ্যা:

0,⍵: সহজ প্রক্রিয়াজাতকরণের জন্য 0সামনের অংশে একটি যুক্ত করুন ⍵। (এটি কোনও ঘটনা হিসাবে গণনা করা হয় না))
(... )⊂: প্রদত্ত বিটমাস্ক অনুসারে অ্যারে বিভক্ত করুন। 1বিটমাস্কের প্রতিটিটিতে একটি নতুন গ্রুপ শুরু হয় ।
- +\∘.=⍨⍵: প্রতিটি মূল্যের (মূল) জন্য ⍵, সমস্ত উপস্থিতি সন্ধান করুন ⍵। তারপরে প্রতিটি মানের মধ্যে ইতিমধ্যে যে পরিমাণটি ⍵ঘটেছে তাতে প্রতিটি পজিশনের জন্য একটি বর্গ ম্যাট্রিক্স প্রদান করে প্রতিটি মানের জন্য চলমান যোগফল তৈরি করুন ।
- ↓: ম্যাট্রিক্সকে তার সারি দ্বারা বিভক্ত করুন, প্রতিটি মানকে প্রতিটি অবস্থানের দ্বারা সংঘটিত হওয়ার পরিমাণের পরিমাণ প্রদর্শন করে এমন একটি অ্যারে প্রদান করে।
- 2⍳⍨¨: এই অ্যারেগুলির প্রত্যেকটিতে প্রথমটির সূচকটি সন্ধান করুন 2।
- (⍳⍴⍵)∊: প্রতিটি সম্ভাব্য সূচীর জন্য ⍵ , দেখুন এটি দ্বিতীয় সংক্রমণের সূচকের তালিকায় অন্তর্ভুক্ত রয়েছে কিনা। (এগুলি প্রথম দল বাদে প্রতিটি গ্রুপ শুরু করে))
- 1,: 1প্রথম দলের শুরুতে চিহ্নিত করে সামনের দিকে একটি যুক্ত করুন ।
1↓¨: প্রতিটি গ্রুপ থেকে প্রথম উপাদানটি সরান। (এগুলি 0হ'ল প্রতিটি মানের সংযুক্তি এবং দ্বিতীয় ঘটনা))

— সামুদ্রিক
সূত্র

8

জে, 28 24 চর

র্যান্ডম্রা বিশেষ ধন্যবাদ ।

(1&,<;._1~1,2=+/@(={:)\)

এটি এভাবে কাজ করে। \ইনপুট অ্যারের সমস্ত উপসর্গ ( ) জুড়ে, আমরা +/@উপসর্গের কতগুলি ( ) উপাদানগুলি উপসর্গের শেষ উপাদান ( ={:) এর সমান, তা লক্ষ্য করি। যখন এই সংখ্যাটি 2 হয়, আমরা জানি যে এটি অ্যারের মধ্যে থাকা আইটেমটির দ্বিতীয় ঘটনা, সুতরাং আমরা সেখানে অ্যারে ব্যবহার করে বিভক্ত করেছিলাম <;._1।

   a=.2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
   (={:)\ a
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 1
   +/@(={:)\ a
1 1 2 2 1 3 4 1 1 1 1 2 2 1 2

প্রাচীন জিনিস সাজানোর ঠাট ব্যবহার করছে: (1&,<;._1~1,1=i.~(]-{)/:@/:)।

— algorithmshark
সূত্র

(1&,<;._1~1,2=+/@(={:)\)4 বাইট সংক্ষিপ্ত এবং অনেক সহজ। ( /:@/:যদিও এটি একটি দুর্দান্ত কৌশল))

— এলোমেলোভাবে

7

গণিত, 58 51 49 বাইট

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&

এটি একটি নামবিহীন ফাংশন যা এর মতো একটি তালিকা গ্রহণ করে

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&[{2,1,1,2,3,2,2,4,5,6,7,3,7,0,5}]

এবং নেস্টেড তালিকার মতো ফিরিয়ে দেয়

{{2, 1}, {}, {3, 2, 2, 4, 5, 6, 7}, {}, {0}, {}}

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

এটি সাথে বেশ কিছু অস্পষ্ট যাদু ব্যবহার করে SplitBy ।

আমি একটি ফাংশনে প্রতিটি সংখ্যার উপস্থিতি সম্পর্কে নজর রাখছি f । ম্যাথামেটিকায় আপনি প্রতিটি ইনপুটটির জন্য আলাদাভাবে কোনও ফাংশনের মান নির্ধারণ করতে পারেন এবং আপনাকে সমস্ত সম্ভাব্য ইনপুটগুলির জন্য মান নির্দিষ্ট করার দরকার নেই (এটি আরও স্টেরয়েডের হ্যাশ টেবিলের মতো)।

সুতরাং আমি আরম্ভ করে শুরু করি f উপস্থিত মানগুলির জন্য 0 থেকে(f@#=0;#)&/@ ।

এখন SplitByএকটি তালিকা এবং একটি ফাংশন নেয় এবং "ধারাবাহিক উপাদানগুলির রান নিয়ে সাবলিস্টগুলিতে তালিকা বিভক্ত হয় fযা প্রয়োগ করার সময় একই মান SplitByদেয় " (নোট যে কোনও উপাদান সরিয়ে দেয় না )। কিন্তু (অননুমোদিত) ক্যাচটি হ'ল, এটি প্রতিটি মৌলের উপর দু'বারf বলা হয় - যখন এটি পূর্বসূর এবং তার উত্তরসূরের সাথে তুলনা করে। সুতরাং আমরা যদি

 SplitBy[{1,2,3,4},Print]

আমরা কেবল একবারে প্রতিটি সংখ্যা পাই না, তবে পরিবর্তে এই মুদ্রণগুলি

যা 3 তুলনা জন্য 6 কল।

আমরা প্রতিটি দ্বিতীয় ঘটনার আগে তালিকাকে বিভক্ত করতে পারি , যদি আমরা এমন একটি ফাংশন লিখি যা সর্বদা ফিরে আসে Falseতবে ফিরে আসে Trueযখন দ্বিতীয় ঘটনার আগে উপাদানটির সাথে তুলনা করা হয়। যে তৃতীয় যে উপাদান চেক (প্রথম সংঘটন দুটি চেক, প্লাস দ্বিতীয় সংঘটন প্রথম চেক)। সুতরাং, আমরা ব্যবহার ++f[#]==3&। সুন্দর জিনিসটি হ'ল এটি ইতিমধ্যে Falseদ্বিতীয় ঘটনার দ্বিতীয় চেকটিতে আবার ফিরে আসে , যেমন আমি Trueপরপর দ্বিতীয়বারের জন্য ফিরে আসতে পারি , তবে এখনও তাদের মধ্যে বিভক্ত হয়ে পড়েছি । একইভাবে, এটি দ্বিতীয় সংঘর্ষের পরে বিভক্ত হবে না কারণ ফাংশনটি ইতিমধ্যে ফিরে এসেছেFalse দ্বিতীয় আবার ।

এখন, প্রশ্নটি আমাদের সেই দ্বিতীয় ঘটনাগুলিও সরিয়ে ফেলতে চাইছে, তাই আমরা প্রতিটি তালিকা থেকে প্রথম উপাদানটি বাদ দিয়ে দিই Rest/@। তবে অবশ্যই, আমরা ইনপুটটিতে খুব প্রথম উপাদানটি সরাতে চাই না, তাই aতালিকার শুরুতে একটি উপাদান যুক্ত করে আমরা আসলে শুরু করি {a}~Join~#। aএকটি অপরিজ্ঞাত পরিবর্তনশীল, যা ম্যাথমেটিকা কেবল একটি অজানা হিসাবে বিবেচনা করে, সুতরাং এটি অন্য কোনও মানকে প্রভাবিত করবে না f। এটিও নিশ্চিত করে যে ইনপুটটিতে প্রথম আসল উপাদানটি প্রতিটি অন্যান্য উপাদানের মতো তার দুটি চেক পায়।

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

এটা বেশ চালাক। আপনারও আসলে Booleসেখানে দরকার নেই।

— 23:30

@ সুইশ আহ, আমাকে স্মরণ করিয়ে দেওয়ার জন্য ধন্যবাদ ... আমি লক্ষ্য করেছি যে মোবাইলে থাকাকালীন, তবে এটি পরিবর্তন করার আগে এটি পরীক্ষা করতে চেয়েছিলাম।

— মার্টিন এন্ডার

5

পাইথন, 148 বাইট

def s(a):z=len(a);x=[-1]+sorted({[i for i in range(z)if a[i]==n][1]for n in a if a.count(n)>1})+[z];return[a[x[i]+1:x[i+1]]for i in range(len(x)-1)]

খুব ভয়ঙ্কর সমাধান। আরও ভাল উপায় হতে পারে ...

সাথে কল s([2, 1, 1, 1, 4, 5, 6]) ।

উদার সংস্করণ

def split(array):
  indices = [-1]
  second_occurrences = set()

  for n in array:
      if array.count(n) > 1:
          occurrences = [i for i in range(len(array)) if array[i] == n]
          second_occurrences.add(occurrences[1])

  indices += sorted(second_occurrences)
  indices += [len(array)]

  return [array[indices[i]+1:indices[i+1]] for i in range(len(indices)-1)]

— Sp3000
সূত্র

1

কী কী… আপনি একটি গলিত সংস্করণে সম্পাদনা করতে পারেন? এক্সডি 148 টি অক্ষর একটি খুব দীর্ঘ রেখা;)

— শন অলরেড

1

@ সান অ্যালার্ড আমি আরও ভাল কাজ করতে পারব বলে নিশ্চিত হওয়ায় আমি কোনও ব্যাখ্যা পোস্ট করতে চাইনি, তবে যেহেতু আমার সমস্যা হচ্ছে আমি অবারিত সংস্করণটি পোস্ট করেছি: পি

— স্প 3000

5

হাস্কেল, 115 113 106 88

f?(x:s)|1<-f x=[]:x%f?s|a:b<-x%f?s=(x:a):b
f?x=[x]
(x%f)h=sum$f h:[1|x==h]
r s=(\_->0)?s

এটি উপাদান থেকে তাদের নিজ নিজ পরিমাণে কোনও ক্রিয়াকলাপ হিসাবে এতদূর পর্যন্ত প্রতিটি উপাদান উপস্থিত হওয়ার পরিমাণ সঞ্চয় করে, যা একটি আকর্ষণীয় কৌশল।

এটি ব্যবহার করে কাজ করে %, এমন একটি ফাংশন যা একটি ফাংশন এফ দেয় এবং একটি আর্গুমেন্ট xএকটি নতুন ফাংশন দেয় যা fতার আর্গুমেন্টের চেয়ে পৃথক হলে এটি প্রয়োগ করে xএবং1 + f x অন্যথায়।

উদাহরণস্বরূপ, 3 % const 0এমন একটি ফাংশন যা 3 টি ব্যতীত প্রতিটি যুক্তির জন্য 0 প্রদান করে, যার জন্য এটি 1 প্রদান করে returns update আপডেট:foldl অনেক ছোট প্রোগ্রাম পাওয়ার জন্য ফিউজড ।

— গর্বিত হাসেলেলার
সূত্র

এটি আকর্ষণীয় দেখায়। আপনি কি একটি অবারিত সংস্করণ সরবরাহ করতে পারেন?

— রডোমজ

4

রুবি 66 ডেমো

f=->a{c=Hash.new 0
r=[[]]
a.map{|e|2==(c[e]+=1)?r<<[]:r[-1]<<e}
r}

রুবি স্ট্যাবি ল্যাম্বদা যা প্যারামিটার হিসাবে অ্যারে নেয় এবং অ্যারেগুলির একটি অ্যারে দেয়।

— ক্রিশ্চিয়ান লুপাস্কু
সূত্র

4

পাইথন: 100 বাইট

def g(l):
 i=j=0;o=[]
 for e in l:
  if l[:i].count(e)==1:o+=[l[j:i]];j=i+1
  i+=1
 return o+[l[j:]]

সোজা সমাধান। আমি তালিকার উপরে পুনরাবৃত্তি করছি, কোনও চরিত্রের আগে কতবার উপস্থিত হয়েছিল তা গণনা করি এবং আউটপুট তালিকার শেষ চেকের পরে অংশটি সংযোজন করি।

— Jakube
সূত্র

3

রুবি, 66

f=->a{s=Hash.new 0
r=[[]]
a.map{|e|(s[e]+=1)==2?r<<[]:r[-1]<<e}
r}

ব্যাখ্যা

e প্রতিটি উপাদান জন্য একটি সংখ্যা হ্যাশ, r এটি এমন অ্যারে যা ফলাফল সংরক্ষণ করা হয়।
লুপ ট্রুপ ইনপুট, প্রতিটি উপাদান দ্বারা সংখ্যার সংখ্যা বাড়িয়ে 1 ।
- যদি ঘটনা গণনা হয় তবে 2আমাদের বিভক্ত হওয়া দরকার। ফলাফলটিতে একটি খালি যুক্ত করুন Array।
- অন্যথায় Arrayফলস্বরূপ কেবলমাত্র উপাদানটি যুক্ত করুন ।

— britishtea
সূত্র

2

সুন্দর টুপি!! অপেক্ষা কর.

— অপ্টিমাইজার

4

কী অবিশ্বাস্য কাকতালীয় ঘটনা! আপনার উত্তর দেওয়ার আগে আমি কয়েক সেকেন্ড আগে পোস্ট করেছি। :)

— ক্রিশ্চিয়ান লুপাস্কু

ওহ আমার, এটি আরও 1 অক্ষর খাটো!

— ব্রিটিশিয়া

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

— ক্রিশ্চিয়ান লুপাস্কু

3

সিজেম, 25 24 বাইট

q~{_L+:L1$a/,3=S@?}%Sa/p

STDIN এর মতো ইনপুট নেয়

[ 2 1 2 1 0 2 2 1 1 3 4 3]

এবং আউটপুট পছন্দ

[[2 1] "" [0 2 2 1 1 3 4] ""]

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

কোড সম্প্রসারণ :

q~{_L+:L1$a/,3=S@?}%Sa/p
q~{               }%             "Evaluate the input array and map it on this block";
   _                             "Copy the current element in iteration";
    L+:L                         "Add the copy to an initially blank array L and update L";
        1$a/                     "Make another copy of the element and split L on it";
            ,3=                  "This checks if the splitted array is of length 3";
                                 "which indirectly means that L contains the element twice";
               S@?               "If the above is true, replace the element by space";
                    Sa/          "Split the final array on space. This final array contains";
                                 "second occurrence of every integer replaced by a space";
                       p         "Print the stringified version of the final nested array";

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

আড্ডায় মার্টিনের পরামর্শ থেকে 1 বাইট সংরক্ষণ করা হয়েছে

— অপ্টিমাইজার
সূত্র

3

রুবি, 64 বাইট

s=->a{x=[];b=[[]];a.map{|e|x<<e;x.count(e)==2?b<<[]:b[-1]<<e};b}

— AlexRath
সূত্র

3

পার্ল 5: 36

এখানে কোনও প্রকৃত বিভাজন ঘটে না বলে এটি গ্রহণযোগ্য কিনা তা নিশ্চিত নন।

#!perl -pa
$x{$_}++-1or$_=']['for@F;$_="[[@F]]"

উদাহরণ:

$ perl spl.pl <<<"2 1 1 2 3 2 2 4 5 6 7 3 7 0 5"
[[2 1 ][ ][ 3 2 2 4 5 6 7 ][ ][ 0 ][]]

— নটকি
সূত্র

সম্পূর্ণ গ্রহণযোগ্য।

— অপ্টিমাইজার

চমৎকার উত্তর. তবে আমি মনে করি, স্ট্যান্ডার্ড অনুশীলনটি হল -paদুটি অতিরিক্ত বাইট হিসাবে গণনা করা (কারণ এটি "ব্যয় হয়" কেবলমাত্র দুটি বাইট, যেহেতু আপনি এটি -paeপরিবর্তে লিখতে পারেন -e)। সুতরাং এটি 38 হবে না, 36

— msh210

2

সিজেম, 28 বাইট

Lq~{1$1$a/,3=S2$?@++}/-2%S/`

STDIN এর মতো ইনপুট নেয়

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

এবং আউটপুটটি STDOUT এর মতো মুদ্রণ করে

[[2 1] "" [3 2 2 4 5 6 7] "" [0] ""]

নোট করুন যে খালি স্ট্রিং এবং খালি অ্যারেগুলি সিজেএমে একই জিনিস এবং প্রদর্শিত হয় are "" ডিফল্ট (এটি এটি খালি অ্যারে নেটিভ উপস্থাপনা)।

(চ্যালেঞ্জ পোস্ট হওয়ার আগে আমি এই নিয়ে কাজ শুরু করেছি, কারণ আমরা চ্যালেঞ্জটি কতটা কঠিন হবে তা নিয়ে আলোচনা করছিলাম।)

ব্যাখ্যা

মূলত, আমি অ্যারের প্রতিটি উপাদান নকল করছি, যদি না এটি দ্বিতীয় ঘটনা হয়, সেক্ষেত্রে আমি প্রথম কপিটি স্থানের সাথে প্রতিস্থাপন করি। গল্ফিং কারণে, এই পরিবর্তিত অ্যারেটি বিপরীতে নির্মিত হয়। তাই [2 1 1 2 3 2 3]হয়ে যায়

[3 S 2 2 3 3 2 S 1 S 1 1 2 2]

তারপরে আমি প্রান্ত থেকে প্রতিটি দ্বিতীয় উপাদান বাছাই করি, এটি আসল অ্যারে তবে স্পেস দ্বারা প্রতিস্থাপিত দ্বিতীয় সংস্থান সহ, অর্থাৎ

[2 1 S S 3 2 S]

অবশেষে, আমি কেবল ফাঁকা জায়গাগুলিতে অ্যারে বিভক্ত করি। কোডটির একটি বিচ্ছেদ এখানে রয়েছে:

L                            "Push empty array.";
 q~                          "Read STDIN an evaluate.";
   {                }/       "For each element of the input.";
    1$1$                     "Copy the array and the element.";
        a/                   "Split the array by that element.";
          ,3=                "Check that it's split into 3 parts.";
             S2$?            "If so, push a space, else, copy the current number.";
                 @++         "Pull up the array from the bottom and add both to the beginning.";
                      -2%    "Pick every second element from the end.";
                         S/  "Split on spaces.";
                           ` "Get the string representation.";

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

যেহেতু এটি আমার নিজের চ্যালেঞ্জ, আমি প্রথমে একটি সুযোগ দিচ্ছি: পি। আমার সাথে আমার 25 বাইট সিজাম সলিউশন রয়েছে।

— অপ্টিমাইজার

খালি অ্যারেগুলি সঠিকভাবে প্রদর্শন করে না - স্পষ্টতই অবৈধ!

— ফেয়ারসুম

1

@ ফেয়ারসাম খালি অ্যারে প্রদর্শন করা যেমন ""প্রশ্নের প্রথম পুনর্বিবেচনায় স্পষ্টভাবে অনুমোদিত। বর্তমান পুনর্বিবেচনায় "যে কোনও সুবিধাজনক ফর্ম্যাট ... সাধারণত নেত্রের স্ট্রিং রিরেস্টেশন অ্যারে" বলা হয়েছে।

— জন ডিভোরাক

2

ইউনিক্স সরঞ্জাম, 100 বাইট

grep -o '[-0-9]*'|awk '{print(++A[$0]-2)?$0:"] ["}'|paste -sd' '|sed -e '/]/s/.*/[\0]/' -e's//[\0]/'

স্টিডিনের মাধ্যমে ইনপুট ব্যতীত। এটি মূলত প্রতিটি দ্বিতীয় ঘটনাকে প্রতিস্থাপন করে "] ["। খালি স্ট্রিং দিয়ে কাজ করে না, []একটি খালি স্ট্রিং দেবে, যা আমি মনে করি খালি অ্যারের সুবিধাজনক উপস্থাপনা :)

— pgy
সূত্র

ঠিক আছে, তাহলে উত্তরটি অনুমান করা হচ্ছে না, তাই না? (নেতিবাচক পূর্ণসংখ্যা সম্পর্কে)। এছাড়াও, কি সম্পর্কে 11? এটি কি রূপান্তরিত হবে 1][?

— অপ্টিমাইজার

এটি 11 এর জন্য ভালভাবে কাজ করে তবে আপনি নেতিবাচক সংখ্যা সম্পর্কে সঠিক, এটি ঠিক করেছেন এবং এটি এখন সিঙ্গলটন অ্যারে গ্রহণ করে।

— pgy

2

এপিএল, 42 টি অক্ষর

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}

উদাহরণ:

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}2 1 1 2 3 2 2 4 5 6 7 3 7 0 5

আউটপুট:

( 2 1  )(   )(  3 2 2 4 5 6 7  )(   )(  0  )(  )

এখানে পরীক্ষিত।

যদি আমার অবশ্যই একটি স্ট্রিং আউটপুট করতে হয় যা এপিএলে সঠিক কাঠামো হিসাবে ব্যাখ্যা করা হয় ... 49 টি অক্ষর

{'1↓1(',',⍬)',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂',⍬)('}

— jimmy23013
সূত্র

কীভাবে কোনও নেস্টেড তালিকা এপিএলে উপস্থাপন করা হয়? হতে পারে আপনার স্ট্রিং ম্যানিপুলেশন করতে হবে না

— অপটিমাইজর

@ অপ্টিমাইজার আউটপুট স্ট্রিং একটি এপিএল প্রোগ্রামের একটি বৈধ তালিকা। তবে এটিতে কেবল একটি তালিকা থাকলে এটি নেস্ট করা হবে না। 1↓1সমস্যার সমাধান করার জন্য একটি প্রস্তুতি নেওয়া , তবে এটি অত্যন্ত অদ্ভুত দেখাচ্ছে।

— jimmy23013

2

জাভা, 223

এটি কেবল ওরাকল বা ওপেনজেডিকে জেআরই-তে কাজ করে, যেহেতু আমি ভেরিয়েবল-দৈর্ঘ্যের চেহারা-পিছনে বাস্তবায়নের জন্য লাক-পেছনে তাদের কোয়ানটিফায়ার এবং দৈর্ঘ্যের চেক প্রয়োগের ক্ষেত্রে এই তর্কটি ব্যবহার করি ।

class W{public static void main(String a[]){System.out.print("["+new java.util.Scanner(System.in).nextLine().replaceAll(" *\\b(\\d+)\\b(?=(.*))(?<=^(?=(.*\\b\\1\\b){2}\\2).*)(?<!^(?=(.*\\b\\1\\b){3}\\2).*) *","] [")+"]");}}

বেশিরভাগ কাজ রেগেক্সে করা হয়, যা কাঁচা আকারে নীচে দেখানো হয়েছে:

 *\b(\d+)\b(?=(.*))(?<=^(?=(.*\b\1\b){2}\2).*)(?<!^(?=(.*\b\1\b){3}\2).*) *

উপরের রেজেক্সের দিকে নজর দেওয়ার আগে আসুন আমরা সমতুল্য। নেট এনজেজেक्सটি দেখি যা এটি সহজ, যেহেতু এটি সরাসরি পরিবর্তনশীল-দৈর্ঘ্যের লুক-ব্যাককে সমর্থন করে (। নেট লুক-ব্যাকটি সম্ভবত ডান থেকে বাম ম্যাচিং মোড দ্বারা সম্পন্ন হয়) :

 *\b(\d+)\b(?<=(.*\b\1\b){2})(?<!(.*\b\1\b){3}) *

*\b(\d+)\bএবং *শেষে একটি সংখ্যা এবং পার্শ্ববর্তী স্পেসগুলির সাথে মেলে (যদি থাকে)। আবদ্ধ চেকগুলি হ'ল আংশিক সংখ্যাটি মিলে যাওয়া থেকে রক্ষা করা, যেহেতু উভয় পক্ষের স্থানগুলি alচ্ছিক। এটি অ্যারেতে 2 য় উপস্থিতি কিনা তা যাচাই করতে এটি নম্বরও ক্যাপচার করে।
(?<=(.*\b\1\b){2})উপরের রেকর্ড করা সংখ্যার 2 টি উদাহরণ খুঁজে পাওয়া যায়। (?<!(.*\b\1\b){3})ধরা পড়ে এমন সংখ্যার 3 টি উদাহরণ খুঁজে পাওয়া যাবে না। উভয় শর্ত সম্মিলিতভাবে দাবি করে যে এখন পর্যন্ত সংখ্যার মাত্র 2 টি উদাহরণ রয়েছে। সম্পূর্ণ নম্বর পরীক্ষা করা হয়েছে তা নিশ্চিত করার জন্য আবদ্ধ চেকগুলি রয়েছে।

জাভা সংস্করণে ফিরে যান। পিছনে পরিবর্তনশীল দৈর্ঘ্যের চেহারা বাস্তবায়নের জন্য, আমরা রূপান্তর করি

(?<=var-length-pattern)

প্রতি

(?<=^(?=.*var-length-pattern).*)

^{আমি এই বিষয়ে কিছুটা হাত বোলছি . লাইন বিভাজককে বাদ দেয় , তবে এটি সহজেই সংশোধন করা যায় এবং বাক্য গঠনটি আরও জটিল করতে চাই না।}

চেহারা-আগাম সবসময় দৈর্ঘ্যে 0 হয় এবং দৈর্ঘ্যের চেকটি বাস্তবায়নের কারণে পাস হয় * কোয়ান্টিফায়ার ।

^এটি কাজ করা করার প্রয়োজন নেই, কিন্তু এটি আছে ব্যর্থ ক্ষেত্রে দ্রুত ব্যর্থ করা। ওরাকল / ওপেনজেডিকে বাস্তবায়নটি প্যাটার্নটির সর্বনিম্ন দৈর্ঘ্য পিছনে পিছনে পদক্ষেপের পরে সম্পন্ন করা হবে, তারপরে ধুয়ে ফেলুন এবং কোনও ম্যাচ না পাওয়া পর্যন্ত দৈর্ঘ্য বাড়িয়ে পুনরাবৃত্তি করুন এবং সবচেয়ে খারাপ অবস্থায় প্যাটার্নটির সর্বাধিক দৈর্ঘ্যে । এর সাথে ^, আমি নিশ্চিত করছি যে উপসর্গের স্ট্রিংটি কেবল একবারে মেলে।

যাইহোক, চেহারা-পিছনের অভ্যন্তরের চেহারা-সামনের দিকটি লুক-পিছনের ডান-সীমানার দ্বারা সীমাবদ্ধ নয়, সুতরাং এটি স্ট্রিংয়ের শেষের সমস্ত দিকের সাথে মেলাতে পারে। সীমানা দৃsert় করার জন্য, আমি সামনের দিকে তাকানোর মধ্যে বাকী স্ট্রিংটিকে অন্য ক্যাপচারিং গ্রুপে ক্যাপচার করি এবং পরিবর্তনশীল দৈর্ঘ্যের প্যাটার্নের সীমাবদ্ধ করতে এটি ব্যবহার করি।

(?=(.*))(?<=^(?=.*var-length-pattern\m).*)
   ^--^                              ^
   mth capturing group               m is the number of the capturing group marked

যেহেতু আমার প্যাটার্নটি ইতিমধ্যে শুরু হয়েছে .*, তাই আমাকে .*সামনে আর যোগ করার দরকার নেই ।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
সূত্র

1

পার্ল 108

map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";push@a,[@b];s/.*/Data::Dumper->Dump(\@a)/e;

কর্মে:

perl -MData::Dumper -pe '
    $Data::Dumper::Terse = 1;
    $Data::Dumper::Indent = 0;
    @a=@b=@e=();
    map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";
    push@a,[@b];
    s/.*/Data::Dumper->Dump(\@a)/e;
' <<<$'2 1 1 2 3 2 2 4 5 6 7 3 7 0 5\n2 1 1 1 4 5 6\n'"$(
    sed 's/./& /g;w/dev/stderr' <<< ${RANDOM}${RANDOM}${RANDOM}$'\n'${RANDOM}${RANDOM})"
2 4 4 7 7 2 9 8 8 4 6 0 1 8 
1 0 3 9 3 7 9 
[2,1][][3,2,2,4,5,6,7][][0][]
[2,1][1,4,5,6]
[2,4][7][][9,8][4,6,0,1,8]
[1,0,3,9][7][]

নোট: দুটি প্রথম লাইন $Data::...কেবলমাত্র ভাল উপস্থাপনার জন্য এবং তৃতীয় লাইনটি @a=@b=@e=();একাধিক লাইনে কাজ করে সরঞ্জামটি তৈরি করার জন্য রয়েছে।

— এফ হাউরি
সূত্র

1

আর, 76

y=scan();r=split(y,cumsum(ave(y,y,FUN=seq)==2));c(r[1],lapply(r[-1],"[",-1))

উদাহরণস্বরূপ ফলাফল: তিনটি খালি ভেক্টর সহ পাঁচটি উপাদানের একটি তালিকা। ( numeric(0))।

$`0`
[1] 2 1

$`1`
numeric(0)

$`2`
[1] 3 2 2 4 5 6 7

$`3`
numeric(0)

$`4`
[1] 0

$`5`
numeric(0)

উপায় দ্বারা: কোডটি একটি সতর্কতা বার্তা উত্পন্ন করে যা উপেক্ষা করা যায়।

— সোভেন হোহেনস্টেইন
সূত্র

1

অ্যাডাব্লিক 29

a[$1]++==1{print"-";next}1

এটি ইনপুট এবং আউটপুট ফর্ম্যাটগুলির সাথে কিছুটা স্বাধীনতা নেয়। ইনপুট "অ্যারে" উল্লম্ব, প্রতি লাইনে এক নম্বর। আউটপুটটি উল্লম্ব, প্রতি লাইনে এক নম্বর, ড্যাশগুলি পৃথক করে অ্যারেগুলি সহ।

ইনপুট:

আউটপুট:

— কেভিন
সূত্র

1

পাইথ 30 32

এটি পাইথের সাথে আমার প্রথমবারের মতো পরীক্ষামূলক। এটি আমার পাইথন সমাধানের মতোই সমাধান।

VQIq/<QN@QN1~Y]:QZN=ZhN;+Y]>QZ

আপনি এটি অনলাইনে চেষ্টা করতে পারেন: পাইথ কম্পাইলার / এক্সিকিউটার

যেমন ইনপুট

[2,1,1,2,3,2,2,4,5,6,7,3,7,0,5]

মুদ্রণ করবে

[[2, 1], [], [3, 2, 2, 4, 5, 6, 7], [], [0], []]

ব্যাখ্যা:

                                 # Q = input(), Y = [], Z = 0
VQ                               # for loop: N iterates over the indices of Q
  I                              # if 
   q\<QN@QN1                     #    Q[N] appears exactly once in Q[:N]
            ~Y]:QZN              #         append the list [Q[Z:N]] to Y
                   =ZhN          #         and assign Z = N + 1
                       ;         # end if and for loop
                        +Y]>QZ   # print Y + [Q[Z:]]

— Jakube
সূত্র

এর জন্য আরও ভাল বিকল্প আছে =Y+Y...?

— জাকুব

- এই হল~Y...

— অপ্টিমাইজার

1

পাইথন 2, 84

l=[[]];p=[]
for x in input():p+=[x];b=p.count(x)==2;l+=[[]]*b;l[-1]+=[x][b:]
print l

তালিকাটি lএখনও পর্যন্ত আউটপুট। আমরা উপাদানগুলির উপর পুনরাবৃত্তি। বর্তমানের যদি দ্বিতীয় উপস্থিতি হয় তবে আমরা একটি নতুন খালি সাবলিস্ট শুরু করি; অন্যথায়, আমরা এটি সর্বশেষ সাবলিস্টে যুক্ত করব। এখনও অবধি দেখা উপাদানগুলির তালিকা সঞ্চিত আছে p। আশ্চর্যের বিষয় হল, তালিকাটি পুনর্গঠন করা ইনপুটটি স্লাইস করার চেয়ে কম মনে হচ্ছে।

— xnor
সূত্র

1

খাঁটি বাশ 111 94

81 শুধুমাত্র বিভাজনের জন্য:

for i;do [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i;b[i]+=7;done;c+=("${d# }")
declare -p c

দ্বিতীয় লাইন declare -p c কেবল ভেরিয়েবলটিকে ডাম্প করছে

নমুনা:

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    declare -p c
}

নোট: লাইনটি local b c d iকেবল কয়েকবার ফাংশনটি চালানোর জন্য প্রয়োজন।

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
declare -a c='([0]="2 1" [1]="" [2]="3 2 2 4 5 6 7" [3]="" [4]="0" [5]="")'

splitIntFunc 2 1 1 1 4 5 6
declare -a c='([0]="2 1" [1]="1 4 5 6")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
1 6 5 3 2 2 4 3 9 4 2 9 7 7 4 
declare -a c='([0]="1 6 5 3 2" [1]="4" [2]="9" [3]="2" [4]="7" [5]="4")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 4 5 2 9 1 1 4 8 7 8 1 0 3 
declare -a c='([0]="2 4 5" [1]="9 1" [2]="" [3]="8 7" [4]="1 0 3")'

যৌনতম উপস্থাপনার জন্য (+26)

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    printf -v l "(%s) " "${c[@]}"
    echo "<$l>"

এর মতো কিছু রেন্ডার করবে:

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
<(2 1) () (3 2 2 4 5 6 7) () (0) () >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
4 3 8 1 4 5 7 9 2 7 8 4 0 
<(4 3 8 1) (5 7 9 2) () (4 0) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
3 1 3 0 2 5 3 6 6 9 2 5 5 
<(3 1) (0 2 5 3 6) (9) () (5) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 2 2 9 1 9 5 0 2 2 7 6 5 4 
<(2) (2 9 1) (5 0 2 2 7 6) (4) >


}

— এফ হাউরি
সূত্র

0

স্কালা, 122 111

অক্ষর সংগ্রহ করুন [21][][3224567][][0][], ~~122~~ 111 আকারে মুদ্রণ করুন :

def s(a:Any*)=print((("[","")/:a){case((b,c),d)=>if(b.indexOf(d)==c.indexOf(d))(b+d,c)else(b+"][",c+d)}._1+"]")

... অথবা একটি অক্ষর সংগ্রহ করুন এবং নেস্টেড তালিকাগুলি ফিরিয়ে দিন, ~~135~~ 129:

def s(a:Char*)=(("",List(List[Any]()))/:a){case((b,c),d)=>b+d->(if(b.count(d==)==1)List()::c else(c.head:+d)::c.tail)}._2.reverse

আমি নিশ্চিত যে আমি কিছু সঞ্চয় পেতে পারি, আমি খুব শক্ত করে দেখিনি।

— চাদ রেটজ
সূত্র

0

পাইথন 220 বাইট

নীচে 220 বাইট রয়েছে যা অন্যদের অনেকের সাথে তুলনা করে দুর্দান্ত নয় তবে বৃহত্তর পূর্ণসংখ্যার সাথে দ্রুত যথেষ্ট রান করে!

xlist = list(input()); result = []; x = 0
for i in range(len(xlist)):
    if xlist[0:i+1].count(xlist[i]) == 2: result.append(xlist[x:i]);x = i+1
    elif i == len(xlist)-1: result.append(xlist[x:])
print(result)

— এস রিক
সূত্র

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

— Rɪᴋᴇʀ

হ্যালো! যদি আপনার সাহায্যের golfing প্রয়োজন হয়, আপনি স্পেস প্রায় অপসারণ করতে পারেন =, পরিবর্তন xlistএবং resultখাটো নাম, এবং প্রায় শূণ্যস্থান অপসারণ ==, ;এবং :। আপনার যদি আরও সহায়তার প্রয়োজন হয় তবে কেবল টাইপ করুন @NoOneIsHere(বা কোনও ব্যবহারকারীর নাম) এবং আমি / ব্যবহারকারী সাহায্য করার চেষ্টা করব।

— NoOneIsHere

-1

জাভা: 563 বাইট

নোট করুন এটি জাভা 8 ব্যবহার করে, প্রাক-জেডিকে 8 পূর্বাভাসের কারণে কয়েক বাইট দীর্ঘ হবে।

import java.util.*;public class a{static String c(String[]b){List<String>d=new ArrayList<>(Arrays.asList(b));Set<String>e=new HashSet<>();Set<String>f=new HashSet<>();for(int i=0;i<Integer.MAX_VALUE;i++){String g;try{g=d.get(i);}catch(IndexOutOfBoundsException ex){break;}
if(e.contains(g)&&!f.contains(g)){d.remove(i);d.add(i,"]");d.add(i+1,"[");f.add(g);i++;}else{e.add(g);}}
d.add(0,"[[");d.add(d.size(),"]]");StringBuilder sb=new StringBuilder();d.forEach(sb::append);return sb.toString();}
public static void main(String[]args){System.out.println(c(args));}}

— PoweredByRice
সূত্র

আমি আর কোথায় ল্যাম্বডা ব্যবহার করতে পারি? অ্যারের দৈর্ঘ্য হওয়া পর্যন্ত লুপিং সঠিক নয় কারণ আপনি আরও "]" এবং "[" যোগ করার সাথে তালিকাকে প্রসারিত রাখা যায়।

— পাওয়ারেডবাইরাইস

প্রতিবার দৈর্ঘ্য বাড়ানো ব্যতিক্রম ধরা পড়ার মতোই লম্বা, এছাড়াও জাভাতে সিইলিং পরিবর্তন করা সম্ভব বলে আমি মনে করি না (i = 0; i <CEILING; i++)।

— পাওয়ারেডবাইরাইস

সত্যি ?

— অপ্টিমাইজার

হুম এটা জানত না, নির্দেশ করার জন্য ধন্যবাদ।

— পাওয়ার্ডবাইরাইস

কি রূপান্তর সম্পর্কে Integer.MAX_VALUEকরার2147483647 ? এটি কম বাইট সহ একই মান। এছাড়াও, IndexOutOfBoundsExceptionছোট করা যেতে পারেException

— চার্লি

একটি স্প্লিট দ্বিতীয় চেয়ে ছোট!

চ্যালেঞ্জ

বিধি

স্কোরিং

এপিএল 25

এপিএল (ডায়ালগ 14) (31)

জে, 28 24 চর

গণিত, 58 51 49 বাইট

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

পাইথন, 148 বাইট

উদার সংস্করণ

হাস্কেল, 115 113 106 88

রুবি 66 ডেমো

পাইথন: 100 বাইট

রুবি, 66

ব্যাখ্যা

সিজেম, 25 24 বাইট

রুবি, 64 বাইট

পার্ল 5: 36

সিজেম, 28 বাইট

ব্যাখ্যা

ইউনিক্স সরঞ্জাম, 100 বাইট

এপিএল, 42 টি অক্ষর

জাভা, 223

পার্ল 108

আর, 76

অ্যাডাব্লিক 29

পাইথ 30 32

ব্যাখ্যা:

পাইথন 2, 84

খাঁটি বাশ 111 94

যৌনতম উপস্থাপনার জন্য (+26)

স্কালা, 122 111

পাইথন 220 বাইট

জাভা: 563 বাইট