স্ট্রিং থেকে প্রথম চরিত্রটি সরানোর সহজতম উপায় কী?

Question

উদাহরণ:

[12,23,987,43

প্রথম চরিত্রটির জন্য [সম্ভবত "তবে " ব্যবহার করে " " মুছে ফেলার দ্রুত, সবচেয়ে কার্যকর উপায় কোনটি chop()?

Comments

আমি আমার উত্তর সম্পাদনা করেছি, তাই আপনার নির্বাচিত উত্তর পরিবর্তন করা সম্ভব হতে পারে। দেখুন যে আপনি জেসন স্ট্রিকের উত্তরে এটি পুরষ্কার দিতে পারেন যেহেতু তিনি সবচেয়ে দ্রুত এবং খুব পঠনযোগ্য।

— টিন ম্যান

Str [1 ..- 1] ব্যবহার করুন, এটি নীচের উত্তর অনুসারে দ্রুততম।

— আচ্যুত রাস্তোগি

রুবি 2.5 হিসাবে আপনি ব্যবহার করতে পারেন delete_prefixএবং delete_prefix!- নীচে আরও বিশদ । আমার কাছে বেঞ্চমার্ক করার সময় হয়নি, তবে শীঘ্রই করব!

— SRack

আপডেট: আমি নতুন পদ্ধতিগুলি ( delete_prefix\ delete_prefix!) বেঞ্চমার্ক করেছি এবং সেগুলি বেশ দ্রুত। গতির জন্য পূর্বের পছন্দগুলি পুরোপুরি পাইপ করবেন না, তবে পঠনযোগ্যতার অর্থ তারা হ'ল দুর্দান্ত বিকল্প রয়েছে!

— এসআরাক

Answer 1

আমি এরকম কিছু ব্যবহার করে পছন্দ করি:

এসএসডিএফ = "[12,23,987,43"
এসএসডিএফ [0] = '' 

পি এসএসডিএফ
# >> "12,23,987,43"

---

আমি সবসময় কাজ করার দ্রুত এবং সর্বাধিক পঠনীয় উপায়ের সন্ধান করি:

require 'benchmark'

N = 1_000_000

puts RUBY_VERSION

STR = "[12,23,987,43"

Benchmark.bm(7) do |b|
  b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
  b.report('sub') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }

  b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
  b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
  b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
  b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }

end

আমার ম্যাক প্রোতে চলছে:

1.9.3
              user     system      total        real
[0]       0.840000   0.000000   0.840000 (  0.847496)
sub       1.960000   0.010000   1.970000 (  1.962767)
gsub      4.350000   0.020000   4.370000 (  4.372801)
[1..-1]   0.710000   0.000000   0.710000 (  0.713366)
slice     1.020000   0.000000   1.020000 (  1.020336)
length    1.160000   0.000000   1.160000 (  1.157882)

---

আরও একটি প্রস্তাবিত উত্তর অন্তর্ভুক্ত করার জন্য আপডেট করা:

require 'benchmark'

N = 1_000_000

class String
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end

  def first(how_many = 1)
    self[0...how_many]
  end

  def shift(how_many = 1)
    shifted = first(how_many)
    self.replace self[how_many..-1]
    shifted
  end
  alias_method :shift!, :shift
end

class Array
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end
end

puts RUBY_VERSION

STR = "[12,23,987,43"

Benchmark.bm(7) do |b|
  b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
  b.report('sub') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }

  b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
  b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
  b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
  b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }
  b.report('eat!') { N.times { "[12,23,987,43".eat! } }
  b.report('reverse') { N.times { "[12,23,987,43".reverse.chop.reverse } }
end

যার ফলাফল:

2.1.2
              user     system      total        real
[0]       0.300000   0.000000   0.300000 (  0.295054)
sub       0.630000   0.000000   0.630000 (  0.631870)
gsub      2.090000   0.000000   2.090000 (  2.094368)
[1..-1]   0.230000   0.010000   0.240000 (  0.232846)
slice     0.320000   0.000000   0.320000 (  0.320714)
length    0.340000   0.000000   0.340000 (  0.341918)
eat!      0.460000   0.000000   0.460000 (  0.452724)
reverse   0.400000   0.000000   0.400000 (  0.399465)

---

এবং অন্যটি /^./প্রথম অক্ষরটি খুঁজে পেতে ব্যবহার করছে:

require 'benchmark'

N = 1_000_000

class String
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end

  def first(how_many = 1)
    self[0...how_many]
  end

  def shift(how_many = 1)
    shifted = first(how_many)
    self.replace self[how_many..-1]
    shifted
  end
  alias_method :shift!, :shift
end

class Array
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end
end

puts RUBY_VERSION

STR = "[12,23,987,43"

Benchmark.bm(7) do |b|
  b.report('[0]') { N.times { "[12,23,987,43"[0] = '' } }
  b.report('[/^./]') { N.times { "[12,23,987,43"[/^./] = '' } }
  b.report('[/^\[/]') { N.times { "[12,23,987,43"[/^\[/] = '' } }
  b.report('sub+') { N.times { "[12,23,987,43".sub(/^\[+/, "") } }
  b.report('sub') { N.times { "[12,23,987,43".sub(/^\[/, "") } }
  b.report('gsub') { N.times { "[12,23,987,43".gsub(/^\[/, "") } }
  b.report('[1..-1]') { N.times { "[12,23,987,43"[1..-1] } }
  b.report('slice') { N.times { "[12,23,987,43".slice!(0) } }
  b.report('length') { N.times { "[12,23,987,43"[1..STR.length] } }
  b.report('eat!') { N.times { "[12,23,987,43".eat! } }
  b.report('reverse') { N.times { "[12,23,987,43".reverse.chop.reverse } }
end

যার ফলাফল:

# >> 2.1.5
# >>               user     system      total        real
# >> [0]       0.270000   0.000000   0.270000 (  0.270165)
# >> [/^./]    0.430000   0.000000   0.430000 (  0.432417)
# >> [/^\[/]   0.460000   0.000000   0.460000 (  0.458221)
# >> sub+      0.590000   0.000000   0.590000 (  0.590284)
# >> sub       0.590000   0.000000   0.590000 (  0.596366)
# >> gsub      1.880000   0.010000   1.890000 (  1.885892)
# >> [1..-1]   0.230000   0.000000   0.230000 (  0.223045)
# >> slice     0.300000   0.000000   0.300000 (  0.299175)
# >> length    0.320000   0.000000   0.320000 (  0.325841)
# >> eat!      0.410000   0.000000   0.410000 (  0.409306)
# >> reverse   0.390000   0.000000   0.390000 (  0.393044)

---

দ্রুত হার্ডওয়্যার এবং রুবির নতুন সংস্করণ সম্পর্কে এখানে আরও একটি আপডেট রয়েছে:

2.3.1
              user     system      total        real
[0]       0.200000   0.000000   0.200000 (  0.204307)
[/^./]    0.390000   0.000000   0.390000 (  0.387527)
[/^\[/]   0.360000   0.000000   0.360000 (  0.360400)
sub+      0.490000   0.000000   0.490000 (  0.492083)
sub       0.480000   0.000000   0.480000 (  0.487862)
gsub      1.990000   0.000000   1.990000 (  1.988716)
[1..-1]   0.180000   0.000000   0.180000 (  0.181673)
slice     0.260000   0.000000   0.260000 (  0.266371)
length    0.270000   0.000000   0.270000 (  0.267651)
eat!      0.400000   0.010000   0.410000 (  0.398093)
reverse   0.340000   0.000000   0.340000 (  0.344077)

---

Gsub এত ধীর কেন?

অনুসন্ধান / প্রতিস্থাপন করার পরে, gsubএটি শেষ হয়ে গেছে কিনা তা জানার আগে সম্ভাব্য অতিরিক্ত ম্যাচগুলি পরীক্ষা করতে হবে। subশুধুমাত্র একটি করে এবং শেষ করে। gsubএটি সর্বনিম্ন দুটি subকল হিসাবে বিবেচনা করুন ।

এছাড়াও, এটি মনে রাখা জরুরী gsubএবং subদুর্বল লিখিত রেজেক্স দ্বারাও প্রতিবন্ধী হতে পারে যা সাব-স্ট্রিং অনুসন্ধানের চেয়ে আরও ধীরে ধীরে মেলে। যদি সম্ভব হয় তবে এখান থেকে সর্বাধিক গতি পেতে রেজেক্স অ্যাঙ্কর করুন। স্ট্যাক ওভারফ্লোতে এখানে এমন উত্তর রয়েছে যেগুলি প্রদর্শিত হচ্ছে যাতে আপনি আরও তথ্য চান তবে আশেপাশে অনুসন্ধান করুন।

Comments

এটি লক্ষণীয় গুরুত্বপূর্ণ যে এটি কেবল রুবি ১.৯ এ কাজ করবে। রুবি 1.8, এই প্রথম সরাবে বাইট স্ট্রিং, থেকে না প্রথম অক্ষর, যা কি ওপি চায় নয়।

— Jörg ডব্লু মিট্টাগ

+1: আমি সর্বদা ভুলে গেছি যে স্ট্রিং-পজিশনে আপনি কেবল একটি একক অক্ষরই বরাদ্দ করতে পারবেন না, তবে আপনি একটি স্ট্রিংগুলিও সন্নিবেশ করতে পারেন। ধন্যবাদ!

— কোয়েটজলকোটল

"[12,23,987,43".delete "["

— rupweb

এটি এটিকে সমস্ত অবস্থান থেকে মুছে ফেলে, যা ওপি চেয়েছিল তা নয়: "... প্রথম চরিত্রটির জন্য?"

— টিন ম্যান

" what about "[12,23,987,43".shift ?"? "[12,23,987,43".shift NoMethodError: undefined method "[12,23,987,43": স্ট্রিং`-র শিফট সম্পর্কে কী ?

— টিন ম্যান

Answer 2

উপরের পাবলো এর উত্তরের মতো, তবে একটি ছায়া ক্লিনার:

str[1..-1]

1 থেকে শেষ চরিত্রটিতে অ্যারে ফিরিয়ে দেবে।

'Hello World'[1..-1]
 => "ello World"

Comments

+1 আমি আমার উত্তরে যুক্ত করে দিয়েছি এমন মানদণ্ডের ফলাফলগুলি একবার দেখুন। আপনি দ্রুততম রান-টাইম পেয়েছেন, এবং আমার কাছে মনে হয় এটি খুব পরিষ্কার।

— টিন ম্যান

str[1,]উপরের তুলনায় কর্মক্ষমতা সম্পর্কে কি ?

— বোহর

@ বোহর: str[1,]পরিসীমা হওয়ায় আপনাকে দ্বিতীয় চরিত্রটি ফিরিয়ে দিন 1:nil। str[1,999999]পুরো লেজটি পাওয়ার জন্য আপনাকে প্রকৃত গণনা করা দৈর্ঘ্য বা দৈর্ঘ্যের চেয়ে উচ্চতর গ্যারান্টিযুক্ত কিছু সরবরাহ করতে হবে, যেমন (অবশ্যই int_max ব্যবহার করুন) tail [1..-1]পরিষ্কার এবং সম্ভবত দ্রুততর, যেহেতু আপনাকে ম্যানুয়ালি দৈর্ঘ্যের উপর পরিচালনা করতে হবে না (বেঞ্চমার্কে [[1.. দৈর্ঘ্য] দেখুন)

— কোয়েটজলক্যাটল

খুব সুন্দর সমাধান। উপায় দ্বারা যদি কেউ প্রথম এবং শেষ অক্ষরগুলি সরাতে চায়:str[1..-2]

— পিসারুক

Answer 3

এটি করার জন্য আমরা স্লাইস ব্যবহার করতে পারি:

val = "abc"
 => "abc" 
val.slice!(0)
 => "a" 
val
 => "bc" 

ব্যবহার করে slice!আমরা যে কোনও চরিত্রের সূচক নির্দিষ্ট করে মুছতে পারি।

Comments

এই মার্জিতটি slice!(0)সত্যই নির্বাচিত উত্তর হওয়া উচিত, কারণ asdf[0] = '' প্রথম চরিত্রটি সরিয়ে ফেলতে ব্যবহার করা হাস্যকর (ঠিক যেমন রেগেক্সের সাথে জিসুব ব্যবহার করা এবং হাউইটজারের সাথে একটি ফ্লাইয়ের শুটিংয়ের মতো)।

— f055

যদিও এটি পৃষ্ঠের উপর অপ্রকাশ্য মনে হতে পারে, []=ততটা অন্তর্নিহিত সি কোডের slice!প্রয়োজন নেই , যেখানে অতিরিক্ত কাজ করা দরকার। যে যোগ করে। যুক্তিটি হতে পারে "কোনটি বেশি পাঠযোগ্য?" আমি []=পঠনযোগ্য ব্যবহার করে দেখতে পাচ্ছি তবে আমি সি -> পার্ল ব্যাকগ্রাউন্ড থেকে আসছি যা সম্ভবত আমার চিন্তাকে রঙিন করে। জাভা বিকাশকারীরা সম্ভবত এটি কম পাঠযোগ্য বলে মনে করবেন। হয় কাজটি সম্পাদন করার একটি গ্রহণযোগ্য উপায় যতক্ষণ না এটি সহজে বোঝা যায় এবং বজায় রাখা যায় এবং সিপিইউকে অযথা লোড না করে।

— টিন ম্যান

ঠিক আছে. আপনি কি জানেন যে কোনও ফাংশন যদি আরওআর-তে বেশি সিপিইউ লোড নেয় তবে আমরা কীভাবে পরিমাপ করতে পারি? অথবা আমাদের মিলি বা ন্যানোসেকেন্ডে মৃত্যুদন্ড কার্যকর করার সময় পার্থক্যটি ব্যবহার করা উচিত?

— বালানভ

Answer 4

রুবি 2.5+

রুবি 2.5 হিসাবে আপনি ব্যবহারযোগ্য delete_prefixবা delete_prefix!এটি পাঠযোগ্য উপায়ে অর্জন করতে পারেন ।

এই ক্ষেত্রে "[12,23,987,43".delete_prefix("[")।

এখানে আরও তথ্য:

• অফিসিয়াল ডকস

• https://blog.jetbrains.com/ruby/2017/10/10-new-features-in-ruby-2-5/

• https://bugs.ruby-lang.org/issues/12694

'invisible'.delete_prefix('in') #=> "visible"
'pink'.delete_prefix('in') #=> "pink"

এনবি আপনি delete_suffixএবং এর সাথে স্ট্রিংয়ের শেষে থেকে আইটেমগুলি সরাতে এটি ব্যবহার করতে পারেনdelete_suffix!

'worked'.delete_suffix('ed') #=> "work"
'medical'.delete_suffix('ed') #=> "medical"

• ডক্স
• https://bugs.ruby-lang.org/issues/13665

সম্পাদনা:

টিন ম্যানের বেঞ্চমার্ক সেটআপটি ব্যবহার করে এটি দেখতে খুব দ্রুত দেখায় (শেষ দুটি প্রবেশের নীচে delete_pএবং delete_p!)। গতির জন্য পূর্বের ফলসগুলিকে পুরোপুরি পাইপ দেয় না , যদিও এটি খুব পঠনযোগ্য।

2.5.0
              user     system      total        real
[0]       0.174766   0.000489   0.175255 (  0.180207)
[/^./]    0.318038   0.000510   0.318548 (  0.323679)
[/^\[/]   0.372645   0.001134   0.373779 (  0.379029)
sub+      0.460295   0.001510   0.461805 (  0.467279)
sub       0.498351   0.001534   0.499885 (  0.505729)
gsub      1.669837   0.005141   1.674978 (  1.682853)
[1..-1]   0.199840   0.000976   0.200816 (  0.205889)
slice     0.279661   0.000859   0.280520 (  0.285661)
length    0.268362   0.000310   0.268672 (  0.273829)
eat!      0.341715   0.000524   0.342239 (  0.347097)
reverse   0.335301   0.000588   0.335889 (  0.340965)
delete_p  0.222297   0.000832   0.223129 (  0.228455)
delete_p!  0.225798   0.000747   0.226545 (  0.231745)

Answer 5

আমি এটি পছন্দ করি:

str = "[12,23,987,43"
puts str[1..-1]
>> 12,23,987,43

Comments

আপনি অন্যান্য উত্তরগুলি পুনরাবৃত্তি করার আগে তাদের চেক করতে চাইতে পারেন। এটি ইতিমধ্যে stackoverflow.com/a/3614642/128421

— টিন ম্যান

Answer 6

আপনি যদি সর্বদা নেতৃস্থানীয় বন্ধনীগুলি সরাতে চান:

"[12,23,987,43".gsub(/^\[/, "")

আপনি যদি কেবলমাত্র প্রথম অক্ষরটি সরাতে চান এবং আপনি জানেন যে এটি কোনও মাল্টিবাইট চরিত্রের সেটে থাকবে না:

"[12,23,987,43"[1..-1]

অথবা

"[12,23,987,43".slice(1..-1)

Comments

আমি এর "[12,23,987,43".sub(/^\[+/, "")পরিবর্তে ব্যবহার করব gsub(/^\[/, "")। প্রথমে রেজেক্স ইঞ্জিনটি সমস্ত মিল খুঁজে পায় তারপরে সেগুলিকে একটি ক্রিয়ায় প্রতিস্থাপন করা হয় এবং রুবি ১.৯.৩ এর সাথে গতিতে প্রায় 2x উন্নতি ঘটায়।

— টিন ম্যান

যেহেতু আমরা স্ট্রিংগুলি নিয়ে কাজ করছি, এটি কি হওয়া উচিত gsub(/\A\[/, "") ?

— সাগর পান্ড্য

Answer 7

অপর্যাপ্ত বিকল্প:

str.reverse.chop.reverse

Answer 8

উদাহরণস্বরূপ: a = "এক দুই তিন"

1.9.2-p290 > a = "One Two Three"
 => "One Two Three" 

1.9.2-p290 > a = a[1..-1]
 => "ne Two Three" 

1.9.2-p290 > a = a[1..-1]
 => "e Two Three" 

1.9.2-p290 > a = a[1..-1]
 => " Two Three" 

1.9.2-p290 > a = a[1..-1]
 => "Two Three" 

1.9.2-p290 > a = a[1..-1]
 => "wo Three" 

এইভাবে আপনি স্ট্রিংয়ের প্রথম অক্ষরটি একে একে মুছে ফেলতে পারেন।

Comments

এটি জেসন স্ট্রিকের উত্তর হিসাবে একই, কেবল তার অনেক মাস আগে জমা দেওয়া হয়েছিল।

— টিন ম্যান

Answer 9

সহজ পথ:

str = "[12,23,987,43"

removed = str[1..str.length]

দুর্দান্ত উপায়:

class String
  def reverse_chop()
    self[1..self.length]
  end
end

"[12,23,987,43".reverse_chop()

(দ্রষ্টব্য: সহজ উপায় পছন্দ করুন :))

Comments

আপনি যদি "চপ" শব্দার্থক সংরক্ষণ করতে চান তবে আপনি কেবল পারেন"[12,23,987,43".reverse.chop.reverse

— ক্রিস হিল্ড

এটি কেবল একটি চর

— পাবলো ফার্নান্দেজ

[১.-... দৈর্ঘ্য] এর চেয়ে [1 ..- 1] ব্যবহার করবেন না কেন?

— ঘোড়াচিকিত্সা

বানরের প্যাচিংয়ের উদাহরণটি এই প্রশ্নের পক্ষে খুব সুন্দর, এটি কেবল অপ্রাসঙ্গিক এবং কুরুচিপূর্ণ IMO।

— dredozubov

Answer 10

মানদণ্ডগুলি একসাথে রাখার জন্য @ দ্য টিন-ম্যানকে ধন্যবাদ!

হায় আফসোস, আমি এই সমাধানগুলির কোনও পছন্দ করি না। হয় ফলাফল পাওয়ার জন্য তাদের একটি অতিরিক্ত পদক্ষেপের প্রয়োজন ( [0] = '', .strip!) অথবা কী ঘটছে সে সম্পর্কে তারা খুব অর্থপূর্ণ / স্পষ্ট নয় ( [1..-1]: "উম, 1 থেকে নেতিবাচক 1 থেকে একরকম? বার্ষিক?"), বা এগুলি ধীর বা দীর্ঘ লিখুন ( .gsub, .length)।

আমরা যা চেষ্টা করছি তা হ'ল 'শিফট' (অ্যারে পার্লেন্সে), তবে যা বদলানো হয়েছিল তার চেয়ে বাকী অক্ষরগুলি ফিরিয়ে দেওয়া। আসুন স্ট্রিং দিয়ে এটি সম্ভব করার জন্য আমাদের রুবি ব্যবহার করুন! আমরা দ্রুত ব্র্যাকেট ক্রিয়াকলাপটি ব্যবহার করতে পারি, তবে এটির একটি ভাল নাম দিন এবং আমরা সামনের অংশটি কতটা ছাঁটাতে চাই তা নির্দিষ্ট করতে একটি তর্ক নিতে:

class String
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end
end

তবে আমরা সেই দ্রুত-তবে-অযৌক্তিক বন্ধনী ক্রিয়াকলাপটি আরও কিছু করতে পারি। আমরা এটিতে থাকাকালীন, সম্পূর্ণতার জন্য, আসুন স্ট্রিংয়ের জন্য একটি লিখি #shiftএবং #firstকেন অ্যারে সমস্ত মজা করা উচিত, আমরা শুরু থেকে কয়টি অক্ষর মুছে ফেলতে চাই তা নির্দিষ্ট করার জন্য একটি তর্কবিতর্ক নেওয়া:

class String
  def first(how_many = 1)
    self[0...how_many]
  end

  def shift(how_many = 1)
    shifted = first(how_many)
    self.replace self[how_many..-1]
    shifted
  end
  alias_method :shift!, :shift
end

ঠিক আছে, এখন আমাদের কাছে একটি স্ট্রিংয়ের সামনে অক্ষরগুলি টানানোর একটি সুস্পষ্ট উপায় রয়েছে যা একটি পদ্ধতির সাথে সামঞ্জস্যপূর্ণ Array#firstএবং Array#shift(যা সত্যই একটি ব্যাং পদ্ধতি হওয়া উচিত ??)। এবং আমরা সহজেই পাশাপাশি পরিবর্তিত স্ট্রিং পেতে পারি #eat!। এইচএম, অ্যারির সাথে আমাদের কী নতুন নতুন eat!শক্তি ভাগ করা উচিত ? কেন না!

class Array
  def eat!(how_many = 1)
    self.replace self[how_many..-1]
  end
end

এখন আমরা পারি:

> str = "[12,23,987,43" #=> "[12,23,987,43"
> str.eat!              #=> "12,23,987,43"
> str                   #=> "12,23,987,43"

> str.eat!(3)           #=> "23,987,43"
> str                   #=> "23,987,43"

> str.first(2)          #=> "23"
> str                   #=> "23,987,43"

> str.shift!(3)         #=> "23,"
> str                   #=> "987,43"

> arr = [1,2,3,4,5]     #=> [1, 2, 3, 4, 5] 
> arr.eat!              #=> [2, 3, 4, 5] 
> arr                   #=> [2, 3, 4, 5] 

এটা তুলনামূলক ভাল!

Comments

আমি পার্ল ফোরামগুলির chip()পরিবর্তে chop()(এবং chimp()এর এনালগ হিসাবে chomp()) নামের সাথে এই জাতীয় ফাংশন সম্পর্কে একটি আলোচনা মনে করি remember

— মার্ক টমাস

Answer 11

str = "[12,23,987,43"

str[0] = ""

Comments

এটি লক্ষণীয় গুরুত্বপূর্ণ যে এটি কেবল রুবি ১.৯ এ কাজ করবে। রুবি 1.8, এই প্রথম সরাবে বাইট স্ট্রিং, থেকে না প্রথম অক্ষর, যা কি ওপি চায় নয়।

— Jörg ডব্লু মিট্টাগ

Answer 12

class String
  def bye_felicia()
    felicia = self.strip[0] #first char, not first space.
    self.sub(felicia, '')
  end
end

Answer 13

রিজেক্স ব্যবহার:

str = 'string'
n = 1  #to remove first n characters

str[/.{#{str.size-n}}\z/] #=> "tring"

Answer 14

আমি str.delete(str[0])এর পাঠ্যতার জন্য একটি দুর্দান্ত সমাধান পেয়েছি, যদিও আমি এর পারফরম্যান্সটির সত্যতা দিতে পারি না।

Answer 15

তালিকা = [1,2,3,4] list.rod (1)

# => [2,3,4]

তালিকাটি অ্যারের শুরু থেকে এক বা একাধিক উপাদানকে ড্রপ করে, অ্যারেটিকে রূপান্তরিত করে না এবং বাদ দেওয়া উপাদানটির পরিবর্তে অ্যারে নিজেই দেয়।