Minha tarefa de casa é pegar uma corda e dividi-la em pedaços a cada nova linha. Eu não tenho ideia do que fazer! Por favor ajude!

^{Nota: Esta é uma pergunta de controle de código . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .}

C

Minha tarefa de casa é pegar uma corda e dividi-la em pedaços a cada nova linha. Eu não tenho ideia do que fazer! Por favor ajude!

Problema complicado para uma classe de programação C inicial! Primeiro você precisa entender algumas noções básicas sobre esse assunto complicado.

Uma sequência é uma sequência composta apenas de caracteres . Isso significa que, para que os programadores indiquem uma coisa "invisível" (que não é um espaço, que conta como um personagem), é necessário usar uma sequência especial de caracteres de alguma forma para significar essa coisa invisível.

• No Windows , a nova linha é uma sequência de dois caracteres na sequência: barra invertida n (ou a sequência "\n")

• Nos Macs Linux ou OS / X , é uma sequência de quatro caracteres: barra invertida, n, barra invertida e, em seguida, r: (ou "\n\r").

(Nota histórica interessante: em Macintoshes mais antigos, havia uma sequência diferente de quatro caracteres: "\ r \ n" ... totalmente ao contrário de como o Unix fazia as coisas! A história toma caminhos estranhos.)

Pode parecer que o Linux é mais inútil que o Windows, mas na verdade é uma idéia melhor usar uma sequência mais longa. Como o Windows usa uma sequência tão curta, o tempo de execução do idioma C não pode imprimir as letras reais \nsem usar chamadas especiais do sistema. Geralmente, você pode fazer isso no Linux sem uma chamada do sistema (pode até imprimir \n\ou \n\q... qualquer coisa, menos \n\r). Porém, como C é uma plataforma cruzada, ele aplica o menor denominador comum. Então você sempre estará vendo \nem seu livro.

(Nota: se você está se perguntando como estamos falando \nsem obter novas linhas sempre que o fizermos, o StackOverflow é escrito quase inteiramente em HTML ... não em C. Portanto, é muito mais moderno. Muitos desses aspectos antigos de C são sendo abordado por coisas que você já deve ter ouvido falar, como CLANG e LLVM.)

Mas voltando ao que estamos trabalhando. Vamos imaginar uma string com três peças e duas novas linhas, como:

"foo\nbaz\nbar"

Você pode ver que o comprimento dessa string é 3 + 2 + 3 + 2 + 3 = 13. Portanto, é necessário fazer um buffer de tamanho 13 para isso, e os programadores C sempre adicionam um ao tamanho de suas matrizes para garantir a segurança. Portanto, faça seu buffer e copie a string para ele:

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

Agora, o que você precisa fazer é procurar o padrão de dois caracteres que representa a nova linha. Você não pode procurar apenas uma barra invertida. Como o C é usado bastante para a divisão de cadeias de caracteres, ocorrerá um erro se você tentar. Você pode ver isso se tentar escrever:

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

(Nota: existe uma configuração no compilador para se você estiver escrevendo um programa que apenas procure barras invertidas. Mas isso é extremamente incomum; as barras invertidas são muito raramente usadas, e é por isso que foram escolhidas para esse fim. Não vamos mudar isso ligar.)

Então, vamos fazer o padrão que realmente queremos, assim:

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

Quando queremos comparar duas strings de um certo comprimento, usamos strncmp. Ele compara um certo número de caracteres de uma sequência potencialmente maior e informa se eles correspondem ou não. Então strncmp("\nA", "\nB", 2)retorna 1 (verdadeiro). Isso ocorre mesmo que as strings não sejam inteiramente iguais ao longo de três ... mas porque apenas dois caracteres são necessários.

Então, vamos percorrer nosso buffer, um caractere de cada vez, procurando a correspondência de dois caracteres com o nosso padrão. Sempre que encontrarmos uma sequência de dois caracteres de uma barra invertida seguida por um n, usaremos a chamada de sistema muito especial (ou "syscall") putcpara colocar um tipo especial de caractere: código ASCII 10 , para obter uma nova linha física .

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

A saída deste programa é o resultado desejado ... a string dividida!

foo
baz
bar

\t é para \ trolling ...

Absolutamente incorreto de cima para baixo. No entanto, cheio de bobagens plausíveis que embaralharam informações como o que está no livro ou na Wikipedia. A lógica do programa parece transparente no contexto das informações erradas, mas é completamente enganosa. Mesmo variáveis ​​globais e retornando um código de erro, para uma boa medida ...

...

Obviamente, há apenas um caractere na representação da sequência C da sequência literal da fonte de dois caracteres \n. Mas aumentar um buffer é inofensivo, desde que strlen()seja usado para obter o comprimento real para operar.

...

Tentamos convencer o leitor de que strncmpé uma operação booleana que corresponde (1) ou não (0). Mas, na verdade, ele tem três valores de retorno (-1 correspondendo menos, 0 para igual, 1 para correspondendo maior) . Nosso "padrão" de dois caracteres sendo comparado não é [ \, n], mas sim [ \n, \0] ... captando o terminador nulo implícito. Como essa sequência desliza pela sequência, nunca será maior que uma sequência de dois caracteres com a qual é comparada ... na melhor das hipóteses, será zero se houver uma nova linha final na sequência de entrada.

...

Então, tudo isso faz um loop pela string e imprime um caractere de cada vez. O ramo superior nunca é executado. (Embora você possa fazer isso se sua string tiver \ncódigos inferiores a ele, diga tab ... que pode ser usado para omitir misteriosamente caracteres da saída :-P)

1. Pegue uma tesoura e a corda que deseja dividir.
2. Abra a tesoura.
3. Coloque sua corda entre as lâminas da tesoura.
4. Feche a tesoura.

Parabéns! Sua string agora deve ser dividida. Caso contrário, repita as etapas até que esteja. Se você repetiu as etapas algumas vezes e a corda não estiver até dividir, tente usar uma tesoura mais afiada.

AVISO LEGAL: Eu não sou responsável por qualquer dano aplicado a você durante o processo.

Python

Eu me sinto tão mal que você recebeu uma pergunta tão óbvia como lição de casa. Uma linguagem altamente avançada, como Python, torna isso um simples alinhador duplo:

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

Por favor, vote e aceite.

C

Em C é realmente fácil:

#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

Chame assim:

split("a\nb");

Exemplo de trabalho:

http://codepad.org/GBHdz2MR
Por que é mau:

• Ele se baseia na printffunção de dividir as cordas
• É totalmente incompreensível
• Isso vai confundir quem não entende #define(e até quem entende )

Isso pode ser feito em algumas linhas de código pelo seguinte algoritmo simples:

1. Procure o primeiro caractere de nova linha na string.
2. Anexe a peça até a nova linha em uma lista.
3. Remova a peça até a nova linha da string.
4. Se a cadeia não estiver vazia, avance para o passo 1.

No entanto, isso é um desperdício. Este é essencialmente um algoritmo de busca linear , que possui complexidade de tempo linear (O (n)). Vou mostrar uma técnica mais avançada: pesquisa binária . A pesquisa binária é muito mais eficiente que a pesquisa linear: possui apenas complexidade de tempo logarítmica (O (log (n)). Isso significa que, se o espaço de pesquisa for duas vezes maior, o tempo de pesquisa não dobrará, apenas aumentará em uma quantia fixa!

O código para pesquisa binária é um pouco mais complicado, porque usa as técnicas avançadas de recursão e divisão e conquista . Mas definitivamente vale a pena pelo benefício de desempenho. Se você enviar isso, espero que receba crédito extra.

A essência do algoritmo é esta:

• Corte a corda em duas.
• Com uma chamada recursiva, divida a primeira metade da sequência.
• Com uma chamada recursiva, divida a segunda metade da sequência.
• Coloque as peças da primeira metade juntamente com as peças da segunda metade, e pronto !

Você não especificou uma linguagem, então eu a escrevi em Python. No mundo real, é claro, as pessoas não escrevem em Python - use C ou C ++ (ou melhor ainda, linguagem assembly) para obter um desempenho real. Não se preocupe se você não entender o que todo o código está fazendo - isso é definitivamente algo avançado.

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

É claro que todas as declarações sobre desempenho são falsas. O algoritmo "simples" pode ser linear ou quadrático, dependendo de como você o interpreta. O algoritmo “avançado” é Θ (n × log (n)) (bastante próximo do linear na prática), mas garoto, é a constante multiplicativa alta devido à reconstrução incessante da lista (que a implementação faz um pouco do seu caminho para promover )

O estilo Python, o estilo de comentários, as declarações sobre escolhas de idioma e quase tudo o mais neste post também não refletem minha opinião ou hábitos.

Visual básico

A IOmônada tem uma função para fazer isso!

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

• Usa uso obsoleto std::strstream
• Esforça-se para introduzir um vazamento de memória
• Assume cegamente que 2045 bytes serão suficientes para manter um strstream
• Nomes horríveis
• Uso inconsistente do std::prefixo
• Não funciona para strings const
• Ignora completamente as saturações de buffer
• Inclui a primeira linha de programadores que sabem o que estão fazendo
• Esvazie o corpo sem sequer um comentário
• Indexação para iniciantes

Python 3 (limpo e arrumado)

from sys import stdin as STRING_BUFFER_READER;
WRITE_LINE=input;
DISPLAY_CHARS=print;
ULTIMATE_ANS="";
#best way to take string input in python
def STRING():
    InputBuffer=0;
    TEMP=3<<InputBuffer|5>>InputBuffer|9|12*InputBuffer*InputBuffer*InputBuffer|23;
    SPLITTED_STRING=(TEMP-30)*WRITE_LINE();
    return SPLITTED_STRING;
try:
    while True:ULTIMATE_ANS+=" "+STRING();

except KeyboardInterrupt: DISPLAY_CHARS(ULTIMATE_ANS);

Rubi

Bem, você vê primeiro, você precisa transformá-lo em uma matriz como esta

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

Agora você deve colocar os elementos como strings

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

Ah, também remova a última vírgula

actually_real_arr = real_arr.chop

Opa esqueci, você deve colocar os colchetes para ser uma matriz

definitely_the_real_arr = "[#{actually_real_arr}]"

Agora basta usar a corda e pronto

final_arr = eval(definitely_the_real_arr)

Maldade:

• o óbvio, não usando split
• toneladas de variáveis ​​inúteis com nomes inúteis
• eval
• requer nova linha à direita na sequência de entrada
• não funciona se a string contém 'ou,

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

Exemplo de entrada: "Hello\nworld\nstuff"
Saída:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Ah, e eu esqueci de mencionar que o código é O (n ^ 2)

Node.JS

Isso é tão simples que qualquer programador poderia fazer isso.
Primeiro temos que mudar o hostsarquivo para que .com, .net, .orgmapa para 127.0.0.1.
e o resto é Javascript básico que qualquer noob poderia entender.

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

Lá vai você :)

Rubi

Strings na programação são feitas de Einsteintanium. Como tal, são extremamente difíceis de dividir.
Felizmente para você, eu tenho um doutorado em química e programação, para que eu possa ajudar.
Nós estaremos usando ruby ​​para isso.

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

Isso é mau porque:

• Pobre camarada terá medo de envenenamento por radiação
• A única parte "que ele pode ignorar" é a parte importante
• Intervalos preguiçosos infinitos. Quero dizer, vamos lá!

C ++

Graças aos novos e poderosos recursos da linguagem de programação C ++, isso pode ser resolvido com facilidade usando a biblioteca padrão, lembre-se de não reinventar a roda .

#include <iostream>

// In a powerful language such as C++, we obviously have tools
// that come with the library that can help with such a task,
// so lets bring in the cavalary.
#include <map>
#include <vector>

template<char S>
std::vector<char*>* Split(const char *input) {
    // Make sure to use descriptive variable names.
    int numberOfSplitsInTheInput = 0;

    // We need to find the number of splits to make, so lets count them.
    // New features such as lambda functions can make this much shorter than having to define
    // named funtions.
    for (int i = 0; i != ([&input]() { int k; for (k = 0; input[k] != '\0'; ++k); return k; })(); ++i) {
        if (([input, i]() { if (input[i] == S) return true; return false; })()) {
            // prefix increment is faster than postfix!
            ++numberOfSplitsInTheInput;
        }
    }

    // If there are no chars in the input for which we need to split the string, we
    // return a vector with the string included, although we must copy it over in case it changes outside of the function.
    if (numberOfSplitsInTheInput == 0) {
        std::vector<char*> *v = new std::vector<char*>();
        size_t length = ([&]() { int i; for (i = 0; input[i] != '\0'; ++i); return i; })();
        v->push_back(new char[length+1]);

        // Copy each character.
        for (int i = 0; i != length; ++i) {
            memcpy(&((*v)[0][i]), &input[i], sizeof(char));
        }

        // Don't forget to set the terminating zero
        (*v)[0][length] = '\0';
        return v;
    }

    // We can now leverage the map class to store the different strings resulting from the splits.
    // But first we need to allocate memory for them!
    char **strings = new char*[numberOfSplitsInTheInput];

    std::map<int, char *> splits;

    // Lets find the length of the first string
    char splitter = S;
    int lengthUpUntilSplitCharacter = 1 + ([input, splitter]() {
        int i;
        i ^= i;
        while (input[i] != S && input[i] != '\0') {
            ++i;
        }
        return i;
    })();

    // Now we need to copy the string over, but disregard the actual delimiter.
    strings[0] = new char[lengthUpUntilSplitCharacter - 1];

    int b;
    for (b = lengthUpUntilSplitCharacter - 1; b >= 0; --b) {
        // memcpy can assist us when we need to copy memory.
        memcpy(&(strings[0][b]), &input[b], sizeof(char));
    }

    // Dont forget to add the terminating zero!
    strings[0][lengthUpUntilSplitCharacter - 1] = '\0';

    // Next, insert the string into our map!
    splits.insert(std::make_pair(0, strings[0]));

    // Now we can actually use recursion to solve the problem!
    // This makes it look a bit more clever and shows you truly understand CS.
    std::vector<char*> *result = Split<S>(input + lengthUpUntilSplitCharacter);

    // We already have one string in our map.
    int i = 1;

    // We can now merge the results into our actual map!
    for (std::vector<char*>::iterator it = result->begin(); it != result->end(); ++it) {

        splits.insert(std::make_pair(i++, (*it)));
    }

    // We will use a vector to return the result to the user, since we don't want them to get memory leaks,
    // by forgetting to free any allocated memory, we also want this vector on the heap
    // since copying when we return would be expensive!
    std::vector<char*> *mySplits = new std::vector<char*>(splits.size());

    // Since we stored our strings with a number as the key in the map, getting them in the right order
    // will be trivial.
    int j = 0;
    while (splits.empty() == false) {
        std::map<int, char*>::iterator result = splits.find(j++);

        if (result != splits.end()) {
            int lengthOfString = ([&]() { 
                for (int z = 0; ; ++z) {
                    if (result->second[z] == '\0') return z;
                }
            })();

            (*mySplits)[result->first] = new char[lengthOfString+1];

            // Copy the string into the vector.
            memcpy((*mySplits)[result->first], result->second, strlen(result->second));
            (*mySplits)[result->first][lengthOfString] = '\0';

            splits.erase(result);
        }
    }

    return mySplits;
}



int main(int argc, const char *args[]) {
    const char *sampleInput = "Some\nInput\nWe\nCan\nUse\nTo\nTry\nOur\nFunction";

    std::vector<char*> splits = *Split<'\n'>(sampleInput);

    for (auto it = splits.begin(); it != splits.end(); ++it) {
        std::cout << *it << std::endl;
    }

    system("PAUSE");

    return 42;
}

Edit: Esta resposta, obviamente, apenas tenta criar algo estupidamente complexo para uma tarefa trivial e, ao fazer isso, abusou do máximo de ferramentas possível enquanto ainda conseguia escrever o código.

Aqui estão algumas coisas a serem observadas:

• Os comentários falam sobre a reutilização de código e o uso da biblioteca padrão, std :: string não é usado.
• Para cada instância em que o comprimento de uma sequência precisa ser calculado, um novo lambda é definido.
• Usa modelos sem nenhuma boa razão.
• Usa memcpy para copiar cada letra individual em seqüências de caracteres.
• Vazamentos de memória estão por toda parte, mas comentários sobre vetores apontam a importância de contar com essa classe para evitar vazamentos de memória. Ele também retorna esse vetor por ponteiro para acumular memória.
• Usa a classe map para armazenamento temporário, enquanto a usa como um vetor.
• Provavelmente mais, minha cabeça dói.
• Ah, e a coisa toda é recursiva também.

C #

Isso usa a tecnologia de recursão para transformar as novas linhas em vírgulas. A sequência CSV resultante pode ser facilmente dividida em uma matriz.

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

Parece totalmente crível e didático até a última expressão. É até correto, tente explicar isso ao seu professor.

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

Obviamente, não há justificativa para isso std::for_each, mas isso nos permite usar mal um lambda. Esse lambda parece estar retornando algo, mas na realidade não. O operador ternário está lá apenas para os efeitos colaterais.

Bem! Portanto, esse problema é facilitado pelo uso de alguns recursos pouco conhecidos do python, incluindo instruções #define (recentemente portadas pelo C ++) e pelo registro automático de métodos nas classes internas.

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

Quão legal é isso?

Explicação

... há uma lista bastante grande de corrico aqui.

1. As instruções #define não existem em python!
2. Eles especialmente não registram métodos nas classes internas automaticamente.
3. out é "preguiçosamente instanciado" - o que realmente não significa nada útil.
4. A função fornecida incluiria o separador no resultado.
5. A função fornecida não incluiria o elemento final do resultado.
6. No entanto, apesar do operador ~ ser composto nesse contexto, ~ 0 é -1, o que significa que a linha realmente funcionaria.
7. Os retornos estão confusos. O local real que ele retornaria apenas retorna sem um valor.
8. O bug # 20221 é um bug python real com "#define" no nome - mas não tem nada a ver com isso.
9. A linha de entrada pode ser apenas uma única linha ... e apenas dividir isso é bastante inútil, pois não pode incluir novas linhas.
10. O uso de sys.stdout.write (str (x)) em vez de print (x) é uma maneira ruim de fazer as coisas.
11. "Máquina virtual Python" é um conceito inventado neste caso. (Também "método de classe" seria um método estático, não um método de instância, portanto essa parte também está errada)

Na verdade, o programa funciona (pelo menos no Python 3.3.0, e além do problema de entrada de linha única), já que várias coisas que fazem com que ele não faça o que diz se combinam para fazê-lo realmente funcionar.

Objetivo LOLCODE

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

ANSI C

Essa é uma tarefa padrão que todos nós fizemos. Esta é a solição geralmente aceita.

#include <stdio.h>

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

Você precisa incluir a biblioteca com a função correta para dividir e imprimir. #include <stdio.h>

Crie a string que você deseja dividir: const char * input = "First Line\nSecond Line\nThird Line\n";Observe como usei a constpalavra-chave para ilustrar que printf não tem como alterar sua entrada. Isso é importante, pois você sempre deseja preservar a entrada do usuário em sua forma original para fins legais.

printf("%s", input); faz a divisão para você, como você pode ver na saída do console.

getchar(); é apenas um pequeno truque extra para manter o console persistente enquanto você inspeciona a saída.

A entrada: "First Line\nSecond Line\nThird Line\n"

Cria a saída:

First Line
Second Line
Third Line

Python

Podemos usar iterativamente o find()método de string do Python para dividir a string em cada nova instância de linha (observe que a string de entrada é codificada como input_str, mas pode ser substituída por 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

Executando o script acima, obtemos a saída esperada (observe que os espaços em branco à esquerda e à direita são consistentes com a divisão da string a cada nova ocorrência de linha):

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

PHP / GD

A divisão de strings é uma questão muito complicada. Embora tenhamos feito uma implementação bastante básica para esta questão tão importante da lição de casa.

É executado sem dependências em uma versão recente do PHP: Quantidade de exemplos limitados no código publicado, pois temos um limite de caracteres de cerca de 40.000 caracteres aqui que não se encaixa em uma quantidade razoável de seqüências de demonstração.

Versão de exemplo:

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

Confirma exatamente suas especificações.

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

Eu não quero ser mau, então aqui está um pedaço de código Python que divide sua string em pedaços. No entanto, como você não especificou onde deseja que ela seja dividida, selecionarei locais aleatórios. Espero que esteja tudo bem com você.

Python

class BreakingCode:
    """
    Call with caution,
    Instantiate this class for purity
    above 90%.
    """
    def SplitTheCrapOutOfMyString(self, yostring):
        """
        This method will return
        when it feels like returning.
        """
        print "Hey, how'you doin?"    # Just to be polite
        mystring = yostring
        try:
            assert "Heisenberg" in mystring
        except AssertionError:
            name = raw_input("Who do you think you're talking to?\n>>>")
            if name.startswith("H"):
                print "Yo, Mr.White"
        else:
            print "I'm the one who knocks"
        for eachword in mystring.split():
            print "{:_^40}".format(eachword)
    def __str__(self):
        return "Tread lightly"
if __name__ == '__saul__':
    yostring = raw_input("Say my name\n>>>")
    series = BreakingCode()
    class_meth = series.SplitTheCrapOutOfMyString(yostring)
    input()

Para idiomas que oferecem suporte à expressão regular e tem splitfunção prontamente disponível, você deve sempre usá-lo para dividir uma string. Isso ajuda a evitar a reinvenção da roda e a manter seu código curto e agradável. O uso de expressão regular também permite portar seu código para outro idioma sem alterar sua expressão regular.

Solução ruim

Existe esta solução óbvia em que você divide \nou \r\n:

Java

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

PHP

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

Essa solução é lixo e nunca deve ser usada. Hoje em dia, é inútil evitar o Unicode, mas todo programador deve adotá-lo e garantir que seu aplicativo esteja pronto para Unicode. Se você considera apenas \nou \r\ncomo um novo separador de linhas, está escrevendo um software nos anos 90. Nesta era Unicode, você deve considerar U + 0085, U + 2028, U + 2029 como separador de linha válido. Como o Unicode é atualizado de vez em quando, e geralmente leva algum tempo para você perceber que foi atualizado, pode haver um novo separador de linhas adicionado ao Unicode. Não se preocupe, porque todos os mecanismos de expressão regular estão prontos para Unicode e são atualizados regularmente para estar em conformidade com o padrão Unicode mais recente. Portanto, se você estiver usando uma linguagem interpretada, seu código estará atualizado sem você fazer nada.

Solução recomendada

Para dividir uma sequência pelo terminador de linha e manter-se atualizado com a evolução do Unicode, forneça o regex ^e especifique o MULTILINEmodo.

Por padrão, ^corresponde apenas ao início da string. No MULTILINEmodo, ^ também corresponde ao início da linha, ou seja, após um terminador de linha.

Por exemplo:

Java

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

PHP

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

Observe que há uma entrada de seqüência vazia extra na frente, basta removê-la ou fazer um loop do índice 1.

Explicação

À primeira vista, isso parece uma boa resposta com uma solução (um tanto) funcional, juntamente com uma explicação com algumas recomendações de práticas recomendadas de codificação. No entanto, a solução em si é um troll ( "Eu sei, usarei expressões regulares." Agora eles têm dois problemas. ), E todo o post está repleto de informações sutilmente erradas, o que envenenará qualquer iniciante em programação.

• Diferentes mecanismos regex suportam diferentes conjuntos de recursos. Se o mecanismo de destino não tiver o recurso que você usa no seu regex, a portabilidade do código não é tão simples quanto copiar e colar. Pode ser possível simular com os recursos suportados, ou pode ser impossível fazê-lo apenas com regex.
• Existem 2 tipos de mecanismos : mecanismo direcionado a texto (baseado em autômato) e mecanismo orientado a regex (retorno). O primeiro retorna a string mais longa à esquerda, o último retorna a string com tendência à esquerda (com tendência para a ordem de exploração, especificada pelo regex). O mesmo regex pode produzir resultados diferentes nos 2 tipos de motores.
• Mesmo para o mesmo recurso, um mecanismo de regex diferente pode ter sintaxe diferente para especificá-lo.
• Mesmo para o mesmo recurso e a mesma sintaxe, diferentes mecanismos de expressão regular podem ter algum comportamento diferente na análise e na correspondência. Erros à parte, a diferença pode vir do design do mecanismo regex (pode ou não pode ser documentado).
• No MULTILINEmodo, o comportamento de ^e $depende da definição de "terminador de linha". Java considera \r\n, \n, \r, \u0085, \u2028, \u2029para ser terminador de linha, onde \r\nseqüência é considerada atômica. JavaScript considera \n, \r, \u2028, \u2029para ser terminadores de linha. Ruby considera apenas o \nterminador de linha.
• splitA função pode ter semântica diferente em idiomas diferentes para casos de canto. O Python não se divide em correspondências vazias, o Java remove seqüências de caracteres vazias à direita (a menos que você especifique um limite negativo), o JavaScript não se divide em uma correspondência de sequência vazia no índice 0.
• A "solução ruim" é mais portátil do que a "solução recomendada". No entanto, o que deve ser considerado um terminador de linha depende da especificação do que você estiver trabalhando (por exemplo, código-fonte C).
• Atualmente, a maioria dos mecanismos de regex nem está em conformidade com o suporte Unicode de nível 1 . Eles podem ter propriedades e blocos Unicode, mas a implementação da seção Limite de Linha está em todo o lugar, conforme explicado acima. O JavaScript nem mesmo suporta propriedades de caracteres Unicode!

Script Bash

new_string=`echo $string`

Isso divide a string por novas linhas. Se você repetir $new_string, notará que ela substituiu a nova linha nos separadores de matriz.

Saída de amostra:

[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

Isso não lê de um arquivo. Expressões regulares são usadas. O código assume que a string lida possui o caractere '\ n' para indicar a nova linha. Os números 1,2,3,4 são usados ​​para indicar a divisão.

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

Você não especifica se a "nova linha" na qual deseja dividir sua sequência é sensível a maiúsculas ou minúsculas. Eu assumo insensível.

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

  }
}

Cara, isso é super fácil de fazer em Powershell.

Apenas pegue sua string assim:

$string = "Helloworld!"

Em seguida, faça um loop sobre ascii aleatórios até que sua string seja dividida em duas como esta:

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

eventualmente, você deve obter a cadeia de caracteres dividida, que você pode gerar assim:

Write-Host $new_string

Saída:

Olá Mundo!

Php

<? Spliter($yourstring); ?>

Aqui está como você divide a string. Não foi tão fácil?

Tudo o que você precisa fazer agora é escrever a função Spliter()

bash específico

Há um ótimo trabalho para o bash !

Sim, a divisão de strings poderia ser feita de maneira realmente simples:

string=$'foo\nbar\nbaz'

Primeiro, você precisa inicializar uma variável que usará para armazenar seu resultado dividido:

declare -a lines

Agora, como cada linha é delimitada por dois do separador, início ou fim da string, você precisará de uma variável para armazenar a primeira

limitA=0

Ok, agora você pode procurar o separador e armazenar suas linhas usando um loop . Como o bash não pode funcionar com valor binário, você pode usar a ferramenta como odpara trabalhar com valores hexadecimais, como exemplo:

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

Agora, temos uma string dividida armazenada na variável lines:

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

Que poderíamos imprimir usando:

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

Colocando tudo isso em um 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

Isso imprimirá:

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

Festa moderna

Mas, usando a implementação moderna do bash , você pode armazenar caracteres de controle como newline em variáveis ​​e até testá-los:

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

Mas se você não se importa com a legibilidade, pode escrever um script condensado como:

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

O script golfed pode aparecer como:

#!/bin/bash

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

e dará o mesmo efeito: A primeira linha divide a sequência e as armazena em uma matriz denominada linhas . E a segunda linha imprimirá cada membro da matriz '' linhas '', seguido por uma nova linha .

console bash + vt

Porém, como muitas pessoas usam o console de texto com base no padrão ANSI VT , você pode usar os comportamentos de VT do seu console e escrever isso mais rapidamente novamente:

#!/bin/bash

echo $'foo\nbar\nbaz'

dará o mesmo resultado.