私の宿題の割り当ては、文字列を取得し、新しい行ごとに分割します。どうすればいいのかわかりません！助けてください！

^{注：これはコードトローリングの質問です。質問や回答を真剣に受け取らないでください。詳細はこちら。}

C

私の宿題の割り当ては、文字列を取得し、新しい行ごとに分割します。どうすればいいのかわかりません！助けてください！

最初のCプログラミングクラスにとって難しい問題！最初に、この複雑な主題に関するいくつかの基本を理解する必要があります。

文字列は、文字のみで構成されるシーケンスです。これは、プログラマーが「見えない」もの（文字ではないスペースではない）を示すために、何らかの方法でその見えないものを意味する特別な文字列を使用する必要があることを意味します。

• に のWindows、新しい行は、一連のある2バックスラッシュとn（または文字列：文字列内の文字"\n"）

• 上のLinuxまたは OS / XのMac、それは一連のである4（または：バックスラッシュ、nは、バックスラッシュ、そしてR：文字"\n\r"）。

（興味深い歴史的なメモ：古いMacintoshでは、4文字の異なるシーケンスでした： "\ r \ n" ... Unixのやり方とは全く逆です！歴史は奇妙な道を歩みます。）

LinuxはWindowsよりも無駄が多いように思えるかもしれませんが、実際には、より長いシーケンスを使用することをお勧めします。Windowsはこのような短いシーケンスを使用するため、C言語ランタイムは\n特別なシステムコールを使用しないと実際の文字を印刷できません。あなたはできる通常のシステムコールせずにLinux上でそれを行う（それも印刷できます\n\か\n\q ...何もなく、\n\r）。しかし、Cはクロスプラットフォームであることを意図しているため、最小公分母を強制します。そのため、あなたは常に\nあなたの本で見ているでしょう。

（注：\n毎回改行を取得せずにどのように話しているのか疑問に思っている場合、StackOverflowはほぼ完全にHTMLで記述されています。Cではなく、より現代的です。Cのこれらの古い側面の多くはCLANGやLLVMなど、聞いたことがあるかもしれないことによって対処されます。）

しかし、私たちが取り組んでいることに戻りましょう。次のような、3つの部分と2つの改行を含む文字列を想像してみましょう。

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

次に、改行を表す2文字のパターンを探す必要があります。あなただけを探すことはできませんバックスラッシュ。Cは文字列の分割に非常に多く使用されるため、実行しようとするとエラーが発生します。あなたが書いてみると、これを見ることができます：

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

（注：バックスラッシュのみを検索するプログラムを作成する場合、コンパイラに設定があります。しかし、それは非常に一般的ではありません;バックスラッシュはほとんど使用されないため、この目的のために選択されました。スイッチオン。）

次のように、本当に欲しいパターンを作りましょう：

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

特定の長さの2つの文字列を比較したい場合は、 strncmp。潜在的に大きな文字列の特定の数の文字を比較し、それらが一致するかどうかを示します。したがって、strncmp("\nA", "\nB", 2)1（true）を返します。これは、文字列が3つの長さにわたって完全に等しいわけではありませんが...必要なのは2文字だけであるためです。

一度に1文字ずつバッファーをステップ実行して、パターンに一致する2文字を探してみましょう。バックスラッシュとそれに続くnの2文字のシーケンスを見つけるたびに、非常に特殊なシステムコール（または「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文字列表現には1文字しかありません\n。ただしstrlen()、実際に操作する長さを取得するために使用される限り、バッファを大きくしても無害です。

...

読者に、strncmp一致する（1）または一致しない（0）ブール演算であると確信させようとします。しかし、実際には3つの戻り値があります（-1より小さいマッチング、0は等しい、1は大きいマッチング）。比較される2つの文字「パターン」は[ \、n]ではなく、[ \n、\0] ...暗黙的なヌルターミネータを選択します。そのシーケンスは文字列をスライドするので、比較される2文字のシーケンスより大きくなることはありません...入力文字列に終了改行がある場合、最高でゼロになります。

...

したがって、これは文字列をループして一度に1文字ずつ出力するだけです。一番上のブランチは実行されません。 （文字列に\nコードよりも低いコードが含まれている場合、それを取得することができますが、タブから...これは、出力から文字を不思議に省略するために使用できます:-P）

1. はさみと分割したい文字列をつかみます。
2. はさみを開きます。
3. はさみの刃の間にひもを入れます。
4. はさみを閉じます。

おめでとうございます！これで文字列が分割されます。そうでない場合は、そうなるまで手順を繰り返します。この手順を数回繰り返した後、文字列が分割されなくなるまで、より鋭いハサミを使用してみてください。

免責事項：私はプロセス中にあなたに適用されたいかなる損害についても責任を負いません。

Python

宿題のような明らかなトリックの質問があなたに与えられたのはとても残念です。Pythonなどの高度な言語により、これは単純な2つのライナーになります。

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））しかありません。これは、検索スペースが2倍の場合、検索時間は2倍ではなく、定額！

バイナリ検索のコードは、再帰と分割統治の高度な技術を使用しているため、もう少し複雑です。です。しかし、パフォーマンス上のメリットを得るには価値があります。あなたがそれを提出した場合、私はあなたが余分なクレジットを取得することを期待しています。

アルゴリズムの要点は次のとおりです。

• 文字列を2つに切ります。
• 再帰呼び出しでは、文字列の前半を分割します。
• 再帰呼び出しでは、文字列の後半を分割します。
• 下期からの作品、との最初の半、一緒に作品を置くほら！

言語を指定しなかったので、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

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文字列では機能しません
• バッファオーバーランを完全に無視します
• 何をしているのかを知っているプログラマーの顕著な第一線が含まれています
• コメントなしでも本文は空です
• 初心者向けのインデックス作成

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
• 入力文字列の末尾に改行が必要です
• 文字列に'以下が含まれている場合は機能しません,

ルア

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マップする必要があり127.0.0.1ます。
残りは、初心者が理解できる基本的なJavaScriptです。

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を使用して、文字列内の個々の文字をコピーします。
• メモリリークはいたるところにありますが、ベクトルに関するコメントは、メモリリークを回避するためにこのクラスに依存することの重要性を指摘しています。また、ヒープメモリへのポインタによってこのベクトルを返します。
• ベクトルのように使用しながら、一時的なストレージにマップクラスを使用します。
• おそらく、私の頭が痛い。
• ああ、すべてが再帰的です。

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が、ラムダを誤用することができます。そのラムダは何かを返しているように見えますが、実際には返りません。三項演算子は、副作用のためだけにあります。

よし！したがって、＃defineステートメント（最近C ++から移植された）や組み込みクラスのメソッドの自動登録など、Pythonのあまり知られていない機能を使用することで、この問題は非常に簡単になります。

#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ステートメントはPythonには存在しません！
2. 特に、組み込みクラスのメソッドを自動的に登録しません。
3. outは「怠instantにインスタンス化されます」-これは実際には何の役にも立ちません。
4. 指定された関数は、結果に区切り文字を含めます。
5. 指定された関数には、結果の最終要素は含まれません。
6. ただし、このコンテキストで〜演算子が構成されているにもかかわらず、〜0は-1であり、これはその行が実際に機能することを意味します。
7. 返品はめちゃくちゃです。返される実際の場所は、値なしで返されます。
8. Bug＃20221は、名前に "#define"が含まれる実際のpythonバグです-ただし、これは何の関係もありません。
9. 入力行は1行のみにすることができます...そして、改行を含めることができないため、分割するだけではかなり価値がありません。
10. print（x）の代わりにsys.stdout.write（str（x））を使用することは、物事を行うのに悪い方法です。
11. 「Python仮想マシン」は、この場合の構成概念です。（「クラスメソッド」もインスタンスメソッドではなく静的メソッドになるため、その部分も間違っています）

実際には、プログラムは（少なくとも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";使用して、constprintfには入力を変更する手段がないことを示しています。法的目的のためにユーザー入力を常に元の形式で保持する必要があるため、これは重要です。

printf("%s", input); コンソール出力でわかるように、分割を行います。

getchar(); 出力を検査している間、コンソールを長持ちさせるためのちょっとした余分なトリックです。

入力： "First Line\nSecond Line\nThird Line\n"

出力を作成します。

First Line
Second Line
Third Line

Python

Pythonの文字列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コードの作業部分があります。ただし、分割する場所を指定しなかったため、ランダムな場所を選択します。私はそれがあなたといいことを願っています。

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：

Java

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

PHP

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

その解決策はゴミであり、決して使用すべきではありません。今日では、ユニコードを避けるのは無益です。むしろ、すべてのプログラマーがユニコードを受け入れ、アプリケーションがユニコード対応であることを確認する必要があります。のみを検討する\n場合\r\n改行セパレーター、改行セパレーター、90年代にソフトウェアを作成しています。このUnicode時代では、U + 0085、U + 2028、U + 2029を有効な行区切り記号と見なす必要があります。ユニコードは時々更新され、更新されたことに気付くまでに通常時間がかかるため、ユニコードに新しい行区切り文字が追加される場合があります。すべての正規表現エンジンはUnicode対応であり、最新のUnicode標準に準拠するように定期的に更新されるため、心配はいりません。したがって、インタープリター言語を使用している場合、コードは何もせずに最新のものになります。

推奨ソリューション

文字列を行末記号で分割し、Unicodeの進化に合わせて最新の状態に保つには、正規表現^を指定してMULTILINEモードを指定します。

デフォルトで^は、文字列の先頭にのみ一致します。ではMULTILINEモード、^ また、すなわち行終端後、行の先頭にマッチします。

例えば：

Java

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

PHP

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

前に余分な空の文字列エントリがあることに注意してください。インデックス1から削除するかループするだけです。

説明

一見したところ、これは（ある程度）実用的なソリューションの良い答えのように見えますが、コーディングのベストプラクティスの推奨事項を伴う説明と相まってです。ただし、ソリューション自体はトロール（「知っている、正規表現を使用します。」現在2つの問題があります）であり、投稿全体に微妙に間違った情報が散りばめられています。

• 異なる正規表現エンジンは、異なる機能セットをサポートします。ターゲットエンジンに正規表現で使用する機能がない場合、コードの移植はコピーアンドペーストほど簡単ではありません。サポートされている機能を使用してシミュレートすることも、正規表現のみを使用してシミュレートすることも不可能な場合があります。
• エンジンには、テキスト指向エンジン（オートマトンベース）と正規表現指向エンジン（バックトラッキング）の2種類があります。前者は左端の最も長い文字列を返し、後者は左端のバイアスされた文字列（正規表現で指定された探索の順序に偏っている）を返します。同じ正規表現は、2種類のエンジンで異なる結果を生成する場合があります。
• 同じ機能であっても、異なる正規表現エンジンでは、指定する構文が異なる場合があります。
• 同じ機能と同じ構文であっても、異なる正規表現エンジンでは、解析と照合の動作が多少異なる場合があります。バグは別として、違いは正規表現エンジンの設計に起因する可能性があります（文書化される場合とされない場合があります）。
• でMULTILINEモードの動作^とは、$「ラインターミネータ」の定義に依存しています。Javaは考慮\r\n、\n、\r、\u0085、\u2028、\u2029回線終端装置であると\r\n配列がアトミックであると考えられます。JavaScriptが考えて\n、\r、\u2028、\u2029行終端します。Rubyは\n、行末記号のみと見なします。
• split関数は、コーナーケースの異なる言語で異なるセマンティクスを持つ場合があります。Pythonは空の一致で分割せず、Javaは末尾の空の文字列を削除し（負の制限を指定しない限り）、JavaScriptはインデックス0の空の文字列の一致で分割しません。
• 「悪い解決策」は実際には「推奨される解決策」よりも移植性があります。ただし、ラインターミネータと見なされるものは、作業しているものの仕様（Cソースコードなど）によって異なります。
• 現在、ほとんどの正規表現エンジンはレベル1のUnicodeサポートにも適合していません。それらはユニコードのプロパティとブロックを持っているかもしれませんが、上で説明したように、行境界セクションの実装はいたるところにあります。JavaScriptはUnicode文字プロパティさえもサポートしていません！

Bashスクリプト

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

Java

これはファイルからは読み取りません。正規表現が使用されます。コードは、読み取られた文字列に改行を示す「\ 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!"

次に、次のように文字列を2つに分割するまで、ランダムアスキーをループします。

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

各行は文字列の開始または終了の2つの区切り文字で区切られているため、最初の行を格納する変数が必要になります

limitA=0

OK、セパレータを検索し、ループを使用して行を保存できます。bashがバイナリ値では動作しませんでした、あなたは次のようなツールを使用することができ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

これらすべてを1つのスクリプトに入れます。

#!/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という名前の配列に格納します。そして、2行目は配列 '' lines ''の各メンバーを印刷し、その後に改行が続きます。

bash + vtコンソール

しかし、多くの人がANSI VT標準に基づくテキストコンソールを使用しているため、コンソールのVTの動作を使用して、これをさらに短く書くことができます。

#!/bin/bash

echo $'foo\nbar\nbaz'

同じ結果が得られます。