์ค๋์ ์ธํด๊ฐ๋ฐ์ ํฌ์ง์
์ ๋ํ ์ฐธ๊ณ ์ฌํญ์ ๋ํด ์ดํด๋ณด๊ณ ์ ํฉ๋๋ค. ์๋ ์์ ์ ์ ๊ฐ ์ด ๊ธ์
๋๋ค: ์ด ๋ฌธ์ ์ ๋ํ ๋ด ์๊ฐ์ ๊ณต์ ํ๊ณ ์ถ์ต๋๋ค. ์ด๋ณด์๊ฐ ์ผ์๋ฆฌ๋ฅผ ์ฐพ์ ๋ ์์ผ๋ก ๋ฌด์์ด ๊ธฐ๋ค๋ฆฌ๊ณ ์๋์ง์ ๋ํ ์์ด๋์ด๋ฅผ ๊ฐ๋ ๊ฒ์ด ์ ์ฉํ ๊ฒ์
๋๋ค.
๊ณต์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค: RUB 30,000์ PostgreSQL ๊ฐ๋ฐ์ ์ฐ์์ . ๊ฐ์ธ ์๋์ธ ๊ณต์ ์ LLC Business Technologies St. Petersburg, Kolomyazhsky Prospekt, 33k2 Business Technologies ํ์ ์
๋ฌด ๊ฒฝํ: ํ์ํ์ง ์์
Ideone์ ๋ํ ์์
์ฝ๋ ์ฐ๊ฒฐ: HERE ์์
์ด ์ฑ๊ณต์ ์ผ๋ก ์๋ฃ๋ ํ ์ธํฐ๋ทฐ์ ์ด๋๋์์ต๋๋ค. ์ธํฐ๋ทฐ ๋์ ๊ทธ๋ค์ ๋์๊ฒ ๋น์ทํ ์์
์ ๋ ๋ค๋ฅธ ๋ฐฐ์น๋ก ๋์ง๊ณ 2 ์๊ฐ ๋์ ๋์๊ฒ ํ๊ณผ ํ์์ฃผ์์ต๋๋ค. A4์ฉ์ง 2์ฅ. ๊ทธ๋ค์ ๋๋ญ์์ ๋ณด์ง ์๊ณ ๊ฐ์ ธ๊ฐ๋๋ ๋ค์ ์ ํํ๊ฒ ๋ค๊ณ ๋งํ์ต๋๋ค. ๊ทธ๋ฌํ ์ค๋ฝ์์ ์ป๋ ์ฆ๊ฑฐ์์ ๊ฒ์ด๋ ๋ง๋ก๋ ์ค๋ช
ํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ต์ํ ์ด๊ฒ์ ๋ง์ ์ฌ๋๋ค์ด ์ฌํ์ ์์ํ ๋ ์ง๋ฉดํด์ผ ํ ๊ฐํนํ ํ์ค์
๋๋ค.
ํฅ๋ฏธ๋กญ๊ณ ๊ฑด์ค์ ์ธ ์ธํฐ๋ทฐ๊ฐ ๋๊ธฐ๋ฅผ ์ง์ฌ์ผ๋ก ๋ฐ๋๋๋ค. ๊ณ ์ฉ์ฃผ๋ฅผ ํ๋ช
ํ๊ฒ ์ ํํ์ญ์์ค. ์ต์ ์ ๋คํ์ธ์!) ์ถ์ : 2018๋
4์(์ํธํํ
๋ฅด๋ถ๋ฅดํฌ) ๊ณ ์ฉ ํ์ฌ์ ๋ํ ๋ด ๋ฆฌ๋ทฐ๋ ์ฌ๊ธฐ์์ ๋ณผ ์ ์์ต๋๋ค.
- ํํ์, ํํ์
- ๊ฐ๋ฐ์์ ์ง๋์ ๋ฐ๋ผ ๋ณต์ก๋๊ฐ ๋ฎ์ ์์ ๊ตฌํ
- ์๊ฒฉ์ ์ง์์ ์ธ ์ฑ์ฅ
- ๊ตฌ์กฐ์ ํ๋ก๊ทธ๋๋ฐ์ ์๋ฆฌ์ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ด๋ก ์ ์ดํดํฉ๋๋ค.
- ์ฑ ์๊ฐ, ๋ ๋ฆฝ์ฑ, ์ฃผ๋์ฑ
- ์์ฌ์ํต ๋ฅ๋ ฅ, ํ์์ ์ผํ๋ ค๋ ๋ฅ๋ ฅ ๋ฐ ์ด๋ง
- ๋์ ํ์ต๋ฅ๋ ฅ
- ์ง์
- SQL;
- Pl\sql;
- Pl\pgSql;
- C++, ์๋ฐ, ํ์ค์นผ.
- ์์ ์ ์ด๊ณ ์ญ๋์ ์ผ๋ก ๋ฐ์ ํ๋ ํ์ฌ์์ ๊ทผ๋ฌด
- ํธ์ํ ๊ทผ๋ฌด ์กฐ๊ฑด
- ํ์์ฃผ์์ ๊ด๋ฃ์ฃผ์์ ๋ถ์กฑ
- ์ ๋ฌธ์ ๋ฐ ๊ฒฝ๋ ฅ ์ฑ์ฅ์ ์ํ ๊ด๋ฒ์ํ ๊ธฐํ
- ๋ฉด์ ๊ฒฐ๊ณผ์ ๋ฐ๋ฅธ ๊ธ์ฌ
- ๋ ธ๋๋ฒ์ ๋ฐ๋ฅธ ๋ฑ๋ก, ๋ ธ๋๋ฒ์ ๋ฐ๋ฅธ ์ ๊ธ ํด๊ฐ.
- ํธ์ง ํค๋์ ์ง์ ์ฝ๋๋ฅผ ํ์ํ์ญ์์ค: Project04
- ์ผ์ชฝ ์ฌ๋ฐฑ์ ๋ค์ฌ์ฐ๊ธฐ๋ ์ค์ฒฉ ์์ค์ ๋ํ๋ ๋๋ค.
- ๋ฃจํ while, for, ๋ฐ๋ณต ๋ฐ ์กฐ๊ฑด ๊ตฌ๋ฌธ์ ํ์ค์นผ๊ณผ ๋์ผํ ์๋ฏธ๋ฅผ ๊ฐ์ต๋๋ค.
- "--" ๊ธฐํธ๋ ์ค๋ช ์ ๋ํ๋ ๋๋ค.
- ":=" ๊ธฐํธ๋ ํ ๋น์ ๋ํ๋ ๋๋ค.
- ๋ฌ๋ฆฌ ๋ช ์๋์ง ์๋ ํ ๋ณ์๋ ํ๋ก์์ ์ ๋ํด ๋ก์ปฌ์ ๋๋ค.
- ๋ฐฐ์ด ์ธ๋ฑ์ค๋ ๋๊ดํธ๋ก ์์ฑ๋๋ฉฐ A[i] ๊ตฌ์ฑ์ ๋ฐฐ์ด A์ i ์์๋ฅผ ์๋ฏธํฉ๋๋ค.
-
์ฌ๋ฌ ํ๋๋ก ๊ตฌ์ฑ๋๊ฑฐ๋ ์ฌ๋ฌ ์์ฑ์ ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ํ๋ ๊ฐ์ FieldName[๊ฐ์ฒด ์ด๋ฆ]์ผ๋ก ์์ฑ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ฐฐ์ด A์ ๊ธธ์ด๋ Length[A]๋ก ์์ฑ๋ฉ๋๋ค. ๋๊ดํธ์ ์๋ฏธ๋ ์ปจํ ์คํธ(๋ฐฐ์ด์ ๋ํ๋ด๋ ๋ณ์ ๋๋ ๊ฐ์ฒด๊ฐ ํด๋น ๊ตฌ์ฑ ๋ฐ์ดํฐ์ ๋ํ ํฌ์ธํฐ์)์ ๋ฐ๋ผ ๊ฒฐ์ ๋ฉ๋๋ค. ์์์ ํ๋ f์ ๋ํด y:=x๋ฅผ ํ ๋นํ๋ฉด 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