Minecraft 1.12 zostanie wydany jutro, więc świętujmy!

Napisz kod, który przyjmuje nieujemną liczbę całkowitą N, która reprezentuje liczbę elementów czegoś w Minecraft . Wydaj go w sposób bardziej pomocny dla graczy, podając liczbę skrzyń, stosów i przedmiotów, które N jest równoważne. Użyj formatu

XcYsZi

gdzie

• X to liczba skrzyń, które możesz całkowicie wypełnić N przedmiotami,
• Y to liczba ładunków, które możesz wypełnić przedmiotami pozostałymi po napełnieniu skrzyń,
• Z jeśli liczba przedmiotów pozostała po napełnieniu skrzyń i stosów.

Uwaga:

• 64 przedmioty mieszczą się w stosie. (Zignorujemy przedmioty, które kumulują się do 16 lub nie kumulują się.)
• 27 stosów mieści się w skrzyni. (Są to pojedyncze skrzynie, a nie podwójne skrzynie.)

Tak więc nigdy nie miałoby sensu, jeśli Yma więcej niż 26 lub Zwięcej niż 63.

Zastrzeżenie dotyczące formatu polega na tym, że jeśli czegoś jest zero, termin ten nie jest drukowany.

• Na przykład, gdyby Ybyły zerowe Xi Zniezerowe, format wyglądałby tak XcZi.

• Podobnie jeśli Yi Zbyło zero i Xniezerowe, format będzie Xc.

• Wyjątkiem jest sytuacja, gdy N wynosi zero. Potem 0ijest wyjście, a nie pusty ciąg.

Możesz założyć, że wszystkie N przedmiotów są tego samego typu, a więc wszystkie można ustawiać jeden na drugim.

Nie możesz wypisać listy ani krotki trzech liczb. Musisz podać ciąg z dokładną notacją „csi”, w tej kolejności, bez spacji i przecinków.

Dla porównania, oto skrzynia całkowicie wypełniona stosami przedmiotów:

Przypadki testowe

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

Najkrótszy kod w bajtach wygrywa.

Galaretka ,  26  24 bajtów

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

Pełny program pobierający numer i drukujący wynik.
Wydaje mi się, że to za długo ...

Wypróbuj online! lub zobacz pakiet testowy .

W jaki sposób?

aktualizuję ...

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 bajtów

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

Wypróbuj online! Obejmuje wszystkie przypadki testowe z wyjątkiem ostatniego, na wypadek przeciążenia TIO. Edycja: Zapisano 7 bajtów dzięki @MartinEnder. Wyjaśnienie:

.+
$*i

Konwertuj liczbę wejściową na unarną, używając is.

i{64}
s

64 przedmioty wypełniają jeden stos.

s{27}
c

27 stosów wypełnia jedną skrzynię.

(.)\1*
$.&$1

Konwertuj wszystkie skrzynie, stosy lub pozostałe elementy na dziesiętne, ale pozostawiając typ jako przyrostek.

^$
0i

Jeśli wartość wejściowa wynosiła zero, zrób wynik 0i.

C #, 84 86 bajtów

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

Zwróć uwagę na odejmowanie w linii, nie zdawałem sobie sprawy, że jest to możliwe, ale i--miało sens, więc dlaczego niei-=10

Edytować:

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

dla 0 krawędzi i sugestii.

Python 3 , 87 bajtów

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)

Wypróbuj online!

05AB1E , 24 bajty

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

Wypróbuj online!

Wyjaśnienie

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 bajty

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

Wypróbuj tutaj .

Kod działa nawet poprawnie na liczbach ujemnych. Możesz być teraz winien bloki OP serwera!

JavaScript (ES6), 77 76 bajtów

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

Przypadki testowe

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 bajtów

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

Wypróbuj tutaj.

CJam , 31 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Skrawek:

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 bajty

Przekształciłem komentarz Gabora Fekete z góry na działający przykład:

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)

Wypróbuj online!

Partia, _{347 335 283 246 234 202 199 191} 189 bajtów

@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 bajtów

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

Wypróbuj online!

W ogóle nie golfa, ale działa

Mathematica, 155 bajtów

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 bajty

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

Wypróbuj online!

PHP , 93 bajty

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

Wypróbuj online!

T-SQL, 139 134 139 bajtów

Dane wejściowe są przechowywane w kolumnie a istniejącej tabeli 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

Podziały linii dla czytelności, nie liczone jako suma bajtów. Testowane na MS SQL Server 2012.

EDYCJA 1: Zmieniono wiele REPLACEna, IIFaby zapisać 5 bajtów. Ostatecznie REPLACEkonieczne, ponieważ STRirytujące podkładki ze spacjami do 10 znaków.

EDYCJA 2: Naprawiono przestrzeganie reguł za pomocą zatwierdzonego typu danych wejściowych SQL, przechowywanych w nazwanej tabeli . Ten bajt kosztów dla FROM, również wymaga SELECTzamiast PRINT. Odzyskano 2 bajty, upuszczając niepotrzebne pareny.

PowerShell, 113 bajtów

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

To bardzo precyzyjnie uderza w punkty bólu PowerShell.

[math]::Floor jest wymagane do tego, ponieważ PS domyślnie wykonuje zaokrąglanie za pomocą bankierów.

PS Ternary również zajmuje dużo bajtów w porównaniu do innych języków, aby wykonać prostą koalescencję zerową ( $a="This";$a?$a:"That"lub "This"?:"That") musimy zrobić(($a="This"),"That")[$a-ne$null]

następnie musimy użyć ich wszystkich dwa razy, a także dodać inny zestaw nawiasów w niektórych miejscach ze względu na domyślną kolejność operacji programu PowerShell.

Python 2 , 77 bajtów

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

Wypróbuj online!

dc , 76 bajtów

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

Wypróbuj online!