remove replit links

modules/10-basics/10-hello-world/description.es.yml

@@ -18,8 +18,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-hello-world
-
   El texto *¡Hola, Mundo!* aparecerá en la pantalla gracias al comando `System.out.println()`, donde `println()` es una abreviatura de la expresión en inglés *print line*. Este comando muestra en la pantalla el valor especificado entre paréntesis `("¡Hola, Mundo!")`, en este caso, una cadena de texto. La cadena de texto se encierra entre comillas dobles `""`. Si no se hace esto, el compilador mostrará un error de sintaxis:
 
   ```bash

modules/10-basics/10-hello-world/es/README.md

@@ -14,8 +14,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-hello-world
-
 El texto *¡Hola, Mundo!* aparecerá en la pantalla gracias al comando `System.out.println()`, donde `println()` es una abreviatura de la expresión en inglés *print line*. Este comando muestra en la pantalla el valor especificado entre paréntesis `("¡Hola, Mundo!")`, en este caso, una cadena de texto. La cadena de texto se encierra entre comillas dobles `""`. Si no se hace esto, el compilador mostrará un error de sintaxis:
 
 ```bash

modules/10-basics/10-hello-world/ru/README.md

@@ -14,8 +14,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-hello-world
-
 Текст *Hello, World!* появится на экране благодаря команде `System.out.println()`, где `println()` — это сокращение от английского *print line*. Она выводит на экран значение, указанное в скобках `("Hello, World!")` — в данном случае строку. Сама строка обрамляется двойными кавычками `""`. Если этого не сделать, то компилятор укажет на синтаксическую ошибку:
 
 ```bash

modules/20-arithmetics/50-priority/description.es.yml

@@ -39,8 +39,6 @@ theory: |
 
   Recuerda: el código se escribe para las personas, porque las personas lo leerán, y las máquinas solo lo ejecutarán. Para las máquinas, no hay código "más" o "menos" comprensible, independientemente de si el código es correcto o no.
 
-  https://replit.com/@hexlet/java-basics-arithmetics
-
 instructions: |
 
   Dada la expresión `70 * 3 + 4 / 8 + 2`.

modules/20-arithmetics/50-priority/en/README.md

@@ -30,5 +30,3 @@ System.out.println(((8 / 2) + 5) - (-3 / 2)); // => 11
 ```
 
 Remember: code is for people, because it'll be read by people, and machines will only execute it. The only thing that matters for the machines is the correctness of code. They don't distinguish between "clear" or "confusing".
-
-https://replit.com/@hexlet/java-basics-arithmetics

modules/20-arithmetics/50-priority/es/README.md

@@ -34,5 +34,3 @@ System.out.println(((8 / 2) + 5) - (-4 / 2)); // => 11
 ```
 
 Recuerda: el código se escribe para las personas, porque las personas lo leerán, y las máquinas solo lo ejecutarán. Para las máquinas, no hay código "más" o "menos" comprensible, independientemente de si el código es correcto o no.
-
-https://replit.com/@hexlet/java-basics-arithmetics

modules/20-arithmetics/50-priority/ru/README.md

@@ -34,5 +34,3 @@ System.out.println(((8 / 2) + 5) - (-4 / 2)); // => 11
 ```
 
 Запомните: код пишется для людей, потому что код будут читать люди, а машины будут только исполнять его. Для машин нет «более» понятного или «менее» понятного кода, независимо от того, является ли код корректным или нет.
-
-https://replit.com/@hexlet/java-basics-arithmetics

modules/25-strings/20-strings-concatenation/description.es.yml

@@ -41,8 +41,6 @@ theory: |
   System.out.println("King's  " + "  Landing"); // => King's    Landing
   ```
 
-  https://replit.com/@hexlet/java-basics-strings#Main.java
-
 instructions: |
 
   Utilizando `System.out.println()`, realiza la concatenación de palabras y muestra en la pantalla la siguiente frase:

modules/25-strings/20-strings-concatenation/en/README.md

@@ -46,5 +46,3 @@ System.out.print("King's " + " Landing");   // => King's  Landing
 
 System.out.print("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings

modules/25-strings/20-strings-concatenation/es/README.md

@@ -36,5 +36,3 @@ Un espacio es simplemente un símbolo más, al igual que los demás. Cuantos má
 System.out.println("King's " + " Landing");   // => King's  Landing
 System.out.println("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings#Main.java

modules/25-strings/20-strings-concatenation/ru/README.md

@@ -36,5 +36,3 @@ System.out.println("King's" + " " + "Landing"); //  => King's Landing
 System.out.println("King's " + " Landing");   // => King's  Landing
 System.out.println("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings#Main.java

modules/30-variables/10-definition/description.es.yml

@@ -47,8 +47,6 @@ theory: |
   ¡Madre!
   </pre>
 
-  https://replit.com/@hexlet/java-basics-variables-1
-
   Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.
 
 instructions: |

modules/30-variables/10-definition/en/README.md

@@ -23,8 +23,6 @@ When the variable is created, you can start using it. It is substituted in those
   Father!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 For the name of the variable, any set of valid characters is used, which include letters of the English alphabet, numbers and the underscore character `_`. In this case, the number can not be put at the beginning. Variable names are case-sensitive, that is, the name `hello` and the name `heLLo` are two different names, and therefore two variables.
 
 The number of variables created is not limited in any way; large programs contain tens and hundreds of thousands of variable names:

modules/30-variables/10-definition/es/README.md

@@ -42,6 +42,4 @@ System.out.println(greeting2);
 ¡Madre!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.

modules/30-variables/10-definition/ru/README.md

@@ -42,6 +42,4 @@ Mother!
 Mother!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 Для удобства анализа программы переменные принято создавать как можно ближе к тому месту, где они используются.

modules/30-variables/12-change/description.es.yml

@@ -15,8 +15,6 @@ theory: |
   System.out.println(saludo);
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-2
-
   Java es un lenguaje de programación de tipado estático. Esto significa que el tipo de una variable se establece al definirla y no cambia después.
 
   En el ejemplo anterior, asignamos una cadena de texto al crear la variable. El compilador recuerda el tipo y verifica todos los cambios posteriores en la variable. Si intentamos asignar un número a esta misma variable, obtendremos el siguiente error:

modules/30-variables/12-change/en/README.md

@@ -11,8 +11,6 @@ System.out.print(greeting);
 System.out.print(greeting);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 The name remains the same, but inside the other data. It should be noted that when changing variables, the type of data contained in them cannot change (this is not quite the case for object-oriented programming, but for the time being we will not go into details). If a variable was assigned a string, then when compiling this assignment — even before the program was started — java associates the data type “string” with this variable, and knows that there will always be only strings, and will not let it put something else in it.
 
 Variables are powerful, and at the same time dangerous thing. One can never be exactly sure what is written inside it without analyzing the code that is in front of the variable. This is exactly what the developers are doing during debugging, when they are trying to figure out why the program is not working or is not working as intended.

modules/30-variables/12-change/es/README.md

@@ -10,8 +10,6 @@ System.out.println(saludo);
 System.out.println(saludo);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 Java es un lenguaje de programación de tipado estático. Esto significa que el tipo de una variable se establece al definirla y no cambia después.
 
 En el ejemplo anterior, asignamos una cadena de texto al crear la variable. El compilador recuerda el tipo y verifica todos los cambios posteriores en la variable. Si intentamos asignar un número a esta misma variable, obtendremos el siguiente error:

modules/30-variables/12-change/ru/README.md

@@ -10,8 +10,6 @@ System.out.println(greeting);
 System.out.println(greeting);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 Java — статически типизированный язык. Это значит, что тип переменной задается при определении и больше не меняется.
 
 В примере выше мы присвоили строку при создании переменной. Компилятор запоминает тип и проверяет все последующие изменения переменной. Если попробовать этой же переменной присвоить число, то мы получим следующую ошибку:

modules/30-variables/15-variable-expressions/description.es.yml

@@ -57,8 +57,6 @@ theory: |
   // => El precio es 3750 rublos
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-3
-
   Cualquier variable puede formar parte de cualquier expresión. En el momento de la evaluación, el valor de la variable se sustituye en lugar de su nombre. El valor de `amountDollars` se calcula antes de que se utilice en otras expresiones. Cuando llega el momento de usar la variable, Java conoce su valor porque ya lo ha calculado.
 
 instructions: |

modules/30-variables/15-variable-expressions/en/README.md

@@ -46,8 +46,6 @@ var rublesCount = dollarsCount * rublesPerDollar; // => 3750
 System.out.print("The price is" + rublesCount + "rubles");
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 The price is 3750 rubles
 
 Any variable can be part of any expression. At the time of calculation, the value of the variable is substituted for its value.

modules/30-variables/15-variable-expressions/es/README.md

@@ -52,6 +52,4 @@ System.out.println("El precio es " + amountRubles + " rublos");
 // => El precio es 3750 rublos
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 Cualquier variable puede formar parte de cualquier expresión. En el momento de la evaluación, el valor de la variable se sustituye en lugar de su nombre. El valor de `amountDollars` se calcula antes de que se utilice en otras expresiones. Cuando llega el momento de usar la variable, Java conoce su valor porque ya lo ha calculado.

modules/30-variables/15-variable-expressions/ru/README.md

@@ -52,6 +52,4 @@ System.out.println("The price is " + rublesCount + " rubles");
 // => The price is 3750 rubles
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 Любая переменная может быть частью любого выражения. В момент вычисления вместо имени переменной подставляется ее значение. Значение `dollarsCount` вычисляется до того, как она начнет использоваться в других выражениях. Когда подходит момент использования переменной, Java знает значение, потому что уже вычислил его.

modules/30-variables/18-variables-concatenation/description.es.yml

@@ -27,8 +27,6 @@ theory: |
   System.out.println(que); // => CaminodeReyes
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-4
-
 instructions: |
 
   Los sitios web constantemente envían correos electrónicos a sus usuarios. Una tarea típica es enviar automáticamente un correo electrónico personalizado, donde el nombre de usuario estará en el asunto. Si el nombre del usuario se almacena en algún lugar de la base de datos del sitio web como una cadena, la tarea de generar el asunto se reduce a la concatenación: por ejemplo, debes concatenar la cadena Hola con la cadena que contiene el nombre.

modules/30-variables/18-variables-concatenation/en/README.md

@@ -27,5 +27,3 @@ var last = "road";
 var what = first + last;
 System.out.print(what); // => "Kingsroad"
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4

modules/30-variables/18-variables-concatenation/es/README.md

@@ -21,5 +21,3 @@ var ultimo = "de Reyes";
 var que = primero + ultimo;
 System.out.println(que); // => CaminodeReyes
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4

modules/30-variables/18-variables-concatenation/ru/README.md

@@ -21,5 +21,3 @@ var last = "road";
 var what = first + last;
 System.out.println(what); //=> Kingsroad
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4

modules/30-variables/23-constants/description.es.yml

@@ -12,8 +12,6 @@ theory: |
   System.out.println(pi); // 3.14
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-5
-
   A diferencia de las variables, al definir una constante se utiliza la palabra clave `final`. Esto le indica al compilador que no se puede modificar. Cualquier intento de cambiar una constante resultará en un error.
 
   Una constante, al igual que una variable, puede ser utilizada en cualquier expresión. La única restricción es que no se puede modificar una constante, lo cual tiene bastante sentido.

modules/30-variables/23-constants/en/README.md

@@ -8,6 +8,4 @@ final var pi = 3.14;
 System.out.print(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 A constant, like a variable, can be used in any expression. The only restriction is that the constant cannot be changed, which sounds quite logical.

modules/30-variables/23-constants/es/README.md

@@ -7,8 +7,6 @@ final var pi = 3.14;
 System.out.println(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 A diferencia de las variables, al definir una constante se utiliza la palabra clave `final`. Esto le indica al compilador que no se puede modificar. Cualquier intento de cambiar una constante resultará en un error.
 
 Una constante, al igual que una variable, puede ser utilizada en cualquier expresión. La única restricción es que no se puede modificar una constante, lo cual tiene bastante sentido.

modules/30-variables/23-constants/ru/README.md

@@ -7,8 +7,6 @@ final var pi = 3.14;
 System.out.println(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 В отличие от переменных, в начале определения константы используют ключевое слово `final`. Оно сообщает компилятору запрет на изменение. Любая попытка поменять константу приведет к ошибке.
 
 Константа, как и переменная, может использоваться в любом выражении. Единственное ограничение — константу нельзя изменить, что звучит довольно логично.

modules/33-data-types/55-type-casting/description.es.yml

@@ -28,8 +28,6 @@ theory: |
   System.out.println(result); // => 15
   ```
 
-  https://replit.com/@hexlet/java-basics-data-types
-
 instructions: |
 
   Imprime en la pantalla la cadena de texto `2 times`, obtenida a partir del número 2.9 y la cadena de texto `times`, utilizando conversiones de tipos y concatenación.

modules/33-data-types/55-type-casting/en/README.md

@@ -17,5 +17,3 @@ System.out.print("It's" + ((int) 5.1));
 It's 5
 
 In case above, in spite of the fact, that 5.1 is the number, it has double type not int. Expression above bring this number type to int type, reject fraction part, because int type doesn't keep fraction part.
-
-https://replit.com/@hexlet/java-basics-data-types

modules/33-data-types/55-type-casting/es/README.md

@@ -22,5 +22,3 @@ La conversión de tipos se puede utilizar dentro de expresiones compuestas:
 var result = 10 + ((int) 5.1);
 System.out.println(result); // => 15
 ```
-
-https://replit.com/@hexlet/java-basics-data-types

modules/33-data-types/55-type-casting/ru/README.md

@@ -22,5 +22,3 @@ System.out.println(result); // => 5
 var result = 10 + ((int) 5.1);
 System.out.println(result); // => 15
 ```
-
-https://replit.com/@hexlet/java-basics-data-types

modules/35-methods-using/100-methods/description.es.yml

@@ -36,8 +36,6 @@ theory: |
   company.toUpperCase(); // "HEXLET"
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-calling
-
   Lo más importante en el trabajo con métodos es comprender el concepto de retorno de valor. Los métodos casi nunca muestran datos en la pantalla, sino que los devuelven. Gracias a esta propiedad, podemos dividir nuestro programa en fragmentos que luego se combinan en algo más complejo.
 
   En los ejemplos anteriores, el resultado de llamar a cada método se guarda en variables. Pero esto no es obligatorio, podemos usar los métodos directamente:

modules/35-methods-using/100-methods/es/README.md

@@ -31,8 +31,6 @@ System.out.println(companyLength); // => 6
 company.toUpperCase(); // "HEXLET"
 ```
 
-https://replit.com/@hexlet/java-basics-methods-calling
-
 Lo más importante en el trabajo con métodos es comprender el concepto de retorno de valor. Los métodos casi nunca muestran datos en la pantalla, sino que los devuelven. Gracias a esta propiedad, podemos dividir nuestro programa en fragmentos que luego se combinan en algo más complejo.
 
 En los ejemplos anteriores, el resultado de llamar a cada método se guarda en variables. Pero esto no es obligatorio, podemos usar los métodos directamente:

modules/35-methods-using/100-methods/ru/README.md

@@ -31,8 +31,6 @@ System.out.println(companyLength); // => 6
 company.toUpperCase(); // "HEXLET"
 ```
 
-https://replit.com/@hexlet/java-basics-methods-calling
-
 Основное в работе с методами – понять принцип возврата значения. Методы почти никогда не выводят данные на экран, они их возвращают. Благодаря этому свойству, мы можем разбить нашу программу на кусочки, из которых потом составляется что-то сложное.
 
 В примерах выше результат вызова каждого метода записывается в переменные. Но это не обязательно, мы можем использовать методы напрямую:

modules/35-methods-using/105-methods-parameters/description.es.yml

@@ -51,8 +51,6 @@ theory: |
   "hexlet".substring(3, 6); // "let"
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-calling-1
-
 instructions: |
 
   Se te han dado tres variables con los apellidos de diferentes personas. Construye y muestra en la pantalla una palabra con los caracteres en el siguiente orden:

modules/35-methods-using/105-methods-parameters/es/README.md

@@ -45,5 +45,3 @@ Por defecto, se toma la cadena hasta el final:
 "hexlet".substring(1, 3); // "ex"
 "hexlet".substring(3, 6); // "let"
 ```
-
-https://replit.com/@hexlet/java-basics-methods-calling-1

modules/35-methods-using/105-methods-parameters/ru/README.md

@@ -45,5 +45,3 @@ searchEngine.replace("go", "mo"); // "moogle"
 "hexlet".substring(1, 3); // "ex"
 "hexlet".substring(3, 6); // "let"
 ```
-
-https://replit.com/@hexlet/java-basics-methods-calling-1

modules/35-methods-using/115-string-immutability/ru/README.md

@@ -30,6 +30,4 @@ var processedLanguage = language.toLowerCase();
 System.out.println(processedLanguage); // => java
 ```
 
-https://replit.com/@hexlet/java-basics-methods-as-expressions
-
 Такой подход нередко предпочтительнее по соображениям читаемости. Переменные, которые постоянно меняются, сложнее анализировать. В итоге все зависит от задачи. С опытом придет понимание, какой подход лучше.

modules/35-methods-using/120-methods-chain/description.es.yml

@@ -56,8 +56,6 @@ theory: |
       .toLowerCase();
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-chain
-
   A pesar de la conveniencia de este mecanismo, no se debe abusar de él. Las variables intermedias pueden facilitar la comprensión del código.
 
 instructions: |

modules/35-methods-using/120-methods-chain/es/README.md

@@ -51,6 +51,4 @@ name = name.trim()
     .toLowerCase();
 ```
 
-https://replit.com/@hexlet/java-basics-methods-chain
-
 A pesar de la conveniencia de este mecanismo, no se debe abusar de él. Las variables intermedias pueden facilitar la comprensión del código.

modules/35-methods-using/120-methods-chain/ru/README.md

@@ -51,6 +51,4 @@ name = name.trim()
     .toLowerCase();
 ```
 
-https://replit.com/@hexlet/java-basics-methods-chain
-
 Несмотря на удобство этого механизма, им не стоит злоупотреблять. Промежуточные переменные могут упростить понимание кода.

modules/35-methods-using/200-methods-deterministic/description.es.yml

@@ -18,8 +18,6 @@ theory: |
   Math.random(); // 0.8839904367241888
   ```
 
-  https://replit.com/@hexlet/java-basics-pure-functions
-
   ¿Por qué es importante saber esto? El determinismo afecta seriamente muchos aspectos. Las funciones deterministas son convenientes para trabajar, son fáciles de optimizar y de probar. Si es posible hacer que una función sea determinista, es mejor hacerlo así.
 
 instructions: |

modules/35-methods-using/200-methods-deterministic/es/README.md

@@ -13,6 +13,4 @@ Math.random(); // 0.09856613113197676
 Math.random(); // 0.8839904367241888
 ```
 
-https://replit.com/@hexlet/java-basics-pure-functions
-
 ¿Por qué es importante saber esto? El determinismo afecta seriamente muchos aspectos. Las funciones deterministas son convenientes para trabajar, son fáciles de optimizar y de probar. Si es posible hacer que una función sea determinista, es mejor hacerlo así.