а решение на питоне в функциональном стиле не канает?

неоптимально, но функционально:

es = chr 0x7D
unescape :: [String] -> [String]
unescape [] = []
unescape (es:x:xs) = ord x .|. 0x7D : unescape xs
unescape x:xs = x :unescape xs

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

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

reduce( lambda R, x: R[:-1]+[x^0x7D] if R and R[-1]==0x7D else R+[x], data, [] )

как то так.

Про APL вроде не спрашивали?

Вообще то это питон;-)

-module(f).
-export([f/2]).

f([], A) ->
	A;

f([H|T], A) when H == escape ->
	f(T, A);

f([H|T], A) ->
	f(T, lists:append(A, [H])).

сильно не пинайте, всё ещё его изучаю.

А первый символ массива по условию не может быть экранированным?

а зачем ?

решение задачи на питоне - на самом деле один вызов re.sub, так же как и на любом другом языке.

жжошь, отец :)

регекспы для такой задачи? да вы издеваетесь.

Если это питон, то это решение не той задачи. Лучше жечь, чем тупить;-)

регекспы для такой задачи? да вы издеваетесь.

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

НО, если вам в Индии, нужен объём, то можно предложить много всяких подходов..функциональный - не самый выгодный..

Рассмотрите лучше ОО - можно создать класс(шаблон/интерфейс) который представляет исходное нечто, закодить класс substitutionRulezz, ко всему этому фабрику, и наконец-то transformer..возможен такой полёт фантазии, что можно реализовывать года два, лишь бы платили :)

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

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

НО, если вам в Индии, нужен объём,

давайте вы не будете меня учить, что мне читать и рассматривать, хорошо?

ну и в дополнение к моему посту, хотелось бы увидеть, то как дожно выглядеть решение использующее re.sub.

обещанный вариант на байтстрингах с фьюзингом и прочими радостями:

unescape xs = toLazyByteString (s <> (foldl' (<>) mempty t'))
     where (s,t) = span (/=0x7D) xs
           t' = map (\x -> word8 (head x .|. 0x7D) <> bytestring (tail x)) (split 0x7D)

можно было написать сильно проще, но не правильно, всё равно никто проверять не будет.

к примеру

import re

s = 'Hello ^[[42mgreen word^[[0m'

print re.sub(r'\^(.)',lambda m:chr(ord(m.group(1))-0100),s)

см http://docs.python.org/2/library/re.html «7.2.5.5. Text Munging»

Может. на это ограничений нет.

принятно, но ну его к черту такое решение за рамками интерпретируемых языков :)

Ну так. Тред не читай @ сразу отвечай :-). Но от своих слов я не отказываюсь всё равно.

Как-то так

def unescape(data):
    i = iter(data)
    while True:
        try:
            x = next(i)
            yield next(i) ^ 0x7D if x == 0x7D else x
        except StopIteration:
            break

p.s. код не проверял, мог допустить ошибку, но принцип такой.

p.p.s. наверное можно и проще без десятиэтажных конструкций

Не вижу смысла в данном случае делать ленивые вычисления, поскольку «очищенный» массив будет сразу же попилен на header+payload и дальше разобран.

Ну зато ФП стиль. За исключением двух переменных, но это по факту не переменные, а константы - в питоне просто вроде нет констант как таковых.

А ленивость тут особой роли не играет... output = list(unescape(input))

По факту тут нужен генератор списков.

По факту, проще (короче) чем с reduce сделать не получиться. С генератором будет муторно, придется делать тройки элементов и отдельно обрабатывать концы.

Ну или прятаться за елдами и пр фигней, но это во первых много строк, во вторых чудес то не бывает - все равно надо хранить «состояние», которое меняется экранирующим символом.

да... наверное reduce попроще :) я ваш пост как-то проглядел.