Giochiamo a golf un decoder BIBABOBU


53

Mentre viaggiavo in futuro, ho notato un gioco divertente tra i bambini intorno al 2275. Quando non vogliono che i loro bis-bis-bis-bis-nonni capiscano quello che stanno dicendo, usano il linguaggio BIBABOBU . Ovviamente, non riuscivo a capire nulla né con il mio cervello dell'era pre-cyborg e mi sentivo (o tecnicamente: mi sentirò ) davvero sciocco. Quindi, avrei bisogno di un decodificatore per la mia prossima visita.

BIBABOBU?

Mentre è stato deprecato per molto tempo, ASCII è ancora comunemente usato nella cultura pop del 2275 e questo linguaggio si basa su di esso.

Una stringa è codificata in BIBABOBU in questo modo:

  • Converti tutti i caratteri nei loro codici ASCII.
  • Prendi la rappresentazione esadecimale a 2 cifre di ciascun codice e convertili utilizzando la seguente tabella:

    0: BI  4: BIDI  8: BADI  C: BODI
    1: BA  5: BIDA  9: BADA  D: BODA
    2: BO  6: BIDO  A: BADO  E: BODO
    3: BU  7: BIDU  B: BADU  F: BODU
    

Esempio

"Hello!" → 48 65 6C 6C 6F 21 → "BIDIBADI BIDOBIDA BIDOBODI BIDOBODI BIDOBODU BOBA"

Tuttavia, l' input corrispondente sarebbe dato senza spazio per imitare l'intonazione monotona che i bambini stanno usando per rendere questo ancora più difficile da capire senza impianti:

"BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBA"

Chiarimenti e regole

  • Ricorda che ho bisogno di un decodificatore , non di un codificatore.
  • I personaggi decodificati sono garantiti nell'intervallo [32 ... 126] .
  • È garantito che l'input contenga un numero pari di cifre esadecimali con codifica BIBABOBU.
  • È possibile accettare input in maiuscolo o minuscolo. Non sono ammessi casi misti.
  • Poiché i bit-flip sono abbastanza comuni durante un viaggio nel tempo, questo è il per ridurre al minimo i rischi.

Casi test

NB: Gli avanzamenti di riga vengono utilizzati di seguito solo a scopo di formattazione. Siete Non suppone di gestirli.

Input:
BIDABIDIBIDOBIDABIDUBUBIDUBIDI

Output:
Test

Input:
BIDABIDUBIDOBIDABIDOBODIBIDOBUBIDOBODUBIDOBODABIDOBIDABOBIBIDUBIDIBIDOBODUBOBIBUBOBUBOBUBI
DUBUBIDABOBA

Output:
Welcome to 2275!

Input:
BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBODIBOBIBIDABIDIBIDOBADABIDOBODABIDOBIDABOBIBIDA
BIDIBIDUBOBIDOBABIDUBIDOBIDOBIDABIDOBODIBIDOBIDABIDUBOBOBABOBIBIDABADABIDOBODUBIDUBIDABOBI
BIDOBODIBIDOBODUBIDOBODUBIDOBADUBOBIBIDUBUBIDOBODUBOBIBIDOBIDOBIDUBIDABIDOBODOBIDOBODOBIDU
BADABOBA

Output:
Hello, Time Traveler! You look so funny!

Input:
BIDIBABIDOBODOBIDOBIDIBOBIBIDUBADABIDOBODUBIDUBIDABOBIBIDOBIDIBIDOBODUBIDOBODOBOBIDUBIDUBI
DIBOBIBIDUBIDABIDOBODOBIDOBIDIBIDOBIDABIDUBOBIDUBUBIDUBIDIBIDOBABIDOBODOBIDOBIDIBOBIBIDUBI
DUBIDOBADIBIDOBABIDUBIDIBOBIBIDIBADABOBIDUBIDOBODABOBIBIDUBUBIDOBABIDUBADABIDOBADABIDOBODO
BIDOBIDUBOBODIBOBIBIDOBIDIBIDOBODUBOBIBIDUBADABIDOBODUBIDUBIDABUBODUBOBIBIDIBADIBIDOBABOBI
BIDOBADIBIDOBABOBIBIDOBADIBIDOBABOBA

Output:
And you don't understand what I'm saying, do you? Ha ha ha!

4
@StewieGriffin Questi dannati ragazzi sono birichini ...: - /
Arnauld

12
A proposito, trovo la storia davvero molto improbabile! Non sarei sorpreso se fosse solo un sogno che hai fatto ... potresti avere una perdita di CO in casa?
Stewie Griffin,

12
Ah ... Questo spiegherebbe anche i pony che cavalcano gli arcobaleni nel mio salotto!
Arnauld,

9
Si potrebbe sostenere che il codice golfizzato aumenta la gravità di un bit-flip (meno ridondanza all'interno del codice) anche se diminuisce la frequenza di un bit-flip ... ma comunque :) - Bella sfida!
JayCe,

4
@JayCe True. Stavo pensando di più: più piccolo è il codice, maggiore è la ridondanza che si può ottenere memorizzando più copie.
Arnauld,

Risposte:


15

05AB1E , 36 35 33 byte

Salvato 1 byte grazie a Mr.Xcoder
Salvato 2 byte grazie a KevinCruijssen

ć©¡®ì®D…IAO©â'D«‚˜®'U«âJskh2ôJHçJ

Provalo online! o come una suite di test

Spiegazione

ć©¡                                 # extract the head ("B") and split input on it
   ®ì                              # prepend "B" to each
     ®D                            # push 2 copies of "B"
       …IAO©â                      # cartesian product with "IAO"
             'D«                   # append "D" to each
                ‚˜                 # add the leftover "B" to the list
                  ®'U«â            # cartesian product with "IAOU"
                       J           # join each to string
                        sk         # get the index of each word of the input in this list
                          h        # convert each to hex
                           2ôJ     # format as pairs of chars
                              H    # convert to int
                               çJ  # convert from ascii-codes to string

Credo che 'B©¡¦®ì®D…IAO©â'D«‚˜®'U«âJskh2ôJHçJfunzioni per 35 byte.
Mr. Xcoder,

@ Mr.Xcoder: Ah, certo. Bello riutilizzo di ©. Grazie :)
Emigna,

-2 byte cambiando la porta 'Bdi će rimuovendo il ¦, poiché l'ingresso sempre inizio un 'B'.
Kevin Cruijssen,

@KevinCruijssen: Ooh, buona idea. Non avevo considerato ć. Grazie!
Emigna,

9
Ora torniamo a quei bambini e vediamo se lo capiscono!
Aaron,

14

Gelatina , 26 24 23 22 20 17 15 byte

ṣḢO^1%9%4Ḅḅ⁴b⁹Ọ

Provalo online!

Come funziona

ṣḢO^1%9%4Ḅḅ⁴b⁹Ọ  Main link. Argument: s (string)

 Ḣ               Head; remove and yield the first character of s.
ṣ                Split s at occurrences of the result ('B').
  O              Ordinal; map "IAOUD" to A1 := [73, 65, 79, 85, 68].
   ^1            Bitwise XOR 1; map A1 to A2 := [72, 64, 78, 84, 69].
     %9          Modulo 9; map A2 to A3 := [0, 1, 6, 3, 6].
       %4        Modulo 4; map A3 to A4 := [0, 1, 2, 3, 2].
                 So far, we've mapped "BX" to [x] and "BXDY" to [x, 2, y],
                 where x/y = 0, 1, 2, 3 when X/Y = I, A, O, U.
         Ḅ       Unbinary; map [x] to x and [x, 2, y] to 4x + 2×2 + y = 4(x + 1) + y.
          ḅ⁴     Convert the resulting array from base 16 to integer.
            b⁹   Convert the resulting integer to base 256.
              Ọ  Unordinal; replace code points with their characters.

13

Perl 6 , 58 byte

{S:g{(B.[D.]?)**2}=chr :16[$0».&{:2[.ords»³X%87 X%4]}]}

Provalo online!

Fortemente ispirato alla soluzione Jelly di Dennis. Utilizza una diversa funzione magica x³ % 87 % 4che mappa anche i codici ASCII di IAOUBDa 012302.

Versione alternativa da 75 74 byte

-1 byte grazie a Jo King

{pack('H',.trans((<B BID BAD BOD>X~ <I A O U>)=>(^16)».base(16))).decode}

Provalo online!

Versione alternativa a 85 byte

{S:g[....]=chr :4(~$/)*2+|221+^:4(~$/)+^238}o{TR:d/UIAOBD/0123/}o{S:g[B.<![D]>]=0~$/}

Provalo online!


Che ne dici (^16)>>.base(16)di -1 byte
Jo King

8

Python 2 , 100 97 96 95 byte

-1 byte grazie a ovs
-1 byte grazie a GB

lambda w:''.join(' 1023546798abdcef'[int(c,35)/7%77%18]for c in w.split('B')[1:]).decode("hex")

Provalo online!



6

05AB1E (legacy), 68 65 60 59 byte

.•5Ç¿ÆΓ•2ô.•1ÒKá ¸ΓìŸÆt`ô_zTºγ„KRI‰ι놽òι•4ô«I¬©¡®ìkh2ôJHçJ

L'ingresso è in minuscolo.

-3 byte implicitamente grazie a @Emigna che cambia 'b¡εg>}s£in 'b©¡®ì.

Provalo online o verifica tutti i casi di test .

Inoltre, può sicuramente essere giocato a golf con qualcosa di più intelligente delle enormi stringhe compresse. Daremo un'altra occhiata più tardi. Risposta più breve già fornita da @Emigna , quindi assicurati di votarlo!

Spiegazione:

.•5Ç¿ÆΓ•      # Compressed string "bibabobu"
        2ô    # Split in parts of 2
              #  → ["bi","ba","bo","bu"]
.•1ÒKá ¸ΓìŸÆt`ô_zTºγ„KRI‰ι놽òι•
              # Compressed string "bidibidabidobidubadibadabadobadubodibodabodobodu"
        4ô    # Split in parts of 4
              #  → ["bidi","bida","bido","bidu","badi","bada","bado","badu","bodi","boda","bodo","bodu"]
«             # Merge both lists together
              #  → ["bi","ba","bo","bu","bidi","bida","bido","bidu","badi","bada","bado","badu","bodi","boda","bodo","bodu"]
I¬©¡          # Take the input and split on the head (always 'b')
              #  i.e. "bidibadibidobidabidobodibidobodibidoboduboba"
              #   → ["idi","adi","ido","ida","ido","odi","ido","odi","ido","odu","o","a"]
    ®ì        # And prepend a 'b' to each item again
              #  i.e. ["idi","adi","ido","ida","ido","odi","ido","odi","ido","odu","o","a"] 
              #   → ["bidi","badi","bido","bida","bido","bodi","bido","bodi","bido","bodu","bo","ba"]
k             # Map each item to the index of the first list
              #   i.e. ["bidi","badi","bido","bida","bido","bodi","bido","bodi","bido","bodu","bo","ba"]
              #    → [4,8,6,5,6,12,6,12,6,15,2,1]
 h            # Convert everything to hexadecimal
              #  i.e. [4,8,6,5,6,12,6,12,6,15,2,1]
              #   → ["4","8","6","5","6","C","6","C","6","F","2","1"]
  2ôJ         # Split it in parts of 2 and join them together
              #  i.e. ["4","8","6","5","6","C","6","C","6","F","2","1"]
              #   → ["48","65","6C","6C","6F","21"]
     H        # Convert that from hexadecimal to an integer
              #  i.e. ["48","65","6C","6C","6F","21"] → [72,101,108,108,111,33]
      ç       # And take its ASCII value
              #  i.e. [72,101,108,108,111,33] → ["H","e","l","l","o","!"]
       J      # Then join everything together (and output implicitly)
              #  i.e. ["H","e","l","l","o","!"] → "Hello!"


5

R , 141 135 byte

function(x,y="I":"A":"O")intToUtf8(matrix(match(el(strsplit(gsub("D","",x),"B"))[-1],paste0(rep("":y,e=4),y:"U"))-1,,2,T)%*%16:1)
":"=c

Provalo online!

Grazie a JayCe per aver salvato 6 byte!

L'uso della magia modulare è probabilmente più breve, ma sono abbastanza contento di questo come un primo passaggio ingenuo.


1
Bello ! Il mio trucco preferito salva 6 byte - ispirato dal tuo commento a una mia risposta l'altro giorno.
JayCe,

@JayCe molto bello e pulito! Anche usandolo con la precedenza su %*%vedo. :-) Puoi anche metterlo `:`come argomento di funzione nel caso in cui volessi usarlo insieme a qualcos'altro!
Giuseppe,

Esatto, tendo sempre a dimenticare i backquotes.
JayCe,

5

Japt, 43 29 28 byte

Non sorprende che un porto della soluzione Jelly di Dennis risulti molto più breve.

Emette una matrice di caratteri.

Åqbu)®¬®c ^1 %9%4Ãì2Ãò ®ìG d

Provalo


Originale, 42 byte

Åqb £`bbidbad¾d`ò3n)ï`ia`q)m¬bXibÃò ®ìG d

Provalo

Spiegazione

Åqb £`bbidbad¾d`ò3n)ï`ia`q)m¬bXibÃò ®ìG d
Å                                              :Slice off the first character
 qb                                            :Split on "b"
    £                                          :Map
     `bbidbad¾d`                               :  Compressed string "bbidbadbod"
                ò3n)                           :  Partition at every 3rd character from the end (["b","bid","bad","bod"])
                    ï                          :  Cartesian product
                     `ia`                      :   Compressed string "iaou"
                          q                    :   Split
                           )                   :  End Cartesian product
                            m                  :  Map
                             ¬                 :   Join
                              b                :  Index of
                               X               :   Current element
                                ib             :   Prepend "b"
                                  Ã            :End map
                                   ò           :Partition at every second element
                                     ®         :Map
                                      ìG       :  Convert from base-16 digit array to base-10 integer
                                         d     :  Get the character at that codepoint

5

C (gcc) , 181 138 136 byte

Spero che ci sarà un compilatore C in futuro per compilare questo! :-)

Grazie a Max Yekhlakov e soffitto per i suggerimenti.

v,t,c,d;f(char*s){for(v=t=c=0;d=*s++;)t+=d==66?v=v*16+t,++c>2?v=!putchar(v),c=1:0,-t:d-65?d-79?d-68?d-85?0:3:4+t*3:2:1;putchar(v*16+t);}

Provalo online!


Nel caso in cui il compilatore C del futuro comprenda solo ASCII ifib BIBABOBU :-)

BIDUBIDOBOBODIBIDUBIDIBOBODIBIDOBUBUBADUBIDOBIDOBOBADIBIDOBUBIDOBADIBIDOBABIDUBOBOBADOBIDUBUBOBADABIDUBADUBIDOBIDOBIDOBODUBIDUBOBOBADIBIDUBIDOBUBODABIDUBIDIBUBODABIDOBUBUBODABUBIBUBADUBOBADOBIDUBUBUBADUBIDUBUBOBADUBOBADUBOBADABIDUBIDIBOBADUBUBODABOBADOBIDUBUBUBODABUBODABUBIDOBUBIDOBUBODUBIDUBIDOBUBODABIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBODIBOBADUBOBADUBIDOBUBUBODOBUBOBUBODUBIDUBIDOBUBODABOBABIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADABOBODIBIDOBUBUBODABUBABUBADOBUBIBOBODIBOBODABIDUBIDIBUBADOBOBADOBIDUBUBOBODABUBIDOBUBIDABUBODUBOBADOBIDUBUBOBODABUBIDUBUBADABUBODUBOBADOBIDUBUBOBODABUBIDOBUBADIBUBODUBOBADOBIDUBUBOBODABUBADIBUBIDABUBODUBUBIBUBADOBUBUBUBADOBUBIDIBOBADUBIDUBIDIBOBADOBUBUBUBADOBUBOBUBADOBUBABUBADUBIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBADABUBADUBIDUBODA

(Encoder Provalo online! )



Suggerisci c=printf(&v),v=0invece div=!putchar(v),c=1
ceilingcat il

4

JavaScript (Node.js) , 131 128 byte

s=>unescape(s.replace(/B.(D.)?/g,(f,s)=>(-~g(f[1])*4*!!s+g((s||f)[1])).toString(16),g=c=>'IAOU'.search(c)).replace(/../g,'%$&'))

Provalo online! Il link include casi di test. Versione alternativa, anche 131 byte:

s=>unescape(s.replace(/B.(D.)?/g,s=>(-~g(s[1])*4*!!s[3]+g(s[3]||s[1])).toString(16),g=c=>'IAOU'.search(c)).replace(/../g,'%$&'))

Provalo online! Il link include casi di test. Modifica: salva 3 byte grazie a @Shaggy.


1
Usare unescape()è una bella idea.
Arnauld,

indexOf-> searchper salvare un byte.
Shaggy,

Inoltre, non è necessario assegnare RegEx a r.
Shaggy,

@Shaggy Whoops, è un residuo di una precedente iterazione. Grazie!
Neil,


4

Scala , 305 byte

Bene, sono abbastanza sicuro che questo possa essere risolto. Ma esiste ancora. Porta l'input in minuscolo. fstampa il risultato in stdout.

EDIT: -8 caratteri grazie a me non essere più stupido (spazi); -13 caratteri grazie a crater2150

var k=Seq("bi","ba","bo","bu")
k++=k.init.flatMap(a=>Seq("di","da","do","du").map(a+_))//Putting "bu" here instead of at line 1, and in place of using init, would be interesting... if it did not cause a typing problem
var m=Seq[String]()
def g(a:Seq[String],b:Int)=k.indexOf(a(b)).toHexString
def f(a:String){a.split('b').drop(1).foreach(x=>m:+="b"+x)
var i=0
while(i<m.length){print(Integer.parseInt(g(m,i)+g(m,i+1),16).toChar)
i+=2}}

Provalo online!


Puoi sostituire dropRight(1)con init, Seq("").drop(1)con Seq[String]()e map(b=>a+b)conmap(a+_)
crater2150

@ crater2150 grazie! il mio compilatore non voleva map(a+_)funzionare ma sapevo che avrei potuto farlo. grazie per altri consigli!
V. Courtois,

3

Python 2 , 142 139 127 118 byte

lambda s:''.join(chr(16*a+b)for a,b in zip(*[iter(4*F(l[:-2])+F(l[-1])-1for l in s.split('B')[1:])]*2));F=' IAOU'.find

Provalo online!


3

Python 2 , 93 byte

lambda w:''.join('c60238e4d1_b7f95a'[hash(x)%3046%17]for x in w.split('B')[1:]).decode('hex')

Provalo online!


Adoro le risposte che abusano del valore hash di elenchi sufficientemente piccoli
Lyndon White,


3

Dyalog APL, 74 72 byte

Soluzione per principianti in Dyalog APL (ho appena iniziato a studiare questo un paio di giorni fa!). Definisce un dfn che accetta un argomento giusto (l'input). 72 caratteri, 72 byte quando si utilizza la codifica dyalog. Basato sulla soluzione di Emigna in 05AB1E.

{⎕UCS 16⊥¨(1 0⍴⍨≢t)⊂1-⍨(,('B',('B'∘.,'IAO'),¨'D')∘.,'IAOU')⍳t←('B'⍷⍵)⊂⍵}

Benvenuti in PPCG e nel mondo del golf APL. Questo è sorprendente dopo solo un paio di giorni di apprendimento APL. Puoi goderti i consigli sul golf APL . Sentiti libero di partecipare anche a The APL Orchard !
Adám,

2

Gelatina , 39 byte

®+“IAO”+”D®;p“IAOU”Ẏ€
=”B©œṗµḊ¢iⱮ’s2ḅ⁴Ọ

Provalo online!

La tecnica utilizzata è molto simile a quella di Emigna . Presto continuerò a giocare a golf, speriamo.


2

Brain-Flak , 178 byte

{(([((((()()()()){}){}){}()){}]{}){{}<>(({}){}){}(<>)}{}<({}(<>))(<>)((()()()())({})()){{(({})){({}[()])<>}{}}<>({}<>)<>{}}{}><>{}{})<>}<>([]){{}({}(((({}){}){}){}){}<>)<>([])}<>

Provalo online!

Spiegazione

# Step 1: convert to hex.
# For each pair of letters in the input:
{

  (

    # Compare first letter to B
    ([((((()()()()){}){}){}()){}]{})

    # If not B, pop previous output, multiply by 4, and put on third stack.
    # 4 is added automatically from pushing/popping the difference
    # between the letters B and D.
    {{}<>(({}){}){}(<>)}{}

    <

      # Push second letter in pair to other stack
      ({}(<>))

      # Push 4 and 9
      (<>)((()()()())({})())

      # Compute 3-((8-(n mod 9)) mod 4)
      # (same as (n-1) mod 9 mod 4)
      {{(({})){({}[()])<>}{}}<>({}<>)<>{}}{}

    >

    # Add result to third stack (either 0 or 4*previous+4)
    <>{}{}

  # Push onto second stack
  )

<>}

# Step 2: Pair up hex digits.
# While digits remain on right stack:
<>([]){{}

  # Push top of stack + 16*second on stack to left stack
  ({}(((({}){}){}){}){}<>)<>

([])}

# Switch to left stack for output.
<>

2

05AB1E , 30 byte

ć¡Ç1^9%4%εDg≠i421øP]€OžvβžzвçJ

La pazza risposta di Jelly di @Dennis (solo con built-in meno convenienti). Quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

ć¡             # Split the input-string on its first character ('B')
               #  i.e. "BIDABIDIBIDOBIDABIDUBUBIDUBIDI"
               #   → ["IDA","IDI","IDO","IDA","IDU","U","IDU","IDI"]
  Ç            # Convert each character to it's ordinal value
               #  → [[73,68,65],[73,68,73],[73,68,79],[73,68,65],[73,68,85],85,[73,68,85],[73,68,73]]
   1^          # XOR it by 1
               #  → [[72,69,64],[72,69,72],[72,69,78],[72,69,64],[72,69,84],84,[72,69,84],[72,69,72]]
     9%        # Take modulo-9
               #  → [[0,6,1],[0,6,0],[0,6,6],[0,6,1],[0,6,3],3,[0,6,3],[0,6,0]]
       4%      # Take Modulo-4
               #  → [[0,2,1],[0,2,0],[0,2,2],[0,2,1],[0,2,3],3,[0,2,3],[0,2,0]]
ε         ]    # Now map it to:
 Dgi          # If the length is not 1:
               #  i.e. [0,2,1] → 3 → 1 (truthy)
               #  i.e. 3 → 1 → 0 (falsey)
     421øP     # Multiply the first number by 4, second by 2, and third by 1
               #  i.e. [0,2,1] and [4,2,1] → [[0,4],[2,2],[1,1]] → [0,4,1]
           O  # Then sum every inner list
               #  [[0,4,1],[0,4,0],[0,4,2],[0,4,1],[0,4,3],3,[0,4,3],[0,4,0]]
               #   → [5,4,6,5,7,3,7,4]
žvβ            # Convert this list from base-16 to base-10
               #  → 1415934836
   žzв         # Convert this integer from base-10 to base-256
               #  → [84,101,115,116]
      ç        # Convert this number to ASCII characters
               #  → ["T","e","s","t"]
       J       # Join the characters together (and output implicitly)
               #  → "Test"

Mi chiedevo come hai eliminato 3 punteggi di Emignas. Jeebus è un +1 complesso per lo sforzo sulla porta: non hai mai usato XOR o quella conversione di base prima! Terrò a mente d'ora in poi!
Magic Octopus Urn

@MagicOctopusUrn Sì, la risposta di Dennis è qualcosa che non mi sarei mai inventato da solo .. E in Jelly questo è fatto in modo molto più efficiente, dato che la sua risposta è di 15 byte e la mia di 30. Ho solo pensato che valesse la pena di postare comunque, anche se è un porto. Ho usato XOR solo una volta, e la conversione Base abbastanza spesso.
Kevin Cruijssen,

2

Java (JDK 10) , 199 byte

s->{var z="";for(var x:s.substring(1).split("B")){int d=-1;for(var y:x.split("D"))d=-~d*4+"IAOU".indexOf(y);z+=(char)(d>9?d+55:d+48);}return new String(new java.math.BigInteger(z,16).toByteArray());}

Provalo online!

Crediti


1
Potresti usare al -~dposto di (d+1)?
Arnauld,

Sì grazie! Ho avuto quelli nella mia prima versione, poi ho giocato con l'idea di usare chars e quando sono tornato alla mia prima versione, l'ho completamente dimenticato di nuovo. ;)
Olivier Grégoire,

2

VBA (Excel), con un incredibile 322 244 byte

Sì, e ADORO l' esadecimale. (Non c'è ancora nessun carattere sarcasmo, quindi sto usando il corsivo per ora) Aggiungerò commenti se qualcuno vuole, ma penso che sia autoesplicativo. Il golf è successo.

Sub b(s)
For Each c In Split(Replace(s,"D",""),"B")
c=Application.Match(c,Array("I","A","O","U","II","IA","IO","IU","AI","AA","AO","AU","IO","OA","OO","OU"),0)
If Not IsError(c)Then d=d &c-1:If Len(d)=2Then e=e &Chr("&h"&d):d=""
Next
Debug.?e
End Sub

Con commenti:

Sub b(s)
  'For each string between B's (Remove the D's first)
  For Each c In Split(Replace(s,"D",""),"B")
    'Get the index of the element in the array (Can cause error if empty)
    c = Application.Match (c,Array("I","A","O","U","II","IA","IO","IU","AI","AA","AO","AU","IO","OA","OO","OU"),0)
    'If c isn't an error
    If Not IsError(c) Then
      'Subtract 1 from c and add to d  --> Array index is 1 based
      d = d & (c-1)
      'If d is 2 characters
      If Len(d)=2 Then
        'Add the char from the hex value of d   --> &h forces Hex
        e = e & Chr("&h" & d)
        'Reset d
        d = ""
      End if
    End if
  Next
  'Print the output
  Debug.Print e
End Sub

Ho davvero provato a farlo entrare nella finestra immediata di VB, ma non sembra funzionare lì ... ciò taglierebbe 11 caratteri, penso. Volevo anche mettere l'istruzione Match tra parentesi, ma ciò causa sempre un errore silenzioso. L'aiuto è apprezzato: D


Benvenuti in PPCG!
Arnauld,

Grazie! Sono qui da un po ', non sono mai stato in grado di pubblicare nulla :)
seadoggie01

Array("I","A","O","U","II","IA","IO","IU","AI","AA","AO","AU","IO","OA","OO","OU")-> Split("I A O U II IA IO IU AI AA AO AU IO OA OO OU")e Not IsError(c)->IsError(c)=0
Taylor Scott,

1

Haxe , 228 byte

s->{var l=(u,i)->((i=u.charCodeAt(i))&8==8?0:1)|((i>>1)&2),p=s.split("B"),i=-1,q,o;[while((i+=2)<p.length)String.fromCharCode(l(q=p[i+1],o=q.length-1)+((o>1?l(q,0)+1:0)+((l(q=p[i],o=q.length-1)+o*(l(q,0)+1)*2)*4))*4)].join("");}

Non i migliori, i nomi delle funzioni di libreria standard sono troppo grandi :(

Provalo online!


1

Pyth, 35 byte

mCid16cm+4imx"IAOU"k.[N2d4tc-Q\D\B2

Emette come un elenco di caratteri.
Provalo qui

Spiegazione

mCid16cm+4imx"IAOU"k.[N2d4tc-Q\D\B2
                          tc-Q\D\B   Get the vowels associated with each digit.
       m            .[N2d            Pad with a quote.
           mx"IAOU"k                 Find each character's position.
        +4i              4           Convert to base 4 and add 4.
      c                           2  Split the result into pairs.
mCid16                               Get the associated ASCII characters.

1

Carbone , 36 byte

FS≡ιB⊞υ⁰D⊞υ×⁴⊕⊟υ⊞υ⁺⊟υ⊕⌕AOUι⭆⪪υ²℅↨ι¹⁶

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

FS≡ι

Passa sopra ogni carattere di input e cambia.

B⊞υ⁰

Se è un Bquindi spingere 0verso l'elenco vuoto predefinito.

D⊞υ×⁴⊕⊟υ

Se è un, Dquindi pop l'ultimo valore, incrementarlo, moltiplicare per 4e spingerlo di nuovo.

⊞υ⁺⊟υ⊕⌕AOUι

Altrimenti, trova l'indice nella stringa AOU, incrementalo e aggiungi all'ultimo valore.

⭆⪪υ²℅↨ι¹⁶

Dividi l'elenco in coppie di valori, decodifica come base 16, converti in ASCII e stampa implicitamente.


1

Pulito , 145 134 byte

import StdEnv                   // import things like addition and comparison
?c=(743rem(toInt c))/16         // magical formula that maps ['IAOU'] to [0,1,2,3]
@[_,b,'D',d:t]=[?d+ ?b*4+4: @t] // convert B#D#
@[_,b:t]=[?b: @t]               // convert "B#"
@_=[]                           // handle base case
$[u,v:t]=[u<<4+v: $t]           // turn the digits into 2-digit numbers
$e=e                            // handle base case

toString o$o@                   // convert to string (make numbers (make digits))

Provalo online!

Ha spiegato:


1

PHP, 119 byte

foreach(explode(B,$argn)as$i=>$m)($v=$v*16+4*strpos(XIAO,$m[-3]?:B)+strpos(IAOU,$m[-1]?:B))?$i&1||print chr($v&=255):0;

assume un input maiuscolo. Esegui come pipe -nRo provalo online .

richiede PHP 7.1
per PHP precedenti, usare substr($m,-3,1)e substr($m,-1)invece di $m[-<x>](+16 byte);
per i più giovani PHP, put B, XIAOe IAOUtra virgolette per evitare messaggi di avviso (+10 byte).



0

PHP, 163 byte

function f($s){$t=[I=>0,A=>1,O=>2,U=>3];for($q=explode(B,$s);$a=&$q[++$i];){$a=($a[1]?($t[$a[0]]+1)*4:0)+$t[$a[2*($a[1]==D)]];$i%2?:print(chr(($q[$i-1]<<4)+$a));}}

Chiama f(string $s)con la stringa appropriata di caratteri codificati in bibabobu e stamperà la stringa decodificata.


0

Python 3, 199 byte

import re
lambda s:''.join(eval(re.sub(r'(\d+), (\d+)',r'chr(16*\1+\2)',str(eval(s.replace('I','1').replace('A','2').replace('O','3').replace('U','4').replace('B',',-1+').replace('D','*4+')[1:])))))

Non il più corto ma senza anelli.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.