นี่คือหนึ่งที่ง่าย: พิมพ์ ASCII แผนภูมิแกนต์

กำหนดช่วงงาน '(เริ่มต้น - Tuples เวลาสิ้นสุด) พิมพ์ Gantt Timeline ในรูปแบบของ-ตัวละครสำหรับแต่ละระยะเวลางาน - แต่ละงานในบรรทัดใหม่

ตัวอย่าง

สมมติว่างานของฉันอยู่ในช่วง28->35, 34->40, 39->44Gantt จะมีลักษณะเช่นนี้:

                            -------
                                  ------
                                       -----

ข้อมูลจำเพาะ

• คุณสามารถเขียนโปรแกรมเต็มฟังก์ชั่นที่มีชื่อหรือฟังก์ชั่นที่ไม่ระบุชื่อ
• โปรแกรมของคุณ / ฟังก์ชั่นควรจะยอมรับงานผ่าน STDIN หรือเป็นข้อโต้แย้ง
• งานแต่ละงานควรจะแสดงเป็นสตริงของstart->endที่startและendเป็นจำนวนเต็ม งานถูกคั่นด้วยช่องว่างหรือเครื่องหมายจุลภาค อีกวิธีหนึ่งคุณอาจได้รับเป็น Tuple of Integers หรือ Array / Collection 2 Integers (ตัวอย่างเช่นใน JavaScript คุณสามารถรับมัน[start,end]- เป็นสิ่งที่ได้รับอนุญาต)
• ควรสนับสนุนจำนวนงานที่ไม่เป็นลบ (อาร์กิวเมนต์) ใด ๆ
• เพื่อให้ชัดเจนไม่อนุญาตให้มีการรวบรวมอาร์กิวเมนต์งานเดียว คุณสามารถแยกอาร์กิวเมนต์สตริงเดี่ยวหรือสนับสนุนอาร์กิวเมนต์ของภารกิจที่มากกว่าหรือมากกว่าก็ได้ โดยที่ task คือ tuple หรือชุดของขนาด 2
• คุณสามารถสันนิษฐานได้ว่าป้อนข้อมูลที่ถูกต้องเท่านั้น ซึ่งหมายความว่าแต่ละงานมีระยะเวลาบวก
• ค่าส่งคืนไม่สำคัญรหัสของคุณจะต้องพิมพ์เส้นเวลาบน STDOUT
• เอาท์พุท: ต่องานstartช่องว่างตามด้วยเครื่องหมายขีดกลางและ(end-start)\n
• ไม่จำเป็นต้องพูดบรรทัดเอาท์พุทควรสั่งให้สอดคล้องกับคำสั่งอินพุต (งาน)
• ต่อท้ายช่องว่างก่อนที่\nจะอนุญาตถ้านั่นช่วยคุณ

กรณีทดสอบ

Input:
(empty)

Output:
(empty)


Input:
0->7,5->6,3->6

Output:
-------
     -
   ---


Input:
5->20,5->20,2->10,15->19

Output:
     ---------------
     ---------------
  --------
               ----

การชนะ

• นี่คือโค้ดกอล์ฟเพื่อให้ความยาวรหัสน้อยที่สุด (เป็นไบต์) ชนะ
• ตามเนื้อผ้าไทเบรกเกอร์โพสต์ก่อนหน้านี้
• "ช่องโหว่มาตรฐานไม่ตลกอีกต่อไป"

-----

แก้ไข

ตามที่คุณหลายคนเข้าใจว่ามันได้รับอนุญาตให้มีอาร์กิวเมนต์การรวบรวมงานเดี่ยวและเนื่องจากไม่มีความแตกต่างระหว่างความต้องการนั้นและความต้องการ varargsดั้งเดิมตอนนี้จึงอนุญาตให้มีอาร์กิวเมนต์การรวบรวมเดี่ยวหากคุณไม่ต้องการใช้ ตัวเลือก varargs หรือในกรณีที่ภาษาของคุณไม่รองรับ varargs

CJam, 16 14 ไบต์

q~{S.*~'-e]N}/

สิ่งนี้คาดว่าจะมีรายการของรายการเป็นอินพุต ตัวอย่างเช่น:

[[5 20] [5 20] [2 10] [5 19]]

ให้:

     ---------------
     ---------------
  --------
     --------------

มันทำงานอย่างไร

q~                      e# Read the input and parse it as a list of list
  {         }/          e# Go over each item in the list in a for loop
   S                    e# S is basically this string - " "
    .*                  e# Multiply each item of the first list with the corresponding index
                        e# item of the second list. This basically repeats the space
                        e# X times where X is the first number of the tuple. The second
                        e# number remains untouched as the second list was only 1 char long
      ~                 e# Unwrap the space string and second number containing list
       '-               e# Put character '-' on stack
         e]             e# Make sure that the space is filled with - to its right so as to
                        e# make the total length of the string equal to the second number
           N            e# Put a newline. After all iterations, the result is printed
                        e# automatically to STDOUT

ลองออนไลน์ได้ที่นี่

Python 2, 39 ไบต์

วิธีแก้ปัญหาตรงไปตรงมาโดยใช้การคูณสตริง :)

for x,y in input():print' '*x+'-'*(y-x)

ยอมรับอินพุตที่จัดรูปแบบดังนี้:

((5,20),(5,20),(2,10),(15,19))

ตรวจสอบที่นี่

Brainfuck, 120 115 111 ไบต์

อย่างน้อยก็สั้นกว่า Java :) อินพุตคือรายการของไบต์โดยที่แต่ละคู่เป็นบรรทัดเดียวในแกนต์

++++[->++++++++<]>[->+>+<<]++++++++++>>+++++++++++++>+[,[->+>+<<]>>[-<<+>>],<[->-<<<<.>>>]>[-<<<.>>>]<<<<<.>>>]

ลองดู

http://copy.sh/brainfuck/

ชุดที่สิ้นสุดของการป้อนข้อมูลจะมีมูลค่าchar \0ตัวอย่างอินพุต: \5\20\5\20\2\10\15\19.

โปรดทราบว่าการตั้งค่า end-of-input ให้เป็น\0จะมีผลข้างเคียงที่จะไม่มีการอ่านอินพุตเพิ่มเติม (และหยุดโปรแกรม) เมื่ออินพุตมีจำนวนศูนย์ ใน BF ไม่มีวิธีอื่นที่จะรู้ได้เมื่อข้อมูลหมด

คำอธิบาย *

++++[->++++++++<]>  #Store <space> at index 1                   
[->+>+<<]           #Move index 1 to index 2 and 3
++++++++++          #Increment index 1 to <newline>
>>                  #Move to index 3
+++++++++++++       #Increment index 3 to <dash>    
>                   #Move to (empty) index 4
+                   #Increment to start the main loop
[                   #Main loop
,                   #Read first number to index 4
[->+>+<<]>>[-<<+>>] #Copy index 4 to index 5 (index 5 can now be altered)
,                   #Read second number (the number pair is now stored at index 5 and 6)
<                   #Move to first number (index 5)
[->-<<<<.>>>]       #Decrement index 5 and 6 and print <space> until index 5 equals zero
>                   #move to second input (index 6)
[-<<<.>>>]          #Decrement index 6 and print <dash> until index 6 equals zero
<<<<<.>>>           #Print <newline> and move to index 4 (original first number)
]                   #End of main loop

_{* (คุณจะไม่สามารถรวบรวม / เรียกใช้เนื่องจากความคิดเห็น)}

Pyth, 36 22 19 14 ไบต์

นี่เป็นโปรแกรม Pyth แรกของฉัน Jakube ช่วยกันตี 5 ไบต์!

FNQ<s*V" -"NeN

[[5,20], [5,20], [2,10], [15,19]]โดยคาดว่าการป้อนข้อมูลในรูปแบบ

คุณสามารถลองออนไลน์ได้

C ++ 14, 69 ไบต์

[]{int a,b;for(;cin>>a>>b;){cout<<setw(b)<<string(b-a,'-')+'\n';}}();

การเล่นกอล์ฟเป็นครั้งแรกนี่เป็นปัญหาที่ดีในการเริ่มต้น!

K, 18 ไบต์

`0:" -"@{&x,y-x}.'

คาดหวังรายการคู่เป็นอินพุต:

  `0:" -"@{&x,y-x}.'(0 7;5 6;3 6)
-------
     -
   ---
  `0:" -"@{&x,y-x}.'(5 20;5 20;2 10; 15 19)
     ---------------
     ---------------
  --------
               ----
  `0:" -"@{&x,y-x}.'()

ผมแกะแต่ละ ( ') tuple ใช้จุดใช้ ( .) เพื่อให้ภายในแลมบ์ดาฉันมีการเข้าถึงค่าเริ่มต้นและสิ้นสุดเป็นxและyตามลำดับ จากนั้นฉันรวมกันใหม่เหล่านี้เป็น tuple (เริ่มต้น, ความยาว) ( x,y-x) และใช้ "where" ( &) สิ่งนี้ทำให้ฉันชอบ:

  {&x,y-x}.'(0 7;5 6;3 6)
(1 1 1 1 1 1 1
 0 0 0 0 0 1
 0 0 0 1 1 1)

จากนั้นฉันก็ต้องทำดัชนีให้เป็นอาเรย์ 2 ตัวอักษรโดยใช้เมทริกซ์แบบ ragged ( " -"@) แล้วส่งมันทั้งหมดไปที่ stdout ( 0:)

JavaScript ( ES6 ), 63

แก้ไข 3 ไบต์บันทึก thx @apsillers
63 ไบต์ไม่นับการมอบหมายให้ F เนื่องจากอนุญาตให้ใช้ฟังก์ชันที่ไม่ระบุชื่อ

ฟังก์ชั่นที่มีจำนวนตัวแปรพารามิเตอร์ตามที่ร้องขอ
ฟังก์ชั่นที่มีรายการงานเป็นพารามิเตอร์เดียว

ทดสอบการเรียกใช้ตัวอย่างด้านล่าง (เป็น EcmaScript 6, Firefox เท่านั้น)

F=l=>l.map(t=>console.log(' '.repeat(l=t[0])+'-'.repeat(t[1]-l)))

// TEST

// for this test, redefine console.log to have output inside the snippet
console.log = (...x) => O.innerHTML += x + '\n';

console.log('* Empty'); F([]);
console.log('\n* [0,7],[5,6],[3,6]'); F([[0,7],[5,6],[3,6]])
console.log('\n* [5,20],[5,20],[2,10],[15,19]');F([[5,20],[5,20],[2,10],[15,19]]);

<pre id=O></pre>

สกาลา, 67 63 59 ไบต์

(r:Seq[(Int,Int)])⇒for((s,e)←r)(println(" "*s+"-"*(e-s)))

การใช้งาน: res0()หรือres0(Seq(28->35, 34->40, 39->44))อื่น ๆ

ขอบคุณ gilad สำหรับการโกน 4 ไบต์ใช้สำหรับนิพจน์!

Ruby: 35 ตัวอักษร

->*t{t.map{|s,e|puts' '*s+?-*(e-s)}

วิ่งตัวอย่าง:

irb(main):001:0> ->*t{t.map{|s,e|puts' '*s+?-*(e-s)}}.call [0,7], [5,6], [3,6]
-------
     -
   ---

อัปเดตเพื่อยอมรับอาร์เรย์สององค์ประกอบหลายรายการหนึ่งรายการสำหรับแต่ละงานที่จะแสดง (ฉันคิดว่านั่นเป็นสิ่งที่ข้อกำหนดที่อัปเดตคาดไว้)

Javascript (ES6), 61/66 ตัวอักษร

คำตอบของฉันใกล้เคียงกับคำตอบที่ @ edc65 แต่มีการปรับปรุงบางอย่าง เนื่องจากไม่อนุญาตให้ใช้งานในอาเรย์เดี่ยว (ดังนั้นจะมีการเรียกใช้ฟังก์ชันดังนี้a([3,4], [7,15], [0,14], [10, 15]):), แก้ไขให้ถูกต้อง ( 66 ตัวอักษรโดยไม่มีการกำหนดชื่อ):

a=(...x)=>x.map(([c,d])=>console.log(' '.repeat(c)+'-'.repeat(d-c)))

และถ้าอนุญาตให้ใช้อาร์กิวเมนต์อาเรย์หนึ่งตัว (ดังนั้น fn จะเรียกสิ่งนี้:) ดังนั้นa([[3,4], [7,15], [0,14], [10, 15]])มันจะเป็น ( 61 อักขระโดยไม่มีการมอบหมาย):

a=x=>x.map(([c,d])=>console.log(' '.repeat(c)+'-'.repeat(d-c)))

SWI-Prolog ขนาด 55 ไบต์

a([[A,B]|C]):-tab(A),writef("%r",[-,B-A]),nl,C=[];a(C).

ตัวอย่าง: a([[5,20],[5,20],[2,10],[15,19]]).ผลลัพธ์

     ---------------
     ---------------
  --------
               ----

Haskell, 76 ไบต์

(#)=replicate
f i=putStr$g=<<(read$'[':i++"]")
g(s,e)=s#' '++(e-s)#'-'++"\n"

รูปแบบอินพุตเป็นสตริงของจุลภาค tuples "(1,2),(3,4)"แยกออกจากกันเช่น

ตัวอย่างการใช้งาน:

*Main> f "(1,2),(3,4)" 
  -
    -

*Main> f "(0,7),(5,6),(3,6)" 
-------
     -
   ---

วิธีการทำงาน: สำหรับการแยกวิเคราะห์อินพุตฉันใส่สตริงอินพุต[และ]และใช้readฟังก์ชันดั้งเดิมของ Haskell สำหรับรายการของจำนวนเต็มทูเปิล ส่วนที่เหลือเป็นเรื่องง่าย: สำหรับแต่ละ tuple (s,e)ใช้sช่องว่างตามด้วยe-sเครื่องหมายขีดคั่นตามด้วยการขึ้นบรรทัดใหม่และต่อกันเป็นสตริงเดียว พิมพ์.

Haskell, 59 ไบต์

ด้วยรูปแบบอินพุตที่ผ่อนคลาย:

(#)=replicate
f=putStr.(g=<<)
g(s,e)=s#' '++(e-s)#'-'++"\n"

ตอนนี้ก็ใช้เวลารายการ tuples f [(0,7),(5,6),(3,6)]e กรัม

ทำงานตามที่อธิบายไว้ข้างต้น แต่ไม่มีการแยกวิเคราะห์อินพุต

จูเลีย 44 ไบต์

x->for t=x a,b=t;println(" "^a*"-"^(b-a))end

สิ่งนี้จะสร้างฟังก์ชั่นนิรนามที่ยอมรับอาร์เรย์ของสิ่งอันดับเป็นอินพุตและพิมพ์ไปยัง STDOUT

คำอธิบาย Ungolfed +:

function f(x)
    # Loop over the tasks (tuples) in x
    for t in x
        # Assign a and b to the two elements of t
        a,b = t

        # Print a spaces followed by b-a dashes on a line
        println(" "^a * "-"^(b-a))
    end
end

ตัวอย่าง:

julia> f([(5,20), (5,20), (2,10), (15,19)])
     ---------------
     ---------------
  --------
               ----

julia> f([(0,7), (5,6), (3,6)])
-------
     -
   ---

julia> f([])

JavaScript (ES6), 106 85 80 68 ไบต์

ตามข้อกำหนดที่อัปเดตแล้วรายการงานได้รับการยอมรับแล้ว

a=>a.reduce((p,v)=>p+=' '.repeat(z=v[0])+'-'.repeat(v[1]-z)+"\n",'')

ใช้ศูนย์หรือมากกว่าอาร์กิวเมนต์: 80 ไบต์

(...a)=>{s='';a.map(v=>s+=' '[r='repeat'](z=v[0])+'-'[r](v[1]-z)+"\n");return s}

ความพยายามเริ่มต้น 106 ไบต์:

(...a)=>{for(i=-1,s='',r='repeat';a.length>++i;){s+=' '[r](a[i][0])+'-'[r](a[i][1]-a[i][0])+"\n"}return s}

C: 108 ไบต์

void g(int*l){for(int c=0;*l>=0;c=!c,l++){if(!c)l[1]-=*l;while(l[0]-->0)putchar(c?45:32);c?putchar(10):0;}}

Ungolfed:

void gantt(int*l) {
    for (int c = 0; *l >= 0; c = !c, l++) {
        if (!c) l[1] -= *l;
        while (l[0]-- > 0) putchar(c? 45 : 32);
        c? putchar(10) : 0;
    }
}

-1ใช้เวลาเป็นพารามิเตอร์รายการของจำนวนเต็มยกเลิกโดย ตัวอย่างเช่น:

int list[] = {
    28, 35,
    34, 40,
    39, 44,
    -1
};
gantt(list);

มันใช้cเพื่อสลับระหว่างการเขียนช่องว่างและขีดกลาง

Perl: 42 41 ตัวอักษร

เพียงแค่มีวิธีแก้ปัญหาอย่างน้อยหนึ่งรายการด้วยการแยกสตริงด้วย

s!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge

วิ่งตัวอย่าง:

bash-4.3$ perl -pe 's!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge' <<< '0->7,5->6,3->6'
-------
     -
   ---

Java 8, 280 275 246 204 195 185 180 ไบต์

void g(String t){for(String s:t.split(",")){String[]a=s.split("->");s="";Integer i;for(i=0;i<i.valueOf(a[0]);i++)s+=" ";for(;i<i.valueOf(a[1]);i++)s+="-";System.out.println(s);};};

เมธอดที่รับสตริงอินพุตที่คั่นด้วยเครื่องหมายคอมม่าและพิมพ์แผนภูมิ ascant Gantt ที่เป็นผลลัพธ์ไปยัง stdout

ขอบคุณ durron597 และ masterX244 ที่ช่วยฉันประหยัด 10 ไบต์

Java, 187 181 197 183 101 ไบต์

void g(int[][]g){for(int[]i:g)for(int j=0;j<i[1];System.out.print(j++<i[0]?" ":j==i[1]?"-\n":"-"));}

Ungolfed (เรียงลำดับ):

void g(int[][] g){
    for(int[] i : g)
        for(int j = 0; j < i[1]; System.out.print(j++ < i[0] ? " " : j == i[1] ? "-\n" : "-"));
}

รับข้อมูลเป็นอาร์เรย์ 2d ของints ขอบคุณmasterX244 ที่ชี้ให้เห็นว่าสิ่งนี้ได้รับอนุญาตตามกฎ

เยลลี่ , 13 9 ไบต์

ạ\⁾ -xµ€Y

ลองออนไลน์!

[[5, 20], [5, 20], [2, 10], [15, 19]]จะเข้าเป็น

-4 ไบต์ขอบคุณ Erik

APL (Dyalog Classic)ขนาด 12 ไบต์

↑('-'\⍨≤∘⍳)/

ลองออนไลน์!

APL ไม่มี varargs ดังนั้น arg ที่นี่คือเมทริกซ์ Nx2 เดียว

JavaScript (ES8), 54 ไบต์

a=>a.map(([x,y])=>"-".repeat(y-x).padStart(y)).join`
`

ลองออนไลน์

PowerShell 3.0 4836 ไบต์

$args|%{" "*$_[0]+"-"*($_[1]-$_[0])}

ขอบคุณ Mazzy สำหรับการประหยัด 12 ด้วยวิธีที่ดีกว่าที่จะผ่านในรายการ

รหัสเก่าและคำอธิบาย:

&{param($b="")$b|%{" "*$_[0]+"-"*($_[1]-$_[0])}}

รับอาร์กิวเมนต์เป็นรายการของ tuples เช่น (5,20), (5,20), (2,10), (15,19) ต้องเริ่มต้น $ b เป็นค่าที่จะดูแลสตริงว่างเนื่องจากจะเข้าสู่บล็อก foreach อย่างใดเมื่อถูกเรียกโดยไม่มีอินพุต

R , 117 90 75 ไบต์

function(y)for(i in 1:ncol(y))cat(" "<y[1,i],"-"<diff(y)[i],"
")
"<"=strrep

ลองออนไลน์!

จูเซปเป้เล่นกอล์ฟอย่างน้อย 29 ไบต์จากคำตอบเดิมของฉัน!

ความคิดที่จะตรงไปตรงมา: พิมพ์เป็นจำนวนมาก" "เท่าที่จำเป็นตามมาด้วยเป็นจำนวนมาก"-"ตามที่ต้องการ อินพุตเป็น2*Lเมทริกซ์ที่มี L จำนวนคู่ ฟังก์ชั่น vectorized diffจะใช้ในการรับจำนวน "-"

VBA (Excel), 99 90 ไบต์

ใช้หน้าต่างทันทีและ[A1]ป้อนข้อมูลเช่น0-1,2-5

ขอบคุณ @TaylorSott สำหรับการตัดไบต์

b=Split([A1]):For x=0To Ubound(b):c=Split(b(x),"-"):?Spc(c(0)-0)String(c(1)-c(0),"-"):Next

CoffeeScript, 104 82, 65 ไบต์

รายการงาน (ES6): 65 ไบต์

(a)->a.map (v)->console.log ' '.repeat(v[0])+'-'.repeat v[1]-v[0]

รายการงาน (ตัวแปร ES5): 82 ไบต์

(a)->a.map (v)->j=-1;s='';s+=(if j<v[0]then' 'else'-') while++j<v[1];console.log s

อาร์กิวเมนต์เป็นศูนย์หรือมากกว่า: 104 ไบต์

()->[].slice.call(arguments).map((v)->j=-1;s='';s+=(if j<v[0]then' 'else'-')while++j<v[1];console.log s)

Unminified:

() -> [].slice.call(arguments).map( # convert to array-like arguments to array and loop
 (v) ->
  j = -1 # counter
  s = '' # initialize string
  s += (if j < v[0] then ' ' else '-') while ++j < v[1]
  console.log s # print to STDOUT
)

PHP, 94 91 ไบต์

รับรายการของงาน (เช่น[[5,20],[5,20],[2,10],[15,19]]) ขอบคุณ @IsmaelMiguel สำหรับคำเตือนของชื่อฟังก์ชันตัวแปร

function x($a){$r=str_repeat;foreach($a as$v){echo$r(' ',$v[0]).$r('-',$v[1]-$v[0])."\n";}}

ความพยายามเริ่มต้น: 94 ไบต์

function x($a){foreach($a as$v){echo str_repeat(' ',$v[0]).str_repeat('-',$v[1]-$v[0])."\n";}}

PHP, 89 ตัวอักษร (ฟังก์ชั่นร่างกาย)

function gantt($x){array_walk($x,function($a){echo str_pad(str_repeat('-',$a[1]-$a[0]),$a[1],' ',0)."\n";});}

ฉันกำลังจะไปอ่านสตริง แต่ในขณะที่มีหลายรายการที่กำลังทำอาร์เรย์ของคู่จำนวนเต็มฉันคิดว่าฉันจะตามหลังชุดสูทเพื่อความกะทัดรัด

สำหรับทูเปิลแต่ละตัว$aในอาเรย์$xฉันสะท้อนสตริงของเครื่องหมายขีดคั่นซ้ำหลาย$a[1] - $a[0]ครั้งเพิ่มจำนวนขึ้น$a[1]ด้วยช่องว่าง ขึ้นบรรทัดใหม่ที่จำเป็น

Gema : 47 ตัว

<D>-\><D><y>=@left{$1;}@repeat{@sub{$2;$1};-}\n

วิ่งตัวอย่าง:

bash-4.3$ gema '<D>-\><D><y>=@left{$1;}@repeat{@sub{$2;$1};-}\n' <<< '0->7,5->6,3->6'
-------
     -
   ---

PostgreSQL: 160 ตัวอักษร

create function g(int[])returns text as
$$select string_agg(lpad(repeat('-',$1[x][2]-$1[x][1]),$1[x][2]),chr(10))from generate_subscripts($1,1)x$$
language sql;

วิ่งตัวอย่าง:

manatwork=# create function g(int[])returns text as
manatwork-# $$select string_agg(lpad(repeat('-',$1[x][2]-$1[x][1]),$1[x][2]),chr(10))from generate_subscripts($1,1)x$$
manatwork-# language sql;
CREATE FUNCTION

manatwork=# select g(array[[0,7],[5,6],[3,6]]);
-------
     -
   ---

J, 21 ไบต์

(' -'#~{.,-~/)"1 ::''

ungolfed

(' -' #~ {. , -~/)"1 ::''

นี้เป็นหลักเพียงคำกริยาสำเนาของเจ#แต่เรากำลังคัดลอกหัวอักขระช่องว่างของรายชื่อ{.จำนวนครั้งและยัติภังค์อักขระ "องค์ประกอบรายการที่ 2 ลบองค์ประกอบรายการที่ 1" -~/จำนวนครั้ง: น่าเศร้าที่บังคับให้เราต้องระบุอันดับอย่าง"1ชัดเจนและเราจำเป็นต้องใช้ Adverse ::เพื่อจัดการกับกรณีที่ว่างเปล่า

ลองออนไลน์!