[Sortie console](sortie #Console)
[Déclaration de variable](#Déclaration de variable)
[Branche conditionnelle](# Branche conditionnelle)
[Traitement répété](# Traitement itératif)
C#
//Le système est facultatif
System.Console.Write("Hello ");
Console.Write("World");
>>> Hello World
Console.WriteLine("Hello ");
Console.WriteLine("Workd");
>>> Hello
World
Java
System.out.print("Hello ");
System.out.print("World");
>>> Hello World
System.out.println("Hello ");
System.out.println("World");
>>> Hello
World
Python
print("Hello")
print("World")
>>> Hello
World
print("Hello ", end="")
print("World")
>>> Hello World
Ruby
print 'Hello '
print 'World'
>>> Hello World
puts 'Hello'
puts 'World'
>>> Hello
World
Kotlin
print("Hello ");
print("World");
>>> Hello World
println("Hello ");
println("Workd");
>>> Hello
World
C#
String stra = "a";
string strb = "b";
int num = 1;
Boolean tr = true;
bool fa = false;
Java
String str = "a";
int num = 1
boolean bool = true
Python
Aucune déclaration de type requise
str = "a" #String
num = 1 #int
tr = True #Boolean
Ruby
Aucune déclaration de type requise
Le type booléen n'existe pas
str = "a" #String
num = 1 #int
Kotlin
val str = "a" //String
//Les variables déclarées avec val ne peuvent pas être modifiées
var num = 1 //int
//Les variables déclarées avec var peuvent être modifiées
num = 2
var tr = True //Boolean
C#
///if
if(Condition A){
Processus A
}
else if(Condition B){
Processus B
}
else{
//Si les conditions ci-dessus ne sont pas remplies
Processus C
}
//switch
switch (variable){
cas Condition A:
Processus A
break;
cas Condition B:
Processus B
break;
default:
//Si les conditions ci-dessus ne sont pas remplies
Processus C
break;
}
Java
//if
if(Condition A){
Processus A
}
else if(Condition B){
Processus B
}
else{
//Si les conditions ci-dessus ne sont pas remplies
Processus C
}
//switch
switch (variable){
cas Condition A:
Processus A
break;
cas Condition B:
Processus B
break;
default:
//Si les conditions ci-dessus ne sont pas remplies
Processus C
break;
}
Python
si condition A:
Processus A
condition elif B:
Processus B
else:
Processus C
#if
si la condition A alors
Processus A
elsif condition B alors
Processus B
else then
//Si les conditions ci-dessus ne sont pas remplies
Processus C
end
#case
variable de cas
quand la condition A alors
Processus A
lorsque la condition B alors
Processus B
else
//Si les conditions ci-dessus ne sont pas remplies
Processus C
end
Kotlin
//if
if(Condition A){
Processus A
}
else if(Condition B){
Processus B
}
else{
//Si les conditions ci-dessus ne sont pas remplies
Processus C
}
//when
when (variable) {
Condition A-> {
Processus A
}
Condition B-> {
Processus B
}
else -> {
Processus C
}
//quand peut être jugé en entrant directement une expression telle que la variable == condition.
when {
Expression conditionnelle A-> {
Processus A
}
Expression conditionnelle B-> {
Processus B
}
else -> {
Processus C
}
}
C#
for (int i = 1; i <= 100; i++){
Console.WriteLine(i);
}
Java
for (int i = 1; i <= 100; i++){
System.out.println(i);
}
Python
for i in range(1, 101):
print(i)
Ruby
#3 types
puts [*1..100]
100.times{|n| println n+1}
1.upto(100){|n| p n}
Kotlin
for (i in 1..100) println(i)
C#
int[] array = new int[10]{1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
foreach(int n in array)
{
Console.WriteLine(n);
}
Java
int[] array = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
for (int n : array) {
System.out.println(n);
}
Python
array = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
for n in array:
print(n)
Ruby
array = Array[1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
for n in array do
puts(n)
end
Kotlin
val arr = arrayOf(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
for (n in arr) {
println(n)
}
C#
int[] ary = {1,10,100};
Java
int[] ary = {1,10,100};
Python
#En Python, le tableau ne peut pas être utilisé sans importer
import array
ary = array.array('i',[1, 10, 100])
#array.array(Moule,[Valeur 1,Valeur 2,Valeur 3])
Ruby
array = [1,10,100]
//Le tableau Ruby peut être modifié
array.push(200)
array[2] = 50
p array
>> [1,10,50,200]
Kotlin
// [1, 2, 3]faire
val list = arrayOf(1, 2, 3)
//Créer un tableau de taille 3 rempli de valeurs nulles
var arr: Array<Int?> = arrayOfNulls(3)
C#
//Déclaration
var list = new List<string>();
//nom d'objet var= new List<Moule>(Nombre d'éléments);
//ajouter à
list.Add("Tokyo");
list.Add("Osaka");
list.Add("Nagoya");
//Effacer
list.Remove("Osaka");
//production
Console.WriteLine("[{0}]", string.Join(", ", list));
Console.WriteLine(list[1]);
//Résultat de sortie
>>> [Tokyo, Nagoya]
Nagoya
Java
import java.util.ArrayList;
import java.util.List;
//Déclaration
List<String> list = new ArrayList<String>();
//List<Types de choses à mettre dans la liste>Nom de l'objet=type de nouvelle liste<Types de choses à mettre dans la liste>(Nombre d'éléments)
//ajouter à
list.add("Tokyo");
list.add("Osaka");
list.add("Nagoya");
//Effacer
list.remove("Osaka");
//production
System.out.println(list);
System.out.println(list.get(1));
//Résultat de sortie
>>> [Tokyo, Nagoya]
Nagoya
Python
list = ["Hello", 1, "world", 2, "!"]
#ajouter à
list.append(5)
#Effacer
list.remove(1)
#production
print(list)
print(list[3])
#Résultat de sortie
>>> ['Hello','world', 2, '!',5]
!
Ruby
Ruby n'a pas de liste car Array joue le même rôle que List
Kotlin
// List<Int>faire. Le contenu de la liste ne peut pas être modifié.
val list = listOf(1, 2, 3, 4, 5)
// MutableList<Int>faire. Vous pouvez modifier le contenu ici
val mlist = mutableListOf(1, 2, 3, 4, 5)
//ajouter à
mlist.add(6)
//Effacer
mlist.remove(3)
//production
println(mlist[0])
println(mlist)
>>> 1
[1, 2, 4, 5,6]
C#
Dictionary<int,String> dict = new Dictionary<int,String>();
//Dictionary<Nom du modèle de clé,Nom du type de valeur>Nom de l'objet= new Dictionary<Nom du modèle de clé,Nom du type de valeur>()
//ajouter à
dict.Add(1,"aaa");
dict.Add(2,"bbb");
dict.Add(3"ccc");
//Effacer
dict.Remove(2)
//production
Console.WriteLine(dict[3])
>>> ccc
//Sortir tout
foreach (KeyValuePair<int, string> item in dict){
Console.WriteLine("[{0}:{1}]", item.Key, item.Value);
}
>>> [1:aaa]
[2:bbb]
Java
import java.util.HashMap;
import java.util.Map;
//Déclaration
Map<Integer,String> map = new HashMap<Integer,String>();
//Map<Nom du modèle de clé,Nom du type de valeur>Nom de l'objet=nouveau type de carte<Nom du modèle de clé,Nom du type de valeur>()
//ajouter à
map.put(1,"aaa");
map.put(2,"bbb");
map.put(3,"ccc");
//Effacer
map.remove(2);
//production
System.out.println(map.get(3));
>> ccc
//Sortir tout
for (int key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
>>> 1:aaa
3:ccc
Python
#Déclaration (initialisation)
dict = {1:"aaa", 2:"bbb", 3:"ccc", "ddd":4}
#Nom de l'objet= {key:value , key;value}
#ajouter à
dict["peach"] = 5
#Effacer
dict.pop(2)
#production
print(dict[3])
print(dict["ddd"])
>>> ccc
4
#Sortir tout
print(dict)
>>> {1: 'aaa', 3: 'ccc', 'ddd': 4, 'peach': 5}
Ruby
#Utiliser des objets Hash
hash = {1 =>"aaa", 2 =>"bbb", 3 => "ccc", "ddd" => 4}
#Nom de l'objet= { key => value}
#ajouter à
hash[5] = "eee"
#Effacer
hash.delete[2]
#production
puts hash["ddd"]
>>>4
#Sortir tout
puts hash.inspect
>>> {:1=>aaa, :3=>cccc :ddd=>4 :5=>eee}
Kotlin
//Map<Int,String>Ne peut pas être changé
val map = mapOf(1 to "aaa", 2 to "bbb")
//nom d'objet val= mapOf(key to value)
// MutableMap<Int, String>Peut être fait et changé
val mmap = mutableMapOf(1 to "aaa", 2 to "bbb")
mmap[1] = "ccc"
//ajouter à
mmap[3] = "ddd"
//Effacer
mmap.remove(2)
//production
println(list[1])
>>> ccc
//Sortir tout
for((key, value) in map)
println("${key} to ${value}")
>>> 1 to ccc
3 to ddd
Recommended Posts