22

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.

— Pasatiempos de Calvin
fuente

1

Relacionado

— Leaky Nun

33

ok aparentemente esta es una investigación de la escena del crimen

— Okx

1

Relacionado.

— Martin Ender

@Okx Leí el título y pensé que sería una forma de Clue / Cluedo, pero para Minecraft.

— caird coinheringaahing

@Okx con todas las escisiones que no serían sorprendentes. Ahora necesitamos un desafío con dibujar un contorno de tiza, quizás de una enredadera

— Chris H

11

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)

— Jonathan Allan
fuente

7

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.

— Neil
fuente

Oh, ¿esto realmente se está convirtiendo en unario y luego reemplazando?

— Jonathan Allan

@ JonathanAllan He agregado una explicación (no tuve tiempo antes, lo siento). (¡Escribir la explicación también me dio la oportunidad de guardar un byte!)

— Neil

2

Puede evitar parte de esa $.&duplicación como esta: tio.run/##FYs9DsIwDIX3d46ASpGq2Ens5ARcAiEQYsjCQNmqnj21Lb9veD@/…

— Martin Ender

@MartinEnder Ah, me preguntaba si valdría la pena convertir directamente en ilugar de 1, pero no pude ver esa simplificación, ¡gracias!

— Neil

4

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.

— LiefdeWen
fuente

1

+1. Y se puede cambiar _-=_/1728*1728a _%=1728al campo de unos pocos bytes.

— Kevin Cruijssen

Además, se olvidó del caso límite 0, que debería generar 0iy actualmente no genera nada. Agregar un simplemente _>0?...:"0i"solucionaría esto.

— Kevin Cruijssen

@KevinCruijssen Ahh, gracias.

— LiefdeWen

3

+1 >_>en el editado

— caird coinheringaahing

3

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!

— Monja permeable
fuente

En Python 2, esto podría acortarse a 82 bytes, usando una división simple (en / lugar de //) y usando un operador de retroceso en lugar destr(...)

— Gábor Fekete

3

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

— Emigna
fuente

¿Cómo funciona en el 0caso de entrada y por qué eso también imprime una nueva línea final mientras que otras entradas no?

— Jonathan Allan

@JonathanAllan: si no se ha impreso nada, 05AB1E imprime implícitamente la parte superior de la pila al final de la ejecución (con nueva línea). For-loops separa las listas y empuja los elementos a la pila, por lo que cualquier elemento no impreso se agregará a la pila. Al final del bucle, el 0estuche 0iestará en la parte superior de la pila ( 0sy 0cestará debajo) y se imprimirá.

— Emigna

3

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!

— Keyu Gan
fuente

Las funciones son aceptables como estándar en PPCG

— Beta Decay

3

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

Mostrar fragmento de código

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

Expand snippet

— Arnauld
fuente

2

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í

— Kevin Cruijssen
fuente

2

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.

— Gato de negocios
fuente

1

JavaScript (ES6) 71 bytes

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

Retazo:

Mostrar fragmento de código

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

Expand snippet

— Rick Hitchcock
fuente

1

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!

— Andrew U Baker
fuente

1

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%

— stevefestl
fuente

Sabes que puedes usar la división y el módulo en una set/aexpresión, ¿no?

— Neil

@Neil Lo sé, estoy trabajando de la misma manera ahora mismo

— stevefestl

@Neil sólo estoy encontrarse con un problema: if %c%==0 (set c=)else remeste los códigos me da " (setno se espera"

— stevefestl

Huh, eso solo debería suceder si c está vacía ...

— Neil

1

JFTR mi solución (dos variaciones ligeramente diferentes con la misma longitud) se ha reducido a 122 bytes.

— Neil

0

Braingolf , 71 bytes

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

Pruébalo en línea!

Para nada golfístico, pero funciona

— Skidsdev
fuente

0

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

— J42161217
fuente

0

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!

— Jörg Hülsermann
fuente

0

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.

— BradC
fuente

0

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.

— colsw
fuente

0

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!

— xnor
fuente

0

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!

— R. Kap
fuente

CSI: Artículos de Minecraft

Casos de prueba

Jalea , 26 24 bytes

¿Cómo?

Retina , 49 48 41 bytes

C #, 84 86 bytes

Editar:

Python 3 , 87 bytes

05AB1E , 24 bytes

C, 85 87 105 110 111 112 bytes

JavaScript (ES6), 77 76 bytes

Casos de prueba

Java 8, 86 bytes

CJam , 31 bytes

Explicación

JavaScript (ES6) 71 bytes

Python 2 , 82 bytes

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

Braingolf , 71 bytes

Mathematica, 155 bytes

PHP , 84 bytes

PHP , 93 bytes

T-SQL, 139134 139 bytes

PowerShell, 113 bytes

Python 2 , 77 bytes

cc , 76 bytes

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