Inspiré par cette question StackOverflow .

Contribution:

Nous prendrons trois entrées:

• Un délimiteur Dsur lequel se diviser
• Un caractère Ientre deux dont nous ignorons le caractère délimiteur (je sais, cela semble vague, mais je vais l'expliquer ci-dessous)
• Un string S

Production:

Une liste / tableau contenant les sous-chaînes après la scission.

Exemple:

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

Pourquoi? Le fractionnement sur une virgule se diviserait normalement également 98,00, 12,000,000et ,-,en deux / trois morceaux. Mais parce qu'ils sont dans le Icaractère d'entrée, nous ignorons ignorer la division ici.

Règles du défi:

• Vous pouvez supposer qu'il y aura toujours un nombre pair de Icaractères dans la chaîne d'entrée.
• Vous pouvez supposer que le personnage Iaura toujours un Dcôté (sauf s'il s'agit du premier ou du dernier caractère de l'entrée) qui peut toujours être correctement divisé. Vous n'aurez donc rien de semblable D = ','; I = '"'; S = 'a,b"c,d"e,f', ni rien de semblable D=','; I='"'; S='a",b,"c'.
• La chaîne d'entrée Sne peut contenir ni l'un Dni l' autre I. S'il ne contient pas D, nous éditons une liste avec la chaîne d'entrée entière comme seul élément.
• La liste de sortie ne contiendra plus le caractère I, même s'il n'en contenait pas D(comme vous pouvez le voir au "Abc "devenir 'Abc 'dans l'exemple ci-dessus).
• Il est possible que la sous-chaîne Icontienne uniquement D. Par exemple: D = ','; I = '"'; S = 'a,",",b,"c","d,e,,",f'entraînerait ['a', ',', 'b', 'c', 'd,e,,', 'f'].
• Vous pouvez supposer que Dcela ne se fera jamais au début ou à la fin S, vous n'aurez donc pas à gérer les éléments vides de fin / de début .
• Lorsqu'une entrée en a deux adjacentes D, nous aurons un élément vide. C'est-à-dire D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f'qu'il en résulterait ['a', 'b,c', 'd', '', 'e', '', 'f'].
• Vous pouvez supposer que les entrées et sorties ne contiendront que de l'ASCII imprimable dans la plage [32, 126](donc à l'exclusion des tabulations et des sauts de ligne).
• Vous êtes également autorisé à sortir tous les éléments délimités par une nouvelle ligne au lieu de renvoyer / sortir une liste / tableau (en particulier pour les langages qui n'ont pas de listes / tableaux; c'est-à-dire Retina).
• Vous êtes autorisé à afficher la liste dans l'ordre inverse si elle enregistre des octets. Cependant, vous n'êtes pas autorisé à le sortir dans l'ordre trié ou «mélangé». Il D = ','; I = 'n'; S = 'a,2,b,3,c'peut donc être sorti en tant que [a,2,b,3,c]ou [c,3,b,2,a], mais pas en tant que [2,3,a,b,c,]ou [a,3,b,c,2]par exemple.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de 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 octets

qV mÏu ?X:XrWRÃq

Essayez!

Fondamentalement, la même stratégie que la nouvelle réponse Pip de DLosc, met de côté les sections "entre guillemets" puis remplace le délimiteur par une nouvelle ligne dans le reste de la chaîne, ce qui entraîne une sortie délimitée par une nouvelle ligne

Explication complète:

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

Notez que même si le premier élément est cité, il finira toujours à l'index 1 et non à l'index 0. Si qtrouve un délimiteur comme premier caractère, il fait du premier élément de la division (index 0) une chaîne vide, donc le contenu du devis devient correctement le deuxième élément (index 1). Voici une démo de traiter correctement une citation de premier plan.

R , 34 octets

Régulier non modifié scanavec les arguments appropriés pour text, sepet quotedevrait le faire.

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

Essayez-le en ligne!

C (gcc) , 64 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 57 octets

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

Essayez-le en ligne!

Python 2, 67 octets

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

Essayez-le en ligne!

Python 2, 71 octets

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

Essayez-le en ligne!

Pip , 18 octets

FxcxQb?!:oOo?xRanx

Prend les entrées comme arguments de ligne de commande. Essayez-le en ligne!

Approche complètement différente: traitez la chaîne un caractère à la fois et sortez les résultats souhaités délimités par la nouvelle ligne.

Comment?

                    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 octets

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

Les entrées sont S, I, D.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Comment ça fonctionne

Considérez les entrées 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'

Rétine , 45 octets

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

Essayez-le en ligne! Explication:

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

Regardez en avant pour trouver les valeurs de Det Isur les deux lignes suivantes. Ensuite, si nous trouvons un, Imangez-le et faites correspondre les caractères au suivant Iet D, sinon, faites simplement correspondre les caractères au suivant Dou à la fin de la ligne.

L$`
$4$5

La liste capture 4 et 5 de chaque match; 4 est la capture entre deux Is tandis que 5 est la capture entre deux Ds.

Powershell, 71 octets

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

Script de test moins golfé:

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

Production:

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

Explication:

• Le bloc de script dans -split{...}spécifie les règles d'application du délimiteur. Voir about_split .
• $script:a=...définit la variable adans la portée externe .
• -ceqsignifie une équation sensible à la casse .
• |% trim $iappelle une méthode trimavec argument$i .

SNOBOL4 (CSNOBOL4) , 109 octets

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

Essayez-le en ligne!

Supposons que D =','et I ='"'. Ensuite, le modèle (I ARB . OUTPUT I | ARB . OUTPUT) (D | RPOS(0))correspond aux chaînes qui ressemblent ".*"ou sont .*suivies par ,ou à la fin de la chaîne, et SORTE les caractères arbitraires ( .*), définissant le REMainder sans correspondance sur Set itérant tant qu'il Sn'est pas vide.

Pip -n , 29 24 octets

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

Prend les entrées comme arguments de ligne de commande. Essayez-le en ligne!

Stratégie: en dehors des Ipaires, remplacez Dpar une nouvelle ligne (car nous sommes garantis que les nouvelles lignes n'apparaîtront pas dans la chaîne). Ensuite, divisez sur la nouvelle ligne et supprimez I.

Gelée ,  20  18 octets

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

Un programme complet prenant les trois arguments D, I, Squi imprime chaque élément sur une ligne.

Essayez-le en ligne! (Le pied de page rejoint les nouvelles lignes)

Comment?

Entourez avec un supplément Dde chaque côté, divisez en Is, divisez les éléments indexés en Ds puis retirez leurs têtes et queues et joignez-les avec des nouvelles lignes, enfin joignez le résultat avec des nouvelles lignes.

PHP , 50 octets

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

Essayez-le en ligne! Utilise une fonction intégrée .

Si le réarrangement des entrées est autorisé ( (S,D,I)il correspond donc austr_getcsv signature), j'ai une version de 44 octets .