我的世界1.12将于明天发布，让我们一起庆祝吧！

编写包含非负整数N的代码，该整数表示Minecraft中某物的项数。以对玩家更有用的方式输出，给定等于N的箱子，筹码和物品数量。使用格式

XcYsZi

哪里

• X 是您可以完全填满N个物品的箱子数，
• Y 是您可以在填满箱子后剩余的物品可以堆满的堆叠数，
• Z 装满箱子和箱子后剩余的物品数量。

注意：

• 一叠可容纳64个物品。（我们将忽略堆叠为16或不堆叠的项目。）
• 胸部可容纳27叠。（这些是单箱，而不是双箱。）

因此，如果Y大于26或Z大于63则毫无意义。

需要注意的是，如果格式为零，则不会打印该术语。

• 因此，例如，如果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

以字节为单位的最短代码获胜。

果冻， 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)

视网膜，49 48 41字节

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

在线尝试！包括所有测试用例（最后一个除外），以防TIO过载。编辑：由于@MartinEnder，节省了7个字节。说明：

.+
$*i

使用is 将输入数字转换为一进制。

i{64}
s

一叠堆填满了64个项目。

s{27}
c

一个箱子里堆满27叠。

(.)\1*
$.&$1

将任何箱子，堆叠或剩余物品转换为十进制，但将类型保留为后缀。

^$
0i

如果输入为零，则得出结果0i。

C＃，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个边缘情况和建议。

Python 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)

在线尝试！

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

C，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)}

在这里尝试。

该代码甚至可以在负数上正常工作。您现在可能欠服务器OP块！

JavaScript（ES6），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

Java 8，86字节

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

在这里尝试。

CJam，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.

JavaScript（ES6）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

Python 2，82字节

我从上面将Gabor Fekete的评论转换为一个工作示例：

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)

在线尝试！

批处理，_{347335283246234202199199191189}字节

@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%

Braingolf，71个字节

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

在线尝试！

根本不打高尔夫球，但可以

Mathematica，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)&

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:"";

在线尝试！

T-SQL，139个134 139字节

输入存储在现有表t的a列中。

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

换行符是为了提高可读性，不计入字节总数。在MS SQL Server 2012上测试。

EDIT 1：改变多个REPLACE对IIF保存5个字节。最后REPLACE仍然有必要，因为STR烦人的空格要填充到10个字符。

编辑2：固定为使用已批准的SQL输入类型（存储在命名表中的值）来遵循规则。此费用字节为FROM，也需要SELECT代替PRINT。通过删除不必要的括号来恢复2个字节。

PowerShell，113字节

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

这非常准确地击中了一堆powershell的痛点。

[math]::Floor 这是必需的，因为PS默认情况下是“银行家四舍五入”。

与其他语言相比，PS三元级还占用了很多字节，要做一个简单的空合并（$a="This";$a?$a:"That"或"This"?:"That"），(($a="This"),"That")[$a-ne$null]

那么我们需要使用所有这些两次，并且由于powershell的默认操作顺序，还需要在某些地方添加另一组括号。

Python 2，77个字节

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

在线尝试！

dc，76字节

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

在线尝试！