Bài tập về nhà của tôi là lấy một chuỗi và chia nó thành từng mảnh ở mỗi dòng mới. Tôi không có ý tưởng gì để làm! Hãy giúp tôi!

^{Lưu ý: Đây là một câu hỏi trolling mã . Xin đừng coi trọng câu hỏi và / hoặc câu trả lời. Thêm thông tin ở đây .}

C

Bài tập về nhà của tôi là lấy một chuỗi và chia nó thành từng mảnh ở mỗi dòng mới. Tôi không có ý tưởng gì để làm! Hãy giúp tôi!

Vấn đề rắc rối cho một lớp lập trình C bắt đầu! Đầu tiên bạn phải hiểu một vài điều cơ bản về chủ đề phức tạp này.

Một chuỗi là một chuỗi chỉ gồm các ký tự . Điều này có nghĩa là để các lập trình viên chỉ ra một thứ "vô hình" (đó không phải là khoảng trắng, được tính là một ký tự), bạn phải sử dụng một chuỗi ký tự đặc biệt bằng cách nào đó để có nghĩa là thứ vô hình đó.

• Trên Windows , dòng mới là một chuỗi gồm hai ký tự trong chuỗi: dấu gạch chéo ngược và n (hoặc chuỗi "\n")

• Trên máy Mac Linux hoặc OS / X , đó là một chuỗi gồm bốn ký tự: dấu gạch chéo ngược, n, dấu gạch chéo ngược và sau đó r: (hoặc "\n\r").

(Ghi chú lịch sử thú vị: trên các máy Macintosh cũ hơn, đó là một chuỗi gồm bốn ký tự khác nhau: "\ r \ n" ... hoàn toàn ngược với cách Unix làm mọi thứ! Lịch sử có những con đường kỳ lạ.)

Có vẻ như Linux lãng phí hơn Windows, nhưng thực sự nên sử dụng chuỗi dài hơn. Vì Windows sử dụng một chuỗi ngắn như vậy, thời gian chạy ngôn ngữ C không thể in ra các chữ cái thực \nmà không sử dụng các cuộc gọi hệ thống đặc biệt. Bạn thường có thể làm điều đó trên Linux mà không cần một cuộc gọi hệ thống (thậm chí nó có thể in \n\hoặc \n\q... bất cứ điều gì ngoài \n\r). Nhưng vì C có nghĩa là đa nền tảng nên nó thực thi mẫu số chung thấp nhất. Vì vậy, bạn sẽ luôn luôn nhìn thấy \ntrong cuốn sách của bạn.

(Lưu ý: Nếu bạn đang tự hỏi làm thế nào chúng ta nói về việc \nkhông có dòng mới mỗi khi chúng ta làm, StackOverflow được viết gần như hoàn toàn bằng HTML ... không phải C. Vì vậy, nó hiện đại hơn rất nhiều. được giải quyết bằng những điều bạn có thể đã nghe nói, như CLANG và LLVM.)

Nhưng trở lại với những gì chúng ta đang làm việc. Hãy tưởng tượng một chuỗi có ba phần và hai dòng mới, như:

"foo\nbaz\nbar"

Bạn có thể thấy độ dài của chuỗi đó là 3 + 2 + 3 + 2 + 3 = 13. Vì vậy, bạn phải tạo một bộ đệm có độ dài 13 cho nó và các lập trình viên C luôn thêm một vào kích thước của mảng để an toàn. Vì vậy, tạo bộ đệm của bạn và sao chép chuỗi vào nó:

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

Bây giờ những gì bạn phải làm là tìm kiếm mô hình hai ký tự đại diện cho dòng mới. Bạn không được phép tìm kiếm chỉ một dấu gạch chéo. Vì C được sử dụng để phân tách chuỗi khá nhiều, nên nó sẽ báo lỗi nếu bạn thử. Bạn có thể thấy điều này nếu bạn thử viết:

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

(Lưu ý: Có một cài đặt trong trình biên dịch nếu bạn đang viết chương trình chỉ tìm kiếm dấu gạch chéo ngược. Nhưng điều đó rất hiếm gặp; dấu gạch chéo ngược rất hiếm khi được sử dụng, đó là lý do tại sao chúng được chọn cho mục đích này. bật.)

Vì vậy, hãy tạo ra mô hình mà chúng ta thực sự muốn, như thế này:

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

Khi chúng ta muốn so sánh hai chuỗi có độ dài nhất định, chúng ta sử dụng strncmp. Nó so sánh một số ký tự nhất định của một chuỗi có khả năng lớn hơn và cho bạn biết liệu chúng có khớp hay không. Vì vậy, strncmp("\nA", "\nB", 2)trả về 1 (đúng). Điều này mặc dù các chuỗi không hoàn toàn bằng nhau trong ba chiều dài ... nhưng vì chỉ cần có hai ký tự.

Vì vậy, hãy bước qua bộ đệm của chúng tôi, mỗi lần một ký tự, tìm kiếm hai ký tự khớp với mẫu của chúng tôi. Mỗi lần chúng tôi tìm thấy một chuỗi hai ký tự của dấu gạch chéo ngược theo sau là n, chúng tôi sẽ sử dụng lệnh gọi hệ thống rất đặc biệt (hoặc "tòa nhà chọc trời") putcđể đưa ra một loại ký tự đặc biệt: mã ASCII 10 , để có được một dòng mới .

#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;
}

Đầu ra của chương trình này là kết quả mong muốn ... phân tách chuỗi!

foo
baz
bar

\t dành cho \ trolling ...

Hoàn toàn không chính xác từ trên xuống dưới. Nhưng chứa đầy những điều vô nghĩa nghe có vẻ hợp lý đã làm xáo trộn thông tin như những gì trong sách giáo khoa hoặc Wikipedia. Logic chương trình xuất hiện trong suốt trong bối cảnh thông tin sai lệch, nhưng hoàn toàn sai lệch. Ngay cả các biến toàn cục và trả về mã lỗi, cho biện pháp tốt ...

...

Tất nhiên, chỉ có một ký tự trong biểu diễn chuỗi C của chuỗi ký tự nguồn hai ký tự \n. Nhưng làm cho một bộ đệm lớn hơn là vô hại, miễn là strlen()được sử dụng để có được chiều dài thực tế để hoạt động.

...

Chúng tôi cố gắng thuyết phục người đọc rằng đó strncmplà một phép toán boolean khớp với (1) hoặc không (0). Nhưng nó thực sự có ba giá trị trả về (-1 khớp ít hơn, 0 cho bằng, 1 cho khớp lớn hơn) . "Mẫu" hai ký tự của chúng ta được so sánh không phải là [ \, n], mà là [ \n, \0] ... chọn bộ kết thúc null ẩn. Khi chuỗi đó trượt qua chuỗi, nó sẽ không bao giờ lớn hơn chuỗi hai ký tự, so với ... tốt nhất là bằng 0 nếu có một dòng mới kết thúc trong chuỗi đầu vào.

...

Vì vậy, tất cả điều này là lặp qua chuỗi và in nó một ký tự tại một thời điểm. Chi nhánh hàng đầu không bao giờ chạy. (Mặc dù bạn có thể hiểu được nếu chuỗi của bạn có \nmã thấp hơn mã trong đó, hãy nói rằng tab ... có thể được sử dụng để bỏ qua các ký tự một cách bí ẩn từ đầu ra :-P)

1. Lấy một cái kéo và chuỗi bạn muốn tách.
2. Mở cái kéo.
3. Đặt chuỗi của bạn giữa các lưỡi cắt kéo.
4. Đóng cái kéo.

Xin chúc mừng! Chuỗi của bạn bây giờ sẽ được chia. Nếu không, lặp lại các bước cho đến khi nó được. Nếu bạn đã lặp lại các bước một vài lần và chuỗi không bị phân tách, hãy thử sử dụng một hình cắt kéo sắc nét hơn.

TUYÊN BỐ TỪ CHỐI: Tôi không chịu trách nhiệm cho bất kỳ thiệt hại nào áp dụng cho bạn trong quá trình này.

Con trăn

Tôi cảm thấy rất tệ khi bạn được đưa ra một câu hỏi mẹo rõ ràng như bài tập về nhà. Một ngôn ngữ rất tiên tiến như Python làm cho điều này trở thành một lớp lót đơn giản:

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

Hãy upvote và chấp nhận.

C

Trong C thật dễ dàng:

#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

Gọi nó như thế này:

split("a\nb");

Ví dụ làm việc:

http://codepad.org/GBHdz2MR
Tại sao nó xấu:

• Nó dựa vào printfchức năng để phân chia chuỗi
• Nó hoàn toàn không thể hiểu được
• Nó sẽ gây nhầm lẫn cho bất cứ ai không hiểu #define(và ngay cả những người làm)

Điều này có thể được thực hiện trong một vài dòng mã bằng thuật toán đơn giản sau:

1. Tìm kiếm ký tự dòng đầu tiên trong chuỗi.
2. Nối phần lên dòng mới vào danh sách.
3. Loại bỏ phần lên đến dòng mới từ chuỗi.
4. Nếu chuỗi không trống, chuyển đến bước 1.

Tuy nhiên, điều này là lãng phí. Đây thực chất là một thuật toán tìm kiếm tuyến tính , có độ phức tạp thời gian tuyến tính (O (n)). Tôi sẽ cho bạn vào một kỹ thuật nâng cao hơn: tìm kiếm nhị phân . Tìm kiếm nhị phân hiệu quả hơn nhiều so với tìm kiếm tuyến tính: nó chỉ có độ phức tạp thời gian logarit (O (log (n)). Điều này có nghĩa là nếu không gian tìm kiếm lớn gấp đôi, thời gian tìm kiếm không tăng gấp đôi, nó chỉ tăng lên gấp đôi một lượng cố định!

Mã cho tìm kiếm nhị phân phức tạp hơn một chút, bởi vì nó sử dụng các kỹ thuật tiên tiến của phép đệ quy và phân chia và chinh phục . Nhưng nó chắc chắn xứng đáng với lợi ích hiệu suất. Nếu bạn gửi nó, tôi hy vọng bạn sẽ nhận được thêm tín dụng.

Ý chính của thuật toán này là:

• Cắt chuỗi thành hai.
• Với một cuộc gọi đệ quy, tách nửa đầu của chuỗi.
• Với một cuộc gọi đệ quy, tách nửa sau của chuỗi.
• Đặt các mảnh từ nửa đầu cùng với các mảnh từ nửa sau, và voilà !

Bạn đã không chỉ định một ngôn ngữ, vì vậy tôi đã viết nó bằng Python. Tất nhiên, trong thế giới thực, mọi người không viết bằng Python - sử dụng C hoặc C ++ (hoặc thậm chí tốt hơn, ngôn ngữ lắp ráp) để thực hiện. Đừng lo lắng nếu bạn không hiểu tất cả các mã đang làm gì - đây chắc chắn là công cụ nâng cao.

#!/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)

Tất nhiên tất cả các tuyên bố về hiệu suất là không có thật. Thuật toán đơn giản của người Viking có thể là tuyến tính hoặc bậc hai tùy thuộc vào cách bạn diễn giải nó. Thuật toán nâng cao của cải tiến là Θ (n × log (n)) (khá gần với tuyến tính trong thực tế), nhưng cậu bé, là hằng số nhân cao do việc xây dựng lại danh sách không liên tục (mà việc triển khai có phần vượt quá khả năng của nó ).

Phong cách Python, phong cách bình luận, tuyên bố về lựa chọn ngôn ngữ và mọi thứ khác trong bài đăng này cũng không phản ánh ý kiến ​​hoặc thói quen thực tế của tôi.

Ngôn ngữ lập trình

Các IOđơn nguyên có một chức năng để làm điều đó!

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

C ++

                                                                                                                                                                                                                      #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));
}

• Sử dụng lâu dài std::strstream
• Ra đi để giới thiệu rò rỉ bộ nhớ
• Giả định mù quáng 2045 byte sẽ đủ để giữ một strstream
• Những cái tên khủng khiếp
• Việc sử dụng std::tiền tố không nhất quán
• Không hoạt động cho chuỗi const
• Hoàn toàn bỏ qua lỗi tràn bộ đệm
• Bao gồm dòng đầu tiên của các lập trình viên, những người biết họ đang làm gì
• Trống rỗng trong khi cơ thể mà không có một bình luận
• Lập chỉ mục vấp ngã

Python 3 (gọn gàng và sạch sẽ)

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);

Hồng ngọc

Vâng, bạn thấy đầu tiên bạn phải làm cho nó thành một mảng như thế này

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

Bây giờ bạn phải đặt các phần tử dưới dạng chuỗi

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

Oh cũng xóa dấu phẩy cuối cùng đó

actually_real_arr = real_arr.chop

Rất tiếc, bạn phải đặt dấu ngoặc là một mảng

definitely_the_real_arr = "[#{actually_real_arr}]"

Bây giờ chỉ cần sử dụng chuỗi và bạn đã hoàn tất

final_arr = eval(definitely_the_real_arr)

Cái ác

• Rõ ràng, không sử dụng split
• hàng tấn biến vô dụng với tên vô dụng
• eval
• yêu cầu theo dõi dòng mới trong chuỗi đầu vào
• không hoạt động nếu chuỗi chứa 'hoặc,

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

Ví dụ đầu vào: "Hello\nworld\nstuff"
Đầu ra:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Ồ và tôi quên đề cập rằng mã là O (n ^ 2)

Nút.

Điều này rất đơn giản, bất kỳ lập trình viên nào cũng có thể -.-.
Đầu tiên chúng ta phải thay đổi hoststập tin để .com, .net, .orgánh xạ tới 127.0.0.1.
và phần còn lại là Javascript cơ bản mà bất kỳ noob nào cũng có thể hiểu được.

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,{}))
}

Có bạn đi :)

Hồng ngọc

Chuỗi trong lập trình được làm bằng Einsteintanium. Vì vậy, chúng rất khó phân chia.
May mắn cho bạn, tôi có bằng tiến sĩ hóa học và lập trình, vì vậy tôi có thể giúp đỡ.
Chúng tôi sẽ sử dụng ruby ​​cho việc này.

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

Điều này là xấu xa bởi vì:

• Chap nghèo sẽ sợ nhiễm độc phóng xạ
• Phần duy nhất "anh ấy có thể bỏ qua" là phần quan trọng
• Phạm vi lười biếng vô hạn. Ý tôi là thôi nào!

C ++

Nhờ các tính năng mới mạnh mẽ của ngôn ngữ lập trình C ++, điều này có thể được giải quyết dễ dàng bằng thư viện chuẩn, hãy nhớ đừng phát minh lại bánh xe .

#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;
}

Chỉnh sửa: Câu trả lời này rõ ràng chỉ là cố gắng tạo ra thứ gì đó phức tạp một cách ngu ngốc cho một nhiệm vụ tầm thường, và trong khi làm như vậy đã lạm dụng nhiều công cụ nhất có thể trong khi tôi vẫn có thể viết mã.

Dưới đây là một số điều cần lưu ý:

• Nhận xét nói về việc sử dụng lại mã và sử dụng thư viện chuẩn, std :: string không được sử dụng.
• Đối với mọi trường hợp trong đó độ dài của chuỗi cần được tính toán, lambda mới được xác định.
• Sử dụng các mẫu không có lý do tốt thực sự.
• Sử dụng memcpy để sao chép từng chữ cái ngẫu nhiên trong chuỗi.
• Rò rỉ bộ nhớ ở khắp mọi nơi, tuy nhiên các ý kiến ​​về vector chỉ ra tầm quan trọng của việc dựa vào lớp này để tránh rò rỉ bộ nhớ. Nó cũng trả về vectơ này bằng con trỏ tới bộ nhớ heap.
• Sử dụng lớp bản đồ để lưu trữ tạm thời, trong khi sử dụng nó giống như một vectơ.
• Có lẽ nhiều hơn, đầu tôi đau.
• Oh, và toàn bộ điều là đệ quy là tốt.

C #

Điều này sử dụng công nghệ đệ quy để chuyển đổi các dòng mới thành dấu phẩy. Chuỗi CSV kết quả có thể dễ dàng phân tách thành một mảng.

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;
            }
        }
    }
}

C ++

Trông hoàn toàn đáng tin và sách giáo khoa cho đến biểu thức cuối cùng. Nó thậm chí còn đúng, chỉ cần cố gắng giải thích điều này với giáo viên của bạn.

#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(); }
    );
}

Tất nhiên không có lời biện minh nào std::for_each, nhưng nó cho phép chúng ta sử dụng sai lambda. Lambda đó trông giống như nó đang trả lại một cái gì đó, nhưng thực tế thì không. Toán tử ternary là có cho các tác dụng phụ.

Ổn thỏa! Vì vậy, vấn đề này được thực hiện rất dễ dàng bằng cách sử dụng một vài tính năng ít được biết đến của python, bao gồm các câu lệnh #define (gần đây họ đã chuyển chúng từ C ++) và đăng ký tự động các phương thức trên các lớp dựng sẵn.

#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!

Làm thế nào là tốt đẹp?

Giải trình

... có một danh sách khá lớn về sự trolling ở đây.

1. #define tuyên bố không tồn tại trong python!
2. Họ đặc biệt không đăng ký phương thức trên các lớp dựng sẵn tự động.
3. ra là "lười biếng ngay lập tức" - điều này thực sự có nghĩa là không có gì hữu ích.
4. Hàm được cung cấp sẽ bao gồm dấu phân cách trong kết quả.
5. Hàm được cung cấp sẽ không bao gồm phần tử cuối cùng của kết quả.
6. Tuy nhiên, mặc dù toán tử ~ được tạo thành trong bối cảnh này, ~ 0 là -1 có nghĩa là dòng đó sẽ thực sự hoạt động.
7. Lợi nhuận bị rối tung. Địa điểm thực tế nó sẽ trả về chỉ trả về mà không có giá trị.
8. Bug # 20221 là một lỗi python thực sự có tên "#define" - nhưng nó không liên quan gì đến điều này.
9. Dòng đầu vào chỉ có thể là một dòng duy nhất ... và chỉ chia tách khá vô giá trị vì nó không thể bao gồm các dòng mới.
10. Sử dụng sys.stdout.write (str (x)) thay vì in (x) là một cách tồi để làm việc.
11. "Máy ảo Python" là một khái niệm hoàn chỉnh trong trường hợp này. (Ngoài ra "phương thức lớp" sẽ là một phương thức tĩnh, không phải là một phương thức cá thể, do đó phần đó cũng sai)

Trên thực tế, chương trình hoạt động (ít nhất là trong Python 3.3.0, và bên cạnh vấn đề đầu vào một dòng) vì một loạt các điều khiến nó không làm những gì nó nói kết hợp để làm cho nó thực sự hoạt động.

LOLCODE khách quan

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

AN C

Đây là một nhiệm vụ tiêu chuẩn mà tất cả chúng ta đã làm. Đây là giải pháp thường được chấp nhận.

#include <stdio.h>

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

Bạn cần bao gồm thư viện với chức năng chính xác để phân chia và in. #include <stdio.h>

Tạo chuỗi bạn muốn tách: const char * input = "First Line\nSecond Line\nThird Line\n";Lưu ý cách tôi sử dụng consttừ khóa để minh họa rằng printf không có nghĩa là thay đổi đầu vào của bạn. Điều này rất quan trọng vì bạn luôn muốn duy trì thông tin người dùng ở dạng ban đầu cho các mục đích hợp pháp.

printf("%s", input); không chia tách cho bạn như bạn có thể thấy trong đầu ra giao diện điều khiển.

getchar(); chỉ là một mẹo nhỏ để giữ giao diện điều khiển kéo dài trong khi bạn kiểm tra đầu ra.

Đầu vào: "First Line\nSecond Line\nThird Line\n"

Tạo đầu ra:

First Line
Second Line
Third Line

Con trăn

Chúng ta có thể lặp lại sử dụng find()phương thức chuỗi của Python để phân tách chuỗi ở mọi trường hợp dòng mới (lưu ý rằng chuỗi đầu vào được mã hóa cứng là input_str, nhưng có thể được thay thế bằng raw_input ()):

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

Chạy tập lệnh trên, chúng tôi có được đầu ra dự kiến ​​(lưu ý rằng cả khoảng trắng đầu và cuối đều phù hợp với việc tách chuỗi ở mỗi lần xuất hiện dòng mới):

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

PHP / GD

Tách chuỗi là một vấn đề rất phức tạp. Mặc dù chúng tôi đã tiếp tục và thực hiện một cách khá cơ bản cho vấn đề bài tập về nhà rất quan trọng này.

Chạy mà không có bất kỳ sự phụ thuộc nào vào phiên bản PHP gần đây: Số lượng ví dụ bị giới hạn trong mã được đăng vì chúng tôi có giới hạn ký tự khoảng 40.000 ký tự ở đây không phù hợp với số lượng chuỗi trình diễn khá.

Phiên bản ví dụ:

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

Chính xác xác nhận thông số kỹ thuật của bạn.

<?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'
/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcgSlBFRyB2ODApLCBkZWZhdWx0IHF1YWxpdHkK/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sAQwEJCQkMCwwYDQ0YMiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy/8AAEQgBQADuAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A9/NJSmkoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAU0lKaSgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAFNJSmkoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAU0lFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRmigAooooAKDSmmk0AGaTcK4nUviHbp4gm0HRdOudY1GD/j5MTLHBb/AO/K3H5A9COoxVbVfFfiqwVJbXQtIvAF/eQQ6jIHz7F4lU/qfaiwHoG4Utef6D8VdE1S+XTtQiudG1Jm2i3v02Bj2w3Tntu2k9hXeK1DTW4ElFIDS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFJmgBaTNNL1Tv8AUrTTLR7q+uYbW3QfNLM4RR+JoAulhUUs8cMTSSyIkajLMxwFHqSa5i38TXfiBA3h2yJtGGRqV8jRxMPWOPh5O3Pyrz949KZceDrLU3Euvz3essDkRXDlbdT7QphePVtx9zR6gVL/AOL3gvT5mhOrm4K8M1rA8qD/AIEBj8q1fD3j/wANeJ5/s+l6kklxjcIJEaNyB3AYDP4VbjgsdPtPJhtbe0tlH3FiWNAPoABXk/jPVPA8Wt6dHoFhDc+JRfQvG+k4QAhwSHZPlYkZGOTzyQKr3WI90BzRSDvS1IxTUM+7yn2ff2nb9ccVMaawzQB5v8L9Itovh/ZXDAPd3byzXshA3PNvZW3e4xj8Peumm0mJ87cqapnQ7/RNSurnRZ4ltruQzT2M6Fo/MPV0IIKE8FhyCecAnNRzr4muUdRfW9pu+61tbfMv4yFwfrgfSh6sDO8Q+DrHWbEwajbCRF4STo0ef7rdvp0PcGuXt9R8Y/DxUZml17w3GQGDKTPbx+ze3uSvGPkq9qvwufXWMuq63q95Nj5WmlRgv0XbtH4CuUv/AIK6xa7pdI1YBgPkVlaFh/wNSf5VpG1rXEe8aVq1jrOmwahp1wk9rMMpIp/MEdiOhB5BGKzte8a6F4ZvbO11e++zyXe7yzsZlAGMliAdo5HX69BmvmmaLx38Pt0co1GximYgS20p2SFR6jg8eoBwPasGTVb57ub7TNPJPOF84XgZnk5DLknJ6cjkcUlFX3C59V+JPHukaBp8U8U0eoXNyQLa2tpA5lzjByM4HI575AGSRXSW1x51rDM6GF5EVjFIy7kJGdpwSMjpwSK+LrkpFLgqZI2GRIAA/GR16HHvXVaF8Ste8OaLHYaZcWk9pC5IWeL94u5ieeR6j2q3S7CufVnmR/3l/Ok81P76/nXy+3xr8VO2ALJR/wBcP65+v6e+Q/GfxeVI86yH0thx+v0/Wo9nIdz6f86L++Pzo8+L++K+Wn+MPjMvkahbrnstqn9RSr8X/GfX+0ID6g2ic/pT9mwufUn2iL++PzpPtMP98V8t/wDC4fGoYt9utST1BtExTl+M/jBMln058/3rTp+TCk6bC59Q/aof736GkN5CO5/KvmI/G3xh2/stSe/2U/8AxVInxq8Zb8+Zp3PY2n/2VLkkFz6d+2wf3v0pftcPYn8q+Z4vjZ4wjI3DSpAOoa0PP5OK00+PWtJFiXQtNeQfxo8iD8uf50/ZyC56T4r+KVt4T8U2um3VhJLZS24lluY3G6MliB8p4xxk5I68ZxisLxb8aLJLSODwnL9qvWO4yT27qqAc7drBSScYPYDvnFcLqHxWh1hmurzwrogvxF5cdzIvnOuMkbVYdskjJxmuX021fWZtN02ytoo729ncvLIzOHQseq5wAOfuj+H0q1BLViv2O28Q/G/xDNqarpMMGnwREoUdRMZmPQkkDHYgDnPUnpUH/CDeOfF8MWr6nqo+0tiSGO8JLKOoOwDbH9AM+oruPC3w2udA1iK/gmsZYXISeOaDEip6o4zz0OMAHGPcemR26R/dUVDlb4R+p4GPh78UrtyLjxDOIz1P9qz4/AAVpWvwZ1qT5tQ8TXbuf+eZc4/Fm5/KvcAtOCVPMxnibfAo3PF1rt3IgOQGQNj8ya7PwX8MNF8IXQu4Y3ub0DAubggsgPZQAAPrjPvXdhKeFxQ5NgKowtLRRSAU0hpTSUAIVBpNgp1FADNlMZampCKAMjWNGtNb09rK9hEkZIZc/wALDoQe3U/gT614j4r+FWtwXtvaaTBBcWku4tcg+W0YU/KpBOMkHJOOdoHGAK+gitQSRA9e1F7AfKuleCNa1vVbvQbezFtNboLlEu5QjRKx2nPG4jscDqF+ptXvwd8aW0w2aZBd/wC3bXUeB9d5U/pXp3j+xv8Aw/4os/G2loJPssXl3cJIG6EHkA98gnjsQp7V6NYXttqNhb3to2+3uY1lhIH3lIBHH49O3Sr9pID5h/4VX44Of+Kdm47+fD/8XTR8L/G+7H/CPTg+88P/AMXX1Rj1GPqKrzrs+YAfXFHtJCsfNEHwi8ay8tpUUP8A11u4v/ZWNacHwQ8XSr802kRez3Ln/wBBjNfQQn+X58CpI3D9PwwKPaMdj52l+CHjFHwo0yUeqXZA/wDHkFRt8FvGiLn7JYN7C8X/AAFfSak9MH8qfg4+6fyo9pILHy6/wi8ahjjRQ2OhF1Dz9PnFQH4T+ORz/YDj/t7g/wDjlfUjtj+FvypN29en50e0YWPl2H4W+M5ZQh0Ux5/ikuYcD8nNX2+DvjVEJ+w2z/7KXaZP5kV9Gso9OP5VKnHy/lR7SQWPmT/hUPjVNx/scZx1+1Rc+w+eu9+Gvge5sPFd5fanAkb2MS28EYdXKFkBJJUkA7CPqJO1et3M8VtDJNMwSKJDJI2fuqBkn8gapaBBIloZZ8/aJ3aeXJB2s7FtuQBkLkKD6KKUptqwGrHCE6ce1WFWhBUoFQA0LTgtLRTAMUUUUAFFFFACmkpTSUAFFFFABRRRQAEVGy1JSEUAZ19arcwlWAPFfO/xB8Nz+HdVE9tNLHptydoCs+LaQcgrg/KD/Rh3FfSjrXF+O/Dya5oN1a7QZGTMZPZxyvPbkYJ9CacXZ3A+c4PFXibT38qLXtXjMZxsN5IQuPYkj9Kvf8LH8ZquB4mv/wAdh/8AZa9Lg+Cuhavp9vd22tamryxL8zrEw3DjBAUcjGCAe3Wsi4+AOqo5+z6/ZSp28y3eMn8i386254MVmcBN478XT/63xHqTZ9Jtv8sVRPifxEc58Qavg9R9vl5/8er0JPgP4iLfPqOloPUPIf8A2QVOnwB1l/va5p6fSJ2z/KnzQA8vfWdWl4l1bUZPZruQ/wDs1MTUL5Pu312vqRO4/rXq4/Z/1X/oYbIfS2f/AOKqX/hQNwkRaXxPErDsNPJ/XzBS54geVpr+tQYEOtanHjpsvZRj/wAerQh8deK4kCp4j1TA9blmP5nNd3/woXUn5i8Q2hHbfauufyY1DJ8BtdT7usaa3uVkH6YNHPANTin8deK36+JdUP0uWH8qYvjXxUnTxLqo9c3bn+ZrsH+BniMOAuo6Yy92zIMfhs/rViP4Da2HRm1jTpCT/qykg3d8ZxxnpntmjmgAvgG+8TeKPEdtb3ur6jNZWkfn3YeVwrsTmNCRjkHBwTyFbPv77aReWgHtXC/DHwqugaPLNI8U91dTNI9zGmBIgYhMdSVx8wz/AHq9DQVhJ3egyRRT6QUtJAFFFFMAooooAKKKKAFNJSmkoAKKKKACiiigAooooAYwqldxCSJgehFaBqCRaQHGWWsaf4evbyw1O/gtEeT7TbGeQLuDAh1XOMkMrNgZOHHrWxaeK/Duo5+ya9pk23r5d2hx+tcV8XNEa98NNdwjM1i/2hPbHX+QP0B55NfPN95CXTZ2BX/eIGI+6ef/AK34VpCCktxH1DqnxS8G6VcGGbWEmkU/MLWJ5gMdiVBH61hN8dPCguBGLbV3TP8ArRbJt+uDJu/SvnjcNm/OVPfPH51GZYj/AMtUH/AhWnsohc+o7b4s+C7sAx61FEx/huUaIj/voAfrVqHxdo+rzBYNa0zyQe13Hlv1r5UDIf4lP407YpXGAR9KPZeYXPsiG+0/YAl/aNx2nU/1qyk0Mn3Jo3PoHBr4sMEX/PJP++RR9nh/55J/3yKXsfMLn2m7xJ950UepYVi6zqMJtxa2l5H9sumEEPlSIXXdks4HP3VDN9VA9q+R0tFllSJIULuwRQFHJJwK9n+CehJLqWpa2EUQRKtjasOOBhnOPf5Dn13e9RKHKrhc9osraK2tY4YUWONFCqqjAUAYwAOlX0FRIKnUVmhi0UUUwCiiigAooooAKKKKAFNJSmkoAKKKKACiiigAooooAKYwp9IRQBkapaJc2skUq742Uq65+8pGCPyrH8IWVpYaIlhDZW8T2jGGXy4tokPUSY5+8CD16kjPFdNcJlCK4HxPrs3gqG41qLTxeRFVinjEix4G75XLEHOCxGAOd/tR1sB3JRRxsT6YFNa2glXD28Dj0aNTXis/x6vILh4v+Ect2Cnhvtx5HY/c70kf7QUw+/4XQ+41E/8Axqr5JAexPoGjy5Muj6c5PUtaoc/pVKfwN4WuWzN4c0lz72kY/kK80X9oOHaN3hiUHvi+B/8AadW4v2gdJK/vtA1FT/sSxt/MijlkB2Mvwv8ABci4Phy0X/rmXT+TCqMnwe8ESLgaM8ZPdL2fj8C5FZEPx68NSf63TtVi+scbY/J6vQfG7wZIcSXF/B7yWbH/ANBzRaYDJfg74Rss3qHULZYUZ3K3G/C7Tk/Mp6DNdH4L0W30Lw7a2VvEY0UF9pcsRuYsRk/X2+lZ7+MtF8Tu+kaTcyzTny2uAbeWPZGSDgkgDJ4GM56+hrrbZNkSj2qJNvcC0gqYUxBT6ACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigCKQfLXM+I9Ot9R0+4srpS1vcRtE+ACQCMZGe46j3FdSw+Ws2/g8xCKQHyFqVjcW9w9nMhN3YubadY/m6E7W4HTGRn2FZrDyvvgx/7wxX1lpbfYtVmt8hDcfOhJHLKMFR/wABAPX+E8VuSYnX5wHH+1zWqqeQrHxb50fTen/fQpyup+6wP0NfZD2ls/D2tu4z/FEp/mKo3OgaDc83OhaXP6eZZRvj81p+18gsfI2atWMay3cYlH7pTvfjPyqMkduuMfjX1KfCHhV+D4X0TB9NOhH8lqlqfgzwjZafPMnhvTfNZfKRUgA3sxwBgYyM4J56A+lHtfILHNfBzRmTSZ9ZnQCbUJS6/LjEa8KB7feI9iK9diXpWRoWmw6ZptvawIqRQoqIFGAABjpW4i1k3d3GSKPlpaKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAA1BMmVqemuMrQBymtQTxoZ7XAuIzvjySFLDkA45wcYPsTXkMvx11uFlaTQ7AAlleJnlVo2BIKnJ+navdr+AOjcV87eNfBWpT+MLyHSdOnuUvE+2AQRkrHIOGzzgZPOTjlhgcU4WvZgW2+PGsFyRoWnBOw82TP50N8etX42aDp49cyyH/CuQX4c+Mnxjw3ff8CCj+ZqRfhj40fIHh26GOuXjH82rW0BHb6f8eNSluo4Z/D9kyMcEpcspHqckEcc13HhfxK3jyVb1bB7Wxs5WWPzJRJ5smMFhxwApIBHXe1eJN4C8UaZazTXWiXcbErECCjABjgn5SfYDHdvcV9GeDNAi0Dw/ZaemD5MYDkE/Mx5Zh9WJOO2azny9BnSQJhQKtqKiRalFSAtFFFABRRRQAUUUUAFFFFABRRRQAGilNJQAUZoooAM0ZooxQAZooxRQAUUUUAFFFFAFeZMqa4rX4W0/WNN1FVGxZvInOOkcg28YHZxGeoGAe+K7xhmszUtNhv7d4ZokkjYYKuoIP4GkBQidehPTtU/mJ26+1cqPAEKO2y+1gKx6f2rc8f8Aj9WbfwQsXH2vUmHpJqVw/wDNzTAsagv9qarp9guGjST7XOMZBVQRGCD0y5DAjvH2rqYItigdhVLS9Hg0yLZCgXcckjufUnvWsq0gFUU6iimAZooxRQAUZooxQAUUUUAGaKMUUAFFFFACmkoooAKKKM0AFFGaM0AFFGaKACiiigAooozQAUhGaXNGaAGbBRsFPooATaKWjNGaACijNFABRRRmgAoozRmgAoozRmgAoozRQAUUUUAFFKaSgAoxRRQAYoxRRQAUUUUAFFFFABRiiigAxRiiigAooooAKMUUUAGKKKKACjFFFABijFFFABijFFFABiiiigAooooAU0lBooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSc0GjNABzRzRRQAc0c0UUAHNHNFGaADmjmjNFABzRzRRQAc0c0ZooAOaOaM0ZoAOaOaKKADmjmiigA5o5oozQAc0c0ZozQAc0c0ZooAOaOaKKADmjmjNGaAFpMUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAJijFLRQAmKMUtFACUUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAf/9k=
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

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

Tôi không muốn có ý nghĩa, vì vậy đây là một đoạn mã Python hoạt động để phân tách chuỗi của bạn thành từng mảnh. Tuy nhiên, vì bạn không chỉ định nơi bạn muốn chia tách, tôi sẽ chỉ chọn các vị trí ngẫu nhiên. Tôi hy vọng điều đó ổn với bạn.

Con trăn

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()

Đối với các ngôn ngữ hỗ trợ biểu thức chính quy và có split sẵn chức năng, bạn nên luôn sử dụng nó để phân tách một chuỗi. Điều này giúp bạn tránh phát minh lại bánh xe và giữ cho mã của bạn ngắn và ngọt ngào. Sử dụng biểu thức chính quy cũng cho phép bạn chuyển mã của mình sang ngôn ngữ khác mà không thay đổi biểu thức thông thường.

Giải pháp xấu

Có giải pháp rõ ràng này khi bạn chia theo \nhoặc \r\n:

Java

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

PHP

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

Giải pháp đó là rác và không bao giờ nên được sử dụng. Trong thời đại ngày nay, việc tránh Unicode là vô ích, thay vào đó mọi lập trình viên nên nắm lấy nó và đảm bảo ứng dụng của bạn sẵn sàng sử dụng Unicode. Nếu bạn chỉ xem xét \nhoặc \r\nlà trình phân tách dòng mới, bạn đang viết phần mềm vào những năm 90. Trong thời đại Unicode này, bạn phải coi U + 0085, U + 2028, U + 2029 là dấu phân cách dòng hợp lệ. Vì Unicode được cập nhật mọi lúc, và thường phải mất một thời gian trước khi bạn nhận ra nó đã được cập nhật, có thể có một dấu tách dòng mới được thêm vào Unicode. Đừng băn khoăn, bởi vì tất cả các công cụ biểu thức chính quy đều sẵn sàng Unicode và chúng được cập nhật thường xuyên để tuân thủ tiêu chuẩn Unicode mới nhất. Vì vậy, nếu bạn đang sử dụng một ngôn ngữ được thông dịch, mã của bạn sẽ được cập nhật mà không cần bạn làm gì cả.

Giải pháp được đề nghị

Để phân tách một chuỗi bởi bộ kết thúc dòng và luôn cập nhật với sự phát triển của Unicode, hãy cung cấp chế độ biểu thức chính ^quy và chỉ định MULTILINE.

Theo mặc định, ^chỉ khớp với phần đầu của chuỗi. Trong MULTILINEchế độ, ^ cũng khớp với đầu dòng, tức là sau khi kết thúc dòng.

Ví dụ:

Java

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

PHP

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

Lưu ý rằng có một mục nhập chuỗi trống phía trước, chỉ cần loại bỏ nó hoặc lặp khỏi chỉ mục 1.

Giải trình

Thoạt nhìn, đây có vẻ là một câu trả lời tốt với một giải pháp hoạt động (phần nào), cùng với lời giải thích với một số khuyến nghị về thực hành tốt nhất về mã hóa. Tuy nhiên, bản thân giải pháp là một trò troll ( "Tôi biết, tôi sẽ sử dụng các biểu thức thông thường." Bây giờ họ có hai vấn đề. ) Và toàn bộ bài đăng được rắc thông tin sai lệch, sẽ đầu độc bất kỳ người mới nào để lập trình.

• Công cụ regex khác nhau hỗ trợ các bộ tính năng khác nhau. Nếu công cụ đích không có tính năng mà bạn sử dụng trong regex của mình, việc chuyển mã không đơn giản như sao chép và dán. Có thể mô phỏng với các tính năng được hỗ trợ hoặc có thể không thể làm điều đó với regex một mình.
• Có 2 loại động cơ : động cơ hướng văn bản (dựa trên tự động) và động cơ hướng regex (quay lui). Chuỗi trước trả về chuỗi dài nhất ngoài cùng bên trái, chuỗi sau trả về chuỗi sai lệch ngoài cùng bên trái (thiên về thứ tự thăm dò, được chỉ định bởi biểu thức chính quy). Cùng một regex có thể tạo ra kết quả khác nhau trên 2 loại động cơ.
• Ngay cả đối với cùng một tính năng, công cụ regex khác nhau có thể có cú pháp khác nhau để chỉ định nó.
• Ngay cả đối với cùng một tính năng và cùng một cú pháp, các công cụ regex khác nhau có thể có một số hành vi khác nhau trong phân tích cú pháp và khớp. Lỗi sang một bên, sự khác biệt có thể đến từ thiết kế của công cụ regex (có thể hoặc không thể được ghi lại).
• Trong MULTILINEchế độ, hành vi của ^và $phụ thuộc vào định nghĩa của "dòng kết thúc". Java xem xét \r\n, \n, \r, \u0085, \u2028, \u2029là dòng terminator, nơi \r\nchuỗi được coi là nguyên tử. Javascript xem xét \n, \r, \u2028, \u2029là Terminators dòng. Ruby chỉ coi \nlà kẻ hủy diệt dòng.
• splitchức năng có thể có ngữ nghĩa khác nhau trong các ngôn ngữ khác nhau cho các trường hợp góc. Python không phân chia trên các kết quả khớp trống, Java sẽ loại bỏ các chuỗi trống theo sau (trừ khi bạn chỉ định giới hạn âm), JavaScript không phân tách trên một kết hợp chuỗi trống ở chỉ số 0.
• "Giải pháp xấu" thực sự dễ mang theo hơn "giải pháp được đề xuất". Tuy nhiên, những gì nên được coi là một bộ kết thúc dòng phụ thuộc vào đặc điểm kỹ thuật của bất cứ điều gì bạn đang làm việc (ví dụ mã nguồn C).
• Hiện tại, hầu hết các công cụ regex thậm chí không tuân thủ hỗ trợ Unicode Cấp 1 . Chúng có thể có các thuộc tính và khối Unicode, nhưng việc triển khai cho phần Đường ranh giới ở khắp mọi nơi, như đã giải thích ở trên. JavaScript thậm chí không hỗ trợ các thuộc tính ký tự Unicode!

Kịch bản Bash

new_string=`echo $string`

Điều này phân tách chuỗi theo dòng mới. Nếu bạn lặp lại $new_string, bạn sẽ thấy rằng nó đã thay thế dòng mới thành dấu phân cách mảng.

Đầu ra mẫu:

[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 ~]$

Java

Điều này không đọc từ một tập tin. Biểu thức thông thường được sử dụng. Mã giả định chuỗi đọc có ký tự '\ n' để chỉ dòng mới. Các số 1,2,3,4 được sử dụng để chỉ sự phân chia.

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]);
}

C #

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);
    }
}

Bạn không chỉ định liệu "dòng mới" mà bạn muốn phân tách chuỗi của mình theo trường hợp nhạy cảm hay không nhạy cảm. Tôi cho rằng vô cảm.

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))));

  }
}

Anh bạn, điều này siêu dễ làm ở Powershell.

Chỉ cần lấy chuỗi của bạn như thế này:

$string = "Helloworld!"

Sau đó lặp lại ascii ngẫu nhiên cho đến khi bạn tách chuỗi thành hai như thế này:

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

cuối cùng bạn sẽ nhận được chuỗi phân tách, mà bạn có thể xuất ra như thế này:

Write-Host $new_string

Đầu ra:

Chào thế giới!

Php

<? Spliter($yourstring); ?>

Đây là cách bạn chia chuỗi. Điều đó có dễ không?

Tất cả bạn phải làm bây giờ là viết hàm Spliter()

bash cụ thể

Có một công việc tuyệt vời cho bash !

Có, tách chuỗi có thể được thực hiện theo cách thực sự đơn giản:

string=$'foo\nbar\nbaz'

Trước tiên, bạn phải khởi tạo một biến bạn sẽ sử dụng để lưu trữ kết quả đã tách:

declare -a lines

Bây giờ khi mỗi dòng được phân tách bằng hai dấu phân cách, bắt đầu hoặc kết thúc chuỗi, bạn sẽ cần một biến để lưu trữ dòng đầu tiên

limitA=0

Ok, bây giờ bạn có thể tìm kiếm dấu phân cách và lưu trữ các dòng của bạn bằng cách sử dụng một vòng lặp . Vì bash không thể hoạt động với giá trị nhị phân, bạn có thể sử dụng công cụ như odlàm việc với các giá trị thập lục phân, cho mẫu:

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")

Bây giờ, chúng ta có một chuỗi tách được lưu trữ thành biến lines:

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

Chúng tôi có thể in bằng cách sử dụng:

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

Đặt tất cả điều này trong một tập lệnh:

#!/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

Điều này sẽ in:

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

Bash hiện đại

Nhưng bằng cách sử dụng triển khai bash hiện đại , bạn có thể lưu trữ các ký tự điều khiển như dòng mới vào biến và thậm chí kiểm tra chúng:

#!/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

bash golf

Nhưng nếu bạn không quan tâm đến khả năng đọc, bạn có thể viết kịch bản cô đọng như:

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

Kịch bản golf có thể xuất hiện dưới dạng:

#!/bin/bash

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

và sẽ cho hiệu ứng tương tự: Chuỗi phân tách dòng đầu tiên và lưu trữ chúng trong một mảng có tên là các dòng . Và dòng thứ hai sẽ in từng thành viên của mảng '' lines '', theo sau là một dòng mới .

bảng điều khiển bash + vt

Nhưng vì nhiều người sử dụng bảng điều khiển văn bản dựa trên tiêu chuẩn ANSI VT , bạn có thể sử dụng các hành vi VT của bảng điều khiển của mình và viết lại đoạn ngắn này:

#!/bin/bash

echo $'foo\nbar\nbaz'

sẽ cho kết quả tương tự.