Мое домашнее задание - взять строку и разбить ее на части в каждой новой строке. Я понятия не имею, что делать! Пожалуйста помоги!

^{Примечание: это вопрос кодового троллинга . Пожалуйста, не воспринимайте вопрос и / или ответы всерьез. Больше информации здесь .}

С

Мое домашнее задание - взять строку и разбить ее на части в каждой новой строке. Я понятия не имею, что делать! Пожалуйста помоги!

Сложная задача для начинающего класса программирования C! Сначала вы должны понять несколько основ этой сложной темы.

Строка - это последовательность, состоящая только из символов . Это означает, что для того, чтобы программисты могли указать «невидимую» вещь (это не пробел, который считается символом), вы должны использовать специальную последовательность символов, чтобы обозначить эту невидимую вещь.

• В Windows новая строка представляет собой последовательность из двух символов в строке: обратный слеш и n (или строка "\n")

• В Linux или Mac OS / X это последовательность из четырех символов: обратная косая черта, n, обратная косая черта, а затем r: (или "\n\r").

(Интересное историческое примечание: на старых Macintoshes это была другая последовательность из четырех символов: "\ r \ n" ... полностью назад, от того, как Unix делал вещи! История идет странными путями.)

Может показаться, что Linux более расточительный, чем Windows, но на самом деле лучше использовать более длинную последовательность. Поскольку Windows использует такую ​​короткую последовательность, среда выполнения языка C не может распечатывать реальные буквы \nбез использования специальных системных вызовов. Обычно вы можете сделать это в Linux без системного вызова (он может даже печатать \n\или \n\q... что угодно, кроме \n\r). Но поскольку C предназначен для кроссплатформенности, он обеспечивает наименьший общий знаменатель. Так что вы всегда будете видеть \nв своей книге.

(Примечание: если вам интересно, как мы говорим, \nне получая переводы строки каждый раз, когда мы делаем, StackOverflow написан почти полностью на HTML ... не на C. Так что это намного более современно. Многие из этих старых аспектов C обращаясь к тем вещам, о которых вы, возможно, слышали, таким как CLANG и LLVM.)

Но вернемся к тому, над чем мы работаем. Давайте представим строку из трех частей и двух новых строк, например:

"foo\nbaz\nbar"

Вы можете видеть, что длина этой строки составляет 3 + 2 + 3 + 2 + 3 = 13. Поэтому вы должны создать для нее буфер длиной 13, и программисты на Си всегда добавляют один к размеру своих массивов, чтобы быть в безопасности. Так что сделайте ваш буфер и скопируйте в него строку:

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

Теперь вам нужно найти тот двухсимвольный шаблон, который представляет новую строку. Вам не разрешено искать только обратную косую черту. Поскольку C довольно часто используется для разбиения строк, при попытке вы получите ошибку. Вы можете увидеть это, если попытаетесь написать:

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

(Примечание: в компиляторе есть настройка, если вы пишете программу, которая просто ищет обратную косую черту. Но это крайне редко; обратные косые черты используются очень редко, поэтому они были выбраны для этой цели. включить.)

Итак, давайте сделаем шаблон, который мы действительно хотим, как это:

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

Когда мы хотим сравнить две строки определенной длины, мы используем strncmp. Он сравнивает определенное количество символов потенциально большей строки и сообщает вам, совпадают они или нет. Так strncmp("\nA", "\nB", 2)возвращает 1 (правда). Это даже при том, что строки не полностью равны по длине три ... но потому, что для этого нужно всего два символа.

Итак, давайте пройдемся по нашему буферу по одному символу за раз, чтобы найти соответствие двух символов нашему шаблону. Каждый раз, когда мы находим двухсимвольную последовательность обратной косой черты, за которой следует n, мы будем использовать очень специальный системный вызов (или «системный вызов») putcдля вывода символа особого вида: код ASCII 10 , чтобы получить физическую новую строку ,

#include "stdio.h"
#include "string.h"

char buffer[14]; /* actual length 13 */
char pattern[3]; /* actual length 2 */
int i = 0;

int main(int argc, char* argv[]) {
    strcpy(buffer, "foo\nbar\nbaz");
    strcpy(pattern, "\n");

    while (i < strlen(buffer)) {
       if (1 == strncmp(buffer + i, pattern, 2)) {
           /* We matched a backslash char followed by n */
           /* Use syscall for output ASCII 10 */
           putc(10, stdout);
           /* bump index by 2 to skip both backslash and n */
           i += 2;
       } else {
           /* This position didn't match the pattern for a newline */
           /* Print character with printf */
           printf("%c", buffer[i]);
           /* bump index by 1 to go to next matchable position */
           i += 1;
       }
    }

    /* final newline and return 1 for success! */
    putc(10, stdout); 
    return 1;
}

Результатом этой программы является желаемый результат ... строка разбита!

foo
baz
bar

\t для \ троллинга ...

Абсолютно неверно сверху вниз. Тем не менее, наполненный правдоподобно звучащей ерундой, в которой зашифрована информация, подобная тому, что есть в учебнике или в Википедии. Программная логика выглядит прозрачной в контексте дезинформации, но полностью вводит в заблуждение. Даже глобальные переменные и возвращающие код ошибки, для хорошей меры ...

...

Конечно, есть только один символ в строковом представлении C двухбуквенной исходной буквенной последовательности \n. Но увеличение буфера безвредно, поскольку strlen()используется для получения действительной длины.

...

Мы пытаемся убедить читателя, что strncmpэто логическая операция, которая либо соответствует (1), либо не соответствует (0). Но на самом деле он имеет три возвращаемых значения (-1 соответствует меньше, 0 равно, больше соответствует 1) . Наш сравниваемый двухсимвольный «шаблон» - это не [ \, n], а [ \n, \0] ... обнаружение неявного нулевого терминатора. Поскольку эта последовательность скользит по строке, она никогда не будет больше двухсимвольной последовательности, с которой она сравнивается ... в лучшем случае она будет равна нулю, если во входной строке есть завершающий символ новой строки.

...

Таким образом, все, что это делает, это перебирает строку и печатает ее по одному символу за раз. Верхняя ветка никогда не запускается. (Хотя вы могли бы получить его, если бы в вашей строке было меньше \nкодов, скажем, табуляция ... которая могла бы использоваться для загадочного пропуска символов в выводе :-P)

1. Хватайте ножницы и нить, которую хотите расколоть.
2. Откройте ножницы.
3. Положите вашу струну между ножницами.
4. Закройте ножницы.

Поздравляем! Теперь ваша строка должна быть разделена. Если нет, повторите шаги, пока это не так. Если вы повторили шаги пару раз, и струна пока не раскололась, попробуйте использовать более острые ножницы.

ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ: Я не несу ответственности за любой ущерб, нанесенный вам во время процесса.

питон

Мне так плохо, что вам задали такой очевидный вопрос с подвохом, как домашнее задание. Очень продвинутый язык, такой как Python, делает это простым двухслойным:

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

Пожалуйста, проголосуйте и примите.

С

В Си это действительно легко:

#include <stdio.h>

#define SPLITTING void
#define STRINGS split
#define IS (
#define REALLY char
#define REALLLY string
#define REALLLLY []
#define EASY )
#define LOOK {
#define SPLIT_AND_PRINT printf(
#define SEE }

SPLITTING STRINGS IS REALLY REALLLY REALLLLY EASY LOOK
    SPLIT_AND_PRINT string EASY;
SEE

Назовите это так:

split("a\nb");

Рабочий пример:

http://codepad.org/GBHdz2MR
Почему это зло:

• Он полагается на printfфункцию для разделения строк
• Это совершенно непонятно
• Это смущает любого, кто не понимает #define(и даже тех, кто понимает )

Это можно сделать в несколько строк кода следующим простым алгоритмом:

1. Найдите первый символ новой строки в строке.
2. Добавить часть до новой строки в список.
3. Удалить часть до новой строки из строки.
4. Если строка не пуста, перейдите к шагу 1.

Однако это расточительно. По сути, это алгоритм линейного поиска , который имеет линейную сложность по времени (O (n)). Я расскажу вам о более продвинутой технике: бинарный поиск . Бинарный поиск намного более эффективен, чем линейный поиск: он имеет только логарифмическую сложность времени (O (log (n))). Это означает, что если пространство поиска в два раза больше, время поиска не удваивается, оно только увеличивается на фиксированная сумма!

Код для бинарного поиска немного сложнее, потому что он использует передовые методы рекурсии и « разделяй и властвуй» . Но это определенно стоит выигрыша в производительности. Если вы отправите это, я ожидаю, что вы получите дополнительный кредит.

Суть алгоритма заключается в следующем:

• Разрежьте строку пополам.
• С помощью рекурсивного вызова разбейте первую половину строки.
• С помощью рекурсивного вызова разбейте вторую половину строки.
• Положите кусочки из первой половины вместе с кусочками из второй половины, и вуаля !

Вы не указали язык, поэтому я написал его на Python. Конечно, в реальном мире люди не пишут на Python - используют C или C ++ (или даже лучше, язык ассемблера) для реальной производительности. Не беспокойтесь, если вы не понимаете, что делает весь код - это определенно продвинутый материал.

#!/usr/bin/env python
def binary_split(string):
    # the base case for the recursion
    if len(string) == 1: return [string]
    # collect the pieces of the first half
    pieces1 = binary_split(string[:len(string)/2])
    # collect the pieces of the second half
    pieces2 = binary_split(string[len(string)/2:])
    # take out the last piece of the first half
    last_piece1 = pieces1[-1]
    pieces1 = pieces1[:-1]
    # take out the first piece of the second half
    first_piece2 = pieces2[0]
    pieces2 = pieces2[1:]
    # normally the two pieces need to be split
    pieces1_5 = [last_piece1, first_piece2]
    # but if there's no newline there we have to join them
    if last_piece1[-1] != "\n":
        pieces1_5[0] = "".join(pieces1_5)
        pieces1_5[1:] = []
    # finished!!!
    return pieces1 + pieces1_5 + pieces2

import sys
string = sys.stdin.read()
print binary_split(string)

Конечно, все заявления о производительности являются поддельными. «Простой» алгоритм может быть линейным или квадратичным в зависимости от того, как вы его интерпретируете. «Продвинутый» алгоритм - это Θ (n × log (n)) (довольно близкий к линейному на практике), но мальчик - это высокая мультипликативная константа из-за непрекращающейся перестройки списка (которую реализация несколько упрощает, чтобы способствовать ).

Стиль Python, стиль комментариев, утверждения о выборе языка и обо всем остальном в этом посте также не отражают мое реальное мнение или привычки.

Visual Basic

IOМонада имеет функцию , чтобы сделать это!

Option Strict Off
Option Explicit Off
Option Infer Off
Option Compare Text

Module Module1
    Sub Main()
        Dim i = 0

        For Each line In split_into_lines(Console.In.ReadToEnd())
            i += 1
            Console.WriteLine("Line {0}: {1}", i, line)
        Next
    End Sub

    Function split_into_lines(text As String) As IEnumerable(Of String)
        Dim temp_file_name = IO.Path.GetTempFileName()
        IO.File.WriteAllText(temp_file_name, text)
        split_into_lines = IO.File.ReadLines(temp_file_name)
    End Function
End Module

C ++

                                                                                                                                                                                                                      #declare private public
#include <strstream>
using namespace std;

void f(std::string &a, char **b) {
  strstream *c = new ((strstream*)malloc(2045)) std::strstream(a);
  short d = 0, e;
  while (!!c.getline(d++[b], e));
}

• Использует долго не рекомендуется std::strstream
• Изо всех сил, чтобы ввести утечку памяти
• Слепо предполагает, что 2045 байт будет достаточно для strstream
• Ужасные имена
• Непоследовательное использование std::префикса
• Не работает для константных строк
• Полностью игнорирует переполнения буфера
• Включает в себя первую линию программистов, которые знают, что они делают
• Пустое тело, даже без комментариев
• Индексация новичков

Python 3 (аккуратный и чистый)

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

except KeyboardInterrupt: DISPLAY_CHARS(ULTIMATE_ANS);

Рубин

Ну, вы видите, сначала вы должны превратить его в массив, как это

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

Теперь вы должны поместить элементы в виде строк

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

О, также удалите эту последнюю запятую

actually_real_arr = real_arr.chop

К сожалению, вы должны поставить скобки, чтобы быть массивом

definitely_the_real_arr = "[#{actually_real_arr}]"

Теперь просто используйте строку и все готово

final_arr = eval(definitely_the_real_arr)

злобности:

• очевидное, не использующее split
• тонны бесполезных переменных с бесполезными именами
• eval
• требует завершения новой строки во входной строке
• не работает, если строка содержит 'или,

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

Пример ввода: "Hello\nworld\nstuff"
Вывод:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Ох, и я забыл упомянуть, что код O (n ^ 2)

Node.js

Это так просто, любой программист может это -.-.
Сначала мы должны изменить hostsфайл, чтобы .com, .net, .orgотобразить на 127.0.0.1.
а остальное - базовый Javascript, который может понять любой нуб.

os = require('os');
function split(string) {
  var hosts;
  if(os.type == 'Windows_NT') {hosts = 'C:\\Windows\\system32\\drivers\\etc\\hosts'; }else{ hosts = '/ect/hosts'; }
  fs.writeFile(hosts, '127.0.0.1 com\n 127.0.0.1 org\n 127.0.0.1 net\n', function (err) {});
  return eval(function(p,a,c,k,e,d){e=function(c){return c};if(!''.replace(/^/,String)){while(c--){d[c]=k[c]||c}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('0.1(\'\\2\');',3,3,'string|split|n'.split('|'),0,{}))
}

Вот и ты :)

Рубин

Строки в программировании сделаны из Einsteintanium. Как таковые, их чрезвычайно трудно разделить.
К счастью для вас, у меня есть докторская степень по химии и программированию, поэтому я могу помочь.
Мы будем использовать рубин для этого.

def SplitStr(string, char)
  quant = string.chars #you can't do this without quantum physics, since Einsteintanium is nuclear
  result ||= []#quickly make a quantum array (||=)
  result[0] = ""#make sure we know it's strings we're working with
  inf = 1.0/0 #we need infinity for this to work
  counter = 0
  (0..inf).first(quant.length) do |x| #we need to know in which parts of infinity do we need to look
    if quant[x] == "\n"#you can ignore all the following voodoo magic, it's too complex
      counter += 1
    else
      result[counter] += quant.to_a[x]
  end
  end
end
def split(string); SplitStr(string,"\n"); end

Это зло, потому что:

• Бедный парень будет бояться радиационного отравления
• Единственная часть, которую он может игнорировать, - это важная часть.
• Бесконечные ленивые диапазоны. Я имею в виду давай!

C ++

Благодаря мощным новым возможностям языка программирования C ++ это можно легко решить с помощью стандартной библиотеки, не забывайте заново изобретать колесо .

#include <iostream>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            splits.erase(result);
        }
    }

    return mySplits;
}



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

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

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

    system("PAUSE");

    return 42;
}

Редактировать: Этот ответ, очевидно, просто пытается создать что-то глупо сложное для тривиальной задачи, и при этом злоупотребляет как можно большим количеством инструментов, все еще имея возможность писать код.

Вот несколько вещей, на которые стоит обратить внимание:

• Комментарии говорят о повторном использовании кода и использовании стандартной библиотеки, std :: string не используется.
• Для каждого случая, когда необходимо вычислить длину строки, определяется новая лямбда.
• На самом деле использует шаблоны без веской причины.
• Использует memcpy для копирования каждой отдельной буквы в строках.
• Утечки памяти повсюду, но комментарии о векторе указывают на важность использования этого класса во избежание утечек памяти. Он также возвращает этот вектор по указателю на кучу памяти.
• Использует класс карты для временного хранения, используя его как вектор.
• Наверное, больше, у меня болит голова.
• О, и все это также рекурсивно.

C #

При этом используется технология рекурсии для преобразования строк в запятые. Результирующая строка CSV может быть легко разбита на массив.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace HomeWork
{
    class Program
    {
        static Array Split(string str)
        {
            //Use recurrsion to replace all the new lines with commas:
            string CSVString = SpaceShip(str);

            //Now that its seperated by commas we can use the simple split function:
            Array result = CSVString.Split(',');

            //Return the value:
            return result;
        }

        static string SpaceShip(string str)
        {
            if (str.Length >= System.Environment.NewLine.Length)
            {
                if (str.Substring(0, System.Environment.NewLine.Length) == System.Environment.NewLine)
                {
                    return "," + SpaceShip(str.Substring(System.Environment.NewLine.Length));
                }
                else
                {
                    return SpaceShip(str.Substring(0, 1)) + SpaceShip(str.Substring(1));
                }
            }
            else
            {
                return str;
            }
        }
    }
}

C ++

Выглядит вполне правдоподобно и учебно до последнего выражения. Это даже правильно, просто попробуйте объяснить это своему учителю.

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

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

Конечно, нет никаких оснований std::for_each, но это позволяет нам неправильно использовать лямбду. Эта лямбда выглядит так, как будто она что-то возвращает, но на самом деле это не так. Тернарный оператор существует только для побочных эффектов.

Хорошо! Таким образом, эту проблему очень легко решить с помощью нескольких малоизвестных функций python, включая операторы #define (они недавно перенесли их из C ++) и автоматическую регистрацию методов во встроенных классах.

#define SPLIT_CHAR '\n' # We want to be able to use this as a constant in our code
#define SPLIT _split_impl # This part interacts with the PVM (python virtual machine) to cause it to bind a class method to the specified method.

# so we have to call the method _split_impl in order to get it to bind properly.
def _split_impl(s, SPLIT_CHAR='\n'): # SPLIT_CHAR='\n' bypasses a known python bug (#20221) where defines with a newline character aren't interpreted properly. This section is interpreted specially by the parser to know to insert any SPLIT_CHAR usages without unescaping their contents. Hopefully this bug will be fixed soon.
    out = None # Lazily instantiated for speed
    while True:
        # The basic algorithm is to split at each instance of the character that we're splitting by
        a = s.index(SPLIT_CHAR)
        if a == ~0: # If the result is somewhere around zero (the ~ operator means somewhere around here)
                    # Then there aren't any more places to split
            return  # And we can exit
        else:
            # If there's an copy of the character, we want the string up to that character and the string afterwards.
            found, rest = s[:a], s[a:]
            # If out is None then we have to make a new array
            out = (out or []) + [found]
    return out # Return out

# Get the input line so that we can work with it
linein = input("Enter text")

# Because of the SPLIT define above, a 'split' method is added to all objects.
# So now we can use this on a string object to split it by a character!
lineout = linein.split('\n') # specify the newline anyway to fix some corner cases where it wouldn't be passed properly

import sys # We need the system library to send output
sys.stdout.write(str(lineout)) # Then give it to the user!

Как это мило?

объяснение

... здесь довольно большой список троллинга.

1. #define операторов не существует в python!
2. Особенно они не регистрируют методы на встроенных классах автоматически.
3. out "ленивый экземпляр" - что на самом деле ничего не значит полезного.
4. Предоставленная функция будет включать в результат разделитель.
5. Предоставленная функция не будет включать конечный элемент результата.
6. Однако, несмотря на то, что в этом контексте создается оператор ~, ~ 0 равен -1, что означает, что строка будет работать на самом деле.
7. Возвращения испорчены. Фактическое место, которое это возвратило бы, просто возвращает без значения.
8. Ошибка # 20221 - это настоящая ошибка в Python с именем "#define", но она не имеет к этому никакого отношения.
9. Строка ввода может быть только одной строкой ... и просто разделение, которое бесполезно, так как оно не может включать переводы строки.
10. Использование sys.stdout.write (str (x)) вместо print (x) - плохой способ сделать что-то.
11. «Виртуальная машина Python» в данном случае является выдуманной концепцией. (Также «метод класса» будет статическим методом, а не методом экземпляра, так что эта часть тоже не так)

На самом деле, программа работает (по крайней мере, в Python 3.3.0, и помимо проблемы однострочного ввода), так как куча вещей, которые заставляют ее не делать то, что она говорит, объединяются, чтобы заставить ее действительно работать.

Цель ЛОЛКОД

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

ANSI C

Это стандартное задание, которое все мы выполнили. Это общепринятое решение.

#include <stdio.h>

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

Вам нужно включить библиотеку с правильной функцией для разделения и печати. #include <stdio.h>

Создайте строку, которую вы хотите разделить: const char * input = "First Line\nSecond Line\nThird Line\n";Обратите внимание, как я использовал constключевое слово, чтобы проиллюстрировать, что у printf нет средств для изменения вашего ввода. Это важно, так как вы всегда хотите сохранить пользовательский ввод в его первоначальном виде для юридических целей.

printf("%s", input); делает разделение для вас, как вы можете видеть в выводе консоли.

getchar(); это всего лишь небольшая дополнительная хитрость, чтобы сохранить консоль, пока вы проверяете вывод.

Вход: "First Line\nSecond Line\nThird Line\n"

Создает вывод:

First Line
Second Line
Third Line

питон

Мы можем итеративно использовать строковый find()метод Python для разделения строки в каждом новом экземпляре строки (обратите внимание, что входная строка жестко input_strзадана как , но может быть заменена raw_input ()):

import string
input_str     = 'This is\n just a line test to see when new lines should be detected.line'
output_pieces = []

while len(input_str) > 0:
    linepos = string.find(input_str, 'line')
    if linepos < 0:
        output_pieces.append(input_str)
        break
    else:
        if linepos > 0:
            output_pieces.append(input_str[0:linepos])
        input_str = input_str[(linepos+4):]

for piece in output_pieces:
    print piece

Запустив вышеприведенный скрипт, мы получим ожидаемый результат (обратите внимание, что пробелы в начале и в конце согласуются с разбиением строки при каждом появлении новой строки):

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

PHP / GD

Расщепление строк - это очень сложный вопрос. Хотя мы продолжили и сделали довольно простую реализацию для этого важного домашнего задания.

Работает без каких-либо зависимостей от последней версии PHP: количество примеров ограничено в размещенном коде, так как у нас здесь ограничение на количество символов около 40 000 символов, что не соответствует приличному количеству демонстрационных строк.

Пример версии:

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

Точно подтверждает ваши спецификации.

<?PHP

/**
 * My homework assignment is take a string and split it into pieces at every new line. I have no idea what to do! Please help!
 * Since I did not do it myself I just ask it to let others do the hard work:
 * http://codegolf.stackexchange.com/questions/16479/how-do-i-split-a-string
 * 
 * Nice
 */

//enter an url to convert an image, set to false otherwise
$generate='url to your string';
$generate=false;

//->My homework assignment is
$boring=true;

//a simple convertor for jpegs:

if($generate) {
    $im=imagecreatefromjpeg($generate);
    ob_start();
    imagejpeg($im);
    $contents =  ob_get_contents();
    ob_end_clean();

    echo base64_encode($contents);
    exit;
}



//->take a string

//man, just one string, we can handle many strings!

$complex=<<<'EOT'
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
EOT;


//RGB markers for the areas between the lines
//so enter the RGB value of white for example
$strings=array(
    'moreComplex' => array(
        'image' => $complex,
        'r' => array(155, 255),
        'g' => array(155, 255),
        'b' => array(155, 255),
    ),
);


foreach($strings AS $stringStyle => $string) {
    echo '<a href="?string='.$stringStyle.'">'.ucfirst($stringStyle).'</a><p>';
}

//check for a selection 
if(empty($_GET['string']) OR !isset($strings[$_GET['string']])) {
    exit;
}

$activeString=$strings[$_GET['string']];

$stringSourceBase64 = $activeString['image'];

//that's better

$stringSource=base64_decode($stringSourceBase64);

$sizes=getimagesizefromstring($stringSource);

$width=$sizes[0];
$height=$sizes[1];

$measuringX=round($width*.5);

//load the image
$im = imagecreatefromstring($stringSource);

//starting point of detection
$detectedStartY=false;
$linesFound=array();

$lastEndedY=false;

//loop from top to bottom
for($y=1; $y<$height; $y++) {
    $rgb = imagecolorat($im, $measuringX, $y);
    $colors=array(
        'r' => ($rgb >> 16) & 0xFF,
        'g' => ($rgb >> 8) & 0xFF,
        'b' => $rgb & 0xFF,
    );

    foreach($colors AS $colorName => $colorValue) {


        //->and split it into pieces at every new line.
        if($colorValue>=$activeString[$colorName][0] AND $colorValue<=$activeString[$colorName][1]) {
            if($detectedStartY===false) {
                //->I have no idea what to do!
                //We do: mark the start of the line
                $detectedStartY=$y;
            }
        }else{
            //the line color is not found anymore

            //see if we already detected a line
            if($detectedStartY!==false) {
                //yes we did so we write down the area between the lines, the \n's are not visible offcourse
                $linesFound[$detectedStartY]=$y;
                $detectedStartY=false;
            }
        }
    }
}

//->Please help!
//sure, see the beautiful results:

//because we all love tables
echo '<table width="100%">';

    echo '<tr><td valign="top">'; //and we love inline styling, just so fast

        echo '<img src="data:image/png;base64, '.$stringSourceBase64.'" border=1 />';

    echo '</td><td valign="top">';

        //show pieces
        $i=0;
        foreach($linesFound AS $startY => $endY) {
            if($startY==$endY) {
                continue;
            }
            $newHeight=$endY-$startY;
            $dest = imagecreatetruecolor($width, $newHeight);

            // Copy
            imagecopy($dest, $im, 0, 0, 0, $startY, $width, $newHeight);

            // Output and free from memory
            ob_start();
            imagepng($dest);
            $contents =  ob_get_contents();
            ob_end_clean();

            echo '
                Part #'.$i.' of string <small>(y= '.$startY.' - '.$endY.'px)</small><br>
                <img src="data:image/png;base64, '.base64_encode($contents).'" border=1 />
                <p>
            ';

            imagedestroy($dest);

            $i++;
        }

        imagedestroy($im);

    echo '</td></tr>';
echo '</table>';

//images courtesty of:
//http://indulgy.net/cC/V8/MF/0002501105.jpg
//http://2.bp.blogspot.com/_JGIxXn5d7dc/TBbM2Zu8qRI/AAAAAAAAABE/8WlYvhPusO8/s320/thong4.jpg
//http://cdn.iofferphoto.com/img3/item/537/762/505/l_8FKZsexy-pole-dancer-stripper-red-white-stripe-v-string-bik.jpg
//
//http://stackoverflow.com/questions/2329364/how-to-embed-images-in-a-single-html-php-file

from random import randint

def splitstring(s):
    while len(s):
        n=randint(2,20)
        yield s[:n]
        s=s[n:]

astring="This is a string. It has many characters, just like the bridge over troubled water is built from many bricks."

for i in splitstring(astring):
    print i

Я не хочу быть злым, поэтому вот рабочий фрагмент кода Python, который разбивает вашу строку на части. Однако, поскольку вы не указали, где вы хотите, чтобы он был разделен, я просто выберу случайные места. Надеюсь, с тобой все в порядке.

питон

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

Для языков, которые поддерживают регулярные выражения и имеют split легкодоступную функцию, вы всегда должны использовать ее для разбиения строки. Это поможет вам не изобретать велосипед и сохранить ваш код коротким и приятным. Использование регулярных выражений также позволяет переносить код на другой язык без изменения регулярного выражения.

Плохое решение

Есть это очевидное решение, где вы делите на \nили \r\n:

Джава

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

PHP

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

Это решение является мусором и никогда не должно использоваться. В наши дни бесполезно избегать Unicode, скорее каждый программист должен принять его и убедиться, что ваше приложение готово к Unicode. Если вы рассматриваете только \nили \r\nкак новый разделитель строк, вы пишете программное обеспечение в 90-х. В этом возрасте Юникода вы должны считать U + 0085, U + 2028, U + 2029 действительным разделителем строк. Поскольку Юникод время от времени обновляется, и обычно требуется некоторое время, прежде чем вы поймете, что он обновлен, возможно, в Юникод добавлен новый разделитель строк. Не беспокойтесь, потому что все механизмы регулярных выражений готовы к Unicode, и они регулярно обновляются, чтобы соответствовать последнему стандарту Unicode. Так что, если вы используете интерпретируемый язык, ваш код будет обновлен, и вы ничего не будете делать.

Рекомендуемое решение

Чтобы разделить строку по разделителю строки и быть в курсе развития Unicode, ^укажите регулярное выражение и укажите MULTILINEрежим.

По умолчанию соответствует ^только началу строки. В MULTILINEрежиме ^ также соответствует началу строки, то есть после окончания строки.

Например:

Джава

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

PHP

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

Обратите внимание, что впереди есть дополнительная пустая строка, просто удалите ее или цикл из индекса 1.

объяснение

На первый взгляд, это выглядит как хороший ответ с (несколько) рабочим решением в сочетании с объяснением с некоторыми рекомендациями по кодированию лучших практик. Однако само решение - это тролль ( «Я знаю, я буду использовать регулярные выражения. Теперь у них есть две проблемы. ), И весь пост усеян тонко неверной информацией, которая отравит любого новичка в программировании.

• Различные движки регулярных выражений поддерживают разные наборы функций. Если целевой движок не имеет функции, которую вы используете в своем регулярном выражении, перенос кода не так прост, как копирование и вставка. Это может быть возможно для моделирования с поддерживаемыми функциями, или это может быть невозможно сделать с одним регулярным выражением вообще.
• Существует 2 типа движков : текстовый движок (на основе автоматов) и регулярный движок (возврат). Первая возвращает самую левую самую длинную строку, вторая возвращает самую левую смещенную строку (смещенную в направлении порядка исследования, указанного в регулярном выражении). Одно и то же регулярное выражение может давать разные результаты для двух типов двигателей.
• Даже для одной и той же функции разные движки регулярных выражений могут иметь разный синтаксис для ее указания.
• Даже для одной и той же функции и одного и того же синтаксиса разные движки регулярных выражений могут иметь разное поведение при разборе и сопоставлении. Помимо ошибок, различие может быть связано с дизайном движка регулярных выражений (может быть или не задокументировано).
• В MULTILINEрежиме поведение ^и $зависит от определения «терминатор строки». Java считает \r\n, \n, \r, \u0085, \u2028, \u2029чтобы линия терминатора, где \r\nпоследовательность считается атомарным. JavaScript считает \n, \r, \u2028, \u2029чтобы линия терминаторы. Ruby считает только \nтерминатор строки.
• splitФункция может иметь разную семантику на разных языках для угловых случаев. Python не разбивает пустые совпадения, Java удаляет завершающие пустые строки (если вы не укажете отрицательный предел), JavaScript не разбивает пустое совпадение с индексом 0.
• «Плохое решение» на самом деле более переносимо, чем «рекомендуемое решение». Однако то, что следует считать разделителем строки, зависит от спецификации того, над чем вы работаете (например, исходный код на Си).
• В настоящее время большинство механизмов регулярных выражений даже не соответствуют поддержке Unicode уровня 1 . Они могут иметь свойства и блоки Unicode, но реализация раздела «Граница линии» повсеместна, как описано выше. JavaScript даже не поддерживает свойства символов Unicode!

Bash скрипт

new_string=`echo $string`

Это разбивает строку на новые строки. Если вы подтвердите $new_string, вы заметите, что он заменил новую строку на разделители массива.

Пример вывода:

[glitchmr@guava ~]$ string=$'some\nnice\nstring'
[glitchmr@guava ~]$ echo "$string"
some
nice
string
[glitchmr@guava ~]$ new_string=`echo $string`
[glitchmr@guava ~]$ echo "$new_string"
some nice string
[glitchmr@guava ~]$

Джава

Это не читает из файла. Регулярные выражения используются. Код предполагает, что прочитанная строка имеет символ '\ n' для обозначения новой строки. Цифры 1,2,3,4 используются для обозначения разделения.

public static void main(String args[])
{

    String strSource = "1.This is a string.This is a string.This is a string.This is a string.This is a string.\n2.This is a string.This is a string.This is a string.This is a string.This is a string.\n3.This is a string.This is a string.This is a string.This is a string.This is a string.\n4.This is a string.This is a string.This is a string.This is a string.This is a string.";
    String[] tokens = Pattern.compile("\n").split(strSource,10) ;
    for (int loop=0;loop<tokens.length;loop++)
        System.out.println(tokens[loop]);
}

C #

static class Module1{
    public static void Main()
{
        dynamic i = 0;
        foreach (object line_loopVariable in split_into_lines(Console.In.ReadToEnd())) {
            line = line_loopVariable;
            i += 1;
            Console.WriteLine("Line {0}: {1}", i, line);
        }
    }
    public static IEnumerable<string> split_into_lines(string text){
        dynamic temp_file_name = System.IO.Path.GetTempFileName();
        System.IO.File.WriteAllText(temp_file_name, text);
        return System.IO.File.ReadLines(temp_file_name);
    }
}

Вы не указываете, является ли "новая строка", на которую вы хотите разбить строку, чувствительной к регистру или нечувствительной. Я предполагаю нечувствительным.

public class SplitStringAtNewline
{
  public static final String STRING_TO_SPLIT = "Hellonew lineWorld";
  public static void main (String [] args)
  {
     System.out.println (
        String.join("",
          Pattern.compile("[nN][eE][wW] [lL][iI][nN][eE]")
              .splitAsStream(STRING_TO_SPLIT)
              .map((s) -> s + "\n")
              .collect(() -> new ArrayList<>(),
                    (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))));

  }
}

Чувак, это очень легко сделать в Powershell.

Просто получите вашу строку, как это:

$string = "Helloworld!"

Затем перебирайте случайный ascii до тех пор, пока ваша строка не будет разбита на две части так:

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

в итоге вы должны получить строку split, которую вы можете вывести так:

Write-Host $new_string

Выход:

Привет, мир!

Php

<? Spliter($yourstring); ?>

Вот как вы разделяете строку. Разве это не так просто?

Все, что вам нужно сделать сейчас, это написать функцию Spliter()

специфичный для bash

У bash отличная работа !

Да, разделение строки может быть сделано очень простым способом:

string=$'foo\nbar\nbaz'

Сначала вам нужно инициализировать переменную, которую вы будете использовать для хранения вашего разбитого результата:

declare -a lines

Теперь, когда каждая строка разделена двумя разделителями, началом или концом строки, вам понадобится переменная для хранения первой

limitA=0

Хорошо, теперь вы можете искать разделитель и хранить ваши строки, используя цикл . Так как bash не может работать с двоичными значениями, вы можете использовать инструмент, например, odдля работы с шестнадцатеричными значениями, например:

while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

Теперь у нас есть разделенная строка, хранящаяся в переменной lines:

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

Чтобы мы могли печатать используя:

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

Собираем все это в один скрипт:

#!/bin/bash

string=$'this is a very long string containing spaces\nshorted, but containing comas...\nthird line.'
declare -a lines
limitA=0
while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

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

Это напечатает:

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

Современная Баш

Но используя современную реализацию bash , вы можете хранить управляющие символы, такие как newline, в переменные и даже тестировать их:

#!/bin/bash

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

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

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

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

Баш Гольф

Но если вы не заботитесь о читабельности, вы можете написать сокращенный скрипт, например:

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

Сценарий для гольфа может выглядеть так:

#!/bin/bash

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

и даст тот же эффект: в первой строке разбить строку и сохранить их в массив с именем линии . А вторая строка будет печатать каждый элемент массива '' lines '', за которым следует новая строка .

консоль bash + vt

Но так как многие люди используют текстовую консоль на основе стандарта ANSI VT , вы можете использовать VT-поведение вашей консоли и написать еще раз:

#!/bin/bash

echo $'foo\nbar\nbaz'

даст тот же результат.