Il mio compito a casa è prendere una stringa e dividerla in pezzi in ogni nuova riga. Non ho idea di cosa fare! Per favore aiuto!

^{Nota: questa è una domanda di traina del codice . Si prega di non prendere sul serio la domanda e / o le risposte. Maggiori informazioni qui .}

C

Il mio compito a casa è prendere una stringa e dividerla in pezzi in ogni nuova riga. Non ho idea di cosa fare! Per favore aiuto!

Problema complicato per una classe di programmazione C iniziale! Per prima cosa devi capire alcune nozioni di base su questo argomento complicato.

Una stringa è una sequenza composta da soli caratteri . Ciò significa che per consentire ai programmatori di indicare una cosa "invisibile" (che non è uno spazio, che conta come un personaggio), devi usare una sequenza speciale di caratteri per indicare quella cosa invisibile.

• Su Windows , la nuova riga è una sequenza di due caratteri nella stringa: barra rovesciata e n (o la stringa "\n")

• Su Mac Linux o OS / X , è una sequenza di quattro caratteri: barra rovesciata, n, barra rovesciata e quindi r: (o "\n\r").

(Interessante nota storica: su Macintoshes più vecchi c'era una sequenza diversa di quattro personaggi: "\ r \ n" ... totalmente indietro rispetto a come Unix ha fatto le cose! La storia prende strade strane.)

Può sembrare che Linux sia più dispendioso di Windows, ma in realtà è un'idea migliore usare una sequenza più lunga. Poiché Windows utilizza una sequenza così breve, il runtime del linguaggio C non può stampare le lettere effettive \nsenza utilizzare chiamate di sistema speciali. Di solito puoi farlo su Linux senza una chiamata di sistema (può persino stampare \n\o \n\q... tutt'altro \n\r). Ma poiché C è pensato per essere multipiattaforma, impone il minimo comune denominatore. Quindi vedrai sempre \nnel tuo libro.

(Nota: se ti stai chiedendo come stiamo parlando \nsenza ottenere nuove righe ogni volta che lo facciamo, StackOverflow è scritto quasi interamente in HTML ... non C. Quindi è molto più moderno. Molti di questi vecchi aspetti di C sono essere affrontato da cose di cui potresti aver sentito parlare, come CLANG e LLVM.)

Ma torniamo a ciò su cui stiamo lavorando. Immaginiamo una corda con tre pezzi e due nuove linee, come:

"foo\nbaz\nbar"

Puoi vedere che la lunghezza di quella stringa è 3 + 2 + 3 + 2 + 3 = 13. Quindi devi creare un buffer di lunghezza 13 per esso, e i programmatori C ne aggiungono sempre uno alla dimensione dei loro array per sicurezza. Quindi crea il tuo buffer e copia la stringa in esso:

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

Ora quello che devi fare è cercare quel modello di due caratteri che rappresenta la nuova riga. Non ti è permesso cercare solo una barra rovesciata. Poiché C viene utilizzato per la suddivisione delle stringhe abbastanza, ti darà un errore se provi. Puoi vedere questo se provi a scrivere:

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

(Nota: nel compilatore è presente un'impostazione se stai scrivendo un programma che cerca solo barre rovesciate. Ma è estremamente raro; le barre rovesciate vengono utilizzate molto raramente, motivo per cui sono state scelte per questo scopo. accendere.)

Quindi facciamo il modello che vogliamo davvero, in questo modo:

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

Quando vogliamo confrontare due stringhe che sono di una certa lunghezza, usiamo strncmp. Confronta un certo numero di caratteri di una stringa potenzialmente più grande e ti dice se corrispondono o meno. Quindi strncmp("\nA", "\nB", 2)restituisce 1 (vero). Questo anche se le stringhe non sono del tutto uguali per la lunghezza di tre ... ma perché sono necessari solo due caratteri.

Quindi esaminiamo il nostro buffer, un personaggio alla volta, cercando la corrispondenza dei due personaggi con il nostro modello. Ogni volta che troviamo una sequenza di due caratteri di una barra rovesciata seguita da una n, useremo la speciale chiamata di sistema (o "syscall") putcper mettere in evidenza un tipo speciale di carattere: il codice ASCII 10 , per ottenere una nuova riga fisica .

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

L'output di questo programma è il risultato desiderato ... la divisione della stringa!

foo
baz
bar

\t è per \ trolling ...

Assolutamente errato dall'alto verso il basso. Eppure pieno di assurdità dal suono plausibile che ha mescolato informazioni come quelle contenute nel libro di testo o in Wikipedia. La logica del programma appare trasparente nel contesto della disinformazione, ma è completamente fuorviante. Anche variabili globali e restituzione di un codice di errore, per buona misura ...

...

Naturalmente, c'è solo un carattere nella rappresentazione in stringa C della sequenza letterale sorgente di due caratteri \n. Ma allargare un buffer è innocuo, purché strlen()venga utilizzato per ottenere la lunghezza effettiva su cui operare.

...

Cerchiamo di convincere il lettore che strncmpè un'operazione booleana che corrisponde a (1) o no (0). Ma in realtà ha tre valori di ritorno (-1 corrispondenza inferiore, 0 per uguale, 1 per corrispondenza maggiore) . Il nostro "modello" a due caratteri che viene confrontato non è [ \, n], ma piuttosto [ \n, \0] ... raccogliendo il terminatore null implicito. Poiché quella sequenza scorre attraverso la stringa, non sarà mai maggiore di una sequenza di due caratteri rispetto a ... al massimo sarà zero se nella stringa di input è presente una nuova riga che termina.

...

Quindi tutto ciò che fa è scorrere la stringa e stamparla un carattere alla volta. Il ramo superiore non corre mai. (Anche se potresti ottenerlo se la tua stringa avesse \ncodici inferiori a quelli in essa contenuti, dì tab ... che potrebbe essere usato per omettere misteriosamente i caratteri dall'output :-P)

1. Prendi una forbice e la corda che vuoi dividere.
2. Apri la forbice.
3. Metti la corda tra le lame delle forbici.
4. Chiudi la forbice.

Congratulazioni! La tua stringa ora dovrebbe essere divisa. In caso contrario, ripetere i passaggi fino a quando non lo è. Se hai ripetuto i passaggi un paio di volte e la corda non è stata divisa, prova a usare una forbice più nitida.

ESCLUSIONE DI RESPONSABILITÀ: Non sono responsabile per eventuali danni che ti verranno applicati durante il processo.

Pitone

Mi sento così male che ti è stata posta una domanda così ovvia come i compiti. Un linguaggio altamente avanzato come Python lo rende un semplice due liner:

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

Si prega di votare e accettare.

C

In C è davvero facile:

#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

Chiamalo così:

split("a\nb");

Esempio funzionante:

http://codepad.org/GBHdz2MR
Perché è malvagio:

• Si basa sulla printffunzione per dividere le stringhe
• È totalmente incomprensibile
• Confonderà chiunque non capisca #define(e anche quelli che lo capiscono )

Questo può essere fatto in poche righe di codice con il seguente semplice algoritmo:

1. Cerca il primo carattere di nuova riga nella stringa.
2. Aggiungi la parte alla nuova riga a un elenco.
3. Rimuovere la parte fino alla nuova riga dalla stringa.
4. Se la stringa non è vuota, andare al passaggio 1.

Tuttavia, questo è uno spreco. Questo è essenzialmente un algoritmo di ricerca lineare , che ha una complessità temporale lineare (O (n)). Ti farò entrare in una tecnica più avanzata: la ricerca binaria . La ricerca binaria è molto più efficiente della ricerca lineare: ha solo complessità temporale logaritmica (O (log (n)). Ciò significa che se lo spazio di ricerca è due volte più grande, il tempo di ricerca non raddoppia, ma aumenta solo di un importo fisso!

Il codice per la ricerca binaria è un po 'più complicato, perché utilizza le tecniche avanzate di ricorsione e divisione e conquista . Ma ne vale sicuramente la pena per il vantaggio prestazionale. Se lo invii, mi aspetto che otterrai credito extra.

L'essenza dell'algoritmo è questa:

• Taglia la corda in due.
• Con una chiamata ricorsiva, dividere la prima metà della stringa.
• Con una chiamata ricorsiva, dividere la seconda metà della stringa.
• Metti i pezzi della prima metà insieme ai pezzi della seconda metà e voilà !

Non hai specificato una lingua, quindi l'ho scritta in Python. Nel mondo reale, ovviamente, le persone non scrivono in Python: usa C o C ++ (o anche meglio, linguaggio assembly) per prestazioni reali. Non ti preoccupare se non capisci cosa sta facendo tutto il codice - questa è sicuramente roba avanzata.

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

Ovviamente tutte le dichiarazioni sulla performance sono false. L'algoritmo "semplice" può essere lineare o quadratico a seconda di come lo si interpreta. L'algoritmo "avanzato" è Θ (n × log (n)) (abbastanza vicino al lineare nella pratica), ma ragazzo, è la costante moltiplicativa elevata a causa della ricostruzione incessante dell'elenco (che l'implementazione fa di tutto per favorire ).

Lo stile Python, lo stile dei commenti, le dichiarazioni sulle scelte linguistiche e quasi tutto il resto in questo post non riflettono nemmeno la mia opinione o le mie abitudini.

Visual Basic

La IOmonade ha una funzione per farlo!

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

• Utilizza a lungo deprecato std::strstream
• Fa di tutto per introdurre una perdita di memoria
• Suppone ciecamente che 2045 byte siano sufficienti per contenere un strstream
• Nomi orribili
• Utilizzo incoerente del std::prefisso
• Non funziona con stringhe const
• Ignora completamente i sovraccarichi del buffer
• Include la caratteristica prima linea di programmatori che sanno cosa stanno facendo
• Vuoto mentre il corpo senza nemmeno un commento
• Indicizzazione per principianti

Python 3 (pulito e ordinato)

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

Rubino

Bene, vedi prima che devi trasformarlo in un array come questo

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

Ora devi mettere gli elementi come stringhe

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

Oh, rimuovi anche l'ultima virgola

actually_real_arr = real_arr.chop

Oops dimenticato, devi mettere le parentesi come array

definitely_the_real_arr = "[#{actually_real_arr}]"

Ora usa la stringa e il gioco è fatto

final_arr = eval(definitely_the_real_arr)

malvagità:

• l'ovvio, non usando split
• tonnellate di variabili inutili con nomi inutili
• eval
• richiede una nuova riga finale nella stringa di input
• non funziona se la stringa contiene 'o,

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

Esempio di input: "Hello\nworld\nstuff"
output:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Oh e ho dimenticato di menzionare che il codice è O (n ^ 2)

Node.JS

Questo è così semplice, qualsiasi programmatore potrebbe questo -.-.
Per prima cosa dobbiamo cambiare il hostsfile in modo che la .com, .net, .orgmappa sia 127.0.0.1.
e il resto è Javascript di base che qualsiasi noob potrebbe capire.

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

Ecco qua :)

Rubino

Le stringhe nella programmazione sono realizzate in Einsteintanium. Come tali, sono estremamente difficili da dividere.
Fortunatamente per te, ho un dottorato in chimica e programmazione, quindi posso aiutarti.
Useremo ruby ​​per questo.

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

Questo è male perché:

• Il povero ragazzo avrà paura dell'avvelenamento da radiazioni
• L'unica parte "che può ignorare" è la parte importante
• Infinite gamme pigre. Voglio dire, andiamo!

C ++

Grazie alle nuove potenti funzionalità del linguaggio di programmazione C ++, questo può essere risolto facilmente utilizzando la libreria standard, ricordate di non reinventare la ruota .

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

Modifica: questa risposta ovviamente cerca solo di creare qualcosa di stupidamente complesso per un compito banale, e nel fare ciò ha abusato di quanti più strumenti ho potuto, pur potendo ancora scrivere il codice.

Ecco alcune cose da notare:

• I commenti parlano del riutilizzo del codice e dell'utilizzo della libreria standard, non viene utilizzato std :: string.
• Per ogni istanza in cui è necessario calcolare la lunghezza di una stringa, viene definita una nuova lambda.
• Utilizza i modelli senza una buona ragione davvero.
• Usa memcpy per copiare ogni singola lettera in stringhe.
• Le perdite di memoria sono ovunque, ma i commenti sui vettori sottolineano l'importanza di fare affidamento su questa classe per evitare perdite di memoria. Restituisce anche questo vettore dal puntatore alla memoria dell'heap.
• Utilizza la classe della mappa per l'archiviazione temporanea, mentre la utilizza come un vettore.
• Probabilmente di più, mi fa male la testa.
• Oh, e anche il tutto è ricorsivo.

C #

Questo utilizza la tecnologia della ricorsione per trasformare le nuove linee in virgole. La stringa CSV risultante può essere facilmente suddivisa in un 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 ++

Sembra del tutto credibile e da manuale fino all'ultima espressione. È anche corretto, prova a spiegarlo al tuo insegnante.

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

Ovviamente non c'è giustificazione per std::for_each, ma ci consente di usare male una lambda. Quella lambda sembra restituire qualcosa, ma in realtà non lo fa. L'operatore ternario è lì solo per gli effetti collaterali.

Tutto apposto! Quindi questo problema è reso molto semplice dall'uso di alcune caratteristiche poco conosciute di Python, tra cui le istruzioni #define (le hanno recentemente portate da C ++) e la registrazione automatica dei metodi nelle classi integrate.

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

Quanto è bello?

Spiegazione

... c'è una lista piuttosto grande di pesca a traina qui.

1. Le istruzioni #define non esistono in Python!
2. In particolare, non registrano automaticamente i metodi nelle classi integrate.
3. out è "pigramente istanziato" - il che in realtà non significa nulla di utile.
4. La funzione fornita includerebbe il separatore nel risultato.
5. La funzione fornita non includerebbe l'elemento finale del risultato.
6. Tuttavia, nonostante l'operatore ~ ​​sia composto in questo contesto, ~ 0 è -1, il che significa che la linea funzionerebbe effettivamente.
7. I ritorni sono incasinati. Il luogo effettivo che restituirebbe solo restituisce senza un valore.
8. Bug # 20221 è un vero bug di Python con "#define" nel nome - ma non ha nulla a che fare con questo.
9. La riga di input può essere solo una singola riga ... e solo dividere ciò è abbastanza inutile poiché non può includere newline.
10. L'uso di sys.stdout.write (str (x)) invece di print (x) è un brutto modo di fare le cose.
11. "Python virtual machine" è un concetto inventato in questo caso. (Anche "metodo di classe" sarebbe un metodo statico, non un metodo di istanza, quindi anche quella parte è sbagliata)

In realtà, il programma funziona (almeno in Python 3.3.0 e oltre al problema di input a linea singola) poiché molte cose che lo fanno non fanno ciò che dice si combinano per farlo funzionare davvero.

LOLCODE obiettivo

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

ANSI C

Questo è un compito standard che tutti noi abbiamo fatto. Questa è la solizione generalmente accettata.

#include <stdio.h>

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

È necessario includere la libreria con la funzione corretta per suddividere e stampare. #include <stdio.h>

Crea la stringa che vuoi dividere: const char * input = "First Line\nSecond Line\nThird Line\n";nota come ho usato la constparola chiave per illustrare che printf non ha mezzi per cambiare il tuo input. Questo è importante poiché si desidera sempre preservare l'ingresso dell'utente nella sua forma originale per scopi legali.

printf("%s", input); fa la divisione per te come puoi vedere nell'output della console.

getchar(); è solo un piccolo trucco extra per mantenere la console persistente mentre si controlla l'output.

L'input: "First Line\nSecond Line\nThird Line\n"

Crea l'output:

First Line
Second Line
Third Line

Pitone

Possiamo usare in modo iterativo il find()metodo stringa di Python per dividere la stringa in ogni nuova istanza di linea (si noti che la stringa di input è input_strhardcoded come , ma può essere sostituita con 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

Eseguendo lo script precedente, otteniamo l'output previsto (si noti che sia lo spazio iniziale che quello finale sono coerenti con la divisione della stringa ad ogni nuova occorrenza di riga):

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

PHP / GD

Dividere le stringhe è una questione molto complicata. Anche se abbiamo continuato e realizzato un'implementazione piuttosto basilare per questo importante problema di compiti a casa.

Funziona senza alcuna dipendenza da una recente versione di PHP: quantità di esempi limitata nel codice pubblicato poiché qui abbiamo un limite di caratteri di circa 40.000 caratteri che non si adatta a una discreta quantità di stringhe dimostrative.

Versione di esempio:

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

Conferma esattamente alle tue specifiche.

<?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'
/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcgSlBFRyB2ODApLCBkZWZhdWx0IHF1YWxpdHkK/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sAQwEJCQkMCwwYDQ0YMiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy/8AAEQgBQADuAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A9/NJSmkoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAU0lKaSgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAFNJSmkoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAU0lFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRmigAooooAKDSmmk0AGaTcK4nUviHbp4gm0HRdOudY1GD/j5MTLHBb/AO/K3H5A9COoxVbVfFfiqwVJbXQtIvAF/eQQ6jIHz7F4lU/qfaiwHoG4Utef6D8VdE1S+XTtQiudG1Jm2i3v02Bj2w3Tntu2k9hXeK1DTW4ElFIDS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFJmgBaTNNL1Tv8AUrTTLR7q+uYbW3QfNLM4RR+JoAulhUUs8cMTSSyIkajLMxwFHqSa5i38TXfiBA3h2yJtGGRqV8jRxMPWOPh5O3Pyrz949KZceDrLU3Euvz3essDkRXDlbdT7QphePVtx9zR6gVL/AOL3gvT5mhOrm4K8M1rA8qD/AIEBj8q1fD3j/wANeJ5/s+l6kklxjcIJEaNyB3AYDP4VbjgsdPtPJhtbe0tlH3FiWNAPoABXk/jPVPA8Wt6dHoFhDc+JRfQvG+k4QAhwSHZPlYkZGOTzyQKr3WI90BzRSDvS1IxTUM+7yn2ff2nb9ccVMaawzQB5v8L9Itovh/ZXDAPd3byzXshA3PNvZW3e4xj8Peumm0mJ87cqapnQ7/RNSurnRZ4ltruQzT2M6Fo/MPV0IIKE8FhyCecAnNRzr4muUdRfW9pu+61tbfMv4yFwfrgfSh6sDO8Q+DrHWbEwajbCRF4STo0ef7rdvp0PcGuXt9R8Y/DxUZml17w3GQGDKTPbx+ze3uSvGPkq9qvwufXWMuq63q95Nj5WmlRgv0XbtH4CuUv/AIK6xa7pdI1YBgPkVlaFh/wNSf5VpG1rXEe8aVq1jrOmwahp1wk9rMMpIp/MEdiOhB5BGKzte8a6F4ZvbO11e++zyXe7yzsZlAGMliAdo5HX69BmvmmaLx38Pt0co1GximYgS20p2SFR6jg8eoBwPasGTVb57ub7TNPJPOF84XgZnk5DLknJ6cjkcUlFX3C59V+JPHukaBp8U8U0eoXNyQLa2tpA5lzjByM4HI575AGSRXSW1x51rDM6GF5EVjFIy7kJGdpwSMjpwSK+LrkpFLgqZI2GRIAA/GR16HHvXVaF8Ste8OaLHYaZcWk9pC5IWeL94u5ieeR6j2q3S7CufVnmR/3l/Ok81P76/nXy+3xr8VO2ALJR/wBcP65+v6e+Q/GfxeVI86yH0thx+v0/Wo9nIdz6f86L++Pzo8+L++K+Wn+MPjMvkahbrnstqn9RSr8X/GfX+0ID6g2ic/pT9mwufUn2iL++PzpPtMP98V8t/wDC4fGoYt9utST1BtExTl+M/jBMln058/3rTp+TCk6bC59Q/aof736GkN5CO5/KvmI/G3xh2/stSe/2U/8AxVInxq8Zb8+Zp3PY2n/2VLkkFz6d+2wf3v0pftcPYn8q+Z4vjZ4wjI3DSpAOoa0PP5OK00+PWtJFiXQtNeQfxo8iD8uf50/ZyC56T4r+KVt4T8U2um3VhJLZS24lluY3G6MliB8p4xxk5I68ZxisLxb8aLJLSODwnL9qvWO4yT27qqAc7drBSScYPYDvnFcLqHxWh1hmurzwrogvxF5cdzIvnOuMkbVYdskjJxmuX021fWZtN02ytoo729ncvLIzOHQseq5wAOfuj+H0q1BLViv2O28Q/G/xDNqarpMMGnwREoUdRMZmPQkkDHYgDnPUnpUH/CDeOfF8MWr6nqo+0tiSGO8JLKOoOwDbH9AM+oruPC3w2udA1iK/gmsZYXISeOaDEip6o4zz0OMAHGPcemR26R/dUVDlb4R+p4GPh78UrtyLjxDOIz1P9qz4/AAVpWvwZ1qT5tQ8TXbuf+eZc4/Fm5/KvcAtOCVPMxnibfAo3PF1rt3IgOQGQNj8ya7PwX8MNF8IXQu4Y3ub0DAubggsgPZQAAPrjPvXdhKeFxQ5NgKowtLRRSAU0hpTSUAIVBpNgp1FADNlMZampCKAMjWNGtNb09rK9hEkZIZc/wALDoQe3U/gT614j4r+FWtwXtvaaTBBcWku4tcg+W0YU/KpBOMkHJOOdoHGAK+gitQSRA9e1F7AfKuleCNa1vVbvQbezFtNboLlEu5QjRKx2nPG4jscDqF+ptXvwd8aW0w2aZBd/wC3bXUeB9d5U/pXp3j+xv8Aw/4os/G2loJPssXl3cJIG6EHkA98gnjsQp7V6NYXttqNhb3to2+3uY1lhIH3lIBHH49O3Sr9pID5h/4VX44Of+Kdm47+fD/8XTR8L/G+7H/CPTg+88P/AMXX1Rj1GPqKrzrs+YAfXFHtJCsfNEHwi8ay8tpUUP8A11u4v/ZWNacHwQ8XSr802kRez3Ln/wBBjNfQQn+X58CpI3D9PwwKPaMdj52l+CHjFHwo0yUeqXZA/wDHkFRt8FvGiLn7JYN7C8X/AAFfSak9MH8qfg4+6fyo9pILHy6/wi8ahjjRQ2OhF1Dz9PnFQH4T+ORz/YDj/t7g/wDjlfUjtj+FvypN29en50e0YWPl2H4W+M5ZQh0Ux5/ikuYcD8nNX2+DvjVEJ+w2z/7KXaZP5kV9Gso9OP5VKnHy/lR7SQWPmT/hUPjVNx/scZx1+1Rc+w+eu9+Gvge5sPFd5fanAkb2MS28EYdXKFkBJJUkA7CPqJO1et3M8VtDJNMwSKJDJI2fuqBkn8gapaBBIloZZ8/aJ3aeXJB2s7FtuQBkLkKD6KKUptqwGrHCE6ce1WFWhBUoFQA0LTgtLRTAMUUUUAFFFFACmkpTSUAFFFFABRRRQAEVGy1JSEUAZ19arcwlWAPFfO/xB8Nz+HdVE9tNLHptydoCs+LaQcgrg/KD/Rh3FfSjrXF+O/Dya5oN1a7QZGTMZPZxyvPbkYJ9CacXZ3A+c4PFXibT38qLXtXjMZxsN5IQuPYkj9Kvf8LH8ZquB4mv/wAdh/8AZa9Lg+Cuhavp9vd22tamryxL8zrEw3DjBAUcjGCAe3Wsi4+AOqo5+z6/ZSp28y3eMn8i386254MVmcBN478XT/63xHqTZ9Jtv8sVRPifxEc58Qavg9R9vl5/8er0JPgP4iLfPqOloPUPIf8A2QVOnwB1l/va5p6fSJ2z/KnzQA8vfWdWl4l1bUZPZruQ/wDs1MTUL5Pu312vqRO4/rXq4/Z/1X/oYbIfS2f/AOKqX/hQNwkRaXxPErDsNPJ/XzBS54geVpr+tQYEOtanHjpsvZRj/wAerQh8deK4kCp4j1TA9blmP5nNd3/woXUn5i8Q2hHbfauufyY1DJ8BtdT7usaa3uVkH6YNHPANTin8deK36+JdUP0uWH8qYvjXxUnTxLqo9c3bn+ZrsH+BniMOAuo6Yy92zIMfhs/rViP4Da2HRm1jTpCT/qykg3d8ZxxnpntmjmgAvgG+8TeKPEdtb3ur6jNZWkfn3YeVwrsTmNCRjkHBwTyFbPv77aReWgHtXC/DHwqugaPLNI8U91dTNI9zGmBIgYhMdSVx8wz/AHq9DQVhJ3egyRRT6QUtJAFFFFMAooooAKKKKAFNJSmkoAKKKKACiiigAooooAYwqldxCSJgehFaBqCRaQHGWWsaf4evbyw1O/gtEeT7TbGeQLuDAh1XOMkMrNgZOHHrWxaeK/Duo5+ya9pk23r5d2hx+tcV8XNEa98NNdwjM1i/2hPbHX+QP0B55NfPN95CXTZ2BX/eIGI+6ef/AK34VpCCktxH1DqnxS8G6VcGGbWEmkU/MLWJ5gMdiVBH61hN8dPCguBGLbV3TP8ArRbJt+uDJu/SvnjcNm/OVPfPH51GZYj/AMtUH/AhWnsohc+o7b4s+C7sAx61FEx/huUaIj/voAfrVqHxdo+rzBYNa0zyQe13Hlv1r5UDIf4lP407YpXGAR9KPZeYXPsiG+0/YAl/aNx2nU/1qyk0Mn3Jo3PoHBr4sMEX/PJP++RR9nh/55J/3yKXsfMLn2m7xJ950UepYVi6zqMJtxa2l5H9sumEEPlSIXXdks4HP3VDN9VA9q+R0tFllSJIULuwRQFHJJwK9n+CehJLqWpa2EUQRKtjasOOBhnOPf5Dn13e9RKHKrhc9osraK2tY4YUWONFCqqjAUAYwAOlX0FRIKnUVmhi0UUUwCiiigAooooAKKKKAFNJSmkoAKKKKACiiigAooooAKYwp9IRQBkapaJc2skUq742Uq65+8pGCPyrH8IWVpYaIlhDZW8T2jGGXy4tokPUSY5+8CD16kjPFdNcJlCK4HxPrs3gqG41qLTxeRFVinjEix4G75XLEHOCxGAOd/tR1sB3JRRxsT6YFNa2glXD28Dj0aNTXis/x6vILh4v+Ect2Cnhvtx5HY/c70kf7QUw+/4XQ+41E/8Axqr5JAexPoGjy5Muj6c5PUtaoc/pVKfwN4WuWzN4c0lz72kY/kK80X9oOHaN3hiUHvi+B/8AadW4v2gdJK/vtA1FT/sSxt/MijlkB2Mvwv8ABci4Phy0X/rmXT+TCqMnwe8ESLgaM8ZPdL2fj8C5FZEPx68NSf63TtVi+scbY/J6vQfG7wZIcSXF/B7yWbH/ANBzRaYDJfg74Rss3qHULZYUZ3K3G/C7Tk/Mp6DNdH4L0W30Lw7a2VvEY0UF9pcsRuYsRk/X2+lZ7+MtF8Tu+kaTcyzTny2uAbeWPZGSDgkgDJ4GM56+hrrbZNkSj2qJNvcC0gqYUxBT6ACiiigAooooAKKKKACiiigBTSUppKACiiigAooooAKKKKACiiigCKQfLXM+I9Ot9R0+4srpS1vcRtE+ACQCMZGe46j3FdSw+Ws2/g8xCKQHyFqVjcW9w9nMhN3YubadY/m6E7W4HTGRn2FZrDyvvgx/7wxX1lpbfYtVmt8hDcfOhJHLKMFR/wABAPX+E8VuSYnX5wHH+1zWqqeQrHxb50fTen/fQpyup+6wP0NfZD2ls/D2tu4z/FEp/mKo3OgaDc83OhaXP6eZZRvj81p+18gsfI2atWMay3cYlH7pTvfjPyqMkduuMfjX1KfCHhV+D4X0TB9NOhH8lqlqfgzwjZafPMnhvTfNZfKRUgA3sxwBgYyM4J56A+lHtfILHNfBzRmTSZ9ZnQCbUJS6/LjEa8KB7feI9iK9diXpWRoWmw6ZptvawIqRQoqIFGAABjpW4i1k3d3GSKPlpaKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAA1BMmVqemuMrQBymtQTxoZ7XAuIzvjySFLDkA45wcYPsTXkMvx11uFlaTQ7AAlleJnlVo2BIKnJ+navdr+AOjcV87eNfBWpT+MLyHSdOnuUvE+2AQRkrHIOGzzgZPOTjlhgcU4WvZgW2+PGsFyRoWnBOw82TP50N8etX42aDp49cyyH/CuQX4c+Mnxjw3ff8CCj+ZqRfhj40fIHh26GOuXjH82rW0BHb6f8eNSluo4Z/D9kyMcEpcspHqckEcc13HhfxK3jyVb1bB7Wxs5WWPzJRJ5smMFhxwApIBHXe1eJN4C8UaZazTXWiXcbErECCjABjgn5SfYDHdvcV9GeDNAi0Dw/ZaemD5MYDkE/Mx5Zh9WJOO2azny9BnSQJhQKtqKiRalFSAtFFFABRRRQAUUUUAFFFFABRRRQAGilNJQAUZoooAM0ZooxQAZooxRQAUUUUAFFFFAFeZMqa4rX4W0/WNN1FVGxZvInOOkcg28YHZxGeoGAe+K7xhmszUtNhv7d4ZokkjYYKuoIP4GkBQidehPTtU/mJ26+1cqPAEKO2y+1gKx6f2rc8f8Aj9WbfwQsXH2vUmHpJqVw/wDNzTAsagv9qarp9guGjST7XOMZBVQRGCD0y5DAjvH2rqYItigdhVLS9Hg0yLZCgXcckjufUnvWsq0gFUU6iimAZooxRQAUZooxQAUUUUAGaKMUUAFFFFACmkoooAKKKM0AFFGaM0AFFGaKACiiigAooozQAUhGaXNGaAGbBRsFPooATaKWjNGaACijNFABRRRmgAoozRmgAoozRmgAoozRQAUUUUAFFKaSgAoxRRQAYoxRRQAUUUUAFFFFABRiiigAxRiiigAooooAKMUUUAGKKKKACjFFFABijFFFABijFFFABiiiigAooooAU0lBooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBTSc0GjNABzRzRRQAc0c0UUAHNHNFGaADmjmjNFABzRzRRQAc0c0ZooAOaOaM0ZoAOaOaKKADmjmiigA5o5oozQAc0c0ZozQAc0c0ZooAOaOaKKADmjmjNGaAFpMUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAJijFLRQAmKMUtFACUUtFACYoxS0UAJijFLRQAmKMUtFACYoxS0UAf/9k=
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

Non voglio essere cattivo, quindi ecco un pezzo funzionante di codice Python che divide la stringa in pezzi. Tuttavia, poiché non hai specificato dove vuoi che venga diviso, sceglierò solo posizioni casuali. Spero che vada bene per te.

Pitone

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

Per le lingue che supportano l'espressione regolare e la cui splitfunzione è prontamente disponibile, dovresti sempre usarla per dividere una stringa. Questo ti aiuta a evitare di reinventare la ruota e di mantenere il tuo codice breve e dolce. L'uso dell'espressione regolare consente inoltre di trasferire il codice in un'altra lingua senza modificare l'espressione regolare.

Pessima soluzione

C'è questa ovvia soluzione in cui dividi per \no \r\n:

Giava

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

PHP

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

Quella soluzione è spazzatura e non dovrebbe mai essere usata. Al giorno d'oggi, è inutile evitare Unicode, piuttosto ogni programmatore dovrebbe accettarlo e assicurarsi che l'applicazione sia pronta per Unicode. Se consideri solo \no \r\ncome un nuovo separatore di riga, stai scrivendo software negli anni '90. In questa era Unicode, devi considerare U + 0085, U + 2028, U + 2029 come separatore di riga valido. Poiché Unicode viene aggiornato di tanto in tanto, e di solito ci vuole del tempo prima che ti accorga che è stato aggiornato, potrebbe esserci un nuovo separatore di riga aggiunto a Unicode. Non preoccuparti, perché tutti i motori delle espressioni regolari sono pronti per Unicode e vengono regolarmente aggiornati per conformarsi all'ultimo standard Unicode. Quindi, se stai usando un linguaggio interpretato, il tuo codice sarà aggiornato senza che tu faccia nulla.

Soluzione consigliata

Per dividere una stringa dal terminatore di riga e rimanere aggiornati con l'evoluzione di Unicode, fornire regex ^e specificare la MULTILINEmodalità.

Per impostazione predefinita, ^corrisponde solo all'inizio della stringa. In MULTILINEmodalità, corrisponde ^ anche all'inizio della riga, ovvero dopo un terminatore di riga.

Per esempio:

Giava

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

PHP

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

Nota che c'è una voce di stringa vuota in più davanti, rimuovila o fai un ciclo dall'indice 1.

Spiegazione

A prima vista, questa sembra una buona risposta con una soluzione (in qualche modo) funzionante, unita a una spiegazione con alcune raccomandazioni sulle migliori pratiche di codifica. Tuttavia, la soluzione stessa è un troll ( "Lo so, userò espressioni regolari." Ora hanno due problemi. ), E l'intero post è cosparso di informazioni sottilmente sbagliate, che avveleneranno qualsiasi principiante nella programmazione.

• Diversi motori regex supportano diversi set di funzionalità. Se il motore di destinazione non ha la funzionalità che usi nella tua regex, il porting del codice non è semplice come copia e incolla. Potrebbe essere possibile simulare con le funzionalità supportate o potrebbe essere impossibile farlo con regex da solo.
• Esistono 2 tipi di motori : motore diretto al testo (basato sull'automa) e motore diretto al regex (backtracking). Il primo restituisce la stringa più lunga più a sinistra, il secondo restituisce la stringa distorta più a sinistra (polarizzata verso l'ordine di esplorazione, specificato dalla regex). Lo stesso regex può produrre risultati diversi sui 2 tipi di motori.
• Anche per la stessa funzione, un motore regex diverso potrebbe avere una sintassi diversa per specificarlo.
• Anche per la stessa funzionalità e la stessa sintassi, diversi motori regex potrebbero avere un comportamento diverso nell'analisi e nella corrispondenza. A parte i bug, la differenza potrebbe derivare dal design del motore regex (può o meno documentato).
• In MULTILINEmodalità, il comportamento di ^e $dipende dalla definizione di "terminatore di linea". Java ritiene \r\n, \n, \r, \u0085, \u2028, \u2029sia terminatore di linea, dove \r\nla sequenza è considerata atomico. JavaScript considera \n, \r, \u2028, \u2029per essere terminatori di linea. Ruby considera solo \ncome terminatore di riga.
• splitLa funzione può avere semantica diversa in lingue diverse per i casi angolari. Python non si divide su corrispondenze vuote, Java rimuove stringhe vuote finali (a meno che non specifichi un limite negativo), JavaScript non si divide su una corrispondenza di stringhe vuote all'indice 0.
• La "soluzione sbagliata" è in realtà più portatile della "soluzione consigliata". Tuttavia, ciò che dovrebbe essere considerato un terminatore di linea dipende dalle specifiche di qualunque cosa tu stia lavorando (ad es. Codice sorgente C).
• Attualmente, la maggior parte dei motori regex non è nemmeno conforme al supporto Unicode di livello 1 . Possono avere proprietà e blocchi Unicode, ma l'implementazione per la sezione Limiti di linea è ovunque, come spiegato sopra. JavaScript non supporta nemmeno le proprietà dei caratteri Unicode!

Bash script

new_string=`echo $string`

Questo divide la stringa per newline. Se si fa eco a $new_string, si noterà che ha sostituito la nuova riga in separatori di array.

Uscita campione:

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

Giava

Questo non legge da un file. Vengono utilizzate espressioni regolari. Il codice presuppone che la stringa letta abbia il carattere '\ n' per indicare la nuova riga. I numeri 1,2,3,4 sono usati per indicare la divisione.

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

Non specifichi se la "nuova linea" in cui vuoi dividere la stringa sia sensibile al maiuscolo / minuscolo. Presumo insensibile.

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

  }
}

Amico, questo è super facile da fare in Powershell.

Prendi la tua stringa in questo modo:

$string = "Helloworld!"

Quindi esegui il ciclo su ascii casuali fino a quando non hai la stringa divisa in due in questo modo:

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

alla fine dovresti ottenere la stringa divisa, che puoi produrre in questo modo:

Write-Host $new_string

Produzione:

Ciao mondo!

php

<? Spliter($yourstring); ?>

Ecco come dividere la stringa. Non è stato così facile?

Tutto quello che devi fare ora è scrivere la funzione Spliter()

bash specifico

C'è un ottimo lavoro per Bash !

Sì, dividere la stringa potrebbe essere fatto in un modo davvero semplice:

string=$'foo\nbar\nbaz'

Innanzitutto devi inizializzare una variabile che utilizzerai per memorizzare il risultato suddiviso:

declare -a lines

Ora che ogni riga è delimitata da due separatori, inizio o fine della stringa, avrai bisogno di una variabile per memorizzare la prima

limitA=0

Ok, ora puoi cercare un separatore e memorizzare le tue linee usando un loop . Poiché bash non poteva funzionare con un valore binario, è possibile utilizzare uno strumento simile oda quello con valori esadecimali, ad esempio:

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

Ora, abbiamo una stringa divisa memorizzata in variabile lines:

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

Che potremmo stampare usando:

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

Mettendo tutto questo in uno script:

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

Questo stamperà:

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

Bash moderno

Ma usando la moderna implementazione di bash , puoi archiviare i caratteri di controllo come newline in variabili e persino testarli:

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

Ma se non ti interessa la leggibilità, potresti scrivere una sceneggiatura condensata come:

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

Lo script golf può apparire come:

#!/bin/bash

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

e darà lo stesso effetto: la prima riga divide la stringa e la memorizza in un array chiamato righe . E la seconda riga stamperà ogni membro dell'array '' righe '', seguito da una nuova riga .

bash + console vt

Ma poiché molte persone utilizzano la console di testo basata sullo standard ANSI VT , è possibile utilizzare i comportamenti VT della console e scrivere di nuovo questo breve:

#!/bin/bash

echo $'foo\nbar\nbaz'

darà lo stesso risultato.