Sajnos pszeudo kódban nem tudom olyan könnyen megfogalmazni, de megírtam a programot C++ nyelven és arra az esetre, ha te magad nem ismernéd ezt a programozási nyelvet, írtam mellé magyarázó szöveget, hogy a program melyik része mit csinál.

#include <iostream>
#include <sstream>
#include <cmath>
#include <vector>

using namespace std;

void megduplaz(int a)
{
stringstream ss; /// szöveggé alakítom a számot, hogy
string s; /// aztán karakterenként("számjegyenként")
ss << a; /// dolgozhassak vele tovább
ss >> s;

vector<int> v; /// a szöveget karakterenként visszalakítom
for(size_t i=0; i<s.size(); i++) /// számmokká, amikkel feltöltök egy táblázatot
{ /// a táblázat tehát a megadott szám
char c; /// számjegyeit tartalmazza sorrendben
c=s[i];

stringstream ss;
int b;
ss << c;
ss >> b;

v.push_back(b);
}

int odd=0; /// számjegyenként ellenőrzöm, hogy azok páratlanok-e
for(size_t i=0; i<v.size(); i++) /// ha igen, akkor a számláló értéke eggyel nő
{ /// ha a számláló értéke annyi, ahány számjegyem van,
if(v[i]%2!=0) /// akkor kiír -1-et
{
odd+=1;
}
}

if(odd==v.size())
{
cout<<-1<<endl;
}
else /// ha nem, akkor a páros számjegyeket megduplázza
{ /// és minden számjegyet kiír
for(size_t i=0;i <v.size(); i++)
{
if(v[i]%2==0)
{
v[i]=v[i]*2;
}

cout<<v[i];
}
}
}

int main()
{
int a; /// beolvasok a konzolról egy természetes számot
cin>>a;
megduplaz(a); /// meghívom a függvényt, ami eldönti, hogy mit írjon ki a kozolra

return 0;
}

Nem vagyok róla meggyőződve, hogy ez a legegyszerűbb lehetséges megoldás, de az biztos, hogy működik. Remélem, hogy ez alapján sikerül megírnod az algoritmus pszeudo kódját.

beolvas n
ha n < 1 akkor
    kiír "nem jó szám"
    vége

nn = 0     // nn-ben keletkezik az új szám, duplázott párosakkal, de megfordítva
nincspáros = igaz
mialatt n > 0
    // megjegyzés: mod és div a maradék és a hányados operátorok
    sz = n mod 10      // utolsó számjegy
    n = n div 10          // a szám többi része az utolsó számjegy nélkül
    ha sz mod 2 == 0 akkor    // ha páros
        nn = nn * 100 + sz * 11 // kétszer lesz benne sz
        nincspáros = hamis
    egyébként
        nn = nn * 10 + sz

ha nincspáros == igaz akkor
    kiír -1
    vége

// nn-ben fordított sorrendben vannak a számjegyek, fordítsuk vissza
szám = 0     // ebben gyűlik a végleges szám
mialatt nn > 0
    sz = nn mod 10
    nn = nn div 10
    szám = szám * 10 + sz

// szám most már jó:
kiír szám

Másik, rövidebb megoldás, ha tanultatok rekurziót:

függvény megdupláz(x):
    ha x == 0 akkor
        visszaad 0
    sz = x mod 10         // utolsó számjegy
    e = x div 10             // az eleje az utolsó számjegy nélkül (ha egyjegyű szám, akkor 0)
    d = megdupláz(e)  // az elejében lévő párosakat megduplázzuk
    ha sz mod 2 == 0 akkor
        visszaad d*100 + sz*11        // sz páros, megduplázzuk
    egyébként
        visszaad d*10 + sz               // sz páratlan, csak 1-szer tesszük bele

program Duplázás:
    beolvas n
    ha n < 1 akkor
        kiír "nem jó szám"
        vége
    egyébként
        nn = megdupláz(n)
        // ha egyetlen páros sem volt, nincs duplázva semmi, maradt az eredeti szám:
        ha nn == n akkor
            kiír -1
        egyébként
            kiír nn
        vége

A feladatodban ugye a számok karakterré változtatása a nehéz. Pszeudo kódban nincs unit, amit meghívsz, és lekezeli a konvertálást, neked kell kitalálni.
A ":=" jelenti "legyen egyenlő"-t.

Változók
i,j :egész (ciklusváltozó);
n :egész (bekérendő szám);
s :szöveg;
m,db,e :egész (segédváltozók);
g :végeredmény;

program indul;
m:=1;
db:=0;


ismétel
ki ("add meg az n-t: ");
be(n);
amíg n<1;

amíg (n/m)>=1 ismétel
m:=10*m;
db:=db+1;
ciklus vége;

e:=n;

i:=1;
amíg i<=db ismétel
amikor egészrész(e/10db-i) = /////case - switch vezérlési szerkezet
0:s:=s+"0";
1:s:=s+"1";
2:s:=s+"2";
3:s:=s+"3";
4:s:=s+"4";
5:s:=s+"5";
6:s:=s+"6";
7:s:=s+"7";
8:s:=s+"8";
9:s:=s+"9";
összetett elágazás vége;
e:=e-10abs(i-db);
i:=i+1;
ciklus vége;

j:=1;
amíg j<=hossz(s) ismétel
ha s[j]="6" akkor
i:=hossz(s)+1;
amíg i>j ismétel
s[i]:=s[i-1];
i:=i-1;
ciklus vége;
s[j]:=1;
s[j+1]:=2;
elágazás vége;
ha s[j]="8" akkor
i:=hossz(s)+1;
amíg i>j ismétel
s[i]:=s[i-1];
i:=i-1;
ciklus vége;
s[j]:=1;
s[j+1]:=6;
elágazás vége;
j:=j+1;
ciklus vége;

/////ha szám típusban (mondjuk az elől deklarált g változóban) kell kiíratni, akkor újra számmá konvertáljuk:

i:=0;
amíg i<=hossz(s) ismétel
amikor s[i] =
"0":g:=10*g;
"1":g:=g+1*10hossz(s)-i;
"2":g:=g+2*10hossz(s)-i;
"3":g:=g+3*10hossz(s)-i;
"4":g:=g+4*10hossz(s)-i;
"5":g:=g+5*10hossz(s)-i;
"6":g:=g+6*10hossz(s)-i;
"7":g:=g+7*10hossz(s)-i;
"8":g:=g+8*10hossz(s)-i;
"9":g:=g+9*10hossz(s)-i;
összetett elágazás vége;
i:=i+1;
ciklus vége;

program vége;