Citações de Tex (UVa 272)

17

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!''
code-golf 
— Altamente radioativo
fonte
O que são aspas duplas à esquerda e aspas duplas à direita?
— meu pronome é monicareinstate
1
@ alguém Alguém aspas duplas à esquerda são as aspas que iniciam uma cotação. Aspas duplas à direita são as que terminam uma citação.
— HighlyRadioactive
As aspas podem ser aninhadas?
— meu pronome é monicareinstate
@soneone Nope. Eles não podem.
— HighlyRadioactive
2
@ LegionMammal978 "As aspas podem ser aninhadas?" ... "@ alguém Nope. Eles não podem."
— Jonathan Allan

Respostas:

18

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

— Robin Ryder
fonte
1
Uma linguagem de citação em um desafio de citação LOL
— HighlyRadioactive
5

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!

— meu pronome é monicareinstate
fonte
1
Por que o ódio por Japt ?! : p
— Shaggy
4

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
— Shaggy
fonte
É uma pena que você não pode usar Qaqui: \
— Oliver
@ Oliver, eu posso (e eu originalmente); Eu também precisaria de um ,.
— Shaggy
Quero dizer, é uma pena que você não possa simplesmente usar Qno lugar de'"
— Oliver
4

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.

— siracusa
fonte
1
Por que não o mais simples \def"#1"{``#1''}? (ou \long\defse você espera que uma cotação ultrapasse o limite de um parágrafo)
— Phelype Oleinik
1
Pela razão óbvia que eu não pensei nisso :-)
— siracusa
2

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.

— Neil
fonte
Eu estava esperando por uma solução de carvão vegetal. Agradável!
— HighlyRadioactive
2

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)
— Robin Ryder
fonte
1

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!

— Neil
fonte
1

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-;;::
— Jonathan Allan
fonte
1

(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.
— GammaFunction
fonte
1
Entre, normalmente, os sinalizadores usados ​​são especificados no cabeçalho. Você pode obter um byte de golfe usando codegolf.stackexchange.com/a/167295/41805 , além de que parte da lógica de ramificação pode ser removida. Então, fazer a solução funcionar sem o -nsinalizador deve economizar um pouco mais. (E, claro, há o trivial sed -zsolução que eu presumo que você tenha intencionalmente evitado)
— Kritixi Lithos
Tudo bem, eu pesquisei man sedum pouco e cheguei aos 30. Sinta-se livre para me informar qualquer coisa que eu perdi, você tem a experiência de golfe nesse idioma. (Oh, -zé novo para mim, mas concordo. Vou ficar sem ele.)
— GammaFunction
Bem feito, estou sempre feliz em ver uma resposta sed
— Kritixi Lithos
1

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.

— Grimmy
fonte
1
Ok, parece que não preciso corrigir e recuperar minha resposta. ;)
— Kevin Cruijssen
1

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!

— Assistente de Trigo
fonte
"\""deve ser "''"(dois apóstrofos)
— siracusa
@siracusa Obrigado, eu assumi desde que você pode usar "no tex, você pode usá-lo aqui.
— Wheat Wizard
1

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''.
— J. Sallé
fonte
0

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''...
— Jonathan Allan
fonte
0

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 (?)
— recursivo
fonte
0

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 ''
— Kevin Cruijssen
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.