वोर-टाइल स्क्रैबल

35

संकट

आप जंगल के बीच में एक केबिन में फंस गए हैं, केवल अपने आप को मनोरंजन करने के लिए एक पुराना स्क्रैबल सेट के साथ। निरीक्षण करने पर आप देखते हैं कि स्क्रैबल अक्षर इतने खराब होते हैं, कि प्रत्येक अक्षर के लिए केवल बिंदु दिखाई देते हैं।

फिर भी आप एक खेल खेलने का फैसला करते हैं। आप बैग से सात पत्र खींचते हैं और उन्हें अपनी ट्रे पर रख देते हैं, आपकी चुनौती यह निर्धारित करना है कि वे पत्र क्या हो सकते हैं।

इसलिए आम तौर पर, अंकों की एक सूची को किसी भी संभावित स्ट्रिंग या अक्षरों की सूची में बदल दिया जाता है।

स्क्रैबल टाइल और वितरण

  • 2 खाली टाइलें (0 अंक स्कोरिंग)
  • 1 बिंदु: ई × 12, ए × 9, आई × 9, ओ × 8, एन × 6, आर × 6, टी × 6, एल × 4, एस × 4, यू × 4
  • 2 अंक: डी × 4, जी × 3
  • 3 अंक: बी × 2, सी × 2, एम × 2, पी × 2
  • 4 अंक: एफ × 2, एच × 2, वी × 2, डब्ल्यू × 2, वाई × 2
  • 5 अंक: K × 1
  • 8 अंक: J × 1, X × 1
  • 10 अंक: क्यू × 1, जेड × 1

इसलिए यदि आपके पास अंकों की सूची है [10,10,8,5,1,1,1]तो "QZJKEEE"मान्य "QQJKEEE"होगी लेकिन मान्य नहीं होगी (क्योंकि बैग में केवल 1 क्यू टाइल है)

समस्या विशिष्ट नियम

  • आप मान सकते हैं कि सभी इनपुट मान्य हैं और इसमें हमेशा 7 टाइलें होंगी (यानी यह सात 10 पॉइंट टाइल्स की सूची नहीं होगी और 9 टाइलें नहीं होंगी)
  • आप मान सकते हैं कि बैग से पहले कोई टाइल नहीं खींची गई है (इसलिए वितरण ऊपर बताए अनुसार अंग्रेजी टाइल्स का मानक वितरण है)
  • आपको एक मान्य शब्द उत्पन्न करने की आवश्यकता नहीं है, केवल अक्षरों का एक वैध स्ट्रिंग है।
  • आपकी स्ट्रिंग का क्रम तब तक अप्रासंगिक है जब तक प्रत्येक टाइल के लिए एक समान अक्षर होता है।
  • अंक मानक अंग्रेजी स्क्रैबल टाइल बिंदुओं पर आधारित हैं जैसा कि ऊपर परिभाषित किया गया है।
  • आप ऊपरी या निचले मामले में उत्पादन कर सकते हैं, एक खाली टाइल के लिए आप या तो एक अंतरिक्ष चरित्र या अंडरस्कोर '_' का उत्पादन कर सकते हैं।
  • आपका उत्तर किसी सूची, स्ट्रिंग, सरणी या अनुक्रम जैसी टाइलों के किसी उचित प्रतिनिधित्व के रूप में आउटपुट कर सकता है

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट ढीले निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों

जाहिर है जब से आप किसी भी संभावित मूल्य का उत्पादन कर सकते हैं, तो सख्त परीक्षण मामलों को परिभाषित करना मुश्किल है।

संभावित वैध वापसी मूल्य वाले कुछ मामले :

[10,0,10,5,8,8,0] -> "Q ZKJX "
[1,1,1,1,1,1,1] -> "EEEEEEE"
[1,2,3,4,5,8,0] -> "NDBHKJ "
[2,2,2,2,2,2,2] -> "DGDGDGD"

अमान्य रिटर्न मान वाले कुछ मामले :

[10,0,10,5,8,8,0] -> "Q QKJX "  - Too many Qs 
[1,1,1,1,1,1,1] -> "EEEEEE "  - Space is 0 points not 1
[1,2,3,4,5,8,0] -> "NDBH" - Too short
[1,2,3,4,5,8,0] -> "NDBHKJ  I" - Too long
[1,2,3,4,5,8,0] -> "ÉDBHKJ1" - Contains none scrabble characters
[2,2,2,2,2,2,2] -> "GDGDGDG" - Contains too many Gs (case for invalid cycling)
code-golf  string  scrabble 
— समय सीमा समाप्त डेटा
स्रोत
क्या मुझे एक स्ट्रिंग आउटपुट करने की आवश्यकता है या एक सूची ठीक है?
— माल्टसेन
आप एक सूची को आउटपुट कर सकते हैं, मैं प्रश्न को अपडेट करूंगा
— डेटा
1
मैं एक रिक्त के लिए क्या उत्पादन कर सकता हूं?
— माल्टीसेन
3
सुझाया गया टेस्ट केस: [2,2,2,2,2,2,2](एक ही मामला जहां साइकिल चलाने की विधि का उपयोग करने के Dबजाय शुरू करना महत्वपूर्ण है G)
— अरनौल
1
सूचनाएं @ हैं तो रिक्त स्थान के बिना व्यक्ति का नाम। यानी एक्सपायर्ड डाटा @ExpiredData हो जाएगा।
— ताउ

जवाबों:

8

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

@Supercat द्वारा सुझाया गया एक छोटा संस्करण

a=>a.map(o=n=>'?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31])

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

जावास्क्रिप्ट (ईएस 6),  137 ... 84 78 77  76 बाइट्स

नील की साइक्लिंग विधि का उपयोग करके 10 बाइट्स बचाए

टाइल्स की सूची लौटाता है। _खाली टाइल्स के लिए उपयोग ।

a=>a.map(o=n=>"____FHVWGDGD_K__BCMPEEEE_ZQ__XJ"[n*20%44%32+(o[n]=-~o[n])%4])

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

कैसे?

प्रत्येक अंक के लिए, हम प्रत्येक समूह की दूसरी टाइल के साथ शुरू करते हुए, बिल्कुल 4 टाइलों के समूह के माध्यम से चक्र करते हैं (यह Gबनाम के लिए महत्वपूर्ण है D):

 points | group | max. sequence
--------+-------+---------------
    0   | ____  | __
    1   | EEEE  | EEEEEEE
    2   | GDGD  | DGDGDGD
    3   | BCMP  | CMPBCMP
    4   | FHVW  | HVWFHVW
    5   | _K__  | K         \
    8   | _XJ_  | XJ         }--- these letters may only appear once each
   10   | _ZQ_  | ZQ        /

इन सभी समूहों को 31 वर्णों के एकल तार के रूप में संग्रहीत किया जाता है:

____FHVWGDGD_K__BCMPEEEE_ZQ__XJ
^   ^   ^   ^   ^   ^   ^   ^
0   4   8  12  16  20  24  28

एनबी : हमें फाइनल को स्टोर करने की आवश्यकता नहीं "_"है "_XJ_", क्योंकि इसे कभी भी एक्सेस नहीं किया जाएगा।

अंकों की संख्या n सही सूचकांक में बदल जाती है मैंn के साथ इस स्ट्रिंग में:

मैंn=((20×n)आधुनिक44)आधुनिक32

  n | *20 | mod 44 | mod 32 | group
----+-----+--------+--------+-------
  0 |   0 |    0   |    0   | ____
  1 |  20 |   20   |   20   | EEEE
  2 |  40 |   40   |    8   | GDGD
  3 |  60 |   16   |   16   | BCMP
  4 |  80 |   36   |    4   | FHVW
  5 | 100 |   12   |   12   | _K__
  8 | 160 |   28   |   28   | _XJ_
 10 | 200 |   24   |   24   | _ZQ_

प्रत्येक समूह में वर्तमान स्थिति ऑब्जेक्ट ओ में संग्रहीत है ।

— Arnauld
स्रोत
प्रत्येक बार ओ [n] 8 को आगे बढ़ाने से उन्नति के लिए एक अतिरिक्त चरित्र का खर्च आएगा, लेकिन एक को शुद्ध जीत के लिए% 4 और% 32 दोनों को & 31 के साथ बदलने की अनुमति दें। मेरा सर्वश्रेष्ठ, आपके आधार पर, होगा a=>a.map(o=n=>('?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31]))। एक छोटा, "लगभग" संस्करण है, a=>a.map(o=n=>("_EDBFK_EDCHJQEGMVXZEGPW"[n+(o[n]=5-~o[n])%24]))लेकिन उस दृष्टिकोण को मानों को 8 और 10 को 11 और 12 में मैप करने के लिए एक कॉम्पैक्ट तरीके की आवश्यकता होगी, साथ ही एक ऑफ-बाय-वन समस्या को ठीक करने के लिए स्ट्रिंग के लिए थोड़ा सा समायोजन।
— सुपरकैट
@supercat अच्छा लगता है! मैं कल इसे करीब से देखूंगा।
— अरनौलड
@supercat '_??VKWZHQFP?M?CGBGXDJD'[(n*96+(o[n]=32-~o[n]))%68%33]||'E'केवल 22 वर्णों के लुकअप स्ट्रिंग के साथ एक और दिलचस्प सूत्र है । पूर्ण कोड अभी भी आपके समाधान से 2 बाइट्स लंबा है, हालांकि।
— अरनौलड
7

चारकोल , 33 बाइट्स

⭆觧⪪”＆↖“Ｖh_z↶∕¡⌈∨₂χ¹‖◨⌊″”¶ι№…θκι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 θ                  Input array
⭆                   Map over elements and join
     ”...”          Literal string " \nE\nDG\nBCMP\nFHVW\nK\n\n\nJX\n\nQZ"
    ⪪     ¶         Split on newlines
   §       ι        Indexed by current element
  §                 Cyclically indexed by
            №…θκι   Number of times current element has already appeared
                    Implcitly print
— नील
स्रोत
5

जेली ,  31 30 27  26 बाइट्स

“ñẒẎYñ(“Nut¦hß’ṃØA;€⁶ɓṢĖœị

एक मोनडिक लिंक पूर्णांक की एक सूची को स्वीकार करता है जो वर्णों की एक सूची देता है।
- निक कैनेडी के मेरे पिछले, नीचे और मेरे सुधार का एक मिश्मश

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

आउटपुट को उसी क्रम में नहीं दिया गया है जैसा कि इनपुट (यह अनुमति है)।

एक उत्तर में भाषा के लिए अपने स्वयं के जोड़ के 2 का उपयोग करना अक्सर नहीं होता है! ( ṃऔर ɓयहां)।

कैसे?

“...“...’ṃØA;€⁶ɓṢĖœị - Link: list of integers, V     e.g. [10,1,0,3,2,1,10]
“...“...’            - list of base 250 integers          [28089224382041, 77611203526272]
          ØA         - 'ABC...XYZ'
         ṃ           - base decompress (vectorises)       ["EDMFKZZJZQ", "NGPYKZZXZZ"]
            ;€       - for €ach: concatenate:
              ⁶      -   a space                          ["EDMFKZZJZQ ", "NGPYKZZXZZ "]
               ɓ     - start a new dyadic chain with swapped arguments - i.e. f(V,that)
                Ṣ    - sort                               [0,1,1,2,3,10,10]
                 Ė   - enumerate                          [[1,0],[2,1],[3,1],[4,2],[5,3],[6,10],[7,10]]
                  œị - multi-dimensional index into       " NEGMZQ"
                       (1-based and modular)

पिछला @ 30

“²rṛʂṂø5=Ɓṇ^N¥Y»⁾tky;⁶s2ɓṢĖUœị

एक मोनडिक लिंक पूर्णांक की एक सूची को स्वीकार करता है जो वर्णों की एक सूची देता है।

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

यह किसी का आउटपुट मिश्रित-केस (यह अनुमति है) भी है।

कैसे?

“...»⁾tky;⁶s2ɓṢĖUœị - Link: list of integers, V          e.g. [10,1,0,3,2,1,10]
“...»               - compression of dictionary entries:
                    -   "end", "GMP", "fyttes", "adj", and "xci" and the string "qz"
                    -                                         "endGMPfyttesadjxciqz"
        y           - translate with:
     ⁾tk            -   ['t', 'k']                            "endGMPfykkesadjxciqz"
         ;⁶s2ɓṢĖUœị - ...
                    - ...then like the above method (except U reverses each pair of indices)
                                                              " neGMzq"
— जोनाथन एलन
स्रोत
मुझे लगता है कि आपने अपनी पहली व्याख्या में एक टाइपो बनाया। ' NWGMZQ'बहु-आयामी सूचकांक के बाद Wस्ट्रिंग में किसी भी के बिना काफी करतब होगा । ;)
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन - yws, टाइपो फिक्सड; धन्यवाद!
— जोनाथन एलन
4

पायथ - 92 86 83 81 80 75 60 52 49 42 बाइट्स

इनपुट के माध्यम से लूप्स, उपलब्ध अक्षरों को बंद करके। मेरे पास प्रत्येक पत्र में से एक है जो एक साथ उस बिंदु श्रेणी के लिए 7 देते हैं। अब पैक्ड स्ट्रिंग एन्कोडिंग का उपयोग कर।

K[M*L7c."B_êº çÑOÒ
7âCkÑ"\Lm.)@K

K                       Assign to K       
 [M                     Map list(for popping). Uses a quirk of M to splat each first
  *L7                   Map repeating each string by 7
   c      \L            Split on occurrences of 'L'
    ."..."              Packed string encoding of the needed letters
m              (Q)      Map on input (input is taken implicitly)
 .)                     Pop. This returns the first element after removing it
  @K                    Index into K
   (d)                  The loop variable is given implicitly

Btw, यह एन्कोडिंग से पहले मूल पत्र स्ट्रिंग है "_ E DG BCMP FHVW K JX QZ":।

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

— Maltysen
स्रोत
3

05AB1E , 70 52 39 38 29 26 25 बाइट्स

{ε.•3Oû}α›ηö‡.ÝŽ{•2ôÁyèNè?

-18 बाइट्स @ExpiredData का धन्यवाद ।
-13 बाइट्स @Maltysen के पाइथ उत्तर से आकार 7 तक एक ही विस्तार का उपयोग करके ।
-9 बाइट्स @JonathanAllan के जेली उत्तर का एक पोर्ट बनाकर , इसलिए उसे अपवोट करना सुनिश्चित करें!
-3 बाइट्स @Emigna की बदौलत ।

वर्णों की सूची में परिणाम, और लोअरकेस अक्षरों और रिक्त स्थान के लिए एक स्थान का उपयोग करता है।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

{                      # Sort the (implicit) input-list
 ε                     # Map each character `y` in this list to:
  .•3Oû}α›ηö‡.ÝŽ{•     #  Push compressed string "endgmpfykkzzzzjxzzqz "
                  2ô   #  Split into parts of size 2
                    Á  #  Rotate it once towards the left so the space is leading
  yè                   #  Use integer `y` to index into the string-pairs
    Nè                 #  Then get the `N`'th character of the string-pair (with automatic
                       #   wraparound), where `N` is the index of the loop

मेरा यह 05AB1E टिप देखें (अनुभाग संपीड़ित तार शब्दकोश का हिस्सा नहीं कैसे? ) को समझने के लिए क्यों .•3Oû}α›ηö‡.ÝŽ{•है "endgmpfykkzzzzjxzzqz "।

पिछले 38 बाइट्स उत्तर:

.•Mñ&Àû«ì{₆v*Å+µ-•#ðšε7∍}IvDyèн©?ε®õ.;

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

.•Mñ&Àû«ì{₆v*Å+µ-•    # Push compressed string "e dg bcmp fhvw k   jx  qz"
                  #   # Split on spaces: ["e","dg","bcmp","fhvw","k","","","jx","","qz"]
                   ðš # Prepend a space to this list
 ε7∍}                 # Extend each string to size 7:
                      #  ["       ","eeeeeee","dgdgdgd","bcmpbcm","fhvwfhv","kkkkkkk","","","jxjxjxj","","qzqzqzq"]
     Iv               # Loop `y` over the input-list:
       Dyè            #  Get the `y`'th string from a copy of the list
          н           #  Get it's first character
           ©?         #  Store it in the register, and print it without trailing newline
        ε             #  Then map each string in the list to:
         ®õ.;         #   Remove the first occurrence of the character from the register

मेरा यह 05AB1E टिप देखें (अनुभाग संपीड़ित तार शब्दकोश का हिस्सा नहीं कैसे? ) को समझने के लिए क्यों .•Mñ&Àû«ì{₆v*Å+µ-•है "e dg bcmp fhvw k jx qz"।

— केविन क्रूज़सेन
स्रोत
क्या आप उपयोग नहीं कर सकते " 0eeeeeee0ddddggg0bbccmmp0ffhhvvw0k000jx00qz"?
— समाप्ति डेटा
@ExpiredData आह, बिल्कुल। आप केवल 7 अक्षर आकर्षित करते हैं .. धन्यवाद! इसे बदल देंगे।
— केविन क्रूज़सेन
1
आप के {vबजाय 7Fऔर के yबजाय 3 बाइट्स बचा सकते हैं I{Nè।
— एमिगा
@Emigna आह, बिल्कुल .. धन्यवाद!
— केविन क्रूज़सेन
2

सी (जीसीसी) , 110 बाइट्स

_[]={0,7,14,21,0,0,22,0,24};f(char*s){for(;*s+1;s++)*s=*s?*s-1?"DDDDGGGBBCCMMPFFHHVVWKJXQZ"[_[*s-2]++]:69:32;}

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

0 और 1 के अपवादों के साथ गतिशील _स्ट्रिंग में एक इंडेक्स के रूप में सरणी का उपयोग करता है "DDDDGGGBBCCMMPFFHHVVWKJXQZ"।

तर्क -1स्कोर का एक -अलग-अलग सरणी है, जो एक-में-एक -1स्ट्रिंग में बदल जाता है ।

— LambdaBeta
स्रोत
— सीलिंगकैट
1

जेली , 34 32 बाइट्स

“¿RÇĊƈ⁸⁾%ỵṆþœsṀṂ’ṃØAṣ”A;⁶ẋ€7⁸ịḢ€

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

मैंने देखा नहीं था जब मैंने यह लिखा था तो एक छोटा जेली उत्तर था, और यह एक अलग दृष्टिकोण का उपयोग करता है इसलिए मुझे लगा कि यह पोस्ट करने लायक था।

2 बाइट बचाने के लिए @JonathanAllan को धन्यवाद!

— निक केनेडी
स्रोत
बेस-डीकंप्रेसन का उपयोग करके ṃ, आप 2 बाइट्स बचा
— जोनाथन एलन
1

पायथन 3 , 178 142 135 127 112 117 बाइट्स

def f(l):
 d=list(map(list,"  _EEEEEEE_DDDDGGG_BBCCMMP_FFHHVVW_K___JX__QZ".split('_')))
 return[d[i].pop()for i in l]

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

-1 बाइट cdlane के लिए धन्यवाद

गणितनंदन का सही धन्यवाद

— Noodle9
स्रोत
111 में
— cdlane
d=list(map(list,"...".split('_')))एक और बाइट बचाने के लिए
— cdlane
इस फ़ंक्शन को fसंभवतः नाम देने की आवश्यकता नहीं है, इसलिए आप 2 बाइट्स बचा सकते हैं। हालांकि, fकी प्रविष्टियों का उपभोग करता है d, इसलिए मुझे यकीन नहीं है कि यह सर्वसम्मति की आवश्यकता पर फिट बैठता है कि "समारोह को अक्सर मनमाने ढंग से, बिना ... पुन: प्रयोज्य होना चाहिए ... प्रस्तुत करने के साथ कोई अन्य कोड।" (उदाहरण के लिए, f([10,0,10,5,8,8,0])एक से अधिक बार चलने से त्रुटि होगी।) कृपया यहाँ मेटा चर्चा देखें: codegolf.meta.stackexchange.com/a/7615/36885
— mathmandan
0

अजगर 2 , 102 बाइट्स (या शायद 95?)

(पायथन 3. के लिए भी ठीक है)

lambda a:''.join([r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a))

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

मुझे नहीं लगता कि निम्नलिखित स्वीकार्य होगा:

lambda a:[[r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a)]

यह दूसरा संस्करण जैसे आउटपुट देगा ['__', 'JX', 'QZ', 'K']। इसलिए अक्षर सही होंगे, लेकिन उन्हें बिंदु मान द्वारा एकत्र किया जाएगा। (यदि यह स्वीकार्य था, तो यह 7 बाइट्स को बचाएगा।)

— mathmandan
स्रोत
0

PHP , 101 बाइट्स

$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($argv as$t){echo$c=($d=$b[$t])[0];$b[$t]=substr($d,1).$c;}

स्टैंडअलोन प्रोग्राम के रूप में, कमांड लाइन के माध्यम से इनपुट:

$ php s.php 10 0 10 5 8 8 0
"Q_ZKJX_"

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

या एक समारोह के रूप में 112 बाइट्स

function($a){$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($a as$t)$b[$t]=substr($d=$b[$t],1).$c[]=$d[0];return$c;}

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

उत्पादन

[10,0,10,5,8,8,0]   "Q_ZKJX_"
[1,1,1,1,1,1,1]     "EEEEEEE"
[1,2,3,4,5,8,0]     "EDBFKJ_"
[2,2,2,2,2,2,2]     "DGDGDGD"
— 640KB
स्रोत
0

पर्ल 6 , 63 बाइट्स

*>>.&{(<_ E DG BCMP FHVW K _ _ JX _ QZ>[$_]x 7).comb[%.{$_}++]}

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

<_ E DG BCMP FHVW K _ _ JX _ QZ> # array indexed on tile value
(<...>[$_] x 7)     # pull letters for this value, repeat 7 times to catch E
          %         # anonymous stateful hash
           .{$_}    # element for this tile value
                ++  # post increment value to move position
       .comb[...]   # characters to array, pull this incrementing index

इसलिए अनिवार्य रूप से यह प्रत्येक टाइल मूल्य के लिए ऑफ़सेट्स की तलाश रखता है और उन्हें आवश्यक रूप से बढ़ाता है, उपलब्ध सेट से एक चरित्र को खींचने के लिए ऑफ़सेट का उपयोग करता है।

— फिल एच
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.