Pekerjaan rumah saya adalah mengambil string dan membaginya menjadi beberapa bagian di setiap baris baru. Saya tidak tahu harus berbuat apa! Tolong bantu!

^{Catatan: Ini adalah pertanyaan troll kode . Tolong jangan menganggap pertanyaan dan / atau jawaban dengan serius. Informasi lebih lanjut di sini .}

C

Pekerjaan rumah saya adalah mengambil string dan membaginya menjadi beberapa bagian di setiap baris baru. Saya tidak tahu harus berbuat apa! Tolong bantu!

Masalah rumit untuk kelas pemrograman C awal! Pertama, Anda harus memahami beberapa dasar tentang subjek yang rumit ini.

String adalah urutan yang hanya terdiri dari karakter . Ini berarti bahwa agar programmer dapat menunjukkan hal "tidak terlihat" (itu bukan spasi, yang dianggap sebagai karakter), Anda harus menggunakan urutan karakter khusus untuk memaksudkan hal yang tidak terlihat itu.

• Pada Windows , baris baru adalah urutan dua karakter dalam string: backslash dan n (atau string "\n")

• Di Linux atau OS / X Mac , ini adalah urutan empat karakter: backslash, n, backslash, dan kemudian r: (atau "\n\r").

(Catatan sejarah yang menarik: pada Macintosh lama itu adalah urutan yang berbeda dari empat karakter: "\ r \ n" ... benar-benar mundur dari cara Unix melakukan sesuatu! Sejarah mengambil jalan yang aneh.)

Tampaknya Linux lebih boros daripada Windows, tetapi sebenarnya itu ide yang lebih baik untuk menggunakan urutan yang lebih lama. Karena Windows menggunakan urutan singkat seperti itu, runtime bahasa C tidak dapat mencetak huruf yang sebenarnya \ntanpa menggunakan panggilan sistem khusus. Anda biasanya dapat melakukannya di Linux tanpa panggilan sistem (bahkan dapat mencetak \n\atau \n\q... apa pun kecuali \n\r). Tetapi karena C dimaksudkan sebagai platform silang, ia memberlakukan common-denominator terendah. Jadi, Anda akan selalu melihat \ndi buku Anda.

(Catatan: Jika Anda bertanya-tanya bagaimana kita berbicara \ntanpa mendapatkan baris baru setiap kali kita lakukan, StackOverflow ditulis hampir seluruhnya dalam HTML ... bukan C. Jadi jauh lebih modern. Banyak aspek lama dari C adalah sedang ditangani oleh hal-hal yang mungkin pernah Anda dengar, seperti CLANG dan LLVM.)

Tetapi kembali ke apa yang sedang kita kerjakan. Mari kita bayangkan sebuah string dengan tiga potong dan dua baris baru, seperti:

"foo\nbaz\nbar"

Anda dapat melihat panjang string itu adalah 3 + 2 + 3 + 2 + 3 = 13. Jadi Anda harus membuat buffer dengan panjang 13 untuk itu, dan programmer C selalu menambahkan satu ke ukuran array mereka agar aman. Jadi buat buffer Anda dan salin string ke dalamnya:

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

Sekarang yang harus Anda lakukan adalah mencari pola dua karakter yang mewakili baris baru. Anda tidak diizinkan mencari hanya garis miring terbalik. Karena C digunakan untuk pemisahan string yang cukup banyak, itu akan memberi Anda kesalahan jika Anda mencoba. Anda dapat melihat ini jika Anda mencoba menulis:

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

(Catatan: Ada pengaturan di kompiler untuk jika Anda menulis program yang hanya mencari garis miring terbalik. Tapi itu sangat jarang; garis miring terbalik sangat jarang digunakan, itulah sebabnya mereka dipilih untuk tujuan ini. Kami tidak akan mengubahnya menyalakan.)

Jadi mari kita buat pola yang kita inginkan, seperti ini:

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

Saat kami ingin membandingkan dua string dengan panjang tertentu, kami menggunakan strncmp. Ini membandingkan sejumlah karakter dari string yang berpotensi lebih besar, dan memberi tahu Anda apakah mereka cocok atau tidak. Jadi strncmp("\nA", "\nB", 2)mengembalikan 1 (benar). Ini meskipun string tidak sepenuhnya sama dengan panjang tiga ... tetapi karena hanya dua karakter yang diperlukan.

Jadi mari kita melangkahi buffer kita, satu karakter pada satu waktu, mencari dua karakter yang cocok dengan pola kita. Setiap kali kita menemukan urutan dua karakter dari garis miring terbalik diikuti oleh n, kita akan menggunakan pemanggilan sistem yang sangat khusus (atau "syscall") putcuntuk mengeluarkan jenis karakter khusus: kode ASCII 10 , untuk mendapatkan baris fisik baru .

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

Output dari program ini adalah hasil yang diinginkan ... string split!

foo
baz
bar

\t untuk \ trolling ...

Benar-benar salah dari atas ke bawah. Namun diisi dengan omong kosong yang terdengar masuk akal yang telah mengacak informasi seperti apa yang ada di buku teks atau Wikipedia. Logika program tampak transparan dalam konteks informasi yang keliru, tetapi sepenuhnya menyesatkan. Bahkan variabel global dan mengembalikan kode kesalahan, untuk ukuran yang baik ...

...

Tentu saja, hanya ada satu karakter dalam representasi string C dari urutan literal sumber dua karakter \n. Tetapi membuat buffer lebih besar tidak berbahaya, asalkan strlen()digunakan untuk mendapatkan panjang aktual untuk beroperasi.

...

Kami mencoba meyakinkan pembaca bahwa strncmpini adalah operasi boolean yang cocok dengan (1) atau tidak (0). Tetapi sebenarnya memiliki tiga nilai kembali (-1 cocok kurang, 0 untuk sama, 1 untuk cocok lebih besar) . "Pola" dua karakter kami yang dibandingkan bukan [ \, n], melainkan [ \n, \0] ... mengambil terminator nol implisit. Ketika urutan tersebut meluncur melalui string, maka tidak akan pernah lebih besar dari urutan dua karakter yang dibandingkan dengan ... paling-paling itu akan menjadi nol jika ada baris baru yang berhenti di string input.

...

Jadi yang dilakukan adalah loop melalui string dan mencetaknya satu karakter pada satu waktu. Cabang teratas tidak pernah berjalan. (Meskipun Anda bisa mendapatkannya jika string Anda memiliki \nkode lebih rendah dari itu, katakan tab ... yang dapat digunakan untuk menghilangkan karakter secara misterius dari output :-P)

1. Ambil gunting dan tali yang ingin Anda pisahkan.
2. Buka guntingnya.
3. Letakkan tali Anda di antara pisau gunting.
4. Tutup guntingnya.

Selamat! String Anda sekarang harus dipisah. Jika tidak, ulangi langkahnya sampai tiba. Jika Anda telah mengulangi langkah-langkah itu beberapa kali dan talinya tidak terpecah, coba gunakan gunting yang lebih tajam.

DISCLAIMER: Saya tidak bertanggung jawab atas kerusakan yang terjadi pada Anda selama proses berlangsung.

Python

Saya merasa sangat buruk karena Anda diberi pertanyaan jebakan yang jelas seperti pekerjaan rumah. Bahasa yang sangat maju seperti Python menjadikan ini dua kalimat sederhana:

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

Harap pilih dan terima.

C

Dalam C sangat mudah:

#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

Sebut saja seperti ini:

split("a\nb");

Contoh kerja:

http://codepad.org/GBHdz2MR
Mengapa ini jahat:

• Ini bergantung pada printffungsi untuk membagi string
• Benar-benar tidak bisa dipahami
• Ini akan membingungkan siapa saja yang tidak mengerti #define(dan bahkan mereka yang mengerti )

Ini dapat dilakukan dalam beberapa baris kode dengan algoritma sederhana berikut:

1. Cari karakter baris baru pertama dalam string.
2. Tambahkan bagian hingga baris baru ke daftar.
3. Hapus bagian hingga baris baru dari string.
4. Jika string tidak kosong, lanjutkan ke langkah 1.

Namun, ini sia-sia. Ini pada dasarnya adalah algoritma pencarian linier , yang memiliki kompleksitas waktu linear (O (n)). Saya akan memberitahu Anda tentang teknik yang lebih maju: pencarian biner . Pencarian biner jauh lebih efisien daripada pencarian linier: ia hanya memiliki kompleksitas waktu logaritmik (O (log (n)). Ini berarti bahwa jika ruang pencarian dua kali lebih besar, waktu pencarian tidak dua kali lipat, itu hanya meningkat sebesar jumlah yang tetap!

Kode untuk pencarian biner sedikit lebih rumit, karena menggunakan teknik rekursi dan divide-and-conquer yang canggih . Tapi itu pasti sepadan untuk manfaat kinerja. Jika Anda mengirimkannya, saya berharap Anda akan mendapatkan kredit tambahan.

Inti dari algoritma ini adalah:

• Potong talinya menjadi dua.
• Dengan panggilan berulang, pisahkan bagian pertama dari string.
• Dengan panggilan rekursif, pisahkan bagian kedua dari string.
• Letakkan potongan-potongan dari babak pertama bersama-sama dengan potongan-potongan dari babak kedua, dan voila !

Anda tidak menentukan bahasa, jadi saya menulisnya dengan Python. Di dunia nyata, tentu saja, orang tidak menulis dengan Python - gunakan C atau C ++ (atau bahkan lebih baik, bahasa assembly) untuk kinerja nyata. Jangan khawatir jika Anda tidak mengerti apa yang dilakukan semua kode - ini pasti hal-hal canggih.

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

Tentu saja semua pernyataan tentang kinerja adalah palsu. Algoritma "sederhana" mungkin linear atau kuadratik tergantung pada bagaimana Anda menafsirkannya. Algoritma "lanjutan" adalah Θ (n × log (n)) (cukup dekat dengan linear dalam praktiknya), tetapi anak laki-laki, adalah konstanta multiplikatif yang tinggi karena pembangunan kembali daftar yang tak henti-hentinya (yang pelaksanaannya agak jauh dari cara untuk mendorong ).

Gaya Python, gaya komentar, pernyataan tentang pilihan bahasa dan hampir semua hal lain dalam posting ini tidak mencerminkan pendapat atau kebiasaan saya yang sebenarnya.

Dasar visual

The IOmonad memiliki fungsi untuk melakukan itu!

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

• Penggunaan lama usang std::strstream
• Keluar dari caranya untuk memperkenalkan kebocoran memori
• Blindly mengasumsikan 2045 byte akan cukup untuk menampung strstream
• Nama yang mengerikan
• Penggunaan std::awalan yang tidak konsisten
• Tidak berfungsi untuk string const
• Sepenuhnya mengabaikan buffer overruns
• Termasuk ciri khas baris pertama programmer yang tahu apa yang mereka lakukan
• Tubuh kosong sementara tanpa komentar
• Pengindeksan pemula-tersandung

Python 3 (Rapi dan Bersih)

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

Rubi

Nah Anda lihat dulu Anda harus membuatnya menjadi array seperti ini

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

Sekarang Anda harus meletakkan elemen sebagai string

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

Oh juga hapus koma terakhir itu

actually_real_arr = real_arr.chop

Ups lupa, Anda harus meletakkan tanda kurung menjadi array

definitely_the_real_arr = "[#{actually_real_arr}]"

Sekarang cukup gunakan string dan Anda selesai

final_arr = eval(definitely_the_real_arr)

Kejahatan:

• yang jelas, tidak menggunakan split
• banyak variabel tidak berguna dengan nama tidak berguna
• eval
• membutuhkan trailing baris baru dalam string input
• tidak berfungsi jika string berisi 'atau,

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

Contoh input: "Hello\nworld\nstuff"
Output:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Oh dan saya lupa menyebutkan bahwa kodenya O (n ^ 2)

Node.JS

Ini sangat sederhana, setiap programmer bisa melakukan ini.
Pertama, kita harus mengubah hostsfile sehingga .com, .net, .orgpeta menjadi 127.0.0.1.
dan sisanya adalah Javascript dasar yang dapat dipahami oleh noob mana pun.

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

Itu dia :)

Rubi

String dalam pemrograman terbuat dari Einsteintanium. Karena itu mereka sangat sulit untuk dibagi.
Beruntung bagi Anda, saya memiliki gelar PhD dalam bidang kimia dan pemrograman, jadi saya dapat membantu.
Kami akan menggunakan ruby ​​untuk ini.

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

Ini jahat karena:

• Orang miskin akan takut akan keracunan radiasi
• Satu-satunya bagian "dia bisa abaikan" adalah bagian penting
• Rentang malas yang tak terbatas. Maksudku, ayolah!

C ++

Berkat fitur baru yang kuat dari bahasa pemrograman C ++ ini dapat diselesaikan dengan mudah menggunakan perpustakaan standar, ingat jangan menciptakan kembali roda .

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

Sunting: Jawaban ini jelas hanya mencoba untuk membuat sesuatu yang sangat rumit untuk tugas sepele, dan sambil melakukan itu menyalahgunakan alat sebanyak yang saya bisa sementara masih bisa menulis kode.

Berikut beberapa hal yang perlu diperhatikan:

• Komentar berbicara tentang menggunakan kembali kode dan menggunakan pustaka standar, std :: string tidak digunakan.
• Untuk setiap instance di mana panjang string perlu dihitung, lambda baru didefinisikan.
• Menggunakan template tanpa alasan yang bagus.
• Menggunakan memcpy untuk menyalin setiap huruf indidvidual dalam string.
• Kebocoran memori ada di mana-mana, namun komentar tentang vektor menunjukkan pentingnya mengandalkan kelas ini untuk menghindari kebocoran memori. Ini juga mengembalikan vektor ini dengan pointer ke memori tumpukan.
• Menggunakan kelas peta untuk penyimpanan sementara, saat menggunakannya seperti vektor.
• Mungkin lebih, kepala saya sakit.
• Oh, dan semuanya rekursif juga.

C #

Ini menggunakan teknologi rekursi untuk mengubah baris baru menjadi koma. String CSV yang dihasilkan dapat dengan mudah dipisah menjadi sebuah array.

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

Terlihat sepenuhnya dapat dipercaya dan buku teks hingga ungkapan terakhir. Itu bahkan benar, coba jelaskan ini kepada guru Anda.

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

Tentu saja tidak ada pembenaran untuk itu std::for_each, tetapi memungkinkan kita untuk salah menggunakan lambda. Lambda itu sepertinya mengembalikan sesuatu, tetapi kenyataannya tidak. Operator ternary ada hanya untuk efek samping.

Baik! Jadi masalah ini menjadi sangat mudah dengan menggunakan beberapa fitur python yang kurang dikenal, termasuk pernyataan #define (mereka baru-baru ini memindahkannya dari C ++) dan pendaftaran otomatis metode pada kelas 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!

Seberapa baik itu?

Penjelasan

... ada daftar trolling yang cukup besar di sini.

1. Pernyataan #define tidak ada dalam python!
2. Mereka terutama tidak mendaftarkan metode pada kelas builtin secara otomatis.
3. keluar adalah "malas instantiated" - yang benar-benar berarti tidak ada gunanya sama sekali.
4. Fungsi yang disediakan akan mencakup pemisah dalam hasilnya.
5. Fungsi yang disediakan tidak akan mencakup elemen akhir dari hasil.
6. Namun, meskipun ~ operator dibuat dalam konteks ini, ~ 0 adalah -1 yang berarti garis itu benar-benar akan berfungsi.
7. Pengembaliannya kacau. Tempat yang sebenarnya akan kembali hanya mengembalikan tanpa nilai.
8. Bug # 20221 adalah bug python asli dengan "#define" dalam namanya - tetapi tidak ada hubungannya dengan ini.
9. Baris input hanya dapat berupa satu baris ... dan hanya pemisahan yang tidak berharga karena tidak dapat memasukkan baris baru.
10. Penggunaan sys.stdout.write (str (x)) alih-alih cetak (x) adalah cara yang buruk untuk melakukan sesuatu.
11. "Mesin virtual Python" adalah konsep yang dibuat-buat dalam kasus ini. (Juga "metode kelas" akan menjadi metode statis, bukan metode contoh, sehingga bagian itu salah juga)

Sebenarnya, program ini berfungsi (setidaknya dalam Python 3.3.0, dan selain masalah input baris tunggal) karena banyak hal yang membuatnya tidak melakukan apa yang dikatakan digabung untuk membuatnya benar-benar berfungsi.

LOLCODE obyektif

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

ANSI C

Ini adalah tugas standar yang telah kita semua lakukan. Ini adalah solisi yang diterima secara umum.

#include <stdio.h>

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

Anda harus menyertakan perpustakaan dengan fungsi yang benar untuk dipecah dan dicetak. #include <stdio.h>

Buat string yang ingin Anda bagi: const char * input = "First Line\nSecond Line\nThird Line\n";Perhatikan bagaimana saya menggunakan constkata kunci untuk menggambarkan bahwa printf tidak memiliki sarana untuk mengubah input Anda. Ini penting karena Anda selalu ingin mempertahankan input pengguna dalam bentuk aslinya untuk tujuan hukum.

printf("%s", input); melakukan pemisahan untuk Anda seperti yang Anda lihat di output konsol.

getchar(); hanyalah trik ekstra kecil untuk menjaga konsol tetap bertahan saat Anda memeriksa output.

Input: "First Line\nSecond Line\nThird Line\n"

Menciptakan output:

First Line
Second Line
Third Line

Python

Kita dapat menggunakan find()metode string Python secara iteratif untuk membagi string pada setiap instance baris baru (perhatikan bahwa string input dikodekan sebagai input_str, tetapi dapat diganti dengan 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

Menjalankan skrip di atas, kami mendapatkan output yang diharapkan (perhatikan bahwa spasi putih depan dan belakang konsisten dengan pemisahan string pada setiap kemunculan baris baru):

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

PHP / GD

Memisahkan string adalah masalah yang sangat rumit. Meskipun kami melanjutkan dan membuat implementasi yang cukup mendasar untuk masalah pekerjaan rumah yang sangat penting ini.

Berjalan tanpa ketergantungan pada versi PHP terbaru: Jumlah contoh terbatas dalam kode yang diposkan karena kami memiliki batas karakter sekitar 40.000 karakter di sini yang tidak sesuai dengan jumlah string demonstrasi yang layak.

Versi contoh:

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

Tepat mengkonfirmasi untuk spesifikasi Anda.

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

Saya tidak ingin menjadi kejam, jadi inilah bagian kerja kode Python yang membagi string Anda menjadi beberapa bagian. Namun, karena Anda tidak menentukan di mana Anda ingin dibagi, saya hanya akan memilih lokasi acak. Saya harap tidak apa-apa dengan Anda.

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

Untuk bahasa yang mendukung ekspresi reguler dan split fungsi yang tersedia, Anda harus selalu menggunakannya untuk membagi string. Ini membantu Anda menghindari menciptakan kembali roda dan menjaga kode Anda pendek dan manis. Menggunakan ekspresi reguler juga memungkinkan Anda untuk porting kode Anda ke bahasa lain tanpa mengubah ekspresi reguler Anda.

Solusi buruk

Ada solusi yang jelas di mana Anda membaginya dengan \natau\r\n :

Jawa

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

PHP

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

Solusi itu adalah sampah dan tidak boleh digunakan. Di zaman sekarang ini, sia-sia untuk menghindari Unicode, alih-alih setiap programmer harus menerimanya dan memastikan aplikasi Anda siap dengan Unicode. Jika Anda hanya mempertimbangkan \natau \r\nsebagai pemisah baris baru, Anda sedang menulis perangkat lunak di tahun 90-an. Di zaman Unicode ini, Anda harus mempertimbangkan U + 0085, U + 2028, U + 2029 sebagai pemisah garis yang valid. Karena Unicode diperbarui setiap sekarang dan kemudian, dan biasanya perlu waktu sebelum Anda menyadarinya telah diperbarui, mungkin ada pemisah baris baru yang ditambahkan ke Unicode. Jangan khawatir, karena semua mesin ekspresi reguler siap dengan Unicode, dan diperbarui secara berkala untuk menyesuaikan dengan standar Unicode terbaru. Jadi jika Anda menggunakan bahasa yang ditafsirkan, kode Anda akan diperbarui tanpa Anda melakukan apa pun.

Solusi yang disarankan

Untuk membagi string dengan terminator garis, dan tetap up-to-date dengan evolusi Unicode, berikan regex ^dan tentukan MULTILINEmode.

Secara default, ^hanya cocok dengan awal string. Dalam MULTILINEmode, ^ juga cocok dengan awal baris, yaitu setelah terminator garis.

Sebagai contoh:

Jawa

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

PHP

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

Perhatikan bahwa ada entri string kosong tambahan di depan, cukup hapus atau loop dari indeks 1.

Penjelasan

Pada pandangan pertama, ini tampak seperti jawaban yang baik dengan solusi (agak) bekerja, ditambah dengan penjelasan dengan beberapa rekomendasi pengkodean praktik terbaik. Namun, solusinya sendiri adalah troll ( "Saya tahu, saya akan menggunakan ekspresi reguler." Sekarang mereka memiliki dua masalah. ), Dan seluruh posting ditaburi dengan informasi yang salah secara halus, yang akan meracuni setiap pemula untuk pemrograman.

• Mesin regex yang berbeda mendukung serangkaian fitur yang berbeda. Jika mesin target tidak memiliki fitur yang Anda gunakan di regex Anda, porting kode tidak semudah menyalin dan menempel. Mungkin dimungkinkan untuk mensimulasikan dengan fitur yang didukung, atau mungkin mustahil untuk melakukannya dengan regex sendirian.
• Ada 2 jenis mesin : mesin teks-diarahkan (berbasis otomat) dan mesin diarahkan-regex (backtracking). Mantan mengembalikan string terpanjang paling kiri, yang terakhir mengembalikan string bias paling kiri (bias terhadap urutan eksplorasi, ditentukan oleh regex). Regex yang sama dapat menghasilkan hasil yang berbeda pada 2 jenis mesin.
• Bahkan untuk fitur yang sama, mesin regex yang berbeda mungkin memiliki sintaks yang berbeda untuk menentukannya.
• Bahkan untuk fitur dan sintaksis yang sama, mesin regex yang berbeda mungkin memiliki beberapa perilaku yang berbeda dalam penguraian dan pencocokan. Selain bug, perbedaan mungkin berasal dari desain mesin regex (mungkin atau tidak didokumentasikan).
• Dalam MULTILINEmode, perilaku ^dan $tergantung pada definisi "terminator garis". Java menganggap \r\n, \n, \r, \u0085, \u2028, \u2029menjadi garis terminator, di mana \r\nurutan dianggap atom. JavaScript menganggap \n, \r, \u2028, \u2029untuk menjadi line terminator. Ruby hanya menganggap \nsebagai terminator garis.
• splitfungsi mungkin memiliki semantik berbeda dalam bahasa yang berbeda untuk kasus sudut. Python tidak terpecah pada kecocokan kosong, Java menghapus jejak kosong (kecuali Anda menentukan batas negatif), JavaScript tidak terpecah pada kecocokan string kosong pada indeks 0.
• "Solusi buruk" sebenarnya lebih portabel daripada "solusi yang disarankan". Namun, apa yang harus dianggap sebagai terminator garis tergantung pada spesifikasi apa pun yang sedang Anda kerjakan (misalnya kode sumber C).
• Saat ini, sebagian besar mesin regex bahkan tidak sesuai dengan dukungan Unicode Level 1 . Mereka mungkin memiliki properti dan blok Unicode, tetapi implementasi untuk bagian Batas Garis ada di semua tempat, seperti dijelaskan di atas. JavaScript bahkan tidak mendukung properti karakter Unicode!

Skrip bash

new_string=`echo $string`

Ini membagi string dengan baris baru. Jika Anda menggema $new_string, Anda akan melihat bahwa itu mengganti baris baru ke pemisah array.

Output sampel:

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

Jawa

Ini tidak membaca dari file. Ekspresi reguler digunakan. Kode mengasumsikan bahwa string yang dibaca memiliki karakter '\ n' untuk menunjukkan baris baru. Angka 1,2,3,4 digunakan untuk menunjukkan perpecahan.

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

Anda tidak menentukan apakah "baris baru" yang Anda inginkan untuk membagi string Anda peka terhadap huruf besar atau kecil. Saya menganggap tidak sensitif.

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

  }
}

Kawan, ini sangat mudah dilakukan di Powershell.

Dapatkan string Anda seperti ini:

$string = "Helloworld!"

Kemudian lilitkan ascii acak hingga string Anda terbelah menjadi dua seperti ini:

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

akhirnya Anda harus mendapatkan string split, yang dapat Anda hasilkan seperti ini:

Write-Host $new_string

Keluaran:

Halo Dunia!

Php

<? Spliter($yourstring); ?>

Inilah cara Anda membagi string. Bukankah itu mudah?

Yang harus Anda lakukan sekarang adalah menulis fungsinya Spliter()

spesifik bash

Ada pekerjaan bagus untuk bash !

Ya, memisahkan string dapat dilakukan dengan cara yang sangat sederhana:

string=$'foo\nbar\nbaz'

Pertama, Anda harus menginisialisasi variabel yang akan Anda gunakan untuk menyimpan hasil pemisahan Anda:

declare -a lines

Sekarang karena setiap baris dibatasi oleh dua pemisah, mulai atau akhir string, Anda akan memerlukan variabel untuk menyimpan yang pertama

limitA=0

Oke, sekarang Anda bisa mencari pemisah dan menyimpan garis Anda menggunakan loop . Karena bash tidak bisa berfungsi dengan nilai biner, Anda bisa menggunakan alat sepertiod untuk bekerja dengan nilai heksadesimal, untuk sampel:

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

Sekarang, kita memiliki string terpisah yang disimpan ke dalam variabel lines:

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

Kita bisa mencetak menggunakan:

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

Masukkan semua ini dalam satu skrip:

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

Ini akan mencetak:

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

Pesta modern

Tetapi menggunakan implementasi bash modern , Anda bisa menyimpan chars kontrol seperti baris baru ke dalam variabel, dan bahkan mengujinya:

#!/bin/bash

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

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

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

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

bash golf

Tetapi jika Anda tidak peduli tentang keterbacaan, Anda bisa menulis skrip kental seperti:

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

Skrip golf dapat muncul sebagai:

#!/bin/bash

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

dan akan memberikan efek yang sama: Baris pertama membagi string dan menyimpannya dalam larik bernama baris . Dan baris kedua akan mencetak setiap anggota array '' baris '', diikuti oleh a baris baru .

konsol bash + vt

Tetapi karena banyak orang menggunakan konsol teks berdasarkan standar ANSI VT , Anda dapat menggunakan perilaku VT konsol Anda dan menulis ini lebih pendek lagi:

#!/bin/bash

echo $'foo\nbar\nbaz'

akan memberikan hasil yang sama.