História

Preciso me lembrar de muitas senhas e não quero usar a mesma para vários sites, então criei uma regra, mas a regra não deve ser transparente, então o que faço é:

• Pense em uma palavra longa ou conceito como breadpudding.
• Substitua a primeira letra pelo site em que estamos fazendo login. Se estamos logando google, nossa palavra se torna greadpudding.
• Faça a primeira letra maiúscula.
• Mude a segunda letra para um @sinal.
• Se a senha começar com uma não consoante, adicione um determinado número (como 1234); caso contrário, adicione outro número (como 4321).

Ta da, agora você tem uma senha adequada.

Embora esse processo seja árduo, preciso de um programa para gerar isso para mim com base no seguinte:

Problema

Dados fornecidos:

• a : a palavra inicial, que é uma sequência e é sempre em minúscula, com garantia de mais de três caracteres.
• b : o site no qual estamos efetuando login, que é uma string e sempre está em minúscula e é garantido que não está vazio.
• c : o número de não consoantes, que é um número inteiro positivo que pode ter zeros à esquerda.
• d : o número de consoantes, que é um número inteiro positivo que pode ter zeros à esquerda.

Saída uma string com base nos critérios acima.

Casos de teste

Entrada a="volvo", b="gmail", c=5555, d="0001"

G@lvo0001

Entrada a="sherlock", b="9gag", c=31415926535, d=3

9@erlock31415926535

Entrada a="flourishing", b="+google", c=11111, d=2222

+@ourishing11111

Regras

• y é uma consoante.
• Se você decidir cou dfor um número inteiro, poderá analisá-lo como tal e os zeros à esquerda podem ser ignorados ( 0091tratados como 91).
• Espaço em branco e novas linhas à direita são permitidos.
• Você pode enviar o resultado para STDOUT ou retornar o resultado em uma função.
• Caracteres permitidos em ae bsão [a-z0-9!@#$%^&*()_+=-].
• Você pode aceitar as 4 entradas em qualquer ordem consistente.

Isso é código-golfe . O menor código em bytes vence.

Geléia , 17 bytes

Ḣ©Œu;”@o;⁶⁵®eØC¤?

Um programa completo, tendo os argumentos na ordem b, a, c, d.

Experimente online!

Quão?

O link principal é diádica, tendo be a, as entradas do programa são, em seguida b, a, ce d(o terceiro ao sexto argumentos de linha de comando), então ce dsão acessados como tal.

Ḣ©Œu;”@o;⁶⁵®eØC¤?  Main link: b, a           e.g. "gmail", "volvo" (c="5555" and d="0001")
Ḣ                  head b                         'g'
 ©                 copy to register and yield     'g'
  Œu               convert to uppercase           "G"
     ”@            literal '@' character          '@'
    ;              concatenate                    "G@"
       o           logical or with a (vectorises) "G@lvo"
                ?  if:
               ¤     nilad followed by link(s) as a nilad:
           ®           recall value from register  'g'
             ØC        yield consonants            "BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz"
            e          exists in?                  1
         ⁶         ...then: 6th arg = 4th in = d   "0001" 
          ⁵        ...else: 5th arg = 3rd in = c   "5555"
        ;          concatenate                     "G@lvo0001"
                   implicit print

Python 3 , 69 bytes

lambda a,b,*c:b[0].upper()+"@"+a[2:]+c[b[0]in"bcdfghjklmnpqrstvwxyz"]

Experimente online!

05AB1E , 22 20 18 bytes

н©u'@I¦¦žN®åiI\}IJ

Entrada tomada como b,a,c,d

Experimente online!

Explicação (desatualizada)

¦                     # remove the first char of a
 s                    # swap b to the top of the stack
  н©                  # push the head of b and store a copy in register
    uì                # convert the head to upper case and prepend to a
      U               # store in variable X
       žN®åi          # if the head of b is a consonant
            \}        # discard c
              X«      # concatenate X with c or d
                '@1ǝ  # insert an "@" at character position 1

0èusado no link como нainda não foi enviado ao TIO.

Javascript ES6, 87 bytes

(a,b,c,d)=>b[0].toUpperCase()+'@'+a.slice(2)+(/[bcdfghjklmnpqrstvwxyz]/.test(b[0])?d:c)

Demo

f=
(a,b,c,d)=>b[0].toUpperCase()+'@'+a.slice(2)+(/[bcdfghjklmnpqrstvwxyz]/.test(b[0])?d:c)

console.log(f("volvo","gmail", 5555, "0001")); //G@lvo0001
console.log(f("sherlock","9gag", 31415926535, 3)); //9@erlock31415926535
console.log(f("flourishing","+google", 11111, "2222")); //+@ourishing11111

C, 441 286 139 bytes

#define o(c)*a[1]==0xc
int main(int b,char** a){printf("%c@%s%s",*a[1],a[2]+2,(*a[1]>97&*a[1]<128)
&!(o(65)|o(69)|o(6F)|o(75))?a[4]:a[3]);}

R , 105 103 bytes

pryr::f({m=substr(b,0,1);paste0(toupper(m),'@',substring(a,3),'if'(grepl("[b-df-hj-np-tv-z]",m),d,c))})

Função anônima. Avalia para

function (a, b, c, d) 
{
    m = substr(b, 0, 1)                      #first letter of website
    paste0(toupper(m),                       #concatenate that letter, capitalized,
           "@",                              #an '@',     
           substring(a, 3),                  #the rest of the long string,
           if(                               #and
           grepl("[b-df-hj-np-tv-z]", m)),   #if the first letter is a consonant,
           d                                 #the consonant string/num,
           else c)                           #else the other one
}

que é o que está no TIO. Por favor, me ajude a jogar esse regex porque sou péssimo com eles.

Salvou 2 bytes de Giuseppe.

Experimente online!

Retina , 80 75 bytes

^..(.*)¶(.).*
$2@$1
^([ -_aeiou].*)¶(.*)¶.*
$1$2
(.*)¶.*¶(.*)
$1$2
T`l`L`^.

Experimente online!

Experimentar um novo idioma aqui, recebe entradas na ordem dada na pergunta

Explicação:

^..(.*)¶(.).*
$2@$1

Crie uma palavra que seja a segunda palavra, primeira letra, sinal @, primeira palavra a partir do terceiro caractere.

^([ -_aeiou].*)¶(.*)¶.*
$1$2

Se a palavra começar com uma não consoante, acrescente o primeiro número

(.*)¶.*¶(.*)
$1$2

Se ainda restarem 3 linhas (nenhuma substituição na última etapa, portanto, ela começa com uma consoante), acrescente o segundo número

T`l`L`^.

Maiúscula a primeira letra

QBIC , 81 bytes

G=ucase$(_s;,1|)+@@`+_s;,3,_lC||~instr(@bcdfghjklmnpqrstvwxyz`,_sC,1|)|?G+;\?G+;

Explicação

Parameters are Website(A$), base word(C$), consonant-number(E$), and nonsonant-number(F$)
G=                           SET G$ to
 ucase$(      )              the upper-case version of (also works for '9gag', '+google')
        _s;,1|                  the first char of the website A$ read from cmd line
 +@@`                        plus a literal @ (B$)
 +_s;,3,_lC||                plus all characters from base word C$ from 3rd char onwards
~instr(                      IF the second arg to INSTR is in the first
 @bcdfghjklmnpqrstvwxyz`,      with all consonants in the first arg
 _sC,1|                        and the first char of the base word C$ in the second
 )
|?G+;                        THEN print G$ plus the consonant addition
\?G+;                        ELSE print G$ plus the other addition

Observe que as duas últimas linhas parecem iguais, mas o intérprete altera ligeiramente o comportamento de cada uma ;: Sempre que vê a ;instrução, cria uma nova variável (nesse caso, os vars È $ andF $ `são os primeiros disponíveis depois de ler tudo literais e argumentos de linha de cmd) e atribui o primeiro parâmetro de linha de cmd ainda não atribuído a essa variável.

JavaScript (ES6), 76 bytes

(a,b,c,d)=>b[0].toUpperCase()+'@'+a.slice(2)+(/[aeiou\d_\W]/.test(b[0])?c:d)

Eu teria acrescentado isso como uma sugestão para melhorar a solução do Weedoze , mas parece que não posso comentar sobre isso, porque eu me espreito

C # , 111 bytes

(a,b,c,d)=>Char.ToUpper(b[0])+"@"+a.Substring(2)+(b.IndexOfAny("bcdfghjklmnpqrstvwxyz".ToCharArray()==0)?d:c);

A verificação da consoante é particularmente cara, sem capacidade direta de regex no stringtipo.

F # , 157 bytes

let f(a:string)(b:string)c d=System.Char.ToUpper(b.[0]).ToString()+"@"+a.[2..]+(if((Seq.except['e';'i';'o';'u']['b'..'z'])|>Seq.contains b.[0])then d else c)

O F # ainda é muito novo para mim, então provavelmente existem abordagens melhores para isso.

Java 8, 112 99 92 87 bytes

(a,b,c,d)->b.toUpperCase().charAt(0)+"@"+a.substring(2)+(b.matches("[a-z&&[^aeiou]].*")?d:c)

-13 bytes, tomando o parâmetro blast em vez de second.
-1 byte removendo y
-7 bytes graças a @ OlivierGrégoire (e os parâmetros estão em ordem novamente)
-5 bytes graças a @ PunPun1000

Explicação:

Experimente aqui.

(a,b,c,d)->                     // Method with 4 String parameters and String return-type
  b.toUpperCase().charAt(0)     //  First character of B capitalized
  +"@"                          //  + literal "@"
  +a.substring(2)               //  + A excluding first two characters
  +(b.matches("[ -_aeiou].*")?  //  If B starts with a consonant:
    d                           //   + D
   :                            //  Else:
    c)                          //   + C
                                // End of method (implicit / lambda with single return)

V , 25 bytes

ldvjr@Ç^[aeiou]ü^Á/j

DÍî

Experimente online!

Leva argumentos no buffer em ordem:

website
word/phrase
consonant number
non-consonant number

Bash 4 , 76 bytes

g(){
a=${2:0:1}
c=$4
[[ "aeiou[0-9]" =~ .*$a.* ]]&&c=$3
p="${a^}@${1:2}$c"
}

Funciona no Bash 4:

g volvo gmail 5555 0001; echo $p
g sherlock 9gag 31415926535 3; echo $p
g flourishing +google 11111 2222; echo $p

Ruby , 73 bytes

->a,b,c,d{a.sub(/..(.*)/){b[0].upcase+"@#$1#{b[0]=~/[aeiou_\d\W]/?c:d}"}}

Experimente online!

JavaScript (ES6), 69 bytes

(a,b,c,d)=>e=a[0].toUpperCase()+"@"+a.slice(2)+/[AEIOU]/.test(e)?c:d

Muito simples, provavelmente pode ser jogado golfe