├── zh
    ├── task-5.md
    ├── task-15.md
    ├── task-20.md
    ├── task-9.md
    ├── task-3.md
    ├── task-13.md
    ├── task-41.md
    ├── task-6.md
    ├── task-8.md
    ├── task-4.md
    ├── task-2.md
    ├── task-7.md
    ├── task-1.md
    ├── task-28.md
    ├── task-43.md
    ├── task-63.md
    ├── task-11.md
    ├── task-46.md
    ├── task-37.md
    └── task-45.md
├── sk
    ├── task-94.md
    ├── task-30.md
    ├── task-5.md
    ├── task-50.md
    ├── task-3.md
    ├── task-13.md
    ├── task-9.md
    ├── task-20.md
    ├── task-15.md
    ├── task-10.md
    ├── task-41.md
    ├── task-16.md
    ├── task-4.md
    ├── task-28.md
    ├── task-21.md
    ├── task-6.md
    ├── task-2.md
    ├── task-7.md
    ├── task-26.md
    ├── task-1.md
    ├── task-8.md
    ├── task-48.md
    ├── task-14.md
    ├── task-43.md
    ├── task-17.md
    └── task-11.md
├── ar
    ├── task-5.md
    ├── task-3.md
    ├── task-41.md
    ├── task-20.md
    ├── task-2.md
    ├── task-15.md
    ├── task-7.md
    ├── task-6.md
    ├── task-4.md
    └── task-1.md
├── ru
    ├── task-3.md
    ├── task-5.md
    ├── task-30.md
    ├── task-20.md
    ├── task-50.md
    ├── task-2.md
    ├── task-22.md
    ├── task-13.md
    ├── task-68.md
    ├── task-4.md
    ├── task-29.md
    ├── task-6.md
    ├── task-19.md
    ├── task-15.md
    ├── task-31.md
    ├── task-41.md
    ├── task-9.md
    ├── task-16.md
    ├── task-10.md
    ├── task-8.md
    ├── task-81.md
    ├── task-26.md
    ├── task-7.md
    ├── task-67.md
    ├── task-23.md
    ├── task-21.md
    ├── task-61.md
    ├── task-1.md
    ├── task-32.md
    ├── task-18.md
    ├── task-28.md
    ├── task-48.md
    ├── task-25.md
    ├── task-57.md
    ├── task-43.md
    ├── task-11.md
    ├── task-52.md
    └── task-44.md
├── fr
    ├── task-5.md
    ├── task-3.md
    ├── task-4.md
    ├── task-2.md
    └── task-1.md
├── de
    ├── task-30.md
    ├── task-5.md
    ├── task-3.md
    ├── task-50.md
    ├── task-13.md
    ├── task-9.md
    ├── task-20.md
    ├── task-15.md
    ├── task-16.md
    ├── task-10.md
    ├── task-4.md
    ├── task-41.md
    ├── task-6.md
    ├── task-2.md
    ├── task-21.md
    ├── task-7.md
    ├── task-28.md
    ├── task-1.md
    ├── task-8.md
    └── task-48.md
├── es
    ├── task-3.md
    ├── task-30.md
    ├── task-50.md
    ├── task-5.md
    ├── task-20.md
    ├── task-15.md
    ├── task-9.md
    ├── task-13.md
    ├── task-22.md
    ├── task-41.md
    ├── task-68.md
    ├── task-31.md
    ├── task-104.md
    ├── task-10.md
    ├── task-16.md
    ├── task-19.md
    ├── task-6.md
    ├── task-2.md
    ├── task-4.md
    ├── task-28.md
    ├── task-8.md
    ├── task-7.md
    ├── task-21.md
    ├── task-1.md
    ├── task-57.md
    ├── task-23.md
    ├── task-14.md
    ├── task-48.md
    ├── task-18.md
    ├── task-26.md
    └── task-11.md
├── ro
    ├── task-3.md
    ├── task-20.md
    ├── task-5.md
    ├── task-41.md
    ├── task-15.md
    ├── task-6.md
    ├── task-4.md
    ├── task-2.md
    ├── task-1.md
    └── task-7.md
└── ua
    ├── task-36.md
    ├── task-59.md
    ├── task-51.md
    └── task-40.md


/zh/task-5.md:
--------------------------------------------------------------------------------
 1 | 为了对条件语句有更多的练习，我们将要写一个使用复杂条件语句的程序。即为了解决这个问题，`if ... else`语句可以（并且应该）
 2 | 嵌套在另一个这样的语句中。    
 3 | 
 4 | 几组三个数为一组的数据将会呈现给你。你的任务是从每组的三个数中选出最小的数值。  
 5 | 
 6 | **输入数据** 将会在第一行包含下面的三元组的个数。  
 7 | 接下来的几行将会包含每组的数据。   
 8 | **答案** 应该包含从各组数据中选出的最小值，并且以空格分隔。      
 9 | 
10 | 示例：   
11 | 
12 |     数据：
13 |     3
14 |     7 3 5
15 |     15 20 40
16 |     300 550 137
17 |     
18 |     答案：
19 |     3 15 137
20 | 


--------------------------------------------------------------------------------
/sk/task-94.md:
--------------------------------------------------------------------------------
 1 | Dnes som chcel spraviť novú úlohu a zistil som, že je  `1. Apríla  2014` - 
 2 | [Deň bláznov](http://en.wikipedia.org/wiki/April_Fools'_Day)
 3 | keď ľudia vymýšľajú všelijaké žarty, jeden na druhého.
 4 | 
 5 | Tu je jedna úloha **bez popisu problému**, avšak vy to dokážete vyriešiť! Veľa šťastia! :)
 6 | 
 7 | Príklad:
 8 | 
 9 |     vstupné dáta:
10 | 	5
11 | 	1 2
12 | 	1 2 3
13 | 	2 3 4
14 | 	2 4 6 8 10
15 | 	7 11 19
16 | 	
17 | 	odpoveď:
18 | 	5 14 29 220 531
19 | 


--------------------------------------------------------------------------------
/zh/task-15.md:
--------------------------------------------------------------------------------
 1 | 这个问题引入了“线性搜索”，这是一个应该透彻学习的流行算法，因为它经常用在更加复杂的编程任务中（排序等）。  
 2 | 
 3 | 一个在一序列数或者数组上很常见的操作是寻找它们的极值 —— 最大值或最小值。为了完成这个任务，需要一个单独的变量来存储
 4 | **当前最大值**（或最小值），然后遍历数组，用其中的每一个元素与这个变量做比较。每当下一个值比这个临时变量大的时候，这
 5 | 个值应该复制给临时变量（作为新的最大值）。  
 6 | 
 7 | 当遍历结束后，这个临时的变量将会保存有极值。  
 8 | 
 9 | **输入数据** 将会在一行中给你确切的`300`个数字。     
10 | **答案** 应该包括这些数值的最大值和最小值，并用空格分隔。        
11 | 
12 | 示例：  
13 | 
14 | 	输入数据：
15 | 	1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
16 | 	
17 | 	答案：
18 | 	300 1
19 | 


--------------------------------------------------------------------------------
/zh/task-20.md:
--------------------------------------------------------------------------------
 1 | 这是一个用于介绍字符串处理的简单问题。我们将会给出几行文本 —— 我们想找出每一行中的元音字母的个数（即字母 `a,o,u,i,e,y`）。**注意：** 在这个任务中`y`被认为是元音字母。      
 2 | 
 3 | *虽然简单，这个技术在密码破解方法中是重要的。例如参考[Caesar Cipher Cracker](./caesar-cipher-cracker)问题。*       
 4 | 
 5 | **输入数据** 在第一行包含测试用例的个数。   
 6 | 接下来是指定的几行，每一行代表一个测试用例。     
 7 | 行中仅包含小写的英文（拉丁）字母和空格。   
 8 | **答案** 应该包含每一行中元音字母的数目，并用空格分开。      
 9 | 
10 | 示例：
11 | 
12 |     输入数据：
13 | 	4
14 | 	abracadabra
15 | 	pear tree
16 | 	o a kak ushakov lil vo kashu kakao
17 | 	my pyx
18 | 	
19 | 	答案：
20 | 	5 4 13 2
21 | 


--------------------------------------------------------------------------------
/zh/task-9.md:
--------------------------------------------------------------------------------
 1 | 三角形是由三个线段组（三角形边）两端相连成的图形。[Wiki on triangles][1]提供了更详细的介绍。
 2 | 
 3 | 假如我们有三条长度为 `A B C` 的线段 - 我们使用这三条线段可以构成一个三角形
 4 | 
 5 | (比如用 `3 4 5` 或者 `3 4 7`(虽然此时面积是0)) 或者根本不能构成一个三角形
 6 | 
 7 | (比如 `1 2 4`)。
 8 | 
 9 | 给你任意组代表三角形的边长的三个数据，你要指出哪些组能够组成一个三角形，哪些组不能。
10 | 
11 | **输入数据：** 第一行包含给定的数据组数。
12 | 
13 | 其他行每行包含代表三角形边长的数据（每个数据之间用空格分开）
14 | 
15 | **答案:** 你需要为每组数据输出 `1` 或者 `0` （`1` 表示改组数据能够组成一个三角形，`0` 表示不能）。
16 | 
17 | 举个栗子：
18 | 
19 |     data:
20 |     2
21 |     3 4 5
22 |     1 2 4
23 | 
24 |     answer:
25 |     1 0
26 | 
27 | [1]: http://en.wikipedia.org/wiki/Triangle


--------------------------------------------------------------------------------
/zh/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="summing two arrays"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | 如果你已经从[Sum in Loop][prevtask]任务中学会了如何编写简单循环的程序，这个新的练习只是做了一个简单的修改。   
 7 | 
 8 | [prevtask]: ./sum-in-loop
 9 | 
10 | 现在我们会给出几对数值，我们想要计算每一对数值的总和。     
11 |  
12 | **输入数据** 将会在第一行包含所要处理的数值对的总数。         
13 | 下面的几行会包含具体的数值对 —— 每一对占一行。      
14 | **答案** 应该包含以空格分隔的结果。  
15 | 
16 | 例子：  
17 | 
18 | 
19 |     数据： 
20 |     3
21 |     100 8
22 |     15 245
23 |     1945 54
24 |     
25 |     答案：
26 |     108 260 1999
27 | 


--------------------------------------------------------------------------------
/zh/task-13.md:
--------------------------------------------------------------------------------
 1 | 这个编程联系类似用于计算CRC和其他校验和以及字符串上的哈希函数的更复杂的算法。此外，它还会给你提供一个将值拆分成十进制数字的练习。在此之前你可能通过计算 [Sum of Digits][1] 来练练手。
 2 | 
 3 | 然我们开始计算数字之和的练习吧，就像之前所说的，但是这里是将每位数字乘以数字所在的位置（从左到右，从1开始）。例如，给定了一个数字 `1776`，我们计算出这个 **加权数字之和** （我们就称之为"wsd"吧）为：
 4 | 
 5 |     wsd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60
 6 | 
 7 | **输入数据** 会在第一行给出测试案例的个数。
 8 | 
 9 | 数据在第二行给出，你需要计算给出的每个数据的加权数字之和。
10 | 
11 | **答案：** 跟往常一样，把结果放到同一行，用空格隔开。
12 | 
13 | 举个栗子：
14 | 
15 |     input data:
16 |     3
17 |     9 15 1776
18 | 
19 |     answer:
20 |     9 11 60
21 | 
22 | [1]: https://www.codeabbey.com/index/task_view/sum-of-digits


--------------------------------------------------------------------------------
/ar/task-5.md:
--------------------------------------------------------------------------------
 1 | تعتبر العبارات الشرطية من أهم عناصر البرامج , في هذه المسألة سنقوم بكتابة برنامج أكثر تعقيداً
 2 | حيث سيتم ادخال عبارتين شرطيتين الواحدة ضمن الأخرى
 3 | 
 4 | 
 5 | 
 6 | ستم إعطاء ثلاثة أرقام في كل حالة و المطلوب إيجاد الرقم الأصغر في كل مرة
 7 | 
 8 | 
 9 | **المعطيات** 
10 | 
11 | السطر الأول : عدد الحالات المراد المقارنة بينها
12 | 
13 | السطر الثاني :الأرقام المراد المقارنة بينها
14 |   
15 | **الجواب** 
16 | 
17 | إعطاء العدد الأصغر في كل حالة بينها فراغات
18 | 
19 | مثال :
20 | 
21 |     المعطيات :
22 |     
23 |     3
24 |     7 3 5
25 |     15 20 40
26 |     300 550 137
27 |     
28 |     الجواب :
29 |     
30 |     3 15 137
31 | 


--------------------------------------------------------------------------------
/zh/task-41.md:
--------------------------------------------------------------------------------
 1 | <!-- #Median of Three -->
 2 | 
 3 | 你可能已经解决了问题[Minimum of Three](./min-of-three) —— 它对你来说不是一个大的困扰？因为程序员应该提高他们的逻辑思
 4 | 维（不仅仅是编程语言的技能），让我们来改变任务以让它更加具有迷惑性。     
 5 | 
 6 | 你将会再次被给予三个数字，但是现在应该选择它们中间的数 —— 即不是最大值和最小值。这样的数字称为**中位数**（集合中，数
 7 | 组中等）。    
 8 | 
 9 | 当然，这个不是简单的"另一个愚蠢的练习" —— 例如它作为强大的快速排序算法的一部分被使用。     
10 | 
11 | **输入数据** 将会在第一行包含下面的三元组的数目。   
12 | 下面的每一行将会包含一个三元组。     
13 | **答案** 应该包含选出的三元组的中位数，并用空格分隔。    
14 | 
15 | 示例：
16 | 
17 |     数据：
18 |     3
19 |     7 3 5
20 |     15 20 40
21 |     300 550 137
22 | 	
23 | 	答案：
24 | 	5 20 300
25 | 
26 | 注意：如果你的程序有很多 if-else-if-else 语句，那么你可能做了一些错误的事情。简单的解法不应该包含有超过三个上述的语
27 | 句。    
28 | 


--------------------------------------------------------------------------------
/zh/task-6.md:
--------------------------------------------------------------------------------
 1 | 当程序处理包含小数部分的数字的时候，我们有时候会想 **约** 这样的数值到一个整数。我们将在接下来的一些问题中用到这
 2 | 个（例如，为了让结果简单一些），因此让我们来尝试下面这个专门的练习来学习这个技巧。      
 3 | 
 4 | 有几对数字。对于每一对数值，你将用第二个数值去除第一个数值，然后返回结果，约 **到最近的** 整数。  
 5 | 
 6 | 最为例子，当结果包含确切的`0.5`作为小数部分，值应该向上约去（即加上另外的`0.5`）。注意负数的"较大者"表示的是"靠近0"。
 7 | 参考维基百科上的页面[Rounding](http://en.wikipedia.org/wiki/Rounding#Round_half_up)来获得更透彻的解释。     
 8 | 
 9 | 在以后的任何问题中，当提到约数 —— 假定就是相同的约数算法（除非明确指定了其它的方法）。   
10 | 
11 | **输入数据** 将会在第一行给出测试用例的个数。  
12 | 接下来的每一行将会包含一个测试用例（即一对数值）。    
13 | **答案** 应该包含每一对的除运算和约数运算之后的结果，并且使用空格分开。         
14 | 
15 | 示例：
16 | 
17 | 	输入数据：
18 | 	3
19 | 	12 8
20 | 	11 -3
21 | 	400 5
22 | 	
23 | 	答案：  
24 | 	2 -4 80
25 | 


--------------------------------------------------------------------------------
/ar/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="summing two arrays"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | إذا كنت قد قمت بحل المشكلة السابقة فإن حل هذه المسألة سيكون موضوع سهل و سيحتاج لتعديلات بسيطة.
 7 | 
 8 | المعطيات الآن هي عبارة عن أزواج من الأرقام و نحن بحاجة لجمع كل زوج على حدا
 9 | 
10 | المعطيات السطر الأول يحتوي على عدد الأزواج المعطاة السطر الثاني يحتوي على الأرقام المراد جمعها( الجواب هو حاصل جمع كل زوج على حدا ويوضع فراغ بين الرقم و الآخر
11 | 
12 | مثال:
13 | 
14 |     المعطيات
15 |     3
16 |     100 8
17 |     15 245
18 |     1945 54
19 |     
20 |     الجواب
21 |     108 260 1999
22 | 


--------------------------------------------------------------------------------
/sk/task-30.md:
--------------------------------------------------------------------------------
 1 | Toto je celkom jednoduchá úloha - tak akurát, aby sme sa naučili pracovať s reťazcami (String).
 2 | 
 3 | **Vstupné dáta** budú obsahovať jeden reťazec malých písmen latinskej abecedy a pár medzier.  
 4 | **Odpoveď** by mala obsahovať reťazec rovnakej dĺžky s rovnakými znakmi ale v opačnom poradí.
 5 | 
 6 | Príklad:
 7 | 
 8 |     vstupné dáta:
 9 | 	four score and seven years ago
10 | 	
11 | 	odpoveď:
12 | 	oga sraey neves dna erocs ruof
13 | 
14 | Napriek tomu, že niektoré jazyky majú takéto funkcie vstavané, prosíme vás, aby ste to spravili podľa seba
15 | a 'po miestach' t.j. posúvaním znakov starého reťazca namiesto kopírovania ich do nového.
16 | 


--------------------------------------------------------------------------------
/ru/task-3.md:
--------------------------------------------------------------------------------
 1 | <!-- #Суммы в Цикле -->
 2 | Если вы уже разобрались с простыми циклами по задаче [Sum in Loop](./sum-in-loop),
 3 | то это упражнение будет её несложной модификацией.
 4 | 
 5 | Теперь нам даны несколько пар значений, и нужно посчитать сумму каждой пары.
 6 | 
 7 | **Входные данные** содержат в первой строке `N` - общее количество пар, которые нужно посчитать.  
 8 | Последующие `N` строк содержат по одной паре целых чисел каждая.  
 9 | **Ответ** должен содержать результаты, разделенные пробелами.
10 | 
11 | Пример:
12 | 
13 |     входные данные:
14 |     3
15 |     100 8
16 |     15 245
17 |     1945 54
18 |     
19 |     ответ:
20 |     108 260 1999
21 | 


--------------------------------------------------------------------------------
/ru/task-5.md:
--------------------------------------------------------------------------------
 1 | <!-- #Минимум из Трёх -->
 2 | Продолжим тренироваться с условными выражениями - напишем программу со сложными условиями. То есть одна
 3 | конструкция `if ... else` может быть заключена внутри другой и т.п.
 4 | 
 5 | Даны несколько троек чисел. Требуется выбрать наименьшее в каждой тройке.
 6 | 
 7 | **Входные данные** - первая строка указывает количество троек чисел.  
 8 | Каждая из следующих строк содержит одну такую тройку.  
 9 | **Ответ** должен содержать выбранные из каждой тройки минимумы, по порядку, через пробел.
10 | 
11 | Пример:
12 | 
13 |     входные данные:
14 |     3
15 |     7 3 5
16 |     15 20 40
17 |     300 550 137
18 |     
19 |     ответ:
20 |     3 15 137
21 | 


--------------------------------------------------------------------------------
/fr/task-5.md:
--------------------------------------------------------------------------------
 1 | Continuons la pratique des instructions conditionnelles: Nous allons écrire un programme avec une structure de conditions
 2 | un peu plus complexe; celui-ci aura deux `if ... else` imbriqués l'un dans l'autre.
 3 | 
 4 | Plusieurs triplets de valeurs vous serons fournis. Votre programme doit sélectionner la valeur minimale parmi les trois.
 5 | 
 6 | **Input data** Contient sur le première ligne le nombre `N` de triplets à traitrer.  
 7 | Les `N` lignes suivantes contiennent les triplets de valeurs.  
 8 | **Answer** Devra contenir les minimum de chaque triplets séparés par des espaces.
 9 | 
10 | Exemple:
11 | 
12 |     data:
13 |     3
14 |     7 3 5
15 |     15 20 40
16 |     300 550 137
17 |     
18 |     answer:
19 |     3 15 
20 | 


--------------------------------------------------------------------------------
/ar/task-41.md:
--------------------------------------------------------------------------------
 1 | من الأرجح أنك قمت بحل مسألة 
 2 | 
 3 | [العدد الأصغر](http://www.codeabbey.com/index/task_view/min-of-three--ar)
 4 | 
 5 | الآن سنجعل الموضوع يستحق العناء أكثر :
 6 | 
 7 | سيتم اعطاء ثلاثة أرقام في كل مرة و المطلو ب إيجاد الرقم الأوسط
 8 | 
 9 | نعني بالأوسط الأوسط قيمةً ليس الصغير ولا الكبير
10 | 
11 | 
12 | 
13 | **المعطيات**
14 | 
15 | السطر الأول عدد الحالات
16 | 
17 | باقي الأسطر في كل سطر ثلاثة أرقام مطلوب إيجاد الرقم الأوسط
18 | 
19 | **الجواب**
20 | 
21 | 
22 | 
23 | مثال:
24 | 
25 |     المعطيات :
26 |     3
27 |     7 3 5
28 |     15 20 40
29 |     300 550 137
30 |     
31 |     الجواب:
32 |     
33 |     5 20 300
34 | 
35 | ملاحظة : في حال احتوى حلك على العديد من العبارات الشرطية 
36 | فمن المرجح أن حلك ليس هو الحل الأمثل
37 | 


--------------------------------------------------------------------------------
/zh/task-8.md:
--------------------------------------------------------------------------------
 1 | 当我们谈到 **等差数列** （或者算术序列）时，就指的是一连串具特殊数字，这里面数字从前往后排列，后面的数字比前面的数字要大（每一步都是这样）。
 2 | 例如，第 `(K+1)` 个和第 `K` 个数值的差值是个常量。下面是个例子：
 3 | 
 4 |     1 2 3 4 5 6 7 ...
 5 |     4 6 8 10 12 14 16...
 6 |     10 13 16 19 22 25 28...
 7 | 
 8 | 这样的话，等差数列就可以说是由第一个数字(A)和增量值 -步长- (B)来定义的。序列（可以认为是自定义序列）前几位数字可以表示为
 9 | 
10 |     A + (A + B) + (A + 2B) + (A + 3B) + ...
11 | 
12 | 你的任务是计算出等差序列前N个值的和。[ Wikipedia page ][1]中关于等差数列的说明对于第一次遇到等差数列的人来说会有很大的帮助。
13 | 
14 | **输入数据：** 第一行包含测试案例的个数。
15 | 
16 | 其他行是具体的测试数据，数据以三个为一组 `A B N`，其中 `A` 是数列的第一个值， `B` 是公差， `N` 是指求等差数列的前N个值的和。
17 | 
18 | **答案：** 你需要为每个输入序列输出一个结果，用空格将结果隔开。
19 | 
20 | 例子：
21 | 
22 |     data:
23 |     2
24 |     5 2 3
25 |     3 0 10
26 | 
27 |     answer:
28 |     21 30
29 | 
30 | [1]: http://en.wikipedia.org/wiki/Arithmetic_progression


--------------------------------------------------------------------------------
/sk/task-5.md:
--------------------------------------------------------------------------------
 1 | Aby sme mali viac praxe s podmienenými výorkmi napíšeme program, ktorý používa komplexnú podmienku.
 2 | T.j. jeden `if ... else` výrok by mohol (aj by mal byť) vnorený vnútri iných `if ... else` na splnenie úlohy.
 3 | 
 4 | Poskytnutých je niekoľko trojíc čísel. Vašou úlohou je zvoliť najmenšie z
 5 | trojice čísel.
 6 | 
 7 | **Vstupné dáta** budú obsahovať v prvom riadku počet trojíc.  
 8 | Každý ďalší riadok bude obsahovať trojicu čísel. 
 9 | **Odpoveď** by mala obsahovať najmenšie číslo z trojice, oddelené medzerami.
10 | 
11 | Príklad:
12 | 
13 |     dáta:
14 |     3
15 |     7 3 5
16 |     15 20 40
17 |     300 550 137
18 |     
19 |     odpoveď:
20 |     3 15 137
21 | 
22 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
23 | 


--------------------------------------------------------------------------------
/zh/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/min_of_two.gif" alt="Choosing minimum animation"/>
 3 | </div>
 4 | 
 5 | 很多程序应该能够做一些选择和决断。我们将要练习包含条件的程序。    
 6 | 它通常通过`if...else`语句来完成，就像下面这样:   
 7 | 
 8 |     IF some_condition THEN
 9 | 	    do_something
10 | 	ELSE
11 | 	    do_other_thing
12 | 	ENDIF
13 | 
14 | 不同的程序设计语言语法会有一些不同，并且`else`部分几乎总是可选的。你可以读维基百科上的文章
15 | [Conditional statements][cond]来获取更多内容。     
16 | 
17 | [cond]: http://en.wikipedia.org/wiki/Conditional_(computer_programming)
18 | 
19 | 请从两个数中选择一个最小的值。会有几对数值用于测试。   
20 | 
21 | **输入数据** 将会在第一行包含测试用例的个数。     
22 | 接下来的每一行都会包含一对数值用于比较     
23 | 对于**答案**，请输入相同数量的最小值，并用空格分隔。例如：    
24 | 
25 |     数据：
26 |     3
27 |     5 3
28 |     2 8
29 |     100 15
30 |     
31 |     答案：
32 |     3 2 15
33 | 


--------------------------------------------------------------------------------
/zh/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="demo of summing an array" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | 现在我们的目标是学习**循环**——即重复动作。让我们来寻找几个数的和（多于两个数）。在一个循环中完成这个操作是有用的。正如上方的图片所展示的那样——你可以创建一个变量`sum`，然后将列表中的每一个值加到它上面。或许["for"循环](http://en.wikipedia.org/wiki/For_loop)会很合适，因为数字的个数是预先就知道的。               
 6 | 
 7 | 如果你有困难，可以先尝试[Sums In Loop](./sums-in-loop) —— 它可能会简单一些。           
 8 | 
 9 | **输入数据**的格式如下:       
10 | 
11 | - 第一行包含`N` ——  要求和的值的总数     
12 | - 第二行包含 `N` 个所要求和的数。      
13 | 
14 | **答案**应该是一个单个的值 —— `N`个数的总和   
15 | 
16 | 例子：  
17 | 
18 | 	输入数据:     
19 | 	8
20 | 	10 20 30 40 5 6 7 8
21 | 	
22 | 	答案:  
23 | 	126
24 | 
25 | **注意**，因为输入数据会有几十个数字，你不应该手动将它们复制到你的程序中，而应该使你的程序能够从标准输入读取它们（这样你就可以一次将它们全部复制）。注意，如果你在我们的服务器上运行代码，为了方便，数据会自动复制到标准输入。  
26 | 


--------------------------------------------------------------------------------
/ru/task-30.md:
--------------------------------------------------------------------------------
 1 | <!-- #Обращение Строк -->
 2 | Переворот строки - очень простая задача - для тех кто начинает изучать текстовые строки...
 3 | 
 4 | **Входные данные** содержат одну строку из латинских букв и пробелов.  
 5 | **Ответ** должен содержать строку такой же длины, но с символами в обратном порядке.
 6 | 
 7 | Пример:
 8 | 
 9 |     входные данные:
10 |     four score and seven years ago
11 |     
12 |     ответ:
13 |     oga sraey neves dna erocs ruof
14 | 
15 | **Внимание** хотя некоторые языки имеют готовую встроенную функцию для обращения строки, пожалуйста, попытайтесь
16 | реализовать алгоритм самостоятельно - т.е. рассматривая строку как массив символов, и оперируя с ними "на месте",
17 | переставляя их некоторым образом - а не создавая новую строку (не выделяя дополнительной памяти).
18 | 


--------------------------------------------------------------------------------
/ar/task-20.md:
--------------------------------------------------------------------------------
 1 | للتعريف بكيفية التعامل مع الحروف حاول أن تحل هذه المسألة.
 2 | 
 3 | سوف يتم إعطاء نص باللغة الإنكليزية , المطلوب عدَ الأحرف الصوتية في كل سطر
 4 | 
 5 | ( `a, o, u, i, e, y`)
 6 | 
 7 | يجب الأخذ بالإعتبار بأن الأحرف الصوتية 5 أحرف ولكن تم إعتبارها 6 لأسباب تتعلق بهذه المسألة
 8 | 
 9 | *هذه المسألة تعتبر تمهيداً لحل غيرها من المسائل كمسألة  
10 | كسر شيفرة القيصر*
11 | 
12 | **المعطيات**
13 | 
14 | السطر الأول : عدد الحالات المطلوب علاجها
15 | 
16 | بقية الأسطر باللغة الإنكيليزية و المطلوب إيجاد الحروف الصوتية في كل سطر منها
17 | 
18 | **الجواب**
19 | عددالأحرف الصوتية في كل سطر مفصولة بفراغات فيما بينها
20 | 
21 | مثال :
22 | 
23 |     المعطيات :
24 |     4
25 |     abracadabra
26 |     pear tree
27 |     o a kak ushakov lil vo kashu kakao
28 |     my pyx
29 |     
30 |     الجواب :
31 |     5 4 13 2
32 | 


--------------------------------------------------------------------------------
/sk/task-50.md:
--------------------------------------------------------------------------------
 1 | <!-- #Palindrómy -->
 2 | Slovo, alebo celá fráza, ktoré sú rovnaké spredu aj zozadu sa nazýva  **Palindróm**. Tu sú nejaké
 3 | príklady:
 4 | 
 5 |     Stats
 6 | 	Amore, Roma
 7 | 	No 'x' in Nixon
 8 | 	Was it a cat I saw?
 9 | 
10 | Ako môžete vidieť, veľkosť písmen sa ignoruje, takisto ako aj medzery a interpunkcia.
11 | 
12 | Vašou úlohou v tomto cvičení, je určiť, či je daná fráza palindróm alebo nie.
13 | 
14 | **Vstupné dáta** obsahujú počet fráz v prvom riadku.  
15 | V každom ďalšom riadku je samotná fráza.  
16 | **Odpoveď** by mala mať jedno písmeno (oddelené medzerami) pre každú frázu: `Y` ak je to palindróm `N` ak nie.
17 | 
18 | Príklad:
19 | 
20 |     vstupné dáta:
21 | 	3
22 | 	Stars
23 | 	O, a kak Uwakov lil vo kawu kakao!
24 | 	Some men interpret nine memos
25 | 	
26 | 	odpoveď:
27 | 	N Y Y
28 | 


--------------------------------------------------------------------------------
/de/task-30.md:
--------------------------------------------------------------------------------
 1 | Eine recht einfache Aufgabe - nur um mit dem Umgang von Strings (Zeichenketten) zu beginnen...
 2 | 
 3 | **Eingabe Daten** enthalten einen einzelnen String bestehend aus kleinen lateinischen Buchstaben und ein paar Leerzeichen.  
 4 | Die **Answer** soll einen gleichlangen String mit denselben Zeichen erhalten, jedoch in umgekehrter Reihenfolge.
 5 | 
 6 | Beispiel:
 7 | 
 8 |     Eingabe Daten:
 9 |     vier spielstand und sieben jahre zuvor
10 |     
11 |     answer:
12 |     rovuz erhaj nebeis dnu dnatsleips reiv
13 | 
14 | Auch wenn einige Sprachen, insbesondere funktionale, eine eingebaute Funktion dafür haben, versuchen Sie bitte, die Aufgabe selber zu lösen. Genauer 
15 | gesagt im "selben" String, also durch Verschieben von Zeichen der gleichen Zeichenkette und nicht durch Kopieren der Zeichen in eine neue Zeichenkette.
16 | 


--------------------------------------------------------------------------------
/zh/task-7.md:
--------------------------------------------------------------------------------
 1 | <!-- #Fahrenheit to Celsius -->
 2 | 这个编程练习与在循环中计算总和大致相同，但是这个需要稍微多一点的计算。       
 3 | 
 4 | <div class="text-center">
 5 | 	<img alt="fahrenheit and celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 6 | </div>
 7 | 
 8 | *注意：在[Rounding](./rounding--zh)问题中解释的约数算法会在这个任务中被用到。*   
 9 | 
10 | 有两个被广泛使用的测量温度的系统 —— 摄氏度和华氏度。第一个在欧洲相当流行，第二个使用也很广泛，例如在美国。  
11 | 
12 | 使用摄氏温度计测量水的冰点温度为0度，沸腾温度为100度。使用华氏温度计测量水的冰点温度为32度，沸腾温度为212度。你
13 | 可以从[wikipedia on Fahrenheit][wiki]来了解更多。使用这两个点来转换两种温度。   
14 | 
15 | [wiki]: http://en.wikipedia.org/wiki/Fahrenheit
16 | 
17 | 你将要编写程序来将华氏度转换为摄氏度。   
18 | 
19 | **输入数据** 包含`N+1`个值，第一个是N自己（**注意**你不应该转换它）。    
20 | **答案** 应该包含确切的`N`个结果，约到最近的整数，并使用空格分隔。  
21 | 
22 | 示例：
23 | 
24 |     数据：
25 |     5 495 353 168 -39 22
26 |     答案：
27 |     257 178 76 -39 -6
28 | 
29 | *请注意，第一个`5`不是温度，而是要转换的值的个数！*    
30 | 


--------------------------------------------------------------------------------
/fr/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="sommation de deux tableaux"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | Si vous avez déjà appris comment programmer une simple boucle dans la tâche [Sum in Loop][prevtask],
 7 | cet exercise ne sera qu'une simple modification.
 8 | 
 9 | [prevtask]: ./sum-in-loop
10 | 
11 | On nous fourni maintenant plusieurs paires de valeurs et nous désirons calculer la somme de chaque paire.
12 | 
13 | **Input data** Contient le nombre de paires à traiter sur la première ligne.  
14 | Les lignes suivantes contiennent les paires de valeurs; une paire par ligne.  
15 | **Answer** doit contenir les sommes séparées par des espaces.
16 | 
17 | Exemple:
18 | 
19 |     data:
20 |     3
21 |     100 8
22 |     15 245
23 |     1945 54
24 |     
25 |     answer:
26 |     108 260 1999
27 | 


--------------------------------------------------------------------------------
/zh/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="centered hint">
 2 | 	<img alt="CodeAbbey Monks struggle with bug" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 3 | 	<span>艺术家眼中的程序员与Bug的斗争.</span><br/>
 4 | 	<span>注意，合适的工具可能会有用！</span>
 5 | </div>
 6 | 
 7 | 万事开头难，让我们先来尝试最简单的问题。
 8 | 这个问题的目标是练习提交答案。    
 9 | 
10 | 我们需要计算两个数的和，然后告诉结果。虽然你可以手动地计算出它们，但是尝试用任意一种你知道的，或你喜欢的，或者你
11 | 想要学习的语言来写一个程序。     
12 | 
13 | _[这个视频](http://www.youtube.com/watch?v=gxfqeDm-B6k) 进一步描述了操作的步骤._
14 | 
15 | ###如何提交解法
16 | 
17 | 如果你已经登录，你将会看到下面的区域:  
18 | 
19 | - **测试数据** 包含 "输入数据" 或者 "测试用例" - 两个我们想要求和的数字。
20 | - **你的答案** - 在那里放置你处理测试数据后的结果。
21 | - **你的解法** - 在那里保存你的代码。它不会被检查
22 |     (至少不会自动这样), 但是它会帮助你在下一个任务中能够重新使用你的代码。
23 |     你可以在任何时候重新查看你在这个任务中提交的解法。
24 | 
25 | 例子:
26 | 
27 | 	输入数据:
28 | 	3 5
29 | 	
30 | 	答案:
31 | 	8
32 | 
33 | 我们提供了几种流行的语言的[样例](../wiki/running),
34 | 但是我们强烈建议你不要在解决了这个问题之前浏览他们。:)
35 | 


--------------------------------------------------------------------------------
/es/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="summing two arrays"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | Si ya aprendiste a cómo escribir un programa con un bucle sencillo en la tarea [Sum in Loop][prevtask],
 7 | este nuevo ejercicio será sólo una ligera modificación.
 8 | 
 9 | [prevtask]: ./sum-in-loop
10 | 
11 | Ahora se nos dan varios pares de valores y queremos calcular la suma de cada par.  
12 | 
13 | Los **datos de entrada** contendrán en la primera línea la cuenta total de los pares a procesar.  
14 | Las siguientes contendrán los pares propiamente - un par en cada línea.  
15 | La **respuesta** debería contener los resultados separados por espacios.
16 | 
17 | Ejemplo:
18 | 
19 |     datos:
20 |     3
21 |     100 8
22 |     15 245
23 |     1945 54
24 |     
25 |     respuesta:
26 |     108 260 1999
27 | 


--------------------------------------------------------------------------------
/ro/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="summing two arrays"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | Dacă deja ai învațat cum să rezolvi problema precedentă [Sum in Loop][prevtask], folosind o buclă simplă, atunci această nouă problemă presupune doar o mică modificare a acelui program.
 7 | 
 8 | [prevtask]: ./sum-in-loop
 9 | 
10 | Pentru fiecare pereche de numere de mai jos, sarcina ta este să calculezi suma lor.
11 | 
12 | **Datele de intrare** conțin pe prima line -  numarul total de perechi.  
13 | Următoarele linii conțin perechile de numere propriu-zise.  
14 | **Răspunsul** ar trebui să conțină rezultatele pentru fiecare pereche, separate prin spațiu.
15 | 
16 | 
17 | Exemplu:
18 | 
19 |     Date de intrare:
20 |     3
21 |     100 8
22 |     15 245
23 |     1945 54
24 |     
25 |     Răspuns:
26 |     108 260 1999
27 | 


--------------------------------------------------------------------------------
/zh/task-28.md:
--------------------------------------------------------------------------------
 1 | 让我们来将编程技能运用到准科学问题上 —— 因为只学习抽象的东西有些枯燥。    
 2 | 
 3 | 测量身体体质的一个简单的方法在十九世纪中叶被提出来。它只取决于一个人的身高和体重 —— 它被称为 **Body Mass Index** 或
 4 | 者 **BMI**.它被定义为:       
 5 |     
 6 |     BMI = weight / height^2
 7 | 其中体重以`千克`为单位，身高以`米`为单位。     
 8 | 
 9 |    四个通常的的等级被提出来：    
10 | 
11 | 
12 | 	Underweight     -           BMI < 18.5
13 | 	Normal weight   -   18.5 <= BMI < 25.0
14 | 	Overweight      -   25.0 <= BMI < 30.0
15 | 	Obesity         -   30.0 <= BMI
16 | 
17 | 例如，如果我的体重是`80kg`，身高是`1.73m`,那么我可以计算:        
18 | 
19 |     BMI = 80 / (1.73)^2 = 26.7
20 | 
21 | 即有点超重。    
22 | 
23 | 我们将不会讨论这个级别是否正确。相反，你应该简单的计算几个人的等级。          
24 | 
25 | **输入数据** 在第一行包含人数。    
26 | 其它行将会在每一行包含两个数 —— 以千克为单位的体重和以米为单位的身高。   
27 | **答案** 对于每一个测试用例应该包含单词`under`,`normal`,`over`,`obes`，并使用空格分开。示例 ：            
28 | 
29 |     输入数据:
30 | 	3
31 | 	80 1.73
32 | 	55 1.58
33 | 	49 1.91
34 | 	
35 | 	答案:
36 | 	over normal under
37 | 


--------------------------------------------------------------------------------
/ru/task-20.md:
--------------------------------------------------------------------------------
 1 | <!-- #Подсчёт Гласных -->
 2 | Эта простая задача познакомит нас с обработкой текстовых строк. Вам даны несколько строчек текста - и для каждой
 3 | из них требуется подсчитать количество гласных (т.е. букв `a, o, u, i, e, y`).
 4 | 
 5 | *Несмотря на простоту этот принцип важен, к примеру, в алгоритмах взлома шифров. Вы можете посмотреть задачу
 6 | [Caesar Cipher Cracker](./caesar-cipher-cracker) чтобы убедиться в этом.*
 7 | 
 8 | **Входные данные** - в первой строке указано количество строк подлежащих обработке.  
 9 | Дальше следуют сами строки, состоящие только из маленьких английских (латинских) букв и пробелов.  
10 | **Ответ** должен содержать количество гласных для каждой строки.
11 | 
12 | Пример:
13 | 
14 |     входные данные:
15 |     4
16 |     abracadabra
17 |     pear tree
18 |     o a kak ushakov lil vo kashu kakao
19 |     my pyx
20 |     
21 |     ответ:
22 |     5 4 13 2
23 | 


--------------------------------------------------------------------------------
/de/task-5.md:
--------------------------------------------------------------------------------
 1 | Damit wir noch mehr Übung mit "Bedingte Anweisungen und Verzweigungen" bekommen, werden wir nun ein Programm 
 2 | mit etwas komplexeren Bedingungen schreiben. Beispielsweise können (und sollten) `if ... else` statements auch ineinander verschachtelt sein,
 3 | um dieses Problem zu lösen.
 4 | 
 5 | Dieses Mal erhalten wir mehrere Triplets von Zahlen. Unsere Aufgabe ist es auch nun wieder, jeweils die kleinste Zahl eines Triplets zu bestimmen. 
 6 | 
 7 | **Eingabe Daten** enthalten in der ersten Zeile die Anzahl der zur Verarbeitung gegebenen Zahlen-Triplets. 
 8 | Die nachfolgenden Zeilen enthalten jeweils pro Zeile ein Triplet.  
 9 | **Lösung** soll wieder eine Reihe bestehend aus jeweils den kleinsten Werten getrennt durch Leerzeichen sein.
10 | 
11 | Beispiel:
12 | 
13 |     Daten:
14 | 	3
15 |     7 3 5
16 |     15 20 40
17 |     300 550 137
18 |     
19 |     Lösung:
20 |     3 15 137
21 | 


--------------------------------------------------------------------------------
/sk/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="summing two arrays"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | Ak ste sa už naučili ako napísať program s jednoduchým cyklom z [Sum in Loop][prevtask] úlohe,
 7 | toto nové cvičenie bude iba jednoduchá úprava.
 8 | 
 9 | [prevtask]: ./sum-in-loop
10 | 
11 | Teraz sme dostali niekoľko párov hodnôt a chceme spočítať sumu pre každý pár.  
12 | 
13 | **Vstupné dáta** budú obsahovať celkový počet párov na spracovanie v prvom riadku.
14 | Nasledujúce riadky budú obsahovať samotné páry - jeden pár v každom riadku.  
15 | **Odpoveď** by mala obsahovať výsledok oddelený medzerami.
16 | 
17 | Príklad:
18 | 
19 |     dáta:
20 |     3
21 |     100 8
22 |     15 245
23 |     1945 54
24 |     
25 |     odpoveď:
26 |     108 260 1999
27 | 
28 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
29 | 


--------------------------------------------------------------------------------
/de/task-3.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/sums_in_loop.gif" alt="Zwei Arrays aufsummieren"/>
 3 | </div>
 4 | <br/>
 5 | 
 6 | Falls Sie schon wissen, wie man Programme mit einfachen Schleifen schreibt, z.B. 
 7 | von der Übungsaufgabe [Sum in Loop](./sum-in-loop), wird diese neue Aufgabe nur eine kleine Abwandlung davon sein.
 8 | 
 9 | Denn nun erhalten wir mehrere Paare von Zahlen, welche wir jeweils miteinander addieren wollen. 
10 | 
11 | **Eingabe Daten** enthält in der ersten Zeile die Anzahl der Zahlen-Paare, welche zu verarbeiten sind.   
12 | Die nachfolgenden Zeilen enthalten die Zahlenpaare selbst. Pro Zeile nur ein Paar.  
13 | **Lösung** sollte jeweils durch Leerzeichen getrennt die Summe jedes Zahlenpaares enthalten. 
14 | 
15 | Beispiel:
16 | 
17 |     Daten:
18 |     3
19 |     100 8
20 |     15 245
21 |     1945 54
22 |     
23 |     Lösung:
24 |     108 260 1999
25 | 


--------------------------------------------------------------------------------
/es/task-30.md:
--------------------------------------------------------------------------------
 1 | <!-- #Invertir una Variable de Texto -->
 2 | Una tarea bastante simple: solo para empezar a aprender sobre variables de texto o 'strings'...
 3 | 
 4 | Los **datos de entrada** contendrán una sola variable con letras latinas minúsculas y algunos espacios.
 5 | La **respuesta** debe contener una cadena de la misma longitud con los mismos caracteres, pero en orden inverso.
 6 | 
 7 | Ejemplo:
 8 | 
 9 |     datos de entrada:
10 |     four score and seven years ago
11 |     
12 |     respuesta:
13 |     oga sraey neves dna erocs ruof
14 | 
15 | Aunque algunos lenguajes, especialmente los funcionales, tienen una función incorporada para hacer esto, intenta realizarlo por tu cuenta y 
16 | 'en el lugar' (también conocido como 'in-place' en inglés), es decir, moviendo los caracteres de la misma variable de texto (string) en lugar de copiarlos a una nueva.
17 | 
18 | _translated by [Alan Garcia](/index/user_profile/st-allan)_


--------------------------------------------------------------------------------
/es/task-50.md:
--------------------------------------------------------------------------------
 1 | <!-- #Palindrome -->
 2 | La palabra o frase completa la cual tiene la misma secuencia de letras en ambas direcciones es llamada **palindrome**. Aqui hay
 3 | unos ejemplos:
 4 | 
 5 |     Stats
 6 | 	Amore, Roma
 7 | 	No 'x' in Nixon
 8 | 	Was it a cat I saw?
 9 | 
10 | Como puedes ver, las mayusculas son tomadas como minusculas. Espacios y puntuacion son ignorados.
11 | 
12 | Tu meta en este ejercicio de programacion es determinar, si la frase representa un palindrome o no.
13 | 
14 | **Datos de Entrada** En la primera linea, contiene el numero de frases.
15 | Las siguientes lineas contienen una frase cada una.
16 | **Respuesta** debe tener una sola letra (separada por espacio) para cada frase: `Y` si es un palindrome y `N` si no.
17 | 
18 | Ejemplo:
19 | 
20 |     datos de entrada:
21 | 	3
22 | 	Stars
23 | 	O, a kak Uwakov lil vo kawu kakao!
24 | 	Some men interpret nine memos
25 | 	
26 | 	respuesta:
27 | 	N Y Y
28 | 


--------------------------------------------------------------------------------
/zh/task-43.md:
--------------------------------------------------------------------------------
 1 | <!-- #Dice Rolling -->
 2 | 当编程板或者角色扮演游戏时，很多初学者经历了将随机值转换成特定的骰子点数的麻烦。这个任务的目标是进行一个模拟投掷骰子的练习，
 3 | 并由一个随机数生成器来产生点数。                            
 4 | 
 5 | 设想我们有一个可以产生`0`（包含）到`1`（不包含）随机值的生成器 —— 这个可以用**Basic**,**Java**,**Matlab**等语言来完成。       
 6 | 
 7 | 我们想要将这些浮点值转换为6个**整数**数字:从`1`到`6`。这个可以通过下面的步骤来实现:          
 8 | 
 9 | 1. 将随机数乘以我们想要的不同数值的个数N —— 在这里我们乘以`6`，之后结果就会在`0`（包括）到`6`（不包括）之间。
10 | 2. 现在让我们来取出结果的整数部分（调用像`floor`这样的函数或者转换为`int`）—— 值将会是`0`，`1`，`2`，`3`，`4`，`5`中的一个，
11 | 并且可能性相同。
12 | 3. 因为我们需要从`1`到`6`的数值，让我们简单地将`1`加到结果中去。
13 | 
14 | 现在你将会被给出几个在`[0..1)`范围内的数字（它们是由随机数生成器给出的）—— 你应该应用上面的算法将它们转换为骰子的点数。           
15 | 
16 | **输入数据** 将会在第一行包含需要转换的值的数目。      
17 | 其他行将会在每一行包含一个值 ，形如`0.142857`     
18 | **答案** 应该包含将输入数据转换为`1`到`6`的值，它们由讨论过的算法产生。    
19 | 
20 | 示例：
21 | 
22 | 	数据：
23 | 	6
24 | 	0.59558786964
25 | 	0.861037873663
26 | 	0.385597702116
27 | 	0.246237673331
28 | 	0.808033385314
29 | 	0.0544673665427
30 | 	
31 | 	答案：
32 | 	4 6 3 2 5 1
33 | 


--------------------------------------------------------------------------------
/zh/task-63.md:
--------------------------------------------------------------------------------
 1 | 算术基本定理这样说过 **任意整数都可以拆解成一个或多个素数的乘积，而且这种表示是唯一的**，例如：
 2 | 
 3 |     1000 = 2 * 2 * 2 * 5 * 5 * 5
 4 |     1001 = 7 * 11 * 13
 5 |     1002 = 2 * 3 * 167
 6 |     1003 = 17 * 59
 7 |     1009 = 1009
 8 | 
 9 | *这里，我们将 `1009` 视为仅有一个值表示的单一案例 - 这个值就是它本身！*
10 | 
11 | 目前还不清楚是否可以有效地对大整数进行快速因式分解。比如有一个由 `200` 个素数（即只拥有 `400` 个数字）乘积而来数字，使用现代计算机将其分解成素数的乘积需要上千年的时间才能完成。
12 | 
13 | 当然，这个重要的事实在密码学中具有重要意义。如果一旦发现了高效的算法，那么如今流行的很多加密方法会立即变得不安全！典型的例子就是 **RSA** 算法，你可以从 [专项练习](https://www.codeabbey.com/index/task_view/rsa-cryptography) 和其他任务中进行深入学习。
14 | 
15 | ## 问题描述
16 | 
17 | 你将会接收一系列数字（不是很大，所以不必害怕）并将它们分解成素数的乘积。
18 | 
19 | **输入数据** 第一行表示要分解的整数的个数。
20 | 
21 | 接下来的每行包含一个要被分解的整数（长度不会超过 `13`）。
22 | 
23 | **答案** 需要显示进行因式分解后的素数的乘积，显示方式可以像 `p1*p2*p3`，其中 `p1 ... p3` 以非递减的顺序显示。各个乘积的表示之间用空格分隔。
24 | 
25 | 举个栗子：
26 | 
27 |     input data:
28 |     5
29 |     1000
30 |     1001
31 |     1002
32 |     1003
33 |     1009
34 | 
35 |     answer:
36 |     2*2*2*5*5*5 7*11*13 2*3*167 17*59 1009


--------------------------------------------------------------------------------
/zh/task-11.md:
--------------------------------------------------------------------------------
 1 | 此编程练习旨在向您介绍数字系统的基础知识，我们从每天都在使用的十进制系统（尽管你需要记住的是计算机并不在内部直接使用十进制，只有向人展示时才会转换成十进制）开始学习数字系统的概念。
 2 | 
 3 | 数字一旦大于9，就要用多个数字来表示，我们也可以计算出这些数字的总和。比如，对于1492和1776这两个数字，对每位数字求和：
 4 | 
 5 |     1 + 4 + 9 + 2 = 16
 6 |     1 + 7 + 7 + 6 = 21
 7 | 
 8 | 本次任务中，您将获得多个数字并要求计算它们的数字总和。
 9 | 
10 | **重要：**尽管很多编程语言中都有内置函数来将数字转换成字符串（从中可以提取数据），你不应该使用这些内置函数（因为你的目的是学习写编程技巧）。
11 | 
12 | **相反**你应该使用多次除10（数字系统的基础）的方式来实现这个这个算法，然后把余数加起来。阅读[Number to digits][1]这篇文章来获取算法的详细信息。
13 | 
14 | ## 问题描述
15 | 
16 | **输入数据**的格式如下：
17 | 
18 | - 第一行包含一个数字N - 本次程序的数据量
19 | 
20 | - 然后N行数据将对每行3个数据A B C进行计算后得到一个结果。
21 | 
22 | - 在每行计算中，你需要将A乘以B然后加上C（也就是A * B + C） - 然后将计算结果的每一位数字进行求和。
23 | 
24 | **答案**应该包含N个数据，并且用空格区分开来，比如：
25 | 
26 |     input data:
27 |     3
28 |     11 9 1
29 |     14 90 232
30 |     111 15 111
31 | 
32 |     answer:
33 |     1 16 21
34 | 
35 | 那第一行数据为例，11 * 9 + 1 = 100，而且100的每位数字之和就是1+0+0=1.
36 | 
37 | 
38 | [1]: https://www.codeabbey.com/index/wiki/number-to-digits


--------------------------------------------------------------------------------
/sk/task-13.md:
--------------------------------------------------------------------------------
 1 | Tento program sa podobá na komplexnejšie algoritmy pre výpočet CRC a iných kontrolných súčtov a tiež hash-funkcií na
 2 | písmena reťazcov. Okrem toho vám poskytne ďalšie cvičenie pre rozdeľovanie hodnôt na čísla. Pred touto úlohou
 3 | by ste možno chceli skúsiť najprv [Sum of Digits.](./sum-of-digits)
 4 | 
 5 | Poďme vypočítať ciferný súčet, tak ako predtým, ale násobením každej číslice jej pozíciou (počítaním zľava, začneme
 6 | od 1). Napríklad, pre hodnotu `1776` spočítame  **vážený** ciferný súčet (túto funkciu nazveme "wsd") pre:
 7 | 
 8 | 	wsd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60
 9 | 
10 | **Vstupné dáta** bude počet príkladov v prvom riadku.  
11 | Samotné hodnoty sú v druhom riadku. Vašou úlohou je
12 | vypočítať vážený ciferný súčet pre každú hodnotu.  
13 | **Odpoveď:** ako zvyčajne, výsledky oddelené medzerami vypíšte do riadku.
14 | 
15 | Príklad:
16 | 
17 |     vstupné dáta:
18 |     3
19 |     9 15 1776
20 |     
21 |     odpoveď:
22 |     9 11 60
23 | 


--------------------------------------------------------------------------------
/es/task-5.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <iframe width="420" height="315" src="//www.youtube.com/embed/ZrUBwbEfN8I" frameborder="0" allowfullscreen></iframe>
 3 | <div class="hint">Puedes mirar este video para obtener una explicación.</div>
 4 | </div>
 5 | 
 6 | Para tener más práctica con las expresiones condicionales, vamos a escribir un programa que usa condiciones complejas,
 7 | ej.: Una expresión `si ... sino` podría (y debería) estar anidada dentro de otra para resolver este problema.
 8 | 
 9 | Varios tríos de números te serán dados. Tu tarea es seleccionar los mínimos para cada trío.
10 | 
11 | Los **Datos de entrada** contendrán en la primera línea el número de tríos a evaluar.  
12 | Cada una de las líneas siguientes contendrá un trío.
13 | La **Respuesta** debería contener los mínimos que seleccionaste de los tríos, separados por espacios.
14 | 
15 | Ejemplo:
16 | 
17 |     datos de entrada:
18 | 	3
19 |     7 3 5
20 |     15 20 40
21 |     300 550 137
22 |     
23 |     respuesta:
24 |     3 15 137
25 | 


--------------------------------------------------------------------------------
/sk/task-9.md:
--------------------------------------------------------------------------------
 1 | <!-- #Triangles -->
 2 | Trojuholník je objekt zložený z troch segmentov (strán), spojený koncami.
 3 | [Wikipédia][wiki] poskytne detailnejšie vysvetlenie.  
 4 | Ak máme tri riadky segmentov s dĺžkami `A B C` - tak buď môžeme s nimi poskladať trojuholník  
 5 | (napríklad s `3 4 5` alebo `3 4 7` - aj keď tento je s nulovým obsahom) alebo je to nemožné  
 6 | (napríklad `1 2 4`).
 7 | 
 8 | [wiki]: https://sk.wikipedia.org/wiki/Trojuholn%C3%ADk
 9 | 
10 | Poskytnutých je niekoľko trojíc hodnôt reprezentujúce dĺžku strán trojuholníka.
11 | Vašou úlohou je rozhodnúť o tom či sa z trojice hodnôt dá poskladať trojuholník alebo nie.
12 | 
13 | **Vstupné dáta:** Prvý riadok obsahuje počet trojíc.  
14 | Ďalšie riadky obsahujú samotné trojíc (jedna trojica na každý riadok).  
15 | **Odpoveď:** Bude `1` alebo `0` pre každú trojicu (`1` ak sa trojuholník
16 | dá poskladať a `0` ak nie).
17 | 
18 | Príklad:
19 | 
20 |     dáta:
21 |     2
22 |     3 4 5
23 |     1 2 4
24 |     
25 |     odpoveď:
26 |     1 0
27 | 


--------------------------------------------------------------------------------
/ro/task-20.md:
--------------------------------------------------------------------------------
 1 | <!-- #Vowel Count -->
 2 | Această problemă este un prim pas către manipularea și procesarea șirurilor de caractere. Pentru fiecare linie de text, sarcina ta va fi să afli numărul total de vocale (literele `a, o, u, i, e, y`). **Notă** litera `y` este considerată drept vocală în cadrul acestei probleme.
 3 | 
 4 | *Deși simplă, această tehnică este importantă in cadrul unor probleme de tip criptografic. Pentru mai multe detalii, consultă problema [Caesar Cipher Cracker](./caesar-cipher-cracker).*
 5 | 
 6 | **Datele de intrare** conțin pe prima linie, numărul total de linii de text.  
 7 | Următoarele linii conțin liniile de text propriu-zise.  
 8 | Liniile de text conțin doar litere mici ale alfabetului latin și spații.  
 9 | **Răspunsul** ar trebui să conțină numărul de vocale pentru fiecare linie, separate prin spațiu.
10 | 
11 | Exemplu:
12 | 
13 | 	Date de intrare:
14 | 	4
15 | 	abracadabra
16 | 	pear tree
17 | 	o a kak ushakov lil vo kashu kakao
18 | 	my pyx
19 | 	
20 | 	Răspuns:
21 | 	5 4 13 2
22 | 


--------------------------------------------------------------------------------
/de/task-50.md:
--------------------------------------------------------------------------------
 1 | Worte oder Sätze die vorwärts- und rückwärtsgelesen denselben Sinn ergeben, werden als **Palindrom** 
 2 | bezeichnet. Hier sind einige Beispiele:
 3 | 
 4 |     Stats
 5 |     Amore, Roma
 6 |     No 'x' in Nixon
 7 |     Was it a cat I saw?
 8 | 
 9 | Wie man sieht, wird hier die Gross- und Kleinschreibung nicht beachtet. Ebenso werden
10 | Leer- und Satzeichen ignoriert.
11 | 
12 | Ihr Ziel in dieser Programmierübung ist es, zu bestimmen, ob es sich bei diesen Sätzen um ein
13 | Palindrom handelt oder nicht.
14 | 
15 | **Eingabedaten:** Die erste Zeile gibt die Anzahl der prüfenden Sätze an. Alle weiteren
16 | Zeilen enthalten die mutmasslichen Palindrome.
17 | 
18 | **Lösung:** Handelt es sich nun um ein Palindrom, wird ein 'Y' geschrieben; sonst ein 'N'. Die 
19 | einzelnen Zeichen werden mit einem Leerzeichen getrennt.
20 | 
21 | Beispiel:
22 |     
23 |     Eingabedaten:
24 |     3
25 |     Stars
26 |     O, a kak Uwakov lil vo kawu kakao!
27 |     Some men interpret nine memos
28 |     
29 |     Antwort:
30 |     N Y Y
31 | 


--------------------------------------------------------------------------------
/ar/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="demo of summing an array" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 |  
 5 | الهدف الآن هو تعلم الحلقات  أي تكرار العمل نفسه عدة مرات
 6 | المطلوب إيجاد حاصل جمع مجموعة من الأرقام , سيكون من المفيد استخدام الحلقات كما توضح الصورة المرفقة أعلاه
 7 |  استخدم متغير بإسم`وقم بإضافة كل رقم لهذا المتغير
 8 | فد تفي حلقة "فور" بالغرض
 9 | 
10 | 
11 | ["for" loop](http://en.wikipedia.org/wiki/For_loop) ب
12 | 
13 | إذا صادفتك مشكلة حاول حل المشكلة الثالثة و التي من الممكن أن تكون أس[Sums In Loop](./sums-in-loop) 
14 | 
15 | **المعطيات** :
16 | 
17 | - السطر الأول يحتوي عدد الأرقام المراد جمعها
18 | - السطر الثاني يحتوي على الأرقام
19 | 
20 | **الجواب** يجب أن يكون رقم واحد هو حاصل جمع الأرقام المعطاة
21 | 
22 | مثال:
23 | 
24 | 	المعطيات:
25 | 	8
26 | 	10 20 30 40 5 6 7 8
27 | 	
28 | 	الجواب:
29 | 	126
30 | 
31 | **ملاحظة**بما أن عدد الأرقام كبير حاول عدم نسخها بشكل يدوي 
32 | ننصحك بإيجاد طريقة برمجية لإدخالها بشكل آلي 
33 | إذا كنت تحل ضمن صفحة الموقع سيتم إدخال المعطيات بشكل أتوماتيكي
34 | 


--------------------------------------------------------------------------------
/sk/task-20.md:
--------------------------------------------------------------------------------
 1 | Toto je jednoduchý problém na úvod do spracovania reťazcov (string). Bude nám poskytnutých niekoľko riadkov textu
 2 | a pre každý z nich chceme vedieť počet samohlások (t.j. písmená `a, o, u, i, e, y`). **Všimnite si:** že `y` považovaný za
 3 | samohlásku pre účel tejto úlohy.
 4 | 
 5 | *Táto dôležitá, aj keď jednoduchá technika je použitá v lámaní šifrovania. Pozri napríklad aj
 6 | [Caesar Cipher Cracker](./caesar-cipher-cracker).*
 7 | 
 8 | **Vstupné dáta** obsahujú počet príkladov v prvom riadku.
 9 | Potom nasleduje určitý počet riadkov, z ktorých každý reprezentuje jeden príklad. 
10 | Riadky pozostavajú iba z malých písmen Anglickej (Latiskej) abecedy a medzier.  
11 | **Odpoveď** by mala obsahovať počet samohlások v každom riadku, oddelenú medzerami.
12 | 
13 | Príklad:
14 | 
15 |     vstupné dáta:
16 | 	4
17 | 	abracadabra
18 | 	pear tree
19 | 	o a kak ushakov lil vo kashu kakao
20 | 	my pyx
21 | 	
22 | 	odpoveď:
23 | 	5 4 13 2
24 | 
25 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
26 | 


--------------------------------------------------------------------------------
/ru/task-50.md:
--------------------------------------------------------------------------------
 1 | <!-- #Палиндромы на Проверку -->
 2 | Слово или целая фраза, буквы которой идут в том же порядке если их читать слева-направо, или справа-налево, называется
 3 | **палиндромом**. Вот несколько примеров:
 4 |     
 5 |     Stats
 6 |     Amore, Roma
 7 |     No 'x' in Nixon
 8 |     Was it a cat I saw?
 9 |     
10 |     Топот
11 |     Бел хлеб
12 |     Мыло голым
13 | 
14 | Как мы видим, регистр букв не учитывается. Пробелы и знаки препинания - тоже.
15 | 
16 | Задача этого упражнения, написать программу, определяющую является ли фраза палиндромом или нет.
17 | 
18 | **Входные данные** указывают количество тестовых фраз в первой строке.  
19 | Остальные строки содержат по одной фразе каждая (латинские буквы, пробелы, знаки препинания).  
20 | **Ответ** должен содержать по одной букве, через пробел, для каждой фразы: `Y` если это палиндром или `N` если нет.
21 | 
22 | Пример:
23 | 
24 |     входные данные:
25 |     3
26 |     Stars
27 |     O, a kak Uwakov lil vo kawu kakao!
28 |     Some men interpret nine memos
29 |     
30 |     ответ:
31 |     N Y Y
32 | 


--------------------------------------------------------------------------------
/es/task-20.md:
--------------------------------------------------------------------------------
 1 | Este es un problema sencillo que sirve de introducción al procesamiento de cadenas. Se nos dará varias líneas de texto - y para cada una
 2 | de ellas queremos conocer el número de vocales (ej.: las letras `a, o, u, i, e, y`). **Nota:** Se considera `y` como una vocal
 3 | para los propósitos de esta tarea.
 4 | 
 5 | *Aunque sencilla, esta técnica es importante en enfoques de decodificación de cifrados. Para un ejemplo, revisa el problema
 6 | [Caesar Cipher Cracker](./caesar-cipher-cracker).*
 7 | 
 8 | Los **Datos de entrada** contendrán el número de casos en la primera línea.  
 9 | Luego sigue el número especificado de líneas, cada uno representando un caso de prueba.  
10 | Las líneas consisten únicamente de letras minúsculas latinas y espacios.  
11 | La **Respuesta** debería contener los números de vocales de cada línea, separados por espacios.
12 | 
13 | Ejemplo:
14 | 
15 |     datos de entrada:
16 |     4
17 |     abracadabra
18 |     pear tree
19 |     o a kak ushakov lil vo kashu kakao
20 |     my pyx
21 | 
22 |     respuesta:
23 |     5 4 13 2
24 | 
25 | 


--------------------------------------------------------------------------------
/ru/task-2.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сумма в цикле -->
 2 | Теперь наша задача научиться писать циклы - т.е. программировать повторяющиеся действия.  
 3 | Требуется найти сумму нескольких чисел (больше чем двух). [Цикл типа FOR](http://en.wikipedia.org/wiki/For_loop)
 4 | будет удобен поскольку количество суммируемых значений известно заранее.
 5 | 
 6 | **Входные данные** представлены так:
 7 | 
 8 | - первая строка содержит  `N` - количество складываемых значений;
 9 | - вторая строка содержит сами эти значения (целые).
10 | 
11 | **Ответ** должен содержать единственное число - подсчитанную сумму.
12 | 
13 | Пример:
14 | 
15 |     исходные данные:
16 |     8
17 |     10 20 30 40 5 6 7 8
18 |     
19 |     ответ:
20 |     126
21 | 
22 | **Внимание** поскольку чисел много, не нужно копировать их в ваш исходный код вручную!
23 | Вместо этого сделайте программу, читающую данные со стандартного ввода (консоли), куда вы их можете легко скопировать
24 | (например, клавишами Ctrl-C, Ctrl-V). А если выполнять код на сервере (с помощью кнопок ниже), то данные будут переданы ему
25 | автоматически.
26 | 


--------------------------------------------------------------------------------
/ar/task-15.md:
--------------------------------------------------------------------------------
 1 | تعتبر هذه المسألة بمثابة مقدمة للتعريف بالخوارزميات , و الخوارزميات بحد ذاتها 
 2 | هي جوهر البرمجة , من أحد أمثلة الخوازميات ترتيب المصفوفات تصاعدياًأو تنازلياً
 3 | سنبدأ هنا بمسألة أقل تعقيداً
 4 | 
 5 | لنفترض أن لدينا مجموعة من الأرقام و المطلوب إيجاد العدد الأكبر و العدد الأصغر
 6 | طبعاً من المعروف بأن هناك لغات برمجية تحتوي على توابع جاهزة لإنجاز المهمة 
 7 | إلا أن المطلوب هو إستخدام طريقة العمل التالية(خوارزمية) 
 8 | **أولاً**
 9 | نقوم بإنتقاء رقم لا على التعيين من الأرقام المعطاةو نخزنه ضمن متغير
10 | و نفترض أنه الرقم الأعلى
11 | 
12 | ومن ثم نقوم بأخذ الرقم التالي ونقارن بين الرقمين فإن كان الرقم الجديد أعلى
13 | تصبح قيمة المتغير تساوي الرقم الجديد نستمر بهذا الإختبار حتى نتفحص كل الأرقام المعطاة
14 | قيمة المتغير تساوي قيمة الرقم الأعلى
15 | يمكن إجراء نفس الإختبار لإيجاد الرقم الأدنى
16 | 
17 | **المعطيات**  
18 | سيتم إعطاء 300 رقم ضمن سطر واحد
19 | 
20 | **الجواب**  
21 | المطلوب استخراج أعلى و أدنى رقم
22 | 
23 | 
24 | 
25 | مثال:
26 | 
27 |     المعطيات :
28 |     1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
29 |     
30 |     الجواب :
31 |     300 1
32 | 


--------------------------------------------------------------------------------
/ru/task-22.md:
--------------------------------------------------------------------------------
 1 | <!-- #Два Принтера -->
 2 | _Мой коллега рассказал мне эту задачку после посещения собеседования в местном офисе Oracle. Надеюсь я запомнил её
 3 | достаточно точно._
 4 | 
 5 | Джон и Мэри основали полиграфическую компанию **J&M publishing house** - для этого они купили пару старых принтеров и пачку бумаги.
 6 | 
 7 | И вот их первая коммерческая сделка - требуется напечатать документ состоящий из `N` страниц.
 8 | 
 9 | Оказывается принтеры работают с неодинаковой скоростью. Один печатает страницу за `X` секунд, а другой за `Y`.
10 | 
11 | И вот теперь Джон и Мэри пытаются подсчитать какое минимальное время они могут затратить на печать всего документа.
12 | 
13 | **Входные данные** содержат количество тест-кейсов в первой строке.  
14 | Далее следуют сами тесты по одному в каждой строке.  
15 | Каждый из них содержит по три целых числа - `X Y N`, где `N` не превышает `1,000,000,000`.  
16 | **Ответ** должен содержать минимальные времена печати для каждого случая, через пробел.
17 | 
18 | Пример:
19 | 
20 | 	входные данные:
21 | 	2
22 | 	1 1 5
23 | 	3 5 4
24 | 	
25 | 	ответ:
26 | 	3 9
27 | 


--------------------------------------------------------------------------------
/ru/task-13.md:
--------------------------------------------------------------------------------
 1 | <!-- #Взвешенная сумма цифр -->
 2 | Эта программа - младший брат более сложных алгоритмов - для подсчёта контрольных сумм (вроде CRC), хэш-функций
 3 | (например, MD5) на строках и т.п. Помимо того она даст нам ещё одно упражнение по разбиению чисел на цифры.
 4 | Возможно вы пожелаете решить сначала похожую задачу [Sum of Digits](./sum-of-digits).
 5 | 
 6 | Давайте сосчитаем сумму цифр, как и раньше, но теперь умножая каждую цифру на её порядковый номер (позицию) в числе,
 7 | считая слева, начиная с единицы - т.е. задавая "вес" каждой цифры.
 8 | Например для числа `1776` мы вычислим такую **взвешенную** сумму цифр (назовем её "wsd") как:
 9 | 
10 |     wsd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60
11 | 
12 | **Входные данные** задают в первой строке общее количество тестов.  
13 | Сами тестовые значения заданы во второй строке. Для каждого из них нужно сосчитать "взвешенную сумму цифр".  
14 | **Ответ** - как обычно, выведите результаты для каждого теста через пробел.
15 | 
16 | Пример:
17 | 
18 |     входные данные:
19 |     3
20 |     9 15 1776
21 |     
22 |     ответ:
23 |     9 11 60
24 | 


--------------------------------------------------------------------------------
/zh/task-46.md:
--------------------------------------------------------------------------------
 1 | 这次我们不是要编写一个与 **井字棋** 游戏竞争对手，而是要编写这种算法的重要组成部分 - 检测函数，这个检查函数可以告诉我们游戏是否结束以及哪一方胜出。
 2 | 
 3 | 这个游戏运行在一个 `3 x 3` 大小的平面上。让我们假设每个栅格用以下方式命名：
 4 | 
 5 |      1 | 2 | 3
 6 |     ---+---+---
 7 |      4 | 5 | 6
 8 |     ---+---+---
 9 |      7 | 8 | 9
10 | 
11 | 两个玩家轮流将他们的分数（ `X` 表示第一位玩家 `O` 表示第二位玩家）放到剩余的任意栅格中，其中一个玩家首先完成 3 连线（三个 X 或 三个 O）后就立即获胜。三连线可以是行、列、对角线的形式（一个有 8 种形式），假如执行了如下的操作：
12 | 
13 |     X   O
14 |     -------
15 |     7
16 |         5
17 |     4
18 |         1
19 |     9
20 |         2
21 |     8
22 | 
23 | 这回导致形成如下的栅格位置：
24 | 
25 |      O | O |  
26 |     ---+---+---
27 |      X | O |  
28 |     ---+---+---
29 |      X | X | X
30 | 
31 | 从而第一个玩家（X）首先完成三连线获胜。
32 | 
33 | ## 问题陈述
34 | 
35 | 你会接收一个操作动作的序列（假如总是 `X` 首先移动） - 通过序列中的数字来标记其放置的对应的栅格 - 你的任务就是确认在哪一步操作后第一个三连线（以任意形式）出现。
36 | 
37 | **输入数据** 第一行显示的是测试案例个数。
38 | 
39 | 接下来每行包含一个测试案例 - 每行有 9 个数字，依次描述操作那个栅格。
40 | 
41 | **答案** 应该包含其中一个玩家获胜时双方一共走了多少步棋（用 `1` 来标示），如果走到最后游戏也没有赢家就用 `0` 标示。
42 | 
43 | 举个栗子：
44 | 
45 |     输入数据:
46 |     3
47 |     7 5 4 1 9 2 8 3 6
48 |     5 1 3 7 6 4 2 9 8
49 |     5 1 2 8 6 4 7 3 9
50 | 
51 |     答案:
52 |     7 6 0
53 | 
54 | 


--------------------------------------------------------------------------------
/ar/task-7.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img alt="fahrenheit and celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 3 | </div>
 4 | 
 5 | *ملاحظة : النتائج تخضع لنظام التقريب المذكور سابقاً*
 6 | 
 7 | يستعمل عالمياً نظامين لقياس درجة الحرارة , نظام سيليسيوس و نظام الفهرنهايت
 8 | 
 9 | نظام سيليسيوس هو المستعمل في الدول العربية و في أوروبا , حيث تتجمد المياه في الدرجة صفر و تغلي في درجة
10 | 
11 | مئة . أما في نظام فهرنهايت فإنها تتجمد في درجة 32 و تغلي في درجة 212 ويستعمل نظام فهرنهايت 
12 | 
13 | في الولايات المتحدة الأمريكية.
14 | 
15 | 
16 | لمزيد من المعلومات يمكن قراءة مقالة ويكيبيديا
17 | [wikipedia on Fahrenheit](http://en.wikipedia.org/wiki/Fahrenheit)
18 | 
19 | المطلوب كتابة برنامج لتحويل درجات الحرارة من الفهرنهايت إلى السيليسيوس
20 | 
21 | **المعطيات** أول  رقم هو عدد درجات الحرارة المطلوب تحويلها (لاتقم بتحويله) في هذه الحالة الرقم 5
22 | 
23 | **الجواب** درجات الحرارة بعد أن تم تحويلها مفصولة بفراغ بينها
24 | 
25 | مثال : 
26 |   
27 |     المعطيات :
28 |   
29 |     5 495 353 168 -39 22
30 |     الجواب:
31 |   
32 |     257 178 76 -39 -6
33 | 
34 | *لا تقم بتحويل الرقم 5*
35 | 


--------------------------------------------------------------------------------
/ru/task-68.md:
--------------------------------------------------------------------------------
 1 | <!-- #Два Велосипедиста -->
 2 | <div class="text-center">
 3 | 	<img alt="два велосипедиста навстречу" src="https://codeabbey.github.io/data/bycicle_race.png"/>
 4 | </div><br/>
 5 | 
 6 | Два велосипедиста выезжают из двух разных городов навстречу друг другу. Дорога между городами прямая и ровная, но едут они
 7 | с неодинаковыми скоростями, так что встретятся необязательно посередине.
 8 | 
 9 | Нам даны расстояние между городами `S` (в километрах) и скорости обоих велосипедистов (`A` и `B` - в километрах в час).
10 | Требуется определить точку встречи (её расстояние от первого города).
11 | 
12 | **Входные данные** указывают количество тесткейсов в первой строке.  
13 | Остальные строки содержат по три значения каждая - `S A B`.  
14 | **Ответ** должен содержать расстояние от первого города до точки встречи (т.е. сколько проедет первый велосипедист) для каждого
15 | из тесткейсов, через пробел.
16 | 
17 | Пример:
18 | 
19 |     входные данные:
20 | 	2
21 | 	10 1 1
22 | 	20 1 2
23 | 	
24 | 	ответ:
25 | 	5 6.66666667
26 | 
27 | *Примечание: вещественные числа должны иметь точность `10e-7` или лучше.*
28 | 


--------------------------------------------------------------------------------
/es/task-15.md:
--------------------------------------------------------------------------------
 1 | Este problema introduce el popular algoritmo de "búsqueda lineal", el cual debe ser aprendido completamente ya que es frecuentemente
 2 | usado en la programación de tareas más complejas (ordenamiento, etc.)
 3 | 
 4 | Una operación muy común en una secuencia de valores, o vectores, es la de encontrar su valor extremo - máximo o mínimo. Para lograrlo,
 5 | se necesita almacenar el **máximo actual** (o mínimo, según sea el caso) en una variable separada, y luego recorrer el vector,
 6 | comparando cada uno de sus elementos con esta variable. Cuando el siguiente valor sea mayor que esta variable temporal, este
 7 | valor debería ser copiado a ella (como un nuevo máximo).
 8 | 
 9 | Al final del recorrido, esta variable temporal portará el valor extremo.
10 | 
11 | Los **Datos de entrada** te darán exactamente `300` números en una sola línea.  
12 | La **Respuesta** debería contener el máximo y el mínimo de estos valores, separados por espacios.
13 | 
14 | Ejemplo:
15 | 
16 |     datos de entrada:
17 |     1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
18 | 
19 |     respuesta:
20 |     300 1
21 | 
22 | 


--------------------------------------------------------------------------------
/ro/task-5.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <iframe width="420" height="315" src="//www.youtube.com/embed/ZrUBwbEfN8I" frameborder="0" allowfullscreen></iframe>
 3 | <div class="hint">Pentru mai multe explicații, urmărește acest video</div>
 4 | </div>
 5 | 
 6 | Încă un pic de antrenament cu programarea condițională, acum vom scrie un program care constă din câteva declarații condiționale mai complexe.
 7 | 
 8 | Sugestie: O declarație de tip `if ... else` ar putea fi (și ar trebuie de altfel sa fie) imbricată in interiorul unei alte declarații, pentru a rezolva această problemă într-un mod eficient.
 9 | 
10 | Căteva triplete de numere îți vor fi furnizate. Sarcina ta este să găsești valoarea minimă dintre fiecare aceste trei valori.
11 | 
12 | **Datele de intrare** conțin pe prima line -  numarul total de triplete.  
13 | Următoarele linii conțin tripletele de numere propriu-zise.  
14 | **Răspunsul** ar trebui să conțină numărul minim al fiecărui triplet, separat prin spațiu.
15 | 
16 | Exemplu:
17 | 
18 |     Date de intrare:
19 |     3
20 |     7 3 5
21 |     15 20 40
22 |     300 550 137
23 |     
24 |     Răspuns:
25 |     3 15 137
26 | 


--------------------------------------------------------------------------------
/ru/task-4.md:
--------------------------------------------------------------------------------
 1 | <!-- #Наименьшее из Двух -->
 2 | Большинство программ должны уметь делать выбор, принимать какие-то решения. Поэтому сейчас мы попробуем освоить
 3 | **условные выражения**. Обычно они используют ключевые слова `if ... else` и выглядят как-то так:
 4 | 
 5 |     IF some_condition THEN
 6 |         do_something
 7 |     ELSE
 8 |         do_other_thing
 9 |     ENDIF
10 | 
11 | В зависимости от выбранного языка, синтаксис может немного различаться, а часть `else` почти всегда является необязательной.
12 | Вы можете найти дополнительную информацию в [статье википедии](http://en.wikipedia.org/wiki/Conditional_(computer_programming))
13 | 
14 | Наша задача - из двух чисел выбрать меньшее. Будут даны несколько пар чисел для более тщательной проверки.
15 | 
16 | **Входные данные** - в первой строке указано количество пар сравниваемых чисел.  
17 | Следующие строки содержат сами эти пары - по одной на строку.  
18 | **Ответ** должен содержать наименьшие элементы из каждой пары, через пробел.
19 | 
20 | Пример:
21 | 
22 |     входные данные:
23 | 	3
24 |     5 3
25 |     2 8
26 |     100 15
27 |     
28 |     ответ:
29 |     3 2 15
30 | 


--------------------------------------------------------------------------------
/ar/task-6.md:
--------------------------------------------------------------------------------
 1 | كثيراً ما نتعامل مع أرقام تحتوي على فواصل عشرية و غالباً ما يكون من الأفضل تقريب هذه الأرقام لتصبح أرقاماً 
 2 | صحيحة , المسألة التالية هي عبارة عن تطبيق لعملية التقريب
 3 | 
 4 | 
 5 | المسألة تحتوي في كل حالة على زوج من الأرقام , يجب تقسيم الرقم الأول على الرقم الثاني   , ومن
 6 | ثم يجب أن نقوم بتقريب حاصل القسمة إلى أقرب رقم صحيح .
 7 | 
 8 | 
 9 | حاصل القسمة و الذي يحتوي على أرقام عشرية إعتباراً من 0.5 و أعلى تقرب إلى الأعلى . في حين أن 
10 | الأرقام السالبة** تقرب للأعلى** (أي بإتجاه الصفر) لمزيد من المعلومات 
11 | يمكن العودة إلى مقالة ويكيبيديا
12 | 
13 | [Rounding](http://en.wikipedia.org/wiki/Rounding#Round_half_up)
14 | 
15 | 
16 | في المسائل القادمة عندما يتم ذكر التقريب نفس آلية التقريب يجب أن يتم تطبيقها ,ما
17 | لم يتم ذكر ما يخالف ذلك 
18 | 
19 | **المعطيات**
20 | 
21 | السطر الأول : عدد الحالات المطلوب معالجتها
22 | 
23 | السطر الثاني :أزواج من الأرقام المطلوب قسمة 
24 | كل زوج منها ومن ثم تقريب حاصل القسمة إلى أقرب رقم صحيح
25 | 
26 | **الجواب**
27 | 
28 | حاصل القسمة و التقريب لكل زوج مفصولة بفراغ
29 | 
30 | مثال:
31 | 
32 | 	المعطيات:
33 | 	3
34 | 	12 8
35 | 	11 -3
36 | 	400 5
37 | 	
38 | 	الجواب:
39 | 	2 -4 80
40 | 


--------------------------------------------------------------------------------
/ru/task-29.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сортировка с Сохранением Индексов -->
 2 | Если вы решили задачу [Bubble Sort](./bubble-sort) то вероятно уже представляете смысл сортировки массива.
 3 | Теперь у нас немного более интересная задача - требуется отсортировать не просто числа а чуть более сложные объекты.
 4 | 
 5 | Как и раньше, нам дан массив чисел. Как и раньше хочется его отсортировать (в порядке неубывания) - а после этого
 6 | вывести для каждого элемента его порядковый номер в исходном массиве (считая с 1).
 7 | 
 8 | Т.е., пусть у нас был массив `50 98 17 79` который отсортировался в `17 50 79 98`. И теперь:
 9 | 
10 |     17 было 3-м элементом исходного массива
11 |     50 было 1-м элементом
12 |     79 было 4-м элементом
13 |     98 было 2-м элементом
14 |     
15 | т.е. результат будет `3 1 4 2`.
16 | 
17 | **Исходные данные** содержит размер массива в первой строке,  
18 | и сами значения массива во второй (целые, через пробел).  
19 | **Ответ** должен содержать исходные индексы элементов в порядке получившемся после сортировки.
20 | 
21 | Пример:
22 | 
23 |     входные данные:
24 |     4
25 |     50 98 17 79
26 |     
27 |     ответ:
28 |     3 1 4 2
29 | 


--------------------------------------------------------------------------------
/ru/task-6.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сложности Округления -->
 2 | Работая с нецелыми числами (вроде `3.14159`) мы иногда хотим **округлить** такие значения до ближайшего целого числа.
 3 | Некоторые из задач в дальнейшем будут требовать приведения результатов к целым, поэтому давайте потренируемся в
 4 | выполнении этой операции.
 5 | 
 6 | Даны несколько пар чисел. В каждой паре нужно разделить первое на второе и вернуть результат
 7 | округлённый **до ближайшего** целого.
 8 | 
 9 | В случаях когда дробная часть равна точно `0.5` договоримся округлять вверх (т.е. прибавляя `0.5`).
10 | Заметьте что для отрицательных чисел "вверх" означает "в сторону нуля".
11 | 
12 | Во всех дальнейших задачах упоминающих округление нужно использовать именно такой алгоритм (если не сказано иное).
13 | 
14 | **Входные данные** - в первой строке указано количество тестов.  
15 | В остальных строках сами тесты (пары чисел, которые нужно делить).  
16 | **Ответ** должен содержать результаты округления для каждого теста, разделенные пробелами.
17 | 
18 | Пример:
19 | 
20 |     входные данные:
21 |     3
22 |     12 8
23 |     11 -3
24 |     400 5
25 |     
26 |     ответ:
27 |     2 -4 80
28 | 


--------------------------------------------------------------------------------
/sk/task-15.md:
--------------------------------------------------------------------------------
 1 | Tento problém uvádza populárny algoritmus "lineárneho vyhľadávania", ktorý by ste sa mali dôkladne naučiť 
 2 | pretože je často používaný v programovaní komplexnejších úloh (zoraďovanie atď.)
 3 | 
 4 | Veľmi bežná operácia na sled hodnôt alebo polí je nájsť krajné hodnoty - maximálne alebo minimálne. Aby sme toto 
 5 | docielili potrebujeme uložiť **aktuálnu maximálnu** (alebo minimálnu) hodnotu v oddelených premenných, a potom 
 6 | prejsť cez pole, porovnávať každý z elementov s touto hodnotou. Kedykoľvek je nasledujúca hodnota väčšia ako táto
 7 | dočasná premenná, táto nová hodnota by mala byť do nej skopírovaná (ako nové maximum).
 8 | 
 9 | Na konci tohoto prechodu táto dočasná premenná bude obsahovať krajnú hodnotu.
10 | 
11 | **Vstupné dáta** vám poskytnú presne `300` čísel v jednom riadku.  
12 | **Odpoveď** by mala obsahovať maximálnu a minimálnu hodnotu z týchto čísel oddelenú medzerou.
13 | 
14 | Príklad:
15 | 
16 | 	vstupné dáta:
17 | 	1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
18 | 	
19 | 	odpoveď:
20 | 	300 1
21 | 
22 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
23 | 


--------------------------------------------------------------------------------
/sk/task-10.md:
--------------------------------------------------------------------------------
 1 | <!-- #Lineárna funkcia -->
 2 | Veľmi bežný problém vo výpočtovom programovaní je určiť základný zákon, ktorými sa riadia niektoré javy.
 3 | Pre učebné účely si poďme vyskúšať jednoduchú úlohu -  objavovanie lineárnej závislosti dvoma uvedenými pozorovaniami
 4 | (napríklad, ako závisí cena produktu od rozmeru, váhy atď.)
 5 | 
 6 | Lineárna funkcia je definovaná vzťahom:
 7 | 
 8 |     y(x) = ax + b
 9 | 
10 | Kde `a` a `b` sú nejaké konštanty.  
11 | Napríklad, pre `a=3, b=2` má funkcia hodnoty `y = 2, 5, 8, 11...`  
12 | kde `x = 0, 1, 2, 3...`
13 | 
14 | Vašou úlohou je určiť `a` a `b` dvoma bodmi, ktoré patria funkcií.  
15 | T.j sú vám dané dva páry hodnôt `(x1, y1), (x2, y2)` pre ktoré funkcia platí
16 | - a vy máte obnoviť samotnú funkciu.
17 | 
18 | **Vstupné dáta** má počet príkladov v prvom riadku
19 | a potom samotné príklady v oddelených riadkoch. 
20 | Každý riadok obsahuje `4` celé čísla (`x1 y1 x2 y2`).  
21 | **Odpoveď** by mala byť tiež celé číslo, oddelená medzerami a samotné páry v zátvorkách, napríklad:
22 | 
23 |     vstupné dáta:
24 |     2
25 |     0 0 1 1
26 |     1 0 0 1
27 |     
28 |     odpoveď:
29 |     (1 0) (-1 1)
30 | 


--------------------------------------------------------------------------------
/de/task-13.md:
--------------------------------------------------------------------------------
 1 | <!-- #Gewichtete Ziffernsumme -->
 2 | Dieses Programm ähnelt komplexeren Algorithmen zur Berechnung von CRC- oder anderen Prüfsummen und Hash-Funktionen für
 3 | Zeichenketten. Darüber hinaus wird es Ihnen weitere Übung für die Zerlegung von Werten in Dezimalstellen bieten. Vielleicht
 4 | möchten Sie vorher [Sum of Digits](./sum-of-digits--de) ausprobieren.
 5 | 
 6 | Berechnen wir die Summe der Ziffern wie bevor, aber multiplizieren dieses Mal jede Ziffer mit Ihrer Position (von links zählend, beginnend
 7 | mit 1). Als Beispiel, wenn wir den Wert `1776` haben, berechnen wir die **gewichtete** Summe der Ziffern (nennen wir sie "wsd") wie folgt:
 8 | 
 9 |     wsd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60
10 | 
11 | **Eingabe Daten** enthalten in der ersten Zeile die Anzahl der Testfälle.  
12 | Darauf folgen in der zweiten Zeile die Werte selbst. Für jeden dieser Werte sollen Sie die gewichtete Summe der Ziffern berechnen.  
13 | **Antwort:** wie üblich, geben Sie die Ergebnisse in einer Zeile und mit Leerzeichen getrennt aus.
14 | 
15 | Beispiel:
16 | 
17 |     Eingabe Daten:
18 |     3
19 |     9 15 1776
20 |     
21 |     Antwort:
22 |     9 11 60
23 | 


--------------------------------------------------------------------------------
/ro/task-41.md:
--------------------------------------------------------------------------------
 1 | <!-- #Median of Three -->
 2 | 
 3 | Probabil că ai rezolvat deja problema [Minimum of Three](./min-of-three) - nu a fost una foarte complicată? Un bun programator ar trebui să posede o logică bună (nu doar cunoștințe sintaxice ale limbajului de programare), îți propun să modificăm problema anterioară, ca ea să devină un pic mai complicată.
 4 | 
 5 | Pentru fiecare triplet de numere, tu ar trebui sa găsești numarul mijlociu - nu cel mai mare număr, nici cel mai mic. Un asemenea număr este numit **Mediana**.
 6 | 
 7 | Acest exercițiu este unul util întrucât, **mediana** joaca un rol important în cadrul algoritmului de sortare Quick Sort.
 8 | 
 9 | **Datele de intrare** conțin pe prima linie, numărul total de triplete.  
10 | Următoarele linii conțin tripletele propriu-zise.  
11 | **Răspunsul** ar trebui să conțină mediana pentru fiecare triplet, separate prin spațiu.
12 | 
13 | Exemplu:
14 | 
15 | 	Date de intrare:
16 | 	3
17 | 	7 3 5
18 | 	15 20 40
19 | 	300 550 137
20 | 	
21 | 	Răspuns:
22 | 	5 20 300
23 | 
24 | Notă: programul tău nu ar trebui să conțină mai mult de trei declarații de tip if-else. Daca el conține mai multe, probabil urmezi o cale greșită.


--------------------------------------------------------------------------------
/es/task-9.md:
--------------------------------------------------------------------------------
 1 | Un triángulo es un objeto compuesto de tres segmentos de recta (los lados del triángulo) conectados en sus extremos.
 2 | [El artículo de Wikipedia][wiki] proporciona una explicación más detallada. 
 3 | 
 4 | Si tenemos tres segmentos de recta con longitudes `A B C` - hay dos posibilidades: que podamos construir un triángulo con ellos  
 5 | (por ejemplo, con `3 4 5` o `3 4 7` - aunque este último tendría un área de cero) o que sea imposible
 6 | (por ejemplo `1 2 4`).
 7 | 
 8 | [wiki]: https://es.wikipedia.org/wiki/Tri%C3%A1ngulo
 9 | 
10 | Se te dan varios tríos de valores que representan las longitudes de los lados de los triángulos.
11 | Deberías indicar con cuales tríos es posible construir un triángulo y con cuales no lo es.
12 | 
13 | **Datos de entrada:** La primera línea contendrá el número de tríos.  
14 | Las otras líneas contendrán los tríos en sí (cada uno en una línea separada).  
15 | **Respuesta:** Deberías mostrar `1` o `0` para cada trío (`1` si el triángulo puede ser construido; de lo contrario muestra `0`).
16 | 
17 | Ejemplo:
18 | 
19 |     datos de entrada:
20 |     2
21 |     3 4 5
22 |     1 2 4
23 |     
24 |     respuesta:
25 |     1 0
26 | 


--------------------------------------------------------------------------------
/ru/task-19.md:
--------------------------------------------------------------------------------
 1 | <!-- #Проверка Соответствия Скобок -->
 2 | Нам даны строки, содержащие скобки `4` видов - круглые `()`, квадратные `[]`, фигурные `{}` и угловые `<>`.
 3 | Задача в том, чтобы проверить является ли последовательность скобок корректной. Т.е. любая открывающая скобка должна
 4 | иметь закрывающую того же типа где-то дальше по строке - и кроме того пары скобок не должны пересекаться, хотя
 5 | они могут быть вложенными:
 6 | 
 7 | 	(a+[b*c] - {d/3})  - здесь квадратные и фигурные скобки вложены в круглые
 8 | 	
 9 | 	(a+[b*c) - 17]     - а здесь "область действия" круглых и квадратных пересекается, что некорректно
10 | 
11 | **Входные данные** указывают количество тестов в первой строке.  
12 | Далее идет указанное количество строк, содержащих по одной символьной последовательности.  
13 | **Ответ** должен содержать для каждого теста `1` если скобки расставлены верно или `0` если нет.
14 | 
15 | Пример:
16 | 
17 | 	входные данные:
18 |   4
19 |   (a+[b*c]-{d/3})
20 |   (a + [b * c) - 17]
21 |   (((a * x) + [b] * y) + c
22 |   auf(zlo)men [gy<psy>] four{s}
23 |   
24 |   ответ:
25 |   1 0 0 1
26 | 
27 | _Заметьте что все символы кроме скобок можно просто игнорировать!_
28 | 


--------------------------------------------------------------------------------
/de/task-9.md:
--------------------------------------------------------------------------------
 1 | <!-- #Triangles -->
 2 | Ein Dreieck ist ein Objekt, das aus drei Liniensegmenten (Seiten des Dreiecks) besteht, die durch ihre jeweiligen Enden miteinander verbunden sind.
 3 | Das [Wiki über Dreiecke][wiki] bietet eine ausführlichere Erklärung.  
 4 | Wenn wir drei Liniensegemente mit den Längen `A B C` haben - können wir damit entweder ein Dreieck bilden  
 5 | (zum Beispiel mit `3 4 5` oder `3 4 7` - allerdings mit dem Flächeninhalt 0) oder es ist unmöglich  
 6 | (zum Beispiel `1 2 4`).
 7 | 
 8 | [wiki]: https://de.wikipedia.org/wiki/Dreieck
 9 | 
10 | Sie erhalten mehrere Tripel von Werten, die die Seitenlängen von Dreiecken darstellen.
11 | Sie sollen dann entscheiden, aus welchen Tripeln ein Dreieck gebildet werden kann und aus welchen nicht.
12 | 
13 | **Eingabe Daten:** Die erste Zeile enthält die Anzahl der Tripel.
14 | Die folgenden Zeilen enthalten die Tripel selbst (jedes in einer eigenen Zeile).  
15 | **Antwort:** Sie sollen für jedes Triplett `1` oder `0` ausgeben (`1` falls das Dreieck gebildet
16 | werden kann und `0` falls nicht).
17 | 
18 | Beispiel:
19 | 
20 |     Daten:
21 |     2
22 |     3 4 5
23 |     1 2 4
24 |     
25 |     Antwort:
26 |     1 0
27 | 


--------------------------------------------------------------------------------
/ru/task-15.md:
--------------------------------------------------------------------------------
 1 | <!-- #Максимум в Массиве -->
 2 | Эта задача - о популярном алгоритме "линейного поиска", который часто используется в составе более сложных алгоритмов
 3 | (например, сортировок).
 4 | 
 5 | Частой операцией над набором значений (например, массивом) является поиск наибольшего (или наименьшего) значения.
 6 | Для этого мы должны создать отдельную переменную - `текущий-максимум` (или минимум) - и проходя по массиву в цикле
 7 | сравнивать каждый из элементов с этой переменной. Если очередное значение оказывается больше `текущего`, то мы
 8 | копируем его в `текущий`, таким образом запоминая. В конце остаётся только вывести содержимое `текущего-максимума`.
 9 | 
10 | Некоторые языки содержат готовые функции для поиска максимума/минимума в массиве, но конечно в методических целях
11 | будет лучше если вы хоть раз реализуете этот несложный алгоритм самостоятельно. :)
12 | 
13 | **Входные данные** содержат ровно `300` целых чисел в одной строке.  
14 | **Ответ** должен содержать максимум и минимум этих чисел, разделенные пробелом.
15 | 
16 | Пример:
17 | 
18 |     входные данные:
19 |     1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
20 |     
21 |     ответ:
22 |     300 1
23 | 


--------------------------------------------------------------------------------
/ru/task-31.md:
--------------------------------------------------------------------------------
 1 | <!-- #Вращение Строки -->
 2 | Вращение строки на `K` символов означает операцию при которой эти символы отрезаются от начала и добавляются в конец.
 3 | Если `K` отрицательно, символы наоборот переносятся из конца в начало.
 4 | 
 5 | **Входные данные** содержат количество тест-кейсов в первой строке.  
 6 | Следующие строки содержат число `K` и следом за ним сам текст `S` отделённый пробелом.  
 7 | Текст `S` содержит только маленькие латинские буквы. `K` не превышает половины длины `S` по модулю.  
 8 | **Ответ** должен содержать строки после осуществления "вращения" на `K` в соответствии с вышеуказанным правилом.
 9 | 
10 |     входные данные:
11 |     2
12 |     3 forwhomthebelltolls
13 |     -6 verycomplexnumber
14 |     
15 |     ответ:
16 |     whomthebelltollsfor numberverycomplex
17 | 
18 | Задача во многих языках легко решается созданием новой строки из двух подстрок старой. Однако если вы хотите
19 | поломать голову, постарайтесь осуществить вращение "на месте", т.е. представив строку как массив символов и
20 | обменивая их внутри этого массива - не выделяя памяти под новую строку. Эта головоломка разрешима с помощью
21 | цикла и единственной вспомогательной переменной!
22 | 


--------------------------------------------------------------------------------
/ar/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/min_of_two.gif" alt="Choosing minimum animation"/>
 3 | </div>
 4 | 
 5 | معظم البرامج بحاجة لأن تختار بين خيارات أو أن تأخذ قرارات معينة
 6 | سنقوم الآن بحل مسألة تعتمد على البرمجة الشرطية
 7 | غالباً مايتم استخدام عبارة
 8 | 
 9 | `if ... else`
10 | 
11 | والتي يتم استخدامها على الشكل التالي
12 | 
13 |     IF some_condition THEN
14 | 	    do_something
15 | 	ELSE
16 | 	    do_other_thing
17 | 	ENDIF
18 | بالطبع فإن شكل العبارة الشرطية يختلف بإختلاف لغة البرمجة المستخدمة
19 | لمزيد من المعلومات حول العبارات الشرطية يمكن قراءة المقالة الموجودة في ويكيبيديا
20 | 
21 | [Conditional statements](http://en.wikipedia.org/wiki/Conditional_(computer_programming))
22 | 
23 | بالعودة للمسألة      
24 | لدينا عددين  و المطلوب إيجاد العدد الأصغر بينهما
25 | 
26 | **المعطيات** 
27 | 
28 | السطر الأول : يحتوي على عدد الأزواج المراد المقارنة بينها
29 | 
30 | السطر الثاني :الأرقام المراد مقارنة كل زوج منها و إختيار الأصغر
31 | 
32 |  **الإجابة**
33 | 
34 |  الرقم الأصغر من كل زوج بينها فراغ
35 | 
36 |   :المعطيات
37 | 
38 | 	3
39 |  
40 |     5 3
41 |  
42 |     2 8
43 |  
44 |     100 15
45 |     
46 |    :الإجابة
47 |  
48 |     3 2 15
49 | 


--------------------------------------------------------------------------------
/ru/task-41.md:
--------------------------------------------------------------------------------
 1 | <!-- #Медиана из Трёх -->
 2 | Вы вероятно уже решили задачу [Minimum of Three](./min-of-three--ru) - и она показалась лёгкой? Давайте теперь слегка изменим
 3 | условие, чтобы получилось более сложное упражнение.
 4 | 
 5 | Вновь будут даны тройки чисел, но теперь нужно выбрать среднее из них - т.е. то, которое останется если отбросить
 6 | наибольший и наименьший элементы. Такое число называется **медианой** (множества, массива и т.п.)
 7 | 
 8 | Не думайте что это всего лишь "очередное дурацкое упражнение" - выбор медианы является частью мощного и популярного
 9 | алгоритма быстрой сортировки (QuickSort) например.
10 | 
11 | **Входные данные** - первая строка содержит количество тестовых наборов чисел.  
12 | Остальные строки содержат сами наборы (тройки) - по одной в каждой строке.  
13 | **Ответ** должен содержать медианы этих троек, разделенные пробелами.
14 | 
15 | Пример:
16 | 
17 |     входные данные:
18 |     3
19 |     7 3 5
20 |     15 20 40
21 |     300 550 137
22 |     
23 |     ответ:
24 |     5 20 300
25 | 
26 | **Замечание**: если ваша программа содержит кучу конструкций if-else-if-else, то вероятно вы делаете что-то не так.
27 | Простое решение состоит не более чем из трёх ветвлений.
28 | 


--------------------------------------------------------------------------------
/sk/task-41.md:
--------------------------------------------------------------------------------
 1 | <!-- #Median of Three -->
 2 | 
 3 | Vyriešili ste už problém [Minimum of Three](./min-of-three) - a nebola to pre vás dostatočná výzva? Keďže programátori
 4 | by si mali zlepšovať logické myslenie (a nie iba zručnosti v programovacom jazyku), zmeňme úlohu aby bola
 5 | obtiažnejšia.
 6 | 
 7 | Opäť dostanete trojicu čísel, ale teraz musíte zvoliť prostrednú hotnodu - t.j. nie najvyššiu ani najnižšiu.
 8 | Takéto číslo nazývame **Stredná hodnota** (v angličtine **Median**) množiny, pola atď. 
 9 | 
10 | Uisťujeme vás, že tento problém nie je "ďalšia sprostá úloha" - ale používa sa napríklad ako časť vo výkonných triediacich 
11 | algorimoch.
12 | 
13 | **Vstupné dáta** v prvom riadku obsahujú počet trojíc na spracovanie.  
14 | Každý ďalší riadok obsahuje samotnú trojicu čísel.   
15 | **Odpoveď** by mala obsahovať vybrané stredné hodnoty, oddelené medzerami.
16 | 
17 | Príklad:
18 | 
19 |     dáta:
20 |     3
21 |     7 3 5
22 |     15 20 40
23 |     300 550 137
24 | 	
25 | 	odpoveď:
26 | 	5 20 300
27 | 
28 | Poznámka: ak váš program bude obsahovať priveľa  if-else-if-else výrokov, tak potom robíte pravdepodobne niečo nesprávne.
29 | Jednoduché riešenie by nemalo obsahovať viac ako 3 if-else výroky.
30 | 


--------------------------------------------------------------------------------
/ru/task-9.md:
--------------------------------------------------------------------------------
 1 | <!-- #Треугольники -->
 2 | Треугольник, как учат в школе, это геометрический объект из трёх отрезков соединённых концами.
 3 | Отрезки образуют "стороны" треугольника, а точки соединения их концов - вершины (и углы).
 4 | [Статья о треугольниках в википедии](http://en.wikipedia.org/wiki/Triangle) может дать более подробное объяснение.  
 5 | 
 6 | Если у нас есть три отрезка с длинами `A B C` - мы либо можем построить из них треугольник
 7 | (например из `3 4 5` или `3 4 7` - хотя в последнем случае треугольник вырожденный, с нулевой площадью) - или это оказывается
 8 | невозможно (например, со сторонами `1 2 4`).
 9 | 
10 | Даны несколько троек чисел, представляющих длины отрезков. Требуется ответить, из каких троек можно построить треугольник,
11 | а из каких нет.
12 | 
13 | **Входные данные** - содержат количество предполагаемых треугольников в первой строке.  
14 | Остальные строки содержат по три числа каждая - длины отрезков для сторон предполагаемого треугольника.  
15 | **Ответ** должен содержать `1` или `0` для каждой тройки чисел (`1` если треугольник можно построить, иначе `0`).
16 | 
17 | Пример:
18 | 
19 |     data:
20 |     2
21 |     3 4 5
22 |     1 2 4
23 |     
24 |     answer:
25 |     1 0
26 | 


--------------------------------------------------------------------------------
/es/task-13.md:
--------------------------------------------------------------------------------
 1 | Este programa se asemeja a algoritmos más complejos usados para la verificación por redundancia cíclica (CRC) y otras sumas de verificación (checksum), y también en funciones hash
 2 | para cadenas de caracteres. Por otro lado, te proporcionará un ejercicio más para practicar la separación de valores en dígitos decimales. Quizá
 3 | quieras intentar [Sum of Digits](./sum-of-digits) antes de esto.
 4 | 
 5 | Calculemos una suma de dígitos, como lo hicimos previamente, pero esta vez multiplicando cada dígito por su posición (contando las posiciones desde la izquierda, y empezando
 6 | desde 1). Por ejemplo, dado el valor `1776`, calculamos la suma **ponderada** de sus dígitos (llamémosla "spd") como:
 7 | 
 8 |     spd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60
 9 | 
10 | Los **Datos de entrada** darán el número de casos de prueba en la primera línea.  
11 | Los valores en sí están en la segunda línea. Para cada uno de estos valores vas a calcular su respectiva suma ponderada de dígitos.  
12 | **Respuesta:** Tal como es usual, coloca los resultados en una línea, separándolos con espacios.
13 | 
14 | Ejemplo:
15 | 
16 |     datos de entrada:
17 |     3
18 |     9 15 1776
19 | 
20 |     respuesta:
21 |     9 11 60
22 | 


--------------------------------------------------------------------------------
/de/task-20.md:
--------------------------------------------------------------------------------
 1 | Hier eine einfache Übungsaufgabe als Einführung in die Verarbeitung von Zeichenketten (Strings).
 2 | Wir erhalten mehrere Zeilen Text und für jede Zeile möchten wir gerne die Anzahl der Vocale wissen.
 3 | (z.B. die Buchstaben  `a, o, u, i, e, y`). **Anmerkung:** Das `y` wurde für diese Übung absichtlich der Liste hinzugefügt!
 4 | 
 5 | *Obwohl diese Aufgabe selbst relativ einfach ist, so ist diese Technik doch ein wichtiger
 6 | Teil beim Entschlüsseln von verschlüsselten Nachrichten. Siehe Übungsaufgabe
 7 | [Caesar Cipher Cracker](./caesar-cipher-cracker).*
 8 | 
 9 | **Eingabe Daten** In der ersten Zeile stehen wieder die Anzahl der zur Verarbeitung anstehenden Test-Fälle.  
10 | Jede folgende Zeile ist jeweils ein einzelner Test-Fall, den es zu untersuchen gilt.  
11 | Die Zeilen bestehen aus Kleinbuchstaben (Lateinischen Buchstaben) Latin) und Leerzeichen.  
12 | **Lösung** Die Lösung sollte die Anzahl der gefundenen Vocale (gemäß Liste) einer einzelnen Text-Zeile, betrennt durch Leerzeichen enthalten.
13 | 
14 | Beispiel:
15 | 
16 |     Eingabe Daten:
17 |     4
18 |     abracadabra
19 |     pear tree
20 |     o a kak ushakov lil vo kashu kakao
21 |     my pyx
22 | 
23 |     Lösung:
24 |     5 4 13 2
25 | 
26 | 


--------------------------------------------------------------------------------
/es/task-22.md:
--------------------------------------------------------------------------------
 1 | <!-- translation by https://github.com/manlug -->
 2 | 
 3 | _Mi colega me ha vuelto a contar este enigma después de visitar una oficina local de la compañía Oracle.
 4 | Espero recordarla exactamente._
 5 | 
 6 | Juan y María fundaron **la editorial J & M** y compraron dos impresoras antiguas para equiparla.
 7 | 
 8 | Ahora tienen su primer encargo: imprimir un documento que consta de páginas `N`.
 9 | 
10 | Las impresoras trabajan a diferentes velocidades. Una imprime una página en `X` segundos y otra en `Y` segundos.
11 | 
12 | Ahora, los fundadores de la empresa, quieren saber el tiempo mínimo necesario para imprimir todo el documento con las dos impresoras.
13 | 
14 | **Datos de entrada** número de casos de prueba en la primera línea.
15 | Luego seguirán los casos de prueba, cada uno en una línea separada.
16 | Cada caso de prueba contiene tres valores enteros, `X Y N`, donde `N` no superara la cantidad de `1,000,000,000`. `X` e `Y` son los segundos/pag. de cada impresora.
17 | 
18 | **La respuesta (salida)** será los tiempos de impresión mínimos para cada uno de los casos de prueba, separados por espacios.
19 | 
20 | Ejemplo:
21 | 
22 | 	Datos entrada:
23 | 	2
24 | 	1 1 5
25 | 	3 5 4
26 | 	
27 | 	Salida:
28 | 	3 9
29 | 


--------------------------------------------------------------------------------
/es/task-41.md:
--------------------------------------------------------------------------------
 1 | <!-- #Median of Three -->
 2 | 
 3 | Probablemente ya resolvistes el problema [Mínimo de tres](./min-of-three--es), ¿ No fue un gran reto ? Los programadores debemos mejorar nuestra lógica (y no solo los conocimientos en lenguajes de programación), cambiaremos el ejercicio para hacerlo más complicado.
 4 | 
 5 | Tendrás de nuevo una tripleta de números, pero ahora debes elegir el del medio de ellos, es decir, ni el más grande, ni el más pequeño. Este número se llama **Mediana** (del conjunto, matriz, etc.).
 6 | 
 7 | Asegúrate de que la solución no sea simplemente "otro ejercicio estúpido" - ya que se utiliza como parte de poderosos algoritmos, QuickSort, por ejemplo.
 8 | 
 9 | **Datos de entrada** contendrán en la primera línea el número de la tripletas a tratar. Las siguientes líneas contendrán una tripleta cada una.  
10 | **La respuesta** medianas seleccionadas de las tripletas, separados por espacios.
11 | 
12 | Ejemplo:
13 | 
14 |     Datos:
15 |     3
16 |     7 3 5
17 |     15 20 40
18 |     300 550 137
19 |     
20 |     Respuestas:
21 |     5 20 300
22 | 
23 | Nota: si la solución contiene muchas declaraciones if-else-if-else, probablemente estés haciendo algo mal. La solución simple no debe tener más de tres.
24 | 


--------------------------------------------------------------------------------
/sk/task-16.md:
--------------------------------------------------------------------------------
 1 | <!-- #Average of an Array -->
 2 | Dôležité odvetvie matematiky, ktoré programovanie často používa je štatistika - t.j. výpočet charakteristiky
 3 | pre nejaké dáta. (Len pomyslite na štatistiky návštev / videnia webstránok atp.)
 4 | Učenie tejto brandže sa zvyčajne začína od zoznámenia sa s **priemernou hodnotou**.
 5 | 
 6 | Priemerná (v angličtine average) hodnota niektorých čísel, sa dá vypočítať ako súčet hodnôt vydelený množstvom. Napríklad:
 7 | 
 8 |     avg(2, 3, 7) = (2 + 3 + 7) / 3 = 4
 9 | 	  avg(20, 10) = (20 + 10) / 2 = 15
10 | 
11 | Dostanete niekoľko polí, a vašou úlohou je pre každé z nich nájsť priemernú hodnotu.
12 | 
13 | **Vstupné dáta** v prvom riadku, poskytnú počet príkladov.      
14 | Za nimi budú nasledovať samotné príklady, jeden na každý riadok. 
15 | Každý príklad obsahuje polia s celými číslami a s hodnotou `0` označujúcu koniec. (Táto nula by nemala
16 | byť zahrnutá vo výpočtoch!!!).  
17 | **Odpoveď** by mala obsahovať priemernú hodnotu pre každé pole, zaokrúhlená k najbližšiemu celému číslu
18 | (viz. [zaokrúhľovanie](./rounding)), oddelenú medzerami.
19 | 
20 | Príklad:
21 | 
22 |     vstupné dáta:
23 |     3
24 |     2 3 7 0
25 |     20 10 0
26 |     1 0
27 |     
28 |     odpoveď:
29 |     4 15 1
30 | 


--------------------------------------------------------------------------------
/es/task-68.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img alt="dos ciclistas" src="https://codeabbey.github.io/data/bycicle_race.png"/>
 3 | </div><br/>
 4 | 
 5 | Dos ciclistas empiezan a moverse simultaneamente desde ciudades diferentes para encontrarse en algún lugar en el medio (no exactamente
 6 | en el punto medio, dado que ellos viajan a diferentes velocidades)
 7 | 
 8 | La carretera está trazada en linea recta entre las dos ciudades.
 9 | 
10 | Te serán dadas las distancia entre las ciudades `S` (en kilometros) y la rapidez para los dos ciclistas (`A` y `B` en
11 | kilometros por hora). Tu tarea es encontrar el punto de encuentro (la distancia medida desde la primera ciudad)
12 | 
13 | **Datos de entrada** tendrá el numero de casos de prueba en la primera linea.  
14 | Las siguientes lineas tendrán tres valores cada una `S A B`.  
15 | **Respuesta** debe contener las distancias entre la primera ciudad y el punto de encuentro (es decir, la distancia recorrida por el primer cilista
16 | antes del cruce entre ellos), separado con espacios.
17 | 
18 | Ejemplo:
19 | 
20 |     datos de entrada:
21 | 	2
22 | 	10 1 1
23 | 	20 1 2
24 | 	
25 | 	respuesta:
26 | 	5 6.66666667
27 | 
28 | *Nota: los valores (punto flotante) deben tener una precision minima de `10e-7`* 
29 | 


--------------------------------------------------------------------------------
/ru/task-16.md:
--------------------------------------------------------------------------------
 1 | <!-- #Среднее в Массиве -->
 2 | Статистика - это важная отрасль математики, притом очень популярная в программировании. По сути это вычисление
 3 | общих характеристик некоего набора данных. Подумайте хотя бы о статистике посещений и просмотров страниц сайта.
 4 | Знакомство с этой дисциплиний обычно начинается с вычисления **среднего значения**.
 5 | 
 6 | Среднее (average, avg) значение для набора чисел определяется как их сумма деленная на их количество, например:
 7 | 
 8 |     avg(2, 3, 7) = (2 + 3 + 7) / 3 = 4
 9 |     avg(20, 10) = (20 + 10) / 2 = 15
10 | 
11 | Вам будут даны несколько списков чисел (массивов) - для каждого из них нужно найти среднее.
12 | 
13 | **Входные данные** в первой строке содержат количество списков.  
14 | Остальные строки содержат по одному списку чисел каждая.  
15 | Числа в каждом списке целые и положительные. Конец списка отмечен значением `0` -
16 | его **не нужно** включать в расчеты!!!  
17 | **Ответ** должен содержать средние значения для каждого из списков, округлённые до ближайшего целого
18 | (см [задачу на округление](./rounding)), разделенные пробелами.
19 | 
20 | Пример:
21 | 
22 |     входные данные:
23 |     3
24 |     2 3 7 0
25 |     20 10 0
26 |     1 0
27 |     
28 |     ответ:
29 |     4 15 1
30 | 


--------------------------------------------------------------------------------
/es/task-31.md:
--------------------------------------------------------------------------------
 1 | Rotar la cadena de caracteres en ´K' significa cortar esos caracteres desde el inicio y transferirlos al final de la cadena.
 2 | Si 'K' es negativo, los caracteres al contrario deben ser transferidos desde el final hasta el inicio.
 3 | 
 4 | **Datos de entrada** contendrán el numero de casos de prueba en la primera linea.
 5 | Las siguientes lineas contendran el numero 'K' y alguna cadena 'S' separada por espacio- un par en cada linea.
 6 | La cadena 'S' contendra unicamente letras en minusculas. 'K' no excederá la mitad de la longitud de 'S' en valor absoluto.
 7 | **Respuesta** debe contener cadenas rotadas de acuerdo con la regla anteriormente dada, separadas por espacios. Por ejemplo:
 8 | 
 9 |     datos de entrada:
10 | 	2
11 | 	3 forwhomthebelltolls
12 | 	-6 verycomplexnumber
13 | 	
14 | 	respuesta:
15 | 	whomthebelltollsfor numberverycomplex
16 | 
17 | La tarea podria ser facilmente resuelta creando una nueva clase de cadena y concatenando las dos subcadenas.
18 | Sin embargo, si quieres un desafio más serio, te puedes animar a desarrollar la rotación "en campo", moviendo los bytes de
19 | la cadena original (Es decir, sin pedir memoria para nuevos datos). Esto podria ser hecho con la ayuda de un loop y solo con 
20 | una variable temporal.
21 | 


--------------------------------------------------------------------------------
/ru/task-10.md:
--------------------------------------------------------------------------------
 1 | <!-- #Линейная Функция -->
 2 | В вычислительном программировании часто встречается задача по определению некой закономерности, в соответствии с которой
 3 | происходит такое-то явление. В учебных целях и в качестве очень простого варианта рассмотрим определение линейной зависимости
 4 | по двум точкам - например, зависимость стоимости дома от его жилой площади.
 5 | 
 6 | Линейная функция определяется уравнением:
 7 | 
 8 |     y(x) = ax + b
 9 | 
10 | Где `a` и `b` - параметры.  
11 | Например, при `a=3, b=2` функция выдаёт значения `y = 2, 5, 8, 11...` для `x = 0, 1, 2, 3...`
12 | 
13 | Наша задача определить неизвестные параметры `a` и `b` по двум имеющимся точкам.  
14 | Т.е. даны две пары значений `(x1, y1), (x2, y2)` которые удовлетворяют уравнению - и нам это уравнение нужно "восстановить".
15 | 
16 | **Входные данные** задают количество тесткейсов в первой строке.  
17 | Далее в отдельных строках следуют сами тесткейсы.  
18 | Каждый содержит `4` целых числа - `x1 y1 x2 y2`.  
19 | **Ответы** также должны быть целыми - значениями для `a` и `b`, объединёнными в скобки попарно и разделенными пробелами.
20 | 
21 | Пример:
22 | 
23 |     входные данные:
24 |     2
25 |     0 0 1 1
26 |     1 0 0 1
27 |     
28 |     ответ:
29 |     (1 0) (-1 1)
30 | 


--------------------------------------------------------------------------------
/de/task-15.md:
--------------------------------------------------------------------------------
 1 | <!-- #Maximum im Array -->
 2 | Diese Aufgabe führt Sie in das Thema "linearer Suchalgorythmus" ein, mit dem Sie sich gut vertraut machen sollten, 
 3 | da es sehr oft auch in komplexeren Programmieraufgaben wie "sortieren" benötigt wird. 
 4 | 
 5 | Eine häufige Verwendung ist z.B. das Auffinden von "Extremen" wie Maximal- und Minimalerte in Zahlenreihen. 
 6 | Um dies zu erreichen, müssen wir uns dieses Mal die Maximal- und Minimalwerte in einer separaten Variable merken, während
 7 | wir uns durch eine Zahlenreihe (Array) durcharbeiten, um jedes Element damit zu vergleichen. 
 8 | Wann immer ein Wert größer als unser gemerktes Maximum bzw kleiner als unser gemerktes Minimum ist, speichern wir diesen Wert 
 9 | erneut in unseren temporären Variablen hierfür als unser neues Maximum bzw. Minimum ab. 
10 | 
11 | Am Ende eines Durchgangs erhalten wir so in den temporären Variablen die "Extremwerte" einer Zahlenreihe.
12 | 
13 | **Eingabe Daten** enthalten dieses Mal exakt `300` Zahlen in einer einzigen Zeile.  
14 | **Lösung** soll nun die Maximum- und Minimumwerte dieser Zeile, getrennt durch Leerzeichen enthalten.
15 | 
16 | Beispiel:
17 | 
18 | 	Eingabe Daten:
19 | 	1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
20 | 	
21 | 	Lösung:
22 | 	300 1
23 | 


--------------------------------------------------------------------------------
/es/task-104.md:
--------------------------------------------------------------------------------
 1 | <!-- #Área del Triángulo -->
 2 | Ser capaz de calcular el área de un triángulo es bastante importante, ya que muchas tareas más complejas a menudo se reducen 
 3 | fácilmente a esto (nosotros también lo usaremos más adelante).
 4 | 
 5 | Uno de los métodos más antiguos conocidos es la [Fórmula de Herón](https://es.wikipedia.org/wiki/F%C3%B3rmula_de_Her%C3%B3n), que toma como entradas 
 6 | las longitudes de los lados del triángulo.
 7 | 
 8 | Sin embargo, en este problema debes escribir un programa que utilice las coordenadas `X` e `Y` de los vértices del triángulo en su lugar. 
 9 | Así que puedes usar esta fórmula de alguna manera o encontrar otra.
10 | 
11 | Los **datos de entrada** contendrán el número de triángulos a procesar.
12 | Las siguientes líneas contendrán `6` valores cada una, en el orden `X1 Y1 X2 Y2 X3 Y3`, describiendo los tres vértices de un triángulo.
13 | La **respuesta** debe dar las áreas de los triángulos separadas por espacios (se espera una precisión de aproximadamente `1e-7`).
14 | 
15 | Ejemplo:
16 | 
17 |     datos:
18 |     3
19 |     1 3 9 5 6 0
20 |     1 0 0 1 10000 10000
21 |     7886 5954 9953 2425 6250 2108
22 |     
23 |     respuesta:
24 |     17 9999.5 6861563
25 | 
26 | _translated by [Alan Garcia](/index/user_profile/st-allan)_


--------------------------------------------------------------------------------
/es/task-10.md:
--------------------------------------------------------------------------------
 1 | Un problema muy común en la programación computacional es determinar la ley subyacente a la cual un fenómeno obedece. Para propósitos de aprendizaje, practiquemos una variante sencilla - descubrir la dependencia lineal de dos observaciones dadas (por
 2 | ejemplo, cómo el precio de un producto depende de su tamaño, peso, etc.)
 3 | 
 4 | Una función lineal está definida por la ecuación:
 5 | 
 6 |     y(x) = ax + b
 7 | 
 8 | Donde `a` y `b` son unas constantes.  
 9 | Por ejemplo, con `a=3, b=2` la función arrojará los valores `y = 2, 5, 8, 11...` cuando `x = 0, 1, 2, 3...`
10 | 
11 | Tu tarea es determinar `a` y `b` usando dos puntos que pertenecen a la función, ej.: Se te indican dos pares de valores `(x1, y1), (x2, y2)` los cuales satisfacen la ecuación de la función - y deberás restaurar la ecuación en sí.
12 | 
13 | Los **Datos en entrada** tienen el número de casos de prueba en la primera línea y luego, en líneas separadas, los casos en sí.  
14 | Cada caso contiene `4` enteros (`x1 y1 x2 y2`).  
15 | Las **Respuestas** deberían ser enteros también y deben escribirse en una línea, separadas con espacios y encerrando cada par en paréntesis, por ejemplo:
16 | 
17 |     datos de entrada:
18 |     2
19 |     0 0 1 1
20 |     1 0 0 1
21 |     
22 |     respuesta:
23 |     (1 0) (-1 1)
24 | 


--------------------------------------------------------------------------------
/ru/task-8.md:
--------------------------------------------------------------------------------
 1 | Арифметическая прогрессия - это последовательность чисел, обладающая особым свойством - каждое следующее значение больше
 2 | предыдущего на фиксированную величину (назовем её "шагом" прогрессии).
 3 | 
 4 | Т.е. разность между `(K+1)`-ым и `K`-ым значениями одинакова для любых `K`.
 5 | 
 6 | Раз так, арифметическая прогрессия полностью определяется начальным значением (`A`) и шагом (`B`).
 7 | Первые несколько значений можно выразить как
 8 | 
 9 |     A,  (A + B),  (A + 2*B),  (A + 3*B), ...
10 | 
11 | Наша задача - вычислить сумму первых нескольких членов арифметической прогрессии. 
12 | [Статья в википедии](http://en.wikipedia.org/wiki/Arithmetic_progression) - или какой-нибудь другой источник могут быть
13 | весьма полезны если вы сталкиваетесь с такими последовательностями впервые.
14 | 
15 | **Входные данные:** первая строка содержит число тестов.  
16 | Остальные строки содержат тесты, по три значения в каждом: `A B N` где `A` это начальное значение последовательности,
17 | `B` её шаг, а `N` количество первых членов которые нужно просуммировать.  
18 | **Ответ** должен содержать результат (сумму первых членов) для каждой тестовой последовательности, через пробел.
19 | 
20 | Пример:
21 | 
22 |     входные данные:
23 |     2
24 |     5 2 3
25 |     3 0 10
26 |     
27 |     ответ:
28 |     21 30
29 | 


--------------------------------------------------------------------------------
/sk/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/min_of_two.gif" alt="Choosing minimum animation"/>
 3 | </div>
 4 | 
 5 | Väčšina programov by mala byť schopná vykonávať výbery a rozhodnutia. My si ideme teraz vyskúšať programovanie
 6 | podmienok. 
 7 | Toto sa zvyčajne vykonáva s `if ... else` výrokmi ktoré môžu vyzerať ako:
 8 | 
 9 |     IF nejaka_podmienka THEN
10 | 	    urob_nieco
11 | 	ELSE
12 | 	    urob_nieco_ine
13 | 	ENDIF
14 | 
15 | V závislosti od vášho programovacieho jazyka syntax môže byť iná a `else` čast je takmer vždy voliteľná.
16 | Viac sa môžete dočítať vo wikipedia článku na [Podmienené príkazy][cond].
17 | 
18 | [cond]: https://cs.wikipedia.org/wiki/Podm%C3%ADn%C4%9Bn%C3%BD_p%C5%99%C3%ADkaz
19 | 
20 | Z dvoch čísel, prosím, vyberte jednu s minimálnou hodnotou. Tu je niekoľko párov čísel pre dôkladné testovanie.
21 | 
22 | **Vstupné dáta** budú obsahovať počet skúšobných príkladov v prvom riadku.  
23 | Nasledujúce riadky budú obsahovať páry čísel pre porovnanie.  
24 | Ako **Odpoveď** prosím vložte rovnaký počet menších čísel oddelený medzerou, napríklad:
25 | 
26 |     dáta:
27 |     3
28 |     5 3
29 |     2 8
30 |     100 15
31 |     
32 |     odpoveď:
33 |     3 2 15
34 | 
35 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
36 | 


--------------------------------------------------------------------------------
/ro/task-15.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <iframe width="420" height="315" src="//www.youtube.com/embed/G4w8MZ9TIaI" frameborder="0" allowfullscreen></iframe><div class="hint">Pentru mai multe explicații, urmărește acest video</div>
 3 | </div>
 4 | 
 5 | In această problemă vei face cunoștință cu un algoritm foarte popular numit "căutare liniară" sau "linear search". Acest algoritm este foarte des folosit în cadrul unor sarcini mai complexe (sortarea datelor etc)
 6 | 
 7 | Foarte des avem nevoie să cunoaștem valoarea maximă sau minimă dint-un ansamblu de numere sau dintr-un tablou. Pentru a rezolva această problemă, trebuie să salvăm **valoarea maximă curentă** (sau valoare minimă) intr-o variabilă, iar apoi să parcurgem tabloul și să o comparăm cu fiecare număr din acest tablou. Atunci când un număr este mai mare decăt **valoarea maximă curentă**, acest numar devine noua valoare maximă.
 8 | 
 9 | O dată ce toate valorile au fost epuizate, această variabilă temporară va conține numarărul maxim din tablou.
10 | 
11 | **Datele de intrare** conțin pe o singură linie, exact `300` de numere.  
12 | **Răspunsul** ar trebui să conțină numărul maxim si numărul minim din acest tablou, separate print spațiu.
13 | 
14 | Exemplu:
15 | 
16 | 	Date de intrare:
17 | 	1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2
18 | 	
19 | 	Răspuns:
20 | 	300 1
21 | 


--------------------------------------------------------------------------------
/es/task-16.md:
--------------------------------------------------------------------------------
 1 | Una rama importante de las matemáticas que usa extensivamente la programación es la estadística - ej.: cálculo de características
 2 | de algún conjunto de datos (Piensa en las estadísticas de visitantes/visualizaciones de página del sitio, etc.).
 3 | El aprendizaje de esta disciplina se inicia usualmente familiarizándose con el concepto de **valor promedio**.
 4 | 
 5 | El valor promedio (o media) de varios números puede ser calculado como su suma dividida por su cantidad. Por ejemplo:
 6 | 
 7 |     prom(2, 3, 7) = (2 + 3 + 7) / 3 = 4
 8 |     prom(20, 10) = (20 + 10) / 2 = 15
 9 | 
10 | Te serán dados varios vectores, para cada uno de los cuales encontrarás un valor promedio.
11 | 
12 | Los **Datos de entrada** darán el número de casos de prueba en la primera línea.  
13 | Después seguirán los casos de prueba en sí, un caso por línea.  
14 | Cada caso de prueba describe un vector de números enteros, con el valor `0` señalando su finalización (¡¡¡este cero no debe ser
15 | incluido en los cálculos!!!).  
16 | La **Respuesta** debería contener valores promedios para cada vector, redondeados al entero más cercano (ver la [tarea sobre Redondeo](./rounding)), y separados por espacios.
17 | 
18 | Ejemplo:
19 | 
20 |     datos de entrada:
21 |     3
22 |     2 3 7 0
23 |     20 10 0
24 |     1 0
25 | 
26 |     respuesta:
27 |     4 15 1
28 | 
29 | 


--------------------------------------------------------------------------------
/de/task-16.md:
--------------------------------------------------------------------------------
 1 | Ein wichtiger Zweig der Mathematik, welcher sich stark auf die Programmierung stützt, ist die Statistik - d.h. die Berechnung von Merkmalen
 2 | für bestimmte Daten. (Man denke nur an die Statistik von Besuchern / Aufrufe einer Website usw.)
 3 | Das Erlernen dieser Disziplin beginnt in der Regel mit dem Kennenlernen eines **Durchschnittswerts**.
 4 | 
 5 | Der Durchschnitt (oder Mittelwert) einiger Zahlen kann als ihre Summe geteilt durch die Anzahl der Zahlen berechnet werden. Als Beispiel:
 6 | 
 7 |     avg(2, 3, 7) = (2 + 3 + 7) / 3 = 4
 8 |     avg(20, 10) = (20 + 10) / 2 = 15
 9 | 
10 | Sie erhalten mehrere Arrays, für die Sie jeweils den Durchschnittswert ermitteln sollen.
11 | 
12 | Die **Eingabe Daten** enthalten die Anzahl der Testfälle in der ersten Zeile.  
13 | Daraufhin folgen die Testfälle selbst, einer pro Zeile.  
14 | Jeder Testfall beinhaltet ein Array mit positiven Ganzzahlen, der Wert `0` markiert jeweils das Ende eines Arrays. (diese Null soll nicht
15 | bei der Berechnung mit einbezogen werden!!!).  
16 | Die **Antwort** sollte den Durchschnittswert für jedes einzelne Array enthalten, gerundet auf die nächste Ganzzahl (siehe [task on rounding](./rounding)), und mit einem Leerzeichen getrennt.
17 | 
18 | Beispiel:
19 | 
20 |     Eingabe Daten:
21 |     3
22 |     2 3 7 0
23 |     20 10 0
24 |     1 0
25 |     
26 |     Antwort:
27 |     4 15 1
28 | 


--------------------------------------------------------------------------------
/ar/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="centered hint">
 2 | 	<img alt="CodeAbbey Monks struggle with bug" src="https://codeabbey.github.io/data/min_of_two.gif"/><br/>
 3 | 	<span>Artist's impression of programmers struggling with The Bug.</span><br/>
 4 | 	<span>Note that proper tools may be helpful!</span>
 5 | </div>
 6 | بما أن البداية قد تكون صعبة في بعض الأحيان, دعنا نبدأبأبسط مشكلة ممكنة
 7 |  الهدف من حل هذه المسألة هو الإ عتياد عل استخدام 
 8 | هذا الموقع .
 9 | 
10 | المطلوب في هذه المسألة جمع الرقمين المعطيين وإعطاء النتيجة,من المؤكد أن حل هذه المشكلة يمكن القيام به دون الحاجة للحاسب
11 | ولكن حاول كتابة برنامج بسيط بأي لغة برمجية تريدها
12 | 
13 | 
14 | _[هذا الفيديو](http://www.youtube.com/watch?v=gxfqeDm-B6k) يظهر الخطوات اللازمة_
15 | 
16 | ###كيفية تسجيل حلك
17 | إذا كنت مسجلاً بالموقع سيكون من الممكن رؤية الحقول في الأسفل:
18 |   
19 | 
20 | - **المعطيات** رقمين المراد جمعهما 
21 | - **الجواب** - هو الحقل الذي ستضح حلك ضمنه
22 | - **حلك** - هو الحقل الذي ستضع برنامجك ضمنه,لن يتم التحقق من صحة البرنامج
23 | - إلا أن تسجيل الحل سيساعدك على إعادة استخدامه لاحقاً
24 | - في حال احتجته ضمن برنامج آخر
25 | - بإمكانك قراءة حلك  و الإطلاع عليه مت شئت في حال قمت بتسجيله
26 | 
27 | مثال
28 | 
29 | 	المعطيات:
30 | 	3 5
31 |     	
32 |     الجواب:
33 | 	8
34 | 
35 | تمت إضافة حلول **[samples](../wiki/running)** لهذه المشكلة بلغات مختلفة
36 | لكننا ننصحك بعدم الإطلاع على هذه الحلول قبل أن تحاول حل المشكلة
37 | 


--------------------------------------------------------------------------------
/ru/task-81.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сумма Бит в Числе -->
 2 | Мы знаем, что компьютеры представляют числа в своей памяти в
 3 | [двоичной системе](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F).
 4 | В этой несложной задаче мы напишем программу, которая подсчитывает количество ненулевых бит в заданном числе.
 5 | 
 6 | Мы используем `32-битовые` целые числа, поэтому количество ненулевых бит может быть от `0` до `32`.
 7 | 
 8 | _Заметим, что в отличие от многих языков Python оперирует числами бесконечной разрядности
 9 | (это не помешает решить данную задачу, однако некоторые способы пригодные для других языков могут работать некорректно)._
10 | 
11 | Например:
12 | 
13 |     число            двоичное                кол-во
14 |       1   00000000000000000000000000000001      1
15 |     100   00000000000000000000000001100100      3
16 |      -1   11111111111111111111111111111111     32
17 | 
18 | **Входные данные** указывают количество чисел для обработки в первой строке.  
19 | Остальные строки содержат сами числа, в диапазоне `-2 000 000 000` .. `2 000 000 000`.  
20 | **Ответ** должен содержать количество бит установленных в `1` для каждого из заданных чисел.
21 | 
22 | Пример:
23 | 
24 |     входные данные:
25 |     3
26 |     1 100 -1
27 |     
28 |     ответ:
29 |     1 3 32
30 | 


--------------------------------------------------------------------------------
/ro/task-6.md:
--------------------------------------------------------------------------------
 1 | Atunci când un program conține numere care au o parte fracționară, preferăm uneori să **rotunjim** asemenea valori la cel mai apropiat număr întreg, deoarece nu ne înteresează zecimalele. Vom folosi acest procedeu ulterior, în cadrul altor probleme (pentru a simplifica răspunsurile).
 2 | 
 3 | Datele de intrare consistă din câteva perechi de numere. Pentru fiecare pereche, sarcina ta este să împarți primul număr la al doilea și să rontunjești câtul **la cel mai apropiat** număr întreg.
 4 | 
 5 | În cazul in care partea fracționară este exact `0.5`, numărul ar trebui rotunjit prin adaos (poți aduna `0.5` la numărul inițial). Pentru numerele negative "mai mare" înseamna "mai aproape de zero". Poți consulta acest articol pe Wikipedia despre [Rounding](http://en.wikipedia.org/wiki/Rounding#Round_half_up) pentru mai multe explicații.
 6 | 
 7 | Dacă in problemele viitoare va fi necesară rotunjirea rezultatului, poți folosi acest procedeu (excepție fiind cazul în care un alt procedeu este specificat)
 8 | 
 9 | **Datele de intrare** conțin pe o singură linie numărul de perechi.  
10 | Următoarele linii conțin perechile de numere propriu-zise.  
11 | **Răspunsul** ar trebui să conțină câtul fiecarei perechi, rotunjit prin procedeul descris mai sus si separat prin spațiu.
12 | 
13 | Exemplu:
14 | 
15 | 	Date de intrare:
16 | 	3
17 | 	12 8
18 | 	11 -3
19 | 	400 5
20 | 	
21 | 	Răspuns:
22 | 	2 -4 80
23 | 


--------------------------------------------------------------------------------
/es/task-19.md:
--------------------------------------------------------------------------------
 1 | Se nos dan cadenas que contienen `4` tipos de paréntesis - redondo `()`, cuadrado `[]`, rizado `{}` y angular `<>`.
 2 | El objetivo es verificar si los paréntesis están en la secuencia correcta, ej.: cualquier paréntesis de apertura debería tener un paréntesis de cierre del mismo tipo en algún lugar posterior de la cadena, y que los pares de paréntesis no deberían superponerse (aunque podrían estar anidados):
 3 | 
 4 | 	(a+[b*c] - {d/3})  - aquí los paréntesis cuadrados y rizados
 5 | 	                        están anidados en los redondos
 6 | 	
 7 | 	(a+[b*c) - 17]     - aquí los paréntesis cuadrados se superponen
 8 | 	                        con los redondos, lo cual no tiene sentido
 9 | 
10 | Los **Datos de entrada** contendrán el número de casos de prueba en la primera línea.  
11 | Después seguirá el número especificado de líneas, cada una conteniendo un caso de prueba en forma de una secuencia de caracteres.  
12 | La **Respuesta** debería contener `1` (si el orden de los paréntesis es correcto) o `0` (si es incorrecto) para cada caso de prueba, y separados por espacios.
13 | 
14 | Ejemplo:
15 | 
16 | 	datos de entrada:
17 | 	4
18 | 	(a+[b*c]-{d/3})
19 | 	(a + [b * c) - 17]
20 | 	(((a * x) + [b] * y) + c
21 | 	auf(zlo)men [gy<psy>] four{s}
22 | 	
23 | 	respuesta:
24 | 	1 0 0 1
25 | 
26 | _¡Nota que todos los caracteres que no son paréntesis pueden ser ignorados sin inconvenientes!_
27 | 


--------------------------------------------------------------------------------
/fr/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/min_of_two.gif" alt="Animation: Choisir le minimum"/>
 3 | </div>
 4 | 
 5 | La plupart des programmes doivent pouvoir effectuer des choix afin de prendre des décisions.
 6 | Nous allons maintenant voir comment programmer avec des conditions.
 7 | 
 8 | Ceci est habituellement accompli avec une instruction similaire à `if ... then ... else` (SI ... ALORS ... SINON) 
 9 | qui ressemble généralement à ceci:
10 | 
11 |     IF une_condition THEN
12 |         faire_quelque_chose
13 |     ELSE
14 |         faire_autre_chose
15 |     ENDIF
16 | 
17 | Tout dépendant de votre langage de programmation, la syntaxe peut différer et la portion `else` est presque
18 | toujours optionnelle.
19 | 
20 | Plus de détails sont donnés sur Wikipédia: [Conditional statements][cond].
21 | 
22 | [cond]: http://en.wikipedia.org/wiki/Conditional_(computer_programming)
23 | 
24 | De deux nombres, choisissez celui avec la valeur minimale. Voici plusieurs paires de nombre pour des tests approfondis.
25 | 
26 | **Input data** contient le nombre de cas à tester sur la première ligne.  
27 | Les lignes suivantes contiennent les paires de nombre à tester.  
28 | Pour la réponse (**Answer**) indiquez le minimum de chaque ligne avec des espaces comme séparateur.
29 | 
30 |     data:
31 |     3
32 |     5 3
33 |     2 8
34 |     100 15
35 |     
36 |     answer:
37 |     3 2 15
38 | 


--------------------------------------------------------------------------------
/de/task-10.md:
--------------------------------------------------------------------------------
 1 | <!-- #Eine lineare Funktion -->
 2 | Ein häufiges Problem bei der Computerprogrammierung besteht darin, das einem bestimmten Phänomen zugrunde liegende Gesetz zu bestimmen.
 3 | Aus Lernzwecken wollen wir eine einfache Variante üben - die Entdeckung der linearen Abhängigkeit durch zwei gegebene Beobachtungen (zum Beispiel, wie der Preis
 4 | für ein Produkt von seiner Größe, seinem Gewicht usw. abhängt)
 5 | 
 6 | Eine lineare Funktion wird durch eine Gleichung definiert, bei der `a` und `b` Konstanten sind:
 7 | 
 8 |     y(x) = ax + b
 9 |  
10 | Als Beispiel, mit `a=3, b=2` erzeugt die Funktion die Werte `y = 2, 5, 8, 11...`  
11 | für `x = 0, 1, 2, 3...`
12 | 
13 | Ihre Aufgabe ist es, `a` und `b` mithilfe von zwei Punkten zu bestimmen, die zur Funktion gehören.  
14 | D.h. Sie erhalten zwei Paare mit Werten `(x1, y1), (x2, y2)`, die die Funktionsgleichung erfüllen - und sollen die Gleichung selbst wiederherstellen.
15 | 
16 | **Eingabe Daten** enthalten die Anzahl der Testfälle in der ersten Zeile  
17 | und dann die Testfälle selbst in einzelnen Zeilen.  
18 | Jeder Testfall besteht aus `4` Ganzzahlen (`x1 y1 x2 y2`).  
19 | Die **Antwort** sollte ebenfalls aus ganzzahligen Paaren bestehen, die jeweils in einer Zeile mit Leerzeichen getrennt und von Klammern umschlossen sind, als Beispiel:
20 | 
21 |     Eingabe Daten:
22 |     2
23 |     0 0 1 1
24 |     1 0 0 1
25 |     
26 |     Antwort:
27 |     (1 0) (-1 1)
28 | 


--------------------------------------------------------------------------------
/ro/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <iframe width="560" height="315" src="//www.youtube.com/embed/P-2BWHbW-SA?list=UUdMYRtGxMim55ghdPFupLGQ" frameborder="0" allowfullscreen></iframe>
 3 | <div class="hint">Pentru mai multe explicații, urmărește acest video</div>
 4 | </div>
 5 | 
 6 | Marea majoritate a programelor sunt capabile să aleagă dintre diverse optiuni, decizii. Acum vei descoperi un nou concept, numit programarea condițională. 
 7 | Acest concept are la bază declarații de tip `if ... else` in urmatorul format:
 8 | 
 9 |     IF o_oarecare_condiție THEN
10 | 	    ia_această_decizie
11 | 	ELSE
12 | 	    ia_cealaltă_decizie
13 | 	ENDIF
14 | 
15 | În dependență de limbajul de programare pe care îl folosești, sintaxa acestuia poate fi diferită, iar partea `else` poate fi opțională.
16 | 
17 | Poți afla mai multe citind acest articol pe wikipedia [Conditional statements][cond].
18 | [cond]: http://en.wikipedia.org/wiki/Conditional_(computer_programming)
19 | 
20 | Sarcina ta este să gasești numărul minim dintre două numere naturale. 
21 | 
22 | **Datele de intrare** conțin pe prima line -  numarul total de perechi.  
23 | Următoarele linii conțin perechile de numere propriu-zise.  
24 | **Răspunsul** ar trebui să conțină numărul minim din fiecare pereche, separat prin spațiu.
25 | 
26 | 
27 | Exemplu:
28 | 
29 |     Date de intrare:
30 |     3
31 |     5 3
32 |     2 8
33 |     100 15
34 |     
35 |     Răspuns:
36 |     3 2 15
37 | 


--------------------------------------------------------------------------------
/sk/task-28.md:
--------------------------------------------------------------------------------
 1 | Poďme použiť naše programátorské skúsenosti na nejaký kvázi-vedecký problém - pretože čisto abstraktné
 2 | veci sú trošku nudné.
 3 | 
 4 | Jednoduché meranie indexu telesnej hmotnosti bolo navrhnuté v strede XIX storočia. Záleží iba na výške a
 5 | hmotnosti dotyčnej osoby - v angličtine nazývané **Body Mass Index** alebo **BMI**. Je definované ako:
 6 | 
 7 |     BMI = váha / výška^2
 8 | 
 9 | Pričom váha je v `kilogramoch` a výška v `metroch`.
10 | 
11 | Medzi telesné stupne patria:
12 | 
13 | 	Podvýživa       -           BMI < 18.5
14 | 	Normálna váha   -   18.5 <= BMI < 25.0
15 | 	Nadváha         -   25.0 <= BMI < 30.0
16 | 	Obezita         -   30.0 <= BMI
17 | 
18 | Napríklad, ak vážim  `80 kg` a mám výšku `1.73 m` môžem vypočítať:
19 | 
20 |     BMI = 80 / (1.73)^2 = 26.7
21 | 
22 | t.j. mierna nadváha.
23 | 
24 | O správnosti alebo nesprávnosti tohoto merania nebudeme diskutovať. Namiesto toho vypočítajte miery pre 
25 | niekoľko ľudí.
26 | 
27 | **Vstupné dáta** obsahuje počet ľudí na prvom riadku.  
28 | V každom ďaľšom riadku budú dve hodnoty - váha v kilogramoch a výška v metroch.  
29 | **Odpoveď** by mala obsahovať text `under` pre podvýživu, `normal` pre normálnu váhu,
30 | `over` pre nadváhu a `obese` pre obezitu pre každý korešpondujúci príklad, oddelený medzerami.
31 | Napríklad:
32 | 
33 |     vstupné dáta:
34 | 	3
35 | 	80 1.73
36 | 	55 1.58
37 | 	49 1.91
38 | 	
39 | 	odpoveď:
40 | 	over normal under
41 | 


--------------------------------------------------------------------------------
/de/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img src="https://codeabbey.github.io/data/min_of_two.gif" alt="Kleinstes wählen Animation"/>
 3 | </div>
 4 | 
 5 | Oft müssen Programme Entscheidungen zum Ablauf eines Programms treffen. Darum werden wir jetzt etwas "Bedingte Anweisungen und Verzweigungen" üben. 
 6 | Üblicherweise wird das mit Hilfe des `if ... else` statements geschehen, das wie folgt aussieht:
 7 | 
 8 |     IF irgendeine_aussage THEN
 9 | 	    tu_dies
10 | 	ELSE
11 | 	    tu_was_anderes
12 | 	ENDIF
13 | 
14 | Abhängig von Ihrer gewählten Programmiersprache kann die Syntax etwas davon abweichen und der `else` Teil ist fast immer nur optional. 
15 | Im Wikipedia Artikel über [Bedingte Anweisung und Verzweigung][cond] können Sie mehr darüber nachlesen.
16 | 
17 | [cond]: https://de.wikipedia.org/wiki/Bedingte_Anweisung_und_Verzweigung
18 | 
19 | Gegeben sind zwei Zahlen, von denen Sie jeweils immer die kleinste Zahl als Lösung wählen. Insgesamt stehen aber mehrere Zahlenpaare zur Verarbeitung bereit. 
20 | 
21 | **Eingabe Daten** enthält in der ersten Zeile die Anzahl der zur Verarbeitung anstehenden Zahlenpaare.  
22 | Die nachfolgenden Zeilen enthalten die Zahlenpaare, dessen Elemente es zu vergleichen gilt.  
23 | Als **Lösung** geben Sie bitte stets das kleinste Element durch Leerzeichen getrennt an. Zum Beispiel:
24 | 
25 |     Daten:
26 | 	3
27 |     5 3
28 |     2 8
29 |     100 15
30 |     
31 |     Lösung:
32 |     3 2 15
33 | 


--------------------------------------------------------------------------------
/ru/task-26.md:
--------------------------------------------------------------------------------
 1 | <!-- #Наибольший Общий Делитель -->
 2 | Кажется ни один из курсов программирования не обходится без упражнений на Евклидов алгоритм вычисления Наибольшего Общего
 3 | Делителя (НОД или GCD).
 4 | 
 5 | НОД двух чисел `A` и `B` называют такое третье число `C` что оба первых делятся на него без остатка, при этом
 6 | `C` должно быть наибольшим из возможных. Например `gcd(20, 35) = 5` а `gcd(13, 28) = 1`. Алгоритм Евклида заключается в том что
 7 | из большего числа вычитают меньшее, повторяя эту операцию пока числа не сравняются - это и будет НОД. Для ускорения можно не
 8 | вычитать, а брать остаток от деления.
 9 | 
10 | Если кажется что это очень абстрактные математические "фокусы", то стоит обратить внимание что делимость чисел вообще и НОД
11 | в частности положены в основу современной криптографии (в чем вы убедитесь из дальнейших задач).
12 | 
13 | Наименьшее общее кратное (НОК или LCM) - это наименьшее из чисел `D` которые делятся и на `A` и на `B`. Его можно найти
14 | так:
15 | 
16 |     lcm(A, B) = A * B / gcd(A, B)
17 | 
18 | ### Задача
19 | 
20 | **Входные данные** указывают количество тестов в первой строке.  
21 | Дальше идут тестовые строки, каждая содержит по два числа - `A` и `B`.  
22 | **Ответ** должен содержать НОД и НОК каждой пары, заключенные в скобки и разделенные пробелами.
23 | 
24 | Пример:
25 | 
26 |     входные данные:
27 |     2
28 |     2 3
29 |     4 10
30 |     
31 |     ответ:
32 |     (1 6) (2 20)
33 | 


--------------------------------------------------------------------------------
/sk/task-21.md:
--------------------------------------------------------------------------------
 1 | Z tohto problému sa naučíme populárny programovací trik používaný v mnohých variantoch štatistických výpočtov.
 2 | 
 3 | Predstavte si, že nejaký horár chce spočítať borovice, jedle a brezy nejakej časti lesa. Môže ísť cez túto časť lesa
 4 | trikrát, pričom bude počítať iba borovice pri prvom prechode, jedle pri druhom a pri treťom iba brezy
 5 | 
 6 | Efektívnejší spôsob by bolo prejsť cez les iba raz a pre každý strom pridať jednu bodku do troch stránok v jeho
 7 | zošite - prvá strana pre borovice, ďalšia pre jedle a posledná pre brezy. To je myšlienka počítania podobných prvkov
 8 | v poradí pomocou poľa počítadiel (namiesto zošita).
 9 | 
10 | Tu je pole s dĺžkou `M` s číslami od `1` po `N`, kde `N` je menšie alebo rovné  `20`.
11 | Prejdeme cez pole, a spočítame koľkokrát sa tam každé číslo vyskytuje.
12 | T.j niečo podobné ako úloha [počítanie samohlások](./vowel-count) , akurát potrebujeme viac ako jedno počítadlo.
13 | Uistite sa, že máte samostatné pole, aby ste nevytvárali veľa oddelených premenných pre každé počítadlo.
14 | 
15 | **Vstupné dáta** obsahuje `M` a `N` v prvom riadku.  
16 | Druhý (pomerne dlhší) riadok obsahuje hodnoty `M` oddelené medzerami.  
17 | **Odpoveď** by mala obsahovať presne `N` hodnôt, oddelené medzerami. Prvá by mala byť počet `jednotiek`,
18 | druhá počet - `dvojok` a tak ďalej.
19 | 
20 | Príklad:
21 | 
22 | 	vstupné dáta:
23 | 	10 3
24 | 	3 2 1 2 3 1 1 1 1 3
25 | 	
26 | 	odpoveď:
27 | 	5 2 3
28 | 


--------------------------------------------------------------------------------
/de/task-41.md:
--------------------------------------------------------------------------------
 1 | Sie haben vielleicht die Übungsaufgabe [Minimum aus Dreien](./min-of-three) schon gelöst. Und vielleicht war es auch gar nicht so schwer für Sie?
 2 | Programmierer sollten nicht nur ihre Programmierkenntnisse fördern, sondern auch ihr logisches Denken.
 3 | Lassen Sie uns daher die Aufgabe etwas schwerer machen. 
 4 | 
 5 | Wieder erhalten Sie Dreier-Gruppen von Nummern. Aber dieses mal müssen Sie uns jeweils die Mittlere nennen.
 6 | Also nicht die größte oder kleinste Zahl, sondern die mittlere ist zu benennen. Diese "mittlere" Zahl einer sortierten Reihe nennt man **Median**.
 7 | 
 8 | Bitte nehmen Sie zur Kenntnis, dass es sich hierbei nicht einfach nur um "irgendeine weitere dumme Übungsaufgabe" handelt, sondern dies z.B. ein wichtiger Teil des "Quicksort Algorythmus" ist.
 9 | 
10 | **Eingabe Daten** enthalten in der ersten Zeile wie Anzahl der zu verarbeitenden Dreiergruppen.  
11 | Die nachfolgenden Zeilen enthalten jeweils eine Dreiergruppe an Zahlen, durch Leerzeichen getrennt.  
12 | **Lösung** sollte den "Median" aller Dreiergruppen durch Leerzeichen getrennt in einer Zeile auflisten. 
13 | 
14 | Beispiel:
15 | 
16 |     Eingabe Daten:
17 |     3
18 |     7 3 5
19 |     15 20 40
20 |     300 550 137
21 | 
22 |     Lösung:
23 |     5 20 300
24 | 
25 | Anmerkung: Falls ihr Programm viele "if-else-if-else" Statements enthält, machen Sie vermutlich etwas falsch. 
26 | Eine einfache Lösung sollte nicht mehr als nur drei enthalten.
27 | 


--------------------------------------------------------------------------------
/es/task-6.md:
--------------------------------------------------------------------------------
 1 | Cuando los programas procesan números que tienen una parte decimal, algunas veces queremos **redondear** tales valores a números enteros. Necesitaremos esto para programar algunos problemas posteriores (por ejemplo, para hacer las respuestas más sencillas), así que
 2 | dediquemos el siguiente ejercicio a aprender este truco.
 3 | 
 4 | Hay varios pares de números. Para cada par, dividirás el primer número entre el segundo y mostrarás el resultado redondeado al entero **más cercano**.
 5 | 
 6 | En ciertos casos, cuando el resultado contenga exactamente `0.5` como parte decimal, el valor debería ser redondeado hacia arriba
 7 | (ej.: sumando otro `0.5`). Nota que para valores negativos, "mayor que" quiere decir
 8 | "más cercano a cero". Revisa la página de Wikipedia sobre [Redondeo](https://es.wikipedia.org/wiki/Redondeo)
 9 | para explicación más detallada.
10 | 
11 | En cualquier problema posterior, cuando se mencione redondeo - se asume que es el mismo
12 | algoritmo de redondeo (a menos que explícitamente se especifique otro).
13 | 
14 | Los **Datos de entrada** darán un número de casos en la primera línea.  
15 | Cada una de las siguientes líneas contendrá un caso de prueba (ej.: un par de números).  
16 | La **Respuesta** debería contener los resultados divididos y redondeados para cada par, separados por espacios.
17 | 
18 | Ejemplo:
19 | 
20 | 	datos de entrada:
21 | 	3
22 | 	12 8
23 | 	11 -3
24 | 	400 5
25 | 	
26 | 	respuesta:
27 | 	2 -4 80
28 | 


--------------------------------------------------------------------------------
/ru/task-7.md:
--------------------------------------------------------------------------------
 1 | <!-- #Перевод из Фаренгейта в Цельсия -->
 2 | Это упражнение так популярно, что вы его можете найти во многих книгах и курсах по программированию (хотя бы в
 3 | классической книге Кернигана и Ричи по языку Си).
 4 | 
 5 | <div class="text-center">
 6 | 	<img alt="сравнение шкал фаренгейта и цельсия" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 7 | </div>
 8 | 
 9 | *Примечание: задача [Rounding](./rounding) объясняет алгоритм округления используемый ниже.*
10 | 
11 | В Европе температуру чаще измеряют в градусах Цельсия, а в США - по Фаренгейту. Обе эти шкалы равномерные, но
12 | по Цельсию вода замерзает при `0` и кипит при `100`, а по Фаренгейту при `32` и `212` соответственно. Вам предлагается
13 | использовать эти две точки для преобразования остальных значений.
14 | 
15 | Напишите программу, преобразующие значения по шкале Фаренгейта в значения по шкале Цельсия.
16 | 
17 | **Входные данные** содержат `N+1` значение, первое из которых это само `N` - количество показаний температуры, которые
18 | нужно преобразовать (**Внимание** это первое число преобразовывать, конечно, не нужно).  
19 | **Ответ** должен содержать ровно `N` результаов, округлённых до ближайшего целого и разделенных пробелами.
20 | 
21 | Пример:
22 | 
23 |     входные данные:
24 |     5 495 353 168 -39 22
25 |     
26 |     ответ:
27 |     257 178 76 -39 -6
28 | 
29 | **Ещё раз заметьте: первое число `5` это не температура, а количество остальных чисел!!**
30 | 


--------------------------------------------------------------------------------
/sk/task-6.md:
--------------------------------------------------------------------------------
 1 | Keď sa program vysporiadava s číslami, ktoré majú desatinú časť, niekedy chceme takéto hodnoty **zaokrúhliť** na celé čísla.
 2 | Toto budeme potrebovať na programovanie niektorých neskorších problémov (na zjednodušovanie odpovedí, napríklad), takže sa
 3 | poďme naučiť tento trik s nasledujúcou úlohou.
 4 | 
 5 | Máme tu niekoľko párov čísel. Pre každý pár najprv vydelíte prvé číslo druhým a výsledok
 6 | bude zaokrúhlený **na najbližšie** celé číslo.
 7 | 
 8 | V prípadoch, keď výsledok obsahuje na mieste desatiného čísla presne `0.5` hodnota by mala byť zaokrúhlena nahor.
 9 | (t.j. ďalším pridaním `0.5`). Všimnite si, že pre záporne hodnoty "väčšie" znamená
10 | "bližšie k nule". Viac na článku [Zaokrúhľovanie](https://cs.wikipedia.org/wiki/Zaokrouhlen%C3%AD)
11 | pre presnejšie vysvetlenia.
12 | 
13 | V každých ďalších problémoch, kde je spomenuté zaokrúhľovanie - sa predpokladá použitie
14 | tohoto istého algoritmu (pokiaľ nie je inak špecifikované).
15 | 
16 | **Vstupné dáta** v prvom riadku je počet skúšobných príkladov.  
17 | Ďalšie riadky budú obsahovať jeden skúšobný príklad (t.j. číselný pár) pre každý riadok.  
18 | **Odpoveď** by mala obsahovať delenie a zaokrúhlenie výsledku pre každý pár oddelený medzerami.
19 | 
20 | Príklad:
21 | 
22 | 	vstupné dáta:
23 | 	3
24 | 	12 8
25 | 	11 -3
26 | 	400 5
27 | 	
28 | 	odpoveď:
29 | 	2 -4 80
30 | 
31 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
32 | 


--------------------------------------------------------------------------------
/es/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="demo of summing an array" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | Ahora nuestro objetivo es aprender los **bucles** - ej: acciones repetidas.
 6 | Vamos a encontrar la suma de varios números (más de dos). Será muy útil hacer esto en un bucle.
 7 | Tal como se ve en la figura de arriba - puedes crear la variable `sum` y sumarle cada valor de la lista.
 8 | Quizá un [bucle "for" o bucle "for"](https://es.wikipedia.org/wiki/Bucle_for) funcione bastante bien ya que la cantidad de números se conoce de antemano.
 9 | 
10 | Si tienes problemas, intenta primero [Sums In Loop](./sums-in-loop) - es probablemente más fácil.
11 | 
12 | Los **datos de entrada** tienen el siguiente formato:
13 | 
14 | - la primera línea contiene `N` - la cantidad de valores a sumar;
15 | - la segunda línea contiene los valores `N` propiamente.
16 | 
17 | La **respuesta** deberían contener un único valor - la suma de los `N` valores.
18 | 
19 | Ejemplo:
20 | 
21 | 	datos de entrada:
22 | 	8
23 | 	10 20 30 40 5 6 7 8
24 | 	
25 | 	respuesta:
26 | 	126
27 | 
28 | **Nota** ya que hay varias docenas de números, no deberías copiarlos manualmente en tu programa.
29 | En lugar de eso, haz que tu programa los lea desde la entrada estándar (donde puedes copiarlos todos de una vez). Nota que si 
30 | corres el código en nuestro servidor, los datos son, por conveniencia, automáticamente copiados a la entrada estándar.
31 | 


--------------------------------------------------------------------------------
/ru/task-67.md:
--------------------------------------------------------------------------------
 1 | <!-- #Последовательность Фибоначчи -->
 2 | Даже начинающие программисты обычно знакомы с **Последовательностью Фибоначчи** которая задаётся так:
 3 | 
 4 | - 0-е значение равно `0`;
 5 | - 1-е значение равно `1`;
 6 | - все остальные значения являются суммой двух неподсредственно предшествующих.
 7 | 
 8 | Таким образом получается:
 9 | 
10 |     0: 0
11 |     1: 1
12 |     2: 1 = 0 + 1
13 |     3: 2 = 1 + 1
14 |     4: 3 = 1 + 2
15 |     5: 5 = 2 + 3
16 |     6: 8 = 3 + 5
17 | 
18 | и так далее, так что если вы продолжите вычисления самостоятельно, то получите начало последовательности вроде:
19 | 
20 |     0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...
21 | 
22 | Легко заметить что значения растут весьма быстро! `17-е` уже больше тысячи, а `31-е` превышает миллион...
23 | 
24 | **Задача**
25 | 
26 | Даны несколько чисел Фибоначчи. Требуется найти их номер в последовательности Фибоначчи.
27 | 
28 | **Входные данные** в первой строке указано количество чисел Фибоначчи которые нужно обработать.  
29 | Остальные строки содержат по одному числу Фибоначчи каждая (из первой тысячи таких чисел).  
30 | **Ответ** должен содержать индексы (номера в последовательности) этих чисел, разделенные пробелами.
31 | 
32 | Пример:
33 | 
34 |     входные данные:
35 |     5
36 |     610
37 |     34
38 |     0
39 |     1346269
40 |     10946
41 |     
42 |     ответ:
43 |     15 9 0 31 21
44 | 
45 | *Внимание: значения могут содержать более сотни цифр!*
46 | 


--------------------------------------------------------------------------------
/sk/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="demo of summing an array" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | Teraz je náš cieľ naučiť sa **cykly** - t.j. opakované akcie..
 6 | Poďme nájsť súčet niekoľkých čísel (viac ako dvoch). Bude to užitočné urobiť v cykle.
 7 | Ako je znázornené na obrázku vyššie - môžete vytvoriť premennú ' sum ' a pridať jej každú hodnotu zo zoznamu.
 8 | Snáď [cyklus "for"](http://en.wikipedia.org/wiki/For_loop) bude dobre vyhovovať, pretože množstvo čísel je známe vopred.
 9 | 
10 | AK máte problémy, vyskúšajte najprv [Sums In Loop](./sums-in-loop) - je to, pravdepodobne, jednoduchšie.
11 | 
12 | **Vstupné dáta** majú nasledujúci formát:
13 | 
14 | - prvý riadok  obsahuje  `N` - počet hodnôt na sčítanie;
15 | - druhý riadok obsahuje  `N` - samotné hodnoty.
16 | 
17 | **Odpoveď** by mala obsahovať jedinú hodnotu - súčet `N` hodnôt.
18 | 
19 | Príklad:
20 | 
21 | 	vstupné dáta:
22 | 	8
23 | 	10 20 30 40 5 6 7 8
24 | 	
25 | 	odpoveď:
26 | 	126
27 | 
28 | **Poznámka** pretože existuje niekoľko tuctov čísel, nemali by ste ich kopírovať ručne do vášho programu.
29 | Namiesto toho, spravte program, ktorý ich prečíta zo štandardného vstupu (kde ich môžete skopírovať naraz).
30 | Všimnite si, že ak spustíte kód na našom serveri, dáta sú automaticky skopírované do štandardného vstupu pre väčšie pohodlie.
31 | 
32 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
33 | 


--------------------------------------------------------------------------------
/es/task-4.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <iframe width="560" height="315" src="//www.youtube.com/embed/P-2BWHbW-SA?list=UUdMYRtGxMim55ghdPFupLGQ" frameborder="0" allowfullscreen></iframe>
 3 | <div class="hint">Puedes mirar este video para obtener una explicación.</div>
 4 | </div>
 5 | 
 6 | La mayoría de los programas deberían ser capaces de hacer algunas elecciones y decisiones. Y ahora vamos a practicar programación condicional.  
 7 | Esta es usualmente realizada mediante expresiones del tipo `si ... sino` las cuales pueden lucir así:
 8 | 
 9 |     SI alguna_condicion ENTONCES
10 | 	    haz_algo
11 | 	SINO
12 | 	    haz_otra_cosa
13 | 	FIN-SI
14 | 
15 | Dependiendo el lenguaje de programación, la sintaxis puede ser diferente, y la parte `sino` casi siempre es opcional.
16 | Puedes leer más en el artículo de Wikipedia sobre [Sentencias condicionales][cond].
17 | 
18 | [cond]: https://es.wikipedia.org/wiki/Sentencia_condicional
19 | 
20 | De dos números, por favor, selecciona aquel con el menor valor. Hay varios pares de números para realizar muchas pruebas.
21 | 
22 | Los **Datos de entrada** contendrá el número de casos de prueba en la primera línea.  
23 | Las siguientes líneas tendrán los pares de números que habrá que comparar entre sí.  
24 | Para la **Respuesta** por favor introduce la misma cantidad de mínimos separados por espacios, por ejemplo:
25 | 
26 |     datos de entrada:
27 | 	3
28 |     5 3
29 |     2 8
30 |     100 15
31 |     
32 |     respuesta:
33 |     3 2 15
34 | 


--------------------------------------------------------------------------------
/zh/task-37.md:
--------------------------------------------------------------------------------
 1 | 银行业务为我们提供了许多有趣的编程问题，与你之前学习的[储蓄计算器](https://www.codeabbey.com/index/task_view/savings-calculator)相比，下面这一个更为复杂。
 2 | 
 3 | Joel 在购买了一艘船后又有了一个新的想法 - 再买个房子。由于他不想等到凑够全款的时候再购买，因此他想到了抵押，从用来从银行贷款立即买下这个房子，同时贷款时使用这个房子作为担保（即，在借款人违约的情况下，银行获得房屋作为补偿金）。
 4 | 
 5 | 在数学上，抵押按以下算法工作：
 6 | 
 7 | - Joel 从银行借了大笔款项 `P` （并进行了购买房屋操作）
 8 | 
 9 | - 银行告诉他贷款利率为百分比 R - 也就是债务增长的速度；
10 | 
11 | - 每个月末债务都会增长 `R / 12` %. 
12 | 
13 | - 紧接着，在 Joel 将一些预定义的小额 `M` 存入银行以减少债务之后；
14 | 
15 | - 当债务减为零（这可能需要数年）时，便视为已清偿债务。
16 | 
17 | 举个栗子，Joel 以 `R = 6%` 的利率从银行借了 `P = $800,000`，他在每个月末原因支出 `M = $10000`。
18 | 
19 | 
20 | 
21 |     Month     P        P * (R/12)%      -M       new P
22 |     1       $800000       $4000       -$10000    $794000
23 |     2       $794000       $3970       -$10000    $787970
24 |     3       $787970       $3940       -$10000    $781910
25 |     ...
26 |     12      $732325       $3662       -$10000    $725987
27 |     ...
28 |     24      $654138       $3271       -$10000    $647408
29 |     ...
30 |     103     $4188         $21        -$4209         $0
31 | 
32 | 那么在 `103 个月` （也就是`8.5年`）后债务可以还清。当然，最后一次付款可能少于M（因为P不能变为负数）。注意，他将支付：
33 | 
34 |     102 * $10000 + $4209 = 1024209
35 | 
36 | 比房屋成本高 `25%`。
37 | 
38 | Joel 现在要请你这个牛逼的程序员帮助他计算一下每月要还的债务 `M`。
39 | 
40 | **输入数据** 包含贷款规模 `P`，利率 `R` 和还款时间 `L`（以月为单位）的值。
41 | 
42 | **答案** 应包含所需的每月付款 `M`，并四舍五入为整数（即​​，如果你获得非整数结果，则将其增加到更大的整数）。
43 | 
44 | 例如：
45 | 
46 |     input data:
47 |     800000 6 103
48 | 
49 |     answer:
50 |     9957


--------------------------------------------------------------------------------
/de/task-6.md:
--------------------------------------------------------------------------------
 1 | Wenn wir ein Programm schreiben, das mit Fließkommazahlen hantiert, ist es manchmal sinnvoll, diese Zahlen auf 
 2 | eine Ganzzahl zu **runden**. Wir werden das auch für spätere Übungen brauchen, um Lösungen zu vereinfachen.
 3 | Also lassen Sie uns hierfür in dieser kleinen Übung einen Trick erlernen, um das zu bewerkstelligen.
 4 | 
 5 | Gegeben sind mehrere Zahlen-Paare. Für jedes Paar dividieren Sie zunächst die erste Zahl mit der zweiten Zahl und geben 
 6 | dann das Resultat gerundet auf die **nächst nähere Ganzzahl** zurück. 
 7 | 
 8 | In Fällen, wo das Resultat der Division genau `0.5` beträgt, sollten Sie aufrunden (z.b. durch addieren von `0.5`).
 9 | Beachten Sie bitte, dass bei negativen Werten "größer" bedeutet, dass die Zahl "näher an der Null" liegt. 
10 | Siehe Wikipedia Seite zum Thema [Rundung](https://de.wikipedia.org/wiki/Rundung), um mehr darüber zu erfahren. 
11 | 
12 | Wenn wir also von nun an und in Zukunft bei Übungsaufgaben von Rundung sprechen, ist genau derselbe 
13 | Algorithmus gemeint (es sei denn, wir legen etwas anderes fest). 
14 | 
15 | **Eingabe Daten** beschreiben in der ersten Zeile die Anzahl der zu verarbeitenden Testfälle.  
16 | In jeder nächsten Zeile steht jeweils ein Testfall als Zahlenpaar durch Leerzeichen getrennt.  
17 | **Lösung** enthält das Resultat nach Division und Rundung für jedes Zahlenpaar, getrennt durch Leerzeichen. 
18 | 
19 | Beispiel:
20 | 
21 |     Eingabe Daten:
22 |     3
23 |     12 8
24 |     11 -3
25 |     400 5
26 | 
27 |     Lösung:
28 |     2 -4 80
29 | 
30 | 


--------------------------------------------------------------------------------
/es/task-28.md:
--------------------------------------------------------------------------------
 1 | Apliquemos nuestras habilidades de programación a un problema cuasi científico - ya que es un poco 
 2 | aburrido sólo aprender cosas abstractas.
 3 | 
 4 | Una forma simple de medir el tipo de cuerpo fue propuesta en la mitad del siglo XIX. Sólo depende de la altura 
 5 | y peso de una persona, y se llama **Índice de Masa Corporal** o **BMI**, por sus siglas en inglés. Se define como:
 6 | 
 7 |     BMI = peso / altura^2
 8 | 
 9 | Donde el peso es calculado en `kilogramos` y la altura en `metros`.
10 | 
11 | Se proponen cuatro notas generales:
12 | 
13 |     Bajo peso (Underweight)      -           BMI < 18.5
14 |     Peso normal (Normal weight)  -   18.5 <= BMI < 25.0
15 |     Sobrepeso (Overweight)       -   25.0 <= BMI < 30.0
16 |     Obesidad (Obesity)           -   30.0 <= BMI
17 | 
18 | Por ejemplo, si tengo un peso de `80 kg` y una altura de `1.73 m` puedo calcular:
19 | 
20 |     BMI = 80 / (1.73)^2 = 26.7
21 | 
22 | En otras palabras, algo de sobrepeso.
23 | 
24 | No discutiremos qué tan apropiadas son estas notas. En vez de esto, sólo debes calcular notas para varias personas.
25 | 
26 | **Datos de entrada**: Contienen el número de personas en la primera línea.  
27 | Cada otra línea contiene dos valores - peso en kilogramos y altura en metros.  
28 | **Respuesta**: Debe contener palabras `under`, `normal`, `over`, y `obese` para cada caso correspondiente, 
29 | separadas por espacios. Por ejemplo:
30 | 
31 |     datos de entrada:
32 |     3
33 |     80 1.73
34 |     55 1.58
35 |     49 1.91
36 | 
37 |     respuesta:
38 |     over normal under
39 | 


--------------------------------------------------------------------------------
/es/task-8.md:
--------------------------------------------------------------------------------
 1 | Cuando hablamos sobre la **progresión aritmética** (o secuencia aritmética) nos referimos a una serie
 2 | de números con una propiedad especial - cada valor es seguido por otro que es mayor por una cantidad predefinida (incremento), 
 3 | ej.: la diferencia del `(K+1)`-ésimo and `K`-ésimo valor es una constante. A continuación ejemplos de tales secuencias:
 4 | 
 5 | 	1 2 3 4 5 6 7 ...
 6 | 	4 6 8 10 12 14 16...
 7 | 	10 13 16 19 22 25 28...
 8 | 
 9 | Dado que la secuencia aritmética puede ser completamente definida por el primer término (`A`) y el valor del
10 | incremento - (`B`), sus primeros términos pueden ser expresados como:
11 | 
12 |     A + (A + B) + (A + 2B) + (A + 3B) + ...
13 | 
14 | Vas a calcular la suma de los primeros miembros de la secuencia aritmética.
15 | [El artículo de Wikipedia][wiki] sobre progresión aritmética podría ser de gran ayuda para
16 | quien haya escuchado sobre ella por primera vez.
17 | 
18 | [wiki]: https://es.wikipedia.org/wiki/Progresi%C3%B3n_aritm%C3%A9tica
19 | 
20 | **Datos de entrada:** La primera línea contiene el número de casos de prueba.  
21 | Las otras líneas contienen los casos de prueba en forma de tríos de valores `A B N` donde `A` es el primer valor de la secuencia,
22 | `B` es el tamaño del incremento y `N` y es el número de términos que deberían ser calculados.  
23 | **Respuesta:** Muestra los resultados (la suma of `N` términos) de cada secuencia separados por espacios.
24 | 
25 | Ejemplo:
26 | 
27 |     datos de entrada:
28 |     2
29 |     5 2 3
30 |     3 0 10
31 |     
32 |     respuesta:
33 |     21 30
34 | 


--------------------------------------------------------------------------------
/ru/task-23.md:
--------------------------------------------------------------------------------
 1 | <!-- #Пузырёк в Массиве -->
 2 | Эта задача является упражнением для изучения идеи, лежащей в основе знаменитого алгоритма [Сортировки Пузырьком](./bubble-sort--ru) -
 3 | который, предположительно, вы напишете чуть позже (или уже написали).
 4 | 
 5 | Пусть нам дан массив целых чисел, и мы проходим по парам соседних элементов от начала. Будем обменивать
 6 | членов каждой пары если первый из них больше второго (т.е.они нарушают порядок).
 7 | 
 8 | Например, пусть у нас маленький массив из чисел `1 4 3 2 6 5` - отметим какие пары подвергаются перестановке, а какие нет:
 9 | 
10 |     (1  4) 3  2  6  5  - пропускаем
11 | 	 1 (4  3) 2  6  5  - обмениваем
12 | 	 1  3 (4  2) 6  5  - обмениваем
13 | 	 1  3  2 (4  6) 5  - пропускаем
14 | 	 1  3  2  4 (6  5) - обмениваем
15 | 	 1  3  2  4  5  6  - закончили
16 | 
17 | Эта операция продвигает элементы покрупнее к концу массива, в то время как меньшие элементы сдвигаются
18 | немного к началу.  
19 | Что особенно важно: **наибольший элемент обязательно уходит в самую последнюю позицию**.
20 | 
21 | **Входные данные** содержат последовательность элементов массива, все целые положительные.
22 | После них следует `-1` означающее конец (это значение не нужно включать в массив).  
23 | **Ответ** должен содержать два значения - количество осуществленных перестановок
24 | и контрольную сумму массива после произведенной операции.  
25 | Контрольную сумму считаем как в задаче [Контрольная Сумма](./array-checksum--ru).
26 | 
27 | Пример:
28 | 
29 |     входные данные:
30 |     1 4 3 2 6 5 -1
31 |     
32 |     ответ:
33 |     3 5242536
34 | 


--------------------------------------------------------------------------------
/sk/task-7.md:
--------------------------------------------------------------------------------
 1 | <!-- #Fahrenheit to Celsius -->
 2 | Táto úloha je približne rovnaká ako sčítavanie v cykle, ale vyžaduje si trochu viac výpočtov.
 3 | 
 4 | <div class="text-center">
 5 | 	<img alt="fahrenheit and celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 6 | </div>
 7 | 
 8 | *Poznámka: problém [Rounding](./rounding) vysvetľuje algoritmus zaokrúhľovania, ktorý je použitý v tejto úlohe.*
 9 | 
10 | Po svete sú rozšírené dva systémy merania teploty - stupne Celzia a Fahrenheita. Prvý je celkom populárny v Európe
11 | a druhý je zaužívaný napríklad v Spojených štátoch.
12 | 
13 | Pri Celziovej stupnici voda mrzne pri 0 stupňoch a vrie pri 100 stupňoch. Pri Fahrenheitovej voda mrzne
14 | pri 32 stupňoch a vrie pri 212 stupňoch. Viac sa môžete dočítať v článku na [wikipédíi][wiki]. Použite 
15 | tieto dve stupnice na konverziu iných hodnôt.
16 | 
17 | [wiki]: https://sk.wikipedia.org/wiki/Stupe%C5%88_Fahrenheita
18 | 
19 | Vašou úlohou je napísať program pre konverziu stupňov Fahrenheita na stupne Celzia.
20 | 
21 | **Vstupné dáta** obsahujú `N+1` hodnôt, prvá z nich je samotné `N`  (**Všimnite si**, že túto hodnotu nemáte premienať).  
22 | **Odpoveď** by mala obsahovať `N` výsledkov, zaokrúhlených na najbližšie celé číslo oddelených medzerami.
23 | 
24 | Príklad:
25 | 
26 |     dáta:
27 |     5 495 353 168 -39 22
28 |     odpoveď:
29 |     257 178 76 -39 -6
30 | 
31 | Prosím všimnite si, že prvá `5` nie je teplota, ale počet hodnôt určených na konverziu!
32 | 
33 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
34 | 


--------------------------------------------------------------------------------
/fr/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="démo de la sommation d'un tableau" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | Maintenant notre but sera d'apprendre les **boucles** - c'est à dire des actions répétées.
 6 | Nous trouverons la somme de plusieurs nombres (plus de deux). Il sera utile de faire ceci en boucle.
 7 | Tel qu'illustré ci-dessus - vous pouvez créez une variable `sum` et lui additionner chaque valeur de la liste.
 8 | Peut-être qu'une [boucle "for"](https://fr.wikipedia.org/wiki/Boucle_for) fera l'affaire car le nombre de valeurs
 9 | est préalablement connu.
10 | 
11 | Si vous avez de la difficulté, essayez le problème [Sums In Loop](./sums-in-loop) d'abord - il est possiblement plus simple.
12 | 
13 | **Input data** (Données fournies) ont le format suivant:
14 | 
15 | - la 1ère ligne contient `N` - le nombre de valeur à additionner;
16 | - la 2ième ligne contient les `N` valeurs en question.
17 | 
18 | **Answer** (Réponse) devrait contenir une seule valeur - la somme des `N` valeurs.
19 | 
20 | Exemple:
21 | 
22 | 	input data:
23 | 	8
24 | 	10 20 30 40 5 6 7 8
25 | 	
26 | 	answer:
27 | 	126
28 | 
29 | **Note** puisqu'il y a plusieurs dizaines de nombres, vous ne devriez pas les copier manuellement dans votre programme.
30 | À la place, créez votre programme pour qu'il lise de "standard input" (ou vous pouvez les copiers tous d'un seul coup).
31 | Notez que si vous exécutez le code directement sur notre serveur, les données du problème seront copiées vers "standard input"
32 | automatiquement afin de vous simplifier la tâche.
33 | 


--------------------------------------------------------------------------------
/ru/task-21.md:
--------------------------------------------------------------------------------
 1 | <!-- #Счётчики в Массиве -->
 2 | Из этой задачи вы узнаете полезный трюк, часто используемый в статистических подсчетах.
 3 | 
 4 | Представьте, что лесник пытается сосчитать сосны, ели и березы на участке леса. Он может обойти весь участок трижды,
 5 | сосчитав сначала только сосны, потом только ели и в третий раз только березы.
 6 | 
 7 | Конечно, более эффективно обойти лес только один раз, отмечая крестиками сосны на одной странице блокнота, ели
 8 | на другой и березы на третьей. Потом останется только сосчитать количество крестиков на каждой странице.
 9 | Аналогичная идея работает для подсчета схожих элементов в последовательности или наборе, с использованием
10 | **массива счетчиков** (в качестве блокнота со страницами).
11 | 
12 | Дан массив длины `M` с числами в диапазоне `1 ... N`, где `N` не больше `20`.
13 | Вам нужно пройти по этому массиву и сосчитать сколько раз встречается каждое число.  
14 | Таким образом задача похожа на [Подсчет Гласных](./vowel-count), но теперь вам нужно работать более чем с одним счетчиком.  
15 | Пожалуйста, не используйте 20 отдельных переменных для счетчиков, а сделайте один массив из них.
16 | 
17 | **Входные данные** содержат `M` и `N` в первой строке.  
18 | Вторая строка (довольно длинная) содержит `M` чисел, через пробел.  
19 | **Ответ** должен содержать ровно `N` чисел, разделенных пробелами. Первое должно означать количество единиц
20 | в исходном массиве, второе - количество двоек и так далее.
21 | 
22 | Пример:
23 | 
24 |     входные данные:
25 |     10 3
26 |     1 2 3 2 3 1 1 1 1 3
27 |     
28 |     ответ:
29 |     5 2 3
30 | 


--------------------------------------------------------------------------------
/es/task-7.md:
--------------------------------------------------------------------------------
 1 | Este ejercicio de programación es aproximadamente el mismo que contar sumas en bucle (sums in loop), pero necesita unos cuantos cálculos más.
 2 | 
 3 | <div class="text-center">
 4 | 	<img alt="fahrenheit and celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 5 | </div>
 6 | 
 7 | *Nota: El problema [Rounding](./rounding--es) explica el algoritmo de redondeo que se usará en esta tarea.*
 8 | 
 9 | Hay dos sistemas ampliamente extendidos para medir la temperatura - Celsius y Fahrenheit. El primero es muy popular en Europa
10 | y el segundo es muy usado en los Estados Unidos por ejemplo.
11 | 
12 | Según la escala de Celsius, el agua se congela a 0 grados y hierve a 100 grados. Según la de Fahrenheit el agua se congela
13 | a 32 grados y hierve a 212 grados. Puedes aprender más en el [artículo de Wikipedia sobre la escala de Fahrenheit][wiki]. Usa estos dos puntos como bases
14 | para la conversión de otras temperaturas.
15 | 
16 | [wiki]: https://es.wikipedia.org/wiki/Grado_Fahrenheit
17 | 
18 | Vas a escribir un programa para convertir grados de Fahrenheit a Celsius.
19 | 
20 | Los **Datos de entrada** contiene `N+1` valores: el primero de ellos es `N` en sí (**Nota** que no deberías intentar convertirlo).  
21 | La **Respuesta** debería contener exactamente `N` resultados, redondeados al entero más cercano y separados por espacios.
22 | 
23 | Ejemplo:
24 | 
25 |     datos de entrada:
26 |     5 495 353 168 -39 22
27 |     respuesta:
28 |     257 178 76 -39 -6
29 | 
30 | *Por favor, ¡date cuenta que el primer `5` no es una temperatura, sino la cantidad de valores a convertir!*
31 | 


--------------------------------------------------------------------------------
/ro/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="demo of summing an array" src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | Acum, scopul nostru este să înțelegem cum funcționeză **instrucțiunile repetitive** (denumite și bucle).
 6 | Vom încerca să calculăm suma cătorva numere (mai multe decat două). O modalitate bună de a realiza această sarcină este folosirea unei bucle.
 7 | Precum poți vedea în imaginea de mai sus, poți crea o variabilă `suma` la care să aduni treptat fiecare valoare din listă.
 8 | Poate ar fi o idee bună să folosești o instrucțiune repetitivă de tip ["for"](http://en.wikipedia.org/wiki/For_loop), considerînd faptul că numărul elementelor ce urmează a fi sumate este precizat.
 9 | 
10 | Dacă întâlnești dificultăți, incearcă să rezolvi [Sums In Loop](./sums-in-loop) întâi, aceasta fiind o sarcină mai simplă.
11 | 
12 | **Datele de intrare** au următorul format:
13 | 
14 | - prima linie conține `N` - valori care urmează a fi sumate;
15 | - a doua linie conține acele `N` valori.
16 | 
17 | **Răspunsul** ar trebui să conțină o singura valoare - suma respectivelor `N` valori.
18 | 
19 | Exemplu:
20 | 
21 | 	Date de intrare:
22 | 	8
23 | 	10 20 30 40 5 6 7 8
24 | 	
25 | 	Răspuns:
26 | 	126
27 | 
28 | **Notă** având în vedere faptul că datele de intrare constituie cateva zeci de numere naturale, nu te sfătuim să copiezi manual aceste numere în programul tau.
29 | În schimb, folosește o funcție pentru a citi aceste valori din intrarea standard. Dacă alegi să folosești compilatorul online pe care il poți găsi mai jos, datele vor fi automat redirecționate către intrarea standard.


--------------------------------------------------------------------------------
/ru/task-61.md:
--------------------------------------------------------------------------------
 1 | <!-- #Генератор Простых Чисел -->
 2 | В этой задаче мы реализуем генератор простых чисел. Простыми называются положительные целые, не имеющие делителей кроме
 3 | `1` и самого числа. Вы можете прочесть больше [в википедии](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE).
 4 | Самые популярные для начинающих программистов алгоритмы - **Решето Эратосфена** и **Перебор делителей**. Вы можете
 5 | найти подробности о них по этим ключевым словам.
 6 | 
 7 | Итак, давайте создадим список или массив простых чисел в порядке возрастания:
 8 | 
 9 | 	[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...]
10 | 
11 | И потом напечатаем те из них, которые соответствуют индексам заданным во входных данных.
12 | 
13 | **Входные данные** указывают в первой строке количество простых чисел которые нужно напечатать.  
14 | Вторая строка содержит интересующие нас индексы в массиве простых чисел. Они будут в диапазоне от `1` до `200000`.  
15 | **Ответ** должен содержать простые числа соответствующие указанным позициям в массиве.
16 | 
17 | **Внимание** в этой задаче индексы массива начинаются с `1` а не с `0` - это для того чтобы легче было пользоваться
18 | (в целях проверки) готовыми списками простых чисел из интернета.
19 | 
20 | Пример:
21 | 
22 | 	входные данные:
23 | 	4
24 | 	7 1 199999 4
25 | 	
26 | 	ответ:
27 | 	17 2 2750131 7
28 | 
29 | *Постарайтесь реализовать алгоритм эффективно - при правильном подходе все `200000` чисел должны
30 | генерироваться за время около секунды (м.б. несколько медленнее на скриптовых языках вроде Python, или на менее современных
31 | компьютерах).*
32 | 


--------------------------------------------------------------------------------
/sk/task-26.md:
--------------------------------------------------------------------------------
 1 | Vyzerá to tak, že žiadny zo začiatočníckych programátorských kurzov nevynecháva precvičovanie [Euklidovského algoritmu](https://sk.wikipedia.org/wiki/Euklidov_algoritmus)
 2 | pre výpočet najväčšieho spoločného deliteľa dvoch čísel.
 3 | 
 4 | Najväčší spoločný deliteľ (v angličtine Greatest Common Divisor alebo `GCD`) čísel  `a` a `b`, je také celé číslo
 5 | `c`, ktorým je možné deliť  `a` aj `b` (bezo zvyšku) pričom je  `c` najväčšie možné číslo. Napríklad `gcd(20, 35) = 5` 
 6 | a `gcd(13, 28) = 1`. Euklidov algoritmus je celkom jednoduchý, budeme odčítať menšiu z hodnôt (`a` a `b`) od väčšej
 7 | a opakovať túto operáciu dokým sa hodnoty nebudú rovnať - táto posledná hodnota bude `gcd`. Pre urýchlenie procesu
 8 | môžeme namiesto odčítania použiť operáciu modulo.
 9 | 
10 | Napríklad:
11 | 
12 | 	20		35		- odčítame prvé od druhého
13 | 	20		15		- odčítame druhé od prvého
14 | 	5		15		- teraz odčítame prvé od druhého dvakrát
15 | 	5		5		- a tu je naše GCD
16 | 
17 | Najmenší spoločný násobok (v angličtine Least Common Multiple alebo `LCM`) čísel `a` a `b` je také celé číslo
18 | `d`, ktoré je deliteľné obidvoma (a je najmenšie možné). Dá sa získať pomocou nasledujúceho pravidla:
19 | 
20 | 	lcm(a, b) = a * b / gcd(a, b)
21 | 
22 | ### Vaša úloha
23 | 
24 | **Vstupné dáta** obsahujú počet príkladov v prvom riadku.  
25 | Na každom ďalšom riadku nasledujú príklady, ktoré obsahujú 2 čísla pre `A` a `B`.  
26 | **Odpoveď** by mala obsahovať GCD a LCM pre každý pár v zátvorkách, oddelený medzerami napríklad takto:
27 | 
28 |     vstupné dáta:
29 | 	2
30 | 	2 3
31 | 	4 10
32 | 	
33 | 	odpoveď:
34 | 	(1 6) (2 20)
35 | 


--------------------------------------------------------------------------------
/ru/task-1.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сложить A и Б -->
 2 | <div class="centered hint">
 3 | 	<img alt="Программисты фиксят баг" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 4 | 	<span>Программисты побеждающие Баг в представлении художника</span><br/>
 5 | 	<span>Подходящие инструменты могут быть полезны!</span>
 6 | </div>
 7 | 
 8 | Начинать зачастую сложно, поэтому попробуем самую простую задачу чтобы практиковаться в отправке ответов и т.п.
 9 | 
10 | Вам нужно сложить два числа и выдать их сумму. Конечно, это можно сделать вручную, однако лучше попробуйте
11 | написать простую программу на любом известном Вам языке программирования (или том который Вы хотите изучить).
12 | 
13 | _Шаги перечисленные ниже также продемонстрированы в [этом полезном видео](http://www.youtube.com/watch?v=gxfqeDm-B6k) -
14 | или в картинках в [этой инструкции](../wiki/demo-step-1)._
15 | 
16 | ###Как отправить решение
17 | 
18 | Если Вы вошли на сайт, на странице с задачей доступна форма с полями:  
19 | 
20 | - **Test data** (ниже) содержит входные данные - в данном случае, два числа которые требуется сложить.
21 | - **Your answer** - поле куда следует ввести ответ.
22 | - **Your solution** - сюда можно (нужно) ввести или скопировать исходный текст программы. Для большинства задач
23 |   он не проверяется, а просто сохраняется чтобы Вы могли посмотреть его впоследствии.
24 | 
25 | Пример:
26 | 
27 |     входные данные:
28 |     3 5
29 | 	
30 |     ответ:
31 |     8
32 |     
33 | Вы можете посмотреть **[примеры](../wiki/running)** решения этой задачи на основных популярных языках программирования,
34 | но я настоятельно рекомендую не делать этого до того как решите задачу сами.
35 | 


--------------------------------------------------------------------------------
/sk/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="centered hint">
 2 | 	<img alt="CodeAbbey Mnísi bojujúci s bugom." src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 3 | 	<span>Umelecké zobrazenie boja programátorov s Bugom.</span><br/>
 4 | 	<span>Všimnite si, že správne náradie môže byť nápomocné!</span>
 5 | </div>
 6 | 
 7 | Začiatky môžu byť niekdy ťažké, preto poďme vyskúšať najjednoduchší možný problém.
 8 | Cieľom je vyskúšať si posielanie odpovedí atď.
 9 | 
10 | Potrebujeme sčítať dve čísla a zobraziť výsledok. Napriek tomu, že to môžete urobiť ručne, skúste napísať 
11 | program v akomkoľvek jazyku ktorý poznáte alebo sa chcete naučiť.
12 | 
13 | _[Toto video](http://www.youtube.com/watch?v=gxfqeDm-B6k) demonštruje ďalšie opísané kroky._
14 | 
15 | ###Ako odoslať riešenie
16 | 
17 | Ak ste prihlásený, nižšie uvidíte nasledujúce polia:  
18 | 
19 | - **Vstupné dáta** obsahujú "vstupné dáta" alebo "skúšobný príklad" - dve čísla, ktoré chceme sčítať.
20 | - **Vaša odpoveď** - tu vložíte váš výsledok po spracovaní skúšobného príkladu.
21 | - **Vaše riešenie** - tu vložíte váš kód programu. Ten by nemal byť kontrolovaný.
22 |     (aspoň automaticky), ale pomôže vám to znova použiť váš kód v ďalších úlohách.
23 |     Úlohu môžete navštíviť kedykoľvek aby ste si pozreli výsledok poslaného riešenia.
24 | 
25 | Príklad:
26 | 
27 | 	Vstupné dáta:
28 | 	3 5
29 | 	
30 | 	Odpoveď:
31 | 	8
32 | 
33 | Poskytujeme **[príklady](../wiki/running)** programu v niekoľkých populárnych jazykoch,
34 | ale dôrazne sa odporúča, aby ste ich neprehliadali skôr, ako vyriešite túto úlohu. :)
35 | 
36 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
37 | 


--------------------------------------------------------------------------------
/es/task-21.md:
--------------------------------------------------------------------------------
 1 | De este problema aprenderemos un truco popular de programación utilizado en muchas variantes de cálculos estadísticos.
 2 | 
 3 | Imagina que un guardia forestal está intentando contar pinos, abetos y abedules en alguna sección del bosque. El guardia puede ir a través de
 4 | esta sección en tres ocasiones, contando sólo los pinos en la primera pasada, sólo abetos en la segunda y sólo abedules en la tercera.
 5 | 
 6 | Una manera más eficiente es realizar una sola pasada a través del bosque y anotar un punto en una de las tres páginas de su
 7 | cuaderno - la primera página es para los pinos, la siguiente para los abetos y la última para los abedules. Esa es la idea para contar elementos similares en una secuencia, utilizando un vector de contadores (en vez del cuaderno). 
 8 | 
 9 | Aquí hay una matriz de longitud `M` con números en un rango de `1 ... N`, donde `N` es menor o igual a `20`.
10 | Tenemos que recorrerla y contar cuántas veces se encuentra cada número,
11 | ej.: es similar a la tarea de [contar vocales](./vowel-count), pero necesitamos mantener más de un contador. Asegúrate de
12 | usar un vector separado para ellos, para no crear un montón de variables separadas.
13 | 
14 | Los **Datos de entrada** contienen `M` y `N` en la primera línea.  
15 | La segunda (y más larga) línea contendrá `M` números separados por espacios.  
16 | La **Respuesta** debería contener exactamente `N` valores, separados por espacios. Primero debería mostrarse la cantidad de `1`,
17 | segundo - la cantidad de `2` y así sucesivamente.
18 | 
19 | Ejemplo:
20 | 
21 |     datos de entrada:
22 |     10 3
23 |     1 2 3 2 3 1 1 1 1 3
24 | 
25 |     respuesta:
26 |     5 2 3
27 | 


--------------------------------------------------------------------------------
/de/task-2.md:
--------------------------------------------------------------------------------
 1 | <div class="centered">
 2 | <img alt="Demo über das addieren eines Arrays." src="https://codeabbey.github.io/data/sum_in_loop.gif"/>
 3 | </div>
 4 | 
 5 | Als nächstes ist unser Ziel, **"Loops"** kennen zu lernen, sprich "Programmschleifen", um Aktionen automatisch zu wiederholen. 
 6 | Dazu lassen Sie uns gemeinsam die Summe mehrerer (mehr als zwei) Zahlen berechnen. Dazu wird am besten eine Programm-Schleife bzw ein "Loop" genutzt. 
 7 | Wie im Bild gezeigt können Sie dazu eine Variable "summe" erzeugen und jede gegebene Zahl der Liste einfach dort hinzuaddieren. 
 8 | Eine ["for" Schleife](http://en.wikipedia.org/wiki/For_loop) ist dafür besonders geeignet, da die Anzahl der Zahlen bereits vorab bekannt ist.
 9 | 
10 | Falls Sie mit dieser Aufgabe Schwierigkeiten haben, versuchen Sie vielleicht zunächst die Aufgabe [Summierung in einer Schleife](./sums-in-loop) zu lösen. - Das ist womöglich für den Anfang etwas einfacher.
11 | 
12 | Die **Eingabe Daten** haben das folgende Format:
13 | 
14 | - Die erste Zeile beinhaltet die Anzahl der Zahlen welche addiert werden sollen;
15 | - Die zweite Zeile enthält die einzelnen Summanten selbst.
16 | 
17 | **Lösung** muss eine einzelne Zahl, die Summe aller Zahlen enthalten.
18 | 
19 | Beispiel:
20 | 
21 | 	Eingabe Daten:
22 | 	8
23 | 	10 20 30 40 5 6 7 8
24 | 	
25 | 	Lösung:
26 | 	126
27 | 
28 | **Anmerkung:** Anstatt die Eingabe-Daten in ihr Programm zu kopieren, sollten Sie ihr Programm so schreiben, dass es die Daten direkt von dem "standard Input" einliest. 
29 | So bald Sie ihren Code auf unserem Server zur Ausführung bringen, stehen Ihnen die Daten automatisch an der "standard input" Schnittstelle zur Verfügung.
30 | 
31 | 


--------------------------------------------------------------------------------
/sk/task-8.md:
--------------------------------------------------------------------------------
 1 | Keď hovoríme o **aritmetickej postupnosti** (alebo aritmetickej sekvencií), myslíme tým sériu
 2 | čísel s mimoriadnou vlastnosťou - každá hodnota je nasledovaná ďalšou, väčšou o predefinovanú
 3 | hodnotu (krok).
 4 | 
 5 | T.j. rozdiel `(K+1)` a `K`-tej hodnoty, je konštanta. Tu sú príklady postupností
 6 | 
 7 | 	1 2 3 4 5 6 7 ...
 8 | 	4 6 8 10 12 14 16...
 9 | 	10 13 16 19 22 25 28...
10 | 
11 | Aritmetická postupnosť je úplne definovaná prvým členom (`A`) a prírastkovou
12 | hodnotou - (`B`). Prvých pár členov by sme vyjadrili ako 
13 | 
14 |     A + (A + B) + (A + 2B) + (A + 3B) + ...
15 | 
16 | Vašou úlohou je vypočítať súčet prvých členov aritmetickej postupnosti.
17 | [Stránka na wikipédií][wiki] o aritmetickej postupnosti by mohla značne pomôcť niekomu
18 | kto vidí tento problém prvýkrát.
19 | 
20 | [wiki]: https://sk.wikipedia.org/wiki/Aritmetick%C3%A1_postupnos%C5%A5
21 | 
22 | **Vstupné dáta:** prvý riadok obsahuje počet skúšobných príkladov.  
23 | Ďalšie riadky obsahujú samotné príklady vo forme trojíc hodnôt `A B N` kde `A` je prvá hodnota postupnosti,
24 | `B` je prírastková hodnota a `N` je počet krokov postupnosti.  
25 | **Odpoveď:** vašou úlohou je zobraziť výsledky (súčty prvých `N` členov) pre každú postupnosť, oddelenú medzerami.
26 | 
27 | Príklad:
28 | 
29 |     dáta:
30 |     2
31 |     5 2 3
32 |     3 0 10
33 |     
34 |     odpoveď:
35 |     21 30
36 | 
37 | _Vysvetlenie Príkladu. V prvom prípade máme postupnosť začínajúcu `5` a zvyšujúcu sa zakaždým o `2`.
38 | K tomu chceme pričítať `3` prvky `5 + 7 + 9 = 21`. Druhý príklad je nenáročný. Začína s číslom `3` ale prírastok je `0`,
39 | takže to je `3 + 3 + ... + 3 = 30` (celkovo `10` prvkov)._
40 | 


--------------------------------------------------------------------------------
/zh/task-45.md:
--------------------------------------------------------------------------------
 1 | 对于任意类型的纸牌游戏洗牌都是比较重要的。由于只有少数编程语言自带随机混洗数组的内置函数（比如PHP），所以有必要学习一些有用的算法。
 2 | 
 3 | 我们以下面的符号来代替卡牌：
 4 | 
 5 |     ranks: A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K
 6 |     suits: C, D, H, S
 7 | 
 8 | 这里面 `CQ` 代表 "梅花Q(Queen of Clubs)"，`HT` 代表 "红桃10(Ten of Hearts)"，`D2` 代表 "方片2(Two of Diamonds)"，`SA` 代表 "黑桃A(Ace of Spades)"。
 9 | 
10 | 一共有52张牌，所有在洗牌前应该将它们放入包含52个元素的数组中。数组的初始排序如下：13张梅花，然后是13张方片，然后是13张红桃，最后是13张黑桃。在每种花色中卡牌从 Ace 到 King 排列，因此整个排序就像这样：
11 | 
12 |     [ CA, C2, C3, ..., CQ, CK, DA, D2, ..., DK, HA, H2, ..., HK, SA, S2, ..., SK ]
13 | 
14 | 然后你需要针对每张牌生成一个处于 `0 ... 51` 内的随机数，然后将这张牌与另一张牌互换位置，要互换的位置就是你随机生成数字所对应的卡牌的位置（数组从0开始计数）。类似下面这样：
15 | 
16 |     FOR i = 0 ... 51 :
17 |         LET j = RANDOM(0 ... 51)
18 |         SWAP deck[i] WITH deck[j]
19 | 
20 | 例如，我们拿第一张牌 `CA` 然后为它生成一个随机数 `15` - 这意味着第一张牌需要移动到 `D3` 所在的15这个位置 - 然后 `D3` 应该移动到第一张牌所在的位置 `0`。然后我们拿位置 `1` 上的 `C2` 这张牌，为它生成一个随机数字 `50` - 因此 `C2` 就与位置 50 上的 `SQ` 进行交换。以此类推。
21 | 
22 | 你将会拿到一串非负随机整数 - 如果这些数字比想要的位置索引值大就把它们 `与52取模` 来进行修建，就像在 [`Double Dice Roll`][1] 任务中那样。执行洗牌操作然后将新的牌序作为结果打印出来。
23 | 
24 | **输入数据** 将会包含52个非负整数，你将使用这些整数来进行洗牌操作。
25 | 
26 | **答案** 应当包含洗牌后的卡牌，使用分好将每个卡牌隔开。
27 | 
28 | 举个栗子：
29 | 
30 |     input data:
31 |     5814 1316 2080 2712 0 647 8098 315 44 6354 7867 100 61 763 6731 685 42 9309 569 92 701 562
32 |             85 8311 698 220 929 71 684 518 113 61 19 168 745 16 655 9548 6018 2686 25 785 81 721
33 |             964 85 44 614 4 509 8708 19
34 | 
35 |     answer:
36 |     C5 D5 S4 C8 CQ S3 HK C9 H3 H6 D3 ST DT HT C6 CK DA H9 SJ SK DK C2 DQ S5 H4 D7 S7 S2 C4 D9 CT
37 |             HJ HQ D2 SA CA H5 H2 C7 D4 CJ D6 S9 HA S8 D8 S6 SQ C3 DJ H8 H7
38 | 
39 | [1]: https://www.codeabbey.com/index/task_view/double-dice-roll


--------------------------------------------------------------------------------
/ro/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="centered hint">
 2 | 	<img alt="CodeAbbey Monks struggle with bug" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 3 | 	<span>Lupta zilnică a programatorilor cu bugg-urile.</span><br/>
 4 | 	<span>Uneltele potrivite îți pot ușura munca!</span>
 5 | </div>
 6 | 
 7 | Începutul fiind întotdeauna mai dificil, îți propun să începem cu una dintre cele mai simple probleme posibile.
 8 | În acest fel, te poți familiariza cu interfața site-ului, modalitățile de a trimite răspunsuri etc.
 9 | 
10 | Sarcina ta este să calculezi suma a două numere. Deși o poți face manual, încearcă să scrii un program simplu, în orice limbaj de programare pe care îl cunoști sau pe care vrei să îl înveți.
11 | 
12 | _[Acest tutorial video](http://www.youtube.com/watch?v=gxfqeDm-B6k) îți demonstrează pășii descriși mai jos._
13 | 
14 | ###Cum să trimiți un răspuns
15 | 
16 | Dacă ești logat, poți remarca următoarele câmpuri:
17 | 
18 | - **Test data** conține datele de intrare. În acest exemplu - cele două numere pe care trebuie sa le sumăm
19 | - **Your answer** - este câmpul în care trebuie să specifici rezultatul obținut, dupa ce datele au fost procesate
20 | - **Your solution** - aici poți salva codul sursă a programului tău. El nu este verificat automat, dar îți poate fi util pe măsura ce vei avea nevoie sa reutilizezi diverse porțiuni de cod. Poți revizita orice problemă ca să revezi soluția ta.
21 | 
22 | Exemplu:
23 | 
24 | 	Date de intrare:
25 | 	3 5
26 | 	
27 | 	Răspuns:
28 | 	8
29 | 
30 | Aici poți găsi **[exemple](../wiki/running)** ale acestui program, în câteva limbaje de programare dar te încurajăm să nu le explorezi înainte de a rezolva singur aceasta primă problema :)
31 | 
32 | 


--------------------------------------------------------------------------------
/ru/task-32.md:
--------------------------------------------------------------------------------
 1 | <!-- #Задача Иосифа -->
 2 | Эта классическая задача пришла из тех древних времен, когда компьютеров вовсе не существовало.
 3 | 
 4 | Около 2000 лет назад была некая война, и в ходе одного из сражений защищающиеся оказались заблокированы нападавшими
 5 | в пещере. Чтобы избежать плена, они решили встать в круг и убивать каждого третьего, пока не останется только один человек.
 6 | Этот один по замыслу должен был покончить самоубийством - но он предпочёл сдаться и стать знаменитым историком.
 7 | Задача как раз названа по его имени - более подробно вы можете прочесть о Задаче Иосифа (Флавия) в [википедии](http://en.wikipedia.org/wiki/Josephus_problem).
 8 | 
 9 | А наша задача - для заданного числа человек `N` и заданного шага `K` - определить номер счастливчика который останется
10 | последним в этой жеребьёвке. Например если всего 10 человек и выбывает каждый 3-й:
11 | 
12 |     N = 10, K = 3
13 | 	
14 | последовательность "вылета" будет такой (в скобках указаны выбывающие номера):
15 | 
16 |     1-й круг: 1 2 (3) 4 5 (6) 7 8 (9) 10
17 |     2-й круг:                            1 (2) 4 5 (7) 8 10
18 |     3-й круг:                                                (1) 4 5 (8) 10
19 |     4-й круг:                                                               4 (5) 10
20 |     5-й круг:                                                                        4 (10)
21 | 
22 | итак победителем оказался тот кто стоял четвертым в начальной позиции.
23 | 
24 | **Входные данные** содержат количество человек `N` и размер шага `K`.  
25 | **Ответ** должен содержать "выигрышный номер" (считая с 1).
26 | 
27 | Пример:
28 | 
29 |     входные данные:
30 |     10 3
31 |     
32 |     ответ:
33 |     4
34 | 


--------------------------------------------------------------------------------
/sk/task-48.md:
--------------------------------------------------------------------------------
 1 | <!-- #Collatz Sequence -->
 2 | Toto je jeden z najzáhadnejších matematických problémov minulého storočia - pretože problémový výrok je mimoriadne jednoduchý
 3 | a pretože dôkaz je stále neznámy, avšak tento problém ponúka dobré programátorské cvičenie pre začiatočníkov.
 4 | 
 5 | **Predpokladajme**, že vyberieme nejaké počiatočné číslo `X` a potom vytvoríme sekvenciu hodnôt podľa pravidiel:
 6 | 
 7 |     if X je párne (t.j. X modulo 2 = 0) potom
 8 | 	    buduceX = X / 2
 9 | 	else
10 | 	    buduceX = 3 * X + 1
11 | 
12 | T.j ak `X` je nepárne, sekvencia rastie - a ak je párne, sekvencia klesá. Napríklad, pre `X = 15` dostaneme sekvenciu:
13 | 
14 |     15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
15 | 
16 | Keď sekvencia dosiahne `1`, dostane sa do cyklu `1 4 2 1 4 2 1...`.
17 | 
18 | Háčik spočíva v tom, že akékoľvek počiatočné číslo `X` skôr či neskôr vyústi v spomínanú `1` - avšak aj keď táto
19 | `Collatzova domienka` bola predstavená v roku `1937`, až do dnes nikto nenašiel dôkaz, že je tomu skutočne tak pre
20 | akékoľvek `X` alebo, že existuje nejaký proti príklad (t.j číslo pre ktoré sekvencia nekončí `1` - buď nejakým väčším 
21 | cyklom alebo nekonečným rastom).
22 | 
23 | **Vašou úlohou** je pre dané čísla, vypočítať koľko krokov je potrebných na dosiahnutie `1`.
24 | 
25 | **Vstupné dáta** obsahuje počet príkladov v prvom riadku.  
26 | Druhý riadok obsahuje samotné príklady t.j hodnoty, pre ktoré by mali byť vykonané výpočty.
27 | **Odpoveď** by mala obsahovať rovnaký počet výsledkov, pričom každý z nich je počet krokov potrebný pre 
28 | dosiahnutie Collatzovej sekvencie na hodnotu `1`.
29 | 
30 | Napríklad:
31 | 
32 |     vstupné dáta:
33 | 	3
34 | 	2 15 97
35 | 	
36 | 	odpoveď:
37 | 	1 17 118
38 | 


--------------------------------------------------------------------------------
/sk/task-14.md:
--------------------------------------------------------------------------------
 1 | Táto úloha poskytuje cvičenie pre základnú vlastnosť zvyšku, ktorá sa používa v aritmetike - pozostávajúca zo
 2 | zvyšku sčítania a násobenia. Táto dôležitá vlastnosť je často používaná pre kontrolu výsledkov z výpočtov,
 3 | v kompetetívnom programovaní, vo výpočte kontrolných súčtov a najmä v šifrovaní. 
 4 | Viac (po anglicky) ohľadne modulárnej aritmetiky [v tomto odkaze][modar].
 5 | 
 6 | [modar]: ../wiki/modular-arithmetic
 7 | 
 8 | Máme tu akýsi dlhý výpočet a našou úlohou je vypočítať výsledok modulo nejakého čísla (`výsledok % M` vo veľa jazykoch).
 9 | 
10 | _Ak ste zvedavý prečo je modulárna aritmetika tak dôležitá, pozrite si úlohy
11 | [úvod do šifrovania s verejným kľúčom](./public-key-cryptography-intro) a [RSA šifrovanie](./rsa-cryptography)._
12 | 
13 | **Vstupné** dáta budú mať:
14 | 
15 | - počiatočné číslo v prvom riadku;
16 | - jeden alebo viac riadkov popisujúci operácie, vo forme `znak a hodnota` kde znak je buď `+` alebo `*` a hodnota je celé číslo;
17 | - posledný riadok je v rovnakej forme ale so znakom `%` a čísla, ktorým by mal byť výsledok vydelený aby sme dostali zvyšok.
18 | 
19 | **Odpoveď** by mal byť zvyšok výsledku vydelený posledným číslom, po vykonaní všetkých operácií postupne (počnúc začínajúcim číslom).
20 | 
21 | _Ak máte problémy s touto úlohou, neváhajte napísať názov úlohy do "vyhľadávacieho" poľa na vrchu v menu a nájdete relevantné
22 | témy na našom fóru._
23 | 
24 | Príklad:
25 | 
26 | 	vstupné dáta:
27 | 	5
28 | 	+ 3
29 | 	* 7
30 | 	+ 10
31 | 	* 2
32 | 	* 3
33 | 	+ 1
34 | 	% 11
35 | 	
36 | 	odpoveď:
37 | 	1
38 | 
39 | _V tomto prípade je výsledok po vykonaní všetkých operácií `397`_.
40 | 
41 | Všetky čísla nepresiahnu 10000 (aj keď medzivýsledky môžu byť veľmi veľké).
42 | 


--------------------------------------------------------------------------------
/ro/task-7.md:
--------------------------------------------------------------------------------
 1 | <!-- #Fahrenheit to Celsius -->
 2 | Acest exercițiu este similar exercițiului **sums in loop**, dar necesită mai multe calcule.
 3 | 
 4 | <div class="text-center">
 5 | 	<img alt="fahrenheit and celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 6 | </div>
 7 | 
 8 | *Notă: Problema [Rounding](./rounding) explică algoritmul folosit pentru rotunjirea rezultatelor.*
 9 | 
10 | Există doua sisteme răspandite pentru a măsura temperatura, Celsius și Fahrenheit. Primul este folosit cu preponderență în Europa, al doilea fiind folosit in Statele Unite ale Americii și în alte câteva țări.
11 | 
12 | Conform sistemului Celsius, punctul de înghețare al apei este la 0 grade și punctul ei de fierbere la 100 de grade. Conform sistemului Fahrenheit punctul de înghețare al apei este la 32 de grade și punctul ei de fierbere la 212 grade. Poți afla mai multe detalii despre [sistemul Fahrenheit][wiki] pe wikipedia. Folosește aceste detalii pentru a converti temperatura dintr-un sistem în altul.
13 | 
14 | [wiki]: http://en.wikipedia.org/wiki/Fahrenheit
15 | 
16 | Sarcina ta este să scrii un program care va realiza în mod automat aceasta conversie din Fahrenheit în Celsius.
17 | 
18 | **Datele de intrare** conțin `N+1` valori, prima valoare fiind însuși `N` adica numărul total de valori (**Notă** această valoare nu ar trebui sa fie tratată).  
19 | **Răspunsul** ar trebui să conțină exact `N` rezultate, fiecare dintre ele rotunjit la cel mai apropiat număr întreg si separate prin spațiu.
20 | 
21 | Exemplu:
22 | 
23 |     Date de intrare:
24 |     5 495 353 168 -39 22
25 |     
26 |     Răspuns:
27 |     257 178 76 -39 -6
28 | 
29 | *Remarcă: primul `5` nu este o temperatură ci numărul total de valori care urmează a fi convertite!*


--------------------------------------------------------------------------------
/ru/task-18.md:
--------------------------------------------------------------------------------
 1 | <!-- #Квадратный Корень -->
 2 | Многие математические задачи в программировании решаются не точно, а приближённо, за несколько повторяющихся
 3 | операций каждая из которых получает все лучшее приближение.
 4 | 
 5 | Давайте рассмотрим этот приём на примере вычисления квадратного корня по следующему способу:
 6 | 
 7 | 1. Пусть мы ищем неизвестный корень `r` из заданного значения `X`.
 8 | 2. Возьмём некоторое начальное приближение, например `r = 1` (конечно, это весьма грубо).
 9 | 3. Для точного квадратного корня было бы справедливо `r = X / r`.
10 | 4. Поэтому вычислим `d = X / r` (оно не будет равно `r` поскольку `r` не является точным значением корня).
11 | 5. И возьмём среднее между `r` и `d` в качестве нового приближения.
12 | 
13 | Т.е. полностью формула одного вычислительного шага выглядит так (здесь `:=` означает присваивание):
14 | 
15 |           r  +  X / r
16 |     r := -------------
17 |                2
18 | 
19 | Вы можете обратиться к статье [Square Root Approximation](../wiki/square-root-approximation) за большими подробностями
20 | о вычислении квадратного корня по **Методу Герона**.
21 | 
22 | Итак, нам будут даны значение `X` для которого нужно посчитать приближение квадратного корня и `N` - количество шагов.  
23 | Используем `r = 1` как первое приближение и выведем результат после `N` шагов.
24 | 
25 | **Входные данные** содержат количество тест-кейсов в первой строке.  
26 | Следующие строки содержат сами тест-кейсы - в каждой будет значение `X`, корень из которого мы ищем и `N` - количество шагов.  
27 | **Ответ** должен содержать вычисленные приближения через пробел (с точностью не хуже `1e-7`).
28 | 
29 | Пример:
30 | 
31 |     входные данные:
32 |     3
33 |     150 0
34 |     5 1
35 |     10 3
36 |     
37 |     ответ:
38 |     1 3 3.196
39 | 


--------------------------------------------------------------------------------
/es/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img alt="CodeAbbey Monks struggle with bug" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 3 | 	<span class="hint">Recreación del artista sobre los programadores luchando contra El Bug.</span><br/>
 4 | 	<span class="hint">¡Nótese que las herramientas apropiadas pueden ser útiles!</span>
 5 | </div>
 6 | 
 7 | Como el empezar algo algunas veces puede ser díficil, hagamos un intento con el problema más sencillo posible.
 8 | El objetivo es lograr algo de práctica en el envío de las respuestas, etc.
 9 | 
10 | Necesitamos sumar dos números y mostrar el resultado. Aunque puedes hacerlo manualmente, trata de escribir un
11 | programa sencillo en cualquier lenguaje que conozcas, o que te guste, o que quieras aprender.
12 | 
13 | _[Esta captura de pantalla en video](http://www.youtube.com/watch?v=gxfqeDm-B6k) demuestra aún más los pasos descritos._
14 | 
15 | ###Cómo enviar la solución
16 | 
17 | Si has iniciado sesión, verás los siguientes campos debajo:  
18 | 
19 | - **Test data** contiene los "datos de entrada" o "casos de prueba" - dos números que queremos sumar.
20 | - **Your answer** - es donde se escribe el resultado después de procesar los datos de entrada.
21 | - **Your solution** - es donde guardas tu código del programa. No sería revisado
22 |     (al menos no automáticamente), pero te ayudará a poder reusar tu código en las siguientes tareas.
23 |     Puedes volver a visitar la tarea en cualquier momento para ver la solución que enviaste.
24 | 
25 | Ejemplo:
26 | 
27 | 	datos de entrada:
28 | 	3 5
29 | 	
30 | 	respuesta:
31 | 	8
32 | 
33 | Tenemos **[muestras](../wiki/running)** del programa en varios lenguajes populares,
34 | pero te aconsejamos totalmente que no les des un vistazo antes que resuelvas esta tarea. :)
35 | 


--------------------------------------------------------------------------------
/ru/task-28.md:
--------------------------------------------------------------------------------
 1 | <!-- #Индекс Массы Тела -->
 2 | Применим наши навыки программирования к некой квази-научной проблеме, поскольку заниматься лишь абстрактными
 3 | упражнениями бывает скучно.
 4 | 
 5 | В 19 веке была предложена несложная мера "относительной упитанности" тела человека. Она вычисляется на основании
 6 | только роста и веса, и называется **Индекс Массы Тела** (Body Mass Index = BMI). Определяется она как вес делённый
 7 | на рост в квадрате:
 8 | 
 9 |     BMI = вес / рост^2
10 | 
11 | Здесь вес берется в килограммах, а рост в метрах.
12 | 
13 | На основании этого показателя выделяют четыре категории:
14 | 
15 | 	Underweight     -           BMI < 18.5      (недостаточная масса)
16 | 	Normal weight   -   18.5 <= BMI < 25.0      (норма)
17 | 	Overweight      -   25.0 <= BMI < 30.0      (избыточная масса)
18 | 	Obesity         -   30.0 <= BMI             (ожирение)
19 | 
20 | Например, если я вешу `80 кг` а мой рост `173 см` то можно вычислить:
21 | 
22 |     BMI = 80 / (1.73)^2 = 26.7
23 | 
24 | т.е. присутствует избыточный вес.
25 | 
26 | Мы не будем обсуждать насколько правильна эта оценка (конечно она не учитывает многих факторов - пола, возраста,
27 | особенностей скелета) - вместо этого вам просто нужно определить категории для нескольких человек по их показателям.
28 | 
29 | **Входные данные** - указывают количество человек (подопытных!) в первой строке.  
30 | Остальные строки содержат параметры одного человека каждая - вес в килограммах и рост в метрах.  
31 | **Ответ** должен содержать одно из слов `under`, `normal`, `over`, `obese` (см. категории выше) для каждого из
32 | исследуемых людей, через пробел.
33 | 
34 | Пример:
35 | 
36 |     входные данные:
37 |     3
38 |     80 1.73
39 |     55 1.58
40 |     49 1.91
41 |     
42 |     ответ:
43 |     over normal under
44 | 


--------------------------------------------------------------------------------
/ru/task-48.md:
--------------------------------------------------------------------------------
 1 | <!-- #Гипотеза Коллатца -->
 2 | Гипотеза Коллатца - одна из наиболее таинственных загадок математики 20 века. Её описание понятно даже школьнику, но
 3 | даже выдающиеся ученые не знают её доказательства. Зато она может служить отличным упражнением для программистов.
 4 | 
 5 | **Пусть** мы выбрали некое исходное число `X` и строим от него последовательность значений по следующим правилам:
 6 | 
 7 |     если X четное (т.е. X mod 2 = 0) тогда
 8 |         Xследующее = X / 2
 9 |     иначе
10 |         Xследующее = 3 * X + 1
11 | 
12 | Таким образом если `X` нечетно, последовательность растет - а если четно, то убывает. Например, с `X = 15` мы получим:
13 | 
14 |     15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
15 | 	
16 | После достижения `1` последовательность зацикливается `1 4 2 1 4 2 1...`.
17 | 
18 | Интрига заключается в том, что для любого начального `X` получаемая последовательность, по-видимому, рано или поздно
19 | достигает `1` - однако хотя это предположение было высказано как гипотеза Коллатца еще в `1937`,
20 | до сих пор никто не смог ни доказать её, ни найти контрпример (т.е. число для которого последовательность либо входит
21 | в другой цикл, нежели `1 4 2 1` - либо растет бесконечно). Может быть повезет вам?
22 | 
23 | Ваша задача - для заданного исходного `X` посчитать сколько шагов требуется чтобы дойти до `1`.
24 | 
25 | **Входные данные** содержат количество тестов в первой строке.  
26 | Вторая строка содержит сами тесты - т.е. исходные значения для которых нужно определить длину получаемых последовательностей.  
27 | **Ответ** должен содержать для каждого исходного значения полученное количество шагов (через пробел).
28 | 
29 | Например:
30 | 
31 |     входные данные:
32 |     3
33 |     2 15 97
34 |     
35 |     ответ:
36 |     1 17 118
37 | 


--------------------------------------------------------------------------------
/ru/task-25.md:
--------------------------------------------------------------------------------
 1 | <!-- #Линейный Конгруэнтный Метод Генерации Случайных Чисел -->
 2 | Если вы уже решали задачу про [Генератор случайных чисел фон-Нейманна](./neumanns-random-generator--ru)
 3 | то уже знаете, что не все методы генерации псевдослучайных последовательностей хороши.
 4 | В частности Нейманновский метод годится разве что для упражнений в программировании :)
 5 | 
 6 | Вот другой способ, гораздо более распространённый (он реализован в большинстве стандартных библиотек и языков программирования)
 7 | и в то же время весьма прост: начнем с некоторого начального числа, и будем получать каждое следующее значение последовательности
 8 | (`Xnext`) на основании текущего (`Xcur`) по следующему правилу:
 9 | 
10 |     Xnext = (A * Xcur + C) % M
11 | 
12 | Нам понадобятся три константы чтобы однозначно задать последовательность (и начальное значение). Не все сочетания констант
13 | хороши (подробности можно прочесть в [Random Numbers](../wiki/random-numbers)), однако всё-таки существует большое количество
14 | хороших вариантов, которые позволяют получать последовательности с периодом `M`, т.е. весьма длинные.
15 | 
16 | В этом упражнении мы собираемся запрограммировать такой алгоритм чтобы узнать `N-ый` член последовательности.
17 | 
18 | **Входные данные** содержат количество тест-кейсов в первой строке.  
19 | Дальше следуют сами тест-кейсы, по одному в каждой строке - они состоят из пяти значений: `A, C, M, X0, N`,
20 | где первые три - константы из формулы, `X0` - это начальный член - а `N` порядковый номер члена который требуется вычислить.  
21 | **Ответы** должны содержать требуемые члены случайных последовательностей для каждого теста, через пробел.
22 | 
23 | Пример:
24 | 
25 |     входные данные:
26 |     2
27 |     3 7 12 1 2
28 |     2 3 15 8 10
29 |     
30 |     ответ:
31 |     1 11
32 | 


--------------------------------------------------------------------------------
/ru/task-57.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сглаживание Графика Погоды -->
 2 | <div class="text-center">
 3 | 	<img alt="сглаживание кусочно-линейного графика" src="https://codeabbey.github.io/data/smooth_weather.png"/>
 4 | </div>
 5 | 
 6 | Маленький Мерлин хочет стать метеорологом. Он измеряет температуру воздуха каждый час, так что через несколько
 7 | дней получается длинная последовательность значений.
 8 | 
 9 | Однако инструменты его несовершенны и измерения не вполне точны - они "скачут" вверх и вниз на несколько градусов
10 | от реальных значений.
11 | 
12 | Обнаружив это, Мерлин решил "сгладить" данные. Чтобы достичь этого, каждое значение нужно заменить средним от трех -
13 | его самого и двух соседних (предыдущего и следующего). Например, если у нас последовательность из `5` значений:
14 | 
15 |     3 5 6 4 5
16 | 
17 | То второе (`5`) должно быть заменено на `(3 + 5 + 6) / 3 = 4.66666666667`,  
18 | а третье (`6`) заменяется на `(5 + 6 + 4) / 3 = 5`,  
19 | четвертое же (`4`) заменим на `(6 + 4 + 5) / 3 = 5`.  
20 | Договоримся также что первое и последнее значения мы не меняем вовсе.
21 | 
22 | На картинке выше синяя линия изображает необработанные результаты измерений, а красная - данные после сглаживания.
23 | 
24 | От нас требуется написать программу которая поможет малышу Мерлину с его хитроумным алгоритмом цифровой обработки
25 | сигнала.
26 | 
27 | **Входные данные** указывают длину последовательности в первой строке.  
28 | Вторая строка содержит результаты измерений (значения последовательности).  
29 | **Ответ** должен содержать "сглаженную" последовательность. Значения нужно сосчитать с точностью `1e-7` или лучше.
30 | 
31 | Пример:
32 | 
33 |     входные данные:
34 |     7
35 |     32.6 31.2 35.2 37.4 44.9 42.1 44.1
36 |     
37 |     ответ:
38 |     32.6 33 34.6 39.1666666667 41.4666666667 43.7 44.1
39 | 


--------------------------------------------------------------------------------
/de/task-21.md:
--------------------------------------------------------------------------------
 1 | <!-- #Array von Zählern -->
 2 | 
 3 | Anhand dieses Problems lernen wir einen beliebten Programmiertrick, der in vielen Varianten der statistischen Berechnungen verwendet wird.
 4 | 
 5 | Stellen Sie sich vor, dass ein Förster versucht, Kiefern, Tannen und Birken in einem bestimmten Waldstück zu zählen. Er kann diesen Abschnitt dreimal durchgehen und beim ersten Durchgang nur Kiefern, beim zweiten nur Tannen und beim dritten nur Birken zählen. 
 6 | 
 7 | Effizienter ist es allerdings, nur einmal durch das Waldstück zu gehen und für jeden Baum einen Punkt auf einer der Baumseiten in seinem
 8 | Notizbuch zu machen - die erste Seite für Kiefern, die nächste für Tannen und die letzte für Birken. Das ist die Idee des Zählens ähnlicher Elemente in einer Sequenz, 
 9 | mithilfe einer Reihe von Zählern (hier einem Array statt eines Notizbuches).
10 | 
11 | Wir bekommen ein Array der Länge `M` mit Zahlen im Bereich von `1 ... N`, wobei `N` kleiner oder gleich `20` ist.
12 | Wir werden es durchlaufen und zählen, wie oft jede Zahl vorkommt.  
13 | D.h. es ist eine ähnliche Aufgabe wie [Vokale Zählen](./vowel-count), allerdings müssen wir mehr als einen Zähler verwalten. Achten Sie darauf, 
14 | dass Sie ein eigenes Array für die Zähler verwenden anstatt viele seperate Variablen für jeden Zähler zu erstellen.
15 | 
16 | Die **Eingabe Daten** enthalten `M` und `N` in der ersten Zeile.  
17 | Die zweite (ziemlich lange) Zeile wird `M` mithilfe von Leerzeichen getrennte Zahlen enthalten.  
18 | Die **Antwort** soll genau `N` durch Leerzeichen getrennte Werte beinhalten. Die erste Zahl soll die Anzahl der `1`-sen,
19 | die zweite die Anzahl der `2`-en entsprechen - und so weiter.
20 | 
21 | Beispiel:
22 | 
23 |     Eingabe Daten:
24 |     10 3
25 |     3 2 1 2 3 1 1 1 1 3
26 | 
27 |     Antwort:
28 |     5 2 3
29 | 


--------------------------------------------------------------------------------
/de/task-7.md:
--------------------------------------------------------------------------------
 1 | <!-- #Fahrenheit zu Celsius -->
 2 | Diese Programmierübung ist ähnlich zur Aufgabe "Summieren in Schleife" ("counting sums in loop"), 
 3 | bedarf aber ein wenig mehr Berechnungen
 4 | 
 5 | 
 6 | <div class="text-center">
 7 | 	<img alt="fahrenheit und celsius" src="https://codeabbey.github.io/data/fahrenheit_celsius.png"/>
 8 | 	<div class="hint">Anmerkung: Die Übung <a href="./rounding--de">Rundung</a> erklärt den Rundungs-Algorythmus
 9 | 	den wir in dieser Aufgabe nun wieder benutzen werden.</div>
10 | </div>
11 | 
12 | Zur Messung von Temperaturen gibt es zwei weitverbreitete Systeme - Celsius and Fahrenheit.
13 | Das erste ist in Europa und weltweit weit verbreitet, während das zweite vor allem in britisch geprägten
14 | Gebieten wie den USA zu finden ist. 
15 | 
16 | Auf der Celsius-Skala friert Wasser bei genau 0 Grad C und kocht bei 100 Grad C. Auf der Fahrenheit-Skala
17 | friert Wasser bei 32 Grad F und kocht bei 212 Grad F. Mehr darüber können Sie im Wikipedia Beitrag 
18 | [Grad Fahrenheit](https://de.wikipedia.org/wiki/Grad_Fahrenheit) nachlesen. 
19 | 
20 | Verwenden Sie diese Punkte für ihre Umrechnung von Temperaturen. 
21 | 
22 | 
23 | Die Aufgabe besteht nun darin, ein Programm zu schreiben, welches Fahrenheit in Celsius umrechnen kann. 
24 | 
25 | **Eingabe Daten** enthalten `N+1` Werte, der erste davon ist `N` selbst. (**Beachten Sie**, dass Sie diesen nicht konvertieren).  
26 | **Lösung** enthält genau `N` Resultate, gerundet auf die nächstnähere Ganzzahl und durch Leerzeichen getrennt. 
27 | 
28 | Beispiel:
29 | 
30 |     Eingabe Daten:
31 |     5 495 353 168 -39 22
32 | 
33 |     Lösung:
34 |     257 178 76 -39 -6
35 | 
36 | *Bitte nehmen Sie zur Kenntnis, dass die erste `5` keine Temperatur ist, sondern die Anzahl der nachfolgend zu konvertierenden Werte darstellt!*
37 | 
38 | 


--------------------------------------------------------------------------------
/ua/task-36.md:
--------------------------------------------------------------------------------
 1 | Якщо ви знаєте старовинну гру [Bulls and Cows](./bulls-and-cows), ця задачка з програмування буде вам знайомою.
 2 | 
 3 | Андрій і Петро грають у гру з відгадання коду. Андрій загадує `таємне число`, що складається з трьох цифр. Петро намагатиметься 
 4 | відгадати код, пропонуючи почергово кілька варіантів.
 5 | 
 6 | На кожну `відгадку` Андрій повинен надати число правильно вгаданих цифр ― тобто таких, що **є однаковими** у запропонованому варіанті 
 7 | та в таємному коді, а також розташовані у **відповідному місці** в числі. Наприклад, якщо таємне число `125` і Петро назве `523`,
 8 | в такому разі Андрієва відповідь буде `1`. Ось зразок гри:
 9 | 
10 |     Андрій вибирає таємне число 846
11 | 	
12 | 	Здогадка Петра          Відповідь Андрія
13 | 	    402                        0
14 | 	    390                        0
15 | 	    816                        2
16 | 	    848                        2
17 | 	    777                        0
18 | 	    815                        1
19 | 	    846                        3
20 | 
21 | Отже Петро вгадав код після `6` спроб.
22 | 
23 | Вам потрібно написати програму, яка проаналізує відповіді Петра (крім останньої) і виведе Андрієве таємне число.
24 | Гарантовано існує єдине рішення задачі.
25 | 
26 | **Вхідні дані** містять у першому рядку число здогадок.  
27 | Нижче подані відповіді із здогадками ― кожна з них містить варіант Петра та відповідь на це Андрія.  
28 | На противагу поданому зразку, в умовах задачі числа складатимуться з `4` цифр.  
29 | **Відповідь** повинна містити таємне число (число з `4` цифр). До прикладу:
30 | 
31 |     вхідні дані:
32 |     6
33 |     402 0
34 |     390 0
35 |     816 2
36 |     848 2
37 |     777 0
38 |     815 1
39 | 
40 |     відповідь:
41 |     846
42 | 
43 | *Для стислості послуговуємось 3-значними числами, проте алгоритм однаковий.*
44 | 


--------------------------------------------------------------------------------
/ua/task-59.md:
--------------------------------------------------------------------------------
 1 | <!-- #Code Guesser -->
 2 | Якщо ви знаєте старовинну гру [Bulls and Cows](./bulls-and-cows), ця задачка з програмування буде вам знайомою.
 3 | 
 4 | Андрій і Петро грають у гру з відгадання коду. Андрій загадує `таємне число`, що складається з трьох цифр. Петро намагатиметься 
 5 | відгадати код, пропонуючи почергово кілька варіантів.
 6 | 
 7 | На кожну `відгадку` Андрій повинен надати число правильно вгаданих цифр ― тобто таких, що **є однаковими** у запропонованому варіанті 
 8 | та в таємному коді, а також розташовані у **відповідному місці** в числі. Наприклад, якщо таємне число `125` і Петро назве `523`,
 9 | в такому разі Андрієва відповідь буде `1`. Ось зразок гри:
10 | 
11 |     Андрій вибирає таємне число 846
12 | 	
13 | 	Здогадка Петра          Відповідь Андрія
14 | 	    402                        0
15 | 	    390                        0
16 | 	    816                        2
17 | 	    848                        2
18 | 	    777                        0
19 | 	    815                        1
20 | 	    846                        3
21 | 
22 | Отже Петро вгадав код після `6` спроб.
23 | 
24 | Вам потрібно написати програму, яка проаналізує відповіді Петра (крім останньої) і виведе Андрієве таємне число.
25 | Гарантовано існує єдине рішення задачі.
26 | 
27 | **Вхідні дані** містять у першому рядку число здогадок.  
28 | Нижче подані відповіді із здогадками ― кожна з них містить варіант Петра та відповідь на це Андрія.  
29 | На противагу поданому зразку, в умовах задачі числа складатимуться з `4` цифр.  
30 | **Відповідь** повинна містити таємне число (число з `4` цифр). До прикладу:
31 | 
32 |     вхідні дані:
33 | 	6
34 | 	402 0
35 | 	390 0
36 | 	816 2
37 | 	848 2
38 | 	777 0
39 | 	815 1
40 | 	
41 | 	відповідь:
42 | 	846
43 | 
44 | *Для стислості послуговуємось 3-значними числами, проте алгоритм однаковий.*
45 | 


--------------------------------------------------------------------------------
/es/task-57.md:
--------------------------------------------------------------------------------
 1 | <div class="text-center">
 2 | 	<img alt="ejemplo de suavizacion de linea en tabla de datos" src="https://codeabbey.github.io/data/smooth_weather.png"/>
 3 | </div>
 4 | 
 5 | El pequeño Merlin quiere ser meteorologo. El mide la temperatura del aire cada hora así que despues de 
 6 | varios dias el tiene una larga secuencia de valores.
 7 | 
 8 | Sin embargo, sus instrumentos no son ideales por lo que las mediciones no son exactas--pues aleatoreamente
 9 | saltan hacia arriba y hacia abajo algunos grados del valor real.
10 | 
11 | observando esto, Merlin decide hacer los datos más suaves. Para lograrlo, el solo necesita que cada valor
12 | sea substituido por el promedio de sus dos vecinos. Por ejemplo, si el tiene una secuencia de cinco valores como esta:
13 | 
14 |     3 5 6 4 5
15 | 
16 | Entonces el segundo  (i.e. `5`) debe ser sustituido por `(3 + 5 + 6) / 3 = 4.66666666667`,  
17 | el tercero (i.e. `6`) debe ser sustituido por `(5 + 6 + 4) / 3 = 5`,  
18 | el cuarto  (i.e. `4`) debe ser sustituido por `(6 + 4 + 5) / 3 = 5`.  
19 | Por convencion, los valores primero y ultimo permanecerán iguales.
20 | 
21 | En la imagen de arriba la linea azul muestra los datos sin procesar, mientras que la roja los muestras suavizados.
22 | 
23 | Tienes que escribir un programa que le ayude al pequeño Merlin con este algoritmo de procesamiento digital de señales.
24 | 
25 | **Datos de entrada** En esta primera linea, se dará la longitud de la secuencia de datos de la segunda linea.  
26 | La segunda linea contendra las mediciones.
27 | **Respuesta** debe contener la secuencia procesada. Todos los valores deben ser calculados con una precision minima de `1e-7`.
28 | 
29 | Ejemplo:
30 | 
31 |     datos de entrada:
32 | 	7
33 | 	32.6 31.2 35.2 37.4 44.9 42.1 44.1
34 | 	
35 | 	respuesta:
36 | 	32.6 33 34.6 39.1666666667 41.4666666667 43.7 44.1
37 | 


--------------------------------------------------------------------------------
/fr/task-1.md:
--------------------------------------------------------------------------------
 1 | <div class="centered hint">
 2 | 	<img alt="Les moînes de CodeAbbey ont de la difficulté avec des erreurs" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 3 | 	<span>Illustration d'un programmeur ayant de la difficulté à trouver une erreur.</span><br/>
 4 | 	<span>Notez que les bons outils peuvent être utiles!</span>
 5 | </div>
 6 | 
 7 | Il n'est pas toujours facile de débuter, alors essayons le plus simple des problèmes.
 8 | Le but est de pratiquer l'utilisation du site, la soumission de réponse, etc.
 9 | 
10 | Nous devons additionner deux nombres et fournir le résultat. Bien que vous puissiez le faire
11 | manuellement, essayez d'écrire un programme simple dans n'importe quel langage que vous connaissez,
12 | aimez ou désirez apprendre.
13 | 
14 | _[Ce vidéo](http://www.youtube.com/watch?v=gxfqeDm-B6k) fait la démonstration en détail des étapes à suivre._
15 | 
16 | ###Comment soumettre une solution
17 | 
18 | Si vous êtes identifié au site (logged in), vous verrez les champs suivants ci-dessous:
19 | 
20 | - **Données fournies** contiens les "données fournies" ou "cas test" - deux nombres dont nous désirons la somme.
21 | - **Réponse** - est l'endroit ou vous inscrivez votre résultat après avoir exécuté votre programme.
22 | - **Votre solution** - est où vous inscrivez votre programme. Celui-ci n'est pas exécuté ni vérifié
23 |     (du moins, pas automatiquement), mais il peut vous être utile pour réutiliser du code dans une
24 |     autre solution. Vous pouvez revisiter la page en tout temps pour voir votre solution.
25 | 
26 | Exemple:
27 | 
28 | 	Données fournies:
29 | 	3 5
30 | 	
31 | 	Réponse:
32 | 	8
33 | 
34 | Nous fournissons **[des exemples](../wiki/running)** du programme en plusieurs langages populaires,
35 | mais nous vous conseillons fortement de ne pas les regarder avant d'avoir réussi votre propre solution. :)
36 | 


--------------------------------------------------------------------------------
/es/task-23.md:
--------------------------------------------------------------------------------
 1 | <!-- translation by https://github.com/manlug -->
 2 | 
 3 | Este problema plantea un ejercicio para aprender la idea principal del algoritmo de [ordenamiento de burbuja (bubble-sort)](./bubble-sort--es), 
 4 | el cual veremos un poco más adelante.
 5 | 
 6 | Dada la matriz de enteros, debemos iterar a través de todos los pares de elementos vecinos, comenzando desde el principio, 
 7 | e intercambiar los miembros de cada par en el caso de que el primer elemento sea mayor que el segundo.
 8 | 
 9 | Por ejemplo, consideremos una pequeña serie de elementos `1 4 3 2 6 5`, marcando qué pares se intercambian y cuáles no:
10 | 
11 |     (1  4) 3  2  6  5  - pasar al siguiente par
12 |     1 (4  3) 2  6  5   - intercambiar
13 |     1  3 (4  2) 6  5   - intercambiar
14 |     1  3  2 (4  6) 5   - pasar al siguiente par
15 |     1  3  2  4 (6  5)  - intercambiar
16 |     1  3  2  4  5  6   - fin
17 | 
18 | Esta operación mueve algunos elementos grandes hacia la derecha (hacía el final de la matriz) y algunos elementos más pequeños hacia la izquierda (hacia el principio de la matriz).
19 | 
20 | Lo más importante es que: **el elemento más grande necesariamente se mueve a la última posición**.
21 | 
22 | **Datos de entrada** contienen la secuencia de elementos de la matriz, todos positivos. Después de este valor sigue `-1` para marcar el final (que no debe ser incluido en la matriz).
23 | 
24 | **La respuesta** debe contener dos valores: el número de intercambios realizados y la suma de comprobación (checksum) de la matriz después del proceso realizado (separado por espacios).
25 | La suma de comprobación (Checksum) se debe calcular exactamente con el mismo método que en la tarea
26 | [Suma de comprobación de matriz (Array Checksum)](./array-checksum--es)
27 | 
28 | Ejemplo:
29 | 
30 | 	Datos entrada:
31 | 	1 4 3 2 6 5 -1
32 | 	
33 | 	Respuesta:
34 | 	3 5242536
35 | 


--------------------------------------------------------------------------------
/sk/task-43.md:
--------------------------------------------------------------------------------
 1 | <!-- #Hod Kockou  -->
 2 | Pri programovaní RPG alebo stolových hrách, veľa začínajúcich programátorov okúsi problémy v konverzií náhodných hodnôt
 3 | na jednotlivé čísla pri hode kockou. Cieľom tejto úlohy je vyskúšať si simuláciu hodom kocky, hodnotami z generátoru
 4 | náhodných čísel.
 5 | 
 6 | Predpokladajme, že máme generátor, ktorý nám da hodnoty v rozmedzí od  `0` (je v intervale) do `1` (nie je v intervale)
 7 | s týmto sa môžete stretnúť v jazykoch ako **Basic**, **Java**, **Matlab** atď.
 8 | 
 9 | Chceme konvertovať tieto hodnoty s rôznou dĺžkou desatinného rozvoja na 6 **celých** čísel: od `1` do `6`. Toto sa dá
10 | dosiahnuť nasledovne:
11 | 
12 | 1. Vynásobením náhodnej hodnoty číslom N, čo je počet odlišných hodnôt, ktoré chceme získať - v našom prípade 
13 |     násobíme `6` a výsledok bude číslo s rôznou dĺžkou desatinného rozvoja od `0` (je v intervale) do `6` (nie je v intervale)
14 | 2. Teraz vezmeme celočíselnú časť tohoto výsledku (funkciou ako `floor` alebo konverziou na `int`) - hodnota
15 |     sa teraz stane jedným z čísel `0`, `1`, `2`, `3`, `4`, `5` .
16 | 3. Keďže my chceme hodnoty od `1` do `6` jednoducho pripočítame `1` k nášmu výsledku. 
17 | 
18 | Teraz dostanete niekoľko čísel v rozmedzí `[0 .. 1)` (uisťujeme vás, že sú poskytnuté generátorom náhodných čísel) - 
19 | a vašou úlohou je premeniť ich na čísla kocky aplikovaním vyššie zmieneného algoritmu.
20 | 
21 | **Vstupné dáta** budú obsahovať počet hodnôt na premenu v prvom riadku.
22 | Ostatné riadky budú obsahovať samotné hodnoty, čísla ako `0.142857`. 
23 | **Odpoveď** by mala obsahovať čísla od `1` do `6` pre každú hodnotu, vytvorené zmieneným algoritmom.
24 | 
25 | Príklad:
26 | 
27 |     6
28 | 	0.59558786964
29 | 	0.861037873663
30 | 	0.385597702116
31 | 	0.246237673331
32 | 	0.808033385314
33 | 	0.0544673665427
34 | 	
35 | 	odpoveď:
36 | 	4 6 3 2 5 1
37 | 


--------------------------------------------------------------------------------
/de/task-28.md:
--------------------------------------------------------------------------------
 1 | Lassen Sie uns nun unsere Programmier-Kenntnisse an einem "quasi" Wissenschaftlichen Problem anwenden. 
 2 | Schliesslich ist es ein bisschen langweilig, nur abstrakte/theoretische Dinge zu erlernen. 
 3 | 
 4 | Die einfache Messung der Körperkonstitution wurde in der Mitte des XIX Jahrhunderts vorgeschlagen.
 5 | Es basiert einzig auf Körpergroße und Gewicht einer Person und wird **Body Mass Index** oder auch **BMI** genannt.
 6 | Es ist definiert als:
 7 | 
 8 |     BMI = Gesicht / Körpergröße^2
 9 | 
10 | Wobei Gewicht in `Kilogram` und Körpergröße in `Meter` gemessen wird.
11 | 
12 | Generell unterscheidet man vier Grade:
13 | 
14 |     Untergewichtig     -           BMI < 18.5
15 |     Normalgewichtig    -   18.5 <= BMI < 25.0
16 |     Übergewichtig      -   25.0 <= BMI < 30.0
17 |     Fettleibig         -   30.0 <= BMI
18 | 
19 | Als Beispiel, bei einem Gewicht von `80 kg` und einer Körpergroße von `1.73 m` berechnet sich mein BMI wie folgt:
20 | 
21 |     BMI = 80 / (1.73)^2 = 26.7
22 | 
23 | Ich bin insofern etwas übergewichtig.
24 | 
25 | Wir werden nun nicht darüber diskutieren, wie ungenau und unangemessen diese Einteilung ist. 
26 | Stattdessen sollen Sie einfach nur die BMI Stufen für mehrere Personen berechnen und ausgeben. 
27 | 
28 | **Eingabe Daten** enthält in der ersten Zeile die Anzahl der Personen, für welche Sie den BMI Grad berechnen sollen.  
29 | Die nachfolgenden Zeilen enthalten jeweils zwei Werte - Das Gewicht in Kilogramm und die Körpergröße in Meter.  
30 | **Lösung** sollte in einer Zeile durch Leerzeichen getrennt die BMI-Stufe als "Wort" ausgeben.  
31 | Verwenden Sie dazu bitte die englische Bezeichnungen `under`, `normal`, `over` oder `obese` entsprechend der BMI Grade.
32 | 
33 | Beispiel:
34 | 
35 |     Eingabe Daten:
36 |     3
37 |     80 1.73
38 |     55 1.58
39 |     49 1.91
40 | 
41 |     Lösung:
42 |     over normal under
43 | 


--------------------------------------------------------------------------------
/sk/task-17.md:
--------------------------------------------------------------------------------
 1 | Kontrolne súčty sú malé hodnoty vypočítané z veľkého množstva dát na otestovanie konzistencie dát, t.j. kontrola
 2 | chýb v dátach.
 3 | 
 4 | Napríklad ak Anna pošle nejaký súbor Bobovi, môže vypočítať kontrolný súčet a povedať ho Bobovi, a on
 5 | si vypočíta kontrolný súčet súboru, ktorý prijal a porovná to s hodnotami od Anny.
 6 | 
 7 | _Ďalší, ešte bežnejší príklad - všetky bankové karty, ktoré používate majú kontrolný súčet v poslednej číslici, 
 8 | takže zariadenia na kontrolu tohoto kontrolného súčtu, vám bránia použitiu nesprávnych čísel omylom (viac sa môžete
 9 | dočítať v cvičení [Luhnov Algoritmus](./luhn-algorithm--sk))._
10 | 
11 | Pre programovanie niekoľkých ďalších úloh použijeme podobný spôsob, aby sme skontrolovali či je výsledok polí (array) 
12 | správny alebo nie. Aby sme predišli problémom s podobnými úlohami, poďme si teraz precvičiť algoritmus počítania kontrolných súčtov
13 | a to je náš
14 | 
15 | ###Problémový výrok
16 | 
17 | Dostanete pole pre ktoré vypočítate kontrolný súčet. Výpočet urobte nasledovne:
18 | pre každý prvok poľa (od začiatku) pridajte tento prvok do premennej `výsledok` a vynásobte túto sumu číslom
19 | `113` - táto nová hodnota, modulo `10000007` bude ďalšia hodnota `výsledku`, a tak ďalej.
20 | 
21 | Pre detailnejšie vysvetlenie si prečítajte [článok o kontrolnom súčte](../wiki/checksum).
22 | Tam môžete nájsť aj príklad pre výpočty tejto kontrolnej sumy.
23 | 
24 | **Vstupné dáta** budú obsahovať dĺžku poľa v prvom riadku.  
25 | Samotné hodnoty budú nasledovať v druhom riadku a budú oddelené medzerami.  
26 | **Odpoveď** by mala obsahovať jednu hodnotu - vypočítaný kontrolný súčet.
27 | 
28 | Príklad:
29 | 
30 |     vstupné dáta:
31 | 	6
32 | 	3 1 4 1 5 9
33 | 
34 | 	odpoveď:
35 | 	8921379
36 | 
37 | _Všetky vstupné hodnoty sú medzi `0` a `1,000,000,000` - uistite sa že nedôjde k presahu 
38 | hodnôt počas výpočtov!_
39 | 


--------------------------------------------------------------------------------
/es/task-14.md:
--------------------------------------------------------------------------------
 1 | Esta tarea proporciona práctica en la propiedad fundamental de la operación del residuo en la aritmética - la persistencia del
 2 | residuo sobre la adición y la multiplicación. Esta importante propiedad es a menudo usada para verificar los resultados de los
 3 | cálculos, en las competencias de programación, en los cálculos de sumas de verificación (checksums) y especialmente para el cifrado.  
 4 | Revisa [Modular arithmetic][modar] para una explicación más detallada.
 5 | 
 6 | [modar]: ../wiki/modular-arithmetic
 7 | 
 8 | Tenemos aquí una especie de cálculo aritmético extenso, y se nos pide el módulo del resultado con otro número (`resultado % M` en varios lenguajes).
 9 | 
10 | _Si tienes curiosidad acerca por qué la aritmética modular es tan importante, puedes darle un vistazo a los ejercicios
11 | [Public Key Cryptography Intro](./public-key-cryptography-intro) y [RSA Cryptography](./rsa-cryptography)._
12 | 
13 | Los **Datos de entrada** tendrán:
14 | 
15 | - Número entero inicial en la primera línea;
16 | - Una o más líneas describiendo las operaciones, según el formato `signo valor` donde el signo es `+` o `*` y el valor es un entero;
17 | - La última línea con la misma forma anterior pero con el signo `%` en su lugar, y un número entre el cual el resultado debe ser dividido para obtener el residuo.
18 | 
19 | La **Respuesta** debería dar el residuo del resultado de todas las operaciones aplicadas secuencialmente (empezando por el número inicial)
20 | y dividido entre el último número.
21 | 
22 | Ejemplo:
23 | 
24 |     datos de entrada:
25 |     5
26 |     + 3
27 |     * 7
28 |     + 10
29 |     * 2
30 |     * 3
31 |     + 1
32 |     % 11
33 | 
34 |     respuesta:
35 |     1
36 | 
37 | _En este caso, el resultado luego de aplicar todas las operaciones secuencialmente es `397`_.
38 | 
39 | Ningún número excederá 10000 (aunque los resultados intermedios podrían ser números muy grandes).
40 | 
41 | 


--------------------------------------------------------------------------------
/es/task-48.md:
--------------------------------------------------------------------------------
 1 | <!-- #Secuencia de Collatz -->
 2 | Este es uno de los problemas matematicos más misteriosos del siglo pasado -- porque su planteamiento es extremadamente simple-
 3 | y porque la prueba es aún desconocida. Sin embargo, ofrece un buen ejercicio de programación para novatos.
 4 | 
 5 | **Suponga** que selecionamos un valor inicial 'X' y luego construimos una secuencia de valores siguiendo las reglas a continuación:
 6 | 
 7 |     si X es par (es decir, X modulo 2 = 0) entonces
 8 | 	    Xsiguiente = X / 2
 9 | 	  sino
10 | 	    Xnext = 3 * X + 1
11 | 
12 | Es decir, si `X` es impar, la secuencia crecerá -- y si es par, la secuencia decrecerá. Por ejemplo, con `X = 15` tenemos la secuencia:
13 | 
14 |     15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
15 | 	
16 | Después de que la secuencia alcanza '1' entra en el loop `1 4 2 1 4 2 1...`.
17 | 
18 | La intriga está en el hecho de que dado cualquier numero inicial 'X' la secuencia tarde o temprano alcanza '1' - sin embargo
19 | imaginate que esta `conjetura de Collatz ` fue expresada en '1937' y hasta el momento nadie ha logrado probar o encontrar un contraejemplo
20 | (Es decir, un numero para el cual la secuencia no termina en '1' --ya sea un entero para el cual el loop es más grande que un loop creciendo hasta infinitamente)
21 | de que la conjetura es para cualquier 'X'.
22 | 
23 | **Tu tarea**  es que para los numeros dados calcules cuantos pasos son necesarios para llegar a '1'
24 | 
25 | **Datos de entrada**  en la primera linea contiene el numero de casos a calcular.  
26 | La segunda linea contiene los casos de prueba- Es decir, los valores para los cuales el calculo debe ser hecho.
27 | **Respuesta** debe contener la misma cantidad de resultados, cada una de ellas dando la cuenta del numero de pasos en la secuencia de Collatz
28 | para llegar a ´1´.
29 | 
30 | Por ejemplo:
31 | 
32 |   datos de entrada:
33 | 	3
34 | 	2 15 97
35 | 	
36 | 	respuesta:
37 | 	1 17 118
38 | 


--------------------------------------------------------------------------------
/de/task-1.md:
--------------------------------------------------------------------------------
 1 | <!-- #Summe zweier Zahlen -->
 2 | <div class="centered hint">
 3 | 	<img alt="CodeAbbey Mönche kämpfen with Bug" src="https://codeabbey.github.io/data/sum_of_two.gif"/><br/>
 4 | 	<span>Eine künstlerische Darstellung von Programmierern, welche mit Software-Bugs zu kämpfen haben.</span><br/>
 5 | 	<span>Merke: Passendes Werkzeug ist wichtig und meist hilfreich!</span>
 6 | </div>
 7 | 
 8 | Da aller Anfang schwer sein kann, lassen Sie uns am besten mit etwas Einfachem beginnen. 
 9 | Das Ziel ist nun, das Einreichen von Lösungen usw. zu üben. 
10 | 
11 | Es sollen nun zwei Zahlen addiert und das Resultat genannt werden. 
12 | Obwohl Sie das auch manuell tun könnten, sollten Sie versuchen, ein
13 | kleines Programm in einer Sprache, welche Sie schon kennen, oder einer Sprache, welche sie gerne lernen möchten, zu scheiben. 
14 | 
15 | _[Dieses Video](http://www.youtube.com/watch?v=gxfqeDm-B6k) (in englisch) demonstriert die notwendigen Schritte._
16 | 
17 | ###Wie übermittle ich eine Lösung
18 | 
19 | Wenn Sie bereits eingeloggt sind, sehen Sie die folgenden Eingabefelder:  
20 | 
21 | - **Test data** beinhaltet die "Eingabe-Daten" bzw. "Test-Daten" - Zwei Zahlen, welche wir gerne addieren möchten. 
22 | - **Your answer** - In diesem Feld erscheint die Ausgabe ihres Programms, also das Resultat der verarbeiteten Daten.
23 | - **Your solution** - Dieses Feld beinhaltet ihren selbstgeschriebenen Programm-Code bzw. die "Lösung" zu dieser Aufgabe.
24 |     Sie können später jederzeit diese Aufgabe wieder aufrufen und ihren eingereichten Programm-Code wieder betrachten.
25 | 
26 | Beispiel:
27 | 
28 |     Eingabe Daten:
29 |     3 5
30 | 
31 |     Resultat:
32 |     8
33 | 
34 | Wir bieten Ihnen für diese Aufgabe **[Lösungsbeispiele](../wiki/running)** in vielen populären Programmiersprachen an, 
35 | aber wir raten davon ab, sich diese vorher anzuschauen. Versuchen Sie besser erst einmal, diese Aufgabe ohne Beispiel zu lösen. :)
36 | 
37 | 


--------------------------------------------------------------------------------
/es/task-18.md:
--------------------------------------------------------------------------------
 1 | Muchos problemas matemáticos en programación no son resueltos exactamente, sino aproximadamente, mediante varias computaciones del
 2 | resultado, cada de una de las cuales se acerca cada vez más al objetivo.
 3 | 
 4 | Practiquemos con el siguiente enfoque el método de cálculo aproximado de la raíz cuadrada:
 5 | 
 6 | 1. Busca la raíz cuadrada `r` del valor dado `X`.
 7 | 2. Usa algún valor arbitrario, por ejemplo `r = 1` como la primera aproximación (seguramente no es la más adecuada).
 8 | 3. Para un cálculo apropiado de la raíz cuadrada, la ecuación `r = X / r` debe cumplirse.
 9 | 4. Calcula `d = X / r` (d no sería igual a `r`, ya que `r` no es la raíz exacta).
10 | 5. Toma el promedio entre `r` y `d` como la nueva aproximación.
11 | 
12 | Ej.: La fórmula general de cada iteración del cálculo es (`:=` es una asignación):
13 | 
14 |           r  +  X / r
15 |     r := -------------
16 |                2
17 | 
18 | Remítete al artículo de [Aproximación de la Raíz Cuadrada](../wiki/square-root-approximation) para más detalles sobre el **Método de Herón**.
19 | 
20 | Se nos dan entonces valores de `X` para los cuales se realizarán los cálculos y el número de iteraciones `N` a ejecutar.  
21 | Usa `r = 1` al comienzo, y muestra la aproximación resultante (después de las `N` iteraciones).
22 | 
23 | Los **Datos de entrada** darán el número de casos de prueba en la primera línea.  
24 | Las siguientes líneas contendrán los casos de prueba en sí mismos, cada uno conteniendo un valor `X`, para el cual la raíz cuadrada debería
25 | ser calculada, y `N` - el número de iteraciones de cálculo.  
26 | La **Respuesta** debería contener las aproximaciones calculadas para cada caso, separadas por espacios.
27 | 
28 | Ejemplo:
29 | 
30 |     datos de entrada:
31 |     3
32 |     150 0
33 |     5 1
34 |     10 3
35 | 
36 |     respuesta:
37 |     1 3 3.196
38 | 
39 | _Los resultados deberían tener una precisión de `1e-7 = 0.0000001` o mejor!_
40 | 


--------------------------------------------------------------------------------
/es/task-26.md:
--------------------------------------------------------------------------------
 1 | <!-- #Máximo Común Divisor -->
 2 | Parece que ningún curso de programación para principiantes evita hacer practicar el algoritmo de Euclides para calcular el máximo común divisor de dos números.
 3 | 
 4 | El Máximo Común Divisor (MCD) de `a` y `b` es un valor entero `c` tal que tanto `a` como `b` son divisibles por él (es decir, no dejan residuo), y `c` es el valor más grande posible. Por ejemplo, `mcd(20, 35) = 5` y `mcd(13, 28) = 1`. El algoritmo de Euclides es bastante simple: seguimos restando el valor más pequeño (de `a` y `b`) del más grande, repitiendo esta operación hasta que los valores se igualen. Este valor final será el MCD. Para acelerar el proceso, podemos usar la operación de módulo en lugar de la resta.
 5 | 
 6 | Por ejemplo:
 7 | 
 8 | 
 9 |     20      35      - restar el primero del segundo
10 |     20      15      - restar el mas pequeño del más grande
11 |     5       15      - ahora restar el primero del segundo de nuevo
12 |     5       5       - una resta mas y aquí está el MCD
13 | 
14 | 
15 | El Mínimo Común Múltiplo (MCM) de `a` y `b` es un entero `d` que es divisible por ambos (y es el más pequeño de todos los posibles). Se puede encontrar usando la siguiente regla:
16 | 
17 |     mcm(a, b) = a * b / mcd(a, b)
18 | 
19 | Por cierto, si este problema te parece demasiado fácil, ¡echa un vistazo a la versión avanzada para encontrar el [MCM de un rango](/index/task_view/lcm-of-a-range)!
20 | 
21 | ### El objetivo:
22 | Los **datos de entrada** contienen el número de casos de prueba en la primera línea. Luego siguen líneas con casos de prueba, cada una conteniendo dos números - `A` y `B`. La **respuesta** debe contener el MCD y el MCM para cada par, rodeados por paréntesis y separados por espacios. Por ejemplo:
23 | 
24 |     datos de entrada:
25 |     2
26 |     2 3
27 |     4 10
28 |     
29 |     respuesta:
30 |     (1 6) (2 20)
31 | 
32 | _translated by [Alan Garcia](/index/user_profile/st-allan)_
33 | 


--------------------------------------------------------------------------------
/de/task-8.md:
--------------------------------------------------------------------------------
 1 | Wenn wir über **arithmetische Progression** (oder arithmetische Folgen) sprechen, meinen wir die Serie
 2 | von Zahlen mit einer besonderen Eigenschaft - auf jeden Wert folgt ein weiterer, der um einen vordefinierten Betrag (Schritt)
 3 | größer ist.
 4 | 
 5 | D.h. die Differenz des `(K+1)`-ten und `K`-ten Wertes ist eine Konstante. Hier sind Beispiele für solche Sequenzen
 6 | 
 7 | 	1 2 3 4 5 6 7 ...
 8 | 	4 6 8 10 12 14 16...
 9 | 	10 13 16 19 22 25 28...
10 | 
11 | Somit ist die arithmetische Sequenz druch das erste Glied (`A`) und den Inkrement
12 | Wert - die Schrittweite - (`B`) vollständig definiert. Die ersten Werte der Sequenz können wie folgt ausgedrückt werden
13 | 
14 |     A + (A + B) + (A + 2B) + (A + 3B) + ...
15 | 
16 | Sie sollen die Summe der ersten Glieder der arithmetischen Folge berechnen.
17 | Die [Wikipedia Seite][wiki] über arithmetische Progression könnte für jemanden der ihnen zum ersten mal begegnet
18 | eine gute Hilfe sein.
19 | 
20 | [wiki]: https://de.wikipedia.org/wiki/Arithmetische_Folge
21 | 
22 | **Eingabe Daten:** haben in der ersten Zeile die Anzahl der Testfälle.  
23 | Die folgenden Zeilen enthalten Wertetripel der Form `A B N` bei denen `A` der erste Wert der Sequenz ist,
24 | `B` die Schrittweite und `N` die Anzahl der ersten Werte die erzeugt werden sollen.  
25 | **Antwort:** Sie sollen die Ergebnisse (also die Summe der ersten `N` Sequenzglieder) für jede Sequenz durch Leerzeichen getrennt ausgeben.
26 | 
27 | Beispiel:
28 | 
29 |     Eingabe Daten:
30 |     2
31 |     5 2 3
32 |     3 0 10
33 |     
34 |     Antwort:
35 |     21 30
36 | 
37 | _Erklärung des Beispiels. Im ersten Fall haben wir eine Sequenz mit dem Startwert `5` und dem Inkrement (der Schrittweite) `2`.
38 | Wir summieren die ersten `3` Elemente der Sequenz `5 + 7 + 9 = 21`. Der zweite Fall ist einfacher. Er startet mit `3`, aber das Inkrement ist `0`,
39 | also ist die Summe `3 + 3 + ... + 3 = 30` (insgesamt für `10` Elemente)._
40 | 


--------------------------------------------------------------------------------
/ru/task-43.md:
--------------------------------------------------------------------------------
 1 | <!-- #Бросание Игральной Кости (Кубика) -->
 2 | Программируя настольные или ролевые игры, новички часто испытывают затруднения с превращением случайных чисел в
 3 | значения очков игральных костей. Цель этой задачи - попрактиковаться в программном выбрасывании костей используя
 4 | значения от генератора случайных чисел.
 5 | 
 6 | Пусть наш генератор выдаёт случайные вещественные числа в диапазоне от `0` (включительно) до `1` (не включая) -
 7 | вы можете встретить такой в языках вроде **Basic**, **Java**, **Matlab** и т.п.
 8 | 
 9 | Нам нужно преобразовать эти дробные значения в **целые**, в диапазоне от `1` до `6`. Это можно сделать например так:
10 | 
11 | 1. Умножим случайное число на `N` - число различных значений которые нам нужны - т.е. в данном случае умножим на `6`,
12 |     так что результат будет вещественным числом от `0` (включая) до `6` (не включая)
13 | 2. Теперь возьмём целую часть от результата (т.е. **округлим вниз** вызвав функцию `floor` или преобразовав в `int`) -
14 |     значение станет одним из `0`, `1`, `2`, `3`, `4`, `5` с равной вероятностью.
15 | 3. Поскольку нас интересуют числа от `1` до `6` просто добавим `1` к полученному результату.
16 | 
17 | Итак, даны несколько вещественных значений в диапазоне `[0 .. 1)` (полученные как раз от генератора случайных чисел) -
18 | их нужно преобразовать в значения очков игрального кубика с помощью вышеописанного алгоритма.
19 | 
20 | **Входные данные** содержат в первой строке число значений, которые нужно преобразовать.  
21 | Остальные строки содержат по одному вещественному случайному числу каждая (в виде `0.142857` и т.п.)  
22 | **Ответ** должен содержать числа от `1` до `6` для каждого из входных тестов, через пробел.
23 | 
24 | Пример:
25 | 
26 |     входные данные:
27 |     6
28 |     0.59558786964
29 |     0.861037873663
30 |     0.385597702116
31 |     0.246237673331
32 |     0.808033385314
33 |     0.0544673665427
34 |     
35 |     ответ:
36 |     4 6 3 2 5 1
37 | 


--------------------------------------------------------------------------------
/de/task-48.md:
--------------------------------------------------------------------------------
 1 | <!-- #Collatz Sequence -->
 2 | Dies ist eines der rätselhaftesten mathematischen Probleme des letzten Jahrhunderts - sowohl, weil seine Aussage extrem einfach ist -
 3 | und weil der Beweis immer noch unbekannt ist. Wie auch immer, für Programmieranfänger bietet es eine sehr gute Übung.
 4 | 
 5 | **Angenommen** wir wählen einen Startwert `X` und bauen dann die Sequenz von Werten nach folgenden Regeln auf:
 6 | 
 7 |     wenn X gerade ist (d.h. X modulo 2 = 0) dann
 8 |         Xnext = X / 2
 9 |     ansonsten
10 |         Xnext = 3 * X + 1
11 | 
12 | D.h. wenn `X` ungerade ist, wächst die Folge - und wenn sie gerade ist, nimmt die Folge ab. Zum Beispiel, mit `X = 15` haben wir folgende Sequenz:
13 | 
14 |     15 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
15 | 	
16 | Nachdem die Fogle `1` erreicht hat, endet sie in der Schleife `1 4 2 1 4 2 1...`.
17 | 
18 | Der Clou liegt darin, dass jede beliebige Startzahl `X` die Sequenz erreicht, die früher oder später bei der `1` landet - allerdings
19 | konnte, obwohl die `Collatz Vermutung` bereits `1937` formuliert wurde, bis heute niemand einen Beweis dafür finden, dass dies wirklich
20 | für jede beliebige Startzahl `X` gilt, oder ein Gegenbeispiel finden(d.h. eine Zahl, deren Folge nicht mit `1` - sondern entweder in einer größeren Schleife endet oder unendlich groß wird).
21 | 
22 | **Ihre Aufgabe** ist es, für gegebene Zahlen zu berechnen, wieviele Schritte notwendig sind um zur `1` zu kommen.
23 | 
24 | Die **Eingabe Daten** enthalten in der ersten Zeile die Anzahl der Testfälle.  
25 | Die zweite Zeile enthält die Testfälle - d.h. die Werte, für die die Berechnungen durchgeführt werden sollen.  
26 | Die **Antwort** sollte die gleiche Anzahl an Ergebnissen enthalten, wobei jedes Ergebnis die Anzahl der Schritte ist, die benötigt werden um die Collatz Sequenz auf `1` zu bringen.
27 | 
28 | Als Beispiel:
29 | 
30 |     Eingabe Daten:
31 |     3
32 |     2 15 97
33 | 
34 |     Antwort:
35 |     1 17 118
36 | 


--------------------------------------------------------------------------------
/ru/task-11.md:
--------------------------------------------------------------------------------
 1 | <!-- #Сумма Цифр -->
 2 | Это упражнение поможет нам разобраться с системами счисления. Мы начнем с экспериментов над десятичной системой
 3 | счисления, с которой имеем дело каждый день (имейте в виду что хотя компьютер показывает нам десятичные числа,
 4 | сам он ею не пользуется - просто превращает числа в десятичные непосредственно перед выводом на экран).
 5 | 
 6 | Поскольку любое число больше `9` представляется несколькими цифрами, мы можем посчитать **сумму цифр**. Например
 7 | для чисел `1492` и `1776` мы получим:
 8 | 
 9 |     1 + 4 + 9 + 2 = 16
10 |     1 + 7 + 7 + 6 = 21
11 | 
12 | В этой задаче вам будут даны несколько значений для которых нужно посчитать сумму цифр.
13 | 
14 | **Важно:** хотя многие современные языки программирования имеют встроенные функции для преобразования чисел в строки
15 | (откуда можно извлечь отдельные цифры), вам желательно не использовать этот читерский подход (если конечно вы заинтересованы
16 | в изучении программирования, а не "сдать задачку побыстрее").
17 | 
18 | **Вместо этого** вам следует реализовать алгоритм который в цикле делит число на `10` и суммирует получаемые остатки
19 | (это и будут цифры, появляющиеся как бы задом-наперед). Описание алгоритма есть в статье [Number to digits](../wiki/number-to-digits).
20 | 
21 | ###Задание
22 | 
23 | **Входные данные** имеют такой формат:
24 | 
25 | - первая строка содержит число `N` - количество тестов которые нужно обработать;
26 | - следующие `N` строк содержат по три целых числа `A B C`, составляющих один тест;
27 | - для каждого теста нужно умножить `A` на `B` и добавить `C` (т.е. `A * B + C`) - после чего сосчитать сумму цифр результата.
28 | 
29 | **Ответ** должен содержать `N` результатов, разделенных пробелами.
30 | 
31 | Пример:
32 | 
33 |     входные данные:
34 |     3
35 |     11 9 1
36 |     14 90 232
37 |     111 15 111
38 |     
39 |     ответ:
40 |     1 16 21
41 | 
42 | Здесь, например, первый тест даёт значение `11*9+1 = 100`, поэтому сумма цифр равна `1+0+0 = 1`.
43 | 


--------------------------------------------------------------------------------
/ru/task-52.md:
--------------------------------------------------------------------------------
 1 | <!-- #Теорема Пифагора -->
 2 | <div class="text-center">
 3 | 	<img alt="прямоугольный, остроугольный и тупоугольный треугольники" src="https://codeabbey.github.io/data/pythagorean-theoreme.png"/>
 4 | </div>
 5 | 
 6 | Треугольник называется **прямоугольным** если один из его углов **прямой**, равный 90° - т.е. прилежащие
 7 | ему стороны перпендикулярны.
 8 | 
 9 | Такие треугольники важны поскольку для них действует **Теорема Пифагора**. Давайте, вспомним её.
10 | 
11 | Стороны, прилежащие прямому углу в таком треугольнике, называются **катетами**, а третья сторона - **гипотенузой**.
12 | Теорема утверждает, что длина гипотенузы определяется по длине катетов в соответствии с простой формулой:
13 | 
14 |     c^2 = a^2 + b^2
15 |     
16 |         или
17 |     
18 |     c = sqrt(a^2 + b^2)
19 | 
20 | Где `c` - длина гипотенузы, а длины катетов - `a` и `b`.
21 | 
22 | Известный пример прямоугольного треугольника - со сторонами находящимися в соотношении `3`, `4` и `5`.
23 | Действительно, для них теорема выполняется:
24 | 
25 |     5^2 = 3^2 + 4^2
26 | 	
27 | 	    или
28 | 	
29 | 	25 = 9 + 16
30 | 
31 | В этой задаче мы напишем программу, которая использует теорему Пифагора, чтобы определить является ли треугольник
32 | прямоугольным (right), или он **остроугольный** (acute), или **тупоугольный** (obtuse):
33 | 
34 | - в остроугольном самая длинная из сторон короче, чем должна была бы быть гипотенуза;
35 | - в тупоугольном - наоборот длиннее.
36 | 
37 | **Входные данные** указывают количество тестовых треугольников в первой строке.  
38 | Остальные строки описывают по одному треугольнику каждая. Описание содержит три значения - длины сторон. Для
39 | простоты самая длинная всегда будет последней.  
40 | **Ответы** должны содержать одну из букв `R` (right), `A` (acute) или `O` (obtuse) для каждого из треугольников,
41 | через пробел.
42 | 
43 | Пример:
44 | 
45 |     входные данные:
46 |     3
47 |     6 8 9
48 |     9 12 15
49 |     16 12 22
50 |     
51 |     ответ:
52 |     A R O
53 | 


--------------------------------------------------------------------------------
/ua/task-51.md:
--------------------------------------------------------------------------------
 1 | <!-- #Dungeons & Dragons Dice -->
 2 | 
 3 | В складних іграх на базі випадково згенерованих чисел гравці можуть використовувати кілька гральних кубиків (костей) із числом граней 
 4 | більшою за `6`. Для прикладу, ступінь поранення від магічного меча можна визначити як суму `3` кубиків з `8`-ма гранями на кожному 
 5 | (такими, що містять числа від `1` до `8`). Це означає, що найменша шкода є `3` і найбільша ― `24`, однак з більшою імовірністю 
 6 | випаде `13` чи `14`.
 7 | 
 8 | Позначки в описі до таких ігор мають вигляд `3d8`, тобто `3` кості з `8`-ма гранями або `2d6` для більш звичного варіанту 
 9 | `2` костей з `6`-ма гранями. Підкидання `5` монет з двома гранями `2` буде записано як `5d2`.
10 | 
11 | У даній задачі ви отримаєте результати багаторазового випадання певної кількості кубиків. Вам належить визначити, скільки кубиків в
12 | комплекті та скільки граней вони мають. Правдоподібно, що знадобиться програма для підрахунку статистики результатів
13 | для підведення підсумків.
14 | 
15 | *Внаслідок ймовірнісної природи задачі на першій спробі вас може спіткати невдача, однак спробуйте кілька разів: якщо ваш алгоритм 
16 | достовірний, відповідь буде зараховано.*
17 | 
18 | У даній задачі кості можуть мати `2`, `4`, `6`, `8`, `10` чи `12` граней. Кількість кубиків коливається від `1` до `5`.
19 | 
20 | **Вхідні дані** містять `303` значення у `3` рядках.  
21 | Кожен рядок містить `100` ненульових результатів випадання (суми очок кубиків), який завершується вільним `0`, котрий враховувати 
22 | не потрібно (позначає кінець рядка).  
23 | **Відповідь** повинна містити три позначки наборів костей для кожного з трьох рядків у вигляді `xdy`, де `x` та `y` є
24 | числами костей та граней відповідно.
25 | 
26 | Приклад: (показано не повністю через надмірну довжину даних)
27 | 
28 |     вхідні дані:
29 |     8 11 23 4 12 15 13 3 ... 7 14 5 13 0
30 |     7 6 3 5 8 7 10 11 3 7 ... 6 9 7 2 0
31 |     7 6 5 6 7 9 8 7 8 8 10 ... 8 10 8 7 0
32 |     
33 |     відповідь:
34 |     3d8 2d6 5d2
35 | 


--------------------------------------------------------------------------------
/ru/task-44.md:
--------------------------------------------------------------------------------
 1 | <!-- #Бросок Двух Игральных Костей -->
 2 | После решения задачи [Dice Rolling](./dice-rolling--ru), мы знаем как преобразовать дробное значение от `0.0` до `1.0`
 3 | в целое, принадлежащее заданному диапазону - например к значениям между `1` и `6`, чтобы сымитировать бросок игрального кубика.
 4 | 
 5 | Однако многие языки программирования (в том числе **C/C++**, **PHP**, **Pascal**) имеют генератор случайных чисел,
 6 | который наоборот возвращает целое число в диапазоне от `0` до некоторого (обычно большого) максимума.
 7 | Как преобразовать такие числа в значения очков на грани кубика?
 8 | 
 9 | Оказывается, такой случай даже проще. Применим следующий подход:
10 | 
11 | 1. Разделим случайное значение `R` на `N` (количество разных значений которые мы хотим получать - т.е. `6` для кубика)
12 |     и возьмем остаток. Он будет в диапазоне от `0` до `N - 1`.
13 | 2. Теперь сдвинем этот диапазон к требуемому, просто добавив `1` (т.е. нижнюю границу нужного нам диапазона) - и получим
14 |     значение от `1` to `N`.
15 | 
16 | Этот метод не очень точен если `N` недостаточно мало в сравнении с `max` генератора (наибольшим возможным случайным числом).
17 | Однако в большинстве типовых случаев (бросание монетки, кубика, раздача игральных карт) он вполне подходит.
18 | 
19 | Для практики попробуем следующее упражнение:
20 | 
21 | **Входные данные** содержат количество тест-кейсов (бросков пары игральных костей) в первой строке.  
22 | Остальные строки содержат сами тест-кейсы - в каждом по два случайных целых числа (между `0` и примерно `2,000,000,000`) -
23 | превратим их в очки выброшенные на двух виртуальных кубиках и сложим.  
24 | **Ответ** должен содержать сумму броска пары кубиков для каждого случая, через пробел.
25 | 
26 | Пример:
27 | 
28 | 	входные данные:
29 | 	7
30 | 	193170145 1912748246
31 | 	753156389 614113621
32 | 	1824520917 53700559
33 | 	1288077384 911939603
34 | 	1939066598 1695763253
35 | 	1905581606 1811712139
36 | 	878644967 1090885451
37 | 	
38 | 	
39 | 	ответ:
40 | 	5 8 6 7 9 5 12
41 | 


--------------------------------------------------------------------------------
/ua/task-40.md:
--------------------------------------------------------------------------------
 1 | <!-- #Paths in the Grid -->
 2 | Динамічне програмування є інструментом для вирішення задач, що набули популярності серед азартних програмістів та авторів коду 
 3 | на сайтах типу [TopCoder](http://topcoder.com/tc). Потрібно освоїти підрахунок маршрутів у прямокутній сітці (до прикладу, 
 4 | це може бути квартал міста).
 5 | 
 6 | Уявіть карту болотистої місцевості, що представлена прямокутною сіткою:
 7 | 
 8 |     @ + + + +
 9 |     + + + X X
10 |     + X + + +
11 |     + + + X +
12 |     + X + + X
13 |     + + + + $
14 | 
15 | де `X` зображає яму (непрохідну клітинку, де людина гарантовано потоне), натомість клітинки `+` безпечні для проходу.
16 | 
17 | **Герой** повинен пройти від верхнього лівого кута (з позначкою `@`) до нижнього правого (позначений `$`). 
18 | Пересуватись він може лише безпечними клітинками, причому з кожної з них він вправі переходити на наступну або 
19 | **праворуч** або **вниз** (згідно карти). Зворотній рух (ліворуч і догори) заборонений: у нашого героя обмежена 
20 | кількість їди в торбинці.
21 | 
22 | Потрібно дізнатися, скільки **різних** маршрутів можна прокласти від одного кута до іншого, згідно поданих правил.
23 | 
24 | **Вхідні дані** у першому рядку містять число рядів та стовпців нашої сітки: `M` та `N`.
25 | Відтак поле сітки складається з `M` рядків, кожен з яких містить `N` символів, розділених пробілом.
26 | Непрохідні клітинки позначені символом `X`.  
27 | **Відповідь** повинна містити єдине число - кількість можливих маршрутів.
28 | 
29 | Результат гарантовано не повинен перевищити `2,000,000,000`.
30 | Однак можливим є варіант, що маршрутів нема взагалі.
31 | 
32 | Приклад:
33 | 
34 |     вхідні дані:
35 |     6 5
36 |     @ + + + +
37 |     + + + X X
38 |     + X + + +
39 |     + + + X +
40 |     + X + + X
41 |     + + + + $
42 |     
43 |     відповідь:
44 |     9
45 | 
46 | На сайті **ProjectEuler** є версія аналогічної загадки без перешкод:
47 | [Lattice Paths](http://projecteuler.net/problem=15) - радимо насамперед обдумати її, якщо на думку не спадає жодних рішень.
48 | 


--------------------------------------------------------------------------------
/sk/task-11.md:
--------------------------------------------------------------------------------
 1 | <!-- #Sum of digits -->
 2 | Toto cvičenie je určené na úvod základov číselného(decimálneho) systému. Začneme sa učit
 3 | tento koncept hraním sa s decimálnym systémom, ktorý používame každý deň (aj keď by ste mali mať na pamäti, že počítač
 4 | tento systém nepoužíva, používa binárny systém, - a decimálne čísla konvertuje v momente keď majú byť zobrazené užívateľovi).
 5 | 
 6 | Každé číslo väčšie ako 9 je reprezentované niekoľkými číslicami, takže môžme spraviť súčet týchto čísel. Napríklad,
 7 | pre čísla `1492` a `1776` dostaneme:
 8 | 
 9 |     1 + 4 + 9 + 2 = 16
10 | 	1 + 7 + 7 + 6 = 21
11 | 
12 | V tejto úlohe dostanete niekoľko čísel a vašou úlohou je vypočítať súčet ich jednotlivých číslic.  
13 | 
14 | **Dôležité:** zatiaľ čo mnohé programovacie jazyky majú vstavané funkcie na konverziu čísel na reťazece
15 | (z ktorých môžu byť čísla extrahované), nemali by ste ich používať (pretože vašim cieľom je naučiť sa nejaké tie programátorske triky).
16 | 
17 | **Namiesto toho** potrebujete implementovať algoritmus s opakovaným delením 10 (základ číselneho systému) 
18 | a sčítavaním zvyškov. Prečítajte si článok [číslo na číslice][numtodig] pre detaily algoritmu.
19 | 
20 | [numtodig]: ../wiki/number-to-digits
21 | 
22 | ###Problémový výrok
23 | 
24 | **Vstupné dáta** sú v nasledujúcom formáte:
25 | 
26 | - prvý riadok obsahuje `N` - počet hodnôt na spracovanie;
27 | - a potom nasleduje `N` riadkov popisujúce hodnoty, pre ktoré by mal byť vypočítaný súčet číslic  `3` celými číslami `A B C`;
28 | - pre každý príklad potrebujete vynásobiť `A`čko s `B`čkom a pripočítať `C`éčko (t.j. `A * B + C`) - a potom vypočítať súčet čísel výsledku.
29 | 
30 | **Odpoveď** by mala mať `N` výsledkov, taktiež oddelená medzerami. Napríklad:
31 | 
32 |     vstupné dáta:
33 | 	3
34 | 	11 9 1
35 | 	14 90 232
36 | 	111 15 111
37 | 	
38 | 	odpoveď:
39 | 	1 16 21
40 | 
41 | V prvom príklaďe je potrebné vypočítať `11*9+1 = 100` a súčet jeho číslic je `1+0+0 = 1`.
42 | 
43 | _translated by [Radovan Markus](https://www.codeabbey.com/index/user_profile/rajkoisawesome)_
44 | 


--------------------------------------------------------------------------------
/es/task-11.md:
--------------------------------------------------------------------------------
 1 | Este ejercicio de programación tiene como propósito darte una introducción a los aspectos básicos de un sistema de numeración. Comencemos a aprender
 2 | este concepto experimentando con el sistema decimal que usamos cotidianamente (aunque deberías tener presente que el computador no lo
 3 | usa internamente - sólo convierte números a él cuando tiene que mostrarlos al usuario).
 4 | 
 5 | Como cualquier número mayor a 9 es representado por varios dígitos, podemos calcular la suma de estos dígitos. Por ejemplo,
 6 | para los números `1492` y `1776` tenemos:
 7 | 
 8 |     1 + 4 + 9 + 2 = 16
 9 |     1 + 7 + 7 + 6 = 21
10 | 
11 | En esta tarea se te darán varios números y se te pedirá que calcules las sumas de sus dígitos.  
12 | 
13 | **Importante:** Aunque muchos lenguajes de programación tienen funciones incorporadas para convertir números a cadenas
14 | (desde las cuales los dígitos pueden ser obtenidos), no deberías usarlas (ya que tu objetivo es aprender algunos trucos de programación).
15 | 
16 | **En su lugar**, debes implementar un algoritmo con división repetitiva entre 10 (la base del sistema numérico) y sumar sus
17 | residuos. Lee el artículo [Number to digits][numtodig] para más detalles sobre el algoritmo.
18 | 
19 | [numtodig]: ../wiki/number-to-digits
20 | 
21 | ###Enunciado del problema
22 | 
23 | Los **Datos de entrada** están en el siguiente formato:
24 | 
25 | - la primera línea contiene `N` - el número de valores a procesar;
26 | - y después siguen `N` líneas que describen los valores para los cuales la suma de dígitos debe ser calculada mediante `3` enteros `A B C`;
27 | - para cada caso, necesitarás multiplicar `A` por `B` y sumar `C` (ej.: `A * B + C`) - luego calcular la suma de dígitos del resultado.
28 | 
29 | La **Respuesta** debería constar de `N` resultados, separados también por espacios. Por ejemplo:
30 | 
31 |     datos de entrada:
32 |     3
33 |     11 9 1
34 |     14 90 232
35 |     111 15 111
36 |     
37 |     respuesta:
38 |     1 16 21
39 | 
40 | Aquí el primer caso requiere calcular `11*9+1 = 100` y la suma de sus dígitos es `1+0+0 = 1`.
41 | 


--------------------------------------------------------------------------------