Dividirlo. ¡Pero no todos!

11

Inspirado en esta pregunta de StackOverflow .

Entrada:

Tomaremos tres entradas:

  • Un carácter delimitador Dpara dividir
  • Un personaje Ientre dos de los cuales ignoramos el carácter delimitador (lo sé, eso suena vago, pero lo explicaré a continuación)
  • Una cuerda S

Salida:

Una lista / matriz que contiene las subcadenas después de la división.

Ejemplo:

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é? Dividir en coma normalmente también se dividiría 98,00, 12,000,000y ,-,en dos / tres piezas. Pero debido a que están dentro del Icarácter de entrada, ignoramos ignoramos la división aquí.

Reglas de desafío:

  • Puede suponer que siempre habrá una cantidad par de Icaracteres en la cadena de entrada.
  • Puede suponer que el carácter Isiempre tendrá un Dlado (excepto cuando es el primer o el último carácter de la entrada) que aún se puede dividir correctamente. Entonces no tendrás algo como esto D = ','; I = '"'; S = 'a,b"c,d"e,f', ni nada como esto D=','; I='"'; S='a",b,"c'.
  • La entrada de la cadena Spodría contener ninguno de cualquiera Do I. Si no contiene D, mostramos una lista con toda la cadena de entrada como único elemento.
  • La lista de salida ya no contendrá el carácter I, incluso cuando no contenía ningún D(como se puede ver en el "Abc "futuro 'Abc 'en el ejemplo anterior).
  • Es posible que la subcadena Icontenga solo D. Por ejemplo: D = ','; I = '"'; S = 'a,",",b,"c","d,e,,",f'resultaría en ['a', ',', 'b', 'c', 'd,e,,', 'f'].
  • Puede suponer que Dnunca estará al principio o al final S, por lo que no tendrá que lidiar con los elementos vacíos finales / iniciales .
  • Cuando una entrada tiene dos adyacentes D, tendremos un elemento vacío. Es decir D = ','; I = '"'; S = 'a,"b,c",d,,e,"",f', resultaría en ['a', 'b,c', 'd', '', 'e', '', 'f'].
  • Puede suponer que las entradas y salidas solo contendrán ASCII imprimibles en el rango [32, 126](excluyendo pestañas y nuevas líneas).
  • También se le permite generar todos los elementos delimitados por una nueva línea en lugar de devolver / generar una lista / matriz (especialmente para aquellos idiomas que no tienen listas / matrices; es decir, Retina).
  • Se le permite generar la lista en orden inverso si guarda bytes. Sin embargo, no está permitido enviarlo en orden ordenado o 'barajado'. Por D = ','; I = 'n'; S = 'a,2,b,3,c'lo tanto, se puede generar como [a,2,b,3,c]o [c,3,b,2,a], pero no como [2,3,a,b,c,]o [a,3,b,c,2]por ejemplo.

Reglas generales:

  • Este es el código de golf , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
  • Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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']
code-golf  string 
— Kevin Cruijssen
fuente
La mayoría (¿o todas?) De las respuestas actuales no tienen elementos vacíos al principio y al final del caso de prueba 6. ¿Es este un caso especial o un error en los casos de prueba? ( "", "'ll remove all ", "")
— TFeld
@TFeld Es un caso especial. Casi todas las respuestas también fallan porque D = ','; I = '"'; S = ',"a,b",c,,d,""'me acabo de dar cuenta. Modificaré el desafío un poco para que los elementos vacíos no sean posibles al principio o al final. Basado en la experiencia en Java y 05AB1E en el pasado, sé lo frustrante que puede ser arreglar los elementos vacíos después de dividirlos manualmente cuando el idioma no lo hace correctamente de manera predeterminada. Aún se deben admitir casos de prueba como este: D = ','; I = '"'; S = 'a,"b,c",d,,e→ ['a', 'b,c', 'd', '', 'e']con un elemento vacío en el medio.
— Kevin Cruijssen
¿Se requiere que la salida final mantenga el orden de la entrada? por ejemplo'1,"2,3"' -> ['2,3','1']
— Kamil Drakari el
1
@KamilDrakari Hmm, agregaré una regla para permitirlo tanto hacia adelante como hacia atrás, pero no barajado. Así [a,b,c]y [c,b,a]son salidas permitidas, pero [a,c,b]o [b,a,c]no, por ejemplo.
— Kevin Cruijssen
¿Cuál debería ser el resultado D=','; I='"'; S='a",b,"c'o es una entrada válida?
— Zgarb

Respuestas:

3

Japt , 16 bytes

qV mÏu ?X:XrWRÃq

¡Intentalo!

Básicamente, la misma estrategia que la nueva respuesta Pip de DLosc, deja de lado las secciones "citadas" y luego reemplaza el delimitador con una nueva línea en el resto de la cadena, lo que resulta en una salida delimitada por nueva línea

Explicación 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

Tenga en cuenta que incluso si se cita el primer elemento, seguirá terminando en el índice 1, no en el índice 0. Si qencuentra un delimitador como primer carácter, convierte el primer elemento en la división (índice 0) en una cadena vacía, por lo que el contenido de la cotización se convierte correctamente en el segundo elemento (índice 1). Aquí hay una demostración de cómo tratar correctamente una cita destacada.

— Kamil Drakari
fuente
Acabo de guardar algunos bytes al reemplazar D con nueva línea fuera de las comillas y dividir en nueva línea, eliminando así la necesidad de reemplazar nueva línea con D al final. ¿Podría eso acortar tu código también?
— DLosc
@DLosc De hecho, ¡gracias por la sugerencia! Poniendo en una nueva versión ahora
— Kamil Drakari
8

R , 34 bytes

Regular sin modificaciones scancon los argumentos apropiados para text, sepy quotedebería hacerlo.

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

Pruébalo en línea!

— J.Doe
fuente
2
Como de costumbre, R lidera el camino en los desafíos de división de cuerdas.
— ngm
2
Hable sobre el idioma adecuado para el trabajo. :) Verifiqué algunos casos de prueba, y todos parecen funcionar bien, así que +1 de mí PD: No se permite tomar datos almacenándolos en una variable de acuerdo con el meta.
— Kevin Cruijssen
1
@KevinCruijssen ¿Puedo enviar scan4 bytes y luego llamarlo con los argumentos en los lugares apropiados?
— J.Doe
1
@ J.Doe Umm .. No lo sé. No está demasiado familiarizado con los posibles formatos de entrada aceptables para R tbh. Hasta donde sé, usar un programa completo con argumentos de programa o STDIN, así como una función (lambda) con los parámetros apropiados o también usando STDIN son aceptables por defecto. En la meta publicación que he vinculado anteriormente, se mencionan todos los formatos de entrada válidos (con una puntuación positiva). Cómo funciona esto para R No lo sé.
— Kevin Cruijssen
@ J.Doe su presentación en este momento es un programa completo, y actualmente no recibe información de stdin. La solución más corta sería envolverlo en una función.
— Giuseppe
7

C (gcc) , 64 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 57 bytes

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

Pruébalo en línea!

— l4m2
fuente
1
Su respuesta C funciona muy bien, pero parece que su respuesta JS aún se divide Ddentro Iy también contiene Ien la salida, que también se puede ver en los primeros casos de prueba en su enlace TIO. (PD: También podría ser mejor publicarlas como respuestas separadas, con un enlace que indique que es un puerto de su respuesta C).
— Kevin Cruijssen
1
@KevinCruijssen Corregido. Por lo general
— publico
4

Pip , 18 bytes

FxcxQb?!:oOo?xRanx

Toma entradas como argumentos de línea de comandos. Pruébalo en línea!

Enfoque completamente diferente: procese la cadena un carácter a la vez y genere los resultados deseados delimitados por nueva línea.

¿Cómo?

                    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
— DLosc
fuente
4

MATL , 24 bytes

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

Las entradas son S, I, D.

Pruébalo en línea! O verificar todos los casos de prueba .

Cómo funciona

Considerar 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'
— Luis Mendo
fuente
3

Retina , 45 bytes

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

Pruébalo en línea! Explicación:

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

Mire hacia adelante para encontrar los valores de Dy Ien las siguientes dos líneas. Luego, si encontramos un y Iluego lo comemos y hacemos coincidir los caracteres con el siguiente Iy D, de lo contrario, solo hacemos coincidir los caracteres con el siguiente Do el final de la línea.

L$`
$4$5

Lista de capturas 4 y 5 de cada partido; 4 es la captura entre dos Is, mientras que 5 es la captura entre dos Ds.

— Neil
fuente
3

Powershell, 71 bytes

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

Menos guión de prueba de 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"
}

Salida:

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

Explicación:

— mazzy
fuente
2

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

Pruébalo en línea!

Supongamos que D =','y I ='"'. Luego, el patrón (I ARB . OUTPUT I | ARB . OUTPUT) (D | RPOS(0))coincide con las cadenas que se parecen ".*"o .*siguen ,al final de la cadena o al final de la misma, y ​​SALE los caracteres arbitrarios ( .*), configurando el REMAinder no coincidente Se iterando siempre que Sno esté vacío.

— Giuseppe
fuente
2

Pip -n , 29 24 bytes

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

Toma entradas como argumentos de línea de comandos. Pruébalo en línea!

Estrategia: Ipares externos , reemplace Dcon nueva línea (ya que tenemos la garantía de que las nuevas líneas no aparecerán en la cadena). Luego se divide en nueva línea y tira I.

— DLosc
fuente
2

Jalea ,  20  18 bytes

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

Un programa completo de tomar los tres argumentos D, I, Sque imprime cada elemento en una línea.

Pruébalo en línea! (El pie de página se une con las nuevas líneas)

¿Cómo?

Rodee con un extra Den cada lado, divida en Is, divida los elementos indexados impares en Ds, luego retire sus cabezas y colas y únalas con líneas nuevas, finalmente unan el resultado con líneas nuevas.

— Jonathan Allan
fuente
1
Creo que la salida de la lista (en lugar de devolver una lista) debe delimitarse de alguna manera, por lo que puede decir 1) que es una lista, y 2) dónde termina un elemento y comienza otro. (No tengo una meta publicación específica para respaldar eso, pero hay una cierta relación con la discusión sobre el comportamiento no observable . En este momento, no es observable que su programa genere una lista en lugar de, por ejemplo, una cadena. )
— DLosc
Así que supongo que puedo reemplazar el apriete con una unión por nuevas líneas (lo que devolverá una lista de listas de caracteres mezclados con caracteres aún ya que un programa completo imprimirá los elementos en nuevas líneas).
— Jonathan Allan
— Jonathan Allan
@JonathanAllan Su solución de 20 bytes funciona según lo previsto, pero su comentario de 17 bytes en el comentario parece dar algunos resultados incorrectos .
— Kevin Cruijssen
1
@KevinCruijssen - sí, el golf móvil no es bueno, me perdí la unión de las nuevas líneas para los artículos indexados de forma impar, 18 publicados.
— Jonathan Allan
2

PHP , 50 bytes

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

Pruébalo en línea! Utiliza una función incorporada .

Si se permite reorganizar las entradas ( (S,D,I)para que coincida con la str_getcsvfirma), tengo una versión de 44 bytes .

— Jo
fuente
1
Creo que se permite reorganizar la entrada, siempre que especifique el orden. Para hacerlo más claro, puede usar las variables $S, $Dy $Icon un costo de 0 bytes, para esta versión larga de 50 bytes.
— Ismael Miguel
Además, la versión de 50 bytes, con el $S, $D, $Ivariables podrían servir como una guía para el orden de los argumentos.
— Ismael Miguel
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.