Textes (UVa 272)

17

Étant donné une chaîne, remplacez tous les guillemets gauches en deux guillemets et tous les guillemets droits en deux guillemets simples.

Left-quotes signifie les citations qui commencent une citation. Les guillemets droits signifient les guillemets qui terminent un devis. Les citations ne peuvent pas être imbriquées. Vous pouvez supposer qu'il existe un nombre pair de guillemets doubles dans la chaîne.

Exemples

Contribution:

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

Production:

``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 Hautement radioactif
la source
Que sont les doubles guillemets gauches et les doubles guillemets droits?
mon pronom est monicareinstate
1
@someone Les doubles guillemets gauches sont les guillemets qui commencent un devis. Les guillemets doubles de droite sont les guillemets qui terminent un devis.
HighlyRadioactive
Les citations peuvent-elles être imbriquées?
mon pronom est monicareinstate
@someone Nope. Ils ne peuvent pas.
HighlyRadioactive
2
@ LegionMammal978 "Les citations peuvent-elles être imbriquées?" ... "@quelqu'un Non. Ils ne peuvent pas."
Jonathan Allan

Réponses:

18

Illisible , 789 777 octets

-12 octets en utilisant la variable X34 plutôt que X6.

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

Essayez-le en ligne!

Affiché en police à largeur variable, selon l'hommage traditionnel au nom de la langue.

J'ai appris Illisible pour ce défi, car c'est évidemment le meilleur outil pour le travail. Les seuls personnages autorisés dans Unreadable sont 'et ", donc sûrement, il est parfaitement adapté à un défi qui consiste à changer "en'' . N'est-ce pas?

Explication:

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

(Les appels à X34 sont en fait des appels à X (X5), puisque X5 = 34.)

Robin Ryder
la source
1
Un langage de cotation dans un défi de cotation LOL
HighlyRadioactive
5

Rétine , 13 octets

Apprendre Retina rapidement parce que pour une raison quelconque, je n'aime pas gagner Japt et j'ai l'impression qu'une solution C # utiliserait de toute façon des expressions régulières. Je sais qu'il y a une réponse Retina, mais je ne l'ai pas utilisée lors de la création et je l'ai trouvée (exactement) de toute façon. 

#2$`"
``
"
''

Essayez-le en ligne!

mon pronom est monicareinstate
la source
1
Pourquoi la haine pour Japt?! : p
Shaggy
5

JavaScript (ES9), 34 octets

Travailler sur des blocs entre guillemets:

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

Essayez-le en ligne!

JavaScript (ES6), 38 octets

Travailler sur chaque guillemet double séparément:

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

Essayez-le en ligne!

Arnauld
la source
L'indicateur dotAll pour RegExp est une nouvelle fonctionnalité d' ECMAScript 2018 , non incluse dans ES6.
tsh
@tsh Bonne prise. Mis à jour.
Arnauld
4

Python 3 , 65 octets

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

Essayez-le en ligne!

-8 octets grâce à Erik l'Outgolfer

Jitse
la source
Quant à la deuxième fonction, vous pouvez supprimer 8 octets (ce n'est pas aussi différent que cela puisse paraître, je viens de remplacer le s[0].replacepar une s[0]=='"'vérification explicite , avec quelques autres modifications).
Erik the Outgolfer
@EriktheOutgolfer Nice trouve, merci!
Jitse
4

Japt , 12 octets

Serait 11 seulement pour une limitation de (ou peut-être que c'est un bug dans) Japt.

r'"ȲîT°g"`'

Essayez-le

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
Hirsute
la source
C'est dommage que vous ne puissiez pas l'utiliser Qici: \
Oliver
@Oliver, je peux (et je l'ai fait à l'origine); J'en aurais juste besoin ,aussi.
Shaggy
Je veux dire, c'est dommage que vous ne puissiez pas simplement utiliser Qà la place de'"
Oliver
4

TeX, 54 32 octets

Pour un défi de remplacement de devis TeX, nous avons également besoin d'une version TeX bien sûr!

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

... est la chaîne d'entrée, donc elle n'ajoute pas au nombre d'octets.

siracusa
la source
1
Pourquoi pas le plus simple \def"#1"{``#1''}? (ou \long\defsi vous vous attendez à ce qu'un devis traverse une limite de paragraphe)
Phelype Oleinik
1
Pour la raison évidente à laquelle je n'y ai pas pensé :-)
siracusa
2

Fusain , 23 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Comprend 8 octets pour éviter un format d'entrée encombrant. Explication:

ＷＳ⊞υι

Collectez les lignes d'entrée jusqu'à ce qu'une ligne vide soit atteinte.

⪫υ¶¦

Rejoignez les lignes sur les caractères de nouvelle ligne.

⪪..."

Divisez l'entrée sur les devis.

⭆...

Mappez sur chaque partie et concaténez les résultats pour l'impression implicite.

⎇κ...ι

Laissez la première partie inchangée.

⁺ײ§'`κι

Préfixez le devis approprié, doublé.

Neil
la source
J'attendais une solution au charbon. Agréable!
HighlyRadioactive
2

R , 40 octets

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

Essayez-le en ligne!

Lit l'entrée de chaîne, en les séparant chacune ", donnant un vecteur de chaînes. Puis colle ces cordes, alternant entre les doubles backticks et les doubles apostrophes comme séparateurs, les recyclant au besoin.

Quelqu'un va probablement poster une réponse R plus courte basée sur une expression régulière ... Pourtant, cette réponse est plus typique de R, je pense.

Explication de la scan(,"",,,'"',"")partie:

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
la source
2

Perl 6 , 23 octets

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

Essayez-le en ligne!

Darn, la solution évidente est plus courte. Remplace chaque partie citée par une version avec les citations appropriées.

Perl 6 , 24 octets

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

Essayez-le en ligne!

Remplace chaque guillemet double, en alternant entre les deux jeux de caractères.

Jo King
la source
1

Rétine , 15 octets

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

Essayez-le en ligne! Borde la réponse ennuyeuse de Retina 0.8.2 par 1 octet. Explication:

"
""

Dupliquez toutes les citations.

Y`"`\`\`''

Remplacez cycliquement les guillemets par des paires de guillemets et des guillemets simples.

Réponse de Retina 0.8.2 16 octets ennuyeuse pour l'exhaustivité:

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

Essayez-le en ligne!

Neil
la source
1

Labyrinthe , (43?) 53 octets

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

Essayez-le en ligne!

Une version golfée de ce programme de 92 octets, beaucoup plus simple:

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

Si nous n'avons pas besoin de gérer l'entrée contenant l'octet zéro, alors 43 octets :

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

(GNU) sed , 38 33 30 octets

-4 en supprimant le -ndrapeau et en l'imprimant implicitement n, -1 en réutilisant le précédent /expression/, merci @Cowsquack. -3 en utilisant de bout en bout implicite.

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

Essayez-le en ligne! Essayez-le en ligne! Essayez-le en ligne!

Quelques sauts d'étiquette assez basiques. Cela peut probablement être joué par un octet ou deux.

: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
la source
1
Btw généralement les drapeaux utilisés sont spécifiés dans l'en-tête. Vous pouvez jouer au golf un octet à l'aide de codegolf.stackexchange.com/a/167295/41805 , en plus une partie de la logique de branchement peut être supprimée. Ensuite, faire fonctionner la solution sans l' -nindicateur devrait économiser un peu plus. (Et bien sûr, il y a la sed -zsolution triviale que je présume que vous avez intentionnellement évitée)
Kritixi Lithos
D'accord, j'ai creusé man sed un peu et suis arrivé à 30. N'hésitez pas à me faire savoir tout ce que j'ai manqué, vous avez l'expérience du golf sur cette langue. (Oh, -zc'est nouveau pour moi, mais je suis d'accord. Je resterai sans.)
GammaFunction
Bien joué, je suis toujours heureux de voir une réponse sed
Kritixi Lithos
1

05AB1E , 15 octets

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

Essayez-le en ligne!

Pas regexes dans 05AB1E, donc nous nous sommes séparés sur ", faire une liste des alternance ``et '', puis les deux entrelacer.

Grimmy
la source
1
Ok, on dirait que je n'ai pas besoin de corriger et d'annuler ma réponse. ;)
Kevin Cruijssen
1

Haskell , 67 60 58 octets

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

Essayez-le en ligne!

La fonction pertinente est (#0).

Comme je pensais à l'origine que la question nous obligeait également à convertir des guillemets simples, voici une version qui gère les deux:

Haskell , 125 octets

(#(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

Essayez-le en ligne!

Post Rock Garf Hunter
la source
"\""devrait être "''"(deux apostrophes)
siracusa
@siracusa Merci, je suppose que puisque vous pouvez utiliser "en tex, vous pouvez l'utiliser ici.
Post Rock Garf Hunter
1

QuadR , 14 octets

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

Essayez-le en ligne!

Recherche / remplacement simple à l'aide de l'encapsuleur @ Adám pour Dyalog APL ⎕R fonction eplace de .

Comment:

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

rouge , 79 octets

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

Essayez-le en ligne!

Galen Ivanov
la source
0

Gelée , 13 octets

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

Un programme complet.

Essayez-le en ligne!

Comment?

ṣ”"µ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
la source
0

Lua , 36 octets

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

Essayez-le en ligne!

Wow, seulement deux caractères de plus que la solution js.

val dit de réintégrer Monica
la source
0

Stax , 11 octets

û╩↕H£ñ╟Uzay

Exécuter et déboguer

Procédure:

  1. Prenez toutes les entrées, les nouvelles lignes et tout.
  2. Regex remplace '"'par un bloc qui produit des sorties alternées de paires de backticks et de foreticks (?)
récursif
la source
0

Java 8, 40 octets

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

Essayez-le en ligne.

Explication:

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

Explication de l'expression régulière:

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