ืืืื ืืจืฆืื ื ืืืกืชืื ืขื ืชื ืื ืืืชืืืืกืืช ืืชืคืงืื ืืคืชื ืืชืืื. ืคืขื ืืชืืชื ืืช ืื: ืื ื ืจืืฆื ืืืืืง ืืช ืืืืฉืืืช ืฉืื ืืขื ืืื ืืื. ืื ืืขืืืจ ืืืชืืืืื ืืงืื ืืืฉื ืื ืืฆืคื ืืื ืืขืชืื ืืืฆืืืช ืขืืืื.
ืืืฉืจื ืืคื ืืื ืืื ืืืืงืื: ืืชืืื ืืคืชื PostgreSQL ื- RUB 30,000. ืืคื ื ื ืืืื ืืก ืืื ืกื ืืืฉื LLC Business Technologies St. Petersburg, Kolomyazhsky Prospekt, 33k2 Business Technologies ื ืืกืืื ืขืืืื ื ืืจืฉ: ืื ืืืื
ืงืืฉืืจ ืขื ืงืื ืขืืืื ื-Ideone: ืืื ืืืฉืืื ืืืฉืืื ืืืฆืืื, ืืืืืจ ืืื ืืืืื ืชื ืืจืืืื, ืฉืื ืืืงืื ืจืืืื ืืจืงื ืขืื ืขืื ืงืืืฆื ืฉื ืืฉืืืืช ืืืืืช ืืขืืื ืืฉืขืชืืื, ื ืชื ื ืื ืขื ื 2 ืคืืกืืช ื ืืืจ A4. ืื ืืงืื ืืช ืืขืืื ืืื ืืืกืชืื ืขืืืื ืืืืจื ืฉืืชืงืฉืจื ืืืืจื. ืื ืืคืฉืจ ืืชืืจ ืืช ืืื ืื ืฉืื ืืืืืื ืืื ืืืืืื ืืฆืื ืืจืืช. ืืื, ืืื ืืคืืืช, ืื ืืืฆืืืืช ืืงืฉื ืฉืจืืื ืืฆืืจืื ืืืชืืืื ืืืชื ืืชืืืืช ืืจืื.
ืื ื ืืืื ืื ืืื ืืื ืจืืืื ืืช ืืขื ืืื ืื ืืืื ืื. ืืืจ ืืช ืืืขืกืืง ืฉืื ืืืืืื. ืื ืืืืื!) ื .ื.: ืืช ืืืืงืืจืช ืฉืื ืขื ืืืจืืช ืืขืกืืงืืช ืืืคืจืื 2018 (ืกื ื ืคืืจืกืืืจื) ื ืืชื ืืืฆืื ืืื
- ืืฉืจื ืืืื, ืืฉืจื ืืืื
- ืืืฆืืข ืืฉืืืืช ืืจืืช ืืืจืืืืช ื ืืืื ืืื ืืืืช ืืคืชื
- ืฆืืืื ืืชืืืช ืฉื ืืืฉืืจืื
- ืืื ืช ืขืงืจืื ืืช ืืชืื ืืช ืืืืื ื ืืืชืืืืจืื ืฉื ืืกืื ื ืชืื ืื ืืืกืืื.
- ืืืจืืืช, ืขืฆืืืืช, ืืืืื
- ืืืฉืืจื ืชืงืฉืืจืช, ืืืืืช ืืจืฆืื ืืขืืื ืืฆืืืช
- ืืืืืช ืืืืื ืืืืื
- ืึถืึทืข
- SQL;
- Pl\sql;
- Pl\pgSql;
- C++, Java, Pascal.
- ืขืืืื ืืืืจื ืืฆืืื ืืืชืคืชืืช ืืฆืืจื ืืื ืืืช
- ืชื ืื ืขืืืื ื ืืืื
- ืืืกืจ ืคืืจืืืืื ืืืืจืืงืจืืื
- ืืืืื ืืืืช ื ืจืืืืช ืืฆืืืื ืืงืฆืืขืืช ืืงืจืืืจื
- ืฉืืจ ืืคื ืชืืฆืืืช ืืจืืืื
- ืจืืฉืื ืืคื ืงืื ืืขืืืื, ืืืคืฉื ืืชืฉืืื ืืืชืื ืืืงืืงืช ืืขืืืื.
- ื ื ืืฆืืื ืืช ืงืื ืืืฉืจื ืืืืชืจืช ืืืืชื: Project04
- ืืืื ืืืฉืืืืื ืืฉืืืืืื ืืขืืื ืขื ืจืืช ืืงืื ืื.
- ืืืืืืืช ืืขืื, ืขืืืจ, ืืื ืื ืืืืจืื ืืชื ืืืื ืืฉ ืืช ืืืชื ืืฉืืขืืช ืืื ืืคืกืงื.
- ืืกืื "--" ืืฆืืื ืืขืจื
- ืืกืื ":=" ืืฆืืื ืืงืฆืื
- ืืืฉืชื ืื ืื ืืงืืืืื ืื ืืื ืืื ืื ืฆืืื ืืืจืช
- ืืื ืืงืก ืืืขืจื ืืชืื ืืกืืืจืืื ืืจืืืขืื, ืืื ืืื A[i] ืคืืจืืฉื ืืืื ื i ืืืขืจื A
-
ื ืืชื ืืืฉืชืืฉ ืืืืืืืงืืื ืืืืจืืืื ืืืกืคืจ ืฉืืืช ืื ืืขืื ืืกืคืจ ืชืืื ืืช; ืขืจืื ืืฉืืืช ื ืืชืืื ืืฉื FieldName[ObjectName].
ืืืืืื, ืืืจื ืืขืจื A ื ืืชื ื- Length[A]; ืืืฉืืขืืช ืฉื ืืกืืืจืืื ืืืจืืืขืื ื ืงืืขืช ืขื ืืื ืืืงืฉืจ (ืืฉืชื ื ืืืฆืืื ืืขืจื, ืื ืืืืืืงื ืืื ืืฆืืืข ืื ืชืื ืื ืืืจืืืืื ืืืชื). ืืืืจ ืืงืฆืืช y:=x ืืื ืฉืื f ืืืืข ืืฉืืืืื f[y]=f[x]; ืงืืืขื ืื ืชืืื ื ืืื ืคืื ืงืฆืื, ืืฉืชื ื ืื ืื ืืืจ ืืืจ ื ืขืฉืืช ืืคื ืืงืฉืจ.
- ืืฆืืืข ืืืื ืืืืืช ืืขื ืืขืจื ืืืืืื NIL, ืฉืืื ื ืืฆืืืข ืขื ืืฃ ืืืืืืงื.
- ืคืจืืืจืื ืืืขืืจืื ืืคื ืขืจื: ืืคืจืืฆืืืจื ืื ืงืจืืช ืืงืืืช ืขืืชืง ืืฉืื ืฉื ืืคืจืืืจืื; ืฉืื ืืืื ืืคืจืืืจืื ืืชืื ืืคืจืืฆืืืจื ืืื ื ื ืจืืื ืืืืืฅ. ืืขืช ืืขืืจืช ืืืืืืงืืื, ืืืขืชืง ืืฆืืืข ืื ืชืื ืื ืืชืืืืื ืืืืชื ืืืืืืงื.
public class Main {
public static void main(String[] args) {
int[] massif = {13, 3, 8, 1, 15, 2, 3, 7, 4};
System.out.print("ะะฐััะธะฒ ะดะพ ัะพััะธัะพะฒะบะธ: ");
for (int i = 0; i < massif.length; i++)
System.out.print(massif[i] + " ");
System.out.println("");
massif = sort(massif);
System.out.print("ะะฐััะธะฒ ะฟะพัะปะต ัะพััะธัะพะฒะบะธ: ");
for (int i = 0; i < massif.length; i++)
System.out.print(massif[i] + " ");
}
public static int[] sort(int x[]) {
if (x.length == 1) //ะ ะตะบัััะธั ะธะดะตั ะดะพ ัะตั
ะฟะพั, ะฟะพะบะฐ ะผะฐััะธะฒ ะดะตะปะธััั
return x;
else {
int half = (int) Math.floor(x.length / 2); //ะ ะฐะทะฑะธะฒะฐะตะผ ะผะฐััะธะฒ ะฝะฐ 2 ัะฐััะธ
int halfFirst[] = new int[half]; //1 ัะฐััั, ะฟัััะพะน ะผะฐััะธะฒ
int halfSecond[] = new int[x.length - half]; //2 ัะฐััั, ะฟัััะพะน ะผะฐััะธะฒ
for (int i = 0; i < x.length; i++) { //ะะฐะฟะพะปะฝัะตะผ ะฝะพะฒะพัะพะทะดะฐะฝะฝัะต ะผะฐััะธะฒั ะทะฝะฐัะตะฝะธัะผะธ
if (i < half)
halfFirst[i] = x[i];
else
halfSecond[i - half] = x[i];
}
halfFirst = sort(halfFirst); //ะ ะตะบัััะธั
halfSecond = sort(halfSecond); //ะ ะตะบัััะธั
x = sortNext(halfFirst, halfSecond); //ะัะฟัะฐะฒะปัะตะผ ะทะฐะฟะพะปะฝะตะฝะฝัะต ะทะฝะฐัะตะฝะธัะผะธ ะผะฐััะธะฒั ะฒ ัะปะตะดัััะธะน ะผะตัะพะด
return x;
}
}
public static int[] sortNext(int x[], int y[]) {
int c[] = new int [x.length + y.length]; //ะกะพะทะดะฐะตะผ ัะตะทัะปััะธััััะธะน ะผะฐััะธะฒ ะธะท ััะผะผั ะดะปะธะฝ ะผะฐััะธะฒะพะฒ ะธะท ะฐัะณัะผะตะฝัะพะฒ ะผะตัะพะดะฐ
int a = 0, b = 0;
for (int i = 0; i < x.length + y.length; i++) { //ะกัะฐะฒะฝะธะฒะฐะตะผ ะผะฐััะธะฒั, ะผะตะฝัะตะผ ะผะตััะฐะผะธ ัะปะตะผะตะฝัั, ะทะฐะฟะพะปะฝัะตะผ ะฝะพะฒะพัะพะทะดะฐะฝะฝัะน ะผะฐััะธะฒ
if (a == x.length) {
c[i] = y[b];
b++;
}
else if (b == y.length) {
c[i] = x[a];
a++;
}
else if (x[a] > y[b]) {
c[i] = y[b];
b++;
}
else {
c[i] = x[a];
a++;
}
}
return c;
}
}
GO TO FULL VERSION