Atualmente, estou digitalizando vários documentos manuscritos e convertendo-os em .txtarquivos. Como eu tenho uma caligrafia terrível, o conversor .jpg-> .txtconverte alguns dos meus tremas para a letra "normal" envolvida por'

Tarefa

Escreva um programa ou uma função que:

• É dada uma string
  • você pode escolher qualquer página de código de E / S, desde que
    • suporta os caracteres AEIOUaeiouÄËÏÖÜäëïöü'.
      • é proibida a combinação de diacríticos
    • as páginas de código de entrada e saída são as mesmas.
  • a entrada (ao lado de espaços) conterá apenas caracteres imprimíveis da sua página de código.
    • Haverá apenas uma solução, portanto, coisas como 'a'e'não aparecerão
• Converte todos os caracteres no seguinte conjunto AEIOUaeiouparaÄËÏÖÜäëïöü
  • Se, e somente se, eles estiverem cercados por 'caracteres:
    • Exemplo :'a''e' -> äë
  • Se a string from for uma única letra.
    • por exemplo 'AE', não muda nada, produzindo como está.
  • Se a partir de personagem não é um personagem de AEIOUaeiouque o personagem não vai mudar.

Nota: O caractere from / from é o que está entre '.

Casos de teste

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

Tente

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>

Explicação

• s=> Função anônima tomando a string de entrada como argumento via parâmetro "s".
• s.replace(x,y) Retorna a string com "x" substituído por "y".
• /'[aeiou]'/gi Expressão regular que não diferencia maiúsculas de minúsculas que corresponde a todas as ocorrências de uma vogal entre aspas simples.
• c=> Passa cada correspondência da expressão regular para uma função anônima através do parâmetro "c".
• "ï ÖÄöä ËÜëüÏ "[n]Retorna o enésimo caractere (0 indexado) na string "ï ÖÄöä ËÜëüÏ", semelhante a "ï ÖÄöä ËÜëüÏ ".charAt(n).
• c.charCodeAt(1)%15 Obtém o restante do código de caractere do segundo caractere em "c" (isto é, o caractere de vogal) quando dividido por 15.

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

A seguir, foi minha resposta antes que a combinação de diacríticos não fosse permitida (Boo-urns!) - melhor visualizada neste Fiddle

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

No entanto, a ETHproductions sugere que, com a adição de .normalize()12 bytes adicionais, isso seria válido.

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

Perl 5, 25 bytes

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

24 bytes, mais 1 para em -pevez de-e

Isso faz uso da regra de que "você pode escolher qualquer página de código de E / S, desde que ela suporte os caracteres AEIOUaeiouÄËÏÖÜäëïöü'". Ele também usa o /asinalizador nas expressões regulares, o que faz \wcom que se refira com precisão aos caracteres, abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789não importa como eles sejam codificados.

A página de código de E / S escolhida para o meu script é 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  '

(Não posso testar esse script nos casos de teste da pergunta, pois eles incluem alguns caracteres realmente estranhos, como t.)

Agradeço ao Grimy por me salvar três bytes. Antes, eu tinha s/'([a-z])'/chr 1+ord$1/gie, que utilizava (a codificação e) o fato interessante que [a-z]é especial no Perl para corresponder precisamente, abcdefghijklmnopqrstuvwxyzindependentemente da codificação. Minha resposta anterior é: IMO, mais interessante, mas essa é mais curta, então, que diabos, eu aceito.

Vim, 33 bytes

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

Experimente online! no intérprete V compatível com versões anteriores.

Japonês , 29 bytes

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

Experimente online!

Explicação

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)

Experimente online!

Substitua todos os caracteres entre aspas pelo caractere treinado correspondente ou pela correspondência em si, se não estiver no grupo de caracteres que precisam ser alterados.

Gelatina , 36 bytes

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

Experimente online!

Isso parece bastante complicado para Jelly!

Quão?

Nota: Como os caracteres não estão na página de código, mas estão dentro do intervalo de um byte no Unicode, acho que devem ser criados a partir dos ordinais, por isso tenho.

œṣ⁹Ṫ¤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@"

Experimente online!

Hexdump:

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

Esta é apenas uma tradução direta da minha resposta vim para que eu possa vencer todos os idiomas do golfe. : P

Ruby , 62 + 1 = 63 bytes

Usa o -psinalizador para +1 byte.

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

Experimente online!

/// , 67 bytes

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

Experimente online!

Isso funciona substituindo letras não pontilhadas entre aspas simples ( 'A') pela mesma letra que pontilhada, sem as aspas simples ( Ä). Uma única substituição deste parecido com este (antes do golf): /'A'/Ä/.

O golfe tem duas ocorrências comuns, //e '/, e usa-los como substitutos.

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]}

Experimente online!

Usa PCRE R moran Jr. (salvando o RegEx como v ) para aplicar a seguinte função para vogais indicados:

{ função anônima

 ' ÄËÏÖÜäëïöü'[… ] Indexe a string (observe dois espaços correspondentes a '[) com:

  ⍵.Match a sequência correspondente

  2⊃ escolha a segunda letra (a vogal)

  v⍳ encontre o índice em v

}

AWK , 99 bytes

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

Experimente online!

Eu tentei chegar a algum regex inteligente dentro de um gensubmas falhou :(

SOGL , 43 35 (UTF-8) bytes

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

Explicação:

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 graças a Emigna

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

05AB1E possui convenientemente os caracteres äëïöüem sua página de código.

Experimente online!

(código antigo)

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

Explicação (desatualizada):

ž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

Experimente online!

Python 3.6, 98 92 caracteres

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

É uma função, não um programa completo.

Formatado para facilitar a leitura:

import re

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

Agradecemos a @ValueInk por dicas inteligentes para continuar jogando.

Retina , 39 bytes

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

Experimente online!