Tantangan

Pekerja pabrik biasanya pekerja keras. Namun, pekerjaan mereka sekarang sering diganti dengan mesin.

Anda harus menulis program yang menggunakan angka sebagai input. Ini akan mencetak pabrik 10 pekerja 10 kali. Setiap kali, setiap pekerja memiliki 1/inputpeluang untuk 'dipecat' dan digantikan oleh mesin.

Memasukkan

Integer, berasal dari STDIN atau panggilan fungsi.

Keluaran

10 kasus pabrik, masing-masing dengan pekerja biasanya lebih banyak dipecat.

Format keluaran - cara mencetak pabrik

Sebuah pabrik terlihat seperti ini:

|0000000000| atau |0000011001|

Sebuah pipa mewakili dinding, 0 mewakili pekerja, dan 1 mewakili mesin, sehingga cetakan pertama dari pabrik akan selalu |0000000000|.

Contoh

Input: 10

Keluaran:

|0000000000| //always start off with this
|0000000010| //a 1/10 chance means that this worker lost his job
|0000010010|
|0010010010|
|1010010010|
|1010110010|
|1010110011|
|1010111011|
|1010111111|
|1110111111|

Input: 5

Keluaran:

|0000000000| //always start here
|0000001001| //a 1/5 chance means that 2 workers got fired
|1000101001|
|1000101111|
|1101101111|
|1111111111| //after achieving all machinery, the machines continue to be printed
|1111111111|
|1111111111|
|1111111111|
|1111111111|

CATATAN

Jumlah pekerja yang dipecat adalah ACAK - dalam contoh saya untuk 1/5 chanceselalu ada 2 pekerja dipecat tetapi program Anda harus melakukan ini secara acak - kadang-kadang 1 dan kadang-kadang 3 - mereka hanya memiliki 1/5 peluang dipecat.

Japt -R , 22 21 20 19 18 byte

AÆP=®|!UöêAçTÃû|C

Cobalah

Penjelasan

AÆP=®|!UöêAçTÃû|C     :Implicit input of integer U
A                      :10
 Æ                     :Map the range [0,A)
  P=                   :  Assign to P (initially the empty string)
    ®                  :    Map P
     |                 :      Bitwise OR with
      !                :      The negation of
       Uö              :      A random integer in the range [0,U)
         Ã             :    End Map
          ª            :    OR, for the first element when the above will still be an empty string (falsey)
           Aç          :    Ten times repeat
             T         :      Zero
              Ã        :End Map
               û|      :Centre pad each element with "|"
                 C     :  To length 12
                       :Implicitly join with newlines and output

R , 92 89 byte

cat(t(cbind("|",apply("[<-"(matrix(runif(100)<1/scan(),10),1,,0),2,cummax),"|
")),sep="")

Cobalah online!

Tidak Disatukan:

m <- matrix(runif(100)<1/n,10,10)   #10x10 matrix of TRUE with probability 1/n
                                    #and FALSE with probability 1-1/n
m[1,] <- 0                          #set first row to 0
m <- apply(m,2,cummax)              #take the column cumulative maxima
m <- cbind("|",m,"|\n")             #put "|" as the first and last columns
m <- t(m)                           #transpose m for the write function
cat(m,sep="")                       #print m to stdout, separated by ""

JavaScript (ES6), 84 byte

n=>[...s=2e9+''].map(j=>`|${s=s.replace(/./g,i=>i&1|Math.random()*n<!+j)}|`).join`
`

Cobalah online!

Versi rekursif, 88 byte

n=>(g=k=>k?`|${s=s.replace(/./g,i=>i%5|Math.random()*n<(s!=k))}|
`+g(k>>3):'')(s=5e9+'')

Cobalah online!

Bagaimana?

Kita mulai dengan k = s = '5000000000' .

Pada setiap iterasi:

• Kami memaksa masing-masing karakter saya dari s ke nomor, menghitung i modulo 5 - sehingga terkemuka 5 diperlakukan seperti 0 - dan secara acak melakukan bitwise OR dengan 1 dengan probabilitas yang diharapkan 1 / n , kecuali pada iterasi pertama .

• Counter k bergeser ke kanan sebanyak 3 bit. Kami menghentikan rekursi segera setelah k = 0 , yang memberikan 10 iterasi.

  Penting untuk dicatat bahwa 5000000000 sedikit lebih besar dari bilangan bulat 32-bit, sehingga secara implisit dikonversi menjadi 5000000000 & 0xFFFFFFFF = 705032704 tepat sebelum pergeseran bitwise pertama terjadi. Maka langkah-langkah berikut:

   step | k
  ------+-----------
     0  | 705032704
     1  | 88129088
     2  | 11016136
     3  | 1377017
     4  | 172127
     5  | 21515
     6  | 2689
     7  | 336
     8  | 42
     9  | 5
    10  | 0
  

APL (Dyalog) , 37 byte

⎕{⎕←' '~⍨⍕'|'⍵'|'⋄×⍵+⍺=?10⍴⍺}⍣10⊢10⍴0

Cobalah online!

Bagaimana?

10⍴0 - mulai dengan 10 nol.

⎕←' '~⍨⍕'|'⍵'|' - setiap kali mencetak array yang diformat,

?10⍴⍺- Menghasilkan array acak dengan nilai mulai 1input,

⍺=- perbandingan elemen-bijaksana dengan input. harus menandai 1/ input elemen, memberikan masing-masing a 1/ input setiap kali,

⍵+ - tambahkan ke array,

×- signum. nol tetap nol, apa pun yang lebih besar dari satu kembali ke satu.

⍣10 - ulangi 10 kali.

Retina , 30 byte

.+
|¶10*$(*0¶
.-10+0\%0<@`\d
1

Cobalah online!

Saya bersenang-senang dengan keacakan di Retina ^^

Penjelasan

Tahap pertama mengatur string yang akan kita kerjakan:

.+
|¶10*$(*0¶

Ini menggantikan seluruh input dengan |, baris baru, dan kemudian 10 baris yang berisi sebanyak 0kata input. Karakter pertama pada setiap baris akan mewakili pekerja pabrik.

Tahap berikut berarti:

.                     Disable automatic printing at the end of the program
 -10+                 Do the following exactly 10 times:
       %                For each line:
        0<                Print the first character, then
          @`\d            Pick a random digit and
1 (on the next line)      replace it with a 1
     0\                 Then print the first character of the whole string
                        followed by a newline

Baris pertama dari string yang bekerja hanya berisi a |, yang akan menjadi karakter pertama yang dicetak oleh setiap iterasi dari loop (menjadi karakter pertama dari baris pertama), dan juga akan dicetak pada akhir setiap iterasi (menjadi yang pertama karakter seluruh string). Penggantian tidak akan memiliki efek apa pun pada saluran ini karena tidak mengandung digit apa pun.

Setiap baris lainnya berisi nangka, sehingga ada 1 yang nberpeluang mengubah karakter pertama dari garis (yang merupakan satu-satunya yang bermakna) menjadi a 1.

PowerShell , 82 80 69 byte

param($x)($a=,0*10)|%{"|$(-join$a)|";$a=$a|%{$_-bor!(Random -ma $x)}}

Cobalah online!

Mengambil input $x. Menciptakan array dari semua nol, menyimpannya ke dalam $adan kemudian loop berkali-kali. Nyaman, pabrik hanya selebar itu layak iterasi. Setiap iterasi, kami output pabrik kami saat ini "|$(-join$a)|", kemudian loop melalui setiap elemen $a.

Di dalam kita memilih elemen saat ini $_yang telah -bditentukan ordengan baik 1berdasarkan Randompeluang berdasarkan pada input $x. Misalnya, untuk input 10, Get-Random -max 10akan berkisar antara 0dan 9dan 0sekitar 1/10 dari waktu. Jadi dengan !(...)membungkusnya Random, kita akan mendapatkan 1kira - kira 1/inputjumlah waktu, dan 1-1/inputjumlah lain dari waktu yang akan kita dapatkan $_. Ya, ini kadang-kadang berarti bahwa kami menimpa 1dengan yang lain 1, tapi itu tidak masalah.

Array yang dihasilkan kemudian disimpan kembali ke $auntuk putaran berikutnya. Semua string yang dihasilkan ditinggalkan di jalur pipa, dan implisit Write-Outputpada penyelesaian program memberi kita baris baru secara gratis.

-2 byte berkat Veskah.
-11 byte berkat ASCII saja.

Perl 6 , 58 byte

{say "|$_|" for 0 x 10,|[\~|] ([~] +(1>$_*rand)xx 10)xx 9}

Cobalah online!

+(1 > $_ * rand)menghasilkan bit tunggal dengan frekuensi 1s yang diperlukan . xx 10mereplikasi ekspresi itu sepuluh kali untuk menghasilkan instance pabrik tunggal sebagai daftar bit, dan [~]bergabung dengan daftar itu menjadi string tunggal. xx 9mereplikasi ekspresi yang menghasilkan string pabrik sembilan kali, dan kemudian [\~|]melakukan pengurangan segitiga (yang beberapa bahasa lain menyebutnya "pemindaian") dengan stringwise atau operator ~|, sehingga pekerja yang dipecat dalam iterasi sebelumnya tetap dipecat dalam yang kemudian.

Python 2 , 104 103 byte

from random import*
x='0'*10;i=input()
exec"print'|%s|'%''.join(x);x=[choice('1'+n*~-i)for n in x];"*10

Cobalah online!

Jelly , 22 byte

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y

Program lengkap yang menerima integer sebagai input baris perintah dan mencetak output ke STDOUT.
(Sebagai tautan monadik, ia mengembalikan daftar karakter dan bilangan bulat.)

Cobalah online!

Bagaimana?

Secara efektif memutuskan pada setiap tahap jika setiap pekerja (termasuk mesin apa pun) kehilangan pekerjaan mereka (dengan peluang satu di N), namun mesin diganti oleh mesin (menggunakan logis-OR).

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y - Main link: integer, N
 ⁵                     - literal ten
ẋ                      - repeat -> [N,N,N,N,N,N,N,N,N,N]
    ⁵                  - literal ten
  ẋ€                   - repeat €ach -> [[N,N,N,N,N,N,N,N,N,N],...,[N,N,N,N,N,N,N,N,N,N]]
       ¦               - sparse application...
      1                - ...to indices: [1]
     ¬                 - ...do: logical-NOT -> [[0,0,0,0,0,0,0,0,0,0],[N,N,...],...]
        X€€            - random integer for €ach for €ach
                       -   (0s stay as 0s; Ns become random integers in [1,N])
           =1          - equals one? (vectorises)
             o\        - cumulative reduce with logical-OR
                  ⁾||  - literal list of characters = ['|','|']
               j@€     - join with sw@pped arguments for €ach
                     Y - join with line feeds
                       - implicit print

MATL , 26 byte

'|'it10th&Yr=0lY(Y>48+y&Yc

Cobalah online!

(Panjang) penjelasan

Contoh konten tumpukan ditampilkan di sepanjang jalan. Pada setiap langkah, isi tumpukan ditampilkan dari bawah ke atas.

'|'    % Push this character
       % STACK: '|'
it     % Take input. Duplicate
       % STACK: '|'
                5
                5
10th   % Push [10 10]
       % STACK: '|'
                5
                5
                [10 10]
&Yr    % Random 10×10 matrix of integers from 1 to input number
       % STACK: '|'
                 5
                 [4 5 4 4 5 5 2 1 2 3
                  3 4 3 3 1 4 4 3 1 5
                  5 1 4 5 4 4 5 2 3 2
                  3 4 5 2 1 3 2 5 3 4
                  4 1 2 2 4 1 1 5 1 1
                  4 5 3 1 5 3 5 2 4 1
                  2 1 4 3 3 1 3 5 3 5
                  1 2 2 1 2 2 4 3 5 3
                  4 5 4 1 2 2 5 3 2 4
                  4 1 2 5 5 5 4 3 5 1]
=      % Is equal? Element-wise
       % STACK: '|'
                [0 1 0 0 1 1 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
0lY(   % Write 0 in the first row
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
Y>     % Cumulative maximum down each column
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 1 1 1 1 1]
48+    % Add 48, element-wise. This transforms each number into the
       % ASCII code of its character representation
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
y      % Duplicate from below
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
                 '|'
&Yc    % Horizontally concatenate all stack contents as char arrays.
       % 1-row arrays are implicitly replicated along first dimension
       % STACK: ['|0000000000|'
                 '|0000000001|'
                 '|1001001001|'
                 '|1011001101|'
                 '|1011001101|'
                 '|1111101101|'
                 '|1111101101|'
                 '|1111101111|'
                 '|1111101111|'
                 '|1111111111|']
       % Implicitly display

JavaScript (Node.js) , 105 93 90 byte

x=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``,w=Array(10).fill(0)

Cobalah online!

+2 byte untuk meletakkan array di dalam fungsi, terima kasih kepada @Shaggy untuk menunjukkannya

(x,w=Array(10).fill(0))=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``

Cobalah online!

C (gcc) , 110 106 byte

-4 byte dari @ceilingcat

char l[]="|0000000000|",i,j;f(n){for(srand(time(i=0));i++<10;)for(j=!puts(l);j++<10;)rand()%n||(l[j]=49);}

Cobalah online!

Iterasi melalui daftar karakter untuk setiap putaran penggantian.

Tidak Disatukan:

f(n)
{
    //start with a fresh factory
    char l[]="|0000000000|";

    //init rng
    srand(time(0));

    //print 11 lines
    for(int i = 0; i < 11; i++)
    {
        //print current factory
        puts(l);

        //iterate through the workers. start at index 1 to skip the '|'
        for(int j = 1; j < 11; j++)
        {
            //the expression (rand()%n) has n possible values in the range [0,n-1],
            //so the value 0 has 1/n chance of being the result and thus the worker
            //has 1/n chance of being replaced
            if(rand()%n == 0)
            {
                l[j] = '1';
            }
        }
    }
}

SmileBASIC, 75 byte

INPUT N
FOR J=0TO 9?"|";BIN$(F,10);"|
FOR I=0TO 9F=F OR!RND(N)<<I
NEXT
NEXT

Perl 5 , 44 byte

#!/usr/bin/perl -a
say"|$_|",s/0/rand"@F"<1|0/eg<0for(0 x10)x10

Cobalah online!

05AB1E , 22 byte

TÅ0TFDJ'|.ø=sITи€L€ΩΘ~

Cobalah online!

Seharusnya ada lebih banyak ruang untuk bermain golf.

• TÅ0 - Dorong daftar 10 nol.
• TF... - Lakukan ini 10 kali:
  • DJ - Gandakan item saat ini dan bergabunglah.
  • '|.ø=- Kelilingi dengan dua |s dan cetak ke STDOUT.
  • ITи - Ulangi input 10 kali.
  • €L€Ω- Dan untuk setiap kejadian, dapatkan elemen acak [1 ... N] . (Mungkin ada built-in untuk ini yang belum saya lihat)
  • Θ- Dorong 05AB1E truthified ™. Untuk masing-masing, periksa apakah sama dengan 1 .
  • s...~ - Logis ATAU hasil dari item saat ini.

JavaScript, 83 byte

f=(n,t=9,s=`|0000000000|
`)=>t?s+f(n,t-1,s.replace(/0/g,v=>+(Math.random()<1/n))):s

f=(n,t=9,s=`|0000000000|
`)=>t?s+f(n,t-1,s.replace(/0/g,v=>+(Math.random()<1/n))):s

<p><input id=i value=10 /><button id=t onclick="o.textContent=f(+i.value)">Run</button><p><pre id=o></pre>

Java 10, 153 152 131 byte

n->{for(int j=10,a[]=new int[j],i;j-->0;){var s="|";for(i=0;i<10;a[i++]|=Math.random()*n<1?1:0)s+=a[i];System.out.println(s+"|");}}

-18 byte berkat @ OlivierGrégoire , dan -3 lebih banyak byte dengan mengonversi Java 8 ke Java 10.

Penjelasan:

Cobalah online.

n->{                             // Method with integer parameter and no return-type
  for(int j=10,a[]=new int[j],i; //  Create the array with 10 workers (0s)
      j-->0;){                   //  Loop 10 times

    var s="|";                   //  Start a String with a wall
    for(i=0;i<10;                //  Loop `i` from 0 to 10 (exclusive)
        a[i++]                   //    After every iteration, change the current item to:
         |=                      //     If it's a 0:
           Math.random()*n<1?    //      If the random value [0:1) is below 1/n
            1                    //       Change the worker to a machine
           :                     //      Else:
            0;                   //       It remains a worker
                                 //     Else (it already is a machine)
                                 //      It remains a machine
      s+=a[i];                   //   Append the current item to the String
    System.out.println(s+"|");}} //   Print the String, with a trailing wall and new-line

Arang , 30 29 27 byte

⊞υ×χ0Ｆχ⊞υ⭆§υ±¹‽⁺1×κ⊖θＥυ⪫||ι

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

⊞υ×χ0

Dorong string 10 0detik ke daftar kosong u.

Ｆχ

Ulangi perintah berikutnya 10 kali.

⊞υ⭆§υ±¹‽⁺1×κ⊖θ

Untuk setiap karakter string terakhir, ulangi n-1kali, tambahkan 1, dan pilih karakter acak dari string. Ini memberi 1/npeluang untuk mengubah karakter menjadi 1. Hasilnya didorong ke u.

Ｅυ⪫||ι

Peta di atas daftar string, mengelilingi masing-masing dengan |, kemudian secara implisit mencetak masing-masing pada barisnya sendiri.

Python 3 , 132 byte

from random import*
w,p,c=[0]*10,'|',1/int(input())
for _ in w:print(p+''.join(map(str,w))+p);w=list(map(lambda x:x|(random()<c),w))

Cobalah online!

APL + WIN, 30 40 35 byte

Ketinggalan sedikit tentang tanpa spasi; (- diperbaiki & terima kasih kepada Uriel untuk -3 byte

Meminta input layar nomor

'|',(⍕0⍪×+⍀n=?9 10⍴n←⎕)[;2×⍳10],'|'

Penjelasan yang mirip dengan Uriel:

?9 10⍴n create a 9x10 matrix of numbers selected at random between 1 and number

×+⍀n= compare elements of matrix to number, cumulatively sum columns and signum

[;2×⍳10] take non-space columns

'|',(⍕0⍪.......,'|' concatenate a row of zeros and front and back columns of |

VBA, 144 byte

Sub f(i)
Dim w(9) As Long
For x = 0 To 9
s = "|"
For y = 0 To 9
s = s & w(y)
If i * Rnd() < 1 Then w(y) = 1
Next
Debug.Print s; "|"
Next
End Sub

Diindentasi untuk membaca lebih mudah:

Sub f(i)
    Dim w(9) As Long
    For x = 0 To 9
        s = "|"
        For y = 0 To 9
            s = s & w(y)
            If i * Rnd() < 1 Then w(y) = 1
        Next
        Debug.Print s; "|"
    Next
End Sub

Mengambil keuntungan dari 2 poin: Array VBA akan default ke Basis 0 (begitu w(9)juga dengan w(0 to 9)) dan membuat Array sebagai Long akan secara otomatis menginisialisasinya menjadi 0.

(Mengganggu, 20 byte memformat otomatis yang ditambahkan VBA tetapi tidak benar-benar diperlukan - 19 spasi dan satu semi-colon)

Saya belum melihat jawaban untuk Ruby, jadi:

Ruby , 92 byte

n=gets.to_i
z='0'*x=10
x.times do
puts'|'+z+'|'
x.times do|s|
z[s]='1' if rand(n)==0
end
end

Cobalah online!

Ruby, 67 byte

->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

Saya pikir saya telah menipu beberapa hal di sini. Pertama-tama, fungsi ini mencetak output dengan tanda kutip di sekitar setiap baris, misalnya:

pry(main)> ->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}[5]
"|0000000000|"
"|0100100000|"
"|0100100000|"
"|0100100000|"
"|0100100100|"
"|0100110100|"
"|0101110100|"
"|0111110100|"
"|1111110110|"
"|1111110110|"
=> 10

Jika ini tidak dapat diterima (mengingat bahwa ini adalah ascii-art , mungkin itulah masalahnya), berikut adalah solusi yang mencetak tanpa tanda kutip untuk 70 byte :

->n{f=[0]*10;10.times{puts"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

Penjelasan:

->n{                                                              } # defines anonymous lambda
    f=[0]*10;                                                       # initializes f to [0,0,0,...] (10)
             10.times{                                           }  # main loop
                      p"|#{f.join}|";                               # joins f and prints | before and after
                                     f.map!{|l|                 }   # maps each element of f
                                               rand>(1.0/n)? :      # if rand is greater than 1.0/n
                                                            l ?1    # keep current element or replace with '1'

PHP, 71 70 byte

penggabungan loop disimpan 5 byte (lagi):

for(;$k<91;$v|=!rand(0,$argn-1)<<$k++%10)$k%10||printf("|%010b|
",$v);

Jalankan sebagai pipa dengan -nRatau coba online .

edit 1: format tetap dan output pertama (tidak ada perubahan dalam jumlah byte berkat golf tambahan)
edit 2: Golfed satu byte lagi: Setelah pencetakan terakhir, tidak ada lagi kebutuhan untuk menembakkan siapa pun.

C # (Visual C # Interactive Compiler) , 131 byte

n=>{var r=new Random();var a=new int[10];for(int i=0;i<100;a[i%10]|=r.Next(n)<1?1:0)if(i++%10<1)Write("|"+string.Concat(a)+"|\n");}

Hei, setidaknya aku terikat dengan Jawa.

Cobalah online!