what is the sizeof earth compared to the other planets?
1. what is the sizeof earth compared to the other planets?
Jawaban:
for the average radius, 6.371 km.
diameter approx 12.756 kilometer.
size of earth =510.1 million km²
I hope it helps
2. 15. guna mengembalikan jumlah byte yang sesuai dengan argumennya, dapat menggunakan fungsi .... a. int array[ ] b. cout sizeof() d. void main() e. #include c. ο
Jawaban:
b. cout sizeof()
Penjelasan:
Pada C++ fungsi sizeof digunakan untuk mengembalikan jumlah byte atau size memory yang digunakan dari sebuah argumen atau tipe data.
Referensi lain: https://en.cppreference.com/w/cpp/language/sizeof
Semoga membantu, jika kurang jelas silakan ajukan pertanyaan di kolom komentar dan jangan lupa untuk dukung naik jawaban ini.
3. 2. Dari potongan kode berikut mana yang menghasilkan ekspresi nilai 1 a. “hello” > “world” b. sizeof(char) > sizeof(unsigned) c. 010 >> 1 d. “ex ex ex” != “ex ex ex” ex= huruf x (restricted word brainly)
Jawaban:
a."hello" > "word"
Penjelasan:
hello = hai
word = kata
gtw bingung
4. PASSAGE ONE (questions 1-2) Eskimos need efficient and adequate means to travel across water in that the areas where the live are surrounded by oceans, bays,and inlets an dotted with lakes an seas. Two different types of boats have been developed by the Eskimos, each constructed to meet specific needs. The kayak is something like a canoe that has been covered by a deck. A kayak is generally constructed with one opening in the deck for one rider; however, some kayaks are made for two. because the deck of a kayak is covered over except for the hole (or holes) for its rider (or riders), a kayak can tip over in the water and roll back up without filling with water and sinking. One of the primary use of the kayak is for hunting. The umiak is not closed over, as is the kayak. Instead, it is an open boat thatis built to hold ten to twelve passengers. Eskimos have numerous uses for umiak which reflect the sizeof the boat;e,g. the umiak is used to haul belongings from campsite to campisite, and it is used for hunting larger animals that are too big to be hunted in a kayak. 1. It is implied in the passage that if a kayak has two holes, then…. (A) It accommodates two riders (B) It is less stable than a kayak with one hole (C) It is as large as an umiak (D) It cannot be used on the ocean Answer : (A) It accommodates two riders 2. It can be inferred from the passage that an example of the animals mentioned might be…. (A) a kangaroo (B) a snake (C) a whale (D) a salmon Answer : (C) a whale tolong terjemahin dong
Jawaban:
PASSAGE ONE (pertanyaan 1-2) Orang Eskimo membutuhkan sarana yang efisien dan memadai untuk melakukan perjalanan melintasi air di daerah di mana kehidupannya dikelilingi oleh samudra, teluk, dan ceruk yang dihiasi dengan danau dan lautan. Dua jenis perahu berbeda telah dikembangkan oleh orang Eskimo, masing-masing dibangun untuk memenuhi kebutuhan khusus. Kayak adalah sesuatu seperti kano yang telah ditutup oleh dek. Kayak umumnya dibuat dengan satu bukaan di geladak untuk satu pengendara; Namun, beberapa kayak dibuat untuk dua orang. karena geladak kayak tertutup kecuali lubang (atau lubang) untuk penunggangnya (atau penunggangnya), kayak dapat terjungkal ke dalam air dan berguling kembali tanpa terisi air dan tenggelam. Salah satu kegunaan utama kayak adalah untuk berburu. Umiak tidak ditutup, seperti halnya kayak. Sebaliknya, itu adalah perahu terbuka yang dibangun untuk menampung sepuluh hingga dua belas penumpang. Orang Eskimo memiliki banyak kegunaan umiak yang mencerminkan ukuran perahu; e, g. Umiak digunakan untuk mengangkut barang-barang dari perkemahan ke campisite, dan digunakan untuk berburu hewan yang lebih besar yang terlalu besar untuk diburu dengan kayak. 1. Tersirat dalam perikop bahwa jika kayak memiliki dua lubang, maka…. (A) Ini menampung dua pengendara (B) Ini kurang stabil dibandingkan kayak dengan satu lubang (C) Itu sebesar umiak (D) Tidak dapat digunakan di laut Jawaban: (A) Ini menampung dua pengendara 2. Dapat disimpulkan dari bagian tersebut bahwa contoh hewan yang disebutkan mungkin…. (A) seekor kanguru (B) seekor ular (C) seekor ikan paus (D) salmon Jawaban: (C) seekor ikan paus
5. Analisis algoritma berikut ini nyatakan dalam bentuk waktu proses T(n). #include <iostream>using namespace std; void insertionSortRecursive(int arr[], int n){ if (n <= 1) return; insertionSortRecursive( arr, n-1 ); int last = arr[n-1]; int j = n-2; while (j >= 0 && arr[j] > last) { arr[j+1] = arr[j]; j--; } arr[j+1] = last;}void printArray(int arr[], int n){ for (int i=0; i < n; i++) cout << arr[i] <<" ";} int main(){ int arr[] = {12, 11, 13, 5, 6}; int n = sizeof(arr)/sizeof(arr[0]); insertionSortRecursive(arr, n); printArray(arr, n); return 0;}
Jawaban:
ggdcbbnjjjjjjjjvcxxccv
6. ada yang bisa benerin? #include #include #include #include struct node { int info; struct node *next; } typedef struct node NODE; typedef NODE* PTRNODE; PTRNODE PtrAwal = NULL, tPtr; /*menambah node di akhir dari list*/ void InsertLast(PTRNODE *Ptr, int Value) { PTRNODE prevPtr = *Ptr, nowPtr = *Ptr, newPtr; newPtr = malloc(sizeof(NODE)); newPtr->info = Value; newPtr->next = NULL; while (nowPtr != NULL) { prevPtr = nowPtr; nowPtr = nowPtr->next; } if(prevPtr == NULL) *Ptr = newPtr; else prevPtr->next = newPtr; } /*menambah node diawal dari list*/ void InsertFirst(PTRNODE *Ptr, int Value) { PTRNODE newPtr; newPtr = malloc(sizeof(NODE)); newPtr->info = Value; newPtr->next = *Ptr; *Ptr = newPtr; } /*menyisipkan node sehingga menjadi list terurut*/ void InsertOrder(PTRNODE *Ptr, int Value) { PTRNODE prevPtr = *Ptr, nowPtr = *Ptr, newPtr; newPtr = malloc(sizeof(NODE)); newPtr->info = Value; newPtr->next = NULL; while(nowPtr != NULL && Value > nowPtr->info) { prevPtr = nowPtr; nowPtr = nowPtr->next; } if (prevPtr == NULL) { newPtr->next = *Ptr; *Ptr = newPtr; } else { prevPtr->next = newPtr; newPtr->next = nowPtr; } } /*mencari node yang mempunyai nilai value tertentu*/ PTRNODE Cari(PTRNODE Ptr, int Value) { PTRNODE cariPtr = Ptr; int Ketemu = 0; while (cariPtr != NULL && Ketemu == 0) { if (cariPtr->info == Value) Ketemu = 1; else cariPtr = cariPtr->next; } return cariPtr; } /*mendapatkan pointer ke node sebelum node yang ditunjuk Ptr*/ PTRNODE PtrSebelum(PTRNODE Head, PTRNODE Ptr) { PTRNODE nowPtr = Head, prevPtr = NULL; while (nowPtr != Ptr) { prevPtr = nowPtr; nowPtr = nowPtr->next; } return prevPtr; } /*menghapus node yang berisi Value*/ void Delete(PTRNODE *Ptr, int Value) { PTRNODE nowPtr, prevPtr, tPtr; nowPtr = Cari(*Ptr, Value); if (nowPtr != NULL) { prevPtr = PtrSebelum(*Ptr, nowPtr); if (prevPtr == NULL) { tPtr = *Ptr; *Ptr = (*Ptr)->next; free(tPtr); } else { prevPtr->next = nowPtr->next; free(nowPtr); } } } /*menyajikan seluruh isi node kelayar*/ void cetak(PTRNODE Ptr) { while (Ptr != NULL) { printf("%4d ",Ptr->info); Ptr = Ptr->next; } printf("\n"); }
#include
#include
#include
#include
struct node
{
int info;
struct node *next;
}
typedef struct node NODE;
typedef NODE* PTRNODE;
PTRNODE PtrAwal = NULL, tPtr;
/*menambah node di akhir dari list*/
void InsertLast(PTRNODE *Ptr, int Value)
{
PTRNODE prevPtr = *Ptr, nowPtr = *Ptr, newPtr;
newPtr = malloc(sizeof(NODE));
newPtr->info = Value;
newPtr->next = NULL;
while (nowPtr != NULL)
{
prevPtr = nowPtr;
nowPtr = nowPtr->next;
}
if(prevPtr == NULL)
*Ptr = newPtr;
else
prevPtr->next = newPtr;
}
/*menambah node diawal dari list*/
void InsertFirst(PTRNODE *Ptr, int Value)
{
PTRNODE newPtr;
newPtr = malloc(sizeof(NODE));
newPtr->info = Value;
newPtr->next = *Ptr;
*Ptr = newPtr;
}
/*menyisipkan node sehingga menjadi list terurut*/
void InsertOrder(PTRNODE *Ptr, int Value)
{
PTRNODE prevPtr = *Ptr, nowPtr = *Ptr, newPtr;
newPtr = malloc(sizeof(NODE));
newPtr->info = Value;
newPtr->next = NULL;
while(nowPtr != NULL && Value > nowPtr->info)
{
prevPtr = nowPtr;
nowPtr = nowPtr->next;
}
if (prevPtr == NULL)
{
newPtr->next = *Ptr;
*Ptr = newPtr;
}
else
{
prevPtr->next = newPtr;
newPtr->next = nowPtr;
}
}
/*mencari node yang mempunyai nilai value tertentu*/
PTRNODE Cari(PTRNODE Ptr, int Value)
{
PTRNODE cariPtr = Ptr;
int Ketemu = 0;
while (cariPtr != NULL && Ketemu == 0)
{
if (cariPtr->info == Value)
Ketemu = 1;
else
cariPtr = cariPtr->next;
}
return cariPtr;
}
/*mendapatkan pointer ke node sebelum node yang ditunjuk Ptr*/
PTRNODE PtrSebelum(PTRNODE Head, PTRNODE Ptr)
{
PTRNODE nowPtr = Head, prevPtr = NULL;
while (nowPtr != Ptr)
{
prevPtr = nowPtr;
nowPtr = nowPtr->next;
}
return prevPtr;
}
/*menghapus node yang berisi Value*/
void Delete(PTRNODE *Ptr, int Value)
{
PTRNODE nowPtr, prevPtr, tPtr;
nowPtr = Cari(*Ptr, Value);
if (nowPtr != NULL)
{
prevPtr = PtrSebelum(*Ptr, nowPtr);
if (prevPtr == NULL)
{
tPtr = *Ptr;
*Ptr = (*Ptr)->next;
free(tPtr);
}
else
{
prevPtr->next = nowPtr->*next;
free(nowPtr);
}
}
/*menyajikan seluruh isi node kelayar*/
void cetak(PTRNODE Ptr)
{
while (Ptr != FULL)
{
printf("%4d ",Ptr->info);
Ptr = Ptr->next;
}
printf("\n");
}
