ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ ਪਾਸਕਲ ਲਈ ਸਾਈਕਲ

ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਕਾਯਦੇ - ਚੱਕਰ, ਉਦਾਹਰਨ ਲਈ, ਲਈ. ਪਾਸਕਲ. ਕਿਸੇ ਵੀ ਕੰਪਿਊਟਰ ਭਾਸ਼ਾ ਦੇ ਨਾਲ ਦੇ ਰੂਪ ਵਿੱਚ, ਇਸ ਨੂੰ ਵੀ ਆਪਣੇ ਸੰਟੈਕਸ ਵਿੱਚ ਅਜਿਹੇ ਡਿਜ਼ਾਈਨ ਸ਼ਾਮਿਲ ਹਨ.

ਅਰਥਾਤ ਚਾਲਕ ਦੀ ਨਿਯੁਕਤੀ

ਇੱਕ ਖਾਸ ਕੰਮ - ਉਸੇ ਹੀ ਕਾਰਵਾਈ ਨੂੰ ਕਈ ਵਾਰ ਕਰਨ ਲਈ ਕੰਪਿਊਟਰ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ. ਇੱਥੇ ਅਤੇ ਡਿਜ਼ਾਇਨ ਨੂੰ ਬਚਾਉਣ, ਕੋਡ ਪੁਨਰਾਵ੍ਰੱਤੀ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਸਹਾਇਕ ਹੈ. ਇਸ ਲਈ, ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਚੱਕਰ - ਇਸ ਨੂੰ ਵਾਰ-ਵਾਰ ਕਾਰਵਾਈ ਨੂੰ ਕਰਨ ਲਈ, ਵਰਤਿਆ ਗਿਆ ਹੈ, ਭਾਸ਼ਾ ਸਰੋਤ ਦੀ ਮਦਦ ਨਾਲ ਆਯੋਜਿਤ ਕੀਤਾ.

ਪਾਸਕਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਡਿਜ਼ਾਈਨ ਦੇ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਲਈ - ਪੈਰਾਮੀਟਰ ਨਾਲ ਦੁਹਰਾਓ;
• ਜਦਕਿ - ਸ਼ਰਤ ਨਾਲ ਦੁਹਰਾਇਆ ਗਿਆ ਸੀ;
• ਦੁਹਰਾਓ ... ਜਦ ਤੱਕ - ਇੱਕ postcondition ਜਾਪ.

ਲੱਗਦਾ ਹੈ ਸਾਦਗੀ ਅਤੇ ਅਰਥਾਤ ਬਣਤਰ ਦੇ ਸਪੱਸ਼ਟਤਾ ਦੇ ਬਾਵਜੂਦ, ਨਿਹਚਾਵਾਨ ਪ੍ਰੋਗਰਾਮਰ ਆਪਣੇ ਲਾਗੂ ਕਰਨ 'ਚ ਸਮੱਸਿਆ ਦੇ ਇੱਕ ਨੰਬਰ ਦਾ ਸਾਹਮਣਾ. ਮਹਾਨ ਮੁਸ਼ਕਲ ਚੱਕਰ ਦੇ ਆਉਟਪੁੱਟ ਸੈਟਿੰਗ ਹਾਲਾਤ ਹੈ. ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਬਿਆਨ ਲਈ ਗਿਣਤੀ ਸਭ ਸਿੱਧਾ ਹੈ.

ਬਣਤਰ

ਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਨਾਲ ਦੁਹਰਾਉ ਬਣਤਰ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਹੇਠ ਕੋਡ ਡਾਇਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

ਲਈ {ਨੂੰ ਇੱਕ}: = {ਅ } {ੲ} ਕਰਨੀ {d}.

ਰਾਜਧਾਨੀ 'ਅੱਖਰ ਦੀ ਸਹੂਲਤ ਲਈ ਭਾਸ਼ਾ ਦੇ ਰਿਜ਼ਰਵਡ ਵਰਡ ਦੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਭਿਆਸ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਇੱਕ ਸਤਰ ਨਿਸ਼ਾਨ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ. ਵਰਤੇ ਵੇਰੀਏਬਲ ਅਤੇ ਚਾਲਕ ਕਰਲੀ ਬਰੈਕਟ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਹਨ. ਉਹ ਦਾ ਮਤਲਬ:

• {ਇੱਕ} -, ਮੰਨਣਯੋਗ ਅਕਸਰ ਅੰਕ ਦੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵੇਰੀਏਬਲ;
• {ਬੀ '}, {ੲ} - ਸਮੀਕਰਨ ਮੰਨਣਯੋਗ ਕਿਸਮ, ਦੇ ਤੌਰ ਤੇ ਹੀ {ਨੂੰ ਇੱਕ};
• {ਡੀ '} - ਇਖਤਿਆਰੀ ਆਪਰੇਟਰ / ਭਾਸ਼ਾ ਦੇ ਚਾਲਕ ਵੀ ਲੂਪ ਸਰੀਰ ਨੂੰ ਕਹਿੰਦੇ ਹਨ.

= {ੲ} ਲਈ ਡਿਜ਼ਾਇਨ ਦੀ ਕਮਾਈ, ਪਾਸਕਲ ਦੀ {ਅ}, {ਸੈੱਟ ਨੂੰ ਇੱਕ} ਮੁੱਲ ਦਾ ਹਿਸਾਬ , ਫਿਰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ:

• ਹਾਲਤ {ਅ} <= {ੲ} ਦੀ ਤਸਦੀਕ , ਜਿਸ 'ਤੇ ਚੱਲਣ ਦੇ ਚੱਕਰ ਕੰਮ ਕਰ ਰੁਕ;
• ਸ਼ੁਰੂਆਤ ਆਪਰੇਟਰ {d};
• ਦੇ ਮੁੱਲ ਨੂੰ ਵੱਧ ਰਹੀ {ਨੂੰ ਇੱਕ} ਯੂਨਿਟ 'ਤੇ ਹੈ, ਉਦਾਹਰਨ ਲਈ {ਨੂੰ ਇੱਕ}: = {ਨੂੰ ਇੱਕ} + 1.

ਇਸ ਉਸਾਰੀ ਜਾਣਿਆ ਲਈ ਸਰੀਰ ਦੇ ਅੰਦਰ ਨੂੰ ਸੁਣੇਗਾ ਦੀ ਗਿਣਤੀ deterministic ਚੱਕਰ ਵੇਖੋ.

ਮਿਸਾਲ

ਨੂੰ ਸਮਝਣ ਲਈ ਇਸ ਨੂੰ ਕਰਨ ਲਈ, ਆਦਿ ਬਾਹਰ ਹੀ ਕੀਤਾ ਜਾਵੇਗਾ, ਇੱਕ ਉਦਾਹਰਨ ਹੈ, "Dummies" ਲਈ ਪਾਸਕਲ ਵਿੱਚ ਕੋਡ ਹੈ.

• ਹਵਾਈਅੱਡੇ: = 0;
• ਨੂੰ ਇੱਕ ਕਰਨ ਲਈ: 5 = 1 ਕੀ
• ਸ਼ੁਰੂ
• ਹਵਾਈਅੱਡੇ: = ਹਵਾਈਅੱਡੇ + ਇੱਕ;
• ਨੂੰ ਖਤਮ;
• writeln (ਹਵਾਈਅੱਡੇ);

ਲਿਖਿਆ ਨਿਰਦੇਸ਼ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਹਰ ਪੜਾਅ ਵਿੱਚ ਮੁੱਲ ਲਿਖ ਸਕਦੇ:

• 1 ਦਾ ਪੜਾਅ: ਇੱਕ = 1; S = 1;
• 2 ਪੜਾਅ: ਇੱਕ = 2; S = 3;
• ਤੀਜਾ ਪੜਾਅ: ਇੱਕ = 3; S = 6;
• 4-th ਪੜਾਅ: ਇੱਕ = 4; S = 10;
• 5 ਪੜਾਅ: ਇੱਕ = 5; S = 15.

5 1 ਨੰਬਰ ਦਾ ਜੋੜ - ਇੱਕ ਨਤੀਜੇ ਦੇ ਤੌਰ ਤੇ, ਉਪਭੋਗੀ ਨੂੰ ਸਕਰੀਨ ਨੰਬਰ "15" 'ਤੇ ਦੇਖਦਾ ਹੈ.

ਪਹਿਲੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਹੋਰ ਪਰਭਾਵੀ ਕਰਨ ਲਈ, ਦਾ ਨੰਬਰ 1 ਅਤੇ 5 ਵੇਰੀਏਬਲ ਤਬਦੀਲ ਕਰੋ.

ਆਮ ਗਲਤੀ

ਜਦ ਤੁਹਾਨੂੰ ਲੂਪ ਲਈ ਇੱਕ ਨੂੰ ਵਰਤਣ, ਪਾਸਕਲ {ਨੂੰ ਇੱਕ}, {ਅ} ਦੇ ਮੁੱਲ ਨੂੰ ਧਿਆਨ ਦੀ ਲੋੜ ਹੈ {ੲ}. ਜੇਕਰ ਤੁਹਾਨੂੰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਦੇ ਨਿਯਮ ਦੀ ਪਾਲਣਾ ਨਾ ਕਰਦੇ, ਜੇ, ਕੰਪਾਈਲਰ ਇੱਕ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕਰੇਗਾ. ਪੰਜ ਅਜਿਹੇ ਨਿਯਮ.

1. ਵਿਰੋਧੀ (ਚੱਕਰ ਪੈਰਾਮੀਟਰ) {ਨੂੰ ਇੱਕ} ਕੀਤਾ ਇੱਕ ਪੂਰਨ ਅੰਕ.
2. ਮੁੱਲ {ਅ} ਅਤੇ {ੲ} ਨੇ ਵੀ ਇੱਕ ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਇਸ ਨੂੰ 0 ਤੱਕ ਪੀ ਲਈ, ਕੋਣ ਦੇ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ radians ਵਿਚ ਜ਼ਰੂਰੀ ਹੈ. = 0 PI ਕਰਨ ਲਈ ਕੀ: ਪਰ ਅਗਲੇ ਕੋਡ ਇੰਦਰਾਜ਼ ਗਲਤ ਲਈ ਹੋ ਜਾਵੇਗਾ. ਹੱਲ - ਵਰਤਣ ਲਈ ਇੱਕ ਗੋਲ ਫੰਕਸ਼ਨ trunc () ਅਤੇ ਦੌਰ '(). ਇਸ ਨੂੰ ਨੇੜੇ ਦੇ ਪੂਰਨ ਦੌਰ '- ਪਹਿਲੀ ਅਸਲੀ ਨੰਬਰ, ਦੂਜਾ ਦਾ ਦਸ਼ਮਲਵ ਹਿੱਸਾ ਰੱਦ.
3. {ਅ} <{ੲ}, {d} ਆਪਰੇਟਰ ਕੰਮ ਕਰੇਗਾ ਕਦੇ ਉਪਭੋਗੀ ਨੂੰ ਇੱਕ ਗਲਤੀ ਕੀਤੀ ਹੈ ਅਤੇ ਕੀਤਾ ਹੈ, ਜੇ.
4. ਲੂਪ ਜਵਾਬੀ ਕਰਨ ਬਾਅਦ {ਨੂੰ ਇੱਕ} ਕਿਸੇ ਵੀ ਮੁੱਲ ਪੈ ਸਕਦਾ ਹੈ. ਪਰ ਇਸ ਨੂੰ counterintuitive ਹੈ, ਪਰ ਅਭਿਆਸ ਵਿੱਚ, {ਨੂੰ ਇੱਕ} <> {ੲ} . ਸਿੱਟਾ: ਨੂੰ ਚਾਲੂ ਨਾ ਕਰੋ {ਨੂੰ ਇੱਕ} ਲਈ ਡਿਜ਼ਾਇਨ ਦੇ ਬਾਅਦ.
5. ਲੂਪ ਦੇ ਸਰੀਰ (ਹੈ, ਜੋ ਕਿ ਹੈ, ਸ਼ਬਦ ਨੂੰ ਕੀ ਦੇ ਬਾਅਦ) ਕੋਈ ਵੀ ਬਿਆਨ ਹੈ, ਜੋ ਕਿ ਪੈਰਾਮੀਟਰ ਮੁੱਲ ਨੂੰ ਤਬਦੀਲ ਵਰਤਣ ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਹੈ {ਨੂੰ ਇੱਕ}. ਇਸ ਨਿਯਮ ਦੇ ਬਾਅਦ ਇੱਕ ਗਲਤੀ ਦਾ ਕਾਰਨ ਨਾ ਕਰੇਗਾ, ਪਰ ਕਾਰਜ ਦੀ ਤਰਕ-ਚੂਰ ਹੋ ਜਾਵੇਗਾ.

ਹੇਠ ਨਿਯਮ ਹੈ ਕਿ ਇੱਕ ਆਮ ਗੱਲ ਹੈ ਅਤੇ "ਸਲੀਕੇ" ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿਚ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ: ਇਸ ਨੂੰ ਕੋਡ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਹੂਲਤ ਸੀ, ਇਸ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਲਈ ਅਪਰੇਟਰ ਦੇ ਸਰੀਰ ਦਾ ਚੱਕਰ ਪਹਿਲੇ ਕਾਲਮ ਨਹੀ ਹੈ ਜ਼ਰੂਰੀ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਖੱਬੇ ਪਾਸੇ 2-3 ਖਾਲੀ ਕਰਨ ਦੇ ਜ Tab ਬਟਨ ਵਰਤ ਕੇ.

ਇਹ ਲੋੜ ਨੂੰ ਪਾਸਕਲ ਭਾਸ਼ਾ ਨੂੰ ਨਾ ਸਿਰਫ ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ. "Dummies" ਲਈ, ਇਸ ਨੂੰ ਤੁਹਾਨੂੰ ਛੇਤੀ ਲੱਭਣ ਅਤੇ ਨਿਰਦੇਸ਼ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਸਹਾਇਕ ਹੈ.

ਆਮ ਕੰਮ

ਤੁਹਾਨੂੰ ਫਾਰਮ f (x) = ਦੇ ਇੱਕ tabulation ਫੰਕਸ਼ਨ ਕਰਨ ਲਈ ਚਾਹੁੰਦੇ ਹੋ ਲਓ 3 X 15, ਜੋ ਕਿ ਸੀਮਾ ਹੈ, [X ₁ ਮੀਟਰ ਫੰਕਸ਼ਨ ਮੁੱਲ ਤੱਕ ਮੇਜ਼ 'ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ _ਹੈ; X _2] ਜਿੱਥੇ ਕਿ X ₁ ਅਤੇ X ₂ - ਘੱਟੋ ਘੱਟ ਹੈ ਅਤੇ ਦਲੀਲ ਦੀ ਵੱਧ ਮੁੱਲ. ਇਸ ਨੂੰ ਅਤੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਲਈ ਤਿਆਰ ਕਰਨ ਲਈ ਮਦਦ ਕਰਦਾ ਹੈ. ਪਾਸਕਲ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕੋਡ ਹੇਠ ਨੂੰ ਰਿਕਾਰਡ:

• ਲਈ ਇੱਕ: = 1 ਮੀਟਰ ਕਰਨ ਲਈ ਕੀ
• ਸ਼ੁਰੂ
• X: = x1 + (x2- x1) * (a- 1) / (ਐਮ-1);
• f: = 3 * X 15;
• writeln (X, '', F );
• ਅੰਤ.

X:: ਇਸ ਵਾਧਾ X ਨਾ ਦਿੱਤਾ, ਦਲੀਲ ਦਾ ਮੁੱਲ ਫਾਰਮੂਲੇ ਵਰਤ ਦੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਹਰ ਪੜਾਅ ਦੇ ਦੌਰਾਨ ਹਿਸਾਬ ਹੈ = x1 + (x2- x1) * (a- 1) / (ਐਮ-1).

ਚੱਕਰ ਵਿਚ ਚੱਕਰ

ਤੱਥ ਇਹ ਹੈ ਕਿ ਬਣਤਰ ਦੇ ਅੰਦਰ ਓਪਰੇਟਰ ਲਈ ਇਕ ਹੋਰ ਚੱਕਰ ਵਿੱਚ ਉਸ ਦੇ ਸਰੀਰ ਨੂੰ ਤਲਾਕ ਦੇਣ ਦੀ ਆਗਿਆ ਕਿਸੇ ਵੀ ਵਰਤਣ ਲਈ ਆਗਿਆ ਹੈ, ਦੀ ਝਲਕ ਵਿਚ. ਪਾਸਕਲ ਕੰਮ, ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨੂੰ ਵੀ ਇਸੇ ਲਈ ਇੱਕ ਮਿਆਰੀ ਦਾ ਵੇਰਵਾ ਹੈ:

• ਲਈ {ਨੂੰ ਇੱਕ}: = {ਅ } ਨੂੰ {ੲ} ਕੀ
• = {B1: {A1} ਲਈ } ਨੂੰ {C1} ਕੀ

ਠੀਕ ਕੰਮ ਕਰ ਤਿਆਰ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਹਾਲਤ ਨਾਲ ਪਾਲਣਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ: ਹਰ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਟਿੱਕਰ ਵੱਖ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਨਹੀ, ਮਨ ਦੀ ਲੂਪ ਬਾਹਰੀ ਲੂਪ, ਜਿਸ ਵਿੱਚ ਲਾਜ਼ੀਕਲ ਗਲਤੀ ਕਰਨ ਦੀ ਅਗਵਾਈ ਕਰੇਗਾ ਦੇ ਮੁੱਲ ਨੂੰ ਬਦਲ ਜਾਵੇਗਾ.