Minecraft 1.12 se lanzará mañana, ¡así que celebremos!

Escriba código que tome un número entero no negativo N que represente la cantidad de elementos de algo en Minecraft . Exprímalo de una manera más útil para los jugadores, dando la cantidad de cofres, pilas y elementos a los que N equivale. Usa el formato

XcYsZi

dónde

• X es la cantidad de cofres que puedes llenar completamente con N elementos,
• Y es la cantidad de pilas que puedes llenar con los elementos restantes después de llenar cofres,
• Z si el número de elementos restantes después de llenar cofres y pilas.

Tenga en cuenta que:

• 64 artículos caben en una pila. (Ignoraremos los elementos que se acumulan a 16 o no se acumulan).
• 27 montones caben en un cofre. (Estos son cofres individuales, no cofres dobles).

Por lo tanto, nunca tendría sentido si Yes más de 26 o si Zes más de 63.

Una advertencia con el formato es que si hay cero de algo, ese término no se imprime.

• Entonces, por ejemplo, si Yfueran cero Xy Zno cero, el formato se vería así XcZi.

• Del mismo modo, si Yy Zfuera cero y Xdistinto de cero, el formato sería Xc.

• La excepción aquí es cuando N es cero. Entonces 0ies la salida en lugar de una cadena vacía.

Puede suponer que todos los N elementos son del mismo tipo, por lo tanto, todos son apilables.

No puede generar una lista o tupla de tres números. Debe dar una cadena con la notación "csi" exacta, en ese orden, sin espacios ni comas.

Como referencia, aquí hay un cofre completamente lleno de pilas de artículos:

Casos de prueba

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

El código más corto en bytes gana.

Jalea ,  26  24 bytes

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

Un programa completo que toma el número e imprime el resultado.
Me parece demasiado largo ...

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

actualizando ...

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)

Retina , 49 48 41 bytes

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

Pruébalo en línea!Incluye todos los casos de prueba, excepto el último, en caso de que se haya sobrecargado el TIO. Editar: Guardado 7 bytes gracias a @MartinEnder. Explicación:

.+
$*i

Convierta el número de entrada a unario usando i s.

i{64}
s

64 artículos llenan una pila.

s{27}
c

27 pilas llenan un cofre.

(.)\1*
$.&$1

Convierte cualquier cofre, pila o elemento restante a decimal, pero deja el tipo como sufijo.

^$
0i

Si la entrada fue cero, haga el resultado 0i.

C #, 84 86 bytes

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

Observe la resta en línea, no me di cuenta de que era posible, pero i--tenía sentido, ¿por qué noi-=10

Editar:

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

para 0 caso de borde y sugerencia.

Python 3 , 87 bytes

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)

Pruébalo en línea!

05AB1E , 24 bytes

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

Pruébalo en línea!

Explicación

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 bytes

#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)}

Pruébalo aquí .

El código incluso funciona correctamente en números negativos. ¡Ahora puede deber bloques de OP del servidor!

JavaScript (ES6), 77 76 bytes

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

Casos de prueba

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 bytes

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

Pruébalo aquí

CJam , 31 bytes

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

Pruébalo en línea!

Explicación

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 bytes

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

Retazo:

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 bytes

Convertí el comentario de Gabor Fekete de arriba en un ejemplo de trabajo:

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)

Pruébalo en línea!

Lote, _{347 335 283 246 234 202 199 191} 189 bytes

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

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

Pruébalo en línea!

Para nada golfístico, pero funciona

Mathematica, 155 bytes

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 bytes

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

Pruébalo en línea!

PHP , 93 bytes

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

Pruébalo en línea!

T-SQL, 139134 139 bytes

La entrada se almacena en la columna a de la tabla t existente .

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

Saltos de línea para facilitar la lectura, no contados en bytes totales. Probado en MS SQL Server 2012.

EDITAR 1: Cambiado múltiple REPLACEa IIFpara guardar 5 bytes. Final REPLACEtodavía necesario porqueSTR molestamente rellena con espacios para 10 caracteres.

EDIT 2: arreglado para seguir las reglas mediante el uso del tipo de entrada aprobado para SQL, valores almacenados en una tabla con nombre . Este costo de bytes para FROM, también requiere en SELECTlugar de PRINT. Se recuperaron 2 bytes al soltar un parens innecesario.

PowerShell, 113 bytes

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

Esto golpea un montón de puntos débiles de PowerShell con mucha precisión.

[math]::Floor es necesario para esto, ya que PS realiza el redondeo de los banqueros por defecto.

el PS Ternary también ocupa una carga de bytes en comparación con otros idiomas, para hacer una coallescencia nula simple ( $a="This";$a?$a:"That"o "This"?:"That") tenemos que hacer(($a="This"),"That")[$a-ne$null]

entonces necesitamos usar todo esto dos veces, y también agregar otro conjunto de corchetes en algunos lugares debido al orden de operación predeterminado de powershell.

Python 2 , 77 bytes

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

Pruébalo en línea!

cc , 76 bytes

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

Pruébalo en línea!