Minecraft 1.12 uscirà domani, quindi festeggiamo!

Scrivi il codice che accetta un numero intero non negativo N che rappresenta il numero di elementi di qualcosa in Minecraft . Distribuiscilo in un modo più utile per i giocatori, fornendo il numero di forzieri, pile e oggetti N è equivalente. Usa il formato

XcYsZi

dove

• X è il numero di bauli che puoi riempire completamente con N articoli,
• Y è il numero di pile che puoi riempire con gli elementi rimanenti dopo aver riempito le casse,
• Z se il numero di oggetti rimanenti dopo aver riempito le casse e le pile.

Nota che:

• 64 oggetti si inseriscono in una pila. (Ignoreremo gli oggetti che si accumulano a 16 o che non si accumulano.)
• 27 pile si adattano al petto. (Questi sono forzieri singoli, non forzieri doppi.)

Quindi non avrebbe mai senso se Yfosse più di 26 o se Zfosse più di 63.

Un avvertimento con il formato è che se c'è zero di qualcosa, quel termine non viene stampato.

• Così, per esempio, se Yfosse zero e Xe Zdiverso da zero, il formato sarà simile XcZi.

• Allo stesso modo se Ye Zfosse zero e diverso da Xzero, il formato sarebbe Xc.

• L'eccezione qui è quando N è zero. Quindi 0iè l'output piuttosto che una stringa vuota.

Puoi presumere che tutti gli N oggetti siano dello stesso tipo, quindi tutti impilabili.

Non è possibile generare un elenco o una tupla di tre numeri. Devi dare una stringa con l'esatta notazione "csi", in quell'ordine, senza spazi o virgole.

Per riferimento, ecco una cassa completamente piena di pile di oggetti:

Casi test

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

Vince il codice più breve in byte.

Gelatina ,  26  24 byte

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

Un programma completo che prende il numero e stampa il risultato.
Mi sembra troppo lungo ...

Provalo online! o vedi la suite di test .

Come?

in aggiornamento...

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 byte

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

Provalo online! Include tutti i casi di test tranne l'ultimo, nel caso in cui TIO sia sovraccarico. Modifica: salvato 7 byte grazie a @MartinEnder. Spiegazione:

.+
$*i

Converti il ​​numero di input in unario usando is.

i{64}
s

64 articoli riempiono una pila.

s{27}
c

27 pile riempiono una cassa.

(.)\1*
$.&$1

Converti eventuali casse, pile o oggetti rimanenti in decimali, lasciando il tipo come suffisso.

^$
0i

Se l'input era zero, crea il risultato 0i.

C #, 84 86 byte

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

Notare la sottrazione in linea, non si rese conto che era possibile, ma i--aveva un senso, quindi perché noi-=10

Modificare:

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

per caso e suggerimento 0 edge.

Python 3 , 87 byte

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)

Provalo online!

05AB1E , 24 byte

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

Provalo online!

Spiegazione

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 byte

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

Provalo qui .

Il codice funziona anche correttamente su numeri negativi. Ora puoi dovere blocchi OP server!

JavaScript (ES6), 77 76 byte

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

Casi test

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 byte

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

Provalo qui.

CJam , 31 byte

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

Provalo online!

Spiegazione

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 byte

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

Frammento:

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 byte

Ho convertito il commento di Gabor Fekete dall'alto in un esempio funzionante:

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)

Provalo online!

Lotto, _{347 335283246 234 202 199 191} 189 byte

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

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

Provalo online!

Per niente golfy, ma funziona

Mathematica, 155 byte

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 byte

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

Provalo online!

PHP , 93 byte

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

Provalo online!

T-SQL, 139 134 139 byte

L'input è memorizzato nella colonna a della tabella preesistente t .

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

Interruzioni di riga per leggibilità, non conteggiate nel totale dei byte. Testato su MS SQL Server 2012.

EDIT 1: Cambiato multipla REPLACEper IIFsalvare 5 byte. Finale REPLACEancora necessario perché i STRpad fastidiosi con spazi a 10 caratteri.

EDIT 2: risolto per seguire le regole utilizzando il tipo di input approvato per SQL, valori memorizzati in una tabella denominata . Questo byte di costo per il FROM, richiede anche SELECTinvece di PRINT. Recuperato 2 byte rilasciando una parentesi non necessaria.

PowerShell, 113 byte

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

Questo colpisce un sacco di punti deboli di PowerShell in modo molto preciso.

[math]::Floor è necessario per questo dato che PS esegue per impostazione predefinita il arrotondamento dei banchieri.

PS Ternary occupa anche un carico di byte rispetto ad altre lingue, per eseguire una semplice coallescenza nulla ( $a="This";$a?$a:"That"o "This"?:"That") che dobbiamo fare(($a="This"),"That")[$a-ne$null]

quindi dobbiamo usare tutti questi due volte e aggiungere anche un altro set di parentesi in alcuni punti a causa dell'ordine operativo predefinito di PowerShell.

Python 2 , 77 byte

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

Provalo online!

dc , 76 byte

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

Provalo online!