Ödevim, bir dizge almak ve her yeni satırda parçalara bölmek. Ne yapacağımı bilemiyorum! Lütfen yardım et!

^{Not: Bu bir kod değiştirme sorusudur. Lütfen soruyu ve / veya cevapları ciddiye almayın. Daha fazla bilgi burada .}

C

Ödevim, bir dizge almak ve her yeni satırda parçalara bölmek. Ne yapacağımı bilemiyorum! Lütfen yardım et!

Yeni başlayan C programlama dersi için zor problem! Öncelikle bu karmaşık konu hakkında birkaç temel bilgiyi anlamanız gerekir.

Bir dize, yalnızca karakterlerden oluşan bir dizidir . Bu, programcıların "görünmez" bir şey göstermesi için (karakter olarak sayılan bir boşluk değil), bir şekilde o görünmez şeyi ifade etmek için özel bir karakter dizisi kullanmanız gerektiği anlamına gelir.

• On Windows'un , yeni satır bir dizisi olan iki ters eğik çizgi ve n (veya dize: dizesindeki karakter "\n")

• Açık Linux veya OS / X Mac , bu dizisidir dört eğik çizgi, n, ters bölme ve daha sonra r: (ya da karakter "\n\r").

(İlginç tarihi not: eski Macintosh'larda dört karakterden oluşan farklı bir sekans vardı: "\ r \ n" ... Unix’in yaptıklarından tamamen geriye! Tarih çok garip yollar alır.)

Linux’un Windows’tan daha israf olduğu anlaşılabilir, ancak aslında daha uzun bir sıra kullanmak daha iyi bir fikirdir. Windows böyle kısa bir sıra kullandığından, C dili çalışma zamanı \nözel sistem çağrıları kullanmadan gerçek harfleri yazdıramaz . Sen edebilir genellikle bir sistem çağrısı (hatta yazdırabilirsiniz olmadan Linux'ta bunu \n\ya \n\q... bir şey ama \n\r). Ancak C, çapraz platform olması gerektiği için, en düşük ortak payda'yı zorlar. Demek her zaman \nkitabında göreceksin .

(Not: \nHer yaptığımızda yeni satırlar olmadan nasıl konuştuğumuzu merak ediyorsanız , StackOverflow neredeyse tamamen HTML olarak yazılmıştır ... C değil. Bu yüzden çok daha modern. C'nin bu eski yönlerinin çoğu CLANG ve LLVM gibi duymuş olabileceğiniz şeyler tarafından ele alınmak.)

Ama üzerinde çalıştığımız şeye geri dönelim. Gibi üç adet ve iki yeni satırlı bir dize düşünelim:

"foo\nbaz\nbar"

Bu dizginin uzunluğunun 3 + 2 + 3 + 2 + 3 = 13 olduğunu görebilirsiniz. Dolayısıyla bunun için 13 uzunluğunda bir tampon yapmanız gerekir ve C programcıları her zaman güvenli olmaları için dizilerinin boyutuna bir tane eklerler. Bu yüzden tamponunu hazırla ve dizgiyi içine kopyala:

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

Şimdi yapmanız gereken, yeni satırı temsil eden o iki karakterli kalıbı aramak. Sadece bir ters eğik çizgi aramanıza izin verilmiyor . C dize bölme işlemi için oldukça fazla kullanıldığından denerseniz, size bir hata verecektir. Yazmayı denerseniz bunu görebilirsiniz:

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

(Not: Sadece ters eğik çizgi arayan bir program yazıyorsanız, derleyicide bir ayar vardır. Ancak bu oldukça nadirdir; ters eğik çizgiler çok nadir kullanılır, bu yüzden bu amaç için seçilmişlerdir. açmak.)

Öyleyse gerçekten istediğimiz kalıbı yapalım, şöyle:

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

Belli bir uzunlukta olan iki dizgiyi karşılaştırmak istediğimizde kullanırız strncmp. Potansiyel olarak daha büyük bir dizginin belirli sayıda karakterini karşılaştırır ve size uyuşup uyuşmadığını size söyler. Böylece strncmp("\nA", "\nB", 2)1 (doğru) döndürür. Bu, dizelerin üçün uzunluğu boyunca tamamen eşit olmasalar da ... sadece iki karakterin olması gerektiği için.

Öyleyse her seferinde bir karakter olan arabelleğimizin üzerinden geçelim , modelimizle iki karakter eşleşmesini arayalım. İki karakterli bir ters eğik çizgi sırasını bulup, n'yi takip edersek, özel bir karakter ortaya koymak için çok özel bir sistem çağrısı (veya "sistem çağrısı") putckullanırız: fiziksel bir satırsonu elde etmek için ASCII kodu 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;
}

Bu programın çıktısı istenen sonucudur ... string split!

foo
baz
bar

\t trolling içindir ...

Kesinlikle yukarıdan aşağıya doğru yanlıştır. Yine de, ders kitabındaki veya Vikipedi'deki gibi bilgileri karıştırmış olan makul-mantıklı saçmalıklarla dolu. Program mantığı yanlış bilgilendirme bağlamında şeffaf görünmektedir , ancak tamamen yanıltıcıdır. Küresel değişkenler ve hata kodu bile, iyi önlem almak için ...

...

Tabii ki, iki karakterli kaynak değişmez dizinin C string temsilinde yalnızca bir karakter var \n. Ancak, tamponun büyütülmesi, strlen()çalışacak gerçek uzunluğu elde etmek için kullanıldığı sürece zararsızdır .

...

Okuyucuyu strncmp(1) eşleşmeyen ya da (0) eşleşmeyen bir boolean işlemi olduğuna ikna etmeye çalışıyoruz . Ancak aslında üç dönüş değeri vardır (-1 eşleşme daha az, eşittir 0, büyük eşleme için 1) . İki karakterli “kalıp ”ımızın karşılaştırılması [ \, n] değil , daha çok [ \n, \0] ... örtük boş sonlandırıcıyı alıyor. Bu dizi, dizi içinde kayarken, hiçbir zaman iki karakterli diziden daha büyük olmayacaktır ... en iyi ihtimalle giriş dizesinde sonlandırıcı bir yeni satır varsa sıfır olacaktır.

...

Yani tüm bunlar dizge boyunca döngü ve her seferinde bir karakter yazdırmaktır. En üst dal asla koşmaz. (Dizenizde \nkodlardan daha düşük kodlar varsa bunu başarabilmenize rağmen , çıktısındaki karakterleri gizemli bir şekilde atlamak için kullanılabilecek bir sekme deyin :-P)

1. Bir makas ve ayırmak istediğiniz ipi alın.
2. Makası aç.
3. İpinizi makas bıçaklarının arasına yerleştirin.
4. Makas kapatın.

Tebrikler! İpin şimdi bölünmüş olmalı. Değilse, adımları kadar olana kadar tekrarlayın. Adımları birkaç kez tekrarladıysanız ve ip bölünmediği sürece, daha keskin bir makas kullanmayı deneyin.

YASAL UYARI: Bu işlem sırasında size verilen hasarlardan sorumlu değilim.

piton

Size ev ödevi olarak açık bir hile sorusu verildiği için kendimi çok kötü hissediyorum. Python gibi son derece gelişmiş bir dil, bunu basit bir iki liner yapar:

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

Lütfen oy verin ve kabul edin.

C

C'de gerçekten kolay:

#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

Buna şöyle diyoruz:

split("a\nb");

Çalışma örneği:

http://codepad.org/GBHdz2MR
Neden kötü:

• printfDizeleri bölme işlevine dayanır
• Tamamen anlaşılmaz
• Anlamayan #define(hatta yapanları bile) kimsenin kafasını karıştıracaktır.

Bu, aşağıdaki basit algoritma ile birkaç kod satırında yapılabilir:

1. Dizedeki ilk newline karakterini arayın.
2. Parçayı listeye yeni satırın üstüne ekleyin.
3. Dizgiden yeni çizgiye kadar olan kısmı çıkarın.
4. Dize boş değilse, 1. adıma gidin.

Ancak, bu israftır. Bu temelde doğrusal zaman karmaşıklığına (O (n)) sahip olan doğrusal bir arama algoritmasıdır . Daha ileri bir teknikte size izin vereceğim: ikili arama . İkili arama, doğrusal aramaya göre çok daha etkilidir: sadece logaritmik zaman karmaşıklığına sahiptir (O ​​(log (n))). Arama alanı iki kat daha büyükse, arama süresinin iki katına çıkmadığı anlamına gelir. sabit bir miktar!

İkili arama için kod biraz daha karmaşıktır, çünkü gelişmiş yineleme ve bölme ve fethetme tekniklerini kullanır . Ancak performans avantajı için kesinlikle buna değer. Bunu gönderirseniz, fazladan kredi alacağınızı umuyorum.

Algoritmanın özü şudur:

• İpi ikiye bölün.
• Özyinelemeli bir çağrı ile dizenin ilk yarısını bölün.
• Özyinelemeli bir çağrı ile dizenin ikinci yarısını bölün.
• İlk yarıdaki parçaları ikinci yarıdaki parçaları ile birlikte koyun ve voilà !

Dil belirtmediniz, ben de Python'da yazdım. Tabii ki gerçek dünyada, insanlar Python'da yazmazlar - gerçek performans için C veya C ++ (veya daha iyisi, assembly dili) kullanın. Tüm kodun ne yaptığını anlamadıysanız endişelenmeyin - bu kesinlikle gelişmiş bir şey.

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

Tabii ki performansla ilgili tüm ifadeler sahtedir. “Basit” algoritma, nasıl yorumladığınıza bağlı olarak doğrusal veya ikinci dereceli olabilir. “Gelişmiş” algoritma Θ (n × log (n)) (pratikte doğrusalya oldukça yakın), ancak çocuk sürekli yapılan yeniden yapılanma nedeniyle (uygulamanın geliştirmenin biraz dışına çıkması nedeniyle çarpma sabiti yüksektir). ).

Python stili, yorum stili, dil seçimleriyle ilgili ifadeler ve bu yazıdaki hemen hemen her şey hakkındaki düşüncelerim benim gerçek düşüncemi veya alışkanlıklarımı yansıtmaz.

Visual Basic

IOMonad Bunu yapmanın bir işlevi vardır!

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

• Uzun süre kullanımdan kaldırılmış kullanır std::strstream
• Bir bellek sızıntısı oluşturmak için kendi yolundan gider
• Kör 2019 baytın bir bekletmeye yeterli olacağını varsayar. strstream
• Korkunç isimler
• std::Önekin tutarsız kullanımı
• Const dizeleri için çalışmıyor
• Tampon taşmalarını tamamen yok sayar
• Ne yaptıklarını bilen programcıların ilk satırını içerir
• Vücut varken yorum yapmadan boşalın
• Acemi Açma-İndeksleme

Python 3 (Düzgün ve Temiz)

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

Yakut

İlk önce bunu böyle bir dizi haline getirmelisin

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

Şimdi elemanları dizge olarak koymalısınız

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

Oh, ayrıca son virgülünü de kaldırın.

actually_real_arr = real_arr.chop

Hata! Unutmayın, bir dizi olmak için parantez koymak zorundasınız.

definitely_the_real_arr = "[#{actually_real_arr}]"

Şimdi sadece dizeyi kullanın ve bitirdiniz

final_arr = eval(definitely_the_real_arr)

Kötülük:

• bariz, kullanmayan split
• yararsız isimlerle tonlarca yararsız değişken
• eval
• giriş dizesinde yeni satır sonunu gerektirir
• dize içeriyorsa çalışmıyor 'veya,

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

Örnek giriş: "Hello\nworld\nstuff"
Çıkış:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Oh ve kodun O (n ^ 2) olduğunu söylemeyi unuttum

node.js

Bu çok basittir, herhangi bir programcı bunu yapabilir.
Öncelikle hostsdosyayı değiştirerek .com, .net, .orgharitaya değiştirmeliyiz 127.0.0.1.
ve gerisi herhangi bir noobun anlayabileceği temel 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,{}))
}

Gidin ya :)

Yakut

Programlamadaki dizgiler Einsteintanium'dan yapılmıştır. Bu nedenle ayrılmaları çok zor.
Neyse ki sizin için, kimya ve programlama alanında doktora yaptım, bu yüzden yardımcı olabilirim.
Bunun için yakut kullanacağız.

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

Bu kötü, çünkü:

• Zavallı adam radyasyon zehirlenmesinden korkacak
• "Görmezden gelebilir" tek kısmı önemli olan
• Sonsuz tembel aralıklar. Yani hadi!

C ++

C ++ programlama dilinin güçlü yeni özellikleri sayesinde bu, standart kütüphane kullanılarak kolaylıkla çözülebilir , tekerleği yeniden icat etmeyi unutmayın .

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

Düzenleme: Bu cevap açıkçası sadece önemsiz bir iş için aptalca karmaşık bir şey yaratma girişiminde bulunuyor ve hala kodu yazarken yapabildiğim kadar çok araç kullanıldı.

İşte dikkat etmeniz gereken birkaç şey:

• Yorumlar kodu tekrar kullanmak ve standart kütüphaneyi kullanmak hakkında konuşur, std :: string kullanılmaz.
• Bir dize uzunluğunun hesaplanması gereken her örnek için yeni bir lambda tanımlanır.
• Şablonları gerçekten iyi bir sebep olmadan kullanır.
• Her bir mektubu her dizede kopyalamak için memcpy kullanır .
• Bellek sızıntıları her yerde, ancak vektör hakkındaki yorumlar bellek sızıntılarını önlemek için bu sınıfa güvenmenin önemine işaret ediyor. Ayrıca bu vektörü işaretçi ile yığın belleği için döndürür.
• Harita sınıfını geçici depolama için kullanır, tıpkı bir vektör gibi kullanır.
• Muhtemelen daha fazla, başım ağrıyor.
• Oh, ve her şey de özyinelemeli.

C #

Bu, yeni hatları virgüllere dönüştürmek için özyineleme teknolojisini kullanır. Sonuçta elde edilen CSV dizesi bir diziye kolayca bölünebilir.

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

Son ifadeye kadar tamamen inanılır ve ders kitabı görünüyor. Bu doğru, sadece bunu öğretmeninize açıklamaya çalışın.

#include <string>
#include <vector>
#include <algorithm>

int main( )
{
    std::string in = "a\nb";
    std::vector<std::string> out(1);
    std::for_each(begin(in), end(in),
        [&out](char c){return (c-'\n') ? out.back() += c:out.emplace_back(); }
    );
}

Tabii ki bunun bir nedeni yok std::for_each, ama bir lambdayı yanlış kullanmamızı sağlıyor. Bu lambda bir şey döndürüyor gibi görünüyor, ama gerçekte değil. Üçlü operatör sadece yan etkiler için orada.

Peki! Bu nedenle, #define ifadeleri (bunları son zamanlarda C ++ 'a aktardılar) ve yerleşik sınıflarda metotların otomatik kaydı da dahil olmak üzere az bilinen bazı python özelliklerinin kullanımıyla bu sorun çok kolay hale geldi.

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

Bu ne kadar hoş?

açıklama

... buradaki trollerin oldukça büyük bir listesi var.

1. #define ifadeleri python'da mevcut değil!
2. Özellikle yerleşik sınıflara otomatik olarak yöntem kaydetmezler.
3. dışarı "tembelce somutlaştırılmış" - bu gerçekten hiçbir şekilde yararlı bir şey değil.
4. Sağlanan işlev sonuçtaki ayırıcıyı içerecektir.
5. Sağlanan işlev, sonucun son öğesini içermez.
6. Bununla birlikte, ~ operatörü bu bağlamda oluşturulmasına rağmen, ~ 0 -1'dir; bu, satırın gerçekte işe yarayacağı anlamına gelir.
7. İade karışık. Döneceği asıl yer sadece bir değer olmadan döner.
8. Hata # 20221, adında "#define" yazan gerçek bir python hatası - ancak bununla ilgisi yok.
9. Giriş satırı sadece tek bir satır olabilir ... ve sadece yeni satırlar içeremediğinden oldukça değersiz olan bir bölme olabilir.
10. Print (x) yerine sys.stdout.write (str (x)) kullanımı, işleri yapmak için kötü bir yoldur.
11. "Python sanal makinesi" bu durumda bir telafi konseptidir. (Ayrıca "sınıf yöntemi", örnek bir yöntem değil statik bir yöntem olacaktır, böylece bu bölüm de yanlıştır.)

Aslında, program çalışır (en azından Python 3.3.0'da ve tek satırlık giriş probleminin yanı sıra), aslında çalışmasını sağlamak için bir araya getirdiği şeyi yapmamasını sağlayan bir çok şey vardır.

Amaç LOLKODU

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

ANSI C

Bu, hepimizin yaptığı standart bir ödevdir. Bu genel kabul görmüş bir çözümdür.

#include <stdio.h>

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

Bölmek ve yazdırmak için kütüphaneye doğru işlevi dahil etmeniz gerekir. #include <stdio.h>

Bölmek istediğiniz dizeyi yaratın: printf'in girişinizi değiştirmenin bir yolu olmadığını göstermek const char * input = "First Line\nSecond Line\nThird Line\n";için constanahtar kelimeyi nasıl kullandığımı not edin. Bu, kullanıcı girişini her zaman orijinal formunda yasal amaçlarla korumak istediğiniz için önemlidir.

printf("%s", input); Konsol çıktısında gördüğünüz gibi bölme işlemini sizin için yapar.

getchar(); Çıktıyı incelerken konsolun devam etmesini sağlamak için küçük bir ekstra numaradır.

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

Çıktıyı yaratır:

First Line
Second Line
Third Line

piton

find()Her yeni satır örneğinde dizeyi bölmek için yinelemeli olarak Python'un dizgi yöntemini kullanabiliriz (giriş dizesinin olduğu gibi kodlanmış olduğunu input_strancak raw_input () ile değiştirilebileceğini unutmayın):

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

Yukarıdaki betiği çalıştırarak, beklenen çıktıyı elde ederiz (hem öncü hem de sondaki boşluk boşluğunun dizeyi her yeni satırda bölme ile tutarlı olduğunu unutmayın):

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

PHP / GD

Dizeleri bölmek çok karmaşık bir konudur. Bu önemli ev ödevi konusu için devam ettik ve oldukça basit bir uygulama yaptık.

PHP'nin son sürümlerinde herhangi bir bağımlılık olmadan çalışır: Burada, kodlanmış kodla sınırlı sayıda örnek vardır, çünkü burada 40.000 karakterlik bir karakter sınırlaması vardır;

Örnek sürüm:

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

Şartnamenizi tam olarak onaylar.

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

Kaba olmak istemiyorum, işte dizginizi parçalara ayıran çalışan bir Python kodu parçası. Ancak, nereye bölünmesini istediğinizi belirtmediğiniz için, yalnızca rastgele konumları seçeceğim. Umarım senin için uygun olur.

piton

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

Düzenli ifadeyi destekleyen ve split hazır işlevi her zaman bir dize bölmek için kullanmanız gerekir. Bu, tekerleği yeniden icat etmekten kaçınmanıza ve kodunuzu kısa ve tatlı tutmanıza yardımcı olur. Normal ifadeyi kullanmak, normal ifadenizi değiştirmeden kodunuzu başka bir dile aktarmanıza olanak tanır.

Kötü çözüm

Şununla bölündüğünüz \nveya şu durumlarda ayırdığınız bu açık çözüm var \r\n:

Java

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

PHP

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

Bu çözüm çöp ve asla kullanılmamalıdır. Bu gün ve yaşta Unicode'dan kaçınmak boşunadır, bunun yerine her programcının onu benimsemesi ve başvurunuzun Unicode'a hazır olduğundan emin olması gerekir. Yalnızca \nveya \r\nyeni bir satır ayırıcı olarak düşünürseniz , 90'lı yıllarda bir yazılım yazıyorsunuzdur. Bu Unicode çağında, geçerli satır ayırıcı olarak U + 0085, U + 2028, U + 2029 olarak düşünmelisiniz. Unicode her gün ve sonra güncellendiğinden ve genellikle güncellendiğini fark etmeden önce biraz zaman alacağı için, Unicode'a eklenen yeni bir satır ayırıcı olabilir. Endişelenmeyin, çünkü tüm düzenli ifade motorları Unicode hazırdır ve en son Unicode standardına uyacak şekilde düzenli olarak güncellenir. Bu yüzden, eğer tercüme edilmiş bir dil kullanıyorsanız, kodunuz hiçbir şey yapmadan güncel olacaktır.

Önerilen çözüm

Bir dizgiyi satır sonlandırıcısına bölmek ve Unicode'un evrimi ile güncel kalmak için, regex'i sağlayın ^ve MULTILINEmodu belirtin .

Varsayılan olarak, ^yalnızca dizenin başlangıcıyla eşleşir. In MULTILINEmodunda ^ da bir çizgi terminatör sonra çizgi, yani başıyla eşleşir.

Örneğin:

Java

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

PHP

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

Önünde fazladan boş bir dize girişi olduğuna dikkat edin, sadece kaldırın ya da indeks 1'den döngüden geçirin.

açıklama

İlk bakışta bu, en iyi kodlama önerileriyle birlikte açıklama ile birleştiğinde (biraz) çalışan bir çözümle iyi bir cevap gibi görünüyor. Bununla birlikte, çözümün kendisi bir trol ( "Biliyorum, düzenli ifadeler kullanacağım." Şimdi iki problemi var. ) Ve bütün yazı, acemi bir yanlış bilgiyle serpiştirildi;

• Farklı regex motorları farklı özellik setlerini destekler. Hedef motor, regex'inizde kullandığınız özelliğe sahip değilse, kodu taşımak, kopyalayıp yapıştırmak kadar kolay değildir. Desteklenen özelliklerle benzetim yapmak mümkün olabilir veya tamamen regex ile yapmak imkansız olabilir.
• Orada 2 motor tipleri metin yönlendirmeli motor (otomat bazlı) ve regex yönlendirmeli motor (backtracking):. İlki en soldaki en uzun dizeyi döndürür, ikincisi en soldaki önyargılı dizeyi (regex tarafından belirtilen keşif sırasına doğru eğilimli) döndürür. Aynı regex 2 tip motor için farklı sonuçlar doğurabilir.
• Aynı özellik için bile, farklı regex motoru, bunu belirtmek için farklı sözdizimine sahip olabilir.
• Aynı özellik ve aynı sözdizimi için bile, farklı regex motorları ayrıştırma ve eşleme konusunda farklı davranışlar gösterebilir. Hatalar bir yana, fark regex motorunun tasarımından gelebilir (belgelenmiş olabilir veya olmayabilir).
• Gelen MULTILINEmodunda davranışı ^ve $"satır sonlandırıcı" tanımına bağlıdır. Java gördüğü \r\n, \n, \r, \u0085, \u2028, \u2029hat sonlandırıcı olmak \r\ndizi atom olarak kabul edilir. JavaScript düşünüyor \n, \r, \u2028, \u2029çizgi sonlandırıcılar olmak. Ruby sadece \nsatır sonlandırıcı olarak görüyor .
• splitişlevi köşe durumlarda için farklı dillerde farklı semantiklere sahip olabilir. Python boş eşleşmelerde ayrılmaz, Java izleyen boş dizeleri kaldırır (negatif sınır belirtmezseniz), JavaScript 0 dizinde boş bir dize eşleşmesinde bölünmez.
• "Kötü çözüm" aslında "önerilen çözümden" daha taşınabilir. Bununla birlikte, bir satır sonlandırıcı olarak görülmesi gereken, üzerinde çalıştığınız şeyin özelliklerine bağlıdır (örneğin, C kaynak kodu).
• Şu anda, çoğu regex motoru Level 1 Unicode desteğine bile uymuyor . Unicode özelliklerine ve bloklarına sahip olabilirler, ancak Hat Sınır bölümünün uygulaması yukarıda açıklandığı gibi her yerdedir. JavaScript Unicode karakter özelliklerini bile desteklemiyor!

Bash betiği

new_string=`echo $string`

Bu, dizgiyi yeni satırlara böler. Echo'yu $new_stringeklerseniz, yeni satırın dizi ayırıcılara dönüştüğünü fark edeceksiniz.

Örnek çıktı:

[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

Bu bir dosyadan okumaz. Düzenli ifadeler kullanılır. Kod, okunan dizenin yeni satırı belirtmek için '\ n' karakterine sahip olduğunu varsayar. Bölünmeyi belirtmek için 1,2,3,4 sayıları kullanılır.

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

Dizginizi bölmek istediğiniz "yeni satırın" büyük / küçük harf duyarlı mı yoksa duyarsız mı olduğunu belirtmezsiniz. Duyarsız olduğumu farz ediyorum.

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

  }
}

Dostum, bu Powershell'de yapmak çok kolay.

Sadece ipini şu şekilde al:

$string = "Helloworld!"

Ardından dizginizi bu şekilde ikiye bölene kadar rasgele ascii üzerinde döngü yapın:

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

sonunda şöyle çıktısını alabileceğiniz split dizgisini almalısınız:

Write-Host $new_string

Çıktı:

Selam Dünya!

php

<? Spliter($yourstring); ?>

İşte string'i nasıl böldünüz? O kadar kolay değil mi?

Şimdi tek yapmanız gereken, işlevi yazmak. Spliter()

özel bash

Bash için harika bir iş var !

Evet, dize bölme işlemi gerçekten basit bir şekilde yapılabilir:

string=$'foo\nbar\nbaz'

Öncelikle bölünmüş sonucunuzu saklamak için kullanacağınız bir değişkeni başlatmanız gerekir:

declare -a lines

Şimdi her satır iki ayırıcı ile sınırlandırılmış , dizgenin başlangıcı veya sonu ile, ilkini saklamak için bir değişkene ihtiyacınız olacak

limitA=0

Tamam, şimdi ayırıcıyı arayabilir ve çizgilerinizi bir döngü kullanarak saklayabilirsiniz . As bash ikili değer ile işlemesi mümkün değil, sen gibi aracını kullanabilirsiniz odnumune için onaltılık değerler ile işe:

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

Şimdi değişkene depolanmış bölünmüş bir dizgemiz var lines:

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

Aşağıdakileri kullanarak basabileceğimizi:

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

Bütün bunları tek bir betiğe koymak:

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

Bu yazdıracak:

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

Modern bash

Ancak modern bash uygulamasını kullanarak , newline gibi kontrol karakterlerini değişkene kaydedebilir ve hatta test edebilirsiniz:

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

Ancak okunabilirliği umursamıyorsanız, aşağıdaki gibi yoğunlaştırılmış komut dosyası yazabilirsiniz:

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

Golf betiği şöyle görünebilir:

#!/bin/bash

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

ve aynı etkiyi verir: İlk satır bölünmüş dizge ve bunları satır adında bir dizide saklar . Ve ikinci satır, '' satırlar '' dizisinin her üyesini ve ardından yeni bir satır yazacaktır .

bash + vt konsolu

Ancak birçok kişi ANSI VT standardını temel alan metin konsolu kullandığından, konsolunuzun VT davranışlarını kullanabilir ve bu kısaltmayı tekrar yazabilirsiniz:

#!/bin/bash

echo $'foo\nbar\nbaz'

aynı sonucu verecektir.