Quando i bambini aprono la bocca, non stanno solo vomitando senza senso. In realtà stanno parlando in una cifra altamente avanzata, a prova di adulto ...

The Baby-talk Cipher

Quando un bambino parla, potrebbe assomigliare a gogooa gagooook aagaaoooy Ogni sezione separata da uno spazio singolo rappresenta un personaggio (quindi l'esempio sopra rappresenta 3 caratteri).

Per decifrare una sezione, dobbiamo contare il numero di As e Os che contiene. Tuttavia, contiamo solo quelli che sono adiacenti a un'altra vocale. Ad esempio, A in "gag" non conta, ma sia A che O in "gaog" lo farebbero.

Contare l'esempio sopra sarebbe simile a questo:

Section    | Num Os | Num As

gogooa     | 2      | 1
gagooook   | 4      | 0
aagaaoooy  | 3      | 4

Quindi usiamo questi valori per convertire l'input in testo semplice su un quadrato di Polybius. Questa è una rappresentazione 5x5 dell'alfabeto inglese, omettendo 'J' (si noti che, in baby-talk, le regole di conteggio 0 si applicano alla tabella):

  0 1 2 3 4
0 A B C D E
1 F G H I K
2 L M N O P
3 Q R S T U
4 V W X Y Z

Usando il numero di Os come colonna e il numero di As come riga, troviamo quale carattere rappresenta ciascuna sezione:

Section    | Num Os | Num As | Character

gogooa     | 2      | 1      | (2,1) -> H
gagooook   | 4      | 0      | (4,0) -> E
aagaaoooy  | 3      | 4      | (3,4) -> Y

Il che ci dice che il bambino stava solo dicendo "HEY".

Note :
- Se una sezione che rappresenta un personaggio ha più di 4 As o Os, ignora gli extra, perché 4 è il valore massimo sulla tabella. - Per questa attività, Y non è una vocale - solo A, E, I, O e U.

La sfida

Il tuo compito è creare un programma completo che accetta un input, una parola in baby-speak e lo stampa in chiaro.

• Il programma deve essere in grado di accettare input in maiuscolo, minuscolo e un mix di entrambi.
• L'input conterrà solo lettere dell'alfabeto ASCII (AZ e az), con spazi singoli per separare le parole del bambino.
• Il testo di output può essere in ogni caso.
• Dovresti prendere l'input STDINe stampare il testo in chiaro STDOUT. Se la tua lingua non li possiede, usa l'equivalente più vicino.
• Questo è code-golf , quindi vince il codice più breve in byte, ma qualsiasi soluzione è benvenuta.

Casi test

'GLOOG KAKAAOOO ARGOOO OOOOOGUGUU' -> CODE
'oaka pooopaa gaau augu' -> GOLF
'Aoao U oOOAoa oaoAoo aoAoAOa' -> NAPPY
'GUG gAGaA gOougOou' -> ALE
'OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI' -> HELLO

05AB1E , 46 byte

lð¡vyžNvyð:}ð¡D€g1›ÏJ©'a¢4‚W5*®'o¢4‚Ws\+A'j-è?

Provalo online!

Spiegazione in passaggi

1. diviso in spazi per formare parole
2. sostituisci i kononanti in parole con spazi
3. dividere le parole negli spazi per formare gruppi di vocali
4. rimuovere i gruppi vocalici con una lunghezza inferiore a 2
5. ottenere il minimo di conteggio (a) e 4, moltiplicare per 5
6. ottenere min di conteggio (o) e 4
7. aggiungi conteggi
8. ricevi una lettera in quell'indice dell'alfabeto (esclusa "j")

Perl, 82 byte

Include +1 per -a

Dare input su STDIN:

perl -M5.010 baby.pl <<< "OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI"

baby.pl:

#!/usr/bin/perl -a
say map{$A=$O=$_=uc;y/AEIOU/@/c;s/(\B.|.\B)/$$1+=$$1<4/eg;(A..I,K..Z)[5*$A+$O]}@F

Questo presuppone una versione perl abbastanza recente dove -aimplica -n. Se il tuo perl è troppo vecchio, dovrai aggiungere -nun'opzione esplicita .

Presuppone anche che i bambini non possano dire stringhe ASCII generali che iniziano con cifre come 1 this will not work

Brainfuck, 656 byte

+[[>>>,[>++++[<-------->-]]<]<<[>]<-[+[<+>>+<-]----[>>+<<----]>>+[<[-<]<[>]>>-]-<[[-]>+<]>[[-[->]<<+>]<->>>]<<<[>>>+<<<-]<<-]>>>>>[[<+>>+<-]----[>-<----]>--[----<]<[>]>[----<]<[>]>[------<]<[>]>[------<]<[>]><+>[[-]<->]>>]<<<[>->]<[<]>[>[<<<<<+>>>>>>+<-]<<<<]<[-]>>>>[<[>[>+<-]<-]>[-]->[<+>-]>>]<<<[-<----[>-<----]>[>+>+<<-]+>[<->[-]<]<[<]>[[<<<]<+>>>>[>>>]<<<-]>+>--------------[<->[-]]<[-<<<<[<<<]>+>>[>>>]>]<<<<]<[<+<+>>-]>++++[<<[->]>[<]>-]+<<[[-]++++<[-]>>]>[<]<<[>+<-]>>+>->[>+>+<<-]<++++[>>[-<]<[>]<-]>>[[-]++++>[-]]<<<[>]<->>>>[<+>-]<[<<<+>>>-]<<<<[>+++++<-]>[>+>+<<-]<++++++++[>>[-<]<[>]<-]>>[[-]>+<]----[>+<----]>++.[-]+>>>,[<++++[>--------<-]]>]

Questo è stato un ottimo modo per uccidere un paio d'ore.

Richiede un interprete brainfuck che utilizza celle di wrapping a 8 bit, consente di andare a sinistra dalla cella 0 e restituisce 0 se , viene utilizzato quando lo stdin è vuoto. Nella mia esperienza, queste sono le impostazioni più comuni.

Questo programma non considera Y una vocale, ma se OP lo vuole è una soluzione semplice.

Sembra che scrivere questo sia un compito scoraggiante, ma se hai familiarità con la lingua non c'è nulla di sorprendente o di nuovo nel codice. Tattiche di brainfuck standard: leggi l'input ma assicurati di lasciare un paio di celle vuote tra ogni byte, usa quelle celle vuote per memorizzare i dati sull'input, usa i dati che hai archiviato per decidere come trasformarlo e sputare qualcosa alla fine . In questo caso è stato ottenuto l'input, impostato tutto in maiuscolo, capire quali celle sono vocali, buttare via quelle informazioni dopo averle utilizzate per determinare quali celle sono accanto alle vocali, impostare tutto ciò che non è accanto a una vocale per alcuni valore che non sarà mai rilevante, quindi non lo saranno più in seguito e il gioco è fatto. Da lì devi solo contare i tuoi 5 per 5 e aggiungere il numero diA s e Os, si moltiplicanoAOs, caso speciale qualsiasi cosa sopra 8 per evitare J e output. Ho scelto di gestire questa parola una alla volta, piuttosto che prendere l'intero input in una volta, quindi ho dovuto impostare la parte del codice che legge stdin per spezzare a 0 o 32, ma non è un grosso problema (basta avvolgere la sottrazione per 32 in un condizionale in modo che non accada se il valore è già 0, quindi correggere per qualsiasi <o> istruzioni che hai perso in seguito).

Non so quanto sarà utile perché l'ho scritto principalmente per mantenere i miei pensieri chiari piuttosto che come una vera spiegazione, ma ecco il codice con i miei commenti e il suo rientro originale:

+[[>>>,[>++++[<-------->-]]<]get an entire word of input
                            each character lowered by 32
                            two empty cells between characters
                            stops when reaching a space or null byte

any lowercase letters have become uppercase; anything with a value below 65 used
to be an uppercase character; fix it

<<[>]<-[+                for each character until hitting 1:
  [<+>>+<-]              make a backup
  subtract 64 from the character but stop if it hits 0
  ----[>>+<<----]>>+     generate the number 64
  [                      64 times:
    <[                     if the character is not 0:
      -                    subtract 1
      <                    go to a guaranteed 0 cell to break the loop
    ]

    we're either on the character or to the left of it; sync up
    <[>]

  >>-]
  -<[[-]>+<]>            logical NOT of character

  [                      if logical NOT returns true:
    [-[->]<<+>]<-          add 32 to backup of character
  >>>]

  <<<[>>>+<<<-]          move copy over to make room
<<-]
  >>>>>[                 for each character:
  [<+>>+<-]              make copies
  ----[>-<----]>--       check if it's A
  [----<]<[>]>           check if it's E
  [----<]<[>]>           check if it's I
  [------<]<[>]>         check if it's O
  [------<]<[>]>         check if it's U

  IF YOU NEED TO ADD Y; THIS IS THE PLACE

  <+>[[-]<->]            logical NOT to complete vowel check
>>]

<<<[                if the last char is a vowel; prevent a side effect
  >->
]

<[<]>[                 for each character:
  >[                     if it's a vowel:
    <<<<<+>>>>>>+<-          leave a flag to the left and right to show that a
  ]                          vowel is adjacent
<<<<]

<[-]>                  clean up a side effect left behind if first char is vowel

>>>[                   for each char:
  <[                     if it's adjacent to a vowel:
    >[>+<-]<-              move it to the side
  ]
  >[-]-                otherwise; destroy it
  >[<+>-]              move backup over if it exists (subtracting 1)
>>]

all characters without a vowel beside them have been set to 255
all characters with a vowel beside them are set to itself minus 1

notable charaters are: 'A' minus 1 = 64
                       'O' minus 1 = 78

<<<[                 for each character:
  -<----[>-<----]      subtract 64
  >[>+>+<<-]           make a copy
  +>[<->[-]<]<[<]>     logical NOT

  [[<<<]<+>>>>[>>>]<<<-] if NOT returns true; record an A

  >+>--------------  subtract 14 from backup

  [<->[-]]<          logical NOT
  [-<<<<[<<<]>+>>[>>>]>] if NOT returns true; record an O
<<<<]


<[<+<+>>-]           make a backup of A count
>++++[<<[->]>[<]>-]  subtract 4 but don't go below 0
+<<[                   if the char was greater than 3:
  [-]++++<[-]>>          put 4 there
]
>[<]                  resynchronise
<<[>+<-]              if there were fewer than 4 As put the number back

same thing but for the O count

>>+>->[>+>+<<-]       make a backup of O count
<++++[>>[-<]<[>]<-]   subtract 4 but don't go below 0
>>[                     if the char was greater than 3:
  [-]++++>[-]             put 4 there
]
<<<[>]                resynchronise
<->>>>[<+>-]          if there were fewer than 4 Os put the number back

<[<<<+>>>-]<<<<[>+++++<-] A*5 plus B = index of character to output

>[>+>+<<-]            make a backup
<++++++++[>>[-<]<[>]<-] subtract 8 but don't go below 0
>>[[-]>+<]            if the result is nonzero it is late enough in the alphabet
                      that it must be increased by 1 to exclude J as a possible
                      output
----[>+<----]>++      add 65 to make it a letter
.[-]+>>>,             output and get new input
[<++++[>--------<-]]> sub 32 if not 0
]

JavaScript (ES6), 145 byte

alert(prompt().replace(/\S+ ?/g,x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)))

Sostituisce ogni parola (e lo spazio seguente) con la lettera corrispondente.

s.split` `.map().join`` è più lungo di 3 byte:

alert(prompt().split` `.map(x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)).join``)

Perl, 159 +1 = 160 byte

+1 byte per -n flag. Lo spazio bianco non fa parte del codice e viene fornito solo per la leggibilità.

for(split$",lc){
    $b=0;
    @a=sort/([ao](?=[aeiou])|(?<=[aeiou])[ao])/g;
    $b++until$b>$#a||$a[$b]eq o;
    $c=($d=$#a-$b+1)>4?4:$d;
    $b=$b>4?4:$b;
    print+(a..i,k..z)[5*$b+$c];
}

Il codice divide l'input per spazi e converte ogni parola in minuscolo prima di procedere. La regex trova tutte le a o o vocali che sono seguite da un'altra vocale, o sono precedute da una vocale, e le ordina, a è all'inizio, o è alla fine, quindi trova l'indice della prima 'o'. Se il numero rimanente di partite (aka, il numero di "a") è maggiore di 4, allora ci preoccupiamo di 4 a, e se ci sono più di 4 o, ci preoccupiamo di 4 o. Quindi estrae la lettera appropriata dalla matrice e la stampa, quindi passa alla parola bambino successiva.

Brainfuck, 283 byte

,[[<[>-[>>>-<<<----[----[>+<------[>-<------[<[-]>>>>[-]->>[-]<<<<<-]]]]]>[>>>>+
<<<<-]>>+<[>[>+<-]>>[>+<-]<<<-]<,<<[>>>+<<<-]>]>+[<+>[-<<]>[[-]+++++[<++++++>-]<
+<]>>>]<]>>[-]>+>>+[[-]>[<+>-[<+>-[<+>-[<+>[-]]]]]<<<]>->[>+<-[[>+<-]>>+>]>[+>--
--[->]]]+[-<+]>>+++++++++++++[>+++++<-]>.,]

formattato:

,
[
  [
    <
    [
      >-
      [
        not a
        >>>-<<<
        ----
        [
          not e
          ----
          [
            not i
            >+<
            ------
            [
              not o
              >-<
              ------
              [
                consonant
                <[-]>
                >>>[-]->>[-]<<<<<-
              ]
            ]
          ]
        ]
      ]
      >[>>>>+<<<<-]> >+<
      [
        prev was vowel
        >[>+<-]>>[>+<-]<<<-
      ]
      <,<<[>>>+<<<-]
      >
    ]
    >+
    [
      <+>[-<<]
      >[[-]+++++[<++++++>-]<+<]
      >>>
    ]
    <
  ]
  >>[-]>+>>+
  [
    [-]
    >[<+>-[<+>-[<+>-[<+>[-]]]]]<
    <<
  ]
  >->
  [
    >+<-
    [
      [>+<-]
      >>+>
    ]
    >
    [
      +>----[->]
    ]
  ]
  +[-<+]
  >>+++++++++++++[>+++++<-]
  >.,
]

Funziona con o senza una nuova riga finale nell'input.

Provalo online.

Ogni carattere viene elaborato mod 32 (con flusso di controllo tale che il codice che implementa l'operazione mod si presenta una sola volta nel programma). Ciò consente l'insensibilità al maiuscolo / minuscolo, nonché la compressione del carattere spaziale e dell'EOF in un singolo caso. Una newline finale è trattata comeJ , il che non influisce sull'output.

Schizzo del layout della memoria:

0 x C c y a A b B

dove cè il carattere di input, Cè il carattere mod 32, xè se è una vocale, yè se il carattere precedente era una vocale, Ae Bsono rispettivamente i conteggi di valido (vicino alle vocali) ae dei ocaratteri, e aeb sono i rispettivi buffer che viene copiato o cancellato a seconda che vi sia una vocale adiacente.

Quando viene raggiunto uno spazio o EOF, viene eseguita una manipolazione per ridurre i conteggi maggiori di 4 e per saltare la lettera J, quindi viene stampato il carattere decodificato.

PHP, 163 byte

<?php for(;$c=preg_replace('/(?<![AEIOU]).(?![AEIOU])/','',strtoupper($argv[++$i]));$j=min($d[79],4)+5*min($d[65],4),print range(A,Z)[$j+($j>8)])$d=count_chars($c);

Versione più leggibile:

<?php
for (
    ;
    $c = preg_replace(
        '/(?<![AEIOU]).(?![AEIOU])/',
        '',
        strtoupper($argv[++$i])
    );
    $j = min($d[79], 4) + 5 * min($d[65], 4),
    print range(A, Z)[$j + ($j > 8)]
)
    $d = count_chars($c);

test:

$ php babytalk.php GLOOG KAKAAOOO ARGOOO OOOOOGUGUU
CODE
$ php babytalk.php oaka pooopaa gaau augu
GOLF
$ php babytalk.php Aoao U oOOAoa oaoAoo aoAoAOa
NAPPY
$ php babytalk.php GUG gAGaA gOougOou
ALE
$ php babytalk.php OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI
HELLO

Java 8, 272 266 251 249 byte

interface M{static void main(String[]i){String z="(?=[AEIOU])|(?<=[AEIOU])";for(String s:i[0].split(" ")){int a=s.split("(?i)A"+z+"A",-1).length-1,o=s.split("(?i)O"+z+"O",-1).length-1,t=(a>4?4:a)*5+(o>4?4:o);System.out.printf("%c",t>9?t+66:t+65);}}}

-6 byte grazie a @Joba .
Conversione di -1 byte da Java 7 a 8 e 14 16 byte aggiuntivi salvati modificando la parte di stampa.

Spiegazione:

Provalo qui.

interface M{                   // Class:
  static void main(String[]i){ //  Main method:
    String z="(?=[AEIOU])|(?<=[AEIOU])";
                               //   Regex-part for look-ahead or look-behind of vowels
    for(String s:i[0].split(" ")){  
                               //    Loop over the program-arguments
      int a=s.split("(?i)A"+z+"A",-1).length-1,
                               //     The amount of A's with adjacent vowels
          o=s.split("(?i)O"+z+"O",-1).length-1,
                               //     The amount of O's with adjacent vowels
          t=(a>4?4:a)          //     If `a` is larger than 4, just take 4, else take `a`
            *5                 //     Multiply it by 5
            +(o>4?4:o);        //     And add 4 if `o` is larger than 4, else take `o`
       System.out.printf("%c", //     Print a character:
        t>9?                   //      If `t` is larger than 9 (index of J)
         t+66                  //       Take character unicode (skipping J)
        :                      //      Else:
         t+65);                //       Take character unicode (prior to J)
    }                          //   End of loop
  }                            //  End of main-method
}                              // End of program

Python 3, 163 162 157 146 byte

import re
for W in input().upper().split():S=''.join(re.findall("[AEIOU]{2,}",W)).count;I=min(S('A'),4)*5+min(S('O'),4);print(end=chr(65+I+(I>9)))

Usa regex per trovare tutte le stringhe di vocali più grandi di 2, conta As e Os con un massimo di 4 e quindi stampa.

APL, 60

{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶

Nota che ←IO ← 0 e ⎕ML ← 3

Esempio:

fn←{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶
fn 'Aoao U oOOAoa oaoAoo aoAoAOa'
NAPPY

Funziona in Dyalog 15.0 , poiché è la versione in cui 819⌶ è stato introdotto per minuscole una stringa.

Pyth, 64 byte

Probabilmente può essere ulteriormente giocato a golf. Provalo qui!

L?<b5b4DebK+ds:rbZ"[aeiou]{2,}"1J+*/K\a5y/K\oR@G?<J9JhJu+GeHcQd"

R, 261 byte

Penso di aver speso troppo tempo solo per farlo funzionare e credo che questa sia una soluzione inutilmente complicata, sebbene funzioni. Prende input da stdin, è importante che la stringa sia racchiusa tra virgolette.

x=el(strsplit(toupper(scan(,""))," "))
cat(apply(sapply(c("A","O"),function(y)sapply(sapply(regmatches(x,gregexpr("[AEIOU]{2,}",x,)),paste,collapse=""),function(s)min(sum(el(strsplit(s,""))%in%y),4)))+1,1,function(z)t(matrix(LETTERS[-10],5))[z[1],z[2]]),sep="")

L'uso di quattro applyfamiglie nidificate potrebbe teoricamente essere ridotto a due solo usando mapplyinvece. Ma poiché gli input per mapplynon avranno la stessa lunghezza, il più breve viene riciclato, il che complica le cose e non sono riuscito a trovare una soluzione funzionante.

Se qualcuno è interessato, aggiungerò una spiegazione non scritta in seguito.

Prova tutti i casi di test su R-fiddle

Si noti che questa versione accetta input come argomento della funzione anziché da stdin perché scannon funziona su R-fiddle. Inoltre, è stata aggiunta una nuova riga per facilitare la lettura.

Python 3, 262 byte

import re;f,b,v,n,r,l,t,g,a,o=re.findall,input().lower(),'aeiou',list(range(26)),'[aeiou]','abcdefghiklmnopqrstuvwxyz','',len,'a','o';del n[9],
for w in b.split():
 O,A=g(f(o+r,w))+g(f(r+o,w)),g(f(a+r,w))+g(f(r+a,w))
 if O>4:O=4
 if A>4:A=4
 t+=l[A*5+O]
print(t)

Less Golfed (I commenti sono le variabili nel codice abbreviato):

import re
findAll = re.findall #f
babyTalk = input('Baby Talk: ').lower() #b
vowels = 'aeiou' #v
numbers = list(range(26)) #n
del numbers[9]
letters = 'abcdefghiklmnopqrstuvwxyz' #l
finalText = '' #t
length = len #g
regex = '[aeiou]' #r
o = 'o' #o
a = 'a' #a
for word in babyTalk.split(): #w in b
 Os = len(findAll('o[aeiou]', word)) + len(findAll('[aeiou]o', word)) #O
 As = len(findAll('a[aeiou]', word)) + len(findAll('[aeiou]a', word)) #A
 if Os > 4: Os = 4
 if As > 4: As = 4
 print(As, Os)
 finalText += letters[As*5+Os]
 print(finalText)

Provalo online!

Kotlin , 221 209 byte

Ora molto più brutto e lento, tutto in nome di 11 byte

readLine()!!.toLowerCase().split(" ").map{fun
c(c:Char)=Regex("([aeiou]{2,})").findAll(it).fold(0){a,b->a+b.value.count{it==c}}.let{if(it>4)4 else it}
(('A'..'I')+('K'..'Z'))[c('a')*5+c('o')]}.forEach(::print)

Salvalo in un file (es. BabyTalk.kts) Per eseguirlo come script. Oppure, il codice sopra può essere anteposto fun main(z:Array<String>)=e compilato normalmente per un costo di 26 byte in più.

Provalo online!

rientrato:

readLine()!!
    .toLowerCase()
    .split(" ")
    .map {
        fun c(c: Char) =
            Regex("([aeiou]{2,})")
                .findAll(it)
                .fold(0) {
                    a, b ->
                    a + b.value.count { it == c }
                }
                .let { if (it > 4) 4 else it }
        (('A'..'I') + ('K'..'Z'))[c('a') * 5 + c('o')]
    }
    .forEach(::print)

PHP, 124 129 121 120 125 byte

for(;$s=$argv[++$i];print chr((8<$O+=5*$A)+$O+65))for($k=$A=$O=0;$c=_&$s[$k++];$p=$c)$$c+=$$c<4&!trim($p.$s[$k]&__,AEIOU)[1];

Accetta input dagli argomenti della riga di comando. Corri con -nro provalo online .

abbattersi

for(;$s=$argv[++$i];            # loop $s through arguments
    print chr((8<$O+=5*$A)+$O+65)   # 3. map A and O counts to letter, print
)
    for($k=$A=$O=0;                 # 1. reset A and O counters
        $c=$s[$k++]&_;              # 2. loop $c through characters:
        $p=$c)                          # 2. remember current character as previous
        $$c+=                           # 1. increment counter for $c, if ...
            $$c<4&                          # it is < 4 and ...
            !trim($p.$s[$k]&__,AEIOU)[1];   # ... previous or next char is vowel

J , 109 byte

echo{&(u:97+i.26)(+8<[)5#.4<.'AO'+/@e."1 0/~(;@#~1<#@>)@(</.~0+/\@,}.~:&(e.&'AEOUI')}:);._1' ',toupper 1!:1]3

Provalo online!