Dada uma sequência, substitua todas as aspas duplas à esquerda em dois reticulares e todas as aspas duplas à direita em duas aspas simples.

Aspas à esquerda significam as aspas que iniciam uma cotação. As aspas à direita significam as aspas que terminam uma cotação. As cotações não podem ser aninhadas. Você pode assumir que há um número par de aspas duplas na string.

Exemplos

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!"

Resultado:

``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!''

Ilegível , 789 777 bytes

-12 bytes usando a variável X34 em vez de X6.

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

Experimente online!

Exibido em fonte de largura variável, de acordo com o tributo tradicional ao nome do idioma.

Eu aprendi ilegível para esse desafio, porque é obviamente a melhor ferramenta para o trabalho. Os únicos personagens permitidos em Ilegível são 'e ", com certeza, é perfeitamente adequado para um desafio que envolve a mudança "para ''. Não é?

Explicação:

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

Na verdade, as chamadas para X34 são chamadas para X (X5), pois X5 = 34.)

Retina , 13 bytes

Aprendendo Retina rapidamente porque, por algum motivo, não gosto de ganhar o Japt e sinto que uma solução C # usaria expressões regulares de qualquer maneira. Sei que há uma resposta Retina, mas não a usei ao criar isso, e também a encontrei (exatamente).

#2$`"
``
"
''

Experimente online!

JavaScript (ES9), 34 bytes

Trabalhando em blocos cotados:

s=>s.replace(/"(.*?)"/gs,"``$1''")

Experimente online!

JavaScript (ES6), 38 bytes

Trabalhando em cada aspas duplas separadamente:

s=>s.replace(/"/g,_=>(c="'`"[s^=1])+c)

Experimente online!

Geléia , 15 13 bytes

⁾``⁾''2ƭ”"Ƒ¡€

Experimente online!

Programa completo.

Python 3 , 65 bytes

f=lambda s:s and(s[0],"`'"[s.count('"')%2]*2)[s[0]=='"']+f(s[1:])

Experimente online!

-8 bytes graças a Erik the Outgolfer

Japonês , 12 bytes

Seria 11 apenas por uma limitação (ou talvez seja um bug) do Japt.

r'"ȲîT°g"`'

Tente

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

TeX, 54 32 bytes

Para um desafio de substituição de cotações TeX, também precisamos de uma versão TeX, é claro!

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

... é a sequência de entrada, portanto, não é adicionada à contagem de bytes.

Carvão , 23 bytes

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

Experimente online! Link é a versão detalhada do código. Inclui 8 bytes para evitar um formato de entrada complicado. Explicação:

ＷＳ⊞υι

Colete linhas de entrada até que uma linha vazia seja alcançada.

⪫υ¶¦

Junte as linhas em caracteres de nova linha.

⪪..."

Divida a entrada entre aspas.

⭆...

Mapeie cada parte e concatene os resultados para impressão implícita.

⎇κ...ι

Deixe a primeira parte inalterada.

⁺ײ§'`κι

Prefixe a cotação apropriada, dobrada.

R , 40 bytes

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

Experimente online!

Lê a entrada da string, separando a cada " , fornecendo um vetor de strings. Em seguida, cola essas cordas, alternando entre os dois encostos e os apóstrofos duplos como separadores, reciclando-os conforme necessário.

Alguém provavelmente postará uma resposta R mais curta com base em uma expressão regular ... Ainda assim, acho que essa resposta é mais típica de R.

Explicação da scan(,"",,,'"',"")peça:

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)

Perl 6 , 23 bytes

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

Experimente online!

Droga, a solução óbvia é mais curta. Substitui cada parte citada por uma versão pelas aspas apropriadas.

Perl 6 , 24 bytes

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

Experimente online!

Substitui cada aspas duplas, alternando entre os dois conjuntos de caracteres.

Retina , 15 bytes

"
""
Y`"`\`\`''

Experimente online! Afia a resposta entediante Retina 0.8.2 por 1 byte. Explicação:

"
""

Duplique todas as aspas.

Y`"`\`\`''

Substitua ciclicamente as aspas por pares de reticulares e aspas simples.

Resposta chata de 16 bytes da Retina 0.8.2 para completude:

s`"(.*?)"
``$1''

Experimente online!

PHP , 62 bytes

Solução não-RegEx:

for(;''<$l=$argv[1][$i++];)echo$l=='"'?["''","``"][++$j%2]:$l;

Experimente online!

PHP , 48 bytes

Solução RegEx do Porto de Arnauld :

<?=preg_replace('/"(.*?)"/s',"``$1''",$argv[1]);

Experimente online!

C (gcc) , 69 68 bytes

t=39,z;f(char*s){z=*s-34?*s:257*(t^=71);printf("%s",&z);*++s&&f(s);}

Experimente online!

Um byte raspado por @ceilingcat!

Labirinto , (43?) 53 bytes

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

Experimente online!

Uma versão em golf deste programa muito mais simples de 92 bytes:

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

Se não precisamos manipular a entrada que contém o byte zero, então 43 bytes :

39}9
@  6
`,""
`  "
: ."=..
_ ;   "
34-;;::

Python 2 , 57 bytes

lambda s:re.sub('"(.*?)"',r"``\1''",s,flags=16)
import re

Experimente online!

Embora eu realmente goste da resposta de Jitse .

(GNU) sed , 38 33 30 bytes

-4 , removendo a -nbandeira e implicitamente a impressão em n, -1 , reutilizando anterior /expression/, graças @Cowsquack. -3 usando ramificação implícita.

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

Experimente online! Experimente online! Experimente online!

Algum rótulo bastante básico pulando. Provavelmente isso pode ser jogado por um byte ou dois.

: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. 

05AB1E , 15 bytes

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

Experimente online!

Não há expressões regulares em 05AB1E; portanto, dividimos ", fazemos uma lista de alternâncias ``e '', em seguida, intercalamos as duas.

Haskell , 67 60 58 bytes

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

Experimente online!

A função relevante é (#0) .

Como eu originalmente pensava que a pergunta também exigia a conversão de aspas simples, aqui está uma versão que trata de 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

Experimente online!

QuadR , 14 bytes

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

Experimente online!

Localização / substituição simples usando o wrapper @ Adám para a ⎕Rfunção eplace do Dyalog APL .

Quão:

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

Vermelho , 79 bytes

func[s][q:"^""parse s[any[to change[q copy t to q q](rejoin["``"t"''"])skip]]s]

Experimente online!

Gelatina , 13 bytes

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

Um programa completo.

Experimente online!

Quão?

ṣ”"µ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''...

Lua , 36 bytes

print((...):gsub('"(.-)"',"``%1''"))

Experimente online!

Uau, apenas dois caracteres a mais do que a solução js.

Perl 5 -p0 , 19 bytes

s/"(.*?)"/``$1''/gs

Experimente online!

Stax , 11 bytes

û╩↕H£ñ╟Uzay

Execute e depure

Procedimento:

1. Pegue todas as entradas, novas linhas e tudo.
2. O Regex substitui '"'por um bloco que produz saídas alternadas de pares de reticulares e foreticks (?)

Java 8, 40 bytes

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

Experimente online.

Explicação:

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

Explicação Regex:

 "([^"]+)"                      // 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 ''