Covfefify una stringa


371

In questa sfida, devi prendere una stringa che corrisponda alla regex ^[a-zA-Z]+$o qualsiasi cosa sia ragionevole (non devi considerare lettere maiuscole o minuscole se vuoi) (puoi presumere che la stringa sia abbastanza lunga e abbia la struttura giusta per tutte le operazioni) e ha prodotto un'altra stringa, prodotta in modo simile a word alla fine di un recente tweet dadaist di POTUS ( "Despite the constant negative press covfefe").

Come personalizzare una stringa:

Innanzitutto, ottieni il primo gruppo di suoni (terminologia inventata).

Come fai a fare questo? Bene:

  • Trova la prima vocale ( yè anche una vocale)

      v
    creation
    
  • Trova la prima consonante dopo quella

        v
    creation
    
  • Rimuovi il resto della stringa

    creat
    

Questo è il tuo primo gruppo sonoro.

Passo successivo:

Ottieni l'ultima consonante del gruppo sonoro

t

e sostituirlo con la versione vocale o senza voce. Per fare questo, trova la lettera in questa tabella. Sostituisci con la lettera fornita (che può essere la stessa lettera)

b: p
c: g
d: t
f: v
g: k
h: h
j: j
k: g
l: l
m: m
n: n
p: b
q: q
r: r
s: z
t: d
v: f
w: w
x: x
z: s

quindi otteniamo

d

Quindi, prendi la vocale successiva dopo quella consonante. Puoi presumere che questa consonante non sia alla fine della stringa. Unisci questi due insieme, quindi ripeti due volte:

didi

Concatena questo al primo gruppo sonoro:

creatdidi

Hai finito: la stringa è personalizzata e ora puoi emetterla.

Casi test:

coverage: covfefe

example: exxaxa

programming: progkaka (the a is the first vowel after the g, even though it is not immediately after)
code: codtete

president: preszizi

Questo è , quindi per favore rendi il tuo programma il più breve possibile!


7
"x" dovrebbe tecnicamente mappare su "gz". "qu" dovrebbe essere mappato su "gw".
Steve Bennett,

2
Questo specifica un concetto di coffefification, ma continuo a ritenere appropriato un riferimento all'opera di Douglas Hofstadter (e Melanie Mitchell) sulle analogie di conversione delle stringhe, ad esempio in Fluid Concepts .
Marte

60
Le risposte di oltre 140 caratteri dovrebbero essere squalificate
Sandy Gifford,

12
Purtroppo è impossibile farlo in TrumpScript :(

4
@ThePlasmaRailgun Era uno scherzo, dal momento che i tweet devono essere di 140 caratteri o meno.
Esolanging Fruit,

Risposte:


91

Gelatina ,  58  57 byte

<TḢị
e€Øyµ¬TĖEÐḟḢṪ;ç¥T
ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2

Un programma completo che accetta un elenco di caratteri minuscoli e stampa il risultato.

Provalo online!

Come?

<TḢị - Link 1, extract first value from y not less than x: number, x; list of numbers, y
     -                                                     e.g. 5, [3,4,7]
<    - x less than vectorised across y                             [0,0,1]
 T   - truthy indices                                              [    3]
  Ḣ  - head                                                             3
   ị - index into y                                                     7

e€Øyµ¬TĖEÐḟḢṪ;ç¥T - Link 2, indices of the letters to manipulate: list of characters, w
  Øy              - vowel+ yield = "AEIOUYaeiouy"                 e.g.  "smouching" 
e€                - exists in for €ach letter in w                       001100100
    µ             - monadic chain separation, call that v
     ¬            - not vectorised across v                              110011011
      T           - truthy indices                                       12  56 89
       Ė          - enumerate                      [[1,1],[2,2],[3,5],[4,6],[5,8],[6,9]]
         Ðḟ       - filter discard if:
        E         -   elements are equal                       [[3,5],[4,6],[5,8],[6,9]]
           Ḣ      - head                                        [3,5]
            Ṫ     - tail                                           5
                T - truthy indices of v                                    34  7
               ¥  - last 2 links as a dyad
              ç   -   call last link (1) as a dyad                         7
             ;    -   concatenate                                     5,7
                  -                                    ...i.e the indexes of 'c' and 'i'

ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2 - Main link: list of characters, w
                                   -                             e.g.  "smouching"
 Ç                                 - call the last link (2) as a monad    [5,7]
ḣ                                  - head to index (vectorises)      ["smouc","smouchi"]
  Ḣ                                - head                             "smouc"
                                   -   implicit print due to below leading constant chain
   ⁸                               - link's left argument, w
    Ç                              - call the last link (2) as a monad    [5,7]
     ị                             - index into w                         "ci"
      µ                            - monadic chain separation, call that p
       Ḣ                           - head p                               'c'
        ØY                         - consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
          i                        - first index                          22
                          ¤        - nilad followed by link(s) as a nilad:
            “ßȷ%Hẹrȧq’             -   base 250 number = 1349402632272870364
                        ØY         -   consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
                      œ?           -   nth permutation  = "BCDFGHJKLMNPQRSTVWXZpctvkhjglmnbqrzdfwxs"
           ị                       - index into         (special case ->) 'c'
                           ⁾cg     - literal ['c','g']
                              y    - translate (change 'c's to 'g's)      'g'
                               ;   - concatenate with the headed p        "gi"
                                ẋ2 - repeat list twice                    "gigi"
                                   - implicit print ...along with earlier = smoucgigi

13
Questo è fantastico ...
Klangen,

Lavoro incredibile.
JF,

9
Sono gelatina. Upvoted.
DeepS1X il

6
Questo è il linguaggio di programmazione più strano che abbia mai visto.
Ryan,

@Ryan è destinato al golf.
Esolanging Fruit,

61

JavaScript (ES6), 107 103 byte

Salvati 4 byte grazie a GOTO 0

s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)

Casi test


6
È possibile salvare alcuni byte in questo modo:s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
GOTO 0

@ GOTO0 Grazie, aggiornato.
Arnauld,

49

Gelatina , 45 39 byte

Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2
e€ØyIi-‘ɓḣ;ç

Provalo online!

Come funziona

e€ØyIi-‘ɓḣ;ç                Main link. Argument: s (string)

  Øy                        Vowels with y; yield "AEIOUYaeiouy".
e€                          Test each character in s for membership.
    I                       Increments; compute the forward differences of the
                            resulting array of Booleans.
     i-                     Find the first index of -1.
       ‘                    Increment this index to find the index of the first
                            consonant that follows a vowel.
                            Let's call this index j.
        ɓ                   Begin a new chain. Left argument: s. Right argument: j
         ḣ                  Head; yield the first j characters of s.
           ç                Call the helper link with arguments s and j.
          ;                 Concatenate the results to both sides.
Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2  Helper link. Left argument: s. Right argument: j

Øa                          Alphabet; set the return value to “abc...xyz”.
  “œṣ$b|0Ḃ’                 Yield 7787255460949942. This is a numeric literal in
                            bijective base 250. The value of each digit matches its
                            1-based index in Jelly's code page.
           ṃ                Convert 7787255460949942 to base 26, using the digts
                            a = 0, b = 1, ..., z = 25.
                            This yields "bcdfkszgvtgp".
            ,Ṛ$             Pair the result with its reverse, yielding
                            ["bcdfkszgvtgp", "pgtvgzskfdcb"].
                ṫ           Call tail with arguments s and j, yielding the j-th and
                            all following characters of s.
               y            Translate the result to the right according to the
                            mapping to the left, i.e., replace 'b' with 'p', 'c'
                            with 'g', etc. 'g' appears twice in the first string
                            of the mapping; only the first occurrence counts.
                            Let's call the resulting string r.
                 µ          Begin a new chain. Argument: r
                  fØy       Filter; remove non-vowels from r.
                     Ḣ      Head; take the first vowel.
                       Ḣ    Head; take the first character/consonant of r.
                      ṭ     Tack; append vowel to the consonant.
                        ẋ2  Repeat the resulting string twice.

4
scusa amico, sembra che ti sia perso il mega rappresentante della gelatina
Destructible Lemon,

Perché una risposta sembra eccessivamente semplicistica ma in realtà è davvero meravigliosa ... semplice è bella
Erik the Outgolfer

31

CJam , 59 58 57 56 byte

q_{"aeiouy":V&,_T|:T^}#)/(_W>"cbdfkszgvtpg"_W%er@sV&0=+_

Provalo online!

Spiegazione

q_                   e# Read the input and copy it.
{                    e# Find the index of the first char for which the following is true:
 "aeiouy":V          e#  Push "aeiouy" and store it in V.
 &,                  e#  Check if the current char is in the vowel string (0 or 1).
 _T|:T               e#  Copy the result and OR with T (T is initially 0), storing back in T.
 ^                   e#  XOR with the original result. This will be 1 for the first 
                     e#  consonant appearing after a vowel.
}#                   e# (end find)
)/                   e# Increment the index and split the string into chunks of that size.
(                    e# Pull out the first chunk.
_W>                  e# Copy it and get the last character (the consonant).
"cbdfkszgvtpg"_W%er  e# Transliterate the consonant to voiced/voiceless alternative.
@s                   e# Bring all the other split chunks to the top and join them together.
V&0=                 e# First char of the set intersection of that and the vowels.
                     e# (i.e. the first vowel in the second half)
+                    e# Concatenate the new consonant and the vowel.
_                    e# Duplicate the result of that.
                     e# Implicit output of stack contents.

2
CJam batte Jelly? : O (almeno, batte la risposta della gelatina a tutti sembra che stia promuovendo).
Esolanging Fruit

29

C, 219 213 206 179 175 byte

#define p putchar
#define q(a)for(;a strchr("aeiouy",*s);p(*s++));
f(s,c,h)char*s;{q(!)q()p(*s);p(c="pgt vkh jglmn bqrzd fwx s"[*s-98]);p(h=s[strcspn(s,"aeiouy")]);p(c);p(h);}

Provalo online!


* P = putchar funziona come prima riga?
k_g,

4
Spiacente squalificato. Impossibile inserirsi in un tweet.
caird coinheringaahing il

@cairdcoinheringaahing, signore, non siete corretti (so che erano 140 quando lo avete scritto)
Stan Strum,


1
È possibile eliminare circa 12 byte sostituendo se #definela funzione con flag di preprocessore ( -D...).


18

PHP, 121 byte

$v=aeiouy;preg_match("#(.*?[$v]+([^$v])).*?([$v])#",$argn,$t);echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;

Provalo online!


3
-2 byte:echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;
Tito

@Titus Non ci ho pensato. Grazie
Jörg Hülsermann,

perché non rinominare $argnqualcosa di più breve? $a, ad esempio, ovvero -3 byte
Tyler Sebastian,

@TylerSebastian Devo avere una variabile di input che esiste. Sì, posso creare una funzione, ma se lo faccio aumenta il conteggio dei byte in più usando i tre byte
Jörg Hülsermann,

ah ok scusa ho dimenticato come PHP fa l'argomentazione della riga di comando - ho appena visto che l'hai definito nella sezione dell'intestazione ma non ho capito che era una variabile riservata.
Tyler Sebastian,

15

Pyth, 54 byte

L+hb?>F}RJ"aeiouy"<b2+hKtb*2+XhK"cgdsfbpvztkg")h@JKytb

Questo definisce una funzione y, che prevede una stringa. Provalo online: Test Suite


14

Python 3, 155 139 byte

import re
def f(x,k='aeiouy])'):b,c,v=re.findall(f'(.*?[{k}([^{k}.*?([{k}',x)[0];return b+c+(('bcdfgkpstvz'+c)['pgtvkgbzdfs'.find(c)]+v)*2

rimosso 16 byte grazie a @ovs

rimosso 1 byte grazie a Gábor Fekete


2
Potresti creare una variabile che ha il valore 'aeiouy]', forse che salverà alcuni byte. Inoltre è possibile rimuovere alcuni caratteri dalle stringhe di sostituzione in quanto sono uguali.
Gábor Fekete,

2
Non riesco a rimuovere gli stessi caratteri dalla stringa di sostituzione, perché sarebbe un IndexError, e il salvataggio aeiouy])non salva alcun byte.
L3viathan,

2
se tiri fuori qualcosa del genere s='aeiouy])', potresti usare b,c,v=re.findall('(.*?[%s([^%s.*?([%s'%(s,s,s). Non è più breve, ma potrebbe portare a un modo per accorciarlo nel complesso.
Jeremy Weirich,


3
L'uso delle stringhe f consente di risparmiare 1 byte: k='aeiouy])'ef'(.*?[{k}([^{k}.*?([{k}'
Gábor Fekete,

14

Java 8, 243 236 222 byte

s->{String q="[a-z&&[^aeiouy]]",a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"),b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))+s.replaceAll(a+q+"*([aeiouy]).*","$1");return a+b+b;}

Utilizza .replaceAllregex con gruppi di acquisizione per filtrare le parti che non vogliamo.

Spiegazione:

Provalo qui.

s->{ // Method with String parameter and String return-type
  // Temp String we use multiple times:
  String q="[a-z&&[^aeiouy]]",
   // Regex to get the first part (i.e. `creation` -> `creat` / `example` -> `ex`)
   a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"), 
   // Get the trailing consonant and convert it
   b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))
   // Get the next vowel after the previous consonant from the input-String
    +s.replaceAll(a+q+"*([aeiouy]).*","$1");
  // Return the result:
  return a+b+b;
} // End of method

13

Haskell , 143 141 138 137 136 byte

z h=elem h"aeiouy"
f i|(s,(m,c:x))<-span z<$>break z i,j:_<-filter z x,d<-"pgt.vkh.jglmn.bqrzd.fwx.s"!!(fromEnum c-98)=s++m++[c,d,j,d,j]

Provalo online!


1
Eccezionale! La sostituzione nxcon qualcosa di una lettera salverà 2 byte.
Tomsmeding

dichiarare zal di fuori fe passare alle guardie anziché a letsalva altri due byte: provalo online!
Laikoni,

2
E altri due combinando (s,v)<-break z i,(m,c:x)<-span z vin (s,(m,c:x))<-span z<$>break z i.
Laikoni,

Potresti radere un altro mettendo la parentesi di apertura accanto alla let, grazie!
bartavelle,

@Laikoni Non capisco la parte di spostare zfuori f?
bartavelle,

10

Python, 261 260 byte

def c(s,t='bpcgdtfvgksz'):
 q,r,t='aeiouy',range(len(s)),t+t[::-1]
 c=[i for i in r if i>[j for j in r if s[j]in q][0]and s[i]not in q][0]
 C=([t[2*i+1]for i in range(12)if s[c]==t[i*2]]or s[c])[0]
 return s[:c+1]+(C+s[[i for i in r if i>c and s[i]in q][0]])*2

Una soluzione non regex, non esoterica. Ci sono voluti circa 20 minuti per fare, e un'ora in più per il golf.

Probabilmente ha una maggiore comprensione dell'elenco rispetto all'intera libreria standard di Python, principalmente perché non conosco regex ...

Provalo online! (Con testcase)


8

Rubino , 90 byte

->x{x[/(.*?#{$v='[aeiouy]'}+.).*?(#$v)/];$1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2}

Provalo online!

Ungolfing un po ', abbiamo qualcosa di equivalente a:

def covfefefify(x)
  v = '[aeiouy]'
  # Match x to a regular expression capturing:
  # Group 1:
  #  some characters (non-greedy)
  #  followed by some (greedy) non-zero number of vowels
  #  followed by exactly one character
  # Ungrouped:
  #  Some more (non-greedy) characters
  # Group 2
  #  Exactly one other vowel
  # By switching between greedy and non-greedy matches, we can capture longest and shortest vowel/consonant sequences without writing out all the consonants
  x[/(.*?#{v}+.).*?(#{v})/]
  # Glue it back together, replace the necessary consonants, duplicate where needed
  $1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2
end

8

Python 2, 251 246 245 239 237 234 229 211 byte

Prima presentazione qui.

def f(s):
  r=c='';n=0;w='aeiouy';a='bcdfghjklmnpqrstvwxz'
  for i in s:
    if n<2:r+=i
    if n<1and i in w:n=1
    if n==1and i in a:c='pgtvkhjglmnbqrzdfwxs'[a.index(i)];n=2
    if n==2and i in w:r+=c+i+c+i;break
  return r

Provalo online!

Compagni di golf che mi hanno aiutato:

 Destructible Lemon / Wheat Wizard - 5 bytes
 Hubert Grzeskowiak - 1 byte
 musicman523 - 16 bytes

2
Benvenuti nel sito! Vedo che hai provato a utilizzare le schede per il rientro. Se si sostituisce ciascuna scheda con un singolo spazio, è funzionalmente identica e in realtà viene visualizzata correttamente anziché come byte extra
Destructible Lemon

4
Mentre ciò che Destructible Lemon ha detto è corretto, puoi salvare ancora più byte nella tua sorgente indentando il primo livello del tuo codice con un singolo spazio e il secondo livello con una singola scheda, questo renderà un po 'difficile la visualizzazione, ma lo farà salvarti 5 byte.
Sriotchilism O'Zaic

1
Il punto e virgola alla fine della riga 4 è necessario?
Hubert Grzeskowiak,

1
@WaitndSee Penso che tu possa accorciare alcuni dei tuoi condizionali. Primo: puoi passare not na n<1per 2 byte, dato che sai nche non sarà mai negativo. Inoltre puoi passare n==3a n>2poiché sai nche non sarà mai maggiore di 3. È inoltre possibile utilizzare i trucchi di Python per i condizionali per accorciare la prima e penultima ancora di più: n=[n,1][i in w and n<1]; r+=[0,r][n<2]
musicman523

1
Puoi cambiarlo r,v,c=('',)*3in r=v=c='', poiché le stringhe sono immutabili. Ho provato un sacco di altri trucchi intelligenti ma frustrantemente sono esattamente lunghi. Inoltre potrebbe valere la pena aggiungere un provalo online! link al tuo post
musicman523

7

Rubino , 175 141 110 byte

->s{s=~/(.*?#{v='[aeiouy]'}+(#{c='[^aeiouy]'}))#{c}*(#{v})/;"#$1#{($2.tr('bcdfgkpstvz','pgtvkgbzdfs')+$3)*2}"}

Provalo online!

  • Risparmiato 34 byte grazie a Eric Duminil
  • Risparmiato 31 byte grazie a Value Ink + trargomenti suggeriti ottimizzati

Ungolfed

covfefify = -> (s) {
    from = 'bcdfgkpstvz'
    to   = 'pgtvkgbzdfs'

    vowels = "[aeiouy]"
    consonants = "[^aeiouy]"

    s.match(/(.*?#{vowels}+(#{consonants}))#{consonants}*(#{vowels})/)
    d = ($2.tr(from, to) + $3) * 2
    "#$1#{d}"
}

4
-34 byte conHash[*"bpcgdtfvgkkgpbsztdvfzs".chars]
Eric Duminil,

1
Poiché l'input sembra essere garantito per tutti i caratteri alfabetici, c=[^aeiou]è più breve. Avere la prima interpolazione per ciascuna variabile assegna simultaneamente per -2 byte: /^(.*?${v='[aeiou]'}+(#{c='[^aeiou]})).../. Finalmente, $2.tr("b-z","pgtevkhijgl-obqrzdufwxys")invece della soluzione Hash.
Value Ink

È possibile salvare 14 byte utilizzando sottoespressioni ( \g<n>) al posto di interpolazione, più un altro 14 utilizzando @ di ValueInk [^aeiou]suggerimento: s=~/^(.*?([aeiouy])+([^aeiou]))\g<3>*(\g<2>)/.
Giordania,

In realtà, questo ha un bug con programming-> progkaka, che non riesco a capire.
Giordania,

@Jordan purtroppo la chiamata di sottoespressione \g<3>aggiorna il valore di $ 3, quindi non possiamo usare questa scorciatoia.
sudee,

6

Cristallo, 203 194 187 186 184 163 byte

o=""
ARGV[v=c=0].each_char{|a|r=/#{a}/
"aeiouy"=~r&&(v=x=1)||(c=v)
o+=a if c<2||x
c>0&&(x&&break||(o+=(i="pgtvkgbqrzdfs"=~r)?"bcdfgkpqrstvz"[i]: a))}
p o+o[-2..-1]

Penso che potresti perdere i genitori in giro c=veo+=<...>
Cyoce,

5

MATLAB / Octave - 159 158 byte

Le seguenti opere presuppongono che la stringa di input sia tutta in minuscolo.

a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]

Spiegazione

  1. a = input('','s');: Ottiene una stringa da STDIN e la memorizza nella variabile a.
  2. m=ismember(a,'aeiouy');: Restituisce un array booleano delle stesse dimensioni della stringa che adetermina la posizione delle vocali
  3. s='pgt vkh jglmn bqrzd fwx s';La covfefemappatura delle consonanti come stringa. Questa stringa ha una lunghezza di 25 caratteri e omette le vocali. La prima posizione in cui la vocale 'a'dovrebbe essere rimossa viene rimossa mentre le altre posizioni in cui si trovano le vocali vengono posizionate con un carattere di spazio fittizio. Questo è così che quando determiniamo la prima consonante che appare dopo la vocale, convertiremo la consonante in una posizione per accedere a un carattere in questa stringa per determinare il primo componente della parola convertita.
  4. m(1:find(m,1))=1: Imposta la prima posizione dell'array booleano su dove abbiamo trovato la prima vocale come tutte le vocali. Questo sarà così che quando cerchiamo la consonante successiva che segue la prima vocale, ignoreremo questi caratteri.
  5. i=find(~m,1);: Trova la prima posizione della stringa che è una consonante dopo la prima vocale.
  6. f=a(1:i): Rimuove la stringa dopo la prima consonante che segue la vocale. Campioniamo semplicemente dalla prima posizione della stringa fino a questo punto.
  7. d=s(f(end)-97);: Prende l'ultimo carattere della stringa rimasta e trova dove dobbiamo campionare dalla stringa di ricerca e ottiene quel carattere. Sottraendo un carattere e un numero in MATLAB o Octave si fondono per formare un numero intero convertendo il carattere nel suo codice ASCII. In questo caso, sottraggiamo l'ultimo carattere dal carattere all'inizio dell'alfabeto per darci la posizione relativa all'inizio. Tuttavia, invece di sottrarre da b(98), sottraggiamo da aMATLAB che inizia a indicizzare da 1 invece di 0. 'a'Il codice ASCII di 0. è 97.
  8. m(1:i)=0;: Prende la maschera booleana e imposta tutti i caratteri nella stringa di input dalla prima posizione alla prima consonante che segue una vocale su falso.
  9. v=a(find(m,1));: Trova la vocale successiva che segue la prima consonante dalla stringa di input.
  10. [f d v d v]: covfefeGenera la nostra stringa ied.

Esecuzioni di esempio

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
coverage

ans =

covfefe

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
example

ans =

exxaxa

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
programming

ans =

progkaka

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
code

ans =

codtete

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
president

ans =

preszizi

Provalo online!

http://www.tutorialspoint.com/execute_octave_online.php?PID=0Bw_CjBb95KQMdjROYVR0aFNrWXM

Quando premi il pulsante Esegui in alto, attendi qualche istante, quindi inserisci la stringa desiderata. Immettere la stringa lentamente poiché sembra che ci sia un ritardo nell'inserimento nel testo.


5

Clojure, 182 156 caratteri

#(let[v #{\a\e\i\o\u\y}p(partition-by v %)[s m[c][n]](if(v(first %))(cons[]p)p)z[(or((zipmap"bcdfgkpstvz""pgtvkgbzdfs")c)c)n]](apply str(concat s m[c]z z)))

Come funziona

(partition-by v "president")

Restituisce un seq di ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

[s m [c] [n]] (if (v (first x)) (cons [] p) p)

Destruttura la ss in s=(\p \r), m=(\e), c=\s, n=\i.

O per "esempio" è s=[], m=(\e), c=\x, n=\a.

(apply str (concat s m [c] [(l c) n] [(l c) n]))

Restituisce la stringa di output concatenando i pezzi insieme e stringendola.

E poi ho rimosso tutto lo spazio bianco che potevo mentre lo facevo ancora compilare.

De-uglified:

(defn covfefify [x]
  (let [vowel? #{\a\e\i\o\u\y}
        parts (partition-by vowel? x)
        [start mid [consonant] [last-vowel]] (if (vowel? (first x)) (cons [] parts) parts)
        lookup #(or ((zipmap "bcdfgkpstvz" "pgtvkgbzdfs") %) %)]
    (apply str (concat start mid [consonant] [(lookup consonant) last-vowel] [(lookup consonant) last-vowel]))))

Benvenuti in PPCG e ottima prima risposta! Speriamo che tu rimanga e ti diverta a partecipare a più sfide. :-)
ETHproductions

Se stai definendo una funzione, il suo nome dovrebbe probabilmente essere il più breve possibile. Potresti semplicemente chiamare la funzione principale c, per esempio. (Consentiamo anche funzioni anonime, che sono più brevi in ​​molte lingue; non sono sicuro che siano in Clojure). Vedo che hai già apportato questo miglioramento all'interno del tuo codice, quindi probabilmente non è necessario cambiare molto qui.

5

R, 341 caratteri

f=function(x){g=function(x,y)el(strsplit(x,y));a=g(x,'');v=g('aeiouy','');n=letters[-c(1,5,9,15,21,25)];l=data.frame(n,g('pgtvkhjglmnbqrzdfwxs',''));y=min(match(n,a)[which(match(n,a)>min(match(v,a),na.rm=T))]);m=l[which(l$n==a[y]),2];e<-a[-c(1:y)][min(match(v,a[-c(1:y)]),na.rm=T)];paste0(paste0(a[c(1:y)],collapse=''),m,e,m,e,collapse="")}

Tentativo orrendo di R, perché le stringhe sono così difficili

Versione leggibile:

f = function(x) {
  g = function(x, y)el(strsplit(x, y))
  a = g(x, '')
  v = g('aeiouy', '')
  n = letters[-c(1, 5, 9, 15, 21, 25)]
  l = data.frame(n, g('pgtvkhjglmnbqrzdfwxs', ''))
  y = min(match(n, a)[which(match(n, a) > min(match(v, a), na.rm = T))])
  m = l[which(l$n == a[y]), 2]
  e <-a[-c(1:y)][min(match(v, a[-c(1:y)]), na.rm = T)]
  paste0(paste0(a[c(1:y)], collapse = ''), m, e, m, e, collapse = "")
}

Credo che il tuo conteggio sia spento - Conto 340 byte
Taylor Scott


4

BlitzMax, 190 byte

s$=Input()For i=1To s.Length
f="aeiouy".Contains(s[i-1..i])If f v=i If c Exit
If v And c|f=0c=i
Next
t$="bpdtfvgkcgsz"x$=s[c-1..c]r=t.Find(x)~1If r>=0x=t[r..r+1]
x:+s[v-1..v]Print s[..c]+x+x

Prende una parola da stdin e stampa il risultato su stdout. Si presume che la parola di input sia in minuscolo e che contenga almeno una vocale seguita da una consonante.

Una versione più leggibile del programma con formattazione e dichiarazioni variabili:

SuperStrict
Framework BRL.StandardIO

Local s:String = Input()
Local v:Int
Local c:Int

For Local i:Int = 1 To s.Length
    Local f:Int = "aeiouy".Contains(s[i - 1..i])
    If f Then
        v = i
        If c Then Exit
    End If
    If v And c | f = 0 Then c = i
Next

Local t:String = "bpdtfvgkcgsz"
Local x:String = s[c-1..c]
Local r:Int = t.Find(x) ~ 1
If r >= 0 Then x = t[r..r + 1]
x :+ s[v - 1..v]
Print s[..c] + x + x

Come funziona:

BlitzMax non ha alcuna funzionalità regex incorporata o simile, quindi un ciclo viene utilizzato per scorrere i caratteri della parola di input fino a quando non trova una vocale seguita da una catena di almeno una consonante. La variabile c memorizza la posizione dell'ultima di quelle consonanti, v quella della vocale. Il ciclo continua a vedere se esiste un'altra vocale dopo la catena e, in tal caso, v viene aggiornata di conseguenza. Quindi la consonante at viene cercata nella stringa "bpdtfvgkcgsz", che funge da tabella di sostituzione. Se la consonante viene trovata nella tabella in qualsiasi posizione, allora quella posizione è XOR-ed con 1 e il carattere nella posizione risultante viene usato come sua sostituzione. L'operazione XOR trasforma 0 in 1, 2 in 3, 4 in 5 ecc. E viceversa, in modo che b venga scambiato con p, d con te così via. Infine, la stringa originale fino a c,

Risultati di esempio:

copertura di copertura

creazione creatdidi

progkaka di programmazione

stupidità stupbibi

blah blahhaha


link al repository blitzmax?
Destructible Lemon

@DestructibleLemon BlitzMax è stato creato come lingua principalmente per lo sviluppo di giochi amatoriali e con un compilatore proprietario venduto per denaro. Anche se ora è gratuito e disponibile da qui , credo che il compilatore non sia ancora open source. Esiste un'implementazione alternativa (repository qui , build qui ), che tuttavia eseguirà solo la versione non controllata del codice precedente a causa della mancanza di un'impostazione "non rigorosa" che consente di omettere dichiarazioni variabili.
FireballStarfish

Uso intelligente di XOR sull'indice: probabilmente lo userò un giorno. Grazie.
AI Breveleri,

4

Perl, 71 byte

s#[aeiouy]+(.)\K.*?([aeiouy]).*#"$1$2"=~y/bcdfgkpstvz/pgtvkgbzdfs/rx2#e

Corri anche con perl -pe. Pochi byte in meno rispetto alla precedente soluzione Perl. Devo ammettere che ho avuto anche qualche ispirazione da lì.


4

05AB1E , 101 104 88 byte

-16 byte grazie a Okx

Spero in qualche modo che ciò possa essere fatto in modo più efficiente.

žOÃćIsk>[DIs£¤žPså#\>]s[DIsèDžOså#\>]ŠŠ"bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"S2ôDí«ø`Šs¤sŠksŠèsŠì2׫

Provalo online!

Spiegazione

                  Argument: s
žOÃ0èk            Get index of first vowel in s
>[DIs£¤žPså#\>]   Increment index and split s until last character of substring is a consonant
s[DIsèDžOså#\>]   Increment index an get character at index in s until character is a vowel
ŠŠ                Rearrange stack
.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`   Prepare character substitution map
Šs                Rearrange stack
¤                 Last character of substring
sŠ                Rearrange stack (yes, again)
k                 Index of last character in substitution key list
sŠ                Rearrange stack (it won't stop)
è                 Character at index in character substitution value list
sŠ                Rearrange stack (ONE LAST TIME)
ì2׫              Prepend substitution consonant before vowel, duplcicate and concatenate with the substring from the very beginning

È possibile sostituire "bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"con .•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•per salvare 15 byte
Okx

È inoltre possibile sostituire žOÃćIskcon žOÃ0èkper salvare un altro byte.
Okx,

@Okx Penso di aver davvero bisogno di imparare alcune tecniche di compressione delle stringhe. Grazie!
Kalsowerus,

@kalsowerus So che è passato un po 'di tempo, ma puoi golf 8 byte dalla tua risposta in questo modo: žOÃнk>[DIs£¤žPså#\>]©s[DIsèDžOså#\>]s\.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`®θkèìDJ provalo online. Mi sono principalmente sbarazzato di tutti gli swap e triple swap utilizzando invece una variabile. E può essere н, e ho sostituito 2׫con DJper unire l'intero stack insieme. PS: ho anche pubblicato una risposta 05AB1E a 55 byte usando una tecnica diversa. (Che include anche un link per comprendere meglio la compressione in 05AB1E.: D)
Kevin Cruijssen,

3

Cristallo, 130 byte

c=/[aeiouy]/
x,y,z=ARGV[0].partition /[^aeiouy]*#{c}*/
k=z[0]
b=((i="pgtvkgbqrzdfs"=~/#{k}/)?"bcdfgkpqrstvz"[i]: k)+z[c]
p y+k+b*2

Come funziona

c = /[aeiouy]/

memorizzare una regex per la ricerca della prima vocale in c.

x, y, z = ARGV[0].partition /[^aeiouy]*#{c}*/

dividere il primo argomento in tre parti {"", String fino a un carattere prima della prima consonante dopo la prima vocale, resto della stringa} e memorizzare ciascuno degli elementi in x, ye z.

k = z[0]

ottenere il primo personaggio, la consonante pertinente.

i = "pgtvkgbqrzdfs" =~ /#{k}/

ottenere l'indice della consonante all'interno della stringa sinistra o nil.

b = ((i = ...) ? "bcdfgkpqrstvz"[i] : k) + z[c]

in caso icontrario nil, utilizzare questo indice per la seconda stringa (tipo di hash golfizzato).

se lo iè nil, usa il carattere originale.

quindi, aggiungi la prima vocale di z.

p y + k + (b * 2)

infine, stampa la prima parte dal primo regex y, la prima consonante ke due volte la stringa calcolata precedente b.

Provalo online .



2

Lua, 164 157 byte

w=arg[1]
i,j,a,b=w:find('[aeiouy]+([^aeiouy]+)(.)')
print(w:sub(1,j-#a)..(('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1,1)))..b):rep(2))

Modifica 1: rimosso 7 byte cercando qualsiasi carattere dopo le consonanti (vedi regex)

Provalo online!

Questo programma accetta una stringa nell'argomento CLI e stampa la sua versione covfefied.

Questa è la mia prima presentazione a un golf di codice! Non ho controllato gli altri in dettaglio, quindi potrei aver perso alcune ottimizzazioni comuni (e sono caduto in alcune trappole). Ho usato Lua perché mi è piaciuta questa piccola lingua e ho cercato di trovare una regex adatta alle mie esigenze.

Ecco una versione più pulita, usando una funzione (avevo intenzione di usarne una, ma le parole chiave in Lua sono troppo lunghe!):

function covfefy(word)
  i, j, a, b = word:find('[aeiouy]+([^aeiouy]+)(.)')

  -- 'a' is one or several consonants following the first vowel, b is the first vowel after that
  -- 'i' is the index of the beginning of 'a', 'j' the index of 'b'

  cov = word:sub(1, j - #a)

  -- Look for the first letter of 'a' in the voiced/voiceless table
  f = ('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1, 1)))

  return cov .. (f .. b):rep(2)
end

Sentiti libero di dare un feedback :)

Nota: se ti stai chiedendo, è lungo 149 byte usando MoonScript!


2

JavaScript (ES5), 237 229 byte

function(s){r=['aeiouy','bcdfgkpstvz','pgtvkgbzdfs']i=0,p=''while(p+=s[i],r[0].indexOf(s[i++])<0);while(p+=s[i],~r[0].indexOf(s[i++]));b=s[i-1];while(r[0].indexOf(s[i++])<0);c=r[1].indexOf(b)d=((~c)?r[2][c]:b)+s[i-1]return p+d+d}

Provalo online!

Probabilmente non è il più goloso, ma è ES5.

Recentemente corretto un bug. Esempio di output:

creation->creatdidi
coverage->covfefe
example->exxaxa
programming->progkaka
code->codtete
president->preszizi

2

sed, 106 (105 + 1) byte

Questo è sed con la -Ebandiera, che apparentemente conta per un byte.

s/([aoeuiy][^aoeuiy])[^aoeuiy]*(.).*/\1\2/
h
s/.*(..)/\1\1/
y/bcdfgkpstvz/pgtvkgbzdfs/
x
s/.$//
G
s/\n//g

Provalo online!


2

C #, 584 581 byte

-3 byte grazie a Destructible Lemon

Questa è la mia prima presentazione su Code Golf e su Stack Exchange in generale. So che C # non è un ottimo linguaggio per il golf e questo probabilmente non è completamente ottimizzato ma volevo provarlo: p. Tutti i suggerimenti sono benvenuti!

Versione golfizzata:

namespace System{class B{static void Main(string[]args){var s="creation";var t="aeiou";int i=0,j=0,l=s.Length;char c=' ',f=' ';for(int x=0;x++<l;){if(t.IndexOf(s[x])>=0){i=x;break;}}for(int x=i;x++<l;){if(!(t.IndexOf(s[x])>=0)){j=x;c=s[x];for(int y=x;y++<l;){if (t.IndexOf(s[y])>=0){f=s[y];goto W;}}}}W:switch(c){case'b':c='p';break;case'c':c='g';break;case'd':c='t';break;case'f':c='v';break;case'g':c='k';break;case'k':c='j';break;case'p':c='b';break;case's':c='z';break;case't':c='d';break;case'v':c='f';break;case'z':c='s';break;}Console.Write(s.Substring(0,l-i-1)+c+f+c+f);}}}

Versione leggibile:

namespace System
{
    class B
    {
        static void Main(string[] args)
        {
            var s = "creation";
            var t = "aeiou";
            int i = 0, j = 0, l = s.Length;
            char c = ' ', f = ' ';
            for (int x = 0; x++ < l; )
            {
                if (t.IndexOf(s[x]) >= 0)
                {
                    i = x; break;
                }
            }
            for (int x = i; x++ < l;)
            {
                if (!(t.IndexOf(s[x]) >= 0))
                {
                    j = x; c = s[x];
                    for (int y = x; y++ < l;)
                    {
                        if (t.IndexOf(s[y]) >= 0)
                        {
                            f = s[y];
                            break;
                        }
                    }
                }
            }
            switch (c)
            {
                case 'b': c = 'p';
                    break;
                case 'c': c = 'g';
                    break;
                case 'd': c = 't';
                    break;
                case 'f': c = 'v';
                    break;
                case 'g': c = 'k';
                    break;
                case 'k': c = 'j';
                    break;
                case 'p': c = 'b';
                    break;
                case 's': c = 'z';
                    break;
                case 't': c = 'd';
                    break;
                case 'v': c = 'f';
                    break;
                case 'z': c = 's';
                    break;
            }
            Console.Write(s.Substring(0, l - i - 1) + c + f + c + f);
        }
    }
}

1
Non sono un esperto, ma penso che puoi aggiungere l'incremento al comparatore nel ciclo for, cioè x++ < l, o qualcosa del genere (forse l > x++se il primo non funziona). non sono sicuro però
Destructible Lemon

@DestructibleLemon Grazie per il suggerimento!
Brandon Hao,

2

SmileBASIC 3, 195 byte

Molto tardi a questa domanda, ma come potrei resistere a una bella sfida per SmileBASIC 3? Funzionalità come l'iterazione di una sequenza o la manipolazione di una stringa non sono così robuste come le altre lingue, quindi questa è una sfida per farlo il più piccolo possibile. Presuppone che le parole siano MAIUSCOLE.

V$="AEIOUY
LINPUT W$REPEAT I=I+1UNTIL.<=INSTR(V$,W$[I-1])&&.>INSTR(V$,W$[I])J=I
WHILE.>INSTR(V$,W$[J])J=J+1WEND?LEFT$(W$,I+1)+("PGTVKHJGLMNBQRZDFWXS"[INSTR("BCDFGHJKLMNPQRSTVWXZ",W$[I])]+W$[J])*2

Spiegazione dettagliata qui!


2

05AB1E , 55 byte

η.ΔžOSåàyžPSÅ¿à*}ÐIsKžOÃнsθU.•gÍĆdQ¸G•SDXåiÂXQÏθë\X}ìDJ

Provalo online o verifica tutti i casi di test .

Spiegazione:

η                        # Suffixes of the (implicit) input
                         #  i.e. "creation" → ["c","cr","cre","crea","creat","creati","creato","creatio","creation"]
        }              # Find the first for which the following is truthy:
   žO                    #  Push vowels (including y): "aeiouy"
     S                   #  Convert it to a list of characters: ["a","e","i","o","u","y"]
      å                  #  Check for each if they're in the current (implicit) suffix
                         #   i.e. "creat" → [1,1,0,0,0,0]
       à                 #  Pop and push the max (basically check if any are truthy)
                         #   i.e. [1,1,0,0,0,0] → 1
   y                     #  Push the suffix again
    žP                   #  Push the consonants (excluding y): "bcdfghjklmnpqrstvwxz"
      S                  #  Convert to a list of characters: ["b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","z"]
       Å¿                #  Check for each if the suffix ends with it
                         #   i.e. "creat" → [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]
         à               #  Pop and push the max (basically check if any are truthy)
                         #   i.e. [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0] → 1
   *                     #  Check if both are truthy
                         #   i.e. 1 and 1 → 1
           Ð             # Triplicate the found suffix
            I            # Push the input
             s           # Swap the top two items on the stack
                         #  i.e. stack contains now: "creat","creat","creation","creat"
K                        # Remove the suffix from the input
                         #  i.e. "creation" and "creat" → "ion"
 žOÃ                     # Only leave the vowels
                         #  i.e. "ion" → "io"
    н                    # Pop and push the first character
                         #  i.e. "io" → "i"
s                        # Swap again so the prefix is a the top of the stack again
 θ                       # Pop and push the last character
                         #  i.e. "creat" → "t"
  U                      # Pop and store it in variable `X`
   .•gÍĆdQ¸G            # Push string "bcdfkszgvtgp"
             S           # Convert to list of characters: ["b","c","d","f","k","s","z","g","v","t","g","p"]
              D          # Duplicate it
               Xåi       # If `X` is in this string:
                  Â      #  Bifurcate the list (short for Duplicate & Reverse copy)
                         #   i.e. ["b","c","d","f","k","s","z","g","v","t","g","p"]
                         #   → ["p","g","t","v","g","z","s","k","f","d","c","b"]
                   XQ    #  Check if they're equal to variable `X`
                         #   i.e. `X` = "t" → [0,0,1,0,0,0,0,0,0,0,0,0]
                     Ï   #  Only keep the truthy values
                         #   i.e. ["b","c",...,"g","p"] and [0,0,1,0,0,0,0,0,0,0,0,0]
                         #    → ["d"]
                      θ  #  Pop and push the last one
                         #   i.e. ["d"] → "d"
                 ë       # Else:
                  \      #  Discard the duplicate list from the stack
                   X     #  And push variable `X` again
                 }       # Close the if-else
                  ì      # Prepend the second character in front of the first
                         #  i.e. "d" and "i" → "di"
                   D     # Duplicate it
J                        # Join the stack together (and output implicitly)
                         #  i.e. "creat" and "di" and "di" → "creatdidi"

Vedere questo consigli 05AB1E mie (sezione Come comprimere le stringhe che non fanno parte del dizionario? ) Per capire il motivo per cui .•gÍĆdQ¸G•è "bcdfkszgvtgp".

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.