Inspirado por esta pergunta StackOverflow .

Entrada:

Tomaremos três entradas:

• Um caractere delimitador Dno qual dividir
• Um caractere Ientre dois dos quais ignoramos o caractere delimitador (eu sei, isso parece vago, mas explicarei abaixo)
• Uma linha S

Resultado:

Uma lista / matriz que contém as substrings após a divisão.

Exemplo:

Input:
D = ','
I = '"'
S = '11020199,"Abc ",aduz,,444,bieb,dc,2 ,2222.00,whatever 5dc,222.22,22.00,"98,00","12,000,000",21-09-2018, 06:00,",-,"'

Output:
['11020199', 'Abc ', 'aduz', '', '444', 'bieb', 'dc', '2 ', '2222.00', 'whatever 5dc', '222.22', '22.00', '98,00', '12,000,000', '21-09-2018', ' 06:00', ',-,']

Por quê? Dividindo em vírgula normalmente também dividir 98,00, 12,000,000e ,-,em dois / três peças. Mas como eles estão dentro do Icaractere de entrada, ignoramos a divisão aqui.

Regras do desafio:

• Você pode assumir que sempre haverá uma quantidade uniforme de Icaracteres na string de entrada.
• Você pode assumir que o caractere Isempre terá um Dpróximo a ele (exceto quando for o primeiro ou o último caractere da entrada) que ainda pode ser dividido corretamente. Então você não terá algo parecido D = ','; I = '"'; S = 'a,b"c,d"e,f', nem nada disso D=','; I='"'; S='a",b,"c'.
• A entrada de cordas Spode conter nenhum dos seja Dou I. Se não contiver D, produzimos uma lista com toda a string de entrada como único item.
• A lista de saída não conterá mais o caractere I, mesmo quando não continha D(como você pode ver no "Abc "devir 'Abc 'no exemplo acima).
• É possível que a subcadeia Icontenha apenas D. Por exemplo: D = ','; I = '"'; S = 'a,",",b,"c","d,e,,",f'resultaria em ['a', ',', 'b', 'c', 'd,e,,', 'f'].
• Você pode assumir que Dnunca estará no início ou no final de S, portanto não precisará lidar com itens vazios à direita / à direita.
• Quando uma entrada tem duas adjacentes D, teremos um item vazio. Ou seja D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f', resultaria em ['a', 'b,c', 'd', '', 'e', '', 'f'].
• Você pode assumir que as entradas e saídas conterão apenas ASCII imprimível no intervalo [32, 126](excluindo guias e novas linhas).
• Você também pode gerar todos os itens delimitados por nova linha em vez de retornar / produzir uma lista / matriz (especialmente para os idiomas que não possuem listas / matrizes; por exemplo, Retina).
• Você tem permissão para gerar a lista na ordem inversa, se ela salvar bytes. Você não tem permissão para produzi-lo na ordem classificada ou 'aleatória'. Portanto, D = ','; I = 'n'; S = 'a,2,b,3,c'pode ser produzido como [a,2,b,3,c]ou [c,3,b,2,a], mas não como [2,3,a,b,c,]ou [a,3,b,c,2]por exemplo.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Input:
D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f'
Output:
['a', 'b,c', 'd', '', 'e', '', 'f']

Input:
D = ','; I = '"'; S = '11020199,"Abc ",aduz,,444,bieb,dc,2 ,2222.00,whatever 5dc,222.22,22.00,"98,00","12,000,000",21-09-2018, 06:00,",-,"'
Output:
['11020199', 'Abc ', 'aduz', '', '444', 'bieb', 'dc', '2 ', '2222.00', 'whatever 5dc', '222.22', '22.00', '98,00', '12,000,000', '21-09-2018', ' 06:00', ',-,']

Input:
D = ' '; I = ','; S = 'this is a test , to see if you understand it, or not , hmmm, I think I have too many commas , or not , perhaps..'
Output:
['this', 'is', 'a', 'test', ' to see if you understand it', 'or', 'not', ' hmmm', 'I', 'think', 'I', 'have', 'too', 'many', 'commas', ' or not ', 'perhaps..']

Input:
D = 'x'; I = 'y'; S = 'contains no lowercase X nor Y'
Output:
['contains no lowercase X nor Y']

Input:
D = '1'; I = '3'; S = '3589841973169139975105820974944592078316406286208948254211370679314'
Output: ['58984197', '69', '9975105820974944592078', '64062862089482542', '', '70679', '4']

Input:
D = ' '; I = 'S'; S = 'regular split on spaces'
Output:
['regular', 'split', 'on', 'spaces']

Japonês , 16 bytes

qV mÏu ?X:XrWRÃq

Tente!

Basicamente, a mesma estratégia da resposta Pip mais recente do DLosc, separa as seções "citadas" e substitui o delimitador por uma nova linha no restante da string, resultando em uma saída delimitada por nova linha

Explicação completa:

qV                  Split on I
   m          Ã     For each segment:
    Ïu ?              If the segment has an odd index (quoted)...
        X             Keep it as-is
         :          Otherwise:
          XrWR        Replace each D in the segment with a newline
               q    Join it all to a single string

Observe que, mesmo que o primeiro item seja citado, ele ainda terminará no índice 1, e não no índice 0. Se qencontrar um delimitador como o primeiro caractere, ele tornará o primeiro item da divisão (índice 0) uma sequência vazia, de modo que o conteúdo da cotação se tornar corretamente o segundo item (índice 1). Aqui está uma demonstração de como lidar corretamente com uma cotação principal.

R , 34 bytes

Regular não modificado scancom os argumentos apropriados para text, sepe quotedeve fazê-lo.

function(D,I,S)scan(,t=S,"",,,D,I)

Experimente online!

C (gcc) , 64 bytes

c;f(d,i,s)char*s;{for(;*s;s++)*s==i?c=!c:putchar(d-*s|c?*s:10);}

Experimente online!

JavaScript (Node.js) , 57 bytes

(d,i,s)=>s.replace(c=/./g,e=>i==e?(c^=1,''):d!=e|c?e:`
`)

Experimente online!

Python 2, 67 bytes

import csv
lambda D,I,S:next(csv.reader(S,delimiter=D,quotechar=I))

Experimente online!

Python 2, 71 bytes

D,I,S=input()
k=1
for p in S.split(I):print p.replace(D*k,'\n'*k),;k^=1

Experimente online!

Pip , 18 bytes

FxcxQb?!:oOo?xRanx

Recebe entradas como argumentos da linha de comando. Experimente online!

Abordagem completamente diferente: processe a string um caractere de cada vez e produza os resultados desejados, delimitados por nova linha.

Quão?

                    a,b,c are cmdline args (respectively representing D,I,S); o is 1;
                    n is newline (implicit)
                    We use o for a flag indicating whether or not to change D into newline
Fxc                 For each character x in c:
   xQb?              If x equals b (the ignore character),
       !:o            Logically negate o in-place
          O          Else, output the following (with no trailing newline):
           o?         If o is truthy,
             xRan      x, with a (the delimiter) replaced with newline
                 x    Else, x unchanged

MATL , 24 bytes

y=Yso~yi=*~*cO10Zt2G[]Zt

As entradas são S, I, D.

Experimente online! Ou verifique todos os casos de teste .

Como funciona

Considere entradas D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f'.

y     % Implicit inputs: S, I. Duplicate from below
      % STACK: 'a,"b,c",d,,e,"",f', '"', 'a,"b,c",d,,e,"",f'
=     % Is equal? Element-wise
      % STACK: 'a,"b,c",d,,e,"",f', [0 0 1 0 0 0 1 0 0 0 0 0 0 1 1 0 0]
Ys    % Cumulative sum
      % STACK: 'a,"b,c",d,,e,"",f', [0 0 1 1 1 1 2 2 2 2 2 2 2 3 4 4 4]
o~    % Parity, negate
      % STACK: 'a,"b,c",d,,e,"",f', [1 1 0 0 0 0 1 1 1 1 1 1 1 0 1 1 1]
y     % Duplicate from below
      % STACK: 'a,"b,c",d,,e,"",f', [1 1 0 0 0 0 1 1 1 1 1 1 1 0 1 1 1], 'a,"b,c",d,,e,"",f'
i=    % Input: D. Is equal? Element-wise
      % STACK: 'a,"b,c",d,,e,"",f', [1 1 0 0 0 0 1 1 1 1 1 1 1 0 1 1 1], [0 1 0 0 1 0 0 1 0 1 1 0 1 0 0 1 0]
*~    % Multiply, negate (equivalent to NAND). Element-wise
      % STACK: 'a,"b,c",d,,e,"",f', [1 0 1 1 1 1 1 0 1 0 0 1 0 1 1 0 1]
*     % Multiply, element-wise. Characters are converted to ASCII code
      % STACK: [97 0 34 98 44 99 34 0 100 0 0 101 0 34 34 0 102]
c     % Convert to char (character 0 is shown here as '·')
      % STACK: 'a·"b,c"·d··e·""·f'
O10   % Push 0 and then 10
      % STACK: 'a·"b,c"·d··e·""·f', 0, 10
Zt    % Replace character 0 by character 10 (newline; shown here as '¶')
      % STACK: 'a¶"b,c"¶d¶¶e¶""¶f'
2G[]  % Push second input (I) and then [] (empty array)
      % STACK: 'a¶"b,c"¶d¶¶e¶""¶f', '"', []
Zt    % Replace character given by input I by empty; that is, remove it. Implicit display
      % STACK: 'a¶b,c¶d¶¶e¶¶f'

Retina , 45 bytes

L$`(?=.*¶(.)¶(.))(\2(.*?)\2|(.*?))(\1|¶)
$4$5

Experimente online! Explicação:

(?=.*¶(.)¶(.))(\2(.*?)\2|(.*?))(\1|¶)

Olhe para a frente para encontrar os valores de De Inas duas linhas a seguir. Então, se encontrarmos um I, coma-o e combine os caracteres para o próximo Ie D, caso contrário, apenas combine os caracteres para o próximo Dou o final da linha.

L$`
$4$5

A lista captura 4 e 5 de cada partida; 4 é a captura entre dois Is enquanto 5 é a captura entre dois Ds.

Powershell, 71 bytes

param($d,$i,$s)$s-split{(1-($script:a+=$i-ceq$_)%2)*($d-ceq$_)}|% *m $i

Script de teste com menos golfe:

$f = {

param($d,$i,$s)
$s-split{
    $script:a+=$i-ceq$_
    (1-$a%2)-and($d-ceq$_)
}|% Trim $i

}

@(
    ,(',','"',
    '',
    '')

    ,(',','"',
    'a,"b,c",d,,e,"",f',
    'a', 'b,c', 'd', '', 'e', '', 'f')

    ,(',','"',
    '11020199,"Abc ",aduz,,444,bieb,dc,2 ,2222.00,whatever 5dc,222.22,22.00,"98,00","12,000,000",21-09-2018, 06:00,",-,"',
    '11020199', 'Abc ', 'aduz', '', '444', 'bieb', 'dc', '2 ', '2222.00', 'whatever 5dc', '222.22', '22.00', '98,00', '12,000,000', '21-09-2018', ' 06:00', ',-,')

    ,(' ',',',
    'this is a test , to see if you understand it, or not , hmmm, I think I have too many commas , or not , perhaps..',
    'this', 'is', 'a', 'test', ' to see if you understand it', 'or', 'not', ' hmmm', 'I', 'think', 'I', 'have', 'too', 'many', 'commas', ' or not ', 'perhaps..')

    ,('x','y',
    'contains no lowercase X nor Y',
    'contains no lowercase X nor Y')

    ,('1','3',
    '3589841973169139975105820974944592078316406286208948254211370679314',
    '58984197', '69', '9975105820974944592078', '64062862089482542', '', '70679', '4')

    ,(' ','S',
    'regular split on spaces',
    'regular', 'split', 'on', 'spaces')

) | % {
    $d,$i,$s,$expected = $_
    $result = &$f $d $i $s
    "$("$result"-eq"$expected"): $result"
}

Resultado:

True:
True: a b,c d  e  f
True: 11020199 Abc  aduz  444 bieb dc 2  2222.00 whatever 5dc 222.22 22.00 98,00 12,000,000 21-09-2018  06:00 ,-,
True: this is a test  to see if you understand it or not  hmmm I think I have too many commas  or not  perhaps..
True: contains no lowercase X nor Y
True: 58984197 69 9975105820974944592078 64062862089482542  70679 4
True: regular split on spaces

Explicação:

• O bloco de scripts no -split{...}especifica regras para aplicar o delimitador. Veja about_split .
• $script:a=...define a variável ano escopo externo .
• -ceqsignifica equação que diferencia maiúsculas de minúsculas .
• |% trim $ichama um método trimcom o argumento$i .

SNOBOL4 (CSNOBOL4) , 109 bytes

	D =INPUT
	I =INPUT
	S =INPUT
S	S (I ARB . OUTPUT I | ARB . OUTPUT) (D | RPOS(0)) REM . S	DIFFER(S)	:S(S)
END

Experimente online!

Suponha que D =','e I ='"'. Em seguida, o padrão (I ARB . OUTPUT I | ARB . OUTPUT) (D | RPOS(0))corresponde a seqüências que parecem ".*"ou são .*seguidas por ,ou no final da sequência e OUTPUTs os .*caracteres arbitrários ( ), configurando o REMainder incomparável para Se iterando, desde que Snão esteja vazio.

Pip -n , 29 24 bytes

cR Xa[na]@(bN{$`})^n||:b

Recebe entradas como argumentos da linha de comando. Experimente online!

Estratégia: Ipares externos , substitua Dpor nova linha (já que temos a garantia de que as novas linhas não aparecerão na string). Em seguida, divida na nova linha e tira I.

Geléia ,  20  18 bytes

;`j⁵œṣ⁴œṣḊṖYʋ€Ðo³Y

Um programa completo de tomar os três argumentos D, I, Sque imprime cada item em uma linha.

Experimente online! (Rodapé se junta a novas linhas)

Quão?

Coloque um acréscimo Dde cada lado, divida em Is, divida os itens Dcom índices ímpares em s, remova a cabeça e o rabo e junte-os a novas linhas, finalmente junte o resultado com novas linhas.

PHP , 50 bytes

function q($D,$I,$S){return str_getcsv($S,$D,$I);}

Experimente online! Usa uma função interna .

Se a reorganização das entradas for permitida ( (S,D,I)para que corresponda à str_getcsvassinatura), eu tenho uma versão de 44 bytes .