[Konsolenausgabe](# Konsolenausgabe)
[Variable Deklaration](#Variable Deklaration)
[Bedingter Zweig](# Bedingter Zweig)
[Verarbeitung wiederholen](# Iterative Verarbeitung)
[Sammlung](# Sammlung)
C#
//System ist optional
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
Keine Typdeklaration erforderlich
str = "a" #String
num = 1 #int
tr = True #Boolean
Ruby
Keine Typdeklaration erforderlich
Boolescher Typ existiert nicht
str = "a" #String
num = 1 #int
Kotlin
val str = "a" //String
//Mit val deklarierte Variablen können nicht geändert werden
var num = 1 //int
//Mit var deklarierte Variablen können geändert werden
num = 2
var tr = True //Boolean
C#
///if
if(Bedingung A.){
Prozess A.
}
else if(Bedingung B.){
Prozess B.
}
else{
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
}
//switch
switch (Variable){
Fall Bedingung A.:
Prozess A.
break;
Fall Bedingung B.:
Prozess B.
break;
default:
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
break;
}
Java
//if
if(Bedingung A.){
Prozess A.
}
else if(Bedingung B.){
Prozess B.
}
else{
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
}
//switch
switch (Variable){
Fall Bedingung A.:
Prozess A.
break;
Fall Bedingung B.:
Prozess B.
break;
default:
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
break;
}
Python
wenn Bedingung A.:
Prozess A.
elif Bedingung B.:
Prozess B.
else:
Prozess C.
#if
wenn Bedingung A dann
Prozess A.
sonst Bedingung B dann
Prozess B.
else then
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
end
#case
Fallvariable
wenn Bedingung A dann
Prozess A.
wenn Bedingung B dann
Prozess B.
else
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
end
Kotlin
//if
if(Bedingung A.){
Prozess A.
}
else if(Bedingung B.){
Prozess B.
}
else{
//Wenn die oben genannten Bedingungen nicht erfüllt sind
Prozess C.
}
//when
when (Variable) {
Bedingung A.-> {
Prozess A.
}
Bedingung B.-> {
Prozess B.
}
else -> {
Prozess C.
}
//Wann kann durch direkte Eingabe eines Ausdrucks wie Variable == Bedingung beurteilt werden.
when {
Bedingter Ausdruck A.-> {
Prozess A.
}
Bedingter Ausdruck B.-> {
Prozess B.
}
else -> {
Prozess 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 Arten
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
#In Python kann das Array nicht ohne Import verwendet werden
import array
ary = array.array('i',[1, 10, 100])
#array.array(Schimmel,[Wert 1,Wert 2,Wert 3])
Ruby
array = [1,10,100]
//Ruby-Array kann geändert werden
array.push(200)
array[2] = 50
p array
>> [1,10,50,200]
Kotlin
// [1, 2, 3]machen
val list = arrayOf(1, 2, 3)
//Erstellen Sie ein Array mit Größe 3, das mit Nullen gefüllt ist
var arr: Array<Int?> = arrayOfNulls(3)
C#
//Erklärung
var list = new List<string>();
//var Objektname= new List<Schimmel>(Elementanzahl);
//hinzufügen
list.Add("Tokyo");
list.Add("Osaka");
list.Add("Nagoya");
//Löschen
list.Remove("Osaka");
//Ausgabe
Console.WriteLine("[{0}]", string.Join(", ", list));
Console.WriteLine(list[1]);
//Ausgabeergebnis
>>> [Tokyo, Nagoya]
Nagoya
Java
import java.util.ArrayList;
import java.util.List;
//Erklärung
List<String> list = new ArrayList<String>();
//List<Arten von Dingen, die in die Liste aufgenommen werden sollen>Objektname=Art der neuen Liste<Arten von Dingen, die in die Liste aufgenommen werden sollen>(Elementanzahl)
//hinzufügen
list.add("Tokyo");
list.add("Osaka");
list.add("Nagoya");
//Löschen
list.remove("Osaka");
//Ausgabe
System.out.println(list);
System.out.println(list.get(1));
//Ausgabeergebnis
>>> [Tokyo, Nagoya]
Nagoya
Python
list = ["Hello", 1, "world", 2, "!"]
#hinzufügen
list.append(5)
#Löschen
list.remove(1)
#Ausgabe
print(list)
print(list[3])
#Ausgabeergebnis
>>> ['Hello','world', 2, '!',5]
!
Ruby
Ruby hat keine Liste, da Array die gleiche Rolle wie List spielt
Kotlin
// List<Int>machen. Der Inhalt der Liste kann nicht geändert werden.
val list = listOf(1, 2, 3, 4, 5)
// MutableList<Int>machen. Hier können Sie den Inhalt ändern
val mlist = mutableListOf(1, 2, 3, 4, 5)
//hinzufügen
mlist.add(6)
//Löschen
mlist.remove(3)
//Ausgabe
println(mlist[0])
println(mlist)
>>> 1
[1, 2, 4, 5,6]
C#
Dictionary<int,String> dict = new Dictionary<int,String>();
//Dictionary<Name des Schlüsselmodells,Werttypname>Objektname= new Dictionary<Name des Schlüsselmodells,Werttypname>()
//hinzufügen
dict.Add(1,"aaa");
dict.Add(2,"bbb");
dict.Add(3"ccc");
//Löschen
dict.Remove(2)
//Ausgabe
Console.WriteLine(dict[3])
>>> ccc
//Alle ausgeben
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;
//Erklärung
Map<Integer,String> map = new HashMap<Integer,String>();
//Map<Name des Schlüsselmodells,Werttypname>Objektname=neuer Kartentyp<Name des Schlüsselmodells,Werttypname>()
//hinzufügen
map.put(1,"aaa");
map.put(2,"bbb");
map.put(3,"ccc");
//Löschen
map.remove(2);
//Ausgabe
System.out.println(map.get(3));
>> ccc
//Alle ausgeben
for (int key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
>>> 1:aaa
3:ccc
Python
#Erklärung (Initialisierung)
dict = {1:"aaa", 2:"bbb", 3:"ccc", "ddd":4}
#Objektname= {key:value , key;value}
#hinzufügen
dict["peach"] = 5
#Löschen
dict.pop(2)
#Ausgabe
print(dict[3])
print(dict["ddd"])
>>> ccc
4
#Alle ausgeben
print(dict)
>>> {1: 'aaa', 3: 'ccc', 'ddd': 4, 'peach': 5}
Ruby
#Verwenden Sie Hash-Objekte
hash = {1 =>"aaa", 2 =>"bbb", 3 => "ccc", "ddd" => 4}
#Objektname= { key => value}
#hinzufügen
hash[5] = "eee"
#Löschen
hash.delete[2]
#Ausgabe
puts hash["ddd"]
>>>4
#Alle ausgeben
puts hash.inspect
>>> {:1=>aaa, :3=>cccc :ddd=>4 :5=>eee}
Kotlin
//Map<Int,String>Kann nicht geändert werden
val map = mapOf(1 to "aaa", 2 to "bbb")
//val Objektname= mapOf(key to value)
// MutableMap<Int, String>Kann gemacht und geändert werden
val mmap = mutableMapOf(1 to "aaa", 2 to "bbb")
mmap[1] = "ccc"
//hinzufügen
mmap[3] = "ddd"
//Löschen
mmap.remove(2)
//Ausgabe
println(list[1])
>>> ccc
//Alle ausgeben
for((key, value) in map)
println("${key} to ${value}")
>>> 1 to ccc
3 to ddd
Recommended Posts