സെയ്‌ന്റുള്ള അടിസ്ഥാന പ്രോഗ്രാമിംഗ് (ഭാഗം 3)

ട്യൂട്ടോറിയലിന്റെ തുടർച്ചയാണിത് സെയ്‌ന്റുള്ള അടിസ്ഥാന പ്രോഗ്രാമിംഗ് (ഭാഗം 2), പ്രോഗ്രാമിന് എന്താണ് വേണ്ടതെന്ന് ഈ സമയം ഞാൻ വിശദീകരിക്കും.

അസൈൻമെന്റ്

ഒരു വേരിയബിൾ സൃഷ്ടിക്കുകയും കൂടാതെ / അല്ലെങ്കിൽ പരിഷ്കരിക്കുകയും ചെയ്യുന്ന ഒരു പ്രക്രിയയാണ് അസൈൻ‌മെന്റ്, അതിന്റെ ഐഡന്റിഫയർ വഴി നമുക്ക് അതിന്റെ മെമ്മറി സ്പേസ് ആക്സസ് ചെയ്യാൻ കഴിയും.

അസൈന്മെന്റിന്റെ വാക്യഘടന ഇതാണ്:

[variable]<- [expresion];
[variable]=[expresion];

[പദപ്രയോഗം] മൂല്യനിർണ്ണയത്തിന്റെ മൂല്യം സ്വീകരിക്കുന്ന വേരിയബിളാണ് ഇവിടെ. രണ്ടും സാധുവായതിനാൽ ഏതാണ് ഉപയോഗിച്ചതെന്നത് പ്രശ്നമല്ല (അവ PSeInt ശരിയായി ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിൽ), പക്ഷേ എന്റെ അഭിപ്രായത്തിൽ ആദ്യത്തേത് ശരിയായ ഒന്നായി ഞാൻ സൃഷ്ടിക്കുന്നു.

അസൈന്മെന്റിന് മുമ്പ് [വേരിയബിൾ] നിലവിലില്ലെങ്കിൽ, [വേരിയബിൾ] സൃഷ്ടിക്കപ്പെട്ടു, അത് നിലവിലുണ്ടെങ്കിൽ മുമ്പത്തെ മൂല്യം നശിപ്പിക്കുകയും പുതിയത് അതിന്റെ സ്ഥാനത്ത് സ്ഥാപിക്കുകയും ചെയ്യുന്നു. ഇക്കാരണത്താൽ, മാപ്പിംഗ് ഒരു വിനാശകരമായ പ്രവർത്തനമായി കണക്കാക്കുന്നു.

വായിക്കുന്നു

പറഞ്ഞ ഡാറ്റ ഒരു വേരിയബിളിൽ സംഭരിക്കാൻ ഉപയോക്താവിൽ നിന്ന് ഒരു ഡാറ്റയോ ഡാറ്റയോ അഭ്യർത്ഥിക്കുന്ന പ്രക്രിയയാണ് വായന.

അതിന്റെ വാക്യഘടന ഇതാണ്:

Leer variable_1,variable_2,...,variable_n;

ഇവിടെ [variable_ {1,2, n}] എന്നത് ഉപയോക്താവ് നൽകിയ മൂല്യം സ്വീകരിക്കുന്ന വേരിയബിൾ അല്ലെങ്കിൽ വേരിയബിളുകളാണ്, ഒന്നിൽ കൂടുതൽ വേരിയബിളുകൾ അഭ്യർത്ഥിച്ചിട്ടുണ്ടെങ്കിൽ, അത് ആദ്യം ആദ്യത്തേതും പിന്നീട് രണ്ടാമത്തേതും അങ്ങനെ ചോദിക്കും എല്ലാ മൂല്യങ്ങളും സ്വീകരിക്കുന്നതുവരെ.

ഇതും ഒരു വിനാശകരമായ പ്രവർത്തനം കൂടിയാണ്.

എഴുത്തു

അക്ഷരങ്ങളുടെ ഒരു സ്ട്രിംഗ് കൂടാതെ / അല്ലെങ്കിൽ ഒന്നോ അതിലധികമോ വേരിയബിളുകൾ സ്ക്രീനിൽ എഴുതുന്ന പ്രക്രിയയാണ് റൈറ്റിംഗ്

വാക്യഘടന ഇതാണ്:

Escribir expresion_1,expresion_2,...,expresion_n;

ഇവിടെ [expersion_ {1,2, n}] പ്രതീക സ്ട്രിംഗുകളും കൂടാതെ / അല്ലെങ്കിൽ വേരിയബിളുകളും പ്രദർശിപ്പിക്കും.

സ്‌ക്രീനിൽ ഇടേണ്ട ഡാറ്റ സ്വീകരിക്കുന്നതിനുപുറമെ എഴുതുന്നതിലൂടെ ലൈൻ ജമ്പ് ഒഴിവാക്കുന്ന "ഒഴിവാക്കാതെ" അല്ലെങ്കിൽ "താഴേക്ക് പോകാതെ" എന്ന നിർദ്ദേശവും ലഭിക്കുന്നു.

റൈറ്റിംഗ് ആർഗ്യുമെന്റുകൾക്കിടയിൽ ഇടങ്ങൾ ചേർക്കുന്നില്ല, അതായത്, നിങ്ങൾ ഇട്ടാൽ:

Proceso SinTitulo
a<- "ola";
b<- "mundo";
Escribir a,b;
FinProceso

case a »നും« b between നും ഇടയിൽ a, b എന്നിവയ്ക്കിടയിലുള്ള ഇടത്തെ സൂചിപ്പിക്കുന്ന പ്രതീക സ്ട്രിംഗില്ലാത്തതിനാൽ ഇത് case olamundo show കാണിക്കും, അതിനാൽ ഇത് ശരിയായി പ്രദർശിപ്പിക്കുന്നതിന് ഇത് ഇതുപോലെ എഴുതിയിരിക്കുന്നു:

Proceso SinTitulo
a<- "ola";
b<- "mundo";
Escribir a,"",b;
FinProceso

ഈ സാഹചര്യത്തിൽ add add ചേർക്കുക, അത് character വേവ് »നും« വേൾഡ് between നും ഇടയിലുള്ള സ്പെയ്സുള്ള ഒരു പ്രതീക സ്ട്രിംഗാണ്, തുടർന്ന് അത് സ്പെയ്സിനൊപ്പം «വേവ് വേൾഡ് show കാണിക്കും.

ഉണ്ടെങ്കിൽ

തന്നിരിക്കുന്ന അവസ്ഥയെ വിലയിരുത്തുകയും പറഞ്ഞ അവസ്ഥയുടെ സത്യസന്ധത കൂടാതെ / അല്ലെങ്കിൽ അസത്യത്തെ പരിശോധിക്കുകയും ചെയ്യുന്ന ഒരു പ്രസ്താവനയാണിത്, അതായത്, വ്യവസ്ഥ പാലിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന്.

ഇതിന്റെ വാക്യഘടന ഇതാണ്:

Si [condición a evaluar] Entonces
[instrucciones por verdadero] Sino
[instrucciones por falso] FinSi

"മറ്റേതെങ്കിലും" വകുപ്പ് നിർബന്ധമല്ല, ഈ സാഹചര്യത്തിൽ, വ്യവസ്ഥ തെറ്റാണെങ്കിൽ, നിർദ്ദേശങ്ങൾ അവഗണിച്ച് വാക്യം നിലവിലില്ലാത്തതുപോലെ തുടരുക, ഈ സാഹചര്യത്തിൽ അത് നിലനിൽക്കും:

Si [condición a evaluar] Entonces
[instrucciones por verdadero] FinSi

"പരാജയം" ക്ലോസ് സ്ഥാപിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്നത് ആ പ്രോഗ്രാമിന്റെ ആവശ്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു.

കണക്കാക്കുന്നു

ഒരു ഓപ്‌ഷനായി 2 ൽ കൂടുതൽ ഓപ്ഷനുകൾ നൽകുന്ന കർശനമായ സംഖ്യാ വേരിയബിളിനെ വിലയിരുത്തുന്ന വാക്യം, മുമ്പത്തേതിന് 2 ഓപ്ഷനുകൾ മാത്രമേ നൽകാൻ കഴിയൂ എന്നതിനാൽ ഇത് "ഇഫ്-പിന്നെ" എന്നതിൽ നിന്നുള്ള വ്യത്യാസമാണ്.

വാക്യഘടന ഇതാണ്:

Segun [variable numérica] Hacer
[número1]: [instrucciones] [número2],[número3]: [instrucciones] [...] De Otro Modo: [instrucciones] FinSegun

"നമ്പർ 1" ന് ശേഷം നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ ഒരു ":" ഉണ്ട്, അതിനുശേഷം "ന്യൂമറിക്കൽ വേരിയബിൾ = നമ്പർ 1" എന്ന കേസിൽ നടപ്പിലാക്കേണ്ട നിർദ്ദേശങ്ങൾ സ്ഥാപിക്കുന്നു, രണ്ടാമത്തെ ഉദാഹരണത്തിൽ ഇത് "നമ്പർ 2, നമ്പർ 3" എന്നാണ് ഇതിനർത്ഥം "ന്യൂമെറിക് വേരിയബിൾ = നമ്പർ 2 അല്ലെങ്കിൽ നമ്പർ 3" ആണെങ്കിൽ "നിർദ്ദേശങ്ങൾ" നടപ്പിലാക്കും, 2 സാധ്യതകൾ ഒരേ നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും.

സാധ്യതകളൊന്നും പൂർത്തീകരിക്കാത്ത സാഹചര്യത്തിൽ "മറ്റൊരു വഴിയിൽ" എന്ന നിബന്ധനയും നടപ്പിലാക്കുന്നു.

WHILE

ഇത് ഒരു ആവർത്തന ഫംഗ്ഷനാണ്, അത് ആദ്യം ഒരു അവസ്ഥയെ വിലയിരുത്തുന്നു, തുടർന്ന് അത് നിറവേറ്റുകയാണെങ്കിൽ അത് ഒരു നിര നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നു, തുടർന്ന് അത് അവസ്ഥയെ വീണ്ടും വിലയിരുത്തുന്നു, അത് ശരിയാണെങ്കിൽ അതേ നിർദ്ദേശങ്ങൾ വീണ്ടും നടപ്പിലാക്കുകയും അവസ്ഥ തെറ്റാകുന്നതുവരെ ഇതുപോലെ തുടരുകയും ചെയ്യുന്നു. .

തുടക്കം മുതൽ‌ ഈ അവസ്ഥ തെറ്റാണെങ്കിൽ‌ അത് ഒരിക്കലും നടപ്പിലാക്കില്ല, അത് എല്ലായ്‌പ്പോഴും ശരിയാണെങ്കിൽ‌ അത് അനന്തമായ ലൂപ്പിൽ‌ സ്ഥാപിക്കും, നിർ‌ദ്ദേശങ്ങളിൽ‌ അവസാനത്തേത് ഒഴിവാക്കുന്നതിന്, ചില ഘട്ടങ്ങളിൽ‌ അവസ്ഥയെ വ്യാജമാക്കുന്ന എന്തെങ്കിലും ഉണ്ടായിരിക്കണം ലൂപ്പ് അവസാനിപ്പിക്കാൻ കഴിയും.

അതിന്റെ വാക്യഘടന ഇതാണ്:

Mientras [condición a evaluar] Hacer
[instrucciones] FinMientras

ആവർത്തിക്കുക-UNTIL

ഇത് മുമ്പത്തേതിനോട് വളരെ സാമ്യമുള്ള ഒരു ഫംഗ്ഷനാണ്, എന്നാൽ മുമ്പത്തേതിൽ നിന്ന് വ്യത്യസ്തമായി, ഇത് അവസാനം അവസ്ഥ പരിശോധിക്കുന്നു, അതായത്, കമാൻഡ് കുറഞ്ഞത് 1 തവണയെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യാൻ പോകുന്നു, കൂടാതെ നിർദ്ദേശങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് പകരം ശരി, നിബന്ധന പാലിച്ചില്ലെങ്കിൽ ഇത് നടപ്പിലാക്കുന്നു, പക്ഷേ വ്യവസ്ഥ പാലിക്കുമ്പോൾ അത് നടപ്പിലാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, "വരെ" എന്നതിന് പകരം "അതേസമയം" ഉപയോഗിക്കുക.

അതിന്റെ വാക്യഘടന ഇതാണ്:

Repetir
[Instrucciones] hasta que [condicion]

വേണ്ടി

ഈ പ്രസ്‌താവന ഒരു വേരിയബിളിനായി എത്ര തവണ നിർണ്ണയിക്കണമെന്ന് നിർദ്ദേശിക്കുന്നു, മുമ്പത്തേതിൽ നിന്ന് വ്യത്യസ്തമായി, ഈ ചക്രം സംശയാസ്‌പദമായ വേരിയബിളിന്റെ മൂല്യം സ്വയം മാറ്റുന്നു, അതുപോലെ തന്നെ വളരെ ശക്തമായ ഒരു വാക്യഘടനയും ഉണ്ട്.

Para [variable] Desde [valor inicial] Hasta [valor Final] Con [paso] Hacer
[instruciones] FinPara

"വേരിയബിൾ" എന്നത് "പ്രാരംഭ മൂല്യം" സ്വീകരിക്കുന്ന നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുകയും തുടർന്ന് "വേരിയബിൾ" പ്ലസ് "സ്റ്റെപ്പ്" ചേർക്കുകയും "വേരിയബിൾ" "അന്തിമ മൂല്യത്തിന്" തുല്യമാകുന്നതുവരെ നിർദ്ദേശങ്ങൾ വീണ്ടും നടപ്പിലാക്കുകയും ചെയ്യുന്നു.

"വിത്ത് [സ്റ്റെപ്പ്]" നീക്കംചെയ്താൽ സ്ഥിരസ്ഥിതിയായി "സ്റ്റെപ്പ്" 1 ന് തുല്യമാണെന്നും [സ്റ്റെപ്പ്] വ്യക്തമാക്കിയിട്ടില്ലെന്നും "പ്രാരംഭ മൂല്യം" "അന്തിമ മൂല്യത്തേക്കാൾ" വലുതാണെന്നും അത് മനസ്സിലാക്കും വിപരീത ക്രമം, അതായത്, "ഘട്ടം" -1 ആണ്

SUBPROCESS / FUNCTION

ഒരു ത്രെഡ് അല്ലെങ്കിൽ ഫംഗ്ഷൻ മറ്റൊന്നിനുള്ളിലെ ഒരു പ്രോഗ്രാം ആണ്, ഈ സബ്പ്രോഗ്രാമിന് ഒന്നോ അതിലധികമോ മൂല്യങ്ങൾ ലഭിക്കുകയും അവ പ്രവർത്തിപ്പിക്കുകയും മറ്റൊന്ന് നൽകുകയും ചെയ്യുന്നു. അതിന്റെ വാക്യഘടനയാണ്

SubProceso [variable_de_retorno]<- [nombre de la funcion] ([arg_1],[arg_2],...,[arg_n])

acción 1;
acción 2;
.
.
.
acción n;
FinSubproceso

ഇത് നടപ്പിലാക്കുന്നതിനായി "arg_1, arg_2, arg_n" പാരാമീറ്ററുകൾ ലഭിച്ച "ഫംഗ്ഷൻ നെയിം" ഫംഗ്ഷൻ നൽകിയ മൂല്യം ഉൾക്കൊള്ളുന്ന വേരിയബിളാണ് "റിട്ടേൺ വേരിയബിൾ".

മറ്റുള്ളവ

ഇവ മറ്റുള്ളവയ്‌ക്ക് മാത്രം പൂരകമാകുന്നതും സങ്കീർണ്ണമായ വാക്യഘടനയില്ലാത്തതുമായ ഫംഗ്ഷനുകളാണ്, കാരണം അവ പൂരക പ്രവർത്തനങ്ങൾ മാത്രമാണ്.

സ്‌ക്രീൻ മായ്‌ക്കുക

ഈ ഫംഗ്ഷൻ ഇന്റർപ്രെറ്ററിലെ ഏതെങ്കിലും ഒബ്ജക്റ്റിന്റെ സ്ക്രീൻ മായ്‌ക്കുന്നു

കീ കാത്തിരിക്കുക

പ്രോഗ്രാം തുടരാൻ ഉപയോക്താവ് ഒരു കീ അമർത്തുന്നതിനായി ഈ പ്രവർത്തനം കാത്തിരിക്കുന്നു

കാത്തിരിക്കുക x {രണ്ടാമതായി, മില്ലിസെക്കൻഡ്}

പ്രോഗ്രാം തുടരാൻ ഈ ഫംഗ്ഷൻ നിമിഷങ്ങൾ അല്ലെങ്കിൽ മില്ലിസെക്കൻഡിൽ കാത്തിരിക്കുന്നു

PS: കാലതാമസത്തിന് ക്ഷമിക്കണം, പക്ഷേ മറ്റ് കാര്യങ്ങളിൽ ഞാൻ തിരക്കിലായിരുന്നു, അതിനാൽ എനിക്ക് എഴുതാൻ കഴിഞ്ഞില്ല


ലേഖനത്തിന്റെ ഉള്ളടക്കം ഞങ്ങളുടെ തത്ത്വങ്ങൾ പാലിക്കുന്നു എഡിറ്റോറിയൽ എത്തിക്സ്. ഒരു പിശക് റിപ്പോർട്ടുചെയ്യാൻ ക്ലിക്കുചെയ്യുക ഇവിടെ.

10 അഭിപ്രായങ്ങൾ, നിങ്ങളുടേത് വിടുക

നിങ്ങളുടെ അഭിപ്രായം ഇടുക

നിങ്ങളുടെ ഇമെയിൽ വിലാസം പ്രസിദ്ധീകരിച്ചു ചെയ്യില്ല.

*

*

  1. ഡാറ്റയുടെ ഉത്തരവാദിത്തം: മിഗുവൽ ഏഞ്ചൽ ഗാറ്റൻ
  2. ഡാറ്റയുടെ ഉദ്ദേശ്യം: സ്പാം നിയന്ത്രിക്കുക, അഭിപ്രായ മാനേജുമെന്റ്.
  3. നിയമസാധുത: നിങ്ങളുടെ സമ്മതം
  4. ഡാറ്റയുടെ ആശയവിനിമയം: നിയമപരമായ ബാധ്യതയല്ലാതെ ഡാറ്റ മൂന്നാം കക്ഷികളുമായി ആശയവിനിമയം നടത്തുകയില്ല.
  5. ഡാറ്റ സംഭരണം: ഒസെന്റസ് നെറ്റ്‌വർക്കുകൾ (ഇയു) ഹോസ്റ്റുചെയ്യുന്ന ഡാറ്റാബേസ്
  6. അവകാശങ്ങൾ: ഏത് സമയത്തും നിങ്ങളുടെ വിവരങ്ങൾ പരിമിതപ്പെടുത്താനും വീണ്ടെടുക്കാനും ഇല്ലാതാക്കാനും കഴിയും.

  1.   ഗില്ലെ പറഞ്ഞു

    എക്സിക്യൂഷൻ നിർത്താതെ കീകൾ പിടിച്ചെടുക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ ഇല്ലേ? 9 വയസുള്ള കുട്ടികളെ കൂടുതൽ ആകർഷിക്കുന്ന ചലനവുമായി എന്തെങ്കിലും ചെയ്യുന്നതിന്, ഒരു ഹാംഗ്മാൻ ഗെയിമും പ്രോഗ്രാമിന് രസകരമായിരിക്കും.

    എന്തെങ്കിലും_ഡിഗോ പ്രോസസ്സ് ചെയ്യുക
    a <-1;
    ലാറ്ററൽ <-30;
    താഴേക്ക് <-5;
    ഒരു = 1 ചെയ്യുമ്പോൾ
    സ്‌ക്രീൻ മായ്‌ക്കുക;
    c <-1;
    വരി <- "";
    ആവർത്തിക്കുക
    വരി <-ലൈൻ + "";
    c <-c + 1;
    C = ലാറ്ററൽ വരെ
    വരി <-ലൈൻ + "എക്സ്";
    c <-1;
    ആവർത്തിക്കുക
    "" എഴുതാൻ;
    c <-c + 1;
    C = down-1 വരെ
    വരി എഴുതുക;
    ആവർത്തിക്കുക
    "" എഴുതാൻ;
    c 2 പിന്നെ
    താഴേക്ക് <-ഡൗൺ -1;
    അതെ എന്ന് അവസാനിപ്പിക്കുക
    "s":
    <15 ന് താഴെയാണെങ്കിൽ
    താഴേക്ക് 2 പിന്നെ
    ലാറ്ററൽ <-പക്ഷീയ -1;
    അതെ എന്ന് അവസാനിപ്പിക്കുക
    "d":
    ലാറ്ററൽ <50 പിന്നെ
    ലാറ്ററൽ <-ലറ്ററൽ + 1;
    അതെ എന്ന് അവസാനിപ്പിക്കുക
    "0":
    a <-2;
    അവസാന സെക്കൻഡ്
    അവസാനിക്കുമ്പോൾ
    പ്രക്രിയ അവസാനിപ്പിക്കുക

  2.   ഗില്ലെ പറഞ്ഞു

    മുകളിലേക്ക് പോയാൽ നന്നായി പരാജയപ്പെടും, 23, 28 വരികൾ മാറ്റുക
    -23 സി = 15 വരെ
    +23 സി = 18 വരെ
    y
    -28 താഴെയാണെങ്കിൽ> 2 പിന്നെ
    +28 താഴെയാണെങ്കിൽ> 3 പിന്നെ

    1.    xnmm പറഞ്ഞു

      സംഭാവനയ്ക്ക് നന്ദി, പക്ഷേ ഇതിന് ചില പ്രശ്‌നങ്ങളുണ്ട്, നിങ്ങൾ ഒരു വാചകം മറ്റൊന്നിനുള്ളിൽ തുറക്കുന്നു, പക്ഷേ അത് ആരംഭിച്ച വാക്യത്തിനുള്ളിൽ അവസാനിക്കണം, അതായത് ഇത് ഇടാൻ കഴിയില്ല

      എന്തെങ്കിലും പ്രോസസ്സ് ചെയ്യുക
      a <- 0;
      വായിക്കുക;
      a 25 ന് തുല്യമല്ലെങ്കിൽ
      a 0 XNUMX ന് തുല്യമല്ല
      വായിക്കുക;
      അതെ എന്ന് അവസാനിപ്പിക്കുക
      അവസാനിക്കുമ്പോൾ

      "എങ്കിൽ" സ്റ്റേറ്റ്മെന്റിനുള്ളിൽ ആരംഭിച്ച് അതിന്റെ പുറത്ത് അവസാനിക്കുമ്പോൾ നിങ്ങൾ ലൂപ്പ് കാണുന്നതുപോലെ, ഇതുപോലുള്ള ഒന്ന് സാധ്യമല്ല.

      സംഭാവനയെ ഞാൻ ഇപ്പോഴും അഭിനന്ദിക്കുന്നു
      പ്രക്രിയ അവസാനിപ്പിക്കുക

      1.    ഗില്ലെ പറഞ്ഞു

        നന്ദി, പക്ഷേ കോഡ് ഇവിടെ ഇടുന്നതിൽ കൂടുതൽ പ്രശ്‌നമുണ്ടെന്ന് ഞാൻ കരുതുന്നു, കോഡ് തരത്തിൽ എങ്ങനെ ഇടാമെന്ന് എനിക്കറിയില്ല, ഇത് ഇൻഡന്റേഷൻ ഇല്ലാതെ പുറത്തുവരുന്നു.

        പ്രോഗ്രാം നന്നായി പ്രവർത്തിക്കുന്നു. "A" എന്ന വേരിയബിൾ ഉപയോക്താവ് പൂജ്യം ടൈപ്പുചെയ്യുമ്പോൾ ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ ഞാൻ ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് ഒരു എക്സിറ്റ് () അല്ലെങ്കിൽ ഇടവേള നൽകാം; സോപാധികമായി അത് നോക്കുകയും വേരിയബിൾ സംരക്ഷിക്കുകയും ചെയ്യുന്നു അവ ഓപ്ഷനുകളാണ്.

        നന്ദി.

      2.    ഗില്ലെ പറഞ്ഞു

        സ്‌പെയ്‌സുകൾക്കും ലേബലുകൾക്കുമായി ടാബുകൾ മാറ്റാൻ ഞാൻ ശ്രമിക്കും por si funciona algo:

        Proceso algo_digo
        a<-1;
        lateral<-30;
        abajo<-5;
        Mientras a=1 Hacer
        Borrar Pantalla;
        c<-1;
        linea<-"";
        Repetir
        linea<-linea+" ";
        c<-c+1;
        Hasta Que c=lateral
        linea<-linea+"X";
        c<-1;
        Repetir
        Escribir " ";
        c<-c+1;
        Hasta Que c=abajo-1
        Escribir linea;
        Repetir
        Escribir " ";
        c 3 Entonces
        abajo<-abajo-1;
        Fin Si
        "s":
        Si abajo < 15 Entonces
        abajo 2 Entonces
        lateral<-lateral-1;
        Fin Si
        "d":
        Si lateral < 50 Entonces
        lateral<-lateral+1;
        Fin Si
        "0":
        a<-2;
        Fin Segun
        Fin Mientras
        FinProceso

      3.    ഗില്ലെ പറഞ്ഞു

        അത് എന്റെ കോഡിൽ നിന്നുള്ള ഇറക്കുമതി പിശകുകൾ നിറഞ്ഞതാണ്, ഞാൻ ടാബുകൾ ഉപയോഗിച്ച് വീണ്ടും ശ്രമിക്കും:
        ഇതാണ് algo.psc ഫയൽ

        Proceso algo_digo
        a<-1;
        lateral<-30;
        abajo<-5;
        Mientras a=1 Hacer
        Borrar Pantalla;
        c<-1;
        linea<-"";
        Repetir
        linea<-linea+" ";
        c<-c+1;
        Hasta Que c=lateral
        linea<-linea+"X";
        c<-1;
        Repetir
        Escribir " ";
        c<-c+1;
        Hasta Que c=abajo-1
        Escribir linea;
        Repetir
        Escribir " ";
        c 3 Entonces
        abajo<-abajo-1;
        Fin Si
        "s":
        Si abajo < 15 Entonces
        abajo 2 Entonces
        lateral<-lateral-1;
        Fin Si
        "d":
        Si lateral < 50 Entonces
        lateral<-lateral+1;
        Fin Si
        "0":
        a<-2;
        Fin Segun
        Fin Mientras
        FinProceso

      4.    ഗില്ലെ പറഞ്ഞു

        രസകരമെന്നു പറയട്ടെ, കോഡ് ലേബലുകളുള്ള അഭിപ്രായം കഴിക്കുന്നു, ഇല്ലാതാക്കുന്നു, അതിനിടയിൽ പോകുന്നതെന്തും, ഉദാഹരണത്തിന് വരികൾക്കിടയിൽ
        ആവർത്തിക്കുക
        "" എഴുതാൻ;
        c
        c ന് ശേഷം a
        എന്നിട്ട് അത് 3 തുടരും
        താഴേക്ക്
        മൊത്തത്തിൽ, ഏത് കോഡുകൾക്കനുസരിച്ച് ഇത് വിശ്വസനീയമല്ല.

  3.   ഗില്ലെ പറഞ്ഞു

    എങ്ങനെയെന്ന് കാണാൻ = എന്നതിലേക്ക് ചിഹ്നങ്ങൾ മാറ്റുന്നു.

    Proceso algo_digo
    a=1;
    lateral=30;
    abajo=5;
    Mientras a=1 Hacer
    Borrar Pantalla;
    c=1;
    linea="";
    Repetir
    linea=linea+" ";
    c=c+1;
    Hasta Que c=lateral
    linea=linea+"X";
    c=1;
    Repetir
    Escribir " ";
    c=c+1;
    Hasta Que c=abajo-1
    Escribir linea;
    Repetir
    Escribir " ";
    c=c+1;
    Hasta Que c=18
    Escribir "Dibujo una X (w,a,s,d y 0 para salir)";
    Leer mueve;
    Segun mueve Hacer
    "w":
    Si abajo > 3 Entonces
    abajo=abajo-1;
    Fin Si
    "s":
    Si abajo 2 Entonces
    lateral=lateral-1;
    Fin Si
    "d":
    Si lateral < 50 Entonces
    lateral=lateral+1;
    Fin Si
    "0":
    a=2;
    Fin Segun
    Fin Mientras
    FinProceso

    1.    ഗില്ലെ പറഞ്ഞു

      ഇത് കോഡിന്റെ ഒരു ഭാഗം കഴിക്കുന്നത് തുടരുന്നു, കോഡ് ടാഗ് പരാജയപ്പെടുന്നു, അത് എഴുത്ത് പോലെ തന്നെ ഉപേക്ഷിക്കണം.

      1.    xnmm പറഞ്ഞു

        ഹായ് ക്ഷമിക്കണം, നിങ്ങൾ മുമ്പ് ഉത്തരം കണ്ടില്ലെങ്കിലും നന്നായി
        നിങ്ങൾ‌ക്ക് കോഡ് നന്നായി പ്രസിദ്ധീകരിക്കാൻ‌ കഴിയാത്തതിനാൽ‌ നിങ്ങൾ‌ അത് മെയിൽ‌ വഴി എനിക്ക് അയയ്‌ക്കാത്തതിനാൽ‌ നിങ്ങൾ‌ക്ക് ഇത്രയധികം തിരിവുകൾ‌ നൽ‌കുന്നില്ല.