Citas de Tex (UVa 272)

17

Dada una cadena, reemplace todas las comillas dobles a la izquierda en dos comillas invertidas y todas las comillas dobles a la derecha en dos comillas simples.

Left-quotes significa las citas que comienzan una cita. Right-quotes significa las citas que finalizan una cita. Las citas no se pueden anidar. Puede suponer que hay un número par de comillas dobles en la cadena.

Ejemplos

Entrada:

"To be or not to be," quoth the Bard, "that
is the question".
The programming contestant replied: "I must disagree.
To `C' or not to `C', that is The Question!"

Salida:

``To be or not to be,'' quoth the Bard, ``that
is the question''.
The programming contestant replied: ``I must disagree.
To `C' or not to `C', that is The Question!''
code-golf 
— Altamente radioactivo
fuente
¿Qué son las comillas dobles a la izquierda y las dobles a la derecha?
— mi pronombre es monicareinstate el
1
@someone Las comillas dobles izquierdas son las comillas que comienzan una comilla. Las comillas dobles correctas son las que terminan una cita.
— HighRadioactive
¿Se pueden anidar las citas?
— mi pronombre es monicareinstate el
@ alguien Nope. No pueden
— HighlyRadioactive
2
@ LegionMammal978 "¿Se pueden anidar las citas?" ... "@alguien Nope. No pueden".
— Jonathan Allan el

Respuestas:

18

Ilegible , 789 777 bytes

-12 bytes utilizando la variable X34 en lugar de X6.

'"" "" ""' "" '"" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" " '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '" "'" "'" "'" "'" "'" ""' "" "" "" '""' "" '""' "" '"" "'" "'" "'" "' ""'" "'" "" "" "" "" "'" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" '"" ""' "" "" "" '""' "" '""' "" "'" "" "" "" "" "" "" "" "" "" "" " "" '""' "" '"" "'" "" "" "" "" "" "" "" '"" "" "'" "" "" "" "" """'" "'" "" '"" "" "" "" "" "" "" "" "" "" "" ""' "" "" "" " '""' "" '""' "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" " '""' "" "'" "" "" "" "" "" "" "" "" ""' "" "" "'"' "" "" "" "'" ""'"' "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "'" "" "" '' " "" "" "" '""' "" "" "" "" "" "'" "" "" "" "" "" "'" "" "" "" "" "'" "" '"" ""' "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "'" "'" "'"" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '""' "" '" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "'" "' ""'" "'" "'" "" "" ""' "" '""' "" '""' "" "

Pruébalo en línea!

Se muestra en letra de ancho variable, según el tributo tradicional al nombre del idioma.

Aprendí Ilegible para este desafío, porque obviamente es la mejor herramienta para el trabajo. Los únicos personajes permitidos en Unreadable son 'y ", por lo tanto, seguramente se adapta perfectamente a un desafío que implica cambiar "a ''. ¿No es así?

Explicación:

'""""""'""'""" assign to X2
'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""" 34 (double quote sign)
'""""""'""'""'""'""'""" assign to X5
'""'""'""'""'""'"""""""'""'""" X2+5 (apostrophe sign)
'"""""'""'""""""'"""'"""""""""" while (1+ (assign to X1 a value read from stdin, or -1 if stdin is empty) != 0)
 '"""" do 2 things
 '""""""'""'""'""'""" assign to X4
 '"""""""'""'""" the value of X2
 AND
 '"""" do 2 things
 '""""""'""'""'""" assign to X3
 '"""""""'""" the value of X1
 AND
 '"""" do 2 things
 '"""""'"""""""'""'""'""'""" while(X4 != 0)
  '"""" do 2 things
  '""""""'""'""'""'""" assign to X4
  '""""""""'"""""""'""'""'""'""" X4-1
  AND
  '""""""'""'""'""" assign to X3
  '""""""""'"""""""'""'""'""" X3-1
 end while
 AND
 '"""""""""'"""""""'""'""'""" if(X3 != 0)
  '"'"""""""'""" print X1
 else
  '" print the output of
  '"""""""""'"""""""'"""""""'""'""" if(X34 !=0)
   '"""" do 2 things
   '""""""'"""""""'""'"""'""""""""'""" assign X34=0
   AND
   '"'"""""""'""'""'""'""'""" print X5
  else
   '"""" do 2 things
   '""""""'"""""""'""'"""'""" assign X34=1
   AND
   '"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""""""'""'""'""'""'""" print X5+57
 end if
end while

(Las llamadas a X34 son en realidad llamadas a X (X5), ya que X5 = 34.)

— Robin Ryder
fuente
1
Un lenguaje curioso en un desafío complejo LOL
— HighlyRadioactive
5

Retina , 13 bytes

Aprendí Retina rápidamente porque, por alguna razón, no me gusta que Japt gane y siento que una solución C # usaría expresiones regulares de todos modos. Sé que hay una respuesta de Retina, pero no la he usado al crearla, y la encontré (exactamente) de todos modos. 

#2$`"
``
"
''

Pruébalo en línea!

— mi pronombre es monicareinstate
fuente
1
¿Por qué el odio por Japt? : p
— Shaggy
4

Japt , 12 bytes

Sería 11 solo por una limitación de (o tal vez es un error en) Japt.

r'"ȲîT°g"`'

Intentalo

r'"ȲîT°g"`'     :Implicit input of string
r'"              :Replace double quotes
   È             :Pass each match through a function
    ²            :  Duplicate
     î           :  Replace each character with
      T°         :    Postfix increment T (initially 0)
        g"`'     :    Index into "`'" with wrapping
— Lanudo
fuente
Es una pena que no puedas usar Qaquí: \
— Oliver
@Oliver, puedo (y originalmente lo hice); Solo necesito un ,también.
— Shaggy
Quiero decir que es una lástima que no podría utilizar simplemente Qen lugar de'"
— Oliver
4

TeX, 54 32 bytes

Para un desafío de reemplazo de cotizaciones de TeX, ¡también necesitamos una versión de TeX, por supuesto!

\catcode`"13\def"#1"{``#1''}...\bye

... es la cadena de entrada, por lo que no se agrega al recuento de bytes.

— siracusa
fuente
1
¿Por qué no el más simple \def"#1"{``#1''}? (o \long\defsi espera que una cita cruce el límite de un párrafo)
— Phelype Oleinik
1
Por la razón obvia de que no pensé en eso :-)
— siracusa
2

Carbón , 23 bytes

ＷＳ⊞υι⭆⪪⪫υ¶¦"⎇κ⁺ײ§'`κιι

Pruébalo en línea! El enlace es a la versión detallada del código. Incluye 8 bytes para evitar un formato de entrada engorroso. Explicación:

ＷＳ⊞υι

Recoja las líneas de entrada hasta llegar a una línea vacía.

⪫υ¶¦

Une las líneas en los personajes de nueva línea.

⪪..."

Dividir la entrada entre comillas.

⭆...

Asigne sobre cada parte y concatene los resultados para la impresión implícita.

⎇κ...ι

Deje la primera parte sin cambios.

⁺ײ§'`κι

Prefije la cita apropiada, doblada.

— Neil
fuente
Estaba esperando una solución de carbón. ¡Agradable!
— Altamente radioactivo el
2

R , 40 bytes

cat(scan(,"",,,'"',""),sep=c("``","''"))

Pruébalo en línea!

Lee la entrada de cadena, separándose en cada " , dando un vector de cadenas. Luego pega esas cuerdas, alternando entre los dobles backticks y los dobles apóstrofes como separadores, reciclándolos según sea necesario.

Alguien probablemente publicará una respuesta R más corta basada en una expresión regular ... Sin embargo, esta respuesta es más típica de R, creo.

Explicación de la scan(,"",,,'"',"")parte:

scan(, # empty first parameter: read from STDIN
  "",  # type of input is a string
  ,    # default 3rd parameter nmax
  ,    # default 4th parameter n
  '"', # separate on character "
  "")  # do not treat any characters as quotations marks (necessary to handle ' in the input)
— Robin Ryder
fuente
2

Perl 6 , 23 bytes

{S:g/\"(.*?)\"/``$0''/}

Pruébalo en línea!

Maldición, la solución obvia es más corta. Reemplaza cada porción citada con una versión con las citas apropiadas.

Perl 6 , 24 bytes

{S:g{\"}=<`` ''>[$++%2]}

Pruébalo en línea!

Reemplaza cada comilla doble, alternando entre los dos conjuntos de caracteres.

— Jo King
fuente
1

Laberinto , (43?) 53 bytes

396"
 } "",)@
  ~"  (
 "~ 3_:
""" 4
" .;-
=   ;
..::;

Pruébalo en línea!

Una versión de golf de este, mucho más simple, programa de 92 bytes:

3 """
9 " ",)@
}96 " (
    " :_34-;;
    "     ; :
   """"""". :
   "        .
   """"""""=.

Si no necesitamos manejar la entrada que contiene el byte cero, entonces 43 bytes :

39}9
@  6
`,""
`  "
: ."=..
_ ;   "
34-;;::
— Jonathan Allan
fuente
1

(GNU) sed , 38 33 30 bytes

-4 eliminando la -nbandera e imprimiendo implícitamente en n, -1 reutilizando anterior /expression/, gracias @Cowsquack. -3 mediante el uso implícito de rama a extremo.

:a
s/"/``/;T
:b
s//''/;ta
n;bb

Pruébalo en línea! Pruébalo en línea! Pruébalo en línea!

Un salto de etiqueta bastante básico. Esto probablemente se puede jugar por un byte o dos.

:a          # label a
s/"/``/;T   # replace " -> ``. If unsuccessful, move to next line
:b          # label b
s//''/;ta   # replace " (implicit) -> ''. If successful, jump to a (w/o reading new line)
n;bb        # read in the next line, but jump to label b.
— Función Gamma
fuente
1
Por cierto, las banderas utilizadas se especifican en el encabezado. Puede jugar golf en un byte usando codegolf.stackexchange.com/a/167295/41805 , además se puede eliminar parte de la lógica de ramificación. Luego, hacer que la solución funcione sin la -nbandera debería ahorrar un poco más. (Y, por supuesto, existe la sed -zsolución trivial que supongo que has evitado intencionalmente)
— Kritixi Lithos
Muy bien, volví a man sedbuscar un poco y llegué a 30. Siéntete libre de hacerme saber todo lo que me perdí, tienes la experiencia de golf en este idioma. (Oh, -zes nuevo para mí, pero estoy de acuerdo. Me quedaré sin él.)
— GammaFunction
Bien hecho, siempre me alegra ver una respuesta sed
— Kritixi Lithos
1

05AB1E , 15 bytes

'"¡ā¨„'`sè2×.ιJ

Pruébalo en línea!

No hay expresiones regulares en 05AB1E, así que nos separamos ", hacemos una lista de alternancia ``y ''luego intercalamos las dos.

— Mugriento
fuente
1
Ok, parece que no tengo que arreglar y recuperar mi respuesta. ;)
— Kevin Cruijssen
1

Haskell , 67 60 58 bytes

(#0)
('"':x)#n=["``","''"]!!n++x#(1-n)
(a:b)#n=a:b#n
x#n=x

Pruébalo en línea!

La función relevante es (#0) .

Como originalmente pensé que la pregunta también requería que convirtiéramos comillas simples, aquí hay una versión que maneja ambos:

Haskell , 125 bytes

(#(1<0,1<0))
('"':x)#(m,n)=last("``":["\""|m])++x#(not m,n)
('\'':x)#(m,n)=last('`':['\''|n]):x#(m,not n)
(a:x)#n=a:x#n
x#n=x

Pruébalo en línea!

— Post Rock Garf Hunter
fuente
"\""debería ser "''"(dos apóstrofes)
— siracusa
@siracusa Gracias, supuse que como puedes usar "en tex, puedes usarlo aquí.
— Post Rock Garf Hunter
1

QuadR , 14 bytes

"(.*?)"
``\1''

Pruébalo en línea!

Búsqueda / reemplazo simple usando el contenedor de @ Adám para Dyalog APL's ⎕R función eplace de .

Cómo:

"(.*?)" ⍝ PCRE, finding anything between two double quotes and assigning it to group 1
``\1''  ⍝ Transformation string, replacing the match with ``group_1''.
— J. Sallé
fuente
0

Jalea , 13 bytes

ṣ”"µJḊ⁾`'ṁḤż@

Un programa completo

Pruébalo en línea!

¿Cómo?

ṣ”"µJḊ⁾`'ṁḤż@ - Main Link: list of characters, T   e.g. ..."hi" - she "said"...
 ”"           - character '"'                           '"'
ṣ             - split (T) at ('"')                      ["...","hi"," - she ","said","..."]
   µ          - (call that X) start a new monadic chain
    J         - range of length (of X)                  [1,2,3,4,5]
     Ḋ        - dequeue                                 [2,3,4,5]
      ⁾`'     - list of characters                      ["`","'"]
         ṁ    - mould like                              ["`","'","`","'"]
          Ḥ   - double                                  ["``","''","``","''"]
           ż@ - (with reversed @rguments) zip (with X)  [["...","``"],["hi","''"],[" - she ","``"],["said","''"],["..."]]
              - implicit (smashing) print               ...``hi'' - she ``said''...
— Jonathan Allan
fuente
0

Stax , 11 bytes

û╩↕H£ñ╟Uzay

Ejecutar y depurarlo

Procedimiento:

  1. Tome todas las entradas, nuevas líneas y todo.
  2. Regex reemplazar '"'con un bloque que produce salidas alternas de pares de backticks y foreticks (?)
— recursivo
fuente
0

Java 8, 40 bytes

s->s.replaceAll("\"([^\"]+)\"","``$1''")

Pruébalo en línea.

Explicación:

s->                             // Method with String as both parameter and return-type
  s.replaceAll("\"([^\"]+)\"",  //  Replace all these matches,
               "``$1''")        //  with this replacement

Explicación de expresiones regulares:

 "([^"]+)"                      // MATCH:
 "                             "//  A literal "
   [^"]+                       "//  Followed by 1 or more non-" characters
  (     )                       //  (captured in capture group 1)
         "                     "//  Followed by a literal " again

``$1''                          // REPLACEMENT:
``                              //  Literal ``
  $1                            //  Followed by the match of capture group 1
    ''                          //  Followed by a literal ''
— Kevin Cruijssen
fuente
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.