การบ้านของฉันรับสายและแบ่งเป็นชิ้น ๆ ในทุกบรรทัดใหม่ ฉันไม่รู้จะทำยังไง! กรุณาช่วย!

^{หมายเหตุ: นี่เป็นคำถามการหมุนรหัส กรุณาอย่าใช้คำถามและ / หรือคำตอบอย่างจริงจัง ข้อมูลเพิ่มเติมที่นี่}

C

การบ้านของฉันรับสายและแบ่งเป็นชิ้น ๆ ในทุกบรรทัดใหม่ ฉันไม่รู้จะทำยังไง! กรุณาช่วย!

ปัญหายุ่งยากสำหรับการเรียนรู้การเขียนโปรแกรมภาษา C เริ่มต้น! ก่อนอื่นคุณต้องเข้าใจพื้นฐานบางอย่างเกี่ยวกับเรื่องที่ซับซ้อนนี้

สตริงเป็นลำดับที่สร้างขึ้นจากตัวละครเท่านั้น นี่หมายความว่าเพื่อให้โปรแกรมเมอร์ระบุสิ่งที่ "มองไม่เห็น" (นั่นไม่ใช่ช่องว่างซึ่งนับเป็นตัวอักษร) คุณต้องใช้ลำดับอักขระพิเศษเพื่อหมายถึงสิ่งที่มองไม่เห็น

• บนWindowsบรรทัดใหม่คือลำดับของอักขระสองตัวในสตริง: backslash และ n (หรือสตริง"\n")

• บน LinuxหรือOS / X Macเป็นลำดับสี่อักขระ: แบ็กสแลช, n, แบ็กสแลชและจากนั้น r: (หรือ"\n\r")

(บันทึกประวัติศาสตร์ที่น่าสนใจ: สำหรับ Macintosh รุ่นเก่ามันเป็นตัวละครสี่ลำดับที่แตกต่างกัน: "\ r \ n" ... ย้อนกลับโดยสิ้นเชิงจากวิธีที่ Unix ทำสิ่งต่าง ๆ ! ประวัติศาสตร์ใช้ถนนที่แปลกประหลาด)

อาจดูเหมือนว่า Linux จะสิ้นเปลืองมากกว่า Windows แต่จริงๆแล้วมันเป็นความคิดที่ดีกว่าที่จะใช้ลำดับที่ยาวกว่า เนื่องจาก Windows ใช้ลำดับสั้น ๆ รันไทม์ภาษา C จึงไม่สามารถพิมพ์ตัวอักษรจริง\nโดยไม่ต้องใช้การเรียกระบบพิเศษ โดยปกติคุณสามารถทำได้บน Linux โดยไม่ต้องมีการเรียกระบบ (สามารถพิมพ์\n\หรือ\n\q... อะไรก็ได้ยกเว้น\n\r) แต่เนื่องจาก C นั้นหมายถึงการเป็น cross platform มันจึงบังคับให้มีตัวหารร่วมที่ต่ำที่สุด ดังนั้นคุณจะเห็น\nในหนังสือของคุณเสมอ

(หมายเหตุ: หากคุณสงสัยว่าเรากำลังพูดถึงเรื่องอะไร \nโดยไม่ต้องขึ้นบรรทัดใหม่ทุกครั้งที่ทำ StackOverflow ถูกเขียนเกือบทั้งหมดใน HTML ... ไม่ใช่ C. ดังนั้นมันจึงทันสมัยกว่ามากแง่มุมเก่า ๆ ของ C คือ ได้รับการแก้ไขโดยสิ่งที่คุณอาจเคยได้ยินเช่น CLANG และ LLVM)

แต่กลับไปที่สิ่งที่เรากำลังทำอยู่ ลองจินตนาการถึงสตริงที่มีสามชิ้นและสองบรรทัดใหม่เช่น:

"foo\nbaz\nbar"

คุณสามารถเห็นความยาวของสตริงนั้นคือ 3 + 2 + 3 + 2 + 3 = 13 ดังนั้นคุณต้องสร้างบัฟเฟอร์ความยาว 13 สำหรับมันและโปรแกรมเมอร์ C เสมอเพิ่มหนึ่งขนาดของอาร์เรย์ของพวกเขาเพื่อความปลอดภัย ดังนั้นให้บัฟเฟอร์ของคุณและคัดลอกสตริงลงไป:

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

ตอนนี้สิ่งที่คุณต้องทำคือมองหารูปแบบอักขระสองตัวที่แสดงถึงบรรทัดใหม่ คุณยังไม่ได้รับอนุญาตให้มองหาเพียงแบ็กสแลช เนื่องจาก C ใช้สำหรับการแยกสตริงค่อนข้างมากมันจะทำให้คุณมีข้อผิดพลาดถ้าคุณลอง คุณสามารถเห็นสิ่งนี้ถ้าคุณลองเขียน:

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

(หมายเหตุ: มีการตั้งค่าในคอมไพเลอร์สำหรับถ้าคุณกำลังเขียนโปรแกรมที่มองหาแบ็กสแลช แต่นั่นเป็นเรื่องผิดปกติอย่างมากแบ็กสแลชมักไม่ค่อยได้ใช้ซึ่งเป็นเหตุผลว่าทำไมพวกเขาถึงเลือกใช้ เปิดสวิตช์)

ดังนั้นเราจะสร้างรูปแบบที่เราต้องการเช่นนี้:

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

strncmpเมื่อเราต้องการเปรียบเทียบสองสายที่มีความยาวบางอย่างที่เราใช้ มันเปรียบเทียบจำนวนอักขระของสตริงที่มีขนาดใหญ่กว่าและบอกคุณว่าตรงกันหรือไม่ ดังนั้นstrncmp("\nA", "\nB", 2)ส่งคืน 1 (จริง) นี่คือแม้ว่าสายอักขระจะไม่เท่ากับความยาวทั้งหมดสาม ... แต่เนื่องจากจำเป็นต้องมีอักขระเพียงสองตัวเท่านั้น

ลองก้าวผ่านบัฟเฟอร์ของเราทีละตัวโดยมองหาอักขระสองตัวที่ตรงกับรูปแบบของเรา ทุกครั้งที่เราพบลำดับสองอักขระของแบ็กสแลชตามด้วย n เราจะใช้การเรียกระบบพิเศษมาก(หรือ "syscall") 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 สำหรับ \ trolling ...

ไม่ถูกต้องอย่างแน่นอนจากบนลงล่าง ยังเต็มไปด้วยเรื่องไร้สาระที่น่าเชื่อถือซึ่งมีข้อมูลที่กวนใจเหมือนสิ่งที่อยู่ในตำราเรียนหรือวิกิพีเดีย ตรรกะของโปรแกรมปรากฏโปร่งใสในบริบทของข้อมูลที่ผิด แต่ถูกเข้าใจผิดอย่างสมบูรณ์ แม้แต่ตัวแปรทั่วโลกและส่งคืนรหัสข้อผิดพลาดเพื่อการวัดที่ดี ...

...

แน่นอนมีเพียงหนึ่งตัวละครในการแสดงสตริง C สองตัวละครที่แหล่งที่มาที่แท้จริง\nลำดับ แต่การทำให้บัฟเฟอร์มีขนาดใหญ่ขึ้นนั้นไม่เป็นอันตรายตราบใดที่strlen()ใช้เพื่อให้ได้ความยาวตามจริงในการใช้งาน

...

เราพยายามโน้มน้าวผู้อ่านที่strncmpเป็นการดำเนินการบูลีนที่ตรงกับ (1) หรือไม่ (0) แต่มันจริงมีสามค่าผลตอบแทน(-1 จับคู่น้อยกว่า 0 เท่ากับ 1 สำหรับการจับคู่มากขึ้น) "รูปแบบ" ของตัวละครสองตัวที่เรานำมาเปรียบเทียบนั้นไม่ใช่ [ \, n] แต่เป็น [ \n, \0] ... การยกค่า null terminator โดยปริยาย เมื่อลำดับนั้นเลื่อนผ่านสตริงมันจะไม่มีวันยิ่งใหญ่กว่าลำดับสองตัวอักษรเมื่อเทียบกับ ... ที่ดีที่สุดมันจะเป็นศูนย์หากมีการขึ้นบรรทัดใหม่ในสตริงอินพุต

...

ทั้งหมดนี้ก็คือการวนรอบสตริงและพิมพ์ทีละตัวอักษร สาขาชั้นนำไม่เคยทำงาน (แม้ว่าคุณจะได้รับมันหากสตริงของคุณมี\nรหัสที่ต่ำกว่านั้นพูดแท็บ ... ซึ่งสามารถใช้เพื่อละเว้นอักขระอย่างลึกลับจากผลลัพธ์ :-P)

1. หยิบกรรไกรและสตริงที่คุณต้องการแยก
2. เปิดกรรไกร
3. ใส่สายของคุณระหว่างใบมีดกรรไกร
4. ปิดกรรไกร

ขอแสดงความยินดี! ตอนนี้คุณควรแบ่งสตริง ถ้าไม่ทำซ้ำขั้นตอนจนกว่ามันจะเป็น หากคุณทำซ้ำขั้นตอนสองสามครั้งและสตริงนั้นยังไม่ถึงแยกให้ลองใช้กรรไกรที่คมชัดกว่า

การปฏิเสธความรับผิด:ฉันจะไม่รับผิดชอบต่อความเสียหายใด ๆ ที่นำไปใช้กับคุณในระหว่างกระบวนการ

หลาม

ฉันรู้สึกแย่มากที่คุณได้รับคำถามกลอุบายที่ชัดเจนเช่นการบ้าน ภาษาขั้นสูงเช่น Python ทำให้เป็นสองซับง่าย:

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

โปรดโหวตและยอมรับ

C

ใน C มันง่ายมาก:

#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(และแม้แต่คนที่ทำ)

ซึ่งสามารถทำได้ในโค้ดไม่กี่บรรทัดโดยอัลกอริทึมแบบง่าย ๆ ดังต่อไปนี้:

1. ค้นหาอักขระขึ้นบรรทัดใหม่ตัวแรกในสตริง
2. ผนวกส่วนจนถึงบรรทัดใหม่ในรายการ
3. ลบส่วนที่ขึ้นบรรทัดใหม่จากสตริง
4. หากสตริงไม่ว่างให้ไปที่ขั้นตอนที่ 1

อย่างไรก็ตามนี่เป็นการสิ้นเปลือง นี่คืออัลกอริทึมการค้นหาเชิงเส้นซึ่งมีความซับซ้อนของเวลาเชิงเส้น (O (n)) ฉันจะให้คุณในด้านเทคนิคขั้นสูงเพิ่มเติมได้ที่: ค้นหาแบบทวิภาค การค้นหาแบบไบนารี่นั้นมีประสิทธิภาพมากกว่าการค้นหาแบบเชิงเส้น: มันมีเพียงความซับซ้อนของเวลาแบบลอการิทึมเท่านั้น(O (log (n))) ซึ่งหมายความว่าหากพื้นที่การค้นหามีขนาดใหญ่เป็นสองเท่า จำนวนเงินที่แน่นอน!

สำหรับค้นหา binary มีความซับซ้อนมากขึ้นอีกนิดเพราะใช้เทคนิคขั้นสูงของการเรียกซ้ำและหารและพิชิต แต่มันก็คุ้มค่าอย่างแน่นอนเพื่อประโยชน์ด้านประสิทธิภาพ หากคุณส่งสิ่งนั้นฉันคาดว่าคุณจะได้รับเครดิตเพิ่ม

ส่วนสำคัญของอัลกอริทึมคือ:

• ตัดสายเป็นสอง
• ด้วยการโทรซ้ำให้แบ่งครึ่งแรกของสตริง
• ด้วยการโทรซ้ำให้แบ่งครึ่งหลังของสตริง
• นำชิ้นส่วนจากครึ่งปีแรกด้วยกันกับชิ้นจากช่วงครึ่งหลังและVoila !

คุณไม่ได้ระบุภาษาดังนั้นฉันจึงเขียนเป็น Python แน่นอนว่าในโลกแห่งความเป็นจริงผู้คนไม่ได้เขียนด้วยภาษา Python ใช้ภาษา C หรือ C ++ (หรือภาษาแอสเซมบลีที่ดีกว่า) เพื่อประสิทธิภาพที่แท้จริง ไม่ต้องกังวลหากคุณไม่เข้าใจว่าโค้ดทั้งหมดกำลังทำอะไร - นี่คือสิ่งที่ล้ำสมัย

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

แน่นอนว่าข้อความทั้งหมดเกี่ยวกับประสิทธิภาพเป็นการหลอกลวง อัลกอริทึม“ ง่าย” อาจเป็นแบบเชิงเส้นหรือเป็นกำลังสองขึ้นอยู่กับว่าคุณตีความมันอย่างไร อัลกอริธึม "ขั้นสูง" คือΘ (n × log (n)) (ค่อนข้างใกล้เคียงกับเส้นตรงในทางปฏิบัติ) แต่เด็กเป็นค่าคงที่ทวีคูณสูงเนื่องจากการสร้างรายชื่อไม่หยุดหย่อน (ซึ่งการนำไปปฏิบัติค่อนข้างไกล )

สไตล์ Python สไตล์ความคิดเห็นข้อความเกี่ยวกับการเลือกภาษาและทุกอย่างในโพสต์นี้ไม่ได้สะท้อนความเห็นหรือนิสัยที่แท้จริงของฉัน

Visual Basic

IOmonad มีฟังก์ชั่นที่จะทำอย่างนั้น!

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

• ใช้เลิกใช้นาน std::strstream
• ออกไปเพื่อแนะนำหน่วยความจำรั่ว
• สุ่มสี่สุ่มห้าสมมติว่า 2,045 ไบต์จะพอเพียงที่จะถือ strstream
• ชื่อที่น่ากลัว
• การใช้std::คำนำหน้าอย่างไม่สอดคล้องกัน
• ไม่ทำงานสำหรับสตริง const
• ละเว้นการโอเวอร์รันบัฟเฟอร์อย่างสมบูรณ์
• รวมถึงโปรแกรมเมอร์บรรทัดแรกของ Hallmark ที่รู้ว่ากำลังทำอะไรอยู่
• ว่างเปล่าในขณะที่ร่างกายโดยไม่ต้องแสดงความคิดเห็น
• การสร้างดัชนีการสมัครสมาชิกใหม่

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

ทับทิม

ก่อนอื่นคุณต้องทำให้มันเป็นแบบนี้

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

ตอนนี้คุณต้องใส่องค์ประกอบเป็นสตริง

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

โอ้ยังลบเครื่องหมายจุลภาคสุดท้าย

actually_real_arr = real_arr.chop

โอ๊ะลืมคุณต้องใส่วงเล็บให้เป็นอาร์เรย์

definitely_the_real_arr = "[#{actually_real_arr}]"

ตอนนี้เพียงแค่ใช้สตริงและคุณเสร็จแล้ว

final_arr = eval(definitely_the_real_arr)

สิง:

• ชัดเจนไม่ได้ใช้ split
• ตันของตัวแปรไร้ประโยชน์ที่มีชื่อไร้ประโยชน์
• eval
• ต้องการการขึ้นบรรทัดใหม่ในสตริงอินพุต
• ไม่ทำงานหากสตริงมี'หรือ,

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

โอ้และฉันลืมที่จะพูดถึงว่ารหัสคือ O (n ^ 2)

Node.js

นี่เป็นโปรแกรมที่ง่ายมาก ๆ
ครั้งแรกที่เราต้องเปลี่ยนhostsไฟล์เพื่อให้แผนที่.com, .net, .org และส่วนที่เหลือเป็น Javascript พื้นฐานที่ไม่มีผู้ใดสามารถเข้าใจได้ 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,{}))
}

ไปแล้ว :)

ทับทิม

เงื่อนไขในการเขียนโปรแกรมทำจาก Einsteintanium พวกมันแยกกันยากมาก
โชคดีสำหรับคุณฉันมีปริญญาเอกด้านเคมีและการเขียนโปรแกรมดังนั้นฉันสามารถช่วยได้
เราจะใช้ทับทิมสำหรับสิ่งนี้

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

นี่คือความชั่วร้ายเพราะ:

• ขากรรไกรที่ไม่ดีจะกลัวพิษจากรังสี
• ส่วนเดียว "เขาสามารถเพิกเฉย" เป็นส่วนสำคัญ
• ช่วงขี้เกียจที่ไม่มีที่สิ้นสุด ฉันหมายถึงมา!

C ++

ด้วยคุณสมบัติใหม่อันทรงพลังของภาษาการเขียนโปรแกรม C ++ สิ่งนี้สามารถแก้ไขได้อย่างง่ายดายด้วยการใช้ไลบรารี่มาตรฐานอย่าจำสิ่งประดิษฐ์ใหม่อีกครั้งอีกคิดค้นล้อ

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

แก้ไข: คำตอบนี้เห็นได้ชัดว่าเพียงแค่พยายามสร้างบางสิ่งที่ซับซ้อนอย่างน่าประหลาดสำหรับงานที่ไม่สำคัญและในขณะที่ทำเครื่องมือมากเท่าที่ฉันจะทำได้ในขณะที่ยังสามารถเขียนรหัสได้

ต่อไปนี้เป็นสิ่งที่ควรทราบ:

• ความคิดเห็นพูดคุยเกี่ยวกับการใช้รหัสซ้ำและการใช้ไลบรารีมาตรฐาน std :: string จะไม่ถูกใช้
• สำหรับทุกอินสแตนซ์ที่ต้องการคำนวณความยาวของสตริงแลมบ์ดาใหม่จะถูกกำหนด
• ใช้แม่แบบโดยไม่มีเหตุผลดีจริง ๆ
• ใช้ memcpy เพื่อคัดลอกแต่ละตัวอักษร indidvidualในสตริง
• การรั่วไหลของหน่วยความจำมีอยู่ทั่วสถานที่ แต่ความคิดเห็นเกี่ยวกับเวกเตอร์ชี้ให้เห็นถึงความสำคัญของการพึ่งพาชั้นนี้เพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ มันจะคืนค่าเวกเตอร์นี้ด้วยตัวชี้ไปยังหน่วยความจำฮีพ
• ใช้คลาสแผนที่สำหรับการจัดเก็บชั่วคราวในขณะที่ใช้มันเหมือนเวกเตอร์
• อาจเป็นไปได้มากขึ้นที่หัวของฉันเจ็บ
• โอ้และสิ่งทั้งหมดก็เกิดซ้ำเช่นกัน

C #

สิ่งนี้ใช้เทคโนโลยีการเรียกซ้ำเพื่อแปลงบรรทัดใหม่เป็นเครื่องหมายจุลภาค สตริง CSV ที่ได้สามารถแบ่งออกเป็นอาร์เรย์ได้อย่างง่ายดาย

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 ++

ดูน่าเชื่อถือทั้งหมดและตำราเรียนจนถึงการแสดงออกครั้งสุดท้าย ถูกต้องเพียงแค่พยายามอธิบายสิ่งนี้กับครูของคุณ

#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แต่มันช่วยให้เราสามารถใช้แลมบ์ดาผิด แลมบ์ดานั้นดูเหมือนว่าจะคืนสิ่ง แต่ในความเป็นจริงแล้วมันไม่ได้ ผู้ประกอบการที่ประกอบไปด้วยเป็นเพียงสำหรับผลข้างเคียง

เอาล่ะ! ดังนั้นปัญหานี้เกิดขึ้นได้ง่ายมากโดยใช้คุณสมบัติที่รู้จักกันน้อยของ python รวมถึง #define statement (เมื่อเร็ว ๆ นี้พวกเขาย้ายพวกมันจาก C ++) และการลงทะเบียนอัตโนมัติของเมธอดบนคลาส builtin

#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. #define statement ไม่มีอยู่ใน python!
2. พวกเขาไม่ได้ลงทะเบียนวิธีการในชั้นเรียน builtin โดยอัตโนมัติ
3. out คือ "instantiated lazily" - ซึ่งไม่มีความหมายอะไรที่เป็นประโยชน์จริงๆ
4. ฟังก์ชั่นที่มีให้จะมีตัวคั่นในผลลัพธ์
5. ฟังก์ชั่นที่ให้มาจะไม่รวมองค์ประกอบสุดท้ายของผลลัพธ์
6. อย่างไรก็ตามแม้จะมีตัวดำเนินการ ~ ถูกสร้างขึ้นในบริบทนี้ ~ 0 คือ -1 ซึ่งหมายความว่าบรรทัดนั้นจะใช้งานได้จริง
7. ผลตอบแทนที่ได้จะสับสน สถานที่จริงมันจะกลับมาเพียงแค่ส่งกลับโดยไม่มีค่า
8. Bug # 20221 เป็นข้อผิดพลาดของงูหลามตัวจริงที่มี "#define" ในชื่อ - แต่ไม่มีอะไรเกี่ยวข้องกับสิ่งนี้
9. บรรทัดอินพุตสามารถเป็นบรรทัดเดียวเท่านั้น ... และแยกที่ไม่มีค่าพอสมควรเนื่องจากไม่สามารถรวมบรรทัดใหม่ได้
10. การใช้ sys.stdout.write (str (x)) แทน print (x) เป็นวิธีที่ไม่ดีในการทำสิ่งต่าง ๆ
11. "Python virtual machine" เป็นแนวคิดที่สร้างขึ้นในกรณีนี้ (เช่น "วิธีการเรียน" จะเป็นวิธีการคงที่ไม่ใช่วิธีการอินสแตนซ์ดังนั้นส่วนที่ผิดเช่นกัน)

ที่จริงแล้วโปรแกรมใช้งานได้ (อย่างน้อยใน Python 3.3.0 และนอกเหนือจากปัญหาอินพุตบรรทัดเดียว) เนื่องจากมีหลายสิ่งที่ทำให้มันไม่ได้ทำในสิ่งที่กล่าวไว้รวมกันเพื่อให้ใช้งานได้จริง

LOLCODE วัตถุประสงค์

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

ANSI C

นี่คือการมอบหมายมาตรฐานที่เราทุกคนทำได้ นี่คือคำตอบที่ได้รับการยอมรับโดยทั่วไป

#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 ไม่มีวิธีในการเปลี่ยนอินพุตของคุณ สิ่งนี้มีความสำคัญเนื่องจากคุณต้องการเก็บรักษาข้อมูลผู้ใช้ในรูปแบบดั้งเดิมเพื่อวัตถุประสงค์ทางกฎหมาย

printf("%s", input); ทำการแยกให้คุณอย่างที่คุณเห็นในคอนโซลเอาต์พุต

getchar(); เป็นเพียงเคล็ดลับพิเศษเล็กน้อยเพื่อให้คอนโซลยังคงทำงานอยู่ในขณะที่คุณตรวจสอบผลลัพธ์

อินพุต: "First Line\nSecond Line\nThird Line\n"

สร้างผลลัพธ์:

First Line
Second Line
Third Line

หลาม

เราสามารถใช้find()วิธีสตริงของ Python ซ้ำ ๆเพื่อแยกสตริงที่อินสแตนซ์ของบรรทัดใหม่ทุกรายการ (โปรดทราบว่าสตริงอินพุตนั้นมีการเข้ารหัสยากเหมือนinput_strกัน แต่สามารถแทนที่ด้วย 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

การเรียกใช้สคริปต์ข้างต้นเราได้รับผลลัพธ์ที่คาดหวัง (โปรดทราบว่าช่องว่างนำหน้าและต่อท้ายสอดคล้องกับการแยกสตริงที่เกิดขึ้นทุกบรรทัดใหม่):

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

PHP / GD

การแยกสตริงเป็นเรื่องที่ซับซ้อนมาก แม้ว่าเราจะดำเนินการต่อไปและทำการใช้งานขั้นพื้นฐานสำหรับปัญหาการบ้านที่สำคัญเช่นนี้

ทำงานโดยไม่มีการอ้างอิงใด ๆ กับ PHP เวอร์ชันล่าสุด: จำนวนตัวอย่าง จำกัด ในโค้ดที่โพสต์เนื่องจากเรามีจำนวนอักขระสูงสุดประมาณ 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

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

ฉันไม่ต้องการที่จะหมายถึงดังนั้นนี่คือชิ้นส่วนของโค้ด Python ที่ทำงานได้ซึ่งแยกสตริงของคุณออกเป็นชิ้น ๆ อย่างไรก็ตามเนื่องจากคุณไม่ได้ระบุตำแหน่งที่คุณต้องการให้แยกฉันจะเลือกตำแหน่งที่ตั้งสุ่ม ฉันหวังว่าไม่เป็นไรกับคุณ

หลาม

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

สำหรับภาษาที่รองรับการแสดงออกปกติและมีsplitฟังก์ชั่นพร้อมใช้งานคุณควรใช้มันเพื่อแบ่งสตริง สิ่งนี้จะช่วยให้คุณหลีกเลี่ยงการสร้างวงล้อใหม่และรักษารหัสของคุณให้สั้นและหวาน การใช้นิพจน์ทั่วไปยังช่วยให้คุณสามารถย้ายรหัสไปยังภาษาอื่นโดยไม่ต้องเปลี่ยนนิพจน์ปกติของคุณ

ทางออกที่ไม่ดี

มีวิธีแก้ปัญหาที่ชัดเจนซึ่งคุณแยกจากกัน \nหรือ\r\n:

ชวา

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

PHP

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

ทางออกนั้นคือขยะและไม่ควรใช้ ในยุคนี้มันไร้ประโยชน์ที่จะหลีกเลี่ยง Unicode แต่โปรแกรมเมอร์ทุกคนควรยอมรับมันและทำให้แน่ใจว่าแอพพลิเคชันของคุณนั้นพร้อมใช้งาน Unicode แล้ว หากคุณพิจารณาเท่านั้น\nหรือ\r\nเป็นตัวแบ่งบรรทัดใหม่คุณกำลังเขียนซอฟต์แวร์ใน 90s ในยุค Unicode นี้คุณต้องพิจารณา U + 0085, U + 2028, U + 2029 ให้เป็นตัวแยกบรรทัดที่ถูกต้อง เนื่องจาก Unicode ได้รับการอัปเดตเป็นระยะ ๆ และโดยทั่วไปจะใช้เวลาสักครู่ก่อนที่คุณจะทราบว่าได้รับการอัปเดตอาจมีตัวคั่นบรรทัดใหม่ที่เพิ่มเข้ามาใน Unicode ไม่ต้องกังวลเพราะเอ็นจินการแสดงผลปกติทั้งหมดนั้นพร้อมใช้งาน Unicode และพวกมันจะได้รับการปรับปรุงอย่างสม่ำเสมอเพื่อให้สอดคล้องกับมาตรฐาน Unicode ล่าสุด ดังนั้นหากคุณใช้ภาษาที่แปลรหัสของคุณจะเป็นรุ่นล่าสุดโดยที่คุณไม่ต้องทำอะไรเลย

วิธีแก้ปัญหาที่แนะนำ

หากต้องการแยกสตริงด้วยตัวยุติบรรทัดและอัพเดทล่าสุดกับวิวัฒนาการของ Unicode ให้ป้อน regex ^และระบุMULTILINEโหมดโหมด

โดยค่าเริ่มต้น^ตรงกับจุดเริ่มต้นของสตริงเท่านั้น ในMULTILINEโหมด^ นี้ยังตรงกับจุดเริ่มต้นของบรรทัดคือหลังจากที่เทอร์มิบรรทัด

ตัวอย่างเช่น:

ชวา

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

PHP

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

โปรดทราบว่ามีรายการสตริงว่างเปล่าไว้ข้างหน้าเพียงแค่เอาออกหรือวนซ้ำจากดัชนี 1

คำอธิบาย

จากภาพรวมในครั้งแรกดูเหมือนว่าจะเป็นคำตอบที่ดีพร้อมกับวิธีแก้ปัญหาการทำงาน (บ้าง) ควบคู่ไปกับการอธิบายพร้อมคำแนะนำเกี่ยวกับการเขียนโค้ดวิธีปฏิบัติที่ดีที่สุด อย่างไรก็ตามวิธีแก้ปัญหานั้นคือการหมุนรอบตัวเอง ( "ฉันรู้ว่าฉันจะใช้การแสดงออกปกติ" ตอนนี้พวกเขามีสองปัญหา ) และโพสต์ทั้งหมดจะถูกโรยด้วยข้อมูลผิด ๆ ซึ่งจะทำให้มือใหม่เขียนโปรแกรม

• เอนจิน regex ที่ต่างกันรองรับคุณสมบัติที่แตกต่างกัน หากเอ็นจิ้นเป้าหมายไม่มีคุณสมบัติที่คุณใช้ใน regex การย้ายรหัสไม่ง่ายเหมือนการคัดลอกและวาง อาจเป็นไปได้ที่จะจำลองด้วยคุณสมบัติที่รองรับหรืออาจเป็นไปไม่ได้ที่จะทำด้วย regex เพียงอย่างเดียว
• เอ็นจิ้นมี2 ประเภทคือเอ็นจิ้นข้อความกำกับ (เครื่องยนต์ออโตมาตา) และเอ็นจิ้นกำกับการเรกซ์ (ย้อนรอย) อดีตจะส่งคืนสตริงที่ยาวที่สุดที่อยู่ด้านหลังสุดซึ่งจะส่งกลับสตริงที่มีความเอนเอียงทางซ้ายสุด (เอนเอียงไปตามลำดับของการสำรวจตามที่ระบุโดย regex) Regex เดียวกันอาจให้ผลลัพธ์ที่แตกต่างกันในเครื่องยนต์ 2 ประเภท
• แม้จะมีคุณสมบัติเดียวกันเอ็นจิน regex ต่างกันอาจมีไวยากรณ์แตกต่างกันเพื่อระบุ
• แม้ว่าจะมีฟีเจอร์และไวยากรณ์เดียวกันเอ็นจิ้น regex ที่แตกต่างกันอาจมีพฤติกรรมที่แตกต่างกันในการวิเคราะห์และจับคู่ ข้อบกพร่องต่างกันอาจมาจากการออกแบบของเครื่องยนต์ regex (อาจมีหรือไม่มีเอกสาร)
• ในMULTILINEโหมดพฤติกรรมของ^และ$ขึ้นอยู่กับคำจำกัดความของ "line terminator" Java พิจารณา\r\n, \n, \r, \u0085,\u2028 , \u2029จะเป็นเทอร์มิเส้นที่\r\nลำดับถือว่าอะตอม JavaScript พิจารณา\n, \r, \u2028, \u2029ที่จะเป็นจุดสิ้นสุดบรรทัด Ruby พิจารณาว่า\nเป็นตัวยุติบรรทัดเท่านั้น
• splitฟังก์ชั่นอาจมีความหมายที่แตกต่างกันในภาษาที่แตกต่างกันสำหรับกรณีมุม Python ไม่ได้แยกการจับคู่ว่างเปล่า, จาวาลบสตริงที่ว่างเปล่าต่อท้าย (เว้นแต่คุณจะระบุขีด จำกัด เชิงลบ), จาวาสคริปต์ไม่ได้แยกในการแข่งขันสตริงว่างที่ดัชนี 0
• "วิธีแก้ปัญหาที่ไม่ดี" นั้นพกพาได้มากกว่า "โซลูชันที่แนะนำ" อย่างไรก็ตามสิ่งที่ควรพิจารณาเป็นตัวยุติบรรทัดขึ้นอยู่กับข้อกำหนดของสิ่งที่คุณกำลังทำงานอยู่ (เช่นซอร์สโค้ด C)
• ปัจจุบันส่วนใหญ่เครื่องยนต์ regex จะไม่ได้สอดคล้องกับการสนับสนุนระดับ 1 Unicode พวกเขาอาจมีคุณสมบัติและบล็อก Unicode แต่การใช้งานสำหรับส่วนของขอบเขตของเส้นนั้นครอบคลุมทุกพื้นที่ตามที่อธิบายไว้ข้างต้น JavaScript ไม่สนับสนุนคุณสมบัติของอักขระ Unicode!

Bash script

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

ชวา

สิ่งนี้ไม่ได้อ่านจากไฟล์ ใช้นิพจน์ทั่วไป รหัสจะถือว่าสตริงที่อ่านมีอักขระ '\ n' เพื่อระบุบรรทัดใหม่ ตัวเลข 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]);
}

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

คุณไม่ได้ระบุว่า "บรรทัดใหม่" ที่คุณต้องการแยกสตริงที่ตรงตามตัวพิมพ์เล็กหรือใหญ่หรือไม่ ฉันถือว่าไม่มีความรู้สึก

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

  }
}

เพื่อนนี่มันง่ายมากที่จะทำใน Powershell

เพิ่งได้รับสายของคุณเช่นนี้:

$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

เอาท์พุท:

สวัสดีชาวโลก!

php

<? Spliter($yourstring); ?>

นี่คือวิธีที่คุณแยกสตริงไม่ใช่เรื่องง่ายใช่ไหม

สิ่งที่คุณต้องทำตอนนี้คือการเขียนฟังก์ชั่น Spliter()

ทุบตีเฉพาะ

มีงานที่ยอดเยี่ยมสำหรับการทุบตี !

ใช่การแบ่งสตริงสามารถทำได้โดยวิธีง่ายๆ:

string=$'foo\nbar\nbaz'

ก่อนอื่นคุณต้องเริ่มต้นตัวแปรที่คุณจะใช้ในการจัดเก็บผลการแยกของคุณ:

declare -a lines

ตอนนี้เนื่องจากแต่ละบรรทัดถูกคั่นด้วยตัวคั่นสองตัวเริ่มต้นหรือสิ้นสุดของสตริงคุณจะต้องใช้ตัวแปรเพื่อเก็บบรรทัดแรก

limitA=0

ตกลงตอนนี้คุณสามารถค้นหาแยกและจัดเก็บสายของคุณโดยใช้ห่วง เนื่องจากbashไม่สามารถทำงานกับค่าไบนารีคุณสามารถใช้เครื่องมือที่ต้องการ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'

สคริปต์ golfed อาจปรากฏเป็น:

#!/bin/bash

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

และจะให้ผลเช่นเดียวกัน: ครั้งแรกสตริงสายแยกและเก็บไว้ในอาร์เรย์ชื่อสาย และบรรทัดที่สองจะพิมพ์สมาชิกแต่ละคนของอาเรย์ '' เส้น '' ตามด้วยการขึ้นบรรทัดใหม่

bash + vt console

แต่เนื่องจากมีหลายคนที่ใช้คอนโซลข้อความตามมาตรฐาน ANSI VTคุณสามารถใช้พฤติกรรม VT ของคอนโซลของคุณและเขียนสิ่งนี้ให้สั้นลงอีกครั้ง:

#!/bin/bash

echo $'foo\nbar\nbaz'

จะให้ผลลัพธ์เดียวกัน