আমি কীভাবে একটি স্ট্রিং বিভক্ত করব ??? Plz সাহায্য করবেন? (কোড ট্রোলিং) [বন্ধ]


21

আমার হোমওয়ার্ক অ্যাসাইনমেন্টটি একটি স্ট্রিং নেবে এবং প্রতিটি নতুন লাইনে এটিকে টুকরো টুকরো করে। আমার কোনো ধারণা নেই কী করতে হবে! সাহায্য করুন!

দ্রষ্টব্য: এটি একটি প্রশ্ন। দয়া করে প্রশ্ন এবং / অথবা উত্তরগুলি গুরুত্ব সহকারে নেবেন না। আরও তথ্য এখানে



@ ব্যবহারকারী1981338, কোড-ট্রোলিং ট্যাগের উইকিটি পড়ুন না।
তুরিয়ান

7
স্ট্রিং বিভাজন সম্পর্কিত আমি এখানে একটি মূল্যবান সংস্থান পেয়েছি ... আমি আশা করি আপনি এটি দরকারী হিসাবে খুঁজে পেয়েছেন! bit.ly/1dSklhO
ওয়াল ওয়েস্ট

সরকারী অবস্থান অনুযায়ী কোড-ট্রোলিং অপসারণের প্রক্রিয়া চলছে এই পোস্টে 75% "ডিলিট" ভোট বেশি পেয়েছেন পোলের । এটিতে প্রশ্ন এবং উত্তরগুলিতে প্রচুর পরিমাণে ভোট রয়েছে তবে এটি 3 মাসেরও বেশি পুরানো এবং কোনও খ্যাতি হারাবে না। অতএব, আমি এটি বন্ধ করছি এবং এটি 24 ঘন্টার মধ্যে মুছে ফেলব। নোট করুন যেহেতু এটি একটি বহিরাগত যেহেতু এতে প্রচুর পরিমাণে ভোট রয়েছে, তাই আমি মেটা সম্পর্কে দৃ conv়প্রত্যয়ী যুক্তি দিয়ে মুছে ফেলা এবং লক করতে পেরে খুশি হব।
ডুরকনব

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

উত্তর:


48

সি

আমার হোমওয়ার্ক অ্যাসাইনমেন্টটি একটি স্ট্রিং নেবে এবং প্রতিটি নতুন লাইনে এটিকে টুকরো টুকরো করে। আমার কোনো ধারণা নেই কী করতে হবে! সাহায্য করুন!

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

একটি স্ট্রিং হল একটি অক্ষর যা কেবলমাত্র অক্ষর দ্বারা গঠিত । এর অর্থ হ'ল প্রোগ্রামাররা একটি "অদৃশ্য" জিনিসটি নির্দেশ করতে (এটি কোনও স্থান নয় যা একটি চরিত্র হিসাবে গণ্য হয়), আপনাকে সেই অদৃশ্য জিনিসটি বোঝাতে কোনওভাবে অক্ষরের একটি বিশেষ ক্রম ব্যবহার করতে হবে ।

  • উপর উইন্ডোজ , নতুন লাইন একটি ক্রম দুই ব্যাকস্ল্যাশ এবং n (বা স্ট্রিং: STRING অক্ষর "\n")

  • উপর লিনাক্স বা ওএস / এক্স Macs- এর , এটা একটি ক্রম চার ব্যাকস্ল্যাশ, এন, ব্যাকস্ল্যাশ, এবং তারপর দ: (অথবা অক্ষর "\n\r")।

(আকর্ষণীয় historicalতিহাসিক দ্রষ্টব্য: পুরানো ম্যাকিনটোশে এটি চারটি চরিত্রের আলাদা ধারা ছিল: "\ r \ n" ... ইউনিক্স কীভাবে কাজ করেছিল তার থেকে পুরোপুরি পিছনে! ইতিহাসটি অদ্ভুত রাস্তা নেয়))

এটি লিনাক্স উইন্ডোজের চেয়ে বেশি অপচয়যোগ্য বলে মনে হতে পারে তবে দীর্ঘতর ক্রমটি ব্যবহার করা আসলে এটি একটি ভাল ধারণা। উইন্ডোজ এই জাতীয় সংক্ষিপ্ত ক্রম ব্যবহার করে সি ভাষার রানটাইম \nবিশেষ সিস্টেম কল ব্যবহার না করে প্রকৃত অক্ষরগুলি মুদ্রণ করতে পারে না । আপনি করতে পারেন সাধারণত একটি সিস্টেম কল (এটা এমনকি মুদ্রণ করতে পারেন ছাড়া লিনাক্স এটা করতে \n\বা \n\q... কিন্তু কিছু \n\r)। সি যেহেতু ক্রস প্ল্যাটফর্ম হিসাবে বোঝানো হয়েছে এটি সর্বনিম্ন সাধারণ-ডিনোমিনেটরকে কার্যকর করে। সুতরাং আপনি সর্বদা \nআপনার বইতে দেখতে পাবেন ।

(দ্রষ্টব্য: আপনি যদি ভাবছেন যে প্রতিবার আমরা কীভাবে \nনিউলাইন না পেয়ে আমরা কীভাবে কথা বলব , স্ট্যাকওভারফ্লো প্রায় পুরোপুরি এইচটিএমএল লেখা হয় ... সি তে নয় তাই এটি অনেক বেশি আধুনিক C সি এর পুরানো দিকগুলির অনেকগুলি হ'ল আপনি শুনেছেন এমন বিষয়গুলির দ্বারা সম্বোধন করা, যেমন ক্ল্যাং এবং এলএলভিএম))

তবে আমরা কী নিয়ে কাজ করছি তা ফিরে। আসুন তিনটি টুকরো এবং দুটি নিউলাইন সহ একটি স্ট্রিং কল্পনা করুন:

"foo\nbaz\nbar"

আপনি দেখতে পাচ্ছেন যে স্ট্রিংয়ের দৈর্ঘ্য 3 + 2 + 3 + 2 + 3 = 13. সুতরাং আপনাকে এর জন্য 13 দৈর্ঘ্যের একটি বাফার তৈরি করতে হবে এবং সি প্রোগ্রামাররা সর্বদা তাদের অ্যারের আকারে নিরাপদ থাকতে একটি যুক্ত করে। সুতরাং আপনার বাফার তৈরি করুন এবং এতে স্ট্রিংটি অনুলিপি করুন:

/* REMEMBER: always add one to your array sizes in C, for safety! */
char buffer[14];
strcpy(buffer, "foo\nbaz\nbar");

এখন আপনাকে যা করতে হবে তা হল দ্বি-চরিত্রের প্যাটার্নটি অনুসন্ধান করা যা নিউলাইনটিকে উপস্থাপন করে। আপনাকে কেবল একটি ব্যাকস্ল্যাশ সন্ধান করার অনুমতি নেই । যেহেতু সি স্ট্রিং বিভক্ত করার জন্য বেশ ব্যবহৃত হয়, আপনি চেষ্টা করলে এটি আপনাকে একটি ত্রুটি দেয়। আপনি লেখার চেষ্টা করলে এটি দেখতে পাবেন:

char pattern[2];
strcpy(pattern, "\");

(দ্রষ্টব্য: সংকলকটিতে একটি সেটিংস রয়েছে যদি আপনি এমন কোনও প্রোগ্রাম লিখছেন যা কেবল ব্যাকস্ল্যাশগুলির সন্ধান করে But তবে এটি অত্যন্ত অস্বাভাবিক; ব্যাকস্ল্যাশ খুব কম ব্যবহার করা হয়, এজন্য এগুলি তাদের এই উদ্দেশ্যে বেছে নেওয়া হয়েছিল We আমরা এটি ঘুরিয়ে দেব না We চালু করা.)

সুতরাং আসুন আমরা এটির মতো প্যাটার্নটি তৈরি করি:

char pattern[3];
strcpy(pattern, "\n");

যখন আমরা দুটি স্ট্রিং তুলনা করতে চাই যা নির্দিষ্ট দৈর্ঘ্যের হয়, আমরা ব্যবহার করি strncmp। এটি সম্ভাব্য বৃহত্তর স্ট্রিংয়ের একটি নির্দিষ্ট সংখ্যক অক্ষরের তুলনা করে এবং সেগুলি মেলে কিনা তা আপনাকে জানায়। সুতরাং strncmp("\nA", "\nB", 2)1 (সত্য) প্রদান করে। এটি স্ট্রিংগুলি তিনটির দৈর্ঘ্যের চেয়ে সম্পূর্ণ সমান নয় যদিও ... তবে কারণ কেবল দুটি অক্ষর হওয়া দরকার।

আমাদের বাফার মাধ্যমে আসুন ধাপে সুতরাং, এক একটি সময়ে চরিত্র, খুঁজছেন দুই আমাদের প্যাটার্ন চরিত্র ম্যাচ। প্রতিবার আমরা যখন এন এর পরে ব্যাকস্ল্যাশের দ্বি-চরিত্রের ক্রম খুঁজে পাই, আমরা একটি বিশেষ ধরণের চরিত্রটি প্রকাশ করতে খুব বিশেষ সিস্টেম কল (বা "সিস্কেল") ব্যবহার করব putc: একটি শারীরিক নিউলাইন পেতে ASCII কোড 10

#include "stdio.h"
#include "string.h"

char buffer[14]; /* actual length 13 */
char pattern[3]; /* actual length 2 */
int i = 0;

int main(int argc, char* argv[]) {
    strcpy(buffer, "foo\nbar\nbaz");
    strcpy(pattern, "\n");

    while (i < strlen(buffer)) {
       if (1 == strncmp(buffer + i, pattern, 2)) {
           /* We matched a backslash char followed by n */
           /* Use syscall for output ASCII 10 */
           putc(10, stdout);
           /* bump index by 2 to skip both backslash and n */
           i += 2;
       } else {
           /* This position didn't match the pattern for a newline */
           /* Print character with printf */
           printf("%c", buffer[i]);
           /* bump index by 1 to go to next matchable position */
           i += 1;
       }
    }

    /* final newline and return 1 for success! */
    putc(10, stdout); 
    return 1;
}

এই প্রোগ্রামের আউটপুটটি কাঙ্ক্ষিত ফলাফল ... স্ট্রিং বিভক্ত!

foo
baz
bar

\t ট্রোলিংয়ের জন্য ...

উপর থেকে নীচে একেবারে ভুল। তবুও পাঠ্যপুস্তক বা উইকিপিডিয়াতে যা আছে তার মতো তথ্য স্ক্র্যাম্বল করে এমন কলুষিত-সাউন্ডিং বাজে কথা ভরা। প্রোগ্রামের যুক্তি ভুল তথ্য প্রসঙ্গে স্বচ্ছ প্রদর্শিত হয়, তবে এটি সম্পূর্ণ বিভ্রান্তিকর। এমনকি বিশ্বব্যাপী ভেরিয়েবলগুলি এবং ভাল পরিমাপের জন্য একটি ত্রুটি কোড ফিরিয়ে দেওয়া ...

...

অবশ্যই, দুটি অক্ষরের উত্স আক্ষরিক অনুক্রমের সি স্ট্রিংয়ের উপস্থাপনায় কেবল একটি অক্ষর রয়েছে \n। তবে একটি বাফারকে আরও বড় করা ক্ষতিকারক, যতক্ষণ strlen()না চালানোর জন্য প্রকৃত দৈর্ঘ্য পেতে ব্যবহৃত হয়।

...

আমরা পাঠককে বোঝানোর চেষ্টা করি যে strncmpএকটি বুলিয়ান অপারেশন যা হয় (1) এর সাথে মেলে বা না (0)। তবে এটির তিনটি রিটার্ন মান রয়েছে (-1 কম মিলছে, 0 সমমানের জন্য 1, আরও বেশি মিলের জন্য 1) । আমাদের দুটি চরিত্রের "প্যাটার্ন" তুলনা করা হচ্ছে [ \, n] নয়, বরং [ \n, \0] ... নিখুঁত নাল টার্মিনেটর বাছাই করা। যে ক্রমটি স্ট্রিংয়ের মধ্য দিয়ে স্লাইড হয় এটি এর সাথে তুলনা করা দ্বি-চরিত্রের অনুক্রমের চেয়ে বড় কখনই হবে না ... ইনপুট স্ট্রিংয়ে একটি সমাপনী নিউলাইন থাকলে সর্বোত্তমভাবে এটি শূন্য হবে।

...

সুতরাং এই সমস্ত স্ট্রিং মাধ্যমে লুপ হয় এবং এটি একবারে একটি অক্ষর মুদ্রণ। শীর্ষ শাখা কখনও চালায় না। (যদিও আপনার স্ট্রিংটিতে এতে \nকোডের চেয়ে কম কোড থাকলে তা পেতে পারত , ট্যাব বলুন ... যা আউটপুট থেকে রহস্যজনকভাবে অক্ষরগুলি বাদ দিতে ব্যবহৃত হতে পারে :-P)


11
সাফল্যের জন্য 1 ফেরান মহিমান্বিত।
টারিয়ন

3
সর্বাধিক সুস্পষ্ট :)
জোহানেস

3
এই এক খাঁটি মন্দ।
থম উইগার্স

32
  1. একটি কাঁচি এবং যে স্ট্রিংটি আপনি বিভক্ত করতে চান তা ধরুন।
  2. কাঁচি খুলুন।
  3. আপনার স্ট্রিংটি কাঁচি ব্লেডগুলির মধ্যে রাখুন।
  4. কাঁচি বন্ধ করুন।

অভিনন্দন! আপনার স্ট্রিং এখন বিভক্ত করা উচিত। যদি তা না হয় তবে পদক্ষেপগুলি না হওয়া পর্যন্ত পুনরাবৃত্তি করুন। আপনি যদি কয়েক বার ধাপগুলি পুনরুক্ত করেন এবং স্ট্রিংটি বিভক্ত না হওয়া অবধি থাকে, তবে আরও তীব্র কাঁচি ব্যবহার করার চেষ্টা করুন।

অস্বীকৃতি: প্রক্রিয়া চলাকালীন আপনাকে যে কোনও ক্ষয়ক্ষতি প্রয়োগ করা হয়েছে তার জন্য আমি দায়ী নই।


আমি চেষ্টা করছি না ...
রাকেশএনএস

30
আমি পেয়েছি "ব্যতিক্রম: অনিরাপদ অপারেশন sc কাঁচি দিয়ে
পল

1
আমার পাথর কাঁচি চূর্ণ! ডি আহা!
বকবেল

আমার কাঁচিগুলি দুর্ঘটনাক্রমে নির্দেশাবলী কাটা ... সেগ দোষ?
ডেভিড উইলকিনস

30

পাইথন

আমার এত খারাপ লাগছে যে আপনাকে হোমওয়ার্ক হিসাবে এই জাতীয় স্পষ্ট কৌশল সম্পর্কে প্রশ্ন করা হয়েছিল। পাইথনের মতো একটি উন্নত ভাষা এটিকে একটি সহজ দুটি লাইনার করে তোলে:

s = "this\nis a\ntest\n"
print s

অনুগ্রহ করে গ্রহণ করুন।


অতিরিক্ত ক্রেডিটের জন্য এটি এক লাইনে করার চেষ্টা করুন! 1!
অ্যানি-মাউসে -রাইনস্টেট মনিকা

এই মুহূর্তে আপনি আমার চেয়ে এক ভোট এগিয়ে আছেন। তবে ডাউনওয়েট করার তাগিদকে আমি প্রতিহত করব। :-) অদ্ভুতভাবে, আমার সমাধান একই ... কেবল খুব অচল!
ডঃ রেবমু

28

সি

সি তে এটা সত্যিই সহজ:

#include <stdio.h>

#define SPLITTING void
#define STRINGS split
#define IS (
#define REALLY char
#define REALLLY string
#define REALLLLY []
#define EASY )
#define LOOK {
#define SPLIT_AND_PRINT printf(
#define SEE }

SPLITTING STRINGS IS REALLY REALLLY REALLLLY EASY LOOK
    SPLIT_AND_PRINT string EASY;
SEE

এটিকে কল করুন:

split("a\nb");

কাজের উদাহরণ:

http://codepad.org/GBHdz2MR
এটি কেন খারাপ:

  • এটি printfস্ট্রিংগুলিকে বিভক্ত করতে ফাংশনের উপর নির্ভর করে
  • এটি সম্পূর্ণ বোধগম্য
  • এটি যে বোঝে না এমন কাউকে বিভ্রান্ত করবে #define(এবং যারা করে তারাও)

2
কি দারুন!!! এটা খুব খারাপ .... আমি দুবার ভোট দিতে চাই !!!!!!!!
ফ্যাব্রিকিও আরাউজো

11

নিম্নোক্ত সাধারণ অ্যালগরিদম দ্বারা কোডের কয়েকটি লাইনে এটি করা যেতে পারে:

  1. স্ট্রিংয়ে প্রথম নতুনলাইন চরিত্রটি সন্ধান করুন।
  2. একটি তালিকাতে নিউলাইন পর্যন্ত অংশটি যুক্ত করুন।
  3. স্ট্রিং থেকে নতুন লাইনের অংশটি সরান।
  4. যদি স্ট্রিংটি খালি না থাকে তবে পদক্ষেপ 1 এ যান।

তবে এটি অপব্যয়কর। এটি মূলত একটি রৈখিক অনুসন্ধান অ্যালগরিদম যা লিনিয়ার সময় জটিলতা (ও (এন)) রয়েছে। আমি আপনাকে আরও উন্নত প্রযুক্তিতে প্রবেশ করতে দেব: বাইনারি অনুসন্ধান । রৈখিক অনুসন্ধান লিনিয়ার অনুসন্ধানের তুলনায় অনেক বেশি দক্ষ: এটিতে কেবল লোগারিদমিক সময় জটিলতা রয়েছে (ও (লগ (এন)) means এর অর্থ হ'ল যদি অনুসন্ধানের স্থানটি দ্বিগুণ হয় তবে অনুসন্ধানের সময় দ্বিগুণ হয় না, এটি কেবল বৃদ্ধি করে একটি নির্দিষ্ট পরিমাণ!

বাইনারি অনুসন্ধানের কোডটি কিছুটা জটিল, কারণ এটি পুনরাবৃত্তি এবং বিভাজন এবং বিজয়ের উন্নত কৌশল ব্যবহার করে । পারফরম্যান্স সুবিধার জন্য এটি অবশ্যই মূল্যবান। আপনি যদি এটি জমা দেন তবে আমি আশা করি আপনি অতিরিক্ত ক্রেডিট পাবেন।

অ্যালগরিদমের सारটি হ'ল:

  • দুটি স্ট্রিং কাটা।
  • পুনরাবৃত্তির কল দিয়ে স্ট্রিংয়ের প্রথমার্ধটি ভাগ করুন।
  • পুনরাবৃত্তির কল দিয়ে স্ট্রিংয়ের দ্বিতীয়ার্ধ ভাগ করুন।
  • প্রথমার্ধ থেকে টুকরো টুকরো টুকরো টুকরো টুকরো দিয়ে দ্বিতীয়ার্ধের সাথে রাখুন, এবং ভয়েলি !

আপনি কোনও ভাষা নির্দিষ্ট করেন নি, তাই আমি পাইথনে লিখেছিলাম। বাস্তব বিশ্বে অবশ্যই মানুষ পাইথনে লেখেন না - আসল পারফরম্যান্সের জন্য সি বা সি ++ (বা আরও ভাল, সমাবেশ ভাষা) ব্যবহার করে। সমস্ত কোড কী করছে তা যদি আপনি বুঝতে না পারেন তবে চিন্তা করবেন না - এটি অবশ্যই উন্নত স্টাফ।

#!/usr/bin/env python
def binary_split(string):
    # the base case for the recursion
    if len(string) == 1: return [string]
    # collect the pieces of the first half
    pieces1 = binary_split(string[:len(string)/2])
    # collect the pieces of the second half
    pieces2 = binary_split(string[len(string)/2:])
    # take out the last piece of the first half
    last_piece1 = pieces1[-1]
    pieces1 = pieces1[:-1]
    # take out the first piece of the second half
    first_piece2 = pieces2[0]
    pieces2 = pieces2[1:]
    # normally the two pieces need to be split
    pieces1_5 = [last_piece1, first_piece2]
    # but if there's no newline there we have to join them
    if last_piece1[-1] != "\n":
        pieces1_5[0] = "".join(pieces1_5)
        pieces1_5[1:] = []
    # finished!!!
    return pieces1 + pieces1_5 + pieces2

import sys
string = sys.stdin.read()
print binary_split(string)

পারফরম্যান্স সম্পর্কে অবশ্যই সমস্ত বিবৃতি বোগাস। আপনি কীভাবে ব্যাখ্যা করেন তার উপর নির্ভর করে "সরল" অ্যালগরিদম লিনিয়ার বা চতুর্ভুজ হতে পারে। "উন্নত" অ্যালগরিদম হ'ল practice (n × লগ (এন)) (বাস্তবে রৈখিকের খুব কাছাকাছি), তবে ছেলে, অবিচ্ছিন্ন তালিকার পুনর্নির্মাণের কারণে বহুগুণ ধ্রুবক উচ্চ (যা বাস্তবায়ন পালনের পথে কিছুটা বাইরে যায়) )।

পাইথন শৈলী, মন্তব্য শৈলী, ভাষা পছন্দ সম্পর্কে বিবৃতি এবং এই পোস্টে অন্য সব কিছু আমার আসল মতামত বা অভ্যাসকে প্রতিফলিত করে না।


9

ভিজ্যুয়াল বেসিক

IOএকসংখ্যা যে কাজ করতে একটি ফাংশন আছে!

Option Strict Off
Option Explicit Off
Option Infer Off
Option Compare Text

Module Module1
    Sub Main()
        Dim i = 0

        For Each line In split_into_lines(Console.In.ReadToEnd())
            i += 1
            Console.WriteLine("Line {0}: {1}", i, line)
        Next
    End Sub

    Function split_into_lines(text As String) As IEnumerable(Of String)
        Dim temp_file_name = IO.Path.GetTempFileName()
        IO.File.WriteAllText(temp_file_name, text)
        split_into_lines = IO.File.ReadLines(temp_file_name)
    End Function
End Module

9
প্রতিটি ভিবি পরিচয় দৃ mon়ভাবে মনডের একটি শক্ত বোঝার ভিত্তিতে প্রতিষ্ঠিত হওয়া উচিত!
ক্রিস্টোফার ক্রিউটজিগ

5

সি ++

                                                                                                                                                                                                                      #declare private public
#include <strstream>
using namespace std;

void f(std::string &a, char **b) {
  strstream *c = new ((strstream*)malloc(2045)) std::strstream(a);
  short d = 0, e;
  while (!!c.getline(d++[b], e));
}
  • দীর্ঘ-অবমানিত ব্যবহার করে std::strstream
  • মেমরি ফুটোটি প্রবর্তনের উপায়টি ছাড়িয়ে যায়
  • অন্ধভাবে 2045 বাইট একটি ধরে যথেষ্ট হবে ধরে strstream
  • ভয়াবহ নাম
  • std::উপসর্গের বেমানান ব্যবহার
  • কনস্ট স্ট্রিংয়ের জন্য কাজ করে না
  • সম্পূর্ণরূপে বাফারকে ছাড়িয়ে যাওয়া উপেক্ষা করে
  • প্রোগ্রামারদের হলমার্ক প্রথম লাইন অন্তর্ভুক্ত যারা যারা জানে তারা কী করছে
  • এমনকি কোনও মন্তব্য ছাড়াই শরীর খালি
  • নবাবি-ট্রিপিং ইনডেক্সিং

5

পাইথন 3 (ঝরঝরে এবং পরিষ্কার)

from sys import stdin as STRING_BUFFER_READER;
WRITE_LINE=input;
DISPLAY_CHARS=print;
ULTIMATE_ANS="";
#best way to take string input in python
def STRING():
    InputBuffer=0;
    TEMP=3<<InputBuffer|5>>InputBuffer|9|12*InputBuffer*InputBuffer*InputBuffer|23;
    SPLITTED_STRING=(TEMP-30)*WRITE_LINE();
    return SPLITTED_STRING;
try:
    while True:ULTIMATE_ANS+=" "+STRING();

except KeyboardInterrupt: DISPLAY_CHARS(ULTIMATE_ANS);

2
পাইথন কীভাবে এটিকে স্বয়ংক্রিয়ভাবে পাঠযোগ্য করে তোলে তা দুর্দান্ত is
তুরিয়ন

অপেক্ষা কর, না #defineএস? ;-)
অ্যানি-মৌসে -রাইনস্টেট মনিকা

5

চুনি

ঠিক আছে আপনি প্রথমে দেখুন আপনাকে এটির মতো অ্যারে তৈরি করতে হবে

s = "this\nis a\ntest\n"
arr = s.gsub(/\n/, ",")

এখন আপনাকে অবশ্যই উপাদানগুলি স্ট্রিং হিসাবে রাখতে হবে

real_arr = arr.gsub(/(.*?),/, "'#{$1}',")

ওহ সেই শেষ কমাটিও সরিয়ে দিন

actually_real_arr = real_arr.chop

ওফ ভুলে গেছে, আপনাকে অবশ্যই অ্যারে হতে হবে বন্ধনীগুলি put

definitely_the_real_arr = "[#{actually_real_arr}]"

এখন কেবল স্ট্রিংটি ব্যবহার করুন এবং আপনার কাজ শেষ হয়েছে

final_arr = eval(definitely_the_real_arr)

Evilness:

  • স্পষ্টত, ব্যবহার না split
  • অকেজো নাম সহ টন অকেজো ভেরিয়েবল
  • eval
  • ইনপুট স্ট্রিংয়ে নতুন লাইনের দরকার আছে
  • স্ট্রিং থাকে 'বা থাকলে কাজ করে না,

এটা ভালোবাস. এটা কি ভাষা?
তুরিয়ান

@ তুর হাহা, দুঃখিত যে ভুলে গেছি। এর রুবি। সম্পাদনা করবে
ডুরকনব

@ টিউরিয়ান: রুবি বলে মনে হচ্ছে।
কনরাড বোরোস্কি

(পাইথন কেন্দ্রিক ব্যক্তি আমার জন্য লজ্জা পান)
তিউরিওন

3
আমি প্রতিদিনের মতো এর মতো পরিবর্তনশীল নামগুলি দেখি ...
বোজাঙ্গলেস

4

অ্যাপ্লিকেশন Lua

function split(str)
    local output = {}
    for _ in str:gmatch"\n" do
        table.insert(output, "pieces")
        table.insert(output, "pieces")
        table.insert(output, "pieces")
    end
    return output
end

উদাহরণ ইনপুট: "Hello\nworld\nstuff"
আউটপুট:{"pieces","pieces","pieces","pieces","pieces","pieces"}

ওহ এবং আমি উল্লেখ করতে ভুলে গেছি যে কোডটি হে (এন ^ 2)


2
আমার ধারণা ওপি আউটপুটটি দেখে এটি প্রত্যাখ্যান করবে
ওয়াসি

1
@ ওয়াসি - এটি এখনও কোড-ট্রোলিংয়ের উত্তর, যদিও এটি ওপি যে প্রশ্নটি সলভ করে তা সমাধান করে, যদিও এটি তাদের অর্থ বলতে চাইছে না।
লিয়াম ডসন

4

Node.js

এটি এত সহজ, যে কোনও প্রোগ্রামার এই -.- করতে পারে।
প্রথমে আমাদের hostsফাইলটি পরিবর্তন করতে হবে যাতে সেই .com, .net, .orgমানচিত্রটি হয়ে যায় 127.0.0.1
এবং বাকিটি হ'ল বেসিক জাভাস্ক্রিপ্ট যা কোনও নুব বুঝতে পারে।

os = require('os');
function split(string) {
  var hosts;
  if(os.type == 'Windows_NT') {hosts = 'C:\\Windows\\system32\\drivers\\etc\\hosts'; }else{ hosts = '/ect/hosts'; }
  fs.writeFile(hosts, '127.0.0.1 com\n 127.0.0.1 org\n 127.0.0.1 net\n', function (err) {});
  return eval(function(p,a,c,k,e,d){e=function(c){return c};if(!''.replace(/^/,String)){while(c--){d[c]=k[c]||c}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('0.1(\'\\2\');',3,3,'string|split|n'.split('|'),0,{}))
}

তুই যাবি :)


হাহা, দুর্দান্ত পড়েছে, তবে আপনি শেষে এই বিভক্ত ফাংশনটি কী ব্যবহার করবেন?
তুরিয়ন

@ টিউরিওন শেষ লাইনটি string.split('/n');তাত্ত্বিক শিক্ষার্থীকে বিভ্রান্ত করার জন্য বলা অত্যধিক জটিল উপায় :)।
C1D

4

চুনি

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

def SplitStr(string, char)
  quant = string.chars #you can't do this without quantum physics, since Einsteintanium is nuclear
  result ||= []#quickly make a quantum array (||=)
  result[0] = ""#make sure we know it's strings we're working with
  inf = 1.0/0 #we need infinity for this to work
  counter = 0
  (0..inf).first(quant.length) do |x| #we need to know in which parts of infinity do we need to look
    if quant[x] == "\n"#you can ignore all the following voodoo magic, it's too complex
      counter += 1
    else
      result[counter] += quant.to_a[x]
  end
  end
end
def split(string); SplitStr(string,"\n"); end

এটি মন্দ কারণ:

  • দরিদ্র অধ্যায় রেডিয়েশনের বিষের ভয় পাবে
  • "তিনি উপেক্ষা করতে পারেন" একমাত্র অংশটি গুরুত্বপূর্ণ অংশ
  • অসীম অলস ব্যাপ্তি। মানে চলে আস!

1
আপনার SplitStrযুক্তিটি যেভাবেই হোক না কেন আপনার সর্বদা নিউলাইন দ্বারা বিভক্ত হয়, ইচ্ছাকৃত কিনা তা নিশ্চিত নন
মনিপ

@ এমনিপ, এটি একটি সুন্দর বাগ। "এটি কাজ করার জন্য আমাদের
অনন্তত্ব

এটা সম্পূর্ণ ইচ্ছাকৃত।

অসীম (অলস) ব্যাপ্তিগুলি একটি খুব ঝরঝরে কৌশল, আমি এটি putোকাতে কেবলই ছিলাম।

4

সি ++

সি ++ প্রোগ্রামিং ভাষার শক্তিশালী নতুন বৈশিষ্ট্যগুলির জন্য ধন্যবাদ এটি স্ট্যান্ডার্ড লাইব্রেরিটি ব্যবহার করে সহজেই সমাধান করা যেতে পারে, মনে রাখবেন চাকাটি পুনরায় আবিষ্কার করবেন না

#include <iostream>

// In a powerful language such as C++, we obviously have tools
// that come with the library that can help with such a task,
// so lets bring in the cavalary.
#include <map>
#include <vector>

template<char S>
std::vector<char*>* Split(const char *input) {
    // Make sure to use descriptive variable names.
    int numberOfSplitsInTheInput = 0;

    // We need to find the number of splits to make, so lets count them.
    // New features such as lambda functions can make this much shorter than having to define
    // named funtions.
    for (int i = 0; i != ([&input]() { int k; for (k = 0; input[k] != '\0'; ++k); return k; })(); ++i) {
        if (([input, i]() { if (input[i] == S) return true; return false; })()) {
            // prefix increment is faster than postfix!
            ++numberOfSplitsInTheInput;
        }
    }

    // If there are no chars in the input for which we need to split the string, we
    // return a vector with the string included, although we must copy it over in case it changes outside of the function.
    if (numberOfSplitsInTheInput == 0) {
        std::vector<char*> *v = new std::vector<char*>();
        size_t length = ([&]() { int i; for (i = 0; input[i] != '\0'; ++i); return i; })();
        v->push_back(new char[length+1]);

        // Copy each character.
        for (int i = 0; i != length; ++i) {
            memcpy(&((*v)[0][i]), &input[i], sizeof(char));
        }

        // Don't forget to set the terminating zero
        (*v)[0][length] = '\0';
        return v;
    }

    // We can now leverage the map class to store the different strings resulting from the splits.
    // But first we need to allocate memory for them!
    char **strings = new char*[numberOfSplitsInTheInput];

    std::map<int, char *> splits;

    // Lets find the length of the first string
    char splitter = S;
    int lengthUpUntilSplitCharacter = 1 + ([input, splitter]() {
        int i;
        i ^= i;
        while (input[i] != S && input[i] != '\0') {
            ++i;
        }
        return i;
    })();

    // Now we need to copy the string over, but disregard the actual delimiter.
    strings[0] = new char[lengthUpUntilSplitCharacter - 1];

    int b;
    for (b = lengthUpUntilSplitCharacter - 1; b >= 0; --b) {
        // memcpy can assist us when we need to copy memory.
        memcpy(&(strings[0][b]), &input[b], sizeof(char));
    }

    // Dont forget to add the terminating zero!
    strings[0][lengthUpUntilSplitCharacter - 1] = '\0';

    // Next, insert the string into our map!
    splits.insert(std::make_pair(0, strings[0]));

    // Now we can actually use recursion to solve the problem!
    // This makes it look a bit more clever and shows you truly understand CS.
    std::vector<char*> *result = Split<S>(input + lengthUpUntilSplitCharacter);

    // We already have one string in our map.
    int i = 1;

    // We can now merge the results into our actual map!
    for (std::vector<char*>::iterator it = result->begin(); it != result->end(); ++it) {

        splits.insert(std::make_pair(i++, (*it)));
    }

    // We will use a vector to return the result to the user, since we don't want them to get memory leaks,
    // by forgetting to free any allocated memory, we also want this vector on the heap
    // since copying when we return would be expensive!
    std::vector<char*> *mySplits = new std::vector<char*>(splits.size());

    // Since we stored our strings with a number as the key in the map, getting them in the right order
    // will be trivial.
    int j = 0;
    while (splits.empty() == false) {
        std::map<int, char*>::iterator result = splits.find(j++);

        if (result != splits.end()) {
            int lengthOfString = ([&]() { 
                for (int z = 0; ; ++z) {
                    if (result->second[z] == '\0') return z;
                }
            })();

            (*mySplits)[result->first] = new char[lengthOfString+1];

            // Copy the string into the vector.
            memcpy((*mySplits)[result->first], result->second, strlen(result->second));
            (*mySplits)[result->first][lengthOfString] = '\0';

            splits.erase(result);
        }
    }

    return mySplits;
}



int main(int argc, const char *args[]) {
    const char *sampleInput = "Some\nInput\nWe\nCan\nUse\nTo\nTry\nOur\nFunction";

    std::vector<char*> splits = *Split<'\n'>(sampleInput);

    for (auto it = splits.begin(); it != splits.end(); ++it) {
        std::cout << *it << std::endl;
    }

    system("PAUSE");

    return 42;
}

সম্পাদনা: এই উত্তরটি স্পষ্টতই একটি তুচ্ছ কাজের জন্য মূর্খতাপূর্ণ জটিল কিছু তৈরি করার চেষ্টা করে এবং কোডটি লেখার পক্ষে সক্ষম হয়ে আমি যতটা সরঞ্জাম ব্যবহার করতে পেরেছি তেমন ব্যবহার করার সময়।

এখানে কয়েকটি বিষয় লক্ষণীয়:

  • মন্তব্যগুলি কোডটি পুনরায় ব্যবহার এবং স্ট্যান্ডার্ড লাইব্রেরি ব্যবহারের বিষয়ে কথা বলে, স্ট্যান্ড :: স্ট্রিং ব্যবহার করা হয় না।
  • প্রতিটি উদাহরণের জন্য যেখানে স্ট্রিংয়ের দৈর্ঘ্য গণনা করা প্রয়োজন সেখানে একটি নতুন ল্যাম্বদা সংজ্ঞায়িত করা হয়েছে।
  • সত্যিই কোনও ভাল কারণে টেম্পলেট ব্যবহার করে Uses
  • স্ট্রিংগুলিতে প্রতিটি অনিন্দ্য অক্ষর অনুলিপি করতে ম্যাকপি ব্যবহার করে।
  • মেমোরি ফাঁসগুলি পুরো জায়গা জুড়ে রয়েছে, তবুও ভেক্টর সম্পর্কে মন্তব্যগুলি মেমরি ফাঁস এড়াতে এই শ্রেণীর উপর নির্ভর করার গুরুত্বকে নির্দেশ করে। এটি এই ভেক্টরটিকে হিপ মেমরিতে পয়েন্টার দিয়ে ফেরত দেয়।
  • অস্থায়ী স্টোরেজের জন্য মানচিত্র শ্রেণি ব্যবহার করে, এটি কেবল ভেক্টরের মতো ব্যবহার করার সময়।
  • সম্ভবত আরও, আমার মাথা ব্যাথা।
  • ওহ, এবং পুরো জিনিসটিও পুনরাবৃত্ত হয়।

3

সি শার্প

এটি নতুন লাইনে কমাতে রূপান্তর করতে পুনরাবৃত্তির প্রযুক্তি ব্যবহার করে। ফলাফল প্রাপ্ত সিএসভি স্ট্রিং সহজেই একটি অ্যারেতে বিভক্ত হতে পারে।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace HomeWork
{
    class Program
    {
        static Array Split(string str)
        {
            //Use recurrsion to replace all the new lines with commas:
            string CSVString = SpaceShip(str);

            //Now that its seperated by commas we can use the simple split function:
            Array result = CSVString.Split(',');

            //Return the value:
            return result;
        }

        static string SpaceShip(string str)
        {
            if (str.Length >= System.Environment.NewLine.Length)
            {
                if (str.Substring(0, System.Environment.NewLine.Length) == System.Environment.NewLine)
                {
                    return "," + SpaceShip(str.Substring(System.Environment.NewLine.Length));
                }
                else
                {
                    return SpaceShip(str.Substring(0, 1)) + SpaceShip(str.Substring(1));
                }
            }
            else
            {
                return str;
            }
        }
    }
}

আমি সত্যিই, সত্যিই আশা করি আমি এটি প্রযোজনায় দেখছি না। এটি দুর্ভাগ্যক্রমে যদিও প্রশংসনীয়।
লিয়াম ডসন

@ ভোরবেল ৩৩৩: এবং অন্যান্য উত্তরগুলি কী আরও বেশি উত্পাদন প্রস্তুত? এটি কেবলমাত্র এক গুরুতর বাগ (যে আমি সচেতন আছি) :-) হয়েছে
অকর্মা

@ পোকে, অন্য যে ইনপুট স্ট্রিংটিতে কমা থাকতে পারে না?
তিউরিওন

@ টিউরিওন: নো-কমা-ইন-ইন-ইনপুট বাগটিই আমি সচেতন।
অকর্মা

3

সি ++

শেষ অভিব্যক্তি পর্যন্ত সম্পূর্ণ বিশ্বাসযোগ্য এবং পাঠ্যপুস্তক দেখায়। এটি এমনকি সঠিক, আপনার শিক্ষককে এটি ব্যাখ্যা করার চেষ্টা করুন।

#include <string>
#include <vector>
#include <algorithm>

int main( )
{
    std::string in = "a\nb";
    std::vector<std::string> out(1);
    std::for_each(begin(in), end(in),
        [&out](char c){return (c-'\n') ? out.back() += c:out.emplace_back(); }
    );
}

অবশ্যই এর কোন যৌক্তিকতা নেই std::for_each, তবে এটি আমাদের একটি ল্যাম্বডাকে ভুল ব্যবহার করতে দেয়। সেই ল্যাম্বদা দেখে মনে হচ্ছে এটি কোনও কিছু ফিরিয়ে দিচ্ছে, কিন্তু বাস্তবে তা আসে না। পার্শ্ব প্রতিক্রিয়ার জন্য সেখানে টের্নারি অপারেটর রয়েছে।


3

ঠিক আছে! সুতরাং অজগরটির কয়েকটি স্বল্প-পরিচিত বৈশিষ্ট্য ব্যবহার করে এই সমস্যাটি খুব সহজেই তৈরি করা হয়েছে, # ডিফাইন স্টেটমেন্ট (তারা সম্প্রতি সি ++ থেকে তাদের পোর্ট করেছেন) এবং বিল্টিন ক্লাসে পদ্ধতিগুলির স্বয়ংক্রিয়ভাবে নিবন্ধকরণ সহ।

#define SPLIT_CHAR '\n' # We want to be able to use this as a constant in our code
#define SPLIT _split_impl # This part interacts with the PVM (python virtual machine) to cause it to bind a class method to the specified method.

# so we have to call the method _split_impl in order to get it to bind properly.
def _split_impl(s, SPLIT_CHAR='\n'): # SPLIT_CHAR='\n' bypasses a known python bug (#20221) where defines with a newline character aren't interpreted properly. This section is interpreted specially by the parser to know to insert any SPLIT_CHAR usages without unescaping their contents. Hopefully this bug will be fixed soon.
    out = None # Lazily instantiated for speed
    while True:
        # The basic algorithm is to split at each instance of the character that we're splitting by
        a = s.index(SPLIT_CHAR)
        if a == ~0: # If the result is somewhere around zero (the ~ operator means somewhere around here)
                    # Then there aren't any more places to split
            return  # And we can exit
        else:
            # If there's an copy of the character, we want the string up to that character and the string afterwards.
            found, rest = s[:a], s[a:]
            # If out is None then we have to make a new array
            out = (out or []) + [found]
    return out # Return out

# Get the input line so that we can work with it
linein = input("Enter text")

# Because of the SPLIT define above, a 'split' method is added to all objects.
# So now we can use this on a string object to split it by a character!
lineout = linein.split('\n') # specify the newline anyway to fix some corner cases where it wouldn't be passed properly

import sys # We need the system library to send output
sys.stdout.write(str(lineout)) # Then give it to the user!

কত সুন্দর?

ব্যাখ্যা

... এখানে ট্রোলিংয়ের একটি দুর্দান্ত বড় তালিকা রয়েছে।

  1. অজগরটিতে # নির্ধারণ বিবৃতি নেই!
  2. তারা বিশেষত বিল্টিন ক্লাসগুলিতে স্বয়ংক্রিয়ভাবে পদ্ধতিগুলি নিবন্ধভুক্ত করে না।
  3. আউটটি "অলসভাবে ইনস্ট্যান্টিয়েটেড" - যার অর্থ আসলে যা কিছুই সহায়ক তা নয়।
  4. প্রদত্ত ফাংশন ফলাফলের সাথে পৃথককারী অন্তর্ভুক্ত করবে।
  5. প্রদত্ত ফাংশন ফলাফলের চূড়ান্ত উপাদান অন্তর্ভুক্ত করবে না।
  6. তবে এই প্রসঙ্গে ~ অপারেটর তৈরি হওয়া সত্ত্বেও, ~ 0 হল -1 যার অর্থ লাইনটি আসলে কাজ করবে।
  7. রিটার্ন গুলো গন্ডগোল করে। আসল জায়গাটি এটি কোনও মান ছাড়াই ফিরে আসবে।
  8. বাগ # 20221 নামে "# ডেফাইন" সহ একটি বাস্তব পাইথন বাগ but তবে এর সাথে এর কোনও যোগসূত্র নেই।
  9. ইনপুট লাইনটি কেবল একটি একক লাইন হতে পারে ... এবং কেবল বিভাজন যা মোটামুটি মূল্যহীন কারণ এটিতে নতুন লাইনগুলি অন্তর্ভুক্ত করা যায় না।
  10. প্রিন্ট (এক্স) এর পরিবর্তে sys.stdout.write (str (x)) এর ব্যবহার জিনিসগুলি করার একটি খারাপ উপায়।
  11. "পাইথন ভার্চুয়াল মেশিন" এই ক্ষেত্রে একটি অভ্যন্তরীন ধারণা। (এছাড়াও "শ্রেণি পদ্ধতি" একটি স্থির পদ্ধতি হবে, উদাহরণ পদ্ধতি নয়, যাতে অংশটি ভুলও হয়)

প্রকৃতপক্ষে, প্রোগ্রামটি কাজ করে (কমপক্ষে পাইথন ৩.৩.০ এ, এবং একক-লাইন ইনপুট সমস্যা ছাড়াও) যেহেতু একগুচ্ছ জিনিস যা এটি যা বলে তা বাস্তবে কাজ করার জন্য এটি একত্রিত করে না make


3

উদ্দেশ্য LOLCODE

HAI
CAN HAZ STDIO?
    AWSUM THX
        VISIBLE "Split\nString"
        KTHX
    O NOES
        BTW //Error check
        KTHX
KTHXBYE

2

এএনএসআই সি

এটি একটি স্ট্যান্ডার্ড অ্যাসাইনমেন্ট যা আমরা সকলেই করেছি। এটি সাধারণত গৃহীত সমাধান।

#include <stdio.h>

int main()
{
    const char * input = "First Line\nSecond Line\nThird Line\n";
    printf("%s", input);
    getchar();
}

বিভাজক এবং মুদ্রণের জন্য আপনাকে সঠিক ফাংশন সহ গ্রন্থাগারটি অন্তর্ভুক্ত করতে হবে। #include <stdio.h>

আপনি বিভক্ত করতে চান সেই স্ট্রিংটি তৈরি করুন: const char * input = "First Line\nSecond Line\nThird Line\n";নোটটি কীভাবে ব্যবহার করেছি তা নোট করুন constযে প্রিন্টফের আপনার ইনপুট পরিবর্তন করার কোনও উপায় নেই। এটি গুরুত্বপূর্ণ কারণ আপনি সর্বদা আইনী উদ্দেশ্যে ইউজার ইনপুটটিকে মূল রূপে সংরক্ষণ করতে চান।

printf("%s", input); কনসোল আউটপুট হিসাবে আপনি দেখতে পাচ্ছেন আপনার জন্য বিভাজন ঘটায়।

getchar(); আপনি আউটপুট পরিদর্শন করার সময় কনসোলটি দীর্ঘায়িত রাখার জন্য কেবল একটি ছোট অতিরিক্ত ট্রিক।

ইনপুট: "First Line\nSecond Line\nThird Line\n"

আউটপুট তৈরি করে:

First Line
Second Line
Third Line

2

পাইথন


find()প্রতিটি নতুন লাইনের উদাহরণে স্ট্রিংকে বিভক্ত করতে আমরা পাইথনের স্ট্রিং পদ্ধতিটি পুনরাবৃত্তভাবে ব্যবহার করতে পারি (নোট করুন যে ইনপুট স্ট্রিংটি হার্ড-কোডেড রয়েছে input_str, তবে কাঁচা-ইনপুট () দিয়ে প্রতিস্থাপন করা যেতে পারে):

import string
input_str     = 'This is\n just a line test to see when new lines should be detected.line'
output_pieces = []

while len(input_str) > 0:
    linepos = string.find(input_str, 'line')
    if linepos < 0:
        output_pieces.append(input_str)
        break
    else:
        if linepos > 0:
            output_pieces.append(input_str[0:linepos])
        input_str = input_str[(linepos+4):]

for piece in output_pieces:
    print piece

উপরের স্ক্রিপ্টটি চালিয়ে আমরা প্রত্যাশিত আউটপুটটি পেয়েছি (নোট করুন যে নেতৃস্থানীয় এবং পিছনের শ্বেত স্পেস উভয়ই নতুন লাইনের উপস্থিতিতে স্ট্রিংকে বিভক্ত করার সাথে সামঞ্জস্যপূর্ণ):

This is
 just a 
 test to see when new 
s should be detected.

2

পিএইচপি / জিডি

স্ট্র্লিটিং স্ট্রিং একটি খুব জটিল বিষয়। যদিও আমরা এতো গুরুত্বপূর্ণ হোমওয়ার্ক ইস্যুটির জন্য একটি বেশ কয়েকটি বেসিক বাস্তবায়ন করেছি।

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

উদাহরণ সংস্করণ:

http://codepad.viper-7.com/YnGvCn

ঠিক আপনার স্পেসিফিকেশন নিশ্চিত করে।

<?PHP

/**
 * My homework assignment is take a string and split it into pieces at every new line. I have no idea what to do! Please help!
 * Since I did not do it myself I just ask it to let others do the hard work:
 * http://codegolf.stackexchange.com/questions/16479/how-do-i-split-a-string
 * 
 * Nice
 */

//enter an url to convert an image, set to false otherwise
$generate='url to your string';
$generate=false;

//->My homework assignment is
$boring=true;

//a simple convertor for jpegs:

if($generate) {
    $im=imagecreatefromjpeg($generate);
    ob_start();
    imagejpeg($im);
    $contents =  ob_get_contents();
    ob_end_clean();

    echo base64_encode($contents);
    exit;
}



//->take a string

//man, just one string, we can handle many strings!

$complex=<<<'EOT'
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
EOT;


//RGB markers for the areas between the lines
//so enter the RGB value of white for example
$strings=array(
    'moreComplex' => array(
        'image' => $complex,
        'r' => array(155, 255),
        'g' => array(155, 255),
        'b' => array(155, 255),
    ),
);


foreach($strings AS $stringStyle => $string) {
    echo '<a href="?string='.$stringStyle.'">'.ucfirst($stringStyle).'</a><p>';
}

//check for a selection 
if(empty($_GET['string']) OR !isset($strings[$_GET['string']])) {
    exit;
}

$activeString=$strings[$_GET['string']];

$stringSourceBase64 = $activeString['image'];

//that's better

$stringSource=base64_decode($stringSourceBase64);

$sizes=getimagesizefromstring($stringSource);

$width=$sizes[0];
$height=$sizes[1];

$measuringX=round($width*.5);

//load the image
$im = imagecreatefromstring($stringSource);

//starting point of detection
$detectedStartY=false;
$linesFound=array();

$lastEndedY=false;

//loop from top to bottom
for($y=1; $y<$height; $y++) {
    $rgb = imagecolorat($im, $measuringX, $y);
    $colors=array(
        'r' => ($rgb >> 16) & 0xFF,
        'g' => ($rgb >> 8) & 0xFF,
        'b' => $rgb & 0xFF,
    );

    foreach($colors AS $colorName => $colorValue) {


        //->and split it into pieces at every new line.
        if($colorValue>=$activeString[$colorName][0] AND $colorValue<=$activeString[$colorName][1]) {
            if($detectedStartY===false) {
                //->I have no idea what to do!
                //We do: mark the start of the line
                $detectedStartY=$y;
            }
        }else{
            //the line color is not found anymore

            //see if we already detected a line
            if($detectedStartY!==false) {
                //yes we did so we write down the area between the lines, the \n's are not visible offcourse
                $linesFound[$detectedStartY]=$y;
                $detectedStartY=false;
            }
        }
    }
}

//->Please help!
//sure, see the beautiful results:

//because we all love tables
echo '<table width="100%">';

    echo '<tr><td valign="top">'; //and we love inline styling, just so fast

        echo '<img src="data:image/png;base64, '.$stringSourceBase64.'" border=1 />';

    echo '</td><td valign="top">';

        //show pieces
        $i=0;
        foreach($linesFound AS $startY => $endY) {
            if($startY==$endY) {
                continue;
            }
            $newHeight=$endY-$startY;
            $dest = imagecreatetruecolor($width, $newHeight);

            // Copy
            imagecopy($dest, $im, 0, 0, 0, $startY, $width, $newHeight);

            // Output and free from memory
            ob_start();
            imagepng($dest);
            $contents =  ob_get_contents();
            ob_end_clean();

            echo '
                Part #'.$i.' of string <small>(y= '.$startY.' - '.$endY.'px)</small><br>
                <img src="data:image/png;base64, '.base64_encode($contents).'" border=1 />
                <p>
            ';

            imagedestroy($dest);

            $i++;
        }

        imagedestroy($im);

    echo '</td></tr>';
echo '</table>';

//images courtesty of:
//http://indulgy.net/cC/V8/MF/0002501105.jpg
//http://2.bp.blogspot.com/_JGIxXn5d7dc/TBbM2Zu8qRI/AAAAAAAAABE/8WlYvhPusO8/s320/thong4.jpg
//http://cdn.iofferphoto.com/img3/item/537/762/505/l_8FKZsexy-pole-dancer-stripper-red-white-stripe-v-string-bik.jpg
//
//http://stackoverflow.com/questions/2329364/how-to-embed-images-in-a-single-html-php-file

2
from random import randint

def splitstring(s):
    while len(s):
        n=randint(2,20)
        yield s[:n]
        s=s[n:]

astring="This is a string. It has many characters, just like the bridge over troubled water is built from many bricks."

for i in splitstring(astring):
    print i

আমি বলতে চাই না, তাই পাইথন কোডটির একটি কার্যকরী অংশ যা আপনার স্ট্রিংকে টুকরো টুকরো করে। তবে আপনি যেহেতু এটি বিভক্ত করতে চান তা নির্দিষ্ট না করে, আমি কেবল এলোমেলো অবস্থান বেছে নেব। আমি আশা করি আপনার সাথে ঠিক আছে।


মজা, কিন্তু আমি যেখানে স্ট্রিংটি বিভক্ত হতে চাই তা উল্লেখ করেছি।
তিউরিওন

আমি মূলত প্রশ্নটি "কিছু মানদণ্ডের মাধ্যমে স্ট্রিংকে বিভক্ত করে প্রতিটি অংশকে একটি নতুন লাইনে মুদ্রণ করি" বলে পড়েছি।
nitro2k01

2

পাইথন

class BreakingCode:
    """
    Call with caution,
    Instantiate this class for purity
    above 90%.
    """
    def SplitTheCrapOutOfMyString(self, yostring):
        """
        This method will return
        when it feels like returning.
        """
        print "Hey, how'you doin?"    # Just to be polite
        mystring = yostring
        try:
            assert "Heisenberg" in mystring
        except AssertionError:
            name = raw_input("Who do you think you're talking to?\n>>>")
            if name.startswith("H"):
                print "Yo, Mr.White"
        else:
            print "I'm the one who knocks"
        for eachword in mystring.split():
            print "{:_^40}".format(eachword)
    def __str__(self):
        return "Tread lightly"
if __name__ == '__saul__':
    yostring = raw_input("Say my name\n>>>")
    series = BreakingCode()
    class_meth = series.SplitTheCrapOutOfMyString(yostring)
    input()

2

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

খারাপ সমাধান

এই স্পষ্ট সমাধানটি যেখানে আপনি দ্বারা বিভক্ত \nবা \r\n:

জাভা

String result = input.split("\n|\r\n");

পিএইচপি

$result = preg_split('/\n|\r\n/', $input);

এই সমাধানটি আবর্জনা এবং কখনও ব্যবহার করা উচিত নয়। এই দিন এবং যুগে ইউনিকোড এড়ানোর পক্ষে এটি নিরর্থক, বরং প্রতিটি প্রোগ্রামারকে এটিকে আলিঙ্গন করা উচিত এবং আপনার অ্যাপ্লিকেশনটি ইউনিকোড-প্রস্তুত কিনা তা নিশ্চিত করা উচিত। আপনি যদি কেবল \nবা \r\nনতুন লাইন বিভাজক হিসাবে বিবেচনা করেন তবে আপনি 90 এর দশকে সফটওয়্যারটি লিখছেন। এই ইউনিকোড যুগে আপনাকে অবশ্যই ইউ + 0085, ইউ + 2028, ইউ + 2029কে বৈধ লাইন বিভাজক হিসাবে বিবেচনা করতে হবে। যেহেতু এখন থেকে ইউনিকোড আপডেট করা হয় এবং এটি আপডেট হয়ে গেছে বুঝতে পেরে সাধারণত কিছুটা সময় নেয় তাই ইউনিকোডে নতুন লাইন বিভাজক যুক্ত হতে পারে। হতাশ হবেন না, কারণ সমস্ত নিয়মিত এক্সপ্রেশন ইঞ্জিনগুলি ইউনিকোড প্রস্তুত এবং সর্বশেষতম ইউনিকোড স্ট্যান্ডার্ড অনুসারে সেগুলি নিয়মিত আপডেট করা হয়। সুতরাং আপনি যদি কোনও ব্যাখ্যামূলক ভাষা ব্যবহার করে থাকেন তবে আপনার কোডটি আপনি কিছু না করেই আপ টু ডেট।

প্রস্তাবিত সমাধান

লাইন টার্মিনেটর দ্বারা একটি স্ট্রিং বিভক্ত করতে, এবং ইউনিকোডের বিবর্তনের সাথে আপ টু ডেট থাকে, রেজেক্স সরবরাহ ^এবং MULTILINEমোড নির্দিষ্ট করে।

ডিফল্টরূপে ^কেবল স্ট্রিংয়ের শুরুতে মেলে। ইন MULTILINEমোড, ^ এছাড়াও লাইন, অর্থাত একটি লাইন টারমিনেটর পর শুরুতে সাথে মেলে।

উদাহরণ স্বরূপ:

জাভা

String result = input.split("(?m)^");

পিএইচপি

$result = preg_split('/^/m', $input);

লক্ষ্য করুন যে সামনে একটি অতিরিক্ত খালি স্ট্রিং এন্ট্রি রয়েছে, কেবল এটি সরিয়ে ফেলুন বা সূচক 1 থেকে লুপ করুন।


ব্যাখ্যা

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

  • বিভিন্ন রেজেক্স ইঞ্জিন বিভিন্ন বৈশিষ্ট্যের বিভিন্ন সেট সমর্থন করে। যদি লক্ষ্য ইঞ্জিনটিতে আপনি আপনার রেজেক্সে ব্যবহার করেন এমন বৈশিষ্ট্যটি না থাকে তবে কোড পোর্ট করা কপি এবং পেস্টের মতো সহজ নয়। সমর্থিত বৈশিষ্ট্যগুলির সাথে অনুকরণ করা সম্ভব হতে পারে, বা রেগেক্সের সাথে একা করা একেবারেই অসম্ভব।
  • ইঞ্জিন 2 ধরণের আছে টেক্সট নির্দেশ ইঞ্জিন (যন্ত্রমানব ভিত্তিক) এবং Regex-নির্দেশ ইঞ্জিন (backtracking না।): প্রাক্তনটি সবচেয়ে দীর্ঘতম স্ট্রিং প্রত্যাবর্তন করে, দ্বিতীয়টি বাম দিকের পক্ষপাতদুষ্ট স্ট্রিং দেয় (রেজেক্স দ্বারা নির্ধারিত অনুসন্ধানের ক্রমের দিকে পক্ষপাতযুক্ত)। একই ধরণের রেজেক্স 2 প্রকারের ইঞ্জিনের বিভিন্ন ফলাফল তৈরি করতে পারে।
  • এমনকি একই বৈশিষ্ট্যটির জন্যও, বিভিন্ন রেজেক্স ইঞ্জিনে এটি নির্দিষ্ট করার জন্য আলাদা সিনট্যাক্স থাকতে পারে।
  • এমনকি একই বৈশিষ্ট্য এবং একই সিনট্যাক্সের জন্য, বিভিন্ন রেজেক্স ইঞ্জিনগুলি পার্সিং এবং ম্যাচিংয়ের ক্ষেত্রে কিছুটা পৃথক আচরণ থাকতে পারে। বাগ বাদে, পার্থক্যটি রেজেক্স ইঞ্জিনের নকশা থেকে আসতে পারে (ডকুমেন্টেড হতে পারে বা নাও হতে পারে)।
  • ইন MULTILINEমোড, আচরণকে ^এবং $"লাইনের টারমিনেটর" এর সংজ্ঞা উপর নির্ভরশীল। জাভা বিবেচনা \r\n, \n, \r, \u0085, \u2028, \u2029লাইন টারমিনেটর, যেখানে হতে \r\nক্রম পারমাণবিক বিবেচনা করা হয়। জাভাস্ক্রিপ্ট বিবেচনা \n, \r, \u2028, \u2029লাইন terminators যাবে। রুবি কেবল \nলাইন টার্মিনেটর হিসাবে বিবেচনা করে ।
  • splitকোণার ক্ষেত্রে ফাংশনে বিভিন্ন ভাষায় বিভিন্ন শব্দার্থবিজ্ঞান থাকতে পারে। পাইথন খালি ম্যাচগুলিতে বিভক্ত হয় না, জাভা ফাঁকা স্ট্রিংগুলি সরিয়ে ফেলবে (যদি আপনি negativeণাত্মক সীমা নির্দিষ্ট না করেন), জাভাস্ক্রিপ্ট শূন্য স্ট্রিং ম্যাচে সূচক 0 তে বিভক্ত হবে না।
  • "খারাপ সমাধান" আসলে "প্রস্তাবিত সমাধান" এর চেয়ে বেশি বহনযোগ্য। তবে লাইন টার্মিনেটরটি কী বিবেচনা করা উচিত তা আপনি যা কাজ করছেন তার স্পেসিফিকেশনের উপর নির্ভর করে (যেমন সি উত্স কোড)।
  • বর্তমানে, বেশিরভাগ রেজেক্স ইঞ্জিনগুলি স্তর 1 ইউনিকোড সমর্থনের পক্ষেও উপযুক্ত নয় । তাদের ইউনিকোড বৈশিষ্ট্য এবং ব্লক থাকতে পারে, তবে উপরে বর্ণিত হিসাবে লাইন সীমানা বিভাগের বাস্তবায়ন সমস্ত জায়গাতেই রয়েছে। জাভাস্ক্রিপ্ট এমনকি ইউনিকোড অক্ষর বৈশিষ্ট্য সমর্থন করে না!

1

বাশ স্ক্রিপ্ট

new_string=`echo $string`

এটি স্ট্রিংকে নিউলাইন দ্বারা বিভক্ত করে। আপনি যদি প্রতিধ্বনিত হন তবে $new_stringআপনি লক্ষ্য করবেন যে এটি নতুন রেখাকে অ্যারে বিভাজকগুলিতে প্রতিস্থাপন করেছে।

নমুনা আউটপুট:

[glitchmr@guava ~]$ string=$'some\nnice\nstring'
[glitchmr@guava ~]$ echo "$string"
some
nice
string
[glitchmr@guava ~]$ new_string=`echo $string`
[glitchmr@guava ~]$ echo "$new_string"
some nice string
[glitchmr@guava ~]$

1

জাভা

এটি কোনও ফাইল থেকে পড়ে না। নিয়মিত এক্সপ্রেশন ব্যবহার করা হয়। কোডটি ধরে রেখেছে স্ট্রিং রিডে নতুন the সংখ্যাগুলি 1,2,3,4 বিভক্তটি নির্দেশ করতে ব্যবহৃত হয়।

public static void main(String args[])
{

    String strSource = "1.This is a string.This is a string.This is a string.This is a string.This is a string.\n2.This is a string.This is a string.This is a string.This is a string.This is a string.\n3.This is a string.This is a string.This is a string.This is a string.This is a string.\n4.This is a string.This is a string.This is a string.This is a string.This is a string.";
    String[] tokens = Pattern.compile("\n").split(strSource,10) ;
    for (int loop=0;loop<tokens.length;loop++)
        System.out.println(tokens[loop]);
}

1

সি শার্প

static class Module1{
    public static void Main()
{
        dynamic i = 0;
        foreach (object line_loopVariable in split_into_lines(Console.In.ReadToEnd())) {
            line = line_loopVariable;
            i += 1;
            Console.WriteLine("Line {0}: {1}", i, line);
        }
    }
    public static IEnumerable<string> split_into_lines(string text){
        dynamic temp_file_name = System.IO.Path.GetTempFileName();
        System.IO.File.WriteAllText(temp_file_name, text);
        return System.IO.File.ReadLines(temp_file_name);
    }
}

1

আপনি আপনার "স্ট্রিংটিকে" নতুন রেখাটি বিভক্ত করতে চান কিনা তা সংবেদনশীল বা সংবেদনশীল কিনা তা আপনি নির্দিষ্ট করতে পারেন না। আমি সংবেদনশীল ধরে নিই।

public class SplitStringAtNewline
{
  public static final String STRING_TO_SPLIT = "Hellonew lineWorld";
  public static void main (String [] args)
  {
     System.out.println (
        String.join("",
          Pattern.compile("[nN][eE][wW] [lL][iI][nN][eE]")
              .splitAsStream(STRING_TO_SPLIT)
              .map((s) -> s + "\n")
              .collect(() -> new ArrayList<>(),
                    (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))));

  }
}

1

ডুড, পাওয়ারশেলের ক্ষেত্রে এটি করা খুব সহজ।

কেবল আপনার স্ট্রিংটি পান:

$string = "Helloworld!"

তারপরে এলোমেলো ascii এর উপর লুপ করুন যতক্ষণ না আপনার স্ট্রিংটি এইভাবে দুটিতে বিভক্ত হয়:

Do {
        1..($string.length+1) | % {$new_string+=[char](random (33..127))}
        rv new_string
} Until ($new_string -eq ($string.insert(($string.length/2)-1," ")))

অবশেষে আপনার বিভক্ত স্ট্রিংটি পাওয়া উচিত, যা আপনি এটির মতো আউটপুট করতে পারেন:

Write-Host $new_string

আউটপুট:

ওহে বিশ্ব!


1

পিএইচপি

<? Spliter($yourstring); ?>

আপনি এখানে স্ট্রিংকে কীভাবে বিভক্ত করবেন that তা কি সহজ নয়?

আপনাকে এখন যা করতে হবে তা হ'ল ফাংশনটি লিখতে Spliter()


1

বাশ নির্দিষ্ট

জন্য দুর্দান্ত কাজ আছে !

হ্যাঁ, বিভক্ত স্ট্রিং সত্যিই সহজ উপায়ে করা সম্ভব:

string=$'foo\nbar\nbaz'

প্রথমে আপনাকে একটি পরিবর্তনশীল শুরু করতে হবে যা আপনি আপনার বিভক্ত ফলাফল সংরক্ষণ করতে ব্যবহার করবেন:

declare -a lines

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

limitA=0

ঠিক আছে, এখন আপনি বিভাজকটি অনুসন্ধান করতে এবং একটি লুপ ব্যবহার করে আপনার লাইনগুলি সঞ্চয় করতে পারেন । যেমন বাইনারি মান নিয়ে কাজ করতে পারে না, আপনি odনমুনার জন্য, হেক্সাডেসিমাল মানগুলির সাথে কাজ করার মতো সরঞ্জামটি ব্যবহার করতে পারেন :

while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

এখন, আমাদের একটি বিভক্ত স্ট্রিং ভেরিয়েবলে সংরক্ষণ করা হয়েছে lines:

set | grep ^lines=
lines=([0]="foo" [1]="bar" [2]="baz")

যা ব্যবহার করে আমরা মুদ্রণ করতে পারি:

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo ${lines[idx]}
done

এই সমস্ত একটি স্ক্রিপ্টে রাখছি:

#!/bin/bash

string=$'this is a very long string containing spaces\nshorted, but containing comas...\nthird line.'
declare -a lines
limitA=0
while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo $idx: ${lines[idx]}
done

এটি মুদ্রণ করবে:

0: this is a very long string containing spaces
1: shorted, but containing comas...
2: third line.

আধুনিক বাশ

তবে আধুনিক বাশ বাস্তবায়ন ব্যবহার করে আপনি কন্ট্রোল অক্ষরকে নতুন লাইনের মতো পরিবর্তনশীল হিসাবে সংরক্ষণ করতে পারেন এবং এগুলি পরীক্ষাও করতে পারেন:

#!/bin/bash

string=$'foo\nbar\nbaz'
declare -a lines
limitA=0
for (( idx=0 ; idx < ${#string} ; idx++ ))
do

    if [ "${string:idx:1}" = $'\n' ]
    then

        lines+=( "${string:limitA:idx-limitA}" )
        limitA=$(( idx + 1 ))
    fi
done
lines+=( "${string:limitA}" )

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo ${lines[idx]}
done

বাশ গল্ফ

তবে আপনি যদি পঠনযোগ্যতার বিষয়ে চিন্তা না করেন তবে আপনি কনডেন্সড স্ক্রিপ্ট যেমন লিখতে পারেন:

IFS=$'\n' read -d'' -a lines <<<$'foo\nbar\nbaz'

গল্ফ স্ক্রিপ্ট হিসাবে প্রদর্শিত হতে পারে:

#!/bin/bash

IFS=$'\n' read -d'' -a lines <<<$'foo\nbar\nbaz'
printf "%s\n" ${lines[@]}

এবং একই প্রভাব দিতে হবে: প্রথম লাইন বিভক্ত স্ট্রিং এবং তাদের একটি অ্যারের নামে সংরক্ষণ লাইন । এবং দ্বিতীয় লাইনে অ্যারের প্রতিটি সদস্যকে ' লাইন ' " মুদ্রণ করবে , তারপরে একটি নতুন লাইন থাকবে

bash + vt কনসোল

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

#!/bin/bash

echo $'foo\nbar\nbaz'

একই ফলাফল দেবে।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.