Actualmente estoy escaneando un montón de documentos escritos a mano y convirtiéndolos en .txtarchivos. Como tengo una letra terrible, el convertidor .jpg-> .txtconvierte algunas de mis diéresis a la letra "normal" encerrada por'

Tarea

Escribe un programa o una función que:

• Se le da una cadena
  • puede elegir cualquier página de códigos de E / S siempre que
    • Es compatible con los personajes AEIOUaeiouÄËÏÖÜäëïöü'.
      • se prohíbe combinar diacríticos
    • Las páginas de códigos de entrada y salida son las mismas.
  • la entrada (junto a los espacios) solo contendrá caracteres imprimibles de su página de códigos.
    • Solo habrá una solución, por lo 'a'e'que no aparecerán cosas como
• Convierte todos los caracteres del siguiente conjunto AEIOUaeiouenÄËÏÖÜäëïöü
  • Si, y solo si, están rodeados de 'caracteres:
    • Ejemplo :'a''e' -> äë
  • Si la cadena from es una sola letra.
    • por ejemplo 'AE'no cambia en absoluto, generando tal cual.
  • Si el del personaje no es un personaje de AEIOUaeiouese personaje no va a cambiar.

Nota: El carácter de / cadena de es el que está entre '.

Casos de prueba

Input
Output
<empty line>

'A'sthetik
Ästhetik

Meinung ist wichtig!
Meinung ist wichtig!

Ich sagte: "Er sagte: 'Ich habe Hunger'"
Ich sagte: "Er sagte: 'Ich habe Hunger'"

Ich sagte: "Er sagte: ''A'sthetik'"
Ich sagte: "Er sagte: 'Ästhetik'"

Hämisch rieb er sich die H'a'nde
Hämisch rieb er sich die Hände

H'a''a'slich isn't a German word
Hääslich isn't a German word

since it's really called h'a'sslich
since it's really called hässlich

JavaScript (ES6), 81 70 68 bytes

s=>s.replace(/'[aeiou]'/gi,c=>"ï   ÖÄöä ËÜëüÏ "[c.charCodeAt(1)%15])

Intentalo

f=
s=>s.replace(/'[aeiou]'/gi,c=>"ï   ÖÄöä ËÜëüÏ "[c.charCodeAt(1)%15])
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("'A'sthetik")) // Ästhetik
console.log(f("Meinung ist wichtig!")) // Meinung ist wichtig!
console.log(f(`Ich sagte: "Er sagte: 'Ich habe Hunger'"`)) // Ich sagte: "Er sagte: 'Ich habe Hunger'"
console.log(f(`Ich sagte: "Er sagte: ''A'sthetik'"`)) // Ich sagte: "Er sagte: 'Ästhetik'"
console.log(f("Hämisch rieb er sich die H'a'nde")) // Hämisch rieb er sich die Hände
console.log(f("H'a''a'slich isn't a German word")) // Hääslich isn't a German word
console.log(f("since it's really called h'a'sslich")) // since it's really called hässlich

<input id=i><pre id=o>

Explicación

• s=> Función anónima que toma la cadena de entrada como argumento a través del parámetro "s".
• s.replace(x,y) Devuelve la cadena con "x" reemplazada por "y".
• /'[aeiou]'/gi Expresión regular que no distingue entre mayúsculas y minúsculas que coincide con todas las apariciones de una vocal encerrada entre comillas simples.
• c=> Pasa cada coincidencia de la expresión regular a una función anónima a través del parámetro "c".
• "ï ÖÄöä ËÜëüÏ "[n]Devuelve el enésimo carácter (0 indexado) en la cadena "ï ÖÄöä ËÜëüÏ", similar a "ï ÖÄöä ËÜëüÏ ".charAt(n).
• c.charCodeAt(1)%15 Obtiene el resto del código de caracteres del segundo carácter en "c" (es decir, el carácter vocal) cuando se divide por 15.

Alternativa, 40/52 36/48 bytes (35/47 caracteres)

La siguiente fue mi respuesta antes de que no se permitieran combinar los signos diacríticos (¡Boo-urnas!), Mejor visto en este violín

s=>s.replace(/'([aeiou])'/gi,"$1̈")

Sin embargo, ETHproductions sugiere que con la adición de .normalize()12 bytes adicionales, esto sería válido.

s=>s.replace(/'([aeiou])'/gi,"$1̈").normalize()

Perl 5, 25 bytes

s/'(\w)'/chr 1+ord$1/age

24 bytes, más 1 para en -pelugar de-e

Esto utiliza la regla de que "puede elegir cualquier página de códigos de E / S siempre que admita los caracteres AEIOUaeiouÄËÏÖÜäëïöü'". También hace uso de la /abandera en las expresiones regulares, lo que hace \wque se refiera con precisión a los caracteres abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789sin importar cómo estén codificados.

La página de códigos de E / S elegida para mi script es esta:

 1  a
 2  ä
 3  e
 4  ë
 5  i
 6  ï
 7  o
 8  ö
 9  u
10  ü
11  A
12  Ä
13  E
14  Ë
15  I
16  Ï
17  O
18  Ö
19  U
20  Ü
21  '

(No puedo probar este script en los casos de prueba en la pregunta, ya que incluyen algunos personajes realmente extraños, como t).

Gracias a Grimy por salvarme tres bytes. Anteriormente, lo hice s/'([a-z])'/chr 1+ord$1/gie, que hizo uso de (la codificación y) el hecho interesante de que [a-z]está especialmente revestido en Perl para que coincida con precisión abcdefghijklmnopqrstuvwxyzsin importar la codificación. Mi respuesta anterior es, OMI, más interesante, pero esta es más corta, así que, qué diablos, lo tomaré.

Vim, 33 bytes

:s/\c'\([aeiou]\)'/<C-v><C-k>\1:/g
ii<esc>D@"

Pruébalo en línea! en el intérprete de V compatible con versiones anteriores.

Japt , 29 bytes

r"'%v'"@"ï   ÖÄöä ËÜëüÏ "gXc1

Pruébalo en línea!

Explicación

r"'%v'"@"ï   ÖÄöä ËÜëüÏ "gXc1

r"'%v'"@                       // Replace each match X of /'<vowel>'/ in the input with
        "ï   ÖÄöä ËÜëüÏ "g     //   the character in this string at index
                          Xc1  //     X.charCodeAt(1).
                               //   Values larger than the length of the string wrap around,
                               //   so this is effectively equal to " ... "[n%15].
                               // Implicit: output result of last expression

Javascript, 67 bytes

s=>s.replace(/'.'/g,c=>"äëïöüÄËÏÖÜ"['aeiouAEIOU'.indexOf(c[1])]||c)

Pruébalo en línea!

Reemplace todos los caracteres entre comillas con el carácter diferido correspondiente o la coincidencia en sí misma si no está en el grupo de caracteres que necesita cambiar.

Jalea , 36 bytes

œṣ⁹Ṫ¤j
“.ạẏụ’D196;+\Ọż⁾''jЀØc¤;@Wç/

Pruébalo en línea!

¡Esto parece bastante complicado para Jelly!

¿Cómo?

Nota: Dado que los caracteres no están en la página de códigos, pero están dentro del rango de un byte en Unicode, creo que deben crearse a partir de ordinales, así que lo he hecho.

œṣ⁹Ṫ¤j - Link 1, Replace: char list S [...], list R [char T, char list F]
œṣ     - split S at sublists equal to:
    ¤  -   nilad followed by link(s) as a nilad:
  ⁹    -     link's right argument, R
   Ṫ   -     tail - yield char list F and modify R to become [T]
     j - join with R (now [T])
       - all in all split S at Rs and join back up with [T]s.

“.ạẏụ’D196;+\Ọż⁾''jЀØc¤;@Wç/ - Main link: char list S
       196;                   - 196 concatenate with:
“.ạẏụ’                        -   base 250 literal 747687476
      D                       -   to decimal list [7,4,7,6,8,7,4,7,6]
           +\                 - cumulative reduce with addition: [196,203,207,214,220,228,235,239,246,252]
             Ọ                - cast to characters: ÄËÏÖÜäëïöü
                       ¤      - nilad followed by link(s) as a nilad:
               ⁾''            -   literal ["'", "'"]
                     Øc       -   vowel yield: AEIOUaeiou
                  jЀ         -   join mapped:  ["'A'", "'E'", ...]
              ż               - zip together
                          W   - wrap S in a list
                        ;@    - concatenate (swap @rguments)
                           ç/ - reduce with last link (1) as a dyad
                              - implicit print

V , 24 bytes

Óã'¨[aeiou]©'/±:
éiD@"

Pruébalo en línea!

Hexdump:

00000000: d3e3 27a8 5b61 6569 6f75 5da9 272f 160b  ..'.[aeiou].'/..
00000010: b13a 0ae9 6944 4022                      .:..iD@"

Esta es solo una traducción directa de mi respuesta vim para que pueda superar todos los idiomas de golf. :PAG

Ruby , 62 + 1 = 63 bytes

Utiliza la -pbandera para +1 byte.

gsub(/'([aeiou])'/i){$1.tr"AEIOUaeiou","ÄËÏÖÜäëïöü"}

Pruébalo en línea!

/// , 67 bytes

/~/'\///`/\/\/~/'A~Ä`E~Ë`I~Ï`O~Ö`U~Ü`a~ä`e~ë`i~ï`o~ö`u~ü/

Pruébalo en línea!

Esto funciona reemplazando las letras no punteadas entre comillas simples ( 'A') con la misma letra que las punteadas, sin las comillas simples ( Ä). Una única sustitución de este se parece a esto (antes de que el golf): /'A'/Ä/.

El golf toma dos ocurrencias comunes, //y '/, y las usa como reemplazos.

Swift - 201 bytes

import Foundation;func g(s:String){var e=s;var r="aeiouAEIOUäëïöüÄËÏÖÜ".characters.map{String($0)};for i in r[0...9]{e=e.replacingOccurrences(of:"'\(i)'",with:r[r.index(of:i)!+10])};print(e)}

Uso: g("'A'sthetik") // => Ästhetik

APL (Dyalog) , 53 bytes

(v←'''[AEIOUaeiou]''')⎕R{'  ÄËÏÖÜäëïöü'[v⍳2⊃⍵.Match]}

Pruébalo en línea!

Utiliza PCRE R eplace (guardando el RegEx como v ) para aplicar la siguiente función a las vocales citadas:

{ función anónima

 ' ÄËÏÖÜäëïöü'[… ] Indexe la cadena (observe dos espacios correspondientes a '[) con:

  ⍵.Match la cuerda combinada

  2⊃ elegir segunda letra (la vocal)

  v⍳ encontrar índice en v

}

AWK , 99 bytes

{split("AEIOUaeiou",p,"")
for(i=1;i<=split("ÄËÏÖÜäëïöü",r,"");i++)gsub("'"p[i]"'",r[i])}1

Pruébalo en línea!

Traté de encontrar una expresión regular inteligente dentro de un gensubpero fallé :(

SOGL , 43 35 (UTF-8) bytes

L∫:ÆW ':h++;"äëïöü”:U+Wŗ

Explicación:

L∫                        repeat 10 times, pushing current iteration (0-based)
  :                       duplicate the iteration
   ÆW                     get the index (1-based) in "aeiouAEIOU"
      ':h++               quote it
           ;              put the copy (current iteration) ontop
            "äëïöü”       push "äëïöü"
                   :      duplicate it
                    U     uppercase it
                     +    join together, resulting in "äëïöüÄËÏÖÜ"
                      W   get the index (1-based) in it
                       ŗ  replace [in the input, current char from "aeiouAEIOU" with
                          the corresponding char in "äëïöüÄËÏÖÜ"

05AB1E , 30 29 24 bytes

-6 bytes gracias a Emigna

žMDu«S''«''ì"äëïöü"Du«S:

05AB1E tiene convenientemente los caracteres äëïöüen su página de códigos.

Pruébalo en línea!

(código antiguo)

žMDu«Svy''.ø})"äëïöü"Du«¹ŠS:

Explicación (obsoleta):

žM                             Push aeiou                    ['aeiou']
  D                            Duplicate                     ['aeiou', 'aeiou']
   u                           Uppercase                     ['aeiou', 'AEIOU']
    «                          Concatenate                   ['aeiouAEIOU']
     vy                        For each...
       ''                        Push '
         .ø                      Surround a with b (a -> bab)
           }                   End loop
            )                  Wrap stack to array           [["'a'", "'e'", "'i'", "'o'", "'u'", "'A'", "'E'", "'I'", "'O'", "'U'"]]
             "äëïöü"           String literal.               [["'a'", "'e'", "'i'", "'o'", "'u'", "'A'", "'E'", "'I'", "'O'", "'U'"], 'äëïöü']
                    Du«        Duplicate, uppercase, concat  [["'a'", "'e'", "'i'", "'o'", "'u'", "'A'", "'E'", "'I'", "'O'", "'U'"], 'äëïöüÄËÏÖÜ']
                       ¹       Push first input
                        Š      Push c, a, b                  ["'A'sthetik", ["'a'", "'e'", "'i'", "'o'", "'u'", "'A'", "'E'", "'I'", "'O'", "'U'"], 'äëïöüÄËÏÖÜ']
                          S    Convert to char list          ["'A'sthetik", ["'a'", "'e'", "'i'", "'o'", "'u'", "'A'", "'E'", "'I'", "'O'", "'U'"], ['ä', 'ë', 'ï', 'ö', 'ü', 'Ä', 'Ë', 'Ï', 'Ö', 'Ü']]
                           :   Replace all                   ['Ästhetik']
                               Implicit print

Pruébalo en línea!

Python 3.6, 98 92 caracteres

import re;a=lambda i,p="'([AEIOUaeiou])'":re.sub(p,lambda x:'ÄËÏÖÜäëïöü'[p.index(x[1])-3],i)

Es una función, no un programa completo.

Formateado para facilitar la lectura:

import re

a = lambda i, p="'([AEIOUaeiou])'":\
    re.sub(p, lambda x: 'ÄËÏÖÜäëïöü'[p.index(x[1]) - 3], i)

Gracias a @ValueInk por consejos inteligentes para seguir jugando al golf.

Retina , 39 bytes

iT`A\EI\OUaei\ou'`ÄËÏÖÜäëïöü_`'[aeiou]'

Pruébalo en línea!