22

Minecraft 1.12 कल जारी किया जाएगा, तो चलो जश्न मनाएं!

एक गैर-नकारात्मक पूर्णांक N में लगने वाला कोड लिखें जो Minecraft में किसी वस्तु की संख्या का प्रतिनिधित्व करता है । यह एक तरह से खिलाड़ियों के लिए अधिक सहायक है, चेस्ट, स्टैक, और आइटम एन की संख्या देने में सहायक है। प्रारूप का उपयोग करें

XcYsZi

कहा पे

X चेस्ट की संख्या है जिसे आप पूरी तरह से एन आइटम से भर सकते हैं,
Y चेस्ट भरने के बाद बची हुई वस्तुओं से आप ढेरों को भर सकते हैं,
Z यदि चेस्ट और स्टैक भरने के बाद बची हुई वस्तुओं की संख्या।

ध्यान दें कि:

64 आइटम एक स्टैक में फिट होते हैं। (हम उन वस्तुओं को अनदेखा कर देंगे जो 16 को स्टैक या स्टैक नहीं करते हैं।)
एक सीने में 27 ढेर लगे। (ये सिंगल चेस्ट हैं, डबल चेस्ट नहीं।)

तो यह कभी भी समझ में नहीं आएगा अगर Y26 से अधिक है या Z63 से अधिक है।

प्रारूप के साथ एक चेतावनी यह है कि यदि कुछ शून्य है, तो वह शब्द मुद्रित नहीं है।

इसलिए, उदाहरण के लिए, यदि Yशून्य Xऔर Zनॉनजरो थे, तो प्रारूप जैसा दिखेगा XcZi।
इसी तरह अगर Yऔर Zशून्य और थे Xअशून्य, प्रारूप होगा Xc।
यहाँ अपवाद तब है जब N शून्य है। फिर 0iएक खाली स्ट्रिंग के बजाय आउटपुट है।

आप मान सकते हैं कि सभी N आइटम एक ही प्रकार के हैं, इसलिए सभी स्टैकेबल हैं।

आप तीन नंबरों की सूची या टपल का उत्पादन नहीं कर सकते हैं। आपको उस क्रम में सटीक "csi" संकेतन के साथ एक स्ट्रिंग देना होगा, जिसमें कोई स्थान या अल्पविराम नहीं होगा।

संदर्भ के लिए, यहां एक छाती पूरी तरह से वस्तुओं के ढेर से भरी हुई है:

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

in -> out
0 -> 0i
1 -> 1i
2 -> 2i
62 -> 62i
63 -> 63i
64 -> 1s
65 -> 1s1i
66 -> 1s2i
127 -> 1s63i
128 -> 2s
129 -> 2s1i
200 -> 3s8i
512 -> 8s
1337 -> 20s57i
1664 -> 26s
1727 -> 26s63i
1728 -> 1c
1729 -> 1c1i
1791 -> 1c63i
1792 -> 1c1s
1793 -> 1c1s1i
4096 -> 2c10s
5183 -> 2c26s63i
5184 -> 3c
5200 -> 3c16i
9999 -> 5c21s15i
385026 -> 222c22s2i
1000000000 -> 578703c19s

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

1

जेली , 26 24 बाइट्स

d64d1¦27Fża¥“csi”Fḟ0ȯ⁾0i

एक पूर्ण कार्यक्रम संख्या ले रहा है और परिणाम प्रिंट कर रहा है।
यह मुझे बहुत लंबा लगता है ...

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें।

कैसे?

अद्यतन करने ...

d64d1¦27Fża¥“csi”Fḟ0ȯ⁾0i - Main link: number n
 64                      - literal 64
d                        - divmod (whole divisions and remainder)
      27                 - literal 27
    1¦                   - apply to index 1 (the whole division from above)
   d                     - divmod
        F                - flatten into a single list (of three items i.e. [(n/64)/27, (n/64)%27, n%64]
            “csi”        - literal ['c','s','i']
           ¥             - last two links as a dyad:
         ż               -   zip
          a              -   logical and (any 0s in the divmod result become [0,0], others become [integer, character]
                 F       - flatten (from list of three lists to one list)
                  ḟ0     - filter discard zeros
                     ⁾0i - literal ['0','i']
                    ȯ    - logical or (non-vectorising)
                         - implicit print (smashed together representation, so [578703,'c',19,'i'] prints as 578703c19i)

— जोनाथन एलन
स्रोत

7

रेटिना , 49 48 41 बाइट्स

.+
$*i
i{64}
s
s{27}
c
(.)\1*
$.&$1
^$
0i

इसे ऑनलाइन आज़माएं! इसमें अंतिम को छोड़कर सभी परीक्षण मामले शामिल हैं, यदि यह TIO को अधिभारित करता है। संपादित करें: @MartinEnder के लिए 7 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
$*i

इनपुट नंबर को is का उपयोग करके unary में कनवर्ट करें ।

i{64}
s

64 आइटम एक स्टैक भरते हैं।

s{27}
c

27 ढेर एक छाती भरते हैं।

(.)\1*
$.&$1

किसी भी चेस्ट, स्टैक या शेष आइटम को दशमलव में परिवर्तित करें, लेकिन एक प्रत्यय के रूप में छोड़ दें।

^$
0i

यदि इनपुट शून्य था, तो परिणाम बनाएं 0i।

— नील
स्रोत

ओह मेरी यह वास्तव में एकता में बदलने के लिए फिर बदल रहा है?

— जोनाथन एलन

@JonathanAllan मैंने एक स्पष्टीकरण जोड़ा है (मेरे पास पहले खेद नहीं था)। (स्पष्टीकरण लिखते हुए मुझे एक बाइट भी बचाने का अवसर मिला!)

— नील

2

आप $.&इस तरह के कुछ दोहराव से बच सकते हैं : tio.run/##FYs9DsIwDIX3d46ASpGq2Ens5ARcAiEQYsjCQNmqnjjLb9veD@/-

— मार्टिन

@MartinEnder आह, मैं सोच रहा था कि क्या यह iइसके बजाय सीधे रूपांतरित करने योग्य होगा 1, लेकिन मैं बस उस सरलीकरण को नहीं देख सकता था, धन्यवाद!

— नील

4

सी #, 84 86 बाइट्स

_=>(_/1728>0?_/1728+"c":"")+((_-=_/1728*1728)/64>0?_/64+"s":"")+(_%64>0?_%64+"i":"")

इनलाइन घटाव पर ध्यान दें, यह महसूस नहीं हुआ कि यह संभव था लेकिन i--समझ में नहीं आया कि ऐसा क्यों किया गयाi-=10

संपादित करें:

_=>_>0?(_/1728>0?_/1728+"c":"")+((_%=1728)/64>0?_/64+"s":"")+(_%64>0?_%64+"i":""):"0i"

0 एज केस और सुझाव के लिए।

— LiefdeWen
स्रोत

1

+1। और अगर आप बदल सकते हैं _-=_/1728*1728करने के लिए _%=1728गोल्फ में कुछ बाइट्स।

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

इसके अलावा, आप किनारे के मामले के बारे में भूल गए 0, जिसके परिणामस्वरूप परिणाम होना चाहिए 0iऔर वर्तमान में कुछ भी नहीं उत्पादन कर रहा है। बस एक जोड़ने से _>0?...:"0i"यह ठीक हो जाएगा।

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

@KevinCruijssen आह, धन्यवाद।

— लाईफ़डेवेन जू

3

+1 के लिए >_>संपादित 1

— caird coinheringaahing

3

पायथन 3 , 87 बाइट्स

lambda n:g(n//1728,"c")+g(n//64%27,"s")+g(n%64,"i")or"0i"
g=lambda n,s:(str(n)+s)*(n>0)

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

— लीक नन
स्रोत

पायथन 2 में इसे 82 बाइट्स तक छोटा किया जा सकता है, सरल विभाजन ( / इसके बजाय //) का उपयोग करके और इसके बजाय बैकटिक ऑपरेटर का उपयोग करने के लिएstr(...)

— गेबर फेकेट

3

05AB1E , 24 बाइट्स

1728‰`64‰)˜…csiøvyJ¬0Êi?

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

व्याख्या

1728‰                      # input divmod 1728 (64*27)
     `                     # split as separate with mod result on top of stack
      64‰                  # divmod 64
         )˜                # wrap stack in flattened list
           …csiø           # zip with the string "csi"
                vy         # for each
                  J        # join amount with storage-type
                   ¬0Êi    # if head != 0
                       ?   # print

— Emigna
स्रोत

यह 0इनपुट के मामले में कैसे काम करता है , और ऐसा क्यों होता है कि एक अनुगामी न्यूलाइन भी छपती है जबकि अन्य इनपुट नहीं होते?

— जोनाथन एलन

@JonathanAllan: यदि कुछ भी प्रिंट नहीं किया गया है, तो 05AB1E निष्पादन के अंत में स्टैक के शीर्ष को प्रिंट करता है (न्यूलाइन के साथ)। फॉर-लूप्स सूचियों को अलग करता है और तत्वों को स्टैक में धकेलता है, इसलिए मुद्रित नहीं की गई कोई भी वस्तु स्टैक में जोड़ी जाएगी। लूप के अंत में 0मामले 0iमें स्टैक के शीर्ष पर होगा ( 0sऔर 0cइसके नीचे होगा) और मुद्रित किया जाएगा।

— इमीना

3

सी, 85 87 105 110 111 112 बाइट्स

#define a(x,y)x?printf("%d%c",x,y+99):0;
f(z){a(z/1728,0)a(z%1728/64,16)!z+a(z%64,6)}

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

कोड भी नकारात्मक संख्याओं पर ठीक से काम करता है। अब आप सर्वर ओपी ब्लॉक का भुगतान कर सकते हैं!

— कीउ गण
स्रोत

पीपीसीजी पर मानक के रूप में कार्य स्वीकार्य हैं

— बीटा डिके

3

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

n=>[n+1,1728,64,1].map((v,i,a)=>(v=n%a[--i]/v|0)?v+'csi'[i]:'').join``||'0i'

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

कोड स्निपेट दिखाएं

let f =

n=>[n+1,1728,64,1].map((v,i,a)=>(v=n%a[--i]/v|0)?v+'csi'[i]:'').join``||'0i'

console.log(f(0)) // -> 0i
console.log(f(1)) // -> 1i
console.log(f(2)) // -> 2i
console.log(f(62)) // -> 62i
console.log(f(63)) // -> 63i
console.log(f(64)) // -> 1s
console.log(f(65)) // -> 1s1i
console.log(f(66)) // -> 1s2i
console.log(f(127)) // -> 1s63i
console.log(f(128)) // -> 2s
console.log(f(129)) // -> 2s1i
console.log(f(200)) // -> 3s8i
console.log(f(512)) // -> 8s
console.log(f(1337)) // -> 20s57i
console.log(f(1664)) // -> 26s
console.log(f(1727)) // -> 26s63i
console.log(f(1728)) // -> 1c
console.log(f(1729)) // -> 1c1i
console.log(f(1791)) // -> 1c63i
console.log(f(1792)) // -> 1c1s
console.log(f(1793)) // -> 1c1s1i
console.log(f(4096)) // -> 2c10s
console.log(f(5183)) // -> 2c26s63i
console.log(f(5184)) // -> 3c
console.log(f(5200)) // -> 3c16i
console.log(f(9999)) // -> 5c21s15i
console.log(f(385026)) // -> 222c22s2i
console.log(f(1000000000)) // -> 578703c19s

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

जावा 8, 86 बाइट्स

i->i>0?(i/1728>0?i/1728+"c":"")+((i%=1728)/64>0?i/64+"s":"")+((i%=64)>0?i+"i":""):"0i"

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

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

2

सीजेएम , 31 बाइट्स

ri64md\27md@]"csi"]z{0=},"0i"e|

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

व्याख्या

ri                               e# Read an int from input.
  64md                           e# Divmod by 64, gives total #stacks, #items.
      \27md                      e# Divmod total #stacks by 27, gives #chests, #stacks.
           @                     e# Bring #items back to top.
            ]                    e# Wrap in an array: [#chests, #stacks, #items]
             "csi"               e# Push "csi".
                  ]z             e# Zip with the other array.
                    {0=},        e# Filter out subarrays where the first element is 0.
                         "0i"e|  e# Logical or with "0i". An input of 0 gives an empty array
                                 e# from the rest of the program, in that case yield "0i"
                                 e# instead.

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

1

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

n=>[n/1728|0,(n/64|0)%27,n%64].map((a,i)=>a?a+'csi'[i]:'').join``||'0i'

स्निपेट:

कोड स्निपेट दिखाएं

f=
n=>[n/1728|0,(n/64|0)%27,n%64].map((a,i)=>a?a+'csi'[i]:'').join``||'0i'

console.log(f(0)) // 0i
console.log(f(1)) // 1i
console.log(f(2)) // 2i
console.log(f(62)) // 62i
console.log(f(63)) // 63i
console.log(f(64)) // 1s
console.log(f(65)) // 1s1i
console.log(f(66)) // 1s2i
console.log(f(127)) // 1s63i
console.log(f(128)) // 2s
console.log(f(129)) // 2s1i
console.log(f(200)) // 3s8i
console.log(f(512)) // 8s
console.log(f(1337)) // 20s57i
console.log(f(1664)) // 26s
console.log(f(1727)) // 26s63i
console.log(f(1728)) // 1c
console.log(f(1729)) // 1c1i
console.log(f(1791)) // 1c63i
console.log(f(1792)) // 1c1s
console.log(f(1793)) // 1c1s1i
console.log(f(4096)) // 2c10s
console.log(f(5183)) // 2c26s63i
console.log(f(5184)) // 3c
console.log(f(5200)) // 3c16i
console.log(f(9999)) // 5c21s15i
console.log(f(385026)) // 222c22s2i
console.log(f(1000000000)) // 578703c19s

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

1

पायथन 2 , 82 बाइट्स

मैंने गैबर फ़ेचे की टिप्पणी को ऊपर से एक कार्यकारी उदाहरण में बदल दिया:

lambda n:g(n/1728,"c")+g(n/64%27,"s")+g(n%64,"i")or"0i"
g=lambda n,s:(`n`+s)*(n>0)

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

— एंड्रयू यू बेकर
स्रोत

1

बैच, _{347 335 283 246 234 202 199 191} 189 बाइट्स

@set/al=%1,c=%1/1728,l-=c*1728,s=l/64,l-=s*64
@set c=%c%c
@set s=%s%s
@set i=%l%i
@if %c%==0c set c=
@if %s%==0s set s=
@if %i%==0i set i=
@if %c%%s%%i%.==. set i=0i
@echo(%c%%s%%i%

— stevefestl
स्रोत

आप जानते हैं कि आप एक set/aअभिव्यक्ति में विभाजन और मापांक का उपयोग कर सकते हैं , है ना?

— नील

@ मुझे पता है, मैं अभी उसी तरह से काम कर रहा हूं

— स्टीवनफेस्टल

@ नील मैं केवल एक मुद्दे का सामना कर रहा हूं: if %c%==0 (set c=)else remयह कोड मुझे " (setअपेक्षित नहीं है"

— स्टेवेफस्टल

हुह, कि ग खाली होने पर ही होना चाहिए ...

— नील

1

JFTR मेरा समाधान (एक ही लंबाई के साथ दो अलग-अलग विविधताएं) 122 बाइट्स तक नीचे है।

— नील

0

ब्रिंगोल्फ , 71 बाइट्स

V"isc"R#@!%>93*!*,>,>!/!*,>,$_-,>,>,/<$_<&,!?_v@R:>|!?_v@R:>|!?_v@R:>|;

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

बिल्कुल नहीं, लेकिन यह काम करता है

— Skidsdev
स्रोत

0

गणितज्ञ, 155 बाइट्स

A=AppendTo;G={};P=Print;(z=Mod[t=Mod[#,1728],64];If[(x=⌊#/1728⌋)>0,A[G,{x,c}]];If[(y=⌊t/64⌋)>0,A[G,{y,s}]];If[z>0||#==0,A[G,{z,i}]];Row@Flatten@G)&

— J42161217
स्रोत

0

PHP , 84 बाइट्स

<?=($c=($a=$argn)/1728^0)?$c.c:"",($s=$a/64%27)?$s.s:"",($i=$a%64)||$c+$s<1?$m.i:"";

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

PHP , 93 बाइट्स

$i-=64*$s=($i-=1728*$c=($i=$argn)/1728^0)/64^0;echo$c?$c.c:"",$s?$s.s:"",$i||$c+$s<1?$i.i:"";

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

— जार्ग हुल्सरमन
स्रोत

0

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

इनपुट स्तंभ में संग्रहीत किया जाता है एक पूर्व मौजूदा तालिका के टी ।

SELECT IIF(a=0,'0i',REPLACE(IIF(a<1728,'',STR(a/1728)+'c')
                           +IIF(a%1728<64,'',STR(a%1728/64)+'s')
                           +IIF(a%64=0,'',STR(a%64)+'i'),' ',''))FROM t

पठनीयता के लिए लाइन ब्रेक, बाइट कुल में गिना नहीं। एमएस SQL सर्वर 2012 पर परीक्षण किया गया।

संपादित करें 1: बदल गया एकाधिक REPLACEकरने के लिए IIF5 बाइट्स को बचाने के लिए। अंतिम REPLACEअभी भी आवश्यक है क्योंकि STRकष्टप्रद पैड 10 वर्णों के रिक्त स्थान के साथ।

संपादित करें 2: एसक्यूएल के लिए अनुमोदित इनपुट प्रकार का उपयोग करके नियमों का पालन करने के लिए निर्धारित, एक नामित तालिका में संग्रहीत मान । इसके लिए यह लागत बाइट्स की FROMभी आवश्यकता SELECTहै PRINT। एक अनावश्यक parens छोड़ने के द्वारा 2 बाइट्स पुनर्प्राप्त।

— BradC
स्रोत

0

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

param($i)("$(($c=[math]::floor($i/1728)))c","")[!$c]+("$(($s=[math]::floor(($i%1728)/64)))s","")[!$s]+"$($i%64)i"

यह पावरशेल के दर्द के बिंदु को बहुत सटीक रूप से हिट करता है।

[math]::Floor इसके लिए आवश्यक है क्योंकि PS डिफ़ॉल्ट रूप से बैंकर्स राउंडिंग करता है।

पीएस टर्नेरी भी अन्य भाषाओं की तुलना में बाइट्स का भार उठाती है, एक साधारण अशांति ( $a="This";$a?$a:"That"या "This"?:"That") करने के लिए हमें क्या करना चाहिए(($a="This"),"That")[$a-ne$null]

फिर हमें इन सभी को दो बार उपयोग करने की आवश्यकता है, और पॉवरशेल के डिफ़ॉल्ट ऑपरेशन ऑर्डर के कारण कुछ स्थानों पर ब्रैकेट के दूसरे सेट में भी जोड़ना होगा।

— colsw
स्रोत

0

पायथन 2 , 77 बाइट्स

lambda n:''.join(`k`+c for k,c in zip([n/1728,n/64%27,n%64],'csi')if k)or'0i'

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

— XNOR
स्रोत

0

डीसी , 76 बाइट्स

?dddsf[1728/n99P]sc1728/0<c1728%ddd[64/n115P]si64/0<i[64%n105P]sy64%0<ylf0=y

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

— आर। कप
स्रोत

सीएसआई: Minecraft आइटम

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

जेली , 26 24 बाइट्स

कैसे?

रेटिना , 49 48 41 बाइट्स

सी #, 84 86 बाइट्स

संपादित करें:

पायथन 3 , 87 बाइट्स

05AB1E , 24 बाइट्स

सी, 85 87 105 110 111 112 बाइट्स

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

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

जावा 8, 86 बाइट्स

सीजेएम , 31 बाइट्स

व्याख्या

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

पायथन 2 , 82 बाइट्स

बैच, 347 335 283 246 234 202 199 191 189 बाइट्स

ब्रिंगोल्फ , 71 बाइट्स

गणितज्ञ, 155 बाइट्स

PHP , 84 बाइट्स

PHP , 93 बाइट्स

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

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

पायथन 2 , 77 बाइट्स

डीसी , 76 बाइट्स

बैच, _{347 335 283 246 234 202 199 191} 189 बाइट्स