Class Lists

একটি অবস্থানে একটি আইটেম ঢোকায়; সেই অবস্থান থেকে আইটেমগুলি এক ঘর উপরে সরে যায়।

উদাহরণ: [10, 20, 30, 40] 99 সূচক 2 এ -> [10, 20, 99, 30, 40]

মূল তালিকার কয়েকটি অবস্থানে একই আইটেম ঢোকায়।

উদাহরণ: [10, 20, 30] 99 সূচক [0, 2] এ -> [99, 10, 20, 99, 30]

কয়েকটি আইটেম ঢোকায়, প্রথমটি প্রথম সূচকে, দ্বিতীয়টি দ্বিতীয়টিতে, এবং এভাবে চলতে থাকে, সবই মূল তালিকার উপর গুনে।

সূচকগুলি ঊর্ধ্বক্রমে হতে হবে এবং প্রতিটি আইটেমের জন্য একটি থাকতে হবে, নাহলে একটি ত্রুটি থ্রো হয়। উদাহরণ: [10, 20, 30] আইটেম [88, 99] সূচক [1, 2] এ -> [10, 88, 20, 99, 30]

তালিকার শেষে একটি আইটেম যোগ করে।

উদাহরণ: [10, 20, 30] 40 যোগ করলে -> [10, 20, 30, 40]

তালিকার শুরুতে একটি আইটেম যোগ করে।

উদাহরণ: [10, 20, 30] 5 সামনে যোগ করলে -> [5, 10, 20, 30]

তালিকার শুরুতে বা শেষে একটি আইটেম যোগ করে, যেমন বাছাই করা হয়।

উদাহরণ: [10, 20, 30] 5 প্রথমে যোগ করলে -> [5, 10, 20, 30]; শেষে -> [10, 20, 30, 5]

কয়েকটি তালিকাকে একটিতে জোড়ে, একটির পর একটি।

উদাহরণ: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]

কিছু ছাড়া একটি নতুন তালিকা তৈরি করে।

উদাহরণ: -> []

একই আইটেম কয়েকবার ধারণকারী একটি তালিকা তৈরি করে।

উদাহরণ: 5 তিনবার -> [5, 5, 5]

আইটেমের একটি প্যাটার্ন বারবার পুনরাবৃত্তি করে যতক্ষণ না তালিকাটি একটি দেওয়া দৈর্ঘ্যে পৌঁছায়।

উদাহরণ: [1, 2, 3] দৈর্ঘ্য 7 পর্যন্ত -> [1, 2, 3, 1, 2, 3, 1]

আইটেমগুলির ক্রম উল্টে দেয়।

উদাহরণ: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]

আইটেমগুলিকে একটি এলোমেলো ক্রমে রাখে, প্রতিটি কলে আলাদা।

উদাহরণ: [1, 2, 3, 4, 5] -> সম্ভবত [3, 1, 5, 2, 4]

তালিকার একটি তালিকাকে পাশ ফেরায়: সারিগুলি কলাম হয় এবং কলামগুলি সারি হয়।

সব ভিতরের তালিকার দৈর্ঘ্য একই হতে হবে। উদাহরণ: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

তালিকাটিকে n আইটেমের দলে ভাগ করে।

শেষে বাকি থাকা আইটেমগুলি বাদ পড়ে যদি না keepRemainder চালু থাকে, যা সেগুলিকে একটি ছোট শেষ দল হিসেবে যোগ করে। উদাহরণ: [0, 1, 2, 3, 4, 5, 6, 7, 8] 3 এর দলে -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

তালিকার একটি অবস্থানের আইটেমটি পড়ে, 0 থেকে গুনে।

তালিকার বাইরের সূচক একটি ত্রুটি থ্রো করে। উদাহরণ: [10, 20, 30, 40] সূচক 2 এ -> 30

তালিকার প্রথম আইটেমটি পড়ে।

উদাহরণ: [10, 20, 30, 40] -> 10

তালিকার শেষ আইটেমটি পড়ে।

উদাহরণ: [10, 20, 30, 40] -> 40

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

উদাহরণ: [1, 2, 3, 4, 5] থ্রেশহোল্ড 0.5 সহ -> সম্ভবত [1, 3, 5]

একটি শুরুর সূচক থেকে একটি শেষ সূচক পর্যন্ত, কিন্তু সেটি বাদ দিয়ে, আইটেমগুলি কেটে নেয়।

উদাহরণ: [10, 20, 30, 40, 50] 1 থেকে 4 পর্যন্ত -> [20, 30, 40]

প্রতি n-তম আইটেম রাখে, একটি অফসেট থেকে শুরু করে।

উদাহরণ: [0, 1, 2, 3, 4, 5, 6, 7, 8] nth 3 ও অফসেট 0 সহ -> [0, 3, 6]; nth 2 ও অফসেট 1 সহ -> [1, 3, 5, 7]

একটি পুনরাবৃত্ত true/false প্যাটার্ন যেখানে true বলে সেই আইটেমগুলি রাখে এবং অন্যগুলি বাদ দেয়।

প্যাটার্নটি ফুরিয়ে গেলে আবার শুরু হয়। উদাহরণ: [0, 1, 2, 3, 4, 5] প্যাটার্ন [true, true, false] সহ -> [0, 1, 3, 4]

নেস্টেড তালিকাগুলিকে অবস্থান অনুসারে পুনরায় দলবদ্ধ করে: প্রতিটি তালিকার প্রথম আইটেমগুলি একসাথে যায়, তারপর দ্বিতীয় আইটেমগুলি, এবং এভাবে চলতে থাকে।

level বলে প্রতিটি তালিকার ভিতরে প্রথমে কত স্তরের নেস্টিং সমতল করতে হবে; 0 সেগুলিকে যেমন আছে তেমনই পুনরায় দলবদ্ধ করে। উদাহরণ: [[0, 1, 2], [3, 4, 5]] level 0 এ -> [[0, 3], [1, 4], [2, 5]]

কয়েকটির মধ্যে দীর্ঘতম তালিকাটি মাপে।

উদাহরণ: [[1, 2], [3, 4, 5, 6], [7]] -> 4

একটি আইটেম তালিকায় আছে কিনা বলে।

আইটেমগুলি পরিচয় দিয়ে তুলনা করা হয়, তাই একটি অবজেক্ট শুধু তখনই পাওয়া যায় যদি হুবহু একই অবজেক্টটি তালিকায় থাকে। উদাহরণ: [10, 20, 30, 40] 30 অন্তর্ভুক্ত -> true, 50 অন্তর্ভুক্ত -> false

একটি আইটেমের প্রথম উপস্থিতির অবস্থান খুঁজে বের করে, অথবা এটি তালিকায় না থাকলে -1।

উদাহরণ: [10, 20, 30, 20, 40] 20 খুঁজলে -> 1, 50 খুঁজলে -> -1

তালিকার ভিতরে তালিকাগুলি কত গভীরে নেস্টেড তা মাপে।

উদাহরণ: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3

তালিকার আইটেমগুলি গোনে।

উদাহরণ: [10, 20, 30, 40, 50] -> 5, [] -> 0

একটি অবস্থানের আইটেমটি সরায়।

উদাহরণ: [10, 20, 30, 40, 50] সূচক 2 সরালে -> [10, 20, 40, 50]

প্রথম আইটেমটি সরায়।

উদাহরণ: [10, 20, 30, 40] -> [20, 30, 40]

শেষ আইটেমটি সরায়।

উদাহরণ: [10, 20, 30, 40] -> [10, 20, 30]

শেষ থেকে গুনে একটি আইটেম সরায়: সূচক 0 শেষ আইটেম, 1 তার আগেরটি।

উদাহরণ: [10, 20, 30, 40, 50] শেষ থেকে সূচক 1 সরালে -> [10, 20, 30, 50]

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

উদাহরণ: [10, 20, 30, 40, 50] সূচক [1, 3] সরালে -> [10, 30, 50]

এটিকে দেওয়া তালিকাটি খালি করে, জায়গাতেই: একই অ্যারে কোনো আইটেম ছাড়া ফেরত আসে।

উদাহরণ: [10, 20, 30, 40] -> []

প্রতি n-তম আইটেম সরায়, একটি অফসেট থেকে শুরু করে।

উদাহরণ: [0, 1, 2, 3, 4, 5, 6, 7, 8] nth 3 ও অফসেট 0 সহ -> [1, 2, 4, 5, 7, 8]

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

উদাহরণ: [1, 2, 3, 4, 5] থ্রেশহোল্ড 0.5 সহ -> সম্ভবত [2, 4]

পুনরাবৃত্ত সংখ্যাগুলি সরায়, প্রতিটির প্রথম উপস্থিতি রেখে।

উদাহরণ: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]

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

উদাহরণ: [1.0, 1.001, 2.0, 2.002, 3.0] টলারেন্স 0.01 সহ -> [1.0, 2.0, 3.0]

যেকোনো ধরনের পুনরাবৃত্ত আইটেম সরায়, প্রতিটির প্রথম উপস্থিতি রেখে।

আইটেমগুলি পরিচয় দিয়ে তুলনা করা হয়, তাই দেখতে সমান দুটি অবজেক্ট দুটোই থাকে। উদাহরণ: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

সংখ্যাগুলিকে সবচেয়ে ছোট থেকে সবচেয়ে বড়, বা সবচেয়ে বড় থেকে সবচেয়ে ছোট ক্রমে সাজায়।

উদাহরণ: [5, 2, 8, 1, 9] ঊর্ধ্বক্রমে -> [1, 2, 5, 8, 9]; নিম্নক্রমে -> [9, 8, 5, 2, 1]

টেক্সটগুলিকে বর্ণানুক্রমে সাজায়, A থেকে Z বা Z থেকে A।

উদাহরণ: ['dog', 'apple', 'cat'] ঊর্ধ্বক্রমে -> ['apple', 'cat', 'dog']

অবজেক্টগুলিকে তাদের একটি প্রপার্টিতে থাকা সংখ্যা দিয়ে সাজায়।

উদাহরণ: [{age: 30}, {age: 20}, {age: 25}] 'age' দিয়ে ঊর্ধ্বক্রমে -> [{age: 20}, {age: 25}, {age: 30}]

কয়েকটি তালিকাকে পালাক্রমে প্রতিটির প্রথম আইটেম নিয়ে, তারপর প্রতিটির দ্বিতীয়টি, এবং এভাবে চলতে থেকে একটিতে বোনে।

একটি ছোট তালিকা ফুরিয়ে গেলে সহজেই বাদ পড়ে। তালিকার একটি খালি তালিকা একটি ত্রুটি থ্রো করে। উদাহরণ: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]