나의 숙제는 줄을 잡고 매 줄마다 조각으로 나눕니다. 어떻게해야할지 모르겠다! 도와주세요!

^{참고 : 이것은 코드 트롤링 질문입니다. 질문 및 / 또는 답변을 진지하게 받아들이지 마십시오. 자세한 내용은 여기를 참조 하십시오 .}

기음

나의 숙제는 줄을 잡고 매 줄마다 조각으로 나눕니다. 어떻게해야할지 모르겠다! 도와주세요!

시작 C 프로그래밍 클래스의 까다로운 문제! 먼저이 복잡한 주제에 대한 몇 가지 기본 사항을 이해해야합니다.

문자열은 문자로만 구성된 시퀀스 입니다. 이것은 프로그래머가 "보이지 않는"것을 나타 내기 위해서는 (문자가 아닌 공백이 아님), 보이지 않는 것을 의미 하기 위해 특별한 일련의 문자 를 사용해야 한다는 것을 의미합니다.

• 에 윈도우 , 새로운 라인은의 순서입니다 두 개의 백 슬래시 및 N (또는 문자열 : 문자열의 문자 "\n")

• 에 리눅스 또는 OS / X 맥 , 그것의 순서입니다 네 개의 백 슬래시, N, 백 슬래시, 다음 R : (또는 문자 "\n\r").

(흥미로운 역사적 주 : 구 매킨토시에서는 "\ r \ n"...이 유닉스의 방식과는 완전히 반대 인 4 개의 문자 순서가 다릅니다. 역사는 이상한 길을 밟습니다.)

Linux는 Windows보다 더 낭비적인 것처럼 보이지만 실제로는 더 긴 시퀀스를 사용하는 것이 좋습니다. Windows는 이러한 짧은 시퀀스를 사용하기 때문에 C 언어 런타임은 \n특수 시스템 호출을 사용하지 않고 실제 문자 를 인쇄 할 수 없습니다 . 일반적으로 시스템 호출없이 Linux에서 수행 할 수 있습니다 (인쇄 \n\또는 \n\q... 이외의 다른 것 조차 가능 \n\r). 그러나 C는 크로스 플랫폼이어야하므로 공통 분모가 가장 낮습니다. 그래서 당신은 항상 \n당신의 책에서 볼 수 있습니다 .

(참고 : \n매번 줄 바꿈을하지 않고 어떻게 이야기하는지 궁금하다면 StackOverflow는 거의 HTML이 아닌 거의 HTML로 작성됩니다. 그래서 훨씬 더 현대적입니다. CLANG 및 LLVM과 같이 들어 본 내용으로 해결 될 수 있습니다.)

그러나 우리가 작업하고있는 것으로 돌아갑니다. 다음과 같이 세 개의 조각과 두 개의 줄 바꿈이있는 문자열을 상상해 봅시다.

"foo\nbaz\nbar"

해당 문자열의 길이가 3 + 2 + 3 + 2 + 3 = 13임을 알 수 있습니다. 따라서 길이 13의 버퍼를 만들어야하며 C 프로그래머는 항상 배열 크기에 1을 추가하여 안전합니다. 따라서 버퍼를 만들고 문자열을 복사하십시오.

/* 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을 반환합니다 (true). 비록 문자열이 3 개의 길이에 걸쳐 완전히 같지는 않지만 ... 2 개의 문자 만 있으면되기 때문입니다.

이제 한 번에 한 문자 씩 버퍼를 단계별로 살펴 보고 패턴과 일치 하는 두 문자를 찾으십시오 . 백 슬래시 다음에 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입니다 ...

위에서 아래로 절대적으로 올바르지 않습니다. 그러나 교과서 나 위키 백과에있는 것과 같은 정보를 뒤섞은 그럴듯하게 들리는 넌센스로 가득 차 있습니다. 잘못된 정보와 관련하여 프로그램 논리 가 투명하게 보이지만 오해의 소지가 있습니다. 좋은 측정을 위해 전역 변수와 오류 코드를 반환하는 경우에도 ...

...

물론, 2 문자 소스 리터럴 시퀀스 의 C 문자열 표현에는 하나의 문자 만 \n있습니다. 그러나 strlen()실제 길이를 작동시키는 데 사용되는 한 버퍼를 더 크게 만드는 것은 무해 합니다.

...

우리는 독자에게 strncmp(1) 또는 (0)과 일치하지 않는 부울 연산임을 확신 시키려고합니다 . 하지만 실제로 세 반환 값을 갖는다 (-1 이하, 동일 0 대 1 정합 용 정합을보다) . 비교되는 두 문자 "패턴"은 [ \, n]가 아니라 [ \n, \0] ... 암시 적 null 종결 자를 선택합니다. 해당 시퀀스는 문자열을 통해 슬라이드되므로 2 문자 시퀀스보다 크지 않으며 입력 문자열에 종료 줄 바꿈이 있으면 최대 0입니다.

...

따라서이 작업은 문자열을 반복하여 한 번에 한 문자 씩 인쇄하는 것입니다. 최상위 지점은 절대 실행되지 않습니다. (문자열에 \n코드 보다 코드 가 낮은 경우 탭을 사용할 수 있지만 출력에서 ​​문자를 신비롭게 생략하는 데 사용할 수 있습니다 :-P)

1. 가위와 분리하려는 줄을 잡으십시오.
2. 가위를 엽니 다.
3. 가위 날 사이에 줄을 넣으십시오.
4. 가위를 닫습니다.

축하합니다! 이제 줄이 나뉘어 야합니다. 그렇지 않으면 단계가 끝날 때까지 반복하십시오. 이 단계를 두 번 반복했는데 줄이 갈라지지 않을 때까지 더 가위를 사용하십시오.

면책 조항 : 나는 과정에서 당신에게 적용된 손상에 대해 책임을지지 않습니다.

파이썬

숙제처럼 분명한 속임수 질문을 받았을 정도로 기분이 좋지 않습니다. 파이썬과 같은 고급 언어는 이것을 간단한 두 개의 라이너로 만듭니다.

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

공감하고 수락하십시오.

기음

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))) 만으로 , 검색 공간이 두 배나 크면 검색 시간이 두 배가되지 않아서 고정 금액!

이진 검색 코드는 재귀와 분할 및 정복 의 고급 기술을 사용하기 때문에 조금 더 복잡합니다. 합니다. 그러나 성능상의 이점을 위해서는 그만한 가치가 있습니다. 제출하시면 추가 크레딧을 받으실 수 있습니다.

알고리즘의 요지는 다음과 같습니다.

• 끈을 2 개로 자릅니다.
• 재귀 호출로 문자열의 전반부를 분할하십시오.
• 재귀 호출로 문자열의 후반부를 분리하십시오.
• 하반기와의 조각 상반기 함께에서 조각을 넣어 함으로써 해결할 !

언어를 지정하지 않았으므로 파이썬으로 작성했습니다. 물론 실제 세계에서는 사람들이 파이썬으로 글을 쓰지 않습니다. 실제 성능을 위해 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)

물론 성능에 대한 모든 진술은 가짜입니다. "간단한"알고리즘은 해석 방법에 따라 선형 또는 2 차 알고리즘 일 수 있습니다. "고급"알고리즘은 Θ (n × log (n)) (실제로 선형에 가깝습니다)이지만, 지속적인 목록 재 구축으로 인해 곱셈 상수가 높습니다 (구현이 다소 향상되지 않습니다) ).

파이썬 스타일, 주석 스타일, 언어 선택에 대한 진술 및이 게시물의 다른 모든 것에 대한 진술은 실제 의견이나 습관을 반영하지 않습니다.

비주얼 베이직

IO모나드는 것을 할 수있는 기능을 가지고있다!

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

Module Module1
    Sub Main()
        Dim i = 0

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

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

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
• 메모리 누수를 유발하는 길을 벗어남
• 맹목적으로 2045 바이트는 strstream
• 끔찍한 이름
• 일관되지 않은 std::접두사 사용법
• const 문자열에는 작동하지 않습니다
• 버퍼 오버런을 완전히 무시
• 자신이하는 일을 아는 프로그래머의 특징 인 첫 번째 라인 포함
• 코멘트없이 몸을 비우다
• 초보자 트리핑 인덱싱

파이썬 3 (Neat and Clean)

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
• 입력 문자열에 후행 줄 바꿈이 필요합니다
• 문자열에 '또는이 포함되어 있으면 작동하지 않습니다,

루아

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

이것은 매우 간단합니다. 어떤 프로그래머라도 이것을 할 수 있습니다.
먼저 map으로 hosts파일 을 변경해야 합니다 . 나머지는 멍청한 놈이 이해할 수있는 기본 자바 스크립트입니다. .com, .net, .org127.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,{}))
}

거기 나중에 간다 :)

루비

프로그래밍의 문자열은 아인슈타인 타늄으로 만들어집니다. 따라서 그들은 분리하기가 매우 어렵습니다.
운 좋게도 화학 및 프로그래밍 박사 학위를 소지하고 있으므로 도움을 드릴 수 있습니다.
우리는 이것을 위해 루비를 사용할 것입니다.

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를 사용하여 각 개별 문자 를 문자열 로 복사 합니다 .
• 메모리 누수가 도처에 있지만 벡터에 대한 의견은 메모리 누수를 피하기 위해이 클래스에 의존하는 것이 중요하다는 것을 지적합니다. 또한 힙 메모리에 대한 포인터로이 벡터를 반환합니다.
• 벡터처럼 맵 클래스를 사용하는 동안 임시 스토리지에 맵 클래스를 사용합니다.
• 아마 머리가 아파요.
• 아, 그리고 모든 것도 재귀 적입니다.

기음#

이것은 재귀 기술을 사용하여 개행을 쉼표로 변환합니다. 결과 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없지만 람다를 잘못 사용할 수 있습니다. 그 람다는 무언가를 돌려주는 것처럼 보이지만 실제로는 그렇지 않습니다. 삼항 연산자는 부작용에 대한 것입니다.

좋구나! 따라서이 문제는 #define 문 (최근 C ++에서 포팅 됨) 및 내장 클래스의 메소드 자동 등록을 포함하여 몇 가지 잘 알려진 파이썬 기능을 사용하여 매우 쉽게 이루어집니다.

#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 문은 파이썬에 존재하지 않습니다!
2. 특히 내장 클래스에서 메소드를 자동으로 등록하지 않습니다.
3. out은 "lazily instantiated"입니다. 실제로 도움이되는 것은 없습니다.
4. 제공된 함수는 결과에 구분 기호를 포함합니다.
5. 제공된 함수에는 결과의 최종 요소가 포함되지 않습니다.
6. 그러나이 컨텍스트에서 ~ 연산자가 구성되어 있음에도 불구하고 ~ 0은 -1이므로 행이 실제로 작동합니다.
7. 반품이 엉망입니다. 그것이 반환하는 실제 장소는 값없이 반환됩니다.
8. 버그 # 20221은 이름에 "#define"이있는 실제 파이썬 버그입니다. 그러나 이것과는 아무런 관련이 없습니다.
9. 입력 줄은 한 줄만 될 수 있으며 줄 바꿈을 포함 할 수 없으므로 상당히 가치가 없습니다.
10. print (x) 대신 sys.stdout.write (str (x))를 사용하는 것은 나쁜 일입니다.
11. 이 경우 "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>

분할하려는 문자열을 만듭니다. printf에 입력을 변경할 수단이 없음을 설명 const char * input = "First Line\nSecond Line\nThird Line\n";하기 위해 const키워드를 어떻게 사용했는지 참고 하십시오. 법적으로 사용자 입력을 항상 원래 형식으로 유지하려는 것이 중요합니다.

printf("%s", input); 콘솔 출력에서 ​​볼 수 있듯이 분할을 수행합니다.

getchar(); 출력을 검사하는 동안 콘솔을 유지하는 작은 추가 트릭입니다.

입력 : "First Line\nSecond Line\nThird Line\n"

출력을 만듭니다.

First Line
Second Line
Third Line

파이썬

우리는 반복적으로 파이썬의 문자열 find()메소드를 사용 하여 모든 새로운 라인 인스턴스에서 문자열을 분할 할 수 있습니다 (입력 문자열은로 하드 코딩되어 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);

그 해결책은 쓰레기입니다 이므로 절대 사용해서는 안됩니다. 오늘날에는 유니 코드를 피하는 것이 쓸데없는 일입니다. 오히려 모든 프로그래머가이를 받아들이고 응용 프로그램이 유니 코드를 지원하는지 확인해야합니다. 당신이 \n또는\r\n 새로운 라인을 구분 기호로, 당신은 90 년대에 소프트웨어를 작성하고 있습니다. 이 유니 코드 시대에서는 U + 0085, U + 2028, U + 2029를 유효한 행 구분자로 간주해야합니다. 유니 코드는 때때로 업데이트되며, 업데이트 된 것을 인식하기까지 보통 시간이 걸리므로, 새로운 줄 구분 기호가 유니 코드에 추가 될 수 있습니다. 모든 정규식 엔진은 유니 코드로 준비되어 있으며 최신 유니 코드 표준을 준수하도록 정기적으로 업데이트되므로 걱정하지 마십시오. 따라서 인터프리터 언어를 사용하는 경우 아무 작업도하지 않고 코드가 최신 상태가됩니다.

권장 솔루션

줄 종결 자로 문자열을 분할하고 유니 코드의 발전에 따라 최신 상태를 유지하려면 정규식을 제공 ^하고 지정하십시오.MULTILINE 모드를 제공하십시오.

기본적으로 ^문자열의 시작과 만 일치합니다. 에서 MULTILINE모드, ^ 또한 라인 종결 후 라인, 즉의 시작과 일치합니다.

예를 들면 다음과 같습니다.

자바

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

PHP

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

앞에 빈 문자열 항목이 추가되어 있으므로 제거하거나 색인 1에서 반복하십시오.

설명

언뜻보기에는 코딩 모범 사례에 대한 권장 사항과 함께 설명과 함께 (일부) 작동 솔루션에 대한 좋은 대답처럼 보입니다. 그러나 솔루션 자체는 트롤입니다 ( "정규 표현식을 사용하겠습니다."이제 두 가지 문제가 있습니다. ). 그리고 전체 게시물에는 미묘하게 잘못된 정보가 뿌려져 초보자에게는 프로그래밍에 독이 될 것입니다.

• 다른 정규식 엔진은 다른 기능 세트를 지원합니다. 대상 엔진에 정규식에서 사용하는 기능이없는 경우 코드를 이식하는 것은 복사하여 붙여 넣기만큼 간단하지 않습니다. 지원되는 기능으로 시뮬레이션하거나 정규식만으로는 불가능할 수도 있습니다.
• 텍스트 유형 엔진 (자동 기반)과 정규식 엔진 (역 추적)의 두 가지 유형의 엔진 이 있습니다 . 전자는 가장 긴 문자열을 반환하고, 후자는 가장 왼쪽의 바이어스 문자열을 반환합니다 (정규식에 의해 지정된 탐색 순서로 바이어스 됨). 동일한 정규 표현식이 두 가지 유형의 엔진에서 다른 결과를 생성 할 수 있습니다.
• 동일한 기능이라도 다른 정규식 엔진은 다른 구문을 사용하여 지정할 수 있습니다.
• 동일한 기능과 구문을 사용하더라도 다른 정규식 엔진은 구문 분석 및 일치에 약간의 차이가있을 수 있습니다. 버그는 제쳐두고, 차이점은 정규식 엔진 디자인에서 비롯 될 수 있습니다 (문서화되거나 문서화되지 않을 수 있음).
• 에서 MULTILINE 모드의 동작 ^과 $"줄 끝"의 정의에 따라 달라집니다. 자바 고려하기 \r\n, \n, \r, \u0085, \u2028, \u2029라인 종결 될 \r\n시퀀스 원자 여겨진다. 자바 스크립트는 고려하기 \n, \r, \u2028, \u2029라인 종결 될 수 있습니다. 루비는 \n라인 종결 자만 고려합니다 .
• split함수는 코너 경우에 대해 다른 언어로 다른 의미를 가질 수 있습니다. 파이썬은 빈 일치 항목을 분할하지 않고 Java는 빈 문자열을 제거합니다 (음수 제한을 지정하지 않는 한), JavaScript는 인덱스 0에서 빈 문자열 일치를 분할하지 않습니다.
• "나쁜 솔루션"은 실제로 "권장 솔루션"보다 이식성이 뛰어납니다. 그러나 라인 터미네이터로 고려해야 할 것은 작업중인 대상의 사양 (예 : C 소스 코드)에 따라 다릅니다.
• 현재 대부분의 정규식 엔진은 레벨 1 유니 코드 지원을 준수하지도 않습니다 . 그것들은 유니 코드 속성과 블록을 가질 수 있지만 선 경계 섹션의 구현은 위에서 설명한 것처럼 모든 곳에서 가능합니다. JavaScript는 유니 코드 문자 속성도 지원하지 않습니다!

배쉬 스크립트

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

기음#

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

그런 다음 문자열을 다음과 같이 2로 나눌 때까지 임의의 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()

배쉬 특정

bash 에는 훌륭한 직업이 있습니다. !

예, 문자열을 분리하면 정말 간단한 방법으로 수행 할 수 있습니다.

string=$'foo\nbar\nbaz'

먼저 분할 된 결과를 저장하는 데 사용할 변수를 초기화해야합니다.

declare -a lines

이제 각 줄은 구분 기호, 문자열의 시작 또는 끝의 두 개로 구분 되므로 첫 번째 줄을 저장하는 변수가 필요합니다.

limitA=0

이제 구분자를 검색하고 루프를 사용하여 줄을 저장할 수 있습니다 . 으로 떠들썩한 파티가 바이너리 값으로 작동하지 않을 수 있습니다, 당신은 같은 도구를 사용할 수있는 od샘플에 대한 16 진수 값과 일에 :

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.

현대 배쉬

그러나 최신 bash 구현을 사용하면 개행 과 같은 제어 문자 를 변수에 저장하고 테스트 할 수도 있습니다.

#!/bin/bash

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

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

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

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

배쉬 골프

그러나 가독성에 관심이 없다면 다음과 같은 압축 된 스크립트를 작성할 수 있습니다.

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

골프 스크립트는 다음과 같이 나타날 수 있습니다.

#!/bin/bash

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

첫 번째 행 분할 문자열을 사용하여 lines 이라는 배열에 저장하십시오 . 그리고 두 번째 줄은 배열 '' lines '' 의 각 멤버와 그 뒤에 줄 바꿈을 인쇄 합니다.

bash + vt 콘솔

그러나 많은 사람들이 ANSI VT 표준 기반의 텍스트 콘솔을 사용함에 따라 콘솔의 VT 동작을 사용하고 이것을 더 짧게 작성할 수 있습니다.

#!/bin/bash

echo $'foo\nbar\nbaz'

같은 결과를 줄 것입니다.