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

^{Примітка. Це запитання щодо кодування . Будь ласка, не сприймайте питання та / або відповіді серйозно. Більше інформації тут .}

С

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

Хитра проблема для початкового класу програмування на C! Спочатку ви повинні зрозуміти кілька основ цього складного предмета.

Рядок - це послідовність, що складається лише з символів . Це означає, що для того, щоб програмісти вказали на "невидиму" річ (це не пробіл, який вважається символом), ви повинні якось використовувати спеціальну послідовність символів, щоб означати цю невидиму річ.

• У Windows новий рядок - це послідовність двох символів у рядку: зворотна косої риски та n (або рядок "\n")

• У Linux або OS / X Macs - це послідовність з чотирьох символів: зворотна косої риски, n, зворотна косої риси, а потім r: (або "\n\r").

(Цікава історична примітка: на старих Macintoshes це була інша послідовність з чотирьох символів: "\ r \ n" ... повністю назад від того, як Unix робив справи! Історія веде дивні дороги.)

Може здатися, що Linux є більш марнотратним, ніж Windows, але насправді краща ідея використовувати довшу послідовність. Оскільки Windows використовує таку коротку послідовність, мова виконання C не може роздрукувати фактичні літери \nбез використання спеціальних системних викликів. Зазвичай ви можете це робити в Linux без системного дзвінка (він може навіть друкувати \n\або \n\q... все, окрім \n\r). Але оскільки C має бути крос-платформою, він застосовує найнижчий спільний знаменник. Тож ви завжди будете бачити \nу своїй книзі.

(Примітка. Якщо вам цікаво, про що ми говоримо, \nне отримуючи нові рядки кожного разу, StackOverflow майже повністю пишеться в HTML ... звертаючись до речей, про які ви могли чути, наприклад, CLANG та LLVM.)

Але повернемося до того, над чим ми працюємо. Давайте уявимо рядок з трьох творів та двох нових рядків, наприклад:

"foo\nbaz\nbar"

Ви можете бачити, що довжина цього рядка дорівнює 3 + 2 + 3 + 2 + 3 = 13. Тому для нього потрібно зробити буфер довжиною 13, а програмісти C завжди додають його до розміру своїх масивів, щоб бути безпечним. Тому зробіть свій буфер і скопіюйте рядок у нього:

/* 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, ми будемо використовувати особливий системний виклик (або "syscall"), 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 призначений для \ тролінгу ...

Абсолютно неправильно зверху вниз. І все-таки наповнений правдоподібною дурницею, яка змалкувала інформацію, як, наприклад, у підручнику чи Вікіпедії. Логіка програми виглядає прозорою в контексті дезінформації, але є повністю оманливою. Навіть глобальні змінні та повернення коду помилки, на добру міру ...

...

Зрозуміло, у представленні рядків С дворядного послідовності джерела є лише один символ \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

Будь ласка, підкажіть і прийміть.

С

В C це дуже просто:

#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)). Це означає, що якщо простір пошуку вдвічі більший, час пошуку не подвоюється, він збільшується лише на фіксовану суму!

Код для двійкового пошуку дещо складніший, оскільки він використовує вдосконалені методи рекурсії та ділення та перемоги . Але це, безумовно, варто заради виступу. Якщо ви подасте це, я думаю, ви отримаєте додатковий кредит.

Суть алгоритму полягає в наступному:

• Розріжте рядок надвоє.
• За допомогою рекурсивного дзвінка розділіть першу половину рядка.
• За допомогою рекурсивного дзвінка розділіть другу половину рядка.
• Викладіть шматочки з першої половини разом з шматочками з другої половини і voilà !

Ви не вказали мову, тому я написав її в 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::префікса
• Не працює для рядків const
• Повністю ігнорує перевиконання буфера
• Включає першу лінійку програмістів, які знають, що роблять
• Порожнє тіло без коментарів
• Індексація початківців

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
• вимагає введення рядка у вхідний рядок
• не працює, якщо рядок містить 'або,

Луа

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)

Вузол.JS

Це так просто, будь-який програміст міг би це -.-.
Спочатку ми повинні змінити hostsфайл, щоб ця .com, .net, .orgкарта була 127.0.0.1.
а решта - це базовий Javascript, який може зрозуміти будь-який noob.

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

Там ви йдете :)

Рубін

Струни в програмуванні виготовлені з Ейнштейна. Як таких, їх надзвичайно важко розділити.
На щастя для вас, я маю доктор наук з хімії та програмування, тому можу допомогти.
Для цього ми будемо використовувати рубін.

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:

Java

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

PHP

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

Цей розчин є сміттям і його ніколи не слід використовувати. У цей день і вік уникнути Unicode марно, швидше кожен програміст повинен прийняти його і переконатися, що ваша програма готова Unicode. Якщо ви розглядаєте лише \nабо \r\nяк новий роздільник рядків, ви пишете програмне забезпечення у 90-х. У цьому віці Unicode слід вважати U + 0085, U + 2028, U + 2029 дійсним роздільником рядків. Оскільки Unicode оновлюється раз у раз і зазвичай проходить певний час, перш ніж ви зрозумієте, що оновлення оновлено, може бути доданий новий роздільник рядків до Unicode. Не біда, адже всі двигуни регулярного вираження готові до Unicode, і вони регулярно оновлюються відповідно до найновішого стандарту Unicode. Отже, якщо ви використовуєте інтерпретовану мову, ваш код буде оновлений без нічого робити.

Рекомендоване рішення

Щоб розділити рядок за термінальним рядком і залишатися в курсі еволюції Unicode, подайте регулярний вираз ^і задайте MULTILINEрежим.

За замовчуванням ^відповідає лише початку рядка. У MULTILINEрежимі ^ також відповідає початку рядка, тобто після термінатора рядка.

Наприклад:

Java

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щоб лінія термінатори. Рубі вважає лише \nлінійним термінатором.
• splitФункція може мати різну семантику на різних мовах для кутових справ. Python не ділиться на порожні збіги, Java видаляє трелі порожні рядки (якщо ви не вказали негативний ліміт), JavaScript не розділяється на відповідність порожнім рядку в індексі 0.
• "Погане рішення" насправді є більш портативним, ніж "рекомендоване рішення". Однак те, що слід вважати лінійним термінатором, залежить від специфікації того, над чим ви працюєте (наприклад, вихідний код C).
• В даний час більшість двигунів регулярного генерування навіть не відповідають рівню підтримки Unicode рівня 1 . Вони можуть мати властивості та блоки Unicode, але реалізація для розділу "Межі лінії" є повсюдно, як пояснено вище. JavaScript навіть не підтримує властивості символів Unicode!

Баш сценарій

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

Java

Це не читається з файлу. Використовуються регулярні вирази. Код передбачає, що прочитаний рядок має символ "\ 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))));

  }
}

Чувак, це зробити в Повершелі дуже просто.

Просто отримайте такий рядок таким чином:

$string = "Helloworld!"

Потім переведіть петлю на випадкові асії, поки ваша струна не розділиться на два:

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

врешті-решт, ви повинні отримати розділений рядок, який ви можете вивести так:

Write-Host $new_string

Вихід:

Привіт Світ!

Php

<? Spliter($yourstring); ?>

Ось як ви розділите рядок. Чи не так просто?

Все, що вам потрібно зробити зараз, це написати функцію Spliter()

специфічний баш

Є чудова робота для баш !

Так, розбиття рядка можна зробити дуже просто:

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.

Сучасний баш

Але, використовуючи сучасну баш-програму , ви можете зберігати контрольні діаграми, як новий рядок, у змінну і навіть перевіряти їх:

#!/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[@]}

і дасть такий же ефект: Перший рядок розділить рядок і збереже їх у масиві з назвою рядків . А другий рядок буде надрукувати кожного члена масиву '' рядки '', а потім новий рядок .

bash + vt console

Але оскільки багато людей використовують текстову консоль на основі стандарту ANSI VT , ви можете використовувати поведінку на консолі VT і знову писати це коротше:

#!/bin/bash

echo $'foo\nbar\nbaz'

дасть такий же результат.