
Korean: 
안녕하세요, 저는 Carrie Anne입니다. 
컴퓨터 과학 특강에 오신 것을 환영합니다!
지난 시간에는 원시적인 기계어로 
프로그램을 작성하는 방법과,
많은 낮은 수준의 세부 사항과 씨름하는 것이 복잡한 프로그램 작성에 장애가 되었다는것도 이야기 했었습니다.
이러한 낮은 수준의 세부 사항을 추상화하기 위해,
프로그래밍 언어는 프로그래머가 계산 문제 해결에 집중하고 하드웨어적인 핵심들은 줄이도록 개발되었습니다.
프로그래밍 언어는 프로그래머가 계산 문제 해결에 집중하고 하드웨어적인 핵심들은 줄이도록 개발되었습니다.
이번시간에도 이와 같은 논쟁을 계속할 것입니다.
그리고 거의 모든 프로그래밍 언어가 제공하는 몇가지 
기본적인 구성 요소들을 소개하려고 합니다.
소개
우리가 말하는 언어(구어)와 마찬가지로, 
프로그래밍 언어에도 문장이 존재합니다.
이 문장들은 개별적인 완전한 생각을 나타냅니다.
"나는 차를 마시고 싶다." 또는  "비가 내리고있다."
다른 단어를 사용하여 의미를 바꿀 수 있습니다.
예를 들어, "나는 차를 마시고 싶어요"를
"나는 유니콘을 원해요." 로 바꿀 수 있습니다.
그러나 "나는 차를 마시고 싶다."를 
"나는 비가 내리고 싶다." 로 바꿀 수는 없죠.
이것은 문법적으로 옳지 않습니다.
언어의 문장 구성 요소와 구조들을 다루는 규칙 세트를 
구문이라고 합니다.

Portuguese: 
Oi, eu sou Carrie Anne, e bem-vindo ao CrashCourse Ciência da Computação!
No último episódio, discutimos como escrever programas em código de máquina nativo, e ter de lidar
com tantos detalhes de baixo nível foi um enorme obstáculo para escrever programas complexos.
Para abstrair muitos desses detalhes de baixo nível, foram desenvolvidas Linguagens de programação que
permitem aos programadores se concentrar em resolver um problema
com computação, e menos em
detalhes intrincados de hardware.
Então, hoje, nós vamos continuar essa discussão,
e introduzir alguns blocos de construção fundamentais
que quase todas as linguagens de programação proporcionam.
INTRODUÇÃO
Assim como as línguas faladas, linguagens de programação têm declarações.
Estas são pensamentos completos individuais, como “Eu quero chá” ou “está chovendo”.
Usando palavras diferentes, podemos mudar o significado; por exemplo, “Eu quero chá” para
“Eu quero unicórnios”.
Mas não podemos mudar “Eu quero chá” para “Eu quero chovendo” - que não faz
sentido gramatical.
O conjunto de regras que governam a estrutura e composição de declarações em uma linguagem

Arabic: 
مرحبا, انا كاري أن, أهلا بكم في كراش كورس لعلوم الكمبيوتر
في اخر حلقة قمنا بشرح كيفية كتابة البرامج باستخدام اوامر لغة الآلة
و بسسب وجود تفاصيل كثيرة على مستوى لغة الآلة مما يشكل عائقا أمام كتابة برامج معقدة
و لإزالة الكثير من هذه التفاصيل , تطورت لغات البرمجة
لكي تسمح للمبرمجين بالتركيز على حل المشاكل الحسابية دون أن ينشغلوا
بتفاصيل مكونات الكمبيوتر
لذا اليوم سةف نستكمل ذلك النقاش وساقدم لكم بعض الاساسيات في بناء البرامج
التي تقدمها تقريبا جميع لغات البرمجة
"Translated by : Eng. Ahmed Isam."
مثل اللغات الصوتية لغات البرمجة لها جمل وأوامر
وهي افكار كاملة مستقلة مثل "أريد الشاي" أو "انها تمطر"
باستخدام كلمات مختلفة يمكننا تغيير المعنى مثل : من "أريد الشاي" إلى
"أريد وحيد قرن"
لكن لا يمكن ان نجعلها "أريد المطر" لان ذلك غير منطقي قواعدياّ
الشعور النحوية.
مجموعة القواعد التي تبني بها وتكتب بها الجملة البرمجية تدعى

Spanish: 
Hola, soy Carrie Ann, y bienvenidos a Crash Course Ciencias de la Computación!
En el último episodio vimos cómo escribir programas
en el idioma nativo de las máquinas,
con tantos detalles de bajo nivel, fue un gran impedimento para escribir programas complejos.
Para remover muchos de estos detalles de bajo nivel,
los lenguajes de programación que se desarrollaron
les permitieron a los programadores concentrarse en resolver problemas de computación, y menos en
detalles de hardware no tan importantes.
Hoy vamos a continuar esa discusión,
e introducir algunos bloques fundamentales
que casi todos los lenguajes de programación tienen.
INTRO
Justo como en los lenguajes hablados, los lenguajes de programación tienen enunciados.
Estos son ideas completas e individuales, como "Quiero té" o "Está lloviendo".
Al usar diferentes palabras, podemos cambiar el significado; por ejemplo, "Quiero" té a
"Quiero" unicornios.
Pero no podemos cambiar "Quiero té" a "Quiero está lloviendo" - eso no
tiene sentido gramáticamente.
Las reglas que gobiernan la estructura y composición de los enunciados en un lenguaje

English: 
Hi, I’m Carrie Anne, and welcome to CrashCourse
Computer Science!
Last episode we discussed how writing programs
in native machine code, and having to contend
with so many low level details, was a huge
impediment to writing complex programs.
To abstract away many of these low-level details,
Programming Languages were developed that
let programmers concentrate on solving a problem
with computation, and less on nitty gritty
hardware details.
So today, we’re going to continue that discussion,
and introduce some fundamental building blocks
that almost all programming languages provide.
INTRO
Just like spoken languages, programming languages
have statements.
These are individual complete thoughts, like
“I want tea” or “it is raining”.
By using different words, we can change the
meaning; for example, “I want tea” to
“I want unicorns”.
But we can’t change “I want tea” to
“I want raining” - that doesn’t make
grammatical sense.
The set of rules that govern the structure
and composition of statements in a language

Chinese: 
嗨，我是Carrie Anne，歡迎來到CrashCourse
計算機科學！
上一集我們討論了要在本機代碼中編寫程序，
並處理這麼多基礎細節，
對於編寫複雜的程序是一個很大的阻礙。
因為簡化了這些基礎細節， 程式語言的開發
讓程序員能夠專注於解決問題與計算，
而較不需和硬體細節纏鬥。
所以今天，我們將延續之前的討論，
並介紹一些幾乎所有的編程語言都提供的，
基本的構成要素。
介紹
就像一般的語言，
編程語言一樣有敘述句(statement)。
他們是個人完整的想法，
比如“我想要茶”或“正在下雨”。
通過使用不同的詞，我們可以改變含義。
例如把「我要茶」改成「我想要獨角獸」。
但我們不能把“我要茶”改成
“我想下雨”
那不合語法邏輯。
管理語言的結構和組成的一套規則

Portuguese: 
é chamado sintaxe.
O idioma Inglês tem uma sintaxe, assim como todas as linguagens de programação.
“A é igual a 5” é uma declaração em linguagem de programação.
Neste caso, a declaração diz que uma variável chamada A tem o número 5 armazenado nela.
Isso é chamado de "declaração de atribuição" porque estamos atribuindo um valor a uma variável.
Para expressar as coisas mais complexas, precisamos de uma série de declarações, como “A é 5, B é
igual a dez, C é igual a A mais B”
Este programa diz ao computador para definir a variável 'A' como 5, a variável 'B' como 10,
e, finalmente, somar 'A' e 'B' e colocar esse resultado, que é de 15, na...
- você adivinhou - variável C.
Note que podemos chamar as variáveis de qualquer coisa que nós quisermos
Em vez de A, B e C, poderia ser 'maçãs', 'peras' e 'frutas'.
O computador não se importa, contanto que as variáveis sejam nomeadas de forma exclusiva.
Mas é provavelmente a melhor prática nomeá-las com coisas que façam sentido no caso de alguém
mais tentar entender seu código.
Um programa, que é uma lista de instruções, é um pouco como uma receita: ferva água, adicione o macarrão,
espere 10 minutos, escorra e desfrute.
Da mesma forma, o programa começa na primeira declaração e desce uma de cada vez
até atingir o fim.
Até agora, nós somamos dois números.
Chato.

Korean: 
언어의 문장 구성 요소와 구조들을 다루는 규칙 세트를 
구문이라고 합니다.
영어에 구문이 있듯이, 
모든 프로그래밍 언어도 구문이 있습니다.
"A equals 5"는 프로그래밍 언어로 된 진술입니다.
이 문장의 경우, A로 정의된 변수는 
5라는 수를 저장되어 있다는 것을 말합니다.
우리는 변수에 값을 할당하기 때문에 
이것을 대입문이라고 합니다.
보다 복잡한 것을 표현하기 위해서는 
일련의 문장들이 필요합니다. 예를 들면,
A는 5이고, B는 10이고 C는 A+B 같이요.
이 프로그램은 컴퓨터에 변수를 설정하도록 지시합니다. 변수 A를 5, 변수 B를 10,
마지막으로 'A'와 'B'를 함께 추가하려면,
그 결과를 15로 놓습니다. 짐작하듯이 이건 변수 C죠.
마지막으로 'A'와 'B'를 함께 추가하려면,
그 결과를 15로 놓습니다. 짐작하듯이 이건 변수 C죠.
원하는 어떤 단어든 변수를 호출 할 수 있다는 점에 
주목해보세요.
A, B, C 대신 사과, 배, 과일이 될 수도 있어요.
컴퓨터는 변수 이름이 특이하게 설정되어도 
이름이 있는 한 상관하지 않습니다.
하지만 아마도 이해가 되도록 
이름 짓는 것이 가장 좋은 방법일 거에요.
만약 다른 사람이 여러분의 코드를 
이해하고자 할 때를 대비해서요.
명령어 목록인 프로그램은 약간 조리법과 비슷합니다.
물을 끓여 국수를 넣고,
10 분 정도 기다렸다가 물을 따라 내고 
먹으면 됩니다.
같은 방식으로, 프로그램은 첫 번째 문장에서 시작해 
한 번에 하나씩 끝에 도달할 때까지 실행됩니다.
같은 방식으로, 프로그램은 첫 번째 문장에서 시작해 
한 번에 하나씩 끝에 도달할 때까지 실행됩니다.
지금까지 두 개의 숫자를 더했습니다.
지루하죠.

Spanish: 
se llama sintáxis.
El idioma inglés tiene sintáxis, y también todos los lenguajes de programación.
"a = 5" es un enunciado de un lenguaje de programación.
En este caso, el enunciado dice que la variable "a" tiene el valor "5" almacenado allí.
Esto se conoce como un enunciado de asignación, porque le estamos dando un valor a una variable.
Para expresar cosas más complejas, necesitamos una serie de enunciados, como "a = 5, b = 10,
y c = a+b".
Este programa le dice a la computadora a asignar la variable "a" igual a 5 y "b" igual a 10,
y finalmente, sumar "a" + "b", y asignar el resultado, que es 15, en - tu
lo adivinaste - la variable "c".
Nota que podemos llamar las variables como sea que queramos.
En lugar de a, b, y c, puede ser manzanas, peras y frutas.
A la computadora  no le importa, siempre y cuando las variables sean únicas.
Probablemente es mejor nombrarlas de manera que tengan sentido, en caso de que
alguien más trate de entender tu código.
Un programa es como una lista de instrucciones, como: hierve agua, agrega fideos,
espera 10 minutos, drena el agua y disfruta.
De la misma manera, el programa empieza en el primer enunciado y ejecuta uno a la vez
hasta que ejecuta el último.
Hasta ahora solamente hemos sumados dos números.
Aburrido.

Arabic: 
بناء الجملة (تركيب الجملة-Syntax-)
اللغة الإنجليزية بناء جملة، وهكذا تفعل
جميع لغات البرمجة.
"A يساوي 5" هي لغة برمجة
بيان.
في هذه الحالة، البيان يقول متغير
اسمه ولديه رقم 5 المخزنة فيه.
وهذا ما يسمى عبارة تعيين ل
نحن تعيين القيمة إلى متغير.
للتعبير عن أشياء أكثر تعقيدا، ونحن بحاجة إلى
سلسلة من البيانات، مثل "A هو 5، B هو
عشرة، C يساوي زائد B "
يروي هذا البرنامج الكمبيوتر لتعيين متغير
'A' يساوي 5، المتغير 'B' إلى 10،
وأخيرا إلى إضافة 'A' و 'B' معا،
وضعت هذه النتيجة، وهو 15 عاما، إلى - أنت
تفكر في ذلك - متغير C.
لاحظ أنه يمكن أن نطلق المتغيرات مهما فعلنا
تريد.
بدلا من A، B و C، ويمكن أن يكون التفاح،
الكمثرى، والفواكه.
لا يهتم الكمبيوتر، طالما المتغيرات
تتم تسمية فريد.
ولكن من المحتمل أن يكون أفضل الممارسات لاسم
لهم الأشياء التي تجعل المعنى في حالة شخص
آخر هو محاولة لفهم التعليمات البرمجية.
برنامج، وهي قائمة من التعليمات،
ويشبه وصفة: غلي الماء، إضافة الشعرية،
انتظر 10 دقيقة، واستنزاف والتمتع بها.
في نفس الطريق، ويبدأ البرنامج في
يعمل البيان الأول وهبوطا في وقت واحد
حتى يضرب النهاية.
وحتى الآن، فقد أضفنا رقمين معا.
ملل.

English: 
is called syntax.
The English language has syntax, and so do
all programming languages.
“A equals 5” is a programming language
statement.
In this case, the statement says a variable
named A has the number 5 stored in it.
This is called an assignment statement because
we're assigning a value to a variable.
To express more complex things, we need a
series of statements, like “A is 5, B is
ten, C equals A plus B”
This program tells the computer to set variable
‘A’ equal to 5, variable ‘B’ to 10,
and finally to add ‘A’ and ‘B’ together,
and put that result, which is 15, into -- you
guessed it -- variable C.
Note that we can call variables whatever we
want.
Instead of A, B and C, it could be apples,
pears, and fruits.
The computer doesn’t care, as long as variables
are uniquely named.
But it’s probably best practice to name
them things that make sense in case someone
else is trying to understand your code.
A program, which is a list of instructions,
is a bit like a recipe: boil water, add noodles,
wait 10 minutes, drain and enjoy.
In the same way, the program starts at the
first statement and runs down one at a time
until it hits the end.
So far, we’ve added two numbers together.
Boring.

Chinese: 
被稱為語法。
和英語一樣，所有的編程語言也都有語法。
“a = 5”是一個編程語言敘述（statement）。
在這裡，這個敘述表示在名為Ａ的變量中
儲存了一個數字5。
這被稱為賦值語句，因為
我們正在為變量賦予一個值。
為了表達更複雜的東西，
我們需要一個一系列的陳述，
如“A是5，B是10，C等於A加B“
這個程序告訴計算機
設置變量'A'等於5，變量'B'為10，
最後把'A'和'B'加在一起，
並把這個結果，也就是15，放入
- 你猜對了 - 變量C.
請注意，我們可以隨我們想要設定變量。
不只是ABC，它可能是蘋果，梨或者水果。
電腦不管這些。只要這些變量有被單一命名。
但有邏輯的命名可能是最好的做法，
尤其當其他人試圖了解你的代碼。
一個程式，也就是這個指令列表，
有點像食譜：把水煮開，加麵條，
等10分鐘，瀝乾並享受。
以同樣的方式，程式從第一個陳述開始，
一次運行一個陳述
直到它結束。
目前為止，我們把兩個數字加在了一起。
無聊。

Chinese: 
我們來做電動遊戲吧！
當然，現在考慮編碼整個遊戲還為時過早，
所以相反的，我們會
用我們的例子寫一點小片段，
涵蓋一些編程基礎的代碼。
想像一下，我們正在建造一個古老的街機遊戲，
格雷斯霍珀必須在蟲蟲飛進在哈佛馬克1
並造成電腦死機前抓住它！
在每個級別，蟲蟲的數量都會增加。
格蕾絲必須在他們磨損機器中的
任何繼電器之前抓住他們。
幸運的是，她有一些額外的繼電器用來維修。
要開始，我們需要先知道一堆對遊戲來說重要的元素
像是玩家所在的級別，得分，剩餘的蟲蟲數量
以及Grace的備用繼電器數量庫存。
所以，我們必須“初始化”我們的變量，
也就是設定其初始值：
“級別”等於1，得分等於0，蟲蟲等於5，
備用繼電器等於4，玩家名稱等於“安德烈”。
要創建一個互動型遊戲，我們需要
控制程序的流程
而不只是從上到下運行。
為此，我們使用流程控制的描述。
流程控制的描述有幾種類型，
但是If描述是最常見的。
你可以把它們想像成
「如果X是真的，就做Y」。

English: 
Let’s make a video game instead!
Of course, it’s way too early to think about
coding an entire game, so instead, we’ll
use our example to write little snippets of
code that cover some programming fundamentals.
Imagine we’re building an old-school arcade
game where Grace Hopper has to capture bugs
before they get into the Harvard Mark 1 and
crash the computer!
On every level, the number of bugs increases.
Grace has to catch them before they wear out
any relays in the machine.
Fortunately, she has a few extra relays for
repairs.
To get started, we’ll need to keep track
of a bunch of values that are important for
gameplay, like what level the player is on,
the score, the number of bugs remaining, as
well as the number of spare relays in Grace’s
inventory.
So, we must “initialize” our variables,
that is, set their initial value: “level
equals 1, score equals 0, bugs equals 5, spare relays equals 4, and player name equals “Andre”.
To create an interactive game, we need to
control the flow of the program beyond just
running from top to bottom.
To do this, we use Control Flow Statements.
There are several types, but If Statements
are the most common.
You can think of them as “If X is true,
then do Y”.

Spanish: 
Creemos un videojuego!
Por supuesto, es muy temprano para pensar en programas un juego completo, entonces vamos
a usar nuestro ejemplo de pequeñas partes de código que podemos usar para cubrir los fundamentos de programación.
Imagina que estamos construyendo un juego de la vieja escuela, donde Grace Hopper tiene que capturar insectos
antes de que lleguen a la Harvard Mark 1 y estropeen la computadora!
En cada nivel, el número de insectos incrementa.
Grace tiene que atraparlos antes de que rompan los transistores de la máquina.
Afortunadamente, ella tiene unos cuantos transistores extra para reparar los daños.
Para empezar, necesitaremos llevar la cuenta de algunos valores que son importantes para
el juego, como el nivel en que se encuentra el jugador, el puntaje, el número de insectos, y
el número de transistores de repuesto que Grace tiene en su inventario.
Entonces, debemos "inicializar" nuestras variables. Es decir, establecer su valor inicial: "nivel
=1, puntaje = 0, insectos = 5, transistores de repuesto = 4, y nombre del jugador "Andre".
Para crear un juego interactivo, necesitamos controlar el flujo del programa más allá
que solo ejecutar desde el inicio hasta el final.
Para hacer esto, usamos Enunciados de Control de Flujo.
Hay varios tipos, pero los enunciados "si" son los más comunes.
Puedes imaginarlos como: "si X es cierto, entonces has Y".

Korean: 
대신 비디오 게임을 만들어 봅시다!
물론 전체 게임을 코딩하는 것에 대해 생각하긴 너무 이릅니다. 그래서 대신에,
예제를 사용하여 프로그래밍의 기본 사항을 다루는 
코드 토막들을 써보겠습니다.
Grace Hopper가 벌레를 잡아야 하는 구식 학교 아케이드 게임을 만든다고 상상해 봅시다.
그 벌레가 HAVARD MARK 1에 들어가서
 컴퓨터를 고장내기 전에 말이죠.
모든 레벨에서 버그 수가 증가합니다.
Grace는 벌레들이 기계의 릴레이 안에 들어가기 전에 
잡아야 합니다.
다행히도, 그녀는 여분의 고칠 수 있는 
릴레이를 가지고 있습니다.
시작 하기 위해, 게임을 실행시키기 위해 중요한 값들을 추적해 나가야 합니다.
플레이어의 레벨, 점수,
남아있는 벌레 숫자 뿐만 아니라
Grace 's 남은 릴레이 수와 같은 것들이요.
따라서 변수를 "초기화"해야합니다. 
바로 초기 값을 정하는 것을 말합니다.
Level은 1과 같고, 점수는 0, 버그는 5, 여분의 릴레이는 4, 플레이어 이름은 "Andre"와 같습니다.
대화형 게임을 만들려면, 단순히 위에서 아래로 실행하는 것 이상의 프로그램의 흐름을 제어할 수 있어야 합니다.
대화형 게임을 만들려면, 단순히 위에서 아래로 실행하는 것 이상의 프로그램의 흐름을 제어할 수 있어야 합니다.
이를 위해 Control Flow Statement(제어 흐름문)
를 사용합니다.
몇 가지 유형이 있지만 If 문이 가장 일반적입니다.
"X가 사실이라면, 다음 Y 를 하십시오." 라고
생각할 수 있습니다.

Portuguese: 
Vamos fazer um videogame em vez disso!
É claro que é muito cedo para pensar em codificar um jogo inteiro, então, no lugar disso, vamos
usar o nosso exemplo para escrever pequenos trechos de código que cobrem alguns fundamentos de programação.
Imagine que estamos construindo jogo clássico onde Grace Hopper tem que capturar insetos
antes que eles entrem no Harvard Mark 1 e travem o computador!
Em cada nível, o número de insetos aumenta.
Grace tem que pegá-los antes que eles desgastem quaisquer relés dentro da máquina.
Felizmente, ela tem alguns relés adicionais para reparos.
Para começar, vamos precisar manter o controle de um monte de valores que são importantes para
a jogabilidade, como em que nível o jogador está, a pontuação, o número de insetos restantes,
bem como o número de relés extras no estoque de Grace.
Então, devemos “inicializar” nossas variáveis, ou seja, definir o seu valor inicial: “nível
é igual a 1, pontuação é igual a 0, insetos é igual a 5, relés extras é igual a 4, e nome do jogador é igual a “Andre”.
Para criar um jogo interativo, precisamos controlar o fluxo do programa para além de apenas
executar de cima para baixo.
Para fazer isso, usamos "Declarações de Controle do Fluxo".
Existem vários tipos, mas declarações "IF" (SE) são as mais comuns.
Você pode pensar nelas como “Se X é verdadeiro, então faça Y”.

Arabic: 
دعونا نجعل لعبة فيديو بدلا من ذلك!
بطبيعة الحال، فإنه من السابق لأوانه التفكير
الترميز لعبة كاملة، لذلك بدلا من ذلك، سوف نقوم
استخدام مثالنا لكتابة قصاصات صغيرة من
التعليمات البرمجية التي تغطي بعض أساسيات البرمجة.
تخيل أننا بناء ممر المدرسة القديمة
لعبة حيث لديها جريس هوبر للقبض على البق
قبل أن ندخل في جامعة هارفارد مارك 1 و
تعطل جهاز الكمبيوتر!
على كل مستوى، وعدد من البق يزيد.
نعمة أن نقبض عليهم قبل أن تبلى
أي التبديلات في الجهاز.
لحسن الحظ، لديها عدد قليل من التبديلات اضافية ل
الإصلاحات.
للبدء، سوف تحتاج إلى تتبع
من مجموعة من القيم التي تعتبر مهمة ل
اللعب، مثل ما هو مستوى اللاعب في وضع التشغيل،
النتيجة، وعدد من البق الباقين، و
كذلك عدد من التبديلات الغيار في غريس
المخزون.
لذلك، يجب علينا أن "تهيئة" المتغيرات لدينا،
وهذا هو، تعيين قيمة الأولية: "مستوى
يساوي 1، والنتيجة تساوي 0، والبق يساوي 5، ناقلات الغيار يساوي 4، واسم لاعب يساوي "أندريه".
لخلق لعبة تفاعلية، نحن بحاجة إلى
السيطرة على تدفق البرنامج إلى أبعد من مجرد
يمتد من أعلى إلى أسفل.
للقيام بذلك، ونحن نستخدم البيانات التحكم في التدفق.
وهناك عدة أنواع، ولكن إذا البيانات
هي الأكثر شيوعا.
يمكنك نفكر بها "إذا X صحيح،
ثم القيام Y ".

Portuguese: 
Um exemplo idioma Inglês é: “Se eu estiver cansada, então, tomar chá”
Assim, se “estou cansado” for uma afirmação verdadeira, então eu irei tomar chá.
Se “estou cansado” for falso, então eu não irei tomar chá.
Uma instrução IF (SE) é como uma bifurcação na estrada.
Qual o caminho que você toma depende de se a expressão é verdadeira ou falsa - de modo que estes
estas expressões são chamadas Declarações Condicionais.
Na maioria das linguagens de programação, uma instrução if
é algo como .... “SE, expressão,
ENTÃO, algum código, então terminar a instrução SE”.
Por exemplo, se “nível” é 1, então nós
definir o marcador para zero, porque o jogador
está apenas começando.
Também definimos o número de insetos para 1, para deixar
mais fácil por enquanto.
Observe que as linhas de código que são condicionais
na instrução SE são aninhadas entre a
IF e END IF.
Claro, podemos mudar a expressão condicional para o que queremos testar, como “pontuação
é maior do que 10” ou "insetos é menos que 1".
E declarações IF(SE) podem ser combinadas com uma declaração ELSE (SENÃO), que atua como um pega-tudo se a
expressão for falsa.
Se o nível não for 1, o código dentro do bloco ELSE será executado em vez disso, e o
número de insetos que Grace tem de combater é definido como 3 vezes o número do nível.
Assim, no nível 2, seriam seis insetos, e no nível 3 haverá 9, e assim por diante.

English: 
An English language example is: “If I am
tired, then get tea”
So if “I am tired” is a true statement,
then I will go get tea
If “I am tired” is false, then I will
not go get tea.
An IF statement is like a fork in the road.
Which path you take is conditional on whether
the expression is true or false -- so these
expressions are called Conditional Statements.
In most programming languages, an if statement
looks something like …. “If, expression,
then, some code, then end the if statement”.
For example, if “level” is 1, then we
set the score to zero, because the player
is just starting.
We also set the number of bugs to 1, to keep
it easy for now.
Notice the lines of code that are conditional
on the if-statement are nested between the
IF and END IF.
Of course, we can change the conditional expression
to whatever we want to test, like “is score
greater than 10” 5 or “is bugs less than 1”.
And If-Statements can be combined with an ELSE statement, which acts as a catch-all if the
expression is false.
If the level is not 1, the code inside the
ELSE block will be executed instead, and the
number of bugs that Grace has to battle is
set to 3 times the level number.
So on level 2, it would be six bugs, and on
level 3 there’s 9, and so on.

Korean: 
영어 예제는 다음과 같습니다. 
"피곤하면, 차를 마시십시오. "
따라서 "나는 피곤하다"가 참인 경우,
그러면 나는 차를 가지러 가겠죠.
"피곤하다"가 거짓이면, 차를 마시지 않을 거에요.
IF 문은 도로의 갈래와 같습니다.
어떤 경로를 택할지는 조건이
참인지 거짓인지에 달려 있습니다.
이러한 표현을 조건문이라고합니다.
대부분의 프로그래밍 언어에서 if문은
다음과 같이 보입니다.
If 표현, Then뒤에 일부 코드,
End if
예를 들어, "level"이 1이면 점수를 0으로 설정하십시오. 왜냐하면 플레이어가 방금 시작했기 때문이죠.
예를 들어, "level"이 1이면 점수를 0으로 설정하십시오. 왜냐하면 플레이어가 방금 시작했기 때문이죠.
또한 벌레 수를 지금은 약간 쉽게 1로 정합시다.
IF문과 END IF 사이에서 조건을 나타내는 
코드의 줄들을 주목해보세요.
IF문과 END IF 사이에서 조건을 나타내는 
코드의 줄들을 주목해보세요.
물론, 조건식을 우리가 테스트 하고 싶은대로 
변경할 수 있습니다. 예를 들자면
"합계가 10보다 크거나 벌레 수가 1보다 적으면"
If문은 ELSE문과 결합 할 수 있습니다. ELSE문은 표현식이 거짓이면 다른 작업을 하도록 합니다.
If문은 ELSE문과 결합 할 수 있습니다. ELSE문은 표현식이 거짓이면 다른 작업을 하도록 합니다.
레벨이 1이 아니면, 대신 ELSE 블록이 실행되고
Grace가 잡아야 하는 벌레 수를
레벨 숫자의 3 배로 설정하도록 합니다.
레벨 2에서는 6마리의 벌레가 있을 것이고,
레벨 3에는 9마리가 있을 거에요.

Arabic: 
مثال اللغة الإنجليزية هو: "إذا أنا
متعب، ثم الحصول على الشاي "
إذا كان الأمر كذلك: "أنا متعب" هو بيان صحيح،
بعد ذلك سوف يذهب للحصول على الشاي
إذا كان "أنا متعب" غير صحيح، ثم سأفعل
لا يذهب للحصول على الشاي.
بيان IF هو مثل شوكة في الطريق.
الطريق الذي كنت تأخذ غير مشروط سواء
التعبير هو صواب أو خطأ - حتى هذه
ويطلق تعبير القوائم المشروطة.
في معظم لغات البرمجة، تعليمة if
يبدو شيء من هذا القبيل .... واضاف "اذا والتعبير،
ثم، بعض التعليمات البرمجية، ثم تنتهي بيان إذا ".
على سبيل المثال، إذا "مستوى" 1، ثم نحن
تعيين النتيجة إلى الصفر، لأن لاعب
هو مجرد بداية.
ونحن أيضا تعيين عدد من الحشرات إلى 1، للحفاظ على
من السهل في الوقت الراهن.
لاحظ الأسطر من التعليمات البرمجية التي هي مشروطة
على-بيان إذا المتداخلة بين
IF وEND IF.
وبطبيعة الحال، لا يمكننا تغيير التعبير الشرطي
إلى كل ما نريد لاختبار، مثل "هو النتيجة
أكبر من 10 "5 أو" هو الخلل أقل من 1 ".
وإذا، البيانات يمكن الجمع بين بيان ELSE، الذي يعمل بمثابة التقاط كل حالة
التعبير غير صحيح.
إذا كان مستوى ليس 1، رمز داخل
وسيتم تنفيذ كتلة ELSE بدلا من ذلك، و
عدد من الأخطاء التي يجب أن المعركة هي نعمة
تعيين 3 مرات رقم المستوى.
هكذا مستوى 2، سيكون من ستة البق، وعلى
مستوى 3 هناك 9، وهلم جرا.

Chinese: 
一個英語的例子是：
「如果我是累了，就喝茶」
所以如果這個敘述「我累了」為真（ture），
那我就會去喝茶
而如果「我累了」是錯的（false），
那麼我就不會去喝茶。
IF敘述就像是一條叉路。
你採用哪條路徑取決於
那些敘述為真（true）或為假 (false)
所以這些表達式被稱為條件命題（Conditional Statements）。
在大多數編程語言中，if語句
看起來像：
「如果(if)」條件，「那麼(then)」一些代碼，
然後「結束如果描述（End if）」。
例如，如果“級別”是1，
那麼我們將分數設置為零，
因為玩家剛剛開始。
我們也將蟲蟲的數量設置為1，
讓他維持在很容易的狀態。
注意嵌在在IF和END IF句之間的那一行條件代碼。
 
當然，我們也可以改變條件描述
來表達任何我們想要測試的東西，
比如「如果得分大於10」或「如果蟲蟲小於1」等等。
而If描述可以與ELSE描述結合使用，
如果是ELSE描述，它可以接住所有其他狀況當-
-if的表達不為真的。
如果級別不是1，則代碼裡面的代碼
ELSE塊將被執行，而
Grace需要對抗的蟲蟲數量被設置為
等級編號的3倍。
所以在第2級，將會有6隻蟲蟲，
而在第3級有9隻，依此類推。

Spanish: 
En español un ejemplo sería, "si estoy cansado, entonces tomaré té"
Entonces si "estoy cansado" es un enunciado verdadero, entonces tomaré té.
Si "estoy cansado" es falso, entonces no tomaré té.
Un enunciado "si" es como una división en el camino.
El camino que tomes es condicionado dependiendo si el enunciado es verdadero o falso - así que
estas expresiones se conocen como Enunciados Condicionados.
En la mayoría de lenguajes de programación, los enunciados "si" se ven como ... "si, expresión,
entonces, algún código, entonces termina el enunciado".
Por ejemplo, si "nivel" es 1, entonces establecemos el "puntaje" a 0, porque el jugador
está empezando.
Entonces también establecemos "insectos" = 1, para mantenerlo fácil por ahora.
Nota que las líneas de código son condicionadas si se encuentran entre
el "si" y "termina si".
Por supuesto, podemos cambiar la expresión condicional para lo que sea que queramos probar, como "si el puntaje
es mayor que 10" o "si los insectos son menores que 1".
También podemos combinar los enunciados "si" con enunciados "si no", que actúan en todo caso
que la expresión sea falsa.
Si el nivel no es 1, el código dentro de "si no" será ejecutado, y el
número de insectos que Grace tendrá que batallar será establecido como 3 x el número del nivel.
Entonces, en nivel 2, tendrá que pelear contra 6 insectos. En nivel 3, contra 9. Y así sucesivamente.

Spanish: 
El puntaje no es modificado por ningún bloque "si no", para que Grace pueda mantener los puntos que ha ganado.
Aquí hay algunos ejemplos de los enunciados  "si" y "si no" en algunos de los lenguajes de programación más populares -
puedes ver que la sintáxis cambia un poco, pero la estructura es casi la misma.
Los enunciados "si" son ejecutados una sola vez, un camino condicionado es escogido, y el programa sigue su recorrido.
Para repetir algunos enunciados muchas veces, necesitamos crear un circuito condicionado.
Una manera de hacerlo es con un enunciado "mientras", también llamado "circuito mientras".
Como puedes imaginar, esta pieza de código funciona mientras una condición sea cierta.
Sin importar el lenguaje de programación, se ven algo asi:
En nuestro juego, vamos a asumir que en ciertos momentos un colega amigable va a darle a Grace nuevos transistores!
Viva!
Para motivarlo a que renueve nuestro inventario, hasta un máximo de 4, podemos usar un "circuito mientras"
Vamos a repasar el código.
Primero vamos a asumir que Grace tiene solamente un tubo restante cuando su colega entra.
Cuando entramos en el "circuito mientras", la primer tarea que la computadora revisa es probar la condición...
los transistores son menos que 4?
Bueno, actualmente es 1, entonces sí.
Entramos al circuito!
Entonces empezamos con el código: "transistores = transistores + 1".

Chinese: 
得分在ELSE塊中未被修改，
所以格雷斯會延續相同的得分。
以下是一些流行的編程語言裡
if-then-else描述的一些例子
可以看到語法稍有不同，但是
底層結構大致相同。
如果描述會執行一次，
然後條件語句路徑被選中，程序繼續。
如果要多次重複一些敘述（statements）
我們需要創建一個條件循環。
一種方法是while描述，也稱為
一個while循環。
正如你可能已經猜到的那樣，
這會在"當(while)“條件成立時，在一段代碼中循環
無論編程語言如何，他們
看起來像這樣：
在我們的遊戲中，讓我們假設在某些狀態下，
會有一位好人同事幫Grace把備用繼電器重新補上！
萬歲！
要讓他替我們補充備品到最多四個，
我們可以使用一個while循環。
我們來看看這段代碼。
首先我們假定當她的同事進入時，
格雷斯只剩一個備用繼電器。
當我們進入這個while循環，
計算機做的第一件事是確認它的條件：
剩餘的繼電器小於4嗎？
Well，繼電器目前是1，所以是的。
現在我們進入循環！
接著，我們看這行代碼：
“繼電器等於繼電器加1“。

Portuguese: 
Pontuação não é modificado no bloco SENÃO, assim Grace fica com quaisquer pontos já ganhos.
Aqui estão alguns exemplos de declarações IF-THEN/ELSE de algumas linguagens de programação populares
- você pode ver que a sintaxe varia um pouco, mas a estrutura subjacente é mais ou menos a mesma.
Instruções SE são executadas uma vez, o caminho condicional é escolhido, e o programa segue em frente.
Para repetir algumas declarações muitas vezes, precisamos
criar um "loop" (ciclo) condicional.
Uma maneira é uma declaração WHILE (ENQUANTO), também chamada "while loop"
Como você deve ter adivinhado, isto repete um trecho de código “enquanto” uma condição for verdadeira.
Independentemente da linguagem de programação, eles se parecem com algo como isto:
No nosso jogo, digamos que em certos pontos, um colega simpático reabastece Grace com relés!
Hurra!
Para animá-lo a reabastecer nosso estoque de volta a um máximo de 4, podemos usar um "while loop".
Vamos caminhar por este código.
Primeiro vamos supor que Grace tem apenas 1 relé quando seu colega entra.
Quando entramos no "while loop", a primeira coisa que o computador faz é testar a sua condicional...
relés é menos de 4?
Bem, relés é atualmente 1, então sim.
Agora vamos entrar no ciclo!
Então, nós atingimos a linha de código: “relés igual a relés mais 1” .

Arabic: 
لا يتم تعديل النتيجة في كتلة ELSE،
حتى يحصل على نعمة للحفاظ على أي النقاط التي أحرزتها.
وإليك بعض الأمثلة من البيانات إذا، ثم، شيء آخر
من بعض لغات البرمجة شعبية - أنت
يمكن أن يرى بناء الجملة يختلف قليلا، ولكن
هيكل الأساسي هو تقريبا نفس.
إذا، البيانات يتم تنفيذ مرة واحدة، مشروطة
يتم اختيار المسار، والبرنامج ينتقل.
لتكرار بعض العبارات مرات عديدة، ونحن بحاجة
لخلق حلقة المشروطة.
طريق واحد هو بيان الوقت، وتسمى أيضا
حلقة while.
كما كنت قد خمنت، وهذا حلقات قطعة
من التعليمات البرمجية "بينما" هو شرط صحيح.
بغض النظر عن لغة البرمجة، فإنها
ننظر بشيء من هذا القبيل:
في لعبتنا، دعنا نقول في بعض النقاط،
زميل ودية restocks غريس مع التبديلات!
الصيحة!
لتحريك له تجديد مخزوننا الظهر
تصل إلى حد أقصى قدره 4، يمكننا استخدام حلقة while.
دعونا المشي من خلال هذا الرمز.
أولا نحن سوف نفترض أن النعمة لديه 1 فقط
غادر أنبوب عندما يدخل زميلها.
عندما ندخل في حلقة في حين، فإن أول شيء
الكمبيوتر لا هو اختبار لها مشروطة ... و
التبديلات أقل من 4؟
حسنا، التبديلات حاليا 1، لذلك نعم.
الآن نحن ندخل في حلقة!
ثم، فإننا ضرب سطر من التعليمات البرمجية: "التبديلات متساوين
التبديلات زائد 1 ".

Korean: 
점수는 ELSE 블록에서 조정되지 않으며,
그래서 Grace는 얻은 점수를 유지합니다.
몇가지 유명한 프로그래밍 언어의 if-then-else 문의 
몇 가지 예는 다음과 같습니다.
구문이 조금씩 다르긴 하지만 
근본적인 구조는 거의  같습니다.
If문이 한 번 실행되면, 조건부 경로가 선택되고
프로그램이 계속 진행됩니다.
여러 번 문장을 반복하려기 위해서는
조건부 루프를 만들어야 합니다.
한 가지 방법은 while 문이라고도하며
while 루프라고 부르기도 합니다.
짐작 했겠지만, 이 루프는 조건이 참일 동안
 while 코드를 반복합니다.
프로그래밍 언어에 관계없이 그들은
다음과 같이 보여집니다.
게임 안의 어떤 시점에서, 친절한 한 동료가 Grace 에게 
릴레이를 보낸다고 가정해봅시다.
만세!
재고를 최대 4개까지 보충해주는 동작을 만들려면, 
while 루프를 사용할 수 있습니다.
이 코드를 살펴 봅시다.
먼저 Grace에게는 그녀의 친구가 들어올 때 1개의 릴레이가 남아 있다고 가정합시다.
while 루프를 시작할 때, 제일 먼저
컴퓨터는 조건부를 테스트 합니다.
릴레이는 4보다 작습니까?
음, 릴레이는 현재 1입니다. 그렇습니다.
이제 루프를 시작합니다!
다음 코드 줄을 보면 
"릴레이 = 릴레이+1" 라고 되어 있습니다.

English: 
Score isn’t modified in the ELSE block,
so Grace gets to keep any points earned.
Here are some examples of if-then-else statements
from some popular programming languages -- you
can see the syntax varies a little, but the
underlying structure is roughly the same.
If-statements are executed once, a conditional
path is chosen, and the program moves on.
To repeat some statements many times, we need
to create a conditional loop.
One way is a while statement, also called
a while loop.
As you might have guessed, this loops a piece
of code “while” a condition is true.
Regardless of the programming language, they
look something like this:
In our game, let’s say at certain points,
a friendly colleague restocks Grace with relays!
Hooray!
To animate him replenishing our stock back
up to a maximum of 4, we can use a while loop.
Let’s walk through this code.
First we’ll assume that Grace only has 1
tube left when her colleague enters.
When we enter the while loop, the first thing
the computer does is test its conditional…is
relays less than 4?
Well, relays is currently 1, so yes.
Now we enter the loop!
Then, we hit the line of code: “relays equals
relays plus 1”.

Spanish: 
Esto es un poco confuso porque la variable se está usando a si misma en un enunciado de asignación,
así que vamos a entenderlo mejor.
Siempre se empieza comprendiendo el lado derecho de la ecuación, entonces
qué significa "transistor + 1" ?
Bueno, el valor actual de los transistores es 1, entonces 1+1 = 2.
Entonces, este resultado es guardado y sobrescribe el valor anterior,
ahora el valor de "transistores" es 2.
Hemos llegado al final del "circuito mientras", lo que hace que el programa inicie de nuevo.
Justo como antes, probamos la condición para ver si entramos nuevamente al circuito.
Los transistores son menores que 4?
Sí, los transistores ahora son 2, entonces entramos al circuito otra vez!
2+1 = 3.
Entonces 3 es guardado en "transistores".
Circuito de nuevo.
3 es menor que 4?
Sí lo es!
Entramos al circuito de nuevo.
3+1 = 4.
Entonces guardamos 4 en "transistores".
Circuito de nuevo.
4 es menor que 4? ...
No!
Entonces ahora que la condición es falsa, salimos del circuito y seguimos con
el código restante.
Así es como funciona un "circuito mientras"!
También es común los "circuitos para".
En lugar de ser un circuito condicionado que se repite infinitamente hasta que la condición
sea falsa, un "circuito para" se repite un número de veces establecido.
Se ven algo así:

Arabic: 
هذا هو مربكا بعض الشيء لأن المتغير
تستخدم نفسها في عبارة تعيين،
لذلك دعونا فك عليه.
كنت دائما تبدأ من خلال معرفة الحق
جانب من توقيع متساوين أولا، لذلك ما تفعله
"التبديلات زائد 1" الخروج أن تكون؟
حسنا، التبديلات حاليا القيمة 1، لذلك
1 زائد 1 يساوي 2.
ثم، ويحصل على حفظ هذه النتيجة مرة أخرى في
التبديلات متغيرة، الكتابة فوق القيمة القديمة،
حتى التبديلات الآن يخزن قيمة 2.
لقد ضرب نهاية حلقة في حين، والتي
يقفز برنامج النسخ الاحتياطي.
فقط كما كان من قبل، ونحن اختبار الشرطي ل
نرى ما اذا كنا في طريقنا للدخول في الحلقة.
هي التبديلات أقل من 4؟
حسنا، نعم، ناقلات يساوي الآن 2، لذلك نحن ندخل
الحلقة مرة أخرى!
2 زائد 1 يساوي 3.
حتى يتم حفظ 3 في التتابع.
حلقة مرة أخرى.
هو 3 أقل من 4؟
نعم إنه كذلك!
في حلقة مرة أخرى.
3 زائد 1 يساوي 4.
لذلك نحن إنقاذ 4 في التتابع.
حلقة مرة أخرى.
هو 4 أقل من 4؟ ....
لا!
وبالتالي فإن الشرط هو الآن خاطئة، وبالتالي نحن
الخروج من حلقة والانتقال إلى أي المتبقية
الشفرة.
هذه هي الطريقة التي تعمل حلقة في حين!
هناك أيضا شيوعا لحلقة.
بدلا من أن تكون حلقة التي تسيطر عليها حالة
التي يمكن تكرار إلى الأبد حتى حالة
هو زائف، وFOR حلقة يتم التحكم العد.
يكرر عدد محدد من المرات.
انها تبدو شيئا من هذا القبيل:

Portuguese: 
Isto é um pouco confuso, porque a variável está usando a si mesma em uma declaração de atribuição.
então vamos descompactar isso.
Você sempre começar por descobrir o que o lado direito do sinal de igual faz, então
o que vem a ser “relés mais 1”?
Bem, relés tem atualmente o valor de 1, então 1 mais 1 é igual a 2.
Então, este resultado é salvo de volta para a variável relés, escrevendo por cima do valor antigo,
então agora relés passa a armazenar o valor de 2.
Nós atingimos o fim do "while loop", que faz o programa saltar de volta para cima.
Tal como antes, testamos a condicional para ver se nós vamos entrar no ciclo.
relés é inferior a 4?
Bem, sim, relés agora é igual a 2, assim entramos no loop novamente!
2 mais 1 é igual a 3.
Então 3 é salvo em relés.
Novo ciclo.
3 é inferior a 4?
Sim, é!
Entrando no ciclo novamente.
3 mais um é igual a quatro.
Então, nós salvamos 4 em relés.
Novo ciclo.
4 é menos que 4? ....
Não!
Assim, a condição agora é falsa, portanto saímos do ciclo e passamos para qualquer
código restante.
É assim que um "while loop" funciona!
Também é muito comum o "For Loop".
Em vez de ser um circuito controlado por condição, que pode repetir para sempre até que a condição
seja falsa, um ciclo FOR é controlado por contagem; ele repete um número específico de vezes.
Eles se parecem algo assim:

English: 
This is a bit confusing because the variable
is using itself in an assignment statement,
so let's unpack it.
You always start by figuring out the right
side of the equals sign first, so what does
“relays plus 1” come out to be?
Well, relays is currently the value 1, so
1 plus 1 equals 2.
Then, this result gets saved back into the
variable relays, writing over the old value,
so now relays stores the value 2.
We’ve hit the end of the while loop, which
jumps the program back up.
Just as before, we test the conditional to
see if we’re going to enter the loop.
Is relays less than 4?
Well, yes, relays now equals 2, so we enter
the loop again!
2 plus 1 equals 3.
So 3 is saved into relays.
Loop again.
Is 3 less than 4?
Yes it is!
Into the loop again.
3 plus 1 equals 4.
So we save 4 into relays.
Loop again.
Is 4 less than 4?....
No!
So the condition is now false, and thus we
exit the loop and move on to any remaining
code.
That’s how a while loop works!
There’s also the common For Loop.
Instead of being a condition-controlled loop
that can repeat forever until the condition
is false, a FOR loop is count-controlled;
it repeats a specific number of times.
They look something like this:

Chinese: 
這有點令人困惑，因為變量
在賦值語句中使用自己，
所以讓我們解釋它。
我們總是從搞清楚等號的右邊開始，
那麼“繼電器加1”會是什麼？
well，繼電器目前價值是1，所以
1加1等於2。
然後這個結果會被存回
繼電器的變量，覆蓋舊值，
所以現在”繼電器“這個變量存儲了數值2。
我們已經達到了while循環的結束，
於是我們跳回程序的前面。
就像以前一樣，我們測試條件為
看看我們是否要進入循環。
繼電器是否小於4？
well，是的，繼電器現在等於2，
所以我們進入再次循環！
2加1等於3。
所以3被保存到繼電器中。
再次循環。
3小於4？
是的！
再次進入循環。
3加1等於4。
所以我們儲存了4個繼電器。
再次循環。
4小於4？....
不！
所以現在的情況是錯誤的(false)，因此我們
退出循環並繼續執行剩下的代碼。
 
這就是一個while循環的工作原理！
還有常見的For Loop。
不像條件控制的循環
那樣在遇到條件不成立之前會無限重複
FOR循環是計數控制的；
它會重複特定的次數。
他們看起來像這樣：

Korean: 
할당문에서 변수가 자기 자신을 사용하고 있어서 
약간 혼란스럽습니다.
그래서 그것을 분석해봅시다.
우리는 항상 등호의 오른쪽부터 
있는 것을 알아내는 것으로 시작합니다.
그러면 "릴레이 플러스 1"은 무엇이 나옵니까?
자, 릴레이는 현재 값이 1이니까 1 더하기 1은 
2와 같습니다.
그런 다음 이 결과가 변수 릴레이로 저장되어 
이전 값을 덮어씁니다.
이제 릴레이는 값 2를 저장합니다.
while 루프가 끝났습니다. 
프로그램을 다시 시작합니다.
이전과 마찬가지로 조건부를 테스트 하여 
루프를 시작할 수 있는 지 확인합니다.
릴레이가 4보다 작습니까?
네, 릴레이는 2입니다. 다시 루프 시작!
2 + 1은 3과 같습니다.
그래서 3이 릴레이에 저장됩니다.
다시 반복하십시오.
3이 4보다 작습니까?
예, 그렇습니다!
루프 안으로 다시.
3 더하기 1은 4와 같습니다.
그래서 우리는 릴레이에 4를 저장합니다.
다시 반복하십시오.
4는 4 보다 작습니까?
아니죠!
그래서 조건은 이제 거짓이며, 따라서 루프를 빠져 나와 남아 있는 코드로 이동합니다.
그래서 조건은 이제 거짓이며, 따라서 루프를 빠져 나와 남아 있는 코드로 이동합니다.
이게 while 루프가 작동하는 방식입니다.
일반적인 것들 중 하나로  For 루프도 있습니다.
조건이 거짓이 될때 까지 영원히 반복되는
 조건 제어 루프 대신
FOR 루프는 횟수를 조정할 수 있어
 특정 횟수 만큼 반복 합니다.
그들은 다음과 같이 보입니다.

Korean: 
자, 실제 가치를 입력해 봅시다.
이 예제는 변수 'I'가 값 1에서 시작하여 10까지 가도록 명시되어 있기 때문에 루프가 10 번 반복됩니다.
이 예제는 변수 'i'가 값 1에서 시작하여 10까지 가도록 명시되어 있기 때문에 루프가 10 번 반복됩니다.
FOR 루프의 독특한 점은 NEXT를 누를 때마다 
'i'에 1을 더합니다.
'i'가 10 일 때, 컴퓨터는 그것은 10번 반복되었다는 것을 알고 루프를 종료시킵니다.
'i'가 10 일 때, 컴퓨터는 그것은 10번 반복되었다는 것을 알고 루프를 종료시킵니다.
여러분이 번호를 원하는대로 설정할 수 있습니다.
10, 42 또는 10 억이든 우리에게 달렸죠.
플레이어에게 남은 진공 릴레이 수에 대해 
각 레벨의 끝에 보너스를 주고 싶다고 합시다.
플레이어에게 남은 진공 릴레이 수에 대해 
각 레벨의 끝에 보너스를 주고 싶다고 합시다.
게임이 어려워 질수록 사용하지 않은 릴레이를 얻는 데에 더 많은 기술이 필요합니다.
그래서 우리는 레벨에 따라 기하급수적으로 
올라가는 보너스를 원합니다.
우리는 지수를 계산하는 코드를 작성해야 합니다. 그것은 특정한 횟수만큼 자기 자신을 곱하는 코드 입니다.
우리는 지수를 계산하는 코드를 작성해야 합니다. 그것은 특정한 횟수만큼 자기 자신을 곱하는 코드 입니다.
루프가 이것에 딱이죠!
먼저 "보너스" 라는 새로운 변수를 초기화하고 
1로 설정 합니다.
그런 다음 1에서 시작하는 FOR 루프를 만들고,
레벨 숫자까지 반복합니다.
그 루프 안에서, 보너스에 릴레이의 숫자를 곱하고 새로운 값을 다시 보너스로 저장합니다.
그 루프 안에서, 보너스에 릴레이의 숫자를 곱하고 새로운 값을 다시 보너스로 저장합니다.
예를 들어, 릴레이가 2개이고, 레벨은 3입니다.

Chinese: 
現在，我們來看一些真實的價值。
這個例子會循環10次，因為我們已經
指定變量'i'
從1開始，而最多到10。
關於FOR循環的獨特之處在於
當每次碰到下一個(NEXT)時，它會向 " i " 添加1。
當 " i " 等於10時，計算機會知道
它已被循環10次，
並退出循環。
我們可以將數字設置為任何我們想要的
 -  10 , 42或10億 - 這取決於我們。
假設我們想給玩家特別獎勵
依據他們在每個級別結束時
留下的繼電器數量
隨著遊戲越來越難，它需要更多的技巧
有未使用的繼電器，所以我們想要獎金
根據等級以指數級上升。
我們需要編寫一段計算指數的代碼 - 即乘以一個數字
本身特定的次數。
循環可以完全符合這個需求！
首先讓我們初始化一個叫做的新變量
“獎勵”並將其設置為1。
然後，我們創建一個從1開始的FOR循環，
並循環直到次數等於級別號碼。
在該循環中，我們將獎勵乘以
繼電器的數量，並保存該新值
回到獎金。
舉個例子，假設繼電器等於2，
和等級等於3。

English: 
Now, let’s put in some real values.
This example loops 10 times, because we’ve
specified that variable ‘i’ starts at
the value 1 and goes up to 10.
The unique thing about a FOR loop is that
each time it hits NEXT, it adds one to ‘i’.
When ‘i’ equals 10, the computer knows
it’s been looped 10 times, and the loop
exits.
We can set the number to whatever we want
-- 10, 42, or a billion -- it’s up to us.
Let’s say we want to give the player a bonus
at the end of each level for the number of
vacuum relays they have left over.
As the game gets harder, it takes more skill
to have unused relays, so we want the bonus
to go up exponentially based on the level.
We need to write a piece of code that calculates exponents - that is, multiplying a number
by itself a specific number of times.
A loop is perfect for this!
First lets initialize a new variable called
“bonus” and set it to 1.
Then, we create a FOR loop starting at 1,
and looping up to the level number.
Inside that loop, we multiply bonus times
the number of relays, and save that new value
back into bonus.
For example, let’s say relays equals 2,
and level equals 3.

Portuguese: 
Agora, vamos colocar alguns valores reais.
Este exemplo repete 10 vezes, porque especificamos que a variável 'i' começa com
o valor de 1 e vai até 10.
A peculiaridade de um ciclo FOR é que cada vez que ele atinge NEXT, ele adiciona 1 à variável 'i'.
Quando 'i' é igual a 10, o computador sabe que repetiu 10 vezes, e o ciclo
se encerra.
Podemos definir o número para o que quisermos - 10, 42, ou um bilhão - isso é conosco.
Vamos dizer que queremos dar ao jogador um bônus
no final de cada nível para o número de
relés de vácuo que ele tem sobrando.
Como o jogo fica mais difícil, é preciso mais habilidade
para ter relés não utilizados, por isso queremos que o bônus
suba exponencialmente com base no nível.
Precisamos escrever um pedaço de código que calcule expoentes - ou seja, multiplique um número
por si mesmo um número específico de vezes.
Um loop é perfeito para isso!
Primeiro vamos inicializar uma nova variável chamada
“Bônus” e configurá-la para 1.
Então, criamos um laço FOR começando em 1,
e repetindo até o número do nível.
Dentro desse loop, nós multiplicamos bônus vezes o número de relés, e salvamos o novo valor
de volta em bônus.
Por exemplo, digamos que relés é igual a 2, e nível é igual a 3.

Spanish: 
Vamos a establecer algunos valores reales.
Este ejemplo se ejecuta 10 veces, porque hemos especificado que la variable "i" empieza con
un valor 1 y hasta 10.
Lo único de un "circuito para"es que cada vez que termina, suma 1 a "i".
Cuando "i" sea igual a 10, la computadora sabe que ya ha ejecutado 10 veces, entonces el
circuito termina.
Podemos configurar estos números a cualquiera que queramos - 10, 42, o un billón - depende de nosotros.
Supongamos que queremos otorgarle al jugador un bonus al final de cada nivel por cada
transistor que tengan de sobra.
A medida que el juego se torna más difícil, toma más destreza tener transistores extra, entonces queremos
que el bonus crezca exponencialmente con respecto al nivel
Necesitamos un código que calcule exponentes - eso es, multiplicar un número
por sí mismo una cantidad de veces específica.
Un circuito es perfecto para esto!
Primero vamos a inicializar una nueva variable llamada "bonus" y establecerla a 1.
Luego creamos un "circuito para" que empiece en 1, y que se ejecute la misma cantidad de veces que el nivel.
Dentro del circuito, multiplicamos  el bonus por la cantidad de transistores, y guardamos el nuevo valor
de vuelta en el bonus.
Por ejemplo, digamos que "transistores" = 2, y "nivel" = 3.

Arabic: 
الآن، دعونا نضع في بعض القيم الحقيقية.
حلقات هذا المثال 10 مرات، لأننا
حدد أن المتغير 'ط' يبدأ في
القيمة 1 وترتفع إلى 10.
إن أهم ما يميز لحلقة هو أن
في كل مرة يضرب NEXT، فإنه يضيف إلى 'ط'.
عندما 'ط' يساوي 10، يعرف الكمبيوتر
انه تم يحلق 10 مرات، وحلقة
المخارج.
فإننا يمكن أن يحدد العدد إلى ما نريد
- 10، 42، أو مليار - والامر متروك لنا.
دعونا نقول أننا نريد أن نعطي لاعب مكافأة
في نهاية كل مستوى لعدد
التبديلات فراغ لديهم خلفها.
كما يحصل اللعبة أصعب، فإنه يأخذ المزيد من المهارات
أن يكون التتابع غير المستخدمة، لذلك نحن نريد مكافأة
لترتفع القائمة على أضعافا مضاعفة على المستوى.
نحن بحاجة لكتابة قطعة من التعليمات البرمجية التي تحسب الدعاة - وهذا هو، بضرب عدد
في حد ذاته عدد محدد من المرات.
حلقة مثالية لهذا!
أولا دعنا تهيئة متغير جديد يسمى
"مكافأة" وتعيينه إلى 1.
ثم، علينا خلق FOR حلقة ابتداء من الساعة 1،
وحلقات يصل الى رقم المستوى.
داخل تلك الحلقة، ضربنا مرات مكافأة
عدد من التبديلات، وحفظ تلك القيمة الجديدة
العودة الى مكافأة.
على سبيل المثال، دعنا نقول التبديلات يساوي 2،
ومستوى يساوي 3.

Spanish: 
El "circuito para" va a ejecutarse 3 veces, significa entonces que el bonus va a multiplicarse por
transistores...por transistores...por transistores.
O en este caso, 2 x 2 x 2, que llega a ser un bonus de 8!
Eso es 2 a la 3era potencia!
Este código exponente es útil, y puede que queramos usarlo en otras partes de nuestro código.
Sería molesto tener que copiar y pegarlo en todo lugar, tendríamos que
renombrar las variables cada vez.
También, si encontráramos un error, tendríamos que buscar y actualizar todos los lugares donde lo hemos utilizado.
También vuelve el código más confuso.
Menos es más!
Lo que queremos es una manera de empacar nuestro código exponente para poder usarlo, obtener el resultado, y
no tener que ver toda la complejidad interna.
Entonces vamos a movernos otra vez a un nuevo nivel de abstracción!
Para separar y esconder la complejidad de los lenguajes de programación, podemos juntar los códigos
en funciones, también llamados métodos o sub-rutinas  en diferentes lenguajes de programación.
Estas funciones pueden usarse en cualquier otra parte del programa solo con su nombre.
Vamos a convertir nuestro código exponente en una función!
Primero, debemos nombrarla.

Korean: 
따라서 FOR 루프는 세 번 반복됩니다.
보너스는 다음과 같이 곱해집니다 .
보너스 * 릴레이 수 * 릴레이 수 * 릴레이 수
이 경우에는, 곱하기 2, 곱하기 2, 곱하기 2,
보너스는 8 입니다.
그것은 2의 3승이죠!
이 지수 코드는 유용해서 여러분이
코드의 다른 부분에서 사용하길 원할지도 모릅니다.
이걸 모든 곳에 복사하여 붙여 넣는 것은 귀찮고, 
변수이름을 매번 업데이트 해야 하죠.
이걸 모든 곳에 복사하여 붙여 넣는 것은 귀찮고, 
변수이름을 매번 업데이트 해야 하죠.
또 만약 벌레를 발견하면 사냥을 하고 우리가 사용했던 
모든 장소들을 업데이트 해야 하죠.
이건 코드를 더 보기에 혼란스럽게 만듭니다.
적은게 더 좋은것!
우리가 원하는 것은 지수코드를 패키지화해서 
그걸 사용하여 결과를 얻는 방법입니다.
모든 내부 복잡성을 볼 필요가 없이요.
우리는 다시 한번 새로운 레벨의 추상화로 갑니다!
복잡성을 분류하고 숨기려면 프로그래밍 언어는 
코드 조각을 명명된 함수로 패키지화할 수 있습니다.
함수는 다른 프로그래밍 언어로 
메서드 또는 서브 루틴이라고도 합니다.
이러한 함수는 해당 프로그램의 다른 부분에서
이름을 호출하면 사용될 수 있습니다.
지수 코드를 함수로 변환해 봅시다!
먼저 이름을 지정해야합니다.

English: 
So the FOR loop will loop three times, which
means bonus is going to get multiplied by
relays... by relays... by relays.
Or in this case, times 2, times 2, times 2,
which is a bonus of 8!
That’s 2 to the 3rd power!
This exponent code is useful, and we might
want to use it in other parts of our code.
It’d be annoying to copy and paste this
everywhere, and have to update the variable
names each time.
Also, if we found a bug, we’d have to hunt
around and update every place we used it.
It also makes code more confusing to look at.
Less is more!
What we want is a way to package up our exponent
code so we can use it, get the result, and
not have to see all the internal complexity.
We’re once again moving up a new level of
abstraction!
To compartmentalize and hide complexity, programming
languages can package pieces of code into
named functions, also called methods or subroutines
in different programming languages.
These functions can then be used by any other
part of that program just by calling its name.
Let’s turn our exponent code into a function!
First, we should name it.

Chinese: 
所以FOR循環將循環三次，其中
意味著獎勵將被乘以
繼電器...繼電器...繼電器（值）。
或說在這個例子裡，乘以2，乘以2，乘以2，
就有了等於8的獎勵！
這是三個2的力量！
這個指數代碼是好用的，我們可以
想要在我們的代碼的其他部分使用它。
但到處複製貼上這個很麻煩
而且我們每次都必須
替變量更新名字。
另外，如果我們發現了一個bug，
我們將得逐一確認並更新我們使用它的每一個地方。
而它也使代碼看起來更混亂。
少即是多！
我們想要的是一種打包這個指數代碼的方法，
以便我們可以使用它，獲得結果，
並且不必看到所有的內部複雜性。
我們再次提高了一個
新層次的抽象！
為了劃分和隱藏複雜性，
編程語言可以將代碼包裝進
命名函數，
或稱為方法(methods)或子程式
在不同的編程語言裡。
這些命名函數可以被程式的任何其他部分使用
只需要叫出他的名稱。
讓我們把我們的指數代碼變成一個函數！
首先，我們應該命名它。

Portuguese: 
Assim, o loop FOR executará três vezes, o que significa bônus será multiplicado por
relés ... por relés ... por relés.
Ou, neste caso, vezes 2, vezes 2, vezes 2, que é um bônus de 8!
Isso é 2 a 3ª potência!
Este código expoente é útil, e nós pudemos querer usá-lo em outras partes do nosso código.
Seria chato copiar e colar isto
em todos os lugares, e ter que atualizar os nomes
das variáveis toda vez.
Além disso, se encontrarmos um erro, teríamos que rastrear e atualizar cada um dos lugares em que o usamos.
Isso também torna o código mais confuso para examinar.
Menos é mais!
O que queremos é uma maneira de "empacotar" nossa código de exponenciação para que possamos usá-lo, obter o resultado, e
não ter que ver toda a complexidade interna.
Estamos, mais uma vez, movendo-nos a um novo nível de abstração!
Para compartimentar e ocultar a complexidade, as linguagens de programação podem empacotar pedaços de código em
funções nomeadas, também chamadas de métodos ou sub-rotinas em diferentes linguagens de programação.
Estas funções podem, em seguida, ser utilizadas por qualquer outra
parte daquele programa apenas chamando por seu nome.
Vamos transformar o nosso código de exponenciação em uma função!
Primeiro, devemos nomeá-lo.

Arabic: 
لذلك لإرادة حلقة حلقة ثلاث مرات، والذي
يعني مكافأة هو الذهاب الى الحصول مضروبا
التبديلات ... بواسطة التبديلات ... بواسطة التبديلات.
أو في هذه الحالة، وأحيانا 2 مرات 2 مرات 2،
الذي هو مكافأة من 8!
هذا هو 2 إلى قوة 3RD!
هذا الرمز الأس هو مفيد، ونحن قد
تريد استخدامها في أجزاء أخرى من التعليمات البرمجية لدينا.
انها تريد ان تكون مزعج للنسخ ولصق هذا
في كل مكان، ويجب أن تحديث متغير
أسماء في كل مرة.
أيضا، إذا وجدنا الخلل، سيكون لدينا لمطاردة
حول وتحديث كل مكان كنا فيه.
كما أنه يجعل رمز أكثر مربكة للنظر في.
الاقل هو الاكثر!
ما نريده هو وسيلة لحزمة حتى الأس لدينا
كود حتى نتمكن من استخدامها، والحصول على نتيجة، و
ليس من الضروري أن ترى كل التعقيد الداخلي.
نحن نتجه مرة أخرى تصل إلى مستوى جديد من
التجريد!
لتجزئة وإخفاء التعقيد، برمجة
يمكن اللغات حزم قطع من الشفرة في
وظائف الكشف عن اسمه، وتسمى أيضا أساليب أو الوظائف الفرعية
في لغات البرمجة المختلفة.
ويمكن بعد هذه الوظائف يتم استخدامها من قبل أي دولة أخرى
جزء من هذا البرنامج فقط عن طريق الاتصال اسمها.
لننتقل كود الأس لدينا في وظيفة!
أولا، يجب علينا أن تسمية.

Spanish: 
Podemos nombrarla como queramos, como Unicornio Feliz, pero ya que nuestro código calcula exponentes,
vamos a llamara "exponente".
Desde luego, en vez de usar variables específicas como "transistores" o "niveles", especificamos
nombres de variables genéricos, como "Base" y "Exponente", cuyos valores iniciales van a ser importados
a nuestra función desde alguna otra parte de nuestro programa.
El resto de nuestro código es igual que antes, solo que ahora agregamos nuestra nueva función con
algunos nombres de variables nuevos.
Finalmente, necesitamos enviar el resultado del código exponente de vuelta a la parte del programa
que la solicitó.
Para esto, vamos a usar un enunciado "regreso", y especificar que el valor del "resultado" debe ser regresado.
Entonces nuestra función de código completa se ve así:
Ahora podemos usar esta función en cualquier parte de nuestro programa, simplemente escribiendo su nombre e importando
dos números.
Por ejemplo, si quiero calcular 2 a la potencia 44, solamente establezco
"exponente (2, 44)".
y el resultado es alrededor de 18 trillones.
Detrás de escenas, 2 y 44 se guardan en las variables "Base" y "Exponente" dentro de la función,
y hace todos los circuitos necesarios hasta que la función termina y expresa el resultado.
Usemos nuestra función para calcular el bonus del puntaje.

Chinese: 
我們可以稱它為我們想要的任何東西，
比如HappyUnicorn，
但由於我們的代碼計算指數，因此
我們命名它為「指數」。
另外，有別於使用特定的變量名稱，
像我們之前指定的「繼電器」和「等級」
我們用更通用的名稱命名變量，如Base和Exp，
其初始值
將會從程式的其他部分被“導入”
我們其餘的代碼和以前一樣，
現在我們函數裡塞進了新的
變量名稱。
最後，我們需要發送我們的指數代碼回到程序裡
要求它。
為此，我們使用RETURN語句並指定
返回'結果'中的值。
所以我們的全函數代碼長這樣：
現在我們可以在任何地方使用這個函數
程式，只需調用其名稱並
置入兩個數字。
例如，如果我們想計算2到
第44次方，我們可以直接寫出
指數（2,44）
並得到結果：18萬億。
在幕後，2和44被存進
函數內部的變量Base和Exp，
它根據需要完成所有循環，然後
該函數給出結果。
讓我們使用我們新鑄造的功能來計算
分數獎勵。

Korean: 
우리는 HappyUnicorn과 같이 우리가 원하는 어떤 것이든 이름 붙일 수 있습니다.
하지만 우리 코드는 지수를 계산하기 때문에
그것을 지수라고 부릅시다.
또한 "릴레이"나 "레벨"같은 
특정 변수 이름을 사용하는 대신
Base 및 Exp와 같은  포괄적인 변수 이름을 지정합니다.
이 변수의 초기값은 프로그램의 다른 부분에서 
함수로 "전달"됩니다.
나머지 코드는 이전과 동일하며, 
이제는 함수와 새로운 변수 이름을 사용합니다.
나머지 코드는 이전과 동일하며, 
이제는 함수와 새로운 변수 이름을 사용합니다.
마지막으로 지수 코드의 결과를 
요청한 프로그램의 부분으로 되돌려야 합니다.
마지막으로 지수 코드의 결과를 
요청한 프로그램의 부분으로 되돌려야 합니다.
이를 위해 RETURN 문을 사용하고
'result'의 값이 반환하도록 지정합니다.
그래서 전체 함수 코드는 다음과 같습니다.
이제 우리는 이 함수를 프로그램 어디서나 
사용할 수 있습니다.
단순히 함수를 호출하고 두개의 숫자를 전달함으로써요.
예를 들어, 2의 44승을 계산하려고 합니다.
단지 Exponent에 2와 44를 부르기만 하면 되죠.
그리고 18 조가 결과로 돌아옵니다.
뒷 배경에서 2와 44가 함수 안의 
바탕수와 지수 로 저장됩니다.
필요한 만큼 모든 루프를 수행 한 다음
함수는 결과를 반환 합니다.
새로 작성한 함수를 사용해서
 점수 보너스를 계산해 봅시다.

English: 
We can call it anything we want, like HappyUnicorn,
but since our code calculates exponents, let’s
call it exponent.
Also, instead of using specific variable names,
like “relays” and “levels”, we specify
generic variable names, like Base and Exp,
whose initial values are going to be “passed”
into our function from some other part of
the program.
The rest of our code is the same as before,
now tucked into our function and with new
variable names.
Finally, we need to send the result of our
exponent code back to the part of the program
that requested it.
For this, we use a RETURN statement, and specify
that the value in ‘result’ be returned.
So our full function code looks like this:
Now we can use this function anywhere in our
program, simply by calling its name and passing
in two numbers.
For example, if we want to calculate 2 to
the 44th power, we can just call “exponent
2 comma 44.”
and like 18 trillion comes back.
Behind the scenes, 2 and 44 get saved into
variables Base and Exp inside the function,
it does all its loops as necessary, and then
the function returns with the result.
Let’s use our newly minted function to calculate
a score bonus.

Portuguese: 
Podemos chamá-lo de qualquer coisa que quisermos, como UnicornioFeliz,
mas já que nosso código calcula expoentes, vamos
chamá-lo "expoente".
Além disso, em vez de usar nomes de variáveis ​​específicas, como “relés” e “níveis”, especificamos
nomes genéricos de variáveis, como base e exp,
cujos valores iniciais vão ser “passados”
para nossa função a partir de alguma outra parte do o programa.
O resto do nosso código é o mesmo que antes, agora embutido em nossa função e com novos
nomes de variáveis.
Finalmente, precisamos enviar o resultado da nosso código de exponenciação de volta para a parte do programa
que o solicitou.
Para isso, usamos uma instrução RETURN, e especificar que o valor em 'resultado' seja devolvido.
Assim, o nosso código de função completo fica assim:
Agora podemos usar esta função em qualquer lugar de nosso programa, simplesmente chamando seu nome e passando
dois números.
Por exemplo, se quisermos calcular 2 à potência de 44, podemos apenas chamar
"expoente" 2 vírgula 44
e o valor de cerca de 18 trilhões retorna.
Nos bastidores, 2 e 44 são salvos em
Variáveis ​​Base e Exp dentro da função,
ela faz todas as suas voltas conforme necessário e, em seguida, a função retorna com o resultado.
Vamos usar nossa função recém-criada para calcular um bônus de pontuação.

Arabic: 
يمكن أن نطلق عليه أي شيء نريد، مثل HappyUnicorn،
ولكن منذ رمز لنا بحساب الأس، دعونا
نسميها الأس.
أيضا، بدلا من استخدام أسماء المتغيرات محددة،
مثل "التتابع" و "المستويات"، نحدده
أسماء المتغيرات العامة، مثل قاعدة والتصدير
قيمها الأولي ستكون "مرت"
في وظيفة لدينا من أي جزء آخر من
البرنامج.
بقية من التعليمات البرمجية لدينا هو نفسه كما كان من قبل،
مدسوس الآن إلى وظيفتنا ومع الجديد
أسماء المتغيرات.
وأخيرا، نحن في حاجة الى ارسال نتيجة لدينا
كود الأس إلى جزء من البرنامج
التي طلبت ذلك.
لهذا، ونحن نستخدم بيان عودة، وتحديد
أن يتم إرجاع القيمة في 'نتيجة'.
لذلك لدينا كود ظيفة الكامل يبدو مثل هذا:
الآن يمكننا استخدام هذه الوظيفة في أي مكان في منطقتنا
البرنامج، ببساطة عن طريق الاتصال اسمها ويمر
في رقمين.
على سبيل المثال، إذا كنا نريد لحساب 2
قوة ال44، يمكننا أن مجرد دعوة "الأس
2 فاصلة 44. "
ومثل 18 تريليون يعود.
وراء الكواليس و 2 و 44 الحصول على حفظها في
المتغيرات قاعدة والتصدير داخل وظيفة،
انها تفعل كل الحلقات لها عند الضرورة، ومن ثم
ترجع الدالة بالنتيجة.
دعونا نستخدم وظيفة المسكوكة حديثا لحساب
مكافأة النتيجة.

Chinese: 
首先，我們將獎勵初始化為0。
然後我們用if敘述來檢查玩家
是否有剩餘的繼電器。
如果他們有，我們叫出指數函數，
放入繼電器和關卡計算
並得到結果，
我們將其存入「獎勵」。
這個獎勵計算代碼之後可能會有用，
所以讓我們把它視作為一個函數來結束吧！
是的，一個調用函數的函數！
然後，等待它......。我們可以在更複雜的函數中使用這個函數。
我們來寫一個每次都會被調用的函數
玩家完成一個關卡。
我們要把它叫做“levelFinished” - 它需要
要知道剩下的繼電器數量是多少
它現在在的等級，和現在的分數。
這些價值必須被代入。
在我們的函數里面，我們將計算
獎勵，使用我們的calcBonus函數，
並把它加到分數裡。
另外，如果當前得分高於
遊戲的最高分，我們儲存新高得分
和玩家名字。
最後，我們交出當前分數。
現在我們變得很漂亮了。
函數調用調用函數的函數！
當我們像這樣調用一行代碼時，
複雜性是被隱藏的。

English: 
First, we initialize bonus to 0.
Then we check if the player has any remaining
relays with an if-statement.
If they do, we call our exponent function,
passing in relays and level, which calculates
relays to the power of level, and returns
the result, which we save into bonus.
This bonus calculating code might be useful later, so let’s wrap it up as a function too!
Yes, a function that calls a function!
And then, wait for it…. we can use this
function in an even more complex function.
Let’s write one that gets called everytime
the player finishes a level.
We’ll call it “levelFinished” - it needs
to know the number of relays left, what level
it was, and the current score; those values
have to get passed in.
Inside our function, we’ll calculate the
bonus, using our calcBonus function, and add
that to the running score.
Also, if the current score is higher than
the game’s high score, we save the new high
score and the players name.
Finally, we return the current score.
Now we’re getting pretty fancy.
Functions are calling functions are calling
functions!
When we call a single line of code, like this
the complexity is hidden.

Arabic: 
أولا، نحن تهيئة مكافأة ل0.
ثم نتحقق إذا كان لاعب لديه أي المتبقية
التبديلات مع-بيان إذا.
إذا فعلوا ذلك، فإننا ندعو وظيفة الأس لدينا،
يمر في التبديلات ومستوى، والتي تحسب
التبديلات لقوة مستوى، والعوائد
ونتيجة لذلك، وهو ما حفظ في المكافأة.
قد يكون هذا الرمز وحساب مكافأة مفيدا في وقت لاحق، لذلك دعونا الانتهاء من ذلك بوصفها وظيفة للغاية!
نعم، باستدعاء وظيفة أن وظيفة!
وبعد ذلك، انتظر .... يمكننا استخدام هذه
وظيفة في وظيفة أكثر تعقيدا.
دعنا نكتب واحد أن يحصل على استدعاء كل مرة
لاعب انتهاء المستوى.
ونحن سوف يطلق عليه "levelFinished" - فإنه يحتاج
لمعرفة عدد من التبديلات اليسار، أي مستوى
كان، والنتيجة الحالية. تلك القيم
يجب أن تحصل مرت في.
داخل وظيفة دينا، ونحن سوف حساب
مكافأة، وذلك باستخدام وظيفة calcBonus لدينا، وإضافة
ذلك إلى درجة التوالي.
أيضا، إذا كانت النتيجة الحالية أعلى من
النتيجة اللعبة عالية، ونحن حفظ مستوى جديد
تسجيل واسم اللاعبين.
وأخيرا، نعود النتيجة الحالية.
الآن نحن نحصل على يتوهم جدا.
وظائف يدعون ظائف يدعون
المهام!
عندما ندعو سطر واحد من التعليمات البرمجية، مثل هذا
تعقيد مخفيا.

Korean: 
먼저 보너스를 0으로 초기화합니다.
그런 다음 플레이어의 If문에 남은 릴레이가 있는지 
확인합니다.
만약 그렇다면 우리는 지수 함수를 호출해서 
릴레이의 숫자와 레벨의 수를 전달합니다.
릴레이 수를 레벨의 수만큼 곱하고 결과로 반환하여 
보너스로 저장합니다.
이 보너스 계산 코드는 나중에 유용 할 수 있으므로 
함수로 정리하도록 하죠!
네, 함수를 호출하는 함수!
그리고, 잠시 기다리면 우리는 이 함수를 더 복잡한 함수 안에서 사용할 수 있습니다.
플레이어가 레벨을 완료할 때 마다 
호출하는 것을 작성해봅시다.
우리는 그것을 "레벨 완성"이라고 부를 것입니다. 
남은 릴레이의 수와 레벨, 현재 점수를 알아야 합니다.
이 값들은 함수에 전달되어야 합니다.
함수 안에서는 calcBonus 함수를 사용하여 
보너스를 계산해 그것을 현재 점수에 더합니다.
함수 안에서는 calcBonus 함수를 사용하여 
보너스를 계산해 그것을 현재 점수에 더합니다.
또한 만약 현재 점수가 게임의 높은 점수보다 더 높다면, 새로운 점수와 플레이어 이름을 저장합니다.
또한 만약 현재 점수가 게임의 높은 점수보다 더 높다면, 새로운 점수와 플레이어 이름을 저장합니다.
마지막으로 현재 점수를 반환합니다.
이제 우리는 꽤 멋진데요!?
함수가 함수를 호출하고, 또 함수를 호출하고 
또 함수를 호출하죠.
이와 같은 한 줄의 코드를 호출하면,
복잡성은 숨겨져 있습니다.

Spanish: 
Primero inicializamos el bonus a 0.
Luego revisamos si el jugador tiene algún transistor sobrante con un enunciado "si".
Si es así, ejecutamos nuestra función exponente, importando los "transistores" y el "nivel", los cuales calculan
"transistores" a la potencia del "nivel", y el resultado es guardado en el "bonus",
Este código que calcula el bonus puede ser útil luego, vamos a convertirlo en una función!
Sí, una función que ejecuta una función!
Y luego, esperen...podemos usar esta función en una función aun más compleja.
Vamos a escribir una que se ejecute cada vez que el jugador termina un nivel.
Vamos a llamarla "nivelTerminado" - necesita saber el número de transistores disponibles, el nivel
anterior, y el puntaje actual; estos valores van a ser importados.
Dentro de nuestra función, vamos a calcular el bonus, usando nuestra función "calcBonus", y agregar
eso al puntaje actual.
También, si el puntaje actual es mayor que el récord del juego, guardamos el nuevo
récord con el nombre del jugador.
Finalmente, terminamos con el puntaje actual.
Cada vez estamos mejorando.
Funciones que ejecutan funciones que ejecutan funciones!
Cuando ejecutamos una sola línea de código, esta es la complejidad que se esconde.

Portuguese: 
Primeiro, nós inicializar bônus a 0.
Em seguida, vamos verificar se o jogador tem algum relé restante, com uma instrução if.
Se tiver, nós chamamos a nossa função expoente, passando relés e nível, que calcula
o valor de relés à potência do valor de nível, e retorna o resultado, que salvamos em bônus.
Este código de cálculo de bônus pode ser útil mais tarde, por isso vamos envolvê-lo como uma função também!
Sim, uma função que chama uma função!
E então, esperem... podemos usar essa função em uma função ainda mais complexa.
Vamos escrever uma que seja chamada sempre que o jogador termina um nível.
Vamos chamá-la “nivelTerminado” - ela precisa saber o número de relés restantes, qual o nível
corrente, e a pontuação atual; esses valores têm de ser passados.
Dentro da nossa função, vamos calcular o bônus, usando a nossa função calcBonus, e adicionar
isto à pontuação corrente.
Além disso, se a pontuação corrente é maior do que o recorde do jogo, nós salvamos o novo recorde
e o nome do jogador.
Finalmente, retornamos à pontuação corrente.
Agora, estamos ficando muito sofisticados.
As funções estão chamando funções que estão chamando funções!
Quando chamamos uma única linha de código, como esta, a complexidade fica escondida.

Chinese: 
我們沒有看到所有的內部循環和
變量，我們只看到結果
像變魔術一般跑回來......。總分為53分。
但這不是魔術，而是簡化的力量！
如果你理解這個例子，那麼你就
明白了函數功能和
現代編成的本質。
例如，你不可能把一個網頁瀏覽器
寫成一個巨大的長列表
的敘述。
它將會有數百萬行，
並且不可能被理解！
相反，軟件由數千個組成
較小的函數程序組成，每個負責
不同的功能。
在現代編程中，看到超過100行左右的
函數的情況並不常見。
因為這種時候，
可能會有應該提出-
-獨立製成函數的東西
模塊化函數不僅使單個程序員
得以編寫整個app，
也可以在處理更大的編程時
團隊工作更有效率。
不同的程序員可以處理不同的問題
功能，如果每個人都確認了他們的
代碼正常運作，那麼當所有東西
被放在一起，整個程序也應該
能夠工作。
而在現實世界中，程序員並不是在
浪費時間寫出像指數這樣的東西。

Korean: 
우리는 모든 내부 루프와 변수를 보지 않으며, 
우리는 반환된 결과만을 봅니다.
마법처럼, 총 점수는 53 점입니다.
그러나 그것은 마법이 아니고, 추상화의 힘이죠!
여러분이 이 예제를 이해한다면, 함수의 힘과 
현대 프로그래밍의 본질을 이해하게 될 것입니다.
여러분이 이 예제를 이해한다면, 함수의 힘과 
현대 프로그래밍의 본질을 이해하게 될 것입니다.
글로 쓰는 것은 불가능합니다. 예를 들어 웹 브라우저를 거대하고 긴 문장의 목록으로 쓸 순 없습니다.
글로 쓰는 것은 불가능합니다. 예를 들어 웹 브라우저를 거대하고 긴 문장의 목록으로 쓸 순 없습니다.
그것은 수백만 줄 이면서 이해하기 불가능할 것입니다.
대신 소프트웨어는 수천개의, 서로 다른 기능을 맡는 
작은 함수들로 구성되어 있습니다.
대신 소프트웨어는 수천개의, 서로 다른 기능을 맡는 
작은 함수들로 구성되어 있습니다.
현대 프로그래밍에서는 100줄보다 
더 긴 함수를 찾가보긴 어렵습니다.
그때 쯤이면 아마 끌어내서 자체 기능으로 만들어야하는 무언가 있을 것이기 때문입니다.
그때 쯤이면 아마 끌어내서 자체 기능으로 만들어야하는 무언가 있을 것이기 때문입니다.
함수로 프로그램을 모듈화 하는 것은 한명의 프로그래머가 전체 앱을 쓰는 걸 가능하게 할 뿐 아니라,
팀 구성원들이 매우 큰 프로그램 안에서도 효율적으로 
작업할 수 있도록 합니다.
다른 프로그래머가 다른 함수 작업을 할 수 있습니다.
만약 모든 사람이 그들의 코드가 
정확하게 작동한다고 확신하면
모든 것이 입력되었을때, 
전체 프로그램은 작동해야 합니다.
모든 것이 입력되었을때, 
전체 프로그램은 작동해야 합니다.
그리고 현실 세계에서 프로그래머들은
지수를 쓰는 것과 같은 시간 낭비를 하지 않습니다.

English: 
We don’t see all the internal loops and
variables, we just see the result come back
as if by magic…. a total score of 53.
But it’s not magic, it’s the power of
abstraction!
If you understand this example, then you understand the power of functions, and the entire essence
of modern programming.
It’s not feasible to write, for example,
a web browser as one gigantically long list
of statements.
It would be millions of lines long and impossible
to comprehend!
So instead, software consists of thousands
of smaller functions, each responsible for
different features.
In modern programming, it’s uncommon to
see functions longer than around 100 lines
of code, because by then, there’s probably
something that should be pulled out and made
into its own function.
Modularizing programs into functions not only
allows a single programmer to write an entire
app, but also allows teams of people to work
efficiently on even bigger programs.
Different programmers can work on different
functions, and if everyone makes sure their
code works correctly, then when everything
is put together, the whole program should
work too!
And in the real world, programmers aren’t
wasting time writing things like exponents.

Portuguese: 
Nós não vemos todos os loops internos e variáveis, vemos apenas o resultado voltar
como que por magia... uma pontuação total de 53.
Mas não é mágica, é o poder da
abstração!
Se você entender este exemplo, então você entenderá o poder de funções, e toda a essência
da programação moderna.
Não é viável escrever, por exemplo,
um navegador web como uma lista gigantescamente longa
de declarações.
Seriam milhões de linhas de comprimento, e impossível
compreender!
Então, ao invés, software consiste em milhares de funções menores, cada um responsável por
características diferentes.
Na programação moderna, é raro
ver funções mais do que cerca de 100 linhas
de código, porque até nesse caso, há provavelmente algo que deve ser puxado para fora e transformado
em sua própria função.
Modularizar programas em funções não só permite que um único programador escreva um
aplicativo inteiro, mas também permite que as equipes de pessoas trabalhem eficientemente em programas ainda maiores.
Diferentes programadores podem trabalhar em diferentes funções, e se todos se certificarem que sua
parte do código funciona corretamente, em seguida, quando tudo for colocado junto, todo o programa deve
funcionar, também!
E no mundo real, os programadores não perdem tempo escrevendo coisas como expoentes.

Spanish: 
No vemos todos los circuitos internos y variables, solamente observamos los resultados finales
como por arte de magia... un puntaje total de 53.
Pero no es magia, es el poder de la abstracción!
Si entiendes este ejemplo, entonces comprendes el poder de las funciones, y esa es la esencia
completa de la programación moderna.
Simplemente no es posible, por ejemplo, programar un explorador web con una lista gigante
de enunciados.
Tendría millones de líneas de código y sería imposible comprenderlo!
A cambio, el software consiste de miles de funciones más pequeñas, cada una responsable por
diferentes características.
En la programación moderna, es poco común encontrar funciones con más de 100 líneas
de código, porque para entonces, algo así probablemente sería transformado
en su propia función.
Modularizar  programas en funciones no solo permite que un solo programador escriba una aplicación
completa, sino que permite a los equipos trabajar eficientemente en programas aún más grandes.
Diferentes programadores pueden trabajar en diferentes funciones, y si todos se aseguran que su
código funciona correctamente, entonces cuando todo se junte, el programa completo
debería funcionar también!
Y en el mundo real, los programadores no pierden su tiempo escribiendo cosas como exponentes.

Arabic: 
ونحن لا نرى جميع الحلقات الداخلية و
المتغيرات، ونحن فقط نرى نتيجة أعود
كما لو كان السحر…. على درجة من مجموع 53.
ولكنها ليست سحرية، انها قوة
التجريد!
إذا فهم هذا المثال، فإنك فهم قوة من الوظائف، وجوهر كامل
البرمجة الحديثة.
انها ليست مجدية في الكتابة، على سبيل المثال،
متصفح ويب كقائمة واحدة طويلة gigantically
البيانات.
وسيكون من الملايين من خطوط طويلة والمستحيل
لفهم!
بدلا من ذلك، البرنامج يتكون من آلاف
وظائف صغيرة، كل منها مسؤولة عن
ميزات مختلفة.
في البرمجة الحديثة، فمن المألوف أن
رؤية وظائف لفترة أطول من حوالي 100 خط
من التعليمات البرمجية، لأن في ذلك الحين، هناك على الارجح
وهو الأمر الذي يجب أن انسحبت وقدمت
في وظيفتها الخاصة.
Modularizing البرامج في وظائف لا
يسمح مبرمج واحد لكتابة كامل
التطبيق، ولكنه يسمح أيضا فرق من الناس للعمل
بكفاءة على برامج أكبر.
يمكن للمبرمجين مختلفة تعمل على مختلف
وظائف، وإذا كان الجميع يحرص على
الرمز يعمل بشكل صحيح، ثم عندما يكون كل شيء
وضعت معا، ينبغي للبرنامج بأكمله
العمل أيضا!
وفي العالم الحقيقي، والمبرمجين ليسوا
إضاعة الوقت في كتابة أشياء مثل الدعاه.

Portuguese: 
Linguagens de programação modernas vêm com enormes pacotes de funções pré-escritas, chamados Bibliotecas.
Estas são escritos por programadores experientes, tornadas eficientes e rigorosamente testadas, e então dadas a todos.
Existem bibliotecas para quase tudo,
incluindo redes, gráficos e som
- temas que vamos discutir em episódios futuros.
Mas antes de chegarmos neles, precisamos conversar sobre algoritmos.
Intrigado?
Você deveria estar.
Vejo você na próxima semana!

English: 
Modern programming languages come with huge
bundles of pre-written functions, called Libraries.
These are written by expert coders, made efficient
and rigorously tested, and then given to everyone.
There are libraries for almost everything,
including networking, graphics, and sound
-- topics we’ll discuss in future episodes.
But before we get to those, we need to talk
about Algorithms.
Intrigued?
You should be.
I’ll see you next week.

Spanish: 
Los lenguajes de programación modernos tienen grandes cantidades de funciones pre-escritas, llamadas "librerías".
Estas son escritas por programadores expertos, probadas de manera rigurosa y eficiente, y luego dadas a todos.
Existen librerías para prácticamente todo, incluyendo redes, gráficos, y sonido
- temas que vamos a discutir en futuros episodios.
Pero antes de llegar a ellos, necesitamos hablar acerca de Algoritmos
Intrigado?
Deberías estarlo.
Te veré la próxima semana.

Chinese: 
現代編程語言有巨大的
預先編寫的函數庫，稱為程式庫( Libraries)。
它們由編碼專家編程，效率高
且經過嚴格測試，然後交給每個人。
幾乎所有東西都有屬於他們的程式庫，
包括網絡，圖形和聲音
- 我們將在未來的其他集討論這個主題。
但在我們接觸到這些之前，我們需要談談
關於算法。
好奇？
你應該。
下週見。

Korean: 
현대 프로그래밍 언어는 미리 작성된 함수들, 
라이브러리라고 불리는 엄청난 묶음입니다.
이들은 전문 코더에 의해 쓰여지고 효율적이게 만들며 
엄격하게 테스트 한 다음, 모든 사람에게 제공합니다.
네트워킹, 그래픽 및 사운드를 모팜하는 
거의 모든 것을 위한 라이브러리가 있습니다.
- 이 주제에 대해서는 앞으로의 강의에서 
다룰 예정입니다.
그러나 우리가 그것들을 다루기 전에 
알고리즘에 대해 말할 필요가 있습니다.
궁금한가요?
그래야만 합니다.
다음 주에 만나요.^^

Arabic: 
لغات البرمجة الحديثة تأتي مع ضخمة
حزم من وظائف مكتوبة مسبقا، ودعا المكتبات.
هذه فقد كتبت بواسطة المبرمجون الخبراء، جعلت كفاءة
وخضعت لاختبارات صارمة، ومن ثم تعطى للجميع.
هناك مكتبات في كل شيء تقريبا،
بما في ذلك الشبكات، والرسومات، والصوت
- المواضيع سنناقش في الحلقات المقبلة.
ولكن قبل أن نصل إلى تلك، ونحن بحاجة الى التحدث
حول الخوارزميات.
مفتون؟
يجب ان تكون.
سوف اراك الاسبوع المقبل.
