कार्यक्रम

आपको दो तार दिए जाते हैं, ए और बी । A वह वर्तमान स्थिति है जिस पर आपका टाइमर चालू है, और B वह स्थिति है जिस पर आपका टाइमर बंद हो जाएगा। दोनों स्ट्रिंग्स फॉर्म m: ss में हैं । आपको एक प्रोग्राम लिखना चाहिए जो निर्धारित समय की मात्रा को निर्धारित करता है जिसे m: ss या mm: ss के रूप में भी स्वरूपित किया जाना चाहिए ।

उदाहरण

0:00 0:01 -> 0:01
0:55 1:00 -> 0:05
1:45 3:15 -> 1:30

code-golf string date

— हंसी मजाक करना
स्रोत

1

डीसी में इनपुट को गलत तरीके से पढ़ा जाता है, क्योंकि :एक कमांड (कोड दर्शन के रूप में डेटा) है। क्या मुझे इसके बजाय रिक्त स्थान का उपयोग करने की अनुमति है या क्या मुझे इसका उत्तर देने के लिए अन्य भाषा खोजने की आवश्यकता है?

— शेषमारा

1

है 01:30वैध उत्पादन? (अग्रणी शून्य)

— लुइस मेन्डो

2

हां, मैं इसे मान्य मानूंगा। मैं वर्णन संपादित करूँगा।

— जोश

1

@seshoumara इनपुट में एक कॉलोन होना चाहिए।

— जोश

मी के लिए अधिकतम मूल्य क्या है ?

— डिजिटल ट्रामा

92

एक्सेल, 6 बाइट्स

=B1-A1

मान लें कि A सेल में है A1और B सेल में हैB1

— रिले
स्रोत

37

नहीं ... नहीं ... मैं एक्सेल जीत नहीं पाऊंगा। +1 तुम व्यक्‍तिगत व्‍यक्‍तिगत हो।

— मैजिक ऑक्टोपस अर्ने

2

उस रद्द करें, जिसे |vy':¡05AB1E में बूट किया गया है, मैं कुछ भी नहीं कर सकता ... मुझे लगता है कि एक्सेल ईमानदारी से इसे जीत सकता है, और कुछ भी नहीं जो उस प्रारूप को स्वचालित रूप से बताता है जिसे मैं जानता हूं।

— मैजिक ऑक्टोपस अर्ने

7

कैसे? कैसे? एक्सेल कैसे जीत रहा है? मेरे दिमाग को अब

— शोषण

2

यदि मीटर 23 से अधिक है, तो स्वरूपण काम नहीं करता है। उदाहरण के लिए यदि मैं 45:45A1 में और 22:22B1 में टाइप करता हूं , तो इसका परिणाम 23:23:00 Edit Nevermind है - मी के लिए अधिकतम अपेक्षित मूल्य 9. है

— डिजिटल ट्रॉमा

4

@EngineerToast जो भी डिफ़ॉल्ट स्वरूपण मेरे लिए काम किया है। मैंने केवल इनपुट में टाइप किया, एक अलग सेल में स्थानांतरित किया, सूत्र टाइप किया और एंटर मारा।

— रिले

15

MATL , 17 7 बाइट्स

YOd15XO

इनपुट स्ट्रिंग्स का एक सेल ऐरे है, फॉर्म में {'1:45' '3:15'}या {'1:45', '3:15'}।

इसे ऑनलाइन आज़माएं!

व्याख्या

YO     % Input cell array of strings (implicit). Convert to serial date numbers
d      % Difference
15XO   % Convert to format 15, i.e. 'HH:MM'. Display (implicit)

— लुइस मेंडो
स्रोत

ओह अच्छा! लगे रहो!

— स्वेवर

8

बैश + कोरुटिल्स, 44 39 बाइट्स

tr : \ |dc -e?r60*+r-r60*-60~rn58PA~rnn

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: परीक्षण मामले (अंतिम उदाहरण) के रूप में "1:45 3:15" का उपयोग करना। मैं उद्धरणों में मध्यस्थ कदम दिखाता हूं।

tr : \ |         # replace colons with spaces: "1 45 3 15"
dc -e?           # start dc script, push input to LIFO stack: "15 3 45 1"
     r60*+            # turn time B to total seconds: "195 45 1"
     r-r60*-          # turn time A to total seconds and get difference: "90"
     60~r             # turn difference (time left) to minutes and seconds: "1 30"
     n58P             # pop and print minutes, print colon (ASCII code 58): "30"
     A~rnn            # print seconds. Padding with zeroes is done by dividing by
                      #10 (A), and printing the quotient and the remainder.

ध्यान दें कि मैं जाँच नहीं करता कि क्या मिनट के मूल्य को शून्य पैडिंग की आवश्यकता है, क्योंकि ओपी ने कहा कि अधिकतम मूल्य m9 है।

नीचे मेरा मूल 44 बाइट्स का उत्तर है, जो dateसेकंड में छोड़े गए कुल समय को m:ssप्रारूप में बदलने के लिए कमांड का उपयोग करता है।

date -d@`tr : \ |dc -e?r60*+r-r60*-p` +%M:%S

— seshoumara
स्रोत

2

@DigitalTrauma धन्यवाद। लेकिन अंत में, मैं डेट कमांड को हटाने और डीसी में फॉर्मेट प्रिंटिंग को भी करने में कामयाब रहा।

— शेषमारा

1

44 को पार करके नियमित 44 की तरह दिखता है।

— रिले

1

@ रिले मैं 44 के आसपास के स्थानों को भी पार कर गया, जो कि पहले स्थान पर होना चाहिए था।

— शीशमारा

1

codegolf.meta.stackexchange.com/a/7427/57100

— रिले

7

पायथन 2, 90 87 83 80 बाइट्स

जैसे इनपुट लेता है "2:45","5:01"।

a,b=[60*int(s[-5:-3])+int(s[-2:])for s in input()]
print'%d:%02d'%divmod(b-a,60)

इसे ऑनलाइन आज़माएं

— mbomb007
स्रोत

आप 3 बाइट्स बचाने के लिए इनपुट पर मैप का उपयोग कर सकते हैं

— रॉड

आप कई बाइट्स को बचाने के लिए सूची समझ का उपयोग कर सकते हैं:a,b=[60*int(s[-5:-3])+int(s[-2:])for s in input()]

— फेलिप नारदी बतिस्ता

अगर मैं गलत नहीं हूँ, तो आप तीन अतिरिक्त वर्णों को दो अंतिम पंक्तियों की जगह बचा सकते हैं print'%d:%02d'%divmod(b-a,60):)

— Morwenn

5

सी, 86

f(a,b,c,d){scanf("%d:%d%d:%d",&a,&b,&c,&d);d+=(c-a)*60-b;printf("%d:%02d",d/60,d%60);}

एसटीडीआईएन से अंतरिक्ष-अलग समय पढ़ता है।

इसे ऑनलाइन आज़माएं ।

— डिजिटल आघात
स्रोत

5

बैच, 74 बाइट्स

@set t=%2-(%1)
@set/as=%t::=*60+1%,m=s/60,t=s/10%%6
@echo %m%:%t%%s:~-1%

:समय के साथ प्रतिस्थापित करना *60+1इसे एक अभिव्यक्ति में परिवर्तित करता है जो सेकंड की संख्या की गणना करता है। बैच ऑक्टल के रूप में अग्रणी शून्य की व्याख्या करता है, इसलिए मैं 1दशमलव रूपांतरण सुनिश्चित करने के लिए सेकंड के लिए प्रीपेन्ड करता हूं ; सौभाग्य से दोनों को 1रद्द कर दिया।

— नील
स्रोत

5

सी, 112 100 बाइट्स

11 बाइट बचाने के लिए @betseg को धन्यवाद और एक बाइट को बचाने के लिए @ जोहान डू टिट को धन्यवाद!

i,j;f(char*a,char*b){i=atoi(b)-atoi(a);j=atoi(b+2)-atoi(a+2);j<0?i--,j+=60:0;printf("%d:%02d",i,j);}

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत

1

आप के %s%dसाथ बदल सकते हैं %02dऔर निकाल सकते हैं ?:। इसे ऑनलाइन आज़माएं!

— betseg

1

scanf()कई पूर्णांकों को पढ़ने के लिए आपका मित्र है।

— डिजिटल ट्रामा

1

आप 1 बाइट का उपयोग करके भी बचा सकते हैं: j <0? I ++, j + = 60: 0;

— जोहान डू टिट

@DigitalTrauma Nononono, यह आमतौर पर उन तर्कों का उपयोग करने के लिए कम है जो उसने किए थे।

— मैथ्यू रो

5

MySQL, 13 22 बाइट्स

select right(timediff(B,A),5)

में समय की उम्मीद है Aऔर B।

— टाइटस
स्रोत

4

बैश + जीएनयू उपयोगिताओं, 43

date -d@`date -f- +%s|dc -e??r-60/p` +%M:%S

इसे ऑनलाइन आज़माएं ।

व्याख्या

         date -f- +%s                        # read in 2 line-delimited dates and output as number of seconds since the epoch
                     |dc -e                  # pipe to dc expression:
                           ??                # - read 2 input numbers
                             r-              # - reverse and subtract
                               60/           # - divide by 60
                                  p          # - output
        `                          `         # evaluate date|dc command
date -d@                             +%M:%S  # format seconds difference and output

नोट को dc60 से विभाजित करें, क्योंकि dateइनपुट को M: SS के बजाय H: MM के रूप में पढ़ता है।

— डिजिटल आघात
स्रोत

4

ECMAScript 6, 99 91 85 बाइट्स

इकलौती रेखा:

f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);t=n=>~~(n/60)+":"+n%60;t(f(b)-f(a));

थोड़ा स्वरूपित:

f=s=>s.split`:`.reduce((a,e,i)=>a+e*(!i?60:1),0);
t=n=>~~(n/60)+":"+n%60;
t(f(b)-f(a));

मुझे लगता है कि वहां कुछ बचत हो सकती है .. लेकिन मैं उन्हें वर्तमान में नहीं देख रहा हूं।

संपादित करें - टिप्पणियों में उत्कृष्ट सुझाव।

— Forty3
स्रोत

आप चारों ओर कोष्ठक हटा सकते हैं s।

— अर्जुन

और इसके बजाय s.split(":"), आप नए सिंटैक्स का उपयोग कर सकते हैं s.split<backtick>:<backtick>:।

— अर्जुन

4

PHP, 55 53 बाइट्स

<?=date('i:s',($s=strtotime)($argv[2])-$s($argv[1]));

कमांड लाइन तर्कों से इनपुट लेता है

— टाइटस
स्रोत

1

53 बाइट्स:<?=date('i:s',($x=strtotime)($argv[2])-$x($argv[1]));

— इस्माईल मिगुएल

4

सी #, 72 बाइट्स

using System;a=>b=>((DateTime.Parse(b)-DateTime.Parse(a))+"").Remove(5);

तार के रूप में इनपुट लेता है। b="3:15" a="1:45"।

स्पष्टीकरण:

क्योंकि प्रारूप DateTime.Parse()में एक तारीख लौटाता है hh:mm:ss, मैं परिणाम का उपयोग करके स्ट्रिंग में पार्स करने में सक्षम हूं +"", फिर अनुगामी ट्रिम कर दीजिए :00।

यह साथ काम करता है hh:mmक्योंकि एक मिनट में 60 सेकंड और एक घंटे में 60 मिनट दोनों हैं।

0:01 0:00 रिटर्न 0:01

1:00 0:55 रिटर्न 0:05

3:15 1:45 रिटर्न 1:30

— ओलिवर
स्रोत

3

दुर्भाग्य से, DateTime.Parse()इनपुट ले रहा है - उदाहरण के लिए, 1:45- के रूप में hh:mmऔर नहीं mm:ss, परिणामस्वरूप आउटपुट - ए 1:45 और बी के लिए 3:15 - [01:30:00]( hh:mm:ss) ( निर्दिष्ट के साथ भीCultureInfo.InvariantCulture )। "0:" + a/bपार्स करते समय आपको जोड़ना पड़ सकता है ।

— आहूमन

@ गौमन आह, अच्छा कैच। मैंने ट्राइलिंग को समाप्त कर दिया :00।

— ओलिवर

मेरा मानना है कि आपको ;अंत की आवश्यकता है , आप करीने का उपयोग कर सकते हैं अर्थात a=>b=>, आपको पूरी तरह से योग्यता प्राप्त करने DateTimeया शामिल करने की आवश्यकता है using System;।

— TheLethalCoder

3

Rebol, 5 बाइट्स

b - a

यह मानते हुए कि मैंने कोई नियम नहीं छोड़ा है।

Rebol में कई शाब्दिक डेटा प्रकारों के लिए अंकगणित अंतर्निहित हैं। यह रेड जैसे अपने वंशजों पर भी लागू होता है

— जीकी आई
स्रोत

मैं इस भाषा के बारे में कुछ नहीं जानता।

— मैजिक ऑक्टोपस Urn

@carusocomputing chat.stackoverflow.com/rooms/291/rebol

— Geeky I

2

पायथ, 47 45 44 40 बाइट्स

J.U-Zbm+*60hdedmmvkcd\:.z%"%d:%02d".DJ60

नए सिरे से इनपुट को अलग कर देता है।

Pyth के पास इसके लिए कोई उपयोगी बिल्ट-इन नहीं था। मैं कुछ फैंसी eval () सामान की कोशिश की, लेकिन स्पष्ट रूप से Pyth के साथ *या किसी भी अग्रणी शून्य सामान नहीं कर सकते हैं । मुझे उम्मीद की तुलना में यह अधिक समय तक मिला। कुछ बाइट्स आउटपुट में एक अग्रणी शून्य जोड़ने पर खर्च किए जाते हैं। कम से कम मैं बैश से छोटा हूं। पूछे जाने पर स्पष्टीकरण देंगे।

इसे इस्तेमाल करे!

वैकल्पिक समाधान, 48 बाइट्स

J.U-Zbm+*60hdh_dmmvkcd\:.z
K%J60
s[/J60\:*<KT\0K

— KarlKastor
स्रोत

2

हास्केल, 98 127 86 बाइट्स

r(m:_:s)=60*read[m]+read s
a#b|(d,m)<-divMod(r b-r a)60=show d++':':['0'|m<=9]++show m

इसे ऑनलाइन आज़माएं!

लेकिन मुझे आश्चर्य है कि इसके लिए कुछ पुस्तकालय कार्य हैं

EDIT: आयात को हटा दिया गया, एक त्रुटि भी तय की गई जहाँ उसने m: s के बजाय m: s दिखाया

इसके अलावा, अच्छी तरह से स्वरूपित संस्करण:

convert :: String -> Integer
convert (a:_:b) = (read [a])*60+(read b)

diffTime :: String -> String -> String
diffTime s1 s2 = let (d,m) = divMod (c b-c a) 60 in show d ++ ":" ++ pad2d m

pad2d :: Int -> String
pad2d n = ['0'|n<=9]++show n

EDIT2: गोल्फ (30?) बाइट्स लाईकोनी के लिए धन्यवाद! साथ ही कुछ अन्य मिसकैरेज किए। बाइट्स।

— सामान्य प्रदर्शन का नाम
स्रोत

1

आपको हमें यह बताना चाहिए कि यह कौन सी भाषा है और यह कितने बाइट्स का उपयोग करती है।

— जोश

2

हाँ, मेरा मतलब पोस्ट को दबाने का नहीं था (जो टेक्स्ट बॉक्स से टैब + दर्ज करना जानता था, वह आपका जवाब देगा?)

— सामान्य प्रदर्शन का नाम

वही दृष्टिकोण, 86 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

मैं एक सूची समझ का उपयोग करने के बारे में नहीं सोचा था। धन्यवाद :)

— जेनेरिक डिस्प्ले नाम

2

टी-एसक्यूएल, 238 बाइट्स

CREATE PROCEDURE d @a time,@b time AS BEGIN DECLARE @d int DECLARE @s varchar(2) SET @d=datediff(s,@a,@b);SET @s=CAST(@d%3600/60 AS VARCHAR(3)) SELECT CAST(@d/3600 AS VARCHAR(3))+':'+(SELECT CASE WHEN LEN(@s)=1 THEN '0'+@s ELSE @s END)END

उपयोग:

EXEC d '00:55','01:00'

PostGres उदाहरण देखने से पहले मैंने महसूस किया कि मैंने SQL में कई गोल्फिंग प्रयास नहीं देखे थे इसलिए मैंने इसे T-SQL में देखा। अब मुझे पता है कि आपको SQL: D में बहुत अधिक गोल्फ क्यों नहीं दिख रहा है

— motosubatsu
स्रोत

2

CJam , 34 33 25 बाइट्स

मार्टिन एंडर के लिए 8 बाइट्स बचाए गए!

{r':/60b}2*\m60mds2Te[':\

इसे ऑनलाइन आज़माएं!

व्याख्या

{             e# Start of block
 r            e#  Read one time from input
 ':/          e#  Split on colons, gives [minutes seconds]
 60b          e#  Convert from base 60
}2*           e# Run this block 2 times
              e# At this point, we have the two times in seconds on the stack
\             e# Swap top elements
m             e# Subtract
60md          e# Divmod the result by 60, to convert back to minutes and seconds
s             e# Convert the seconds to a string
2Te[          e# Pad it to 2 characters by adding 0s to the left (T = 0)
':            e# Push a colon character
\             e# Swap top elements, bringing seconds back to the top

— बिजनेस कैट
स्रोत

2

टी-एसक्यूएल, 82 बाइट्स

select left(cast(dateadd(minute, datediff(S,'0:00','0:01')/60,114) as time(0)), 5)

— Nelz
स्रोत

2

अजगर, 160 बाइट्स

मैं अभी भी गोल्फ को कोड करने के लिए नया हूं, अगर किसी के पास कोई सुझाव है, तो मैं इसकी सराहना करूंगा।

a, b = input()
def z(x):
    x = x.split(":")
    return int(x[0])*60+int(x[1])
a, b = z(a),z(b)
s, m = b-a,0
while s >= 60:
    s -= 60
    m += 1
print(str(m)+":"+str(s))

— JKonowitz
स्रोत

1

नमस्कार और हमारी साइट पर आपका स्वागत है। ऐसा लगता है कि आप अपने प्रोग्राम के लिए प्रीइंस्टीट्यूशनल वेरिएबल्स से इनपुट ले रहे हैं। हालांकि IO के लिए यह चूक के तहत अनुमति नहीं है । मैं इस विशिष्ट मामले के माध्यम से इनपुट लेने की सलाह दूंगा raw_input()।

— गेहूं जादूगर

1

आरईएक्सएक्स, 79 बाइट्स

arg t q
say right(time(,f(q)-f(t),s),5)
f:return time(s,'00:'right(arg(1),5,0))

— idrougge
स्रोत

1

अजगर, २,

%"%d:%02d".Dh.+misMcd\:60Q60

यह कोशिश करो ।

व्याख्या

                   cd\:      # lambda to split c on ":"
                 sM          # map to convert string to int
               mi      60Q   # convert from base-60 list to give seconds
             .+              # delta of the two seconds values
            h                # single-item list to int
          .D              60 # divmod by 60
%"%d:%02d"                   # format output

— डिजिटल आघात
स्रोत

1

जावा 7, 164 बाइट्स

String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

स्पष्टीकरण:

String c(String a, String b){       // Method with two String parameters and String return-type
  long s = x(b,1) - x(a,1)          //  Get difference in seconds from input times
           + (x(b,0) - x(a,0)*60,   //   plus the difference in minutes times 60 to get the seconds
    m = s%60;                       //  Temp variable of seconds after we've subtracted the minutes (used multiple times)
  return (s/60)                     //  Return minutes
    +":"                            //   plus ":"
    +(m>9?m:"0"+m);                 //   plus seconds (with a leading 0 if necessary)
}                                   // End of method

long x(String s,int i){             // Separate ethod with String and Integer parameters and long return-type
  return new Long(s.split(":")[i];  //  Return either minutes or seconds of String parameter based on the index
}                                   // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  String c(String a,String b){long s=x(b,1)-x(a,1)+(x(b,0)-x(a,0))*60,m=s%60;return(s/60)+":"+(m>9?m:"0"+m);}long x(String s,int i){return new Long(s.split(":")[i]);}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("0:00", "0:01"));
    System.out.println(m.c("0:55", "1:00"));
    System.out.println(m.c("1:45", "3:15"));
  }
}

आउटपुट:

0:01
0:05
1:30

— केविन क्रूज़सेन
स्रोत

1

TXR लिस्प, 101 बाइट्स

$ txr -e '(awk (:let (s "%M:%S"))
               ((mf (time-parse s))
                (prn (time-string-local (- [f 1].(time-utc) [f 0].(time-utc)) s))))'
13:49 14:49 
01:00
0:13 1:47
01:34
5:01 5:59
00:58
6:00 6:00
00:00
6:00 5:00
59:00

संघनित: (awk(:let(s"%M:%S"))((mf(time-parse s))(prn(time-string-local(-[f 1].(time-utc)[f 0].(time-utc))s))))

— Kaz
स्रोत

आपको एक बाईटेकाउंट चाहिए, और मुझे नहीं लगता कि यह पूरी तरह से गोल्फ है।

— R

1

रूबी , 91 बाइट्स

require'time';t=Time;d=t.parse($*[1])-t.parse($*[0]);puts t.at(d.to_i).utc.strftime '%H:%M'

इसे ऑनलाइन आज़माएं!

कमांड लाइन तर्कों से इनपुट लेता है।

मंगलाचरण:

ruby outatime.rb $A $B

उदाहरण:

ruby outatime.rb 1:45 3:15

आउटपुट:

1:30

— sfgeorge
स्रोत

साइट पर आपका स्वागत है!

— DJMcMayhem

1

पॉवरशेल 47 बाइट्स

param($s,[timespan]$f)($f-$s).ToString("h\:mm")

सरल समय गणित और घंटे और सेकंड स्ट्रिंग को कवर।

— मैट
स्रोत

0

जावास्क्रिप्ट, 88 बाइट्स

a=>b=>{c=a.split`:`,d=b.split`:`;return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

बृहदान्त्र पर आदानों को विभाजित करता है

c=a.split`:`,d=b.split`:`;

स्ट्रिंग को इंट में परिवर्तित करता है

+c[0]

मिनट मूल्य हो जाता है

+c[0]-d[0]-d[1]>c[1]?1:0

दूसरा मूल्य पाता है

(+c[1]+60-d[1])%60

स्ट्रिंग मिनट लौटाता है: सेकंड

return +c[0]-d[0]-d[1]>c[1]?1:0+":"+(+c[1]+60-d[1])%60

— fənɛtɪk
स्रोत

शेष समय कितना है?

कार्यक्रम

उदाहरण

एक्सेल, 6 बाइट्स

MATL , 17 7 बाइट्स

व्याख्या

बैश + कोरुटिल्स, 44 39 बाइट्स

पायथन 2, 90 87 83 80 बाइट्स

सी, 86

बैच, 74 बाइट्स

सी, 112 100 बाइट्स

MySQL, 13 22 बाइट्स

बैश + जीएनयू उपयोगिताओं, 43

व्याख्या

ECMAScript 6, 99 91 85 बाइट्स

इकलौती रेखा:

थोड़ा स्वरूपित:

PHP, 55 53 बाइट्स

सी #, 72 बाइट्स

स्पष्टीकरण:

Rebol, 5 बाइट्स

पायथ, 47 45 44 40 बाइट्स

वैकल्पिक समाधान, 48 बाइट्स

हास्केल, 98 127 86 बाइट्स

टी-एसक्यूएल, 238 बाइट्स

CJam , 34 33 25 बाइट्स

टी-एसक्यूएल, 82 बाइट्स

अजगर, 160 बाइट्स

आरईएक्सएक्स, 79 बाइट्स

अजगर, २,

व्याख्या

जावा 7, 164 बाइट्स

TXR लिस्प, 101 बाइट्स

रूबी , 91 बाइट्स

मंगलाचरण:

उदाहरण:

पॉवरशेल 47 बाइट्स

जावास्क्रिप्ट, 88 बाइट्स

स्पष्टीकरण: