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

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


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!


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

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


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

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

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

WS⊞υι

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.


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)


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!




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


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. 

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.


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!


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


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



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 (?)

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