Ispirato da questa domanda StackOverflow .

Ingresso:

Prenderemo tre input:

• Un carattere delimitatore su cui Ddividere
• Un personaggio Itra due dei quali ignoriamo il carattere delimitatore (lo so, sembra vago, ma lo spiegherò di seguito)
• Una stringa S

Produzione:

Un elenco / array contenente le sottostringhe dopo la divisione.

Esempio:

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', ',-,']

Perché? Splitting sulla virgola normalmente anche dividere 98,00, 12,000,000e ,-,in due / tre pezzi. Ma poiché sono all'interno del Icarattere di input, ignoriamo ignorare la divisione qui.

Regole della sfida:

• Puoi presumere che ci sarà sempre una quantità pari di Icaratteri nella stringa di input.
• Puoi presumere che il personaggio Iavrà sempre un Daccanto (tranne quando è il primo o l'ultimo carattere dell'input) che può ancora essere diviso correttamente. Quindi non avrai qualcosa del genere D = ','; I = '"'; S = 'a,b"c,d"e,f', né niente del genere D=','; I='"'; S='a",b,"c'.
• La stringa di input non Spuò contenere nessuno dei due Do I. Se contiene no D, viene visualizzato un elenco con l'intera stringa di input come unico elemento.
• L'elenco di output non conterrà più il carattere I, anche quando non conteneva no D(come puoi vedere al "Abc "divenire 'Abc 'nell'esempio sopra).
• È possibile che la sottostringa all'interno Icontenga solo D. Ad esempio: D = ','; I = '"'; S = 'a,",",b,"c","d,e,,",f'si tradurrebbe in ['a', ',', 'b', 'c', 'd,e,,', 'f'].
• Puoi presumere che Dnon sarà mai all'inizio o alla fine di S, quindi non dovrai occuparti di trascinare / portare oggetti vuoti.
• Quando un input ha due adiacenti D, avremo un oggetto vuoto. Ie D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f'comporterebbe ['a', 'b,c', 'd', '', 'e', '', 'f'].
• Puoi presumere che gli ingressi e le uscite conterranno solo ASCII stampabili nell'intervallo [32, 126](quindi escludendo le schede e le nuove righe).
• È anche consentito produrre tutti gli elementi delimitati da nuova riga anziché restituire / generare un elenco / matrice (specialmente per quelle lingue che non hanno liste / matrici; ad esempio Retina).
• Puoi salvare l'elenco in ordine inverso se salva byte. Tuttavia, non è consentito emetterlo in ordine ordinato o 'mischiato'. Quindi D = ','; I = 'n'; S = 'a,2,b,3,c'può essere emesso come [a,2,b,3,c]o [c,3,b,2,a], ma non come [2,3,a,b,c,]o [a,3,b,c,2]per esempio.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

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']

Japt , 16 byte

qV mÏu ?X:XrWRÃq

Provalo!

Fondamentalmente la stessa strategia della nuova risposta Pip di DLosc, mette da parte le sezioni "quotate", quindi sostituisce il delimitatore con una nuova riga nel resto della stringa, risultante in un output delimitato da nuova riga

Spiegazione 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

Si noti che anche se il primo elemento viene citato, andrà comunque all'indice 1 non all'indice 0. Se qtrova un delimitatore come primo carattere, il primo elemento nella divisione (indice 0) diventa una stringa vuota, quindi il contenuto del preventivo diventa correttamente il secondo elemento (indice 1). Ecco una demo di come gestire correttamente una citazione principale.

R , 34 byte

Regolare non modificato scancon gli argomenti appropriati per text, sepe quotedovrebbe farlo.

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

Provalo online!

C (gcc) , 64 byte

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

Provalo online!

JavaScript (Node.js) , 57 byte

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

Provalo online!

Python 2, 67 byte

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

Provalo online!

Python 2, 71 byte

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

Provalo online!

Pip , 18 byte

FxcxQb?!:oOo?xRanx

Accetta input come argomenti della riga di comando. Provalo online!

Approccio completamente diverso: elaborare la stringa di un carattere alla volta e generare i risultati desiderati delimitati da nuova riga.

Come?

                    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 byte

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

Gli ingressi sono S, I, D.

Provalo online! Oppure verifica tutti i casi di test .

Come funziona

Considerare gli input 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 byte

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

Provalo online! Spiegazione:

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

Guarda avanti per trovare i valori di De Isulle seguenti due righe. Quindi, se lo troviamo, Ilo mangiamo e abbiniamo i personaggi al successivo Ie D, in caso contrario, abbina i caratteri al successivo Do alla fine della linea.

L$`
$4$5

Elenco cattura 4 e 5 da ogni partita; 4 è la cattura tra due Isecondi mentre 5 è la cattura tra due Dsecondi.

Powershell, 71 byte

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

Script di test meno golfato:

$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"
}

Produzione:

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

Spiegazione:

• Il blocco di script in -split{...}specifica le regole per l'applicazione del delimitatore. Vedi about_split .
• $script:a=...imposta la variabile ain esterno portata .
• -ceqsignifica equazione sensibile al maiuscolo / minuscolo .
• |% trim $ichiama un metodo trimcon argomento$i .

SNOBOL4 (CSNOBOL4) , 109 byte

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

Provalo online!

Supponiamo che D =','e I ='"'. Quindi il pattern (I ARB . OUTPUT I | ARB . OUTPUT) (D | RPOS(0))abbina stringhe che sembrano ".*"o .*seguite da ,o alla fine della stringa e OUTPUTs i caratteri arbitrari ( .*), impostando il REMainder senza eguali su Se iterando finché Snon è vuoto.

Pip -n , 29 24 byte

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

Accetta input come argomenti della riga di comando. Provalo online!

Strategia: Icoppie esterne , sostituisci Dcon newline (poiché siamo sicuri che le newline non appariranno nella stringa). Quindi dividere su newline e strip I.

Gelatina ,  20  18 byte

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

Un programma completo di prendere i tre argomenti D, I, Sche stampa ogni voce su una linea.

Provalo online! (Il piè di pagina si unisce alle nuove righe)

Come?

Circondati di un extra Dsu ciascun lato, dividi a Is, dividi gli elementi a indice dispari a Ds, quindi rimuovi le loro teste e code e uniscili con le nuove linee, infine unisci il risultato con le nuove linee.

PHP , 50 byte

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

Provalo online! Utilizza una funzione integrata .

Se la riorganizzazione degli ingressi è consentita ( (S,D,I)quindi corrisponde alla str_getcsvfirma), ho una versione da 44 byte .