Minecraft 1.12 wird morgen veröffentlicht, also lasst uns feiern!

Schreiben Sie Code, der eine nicht negative Ganzzahl N enthält, die die Anzahl der Elemente in Minecraft angibt . Geben Sie es hilfreicher für die Spieler aus, indem Sie die Anzahl der Truhen, Stapel und Gegenstände angeben, denen N entspricht. Verwenden Sie das Format

XcYsZi

woher

• X ist die Anzahl der Truhen, die Sie vollständig mit N Gegenständen füllen können,
• Y ist die Anzahl der Stapel, die Sie mit den nach dem Befüllen der Truhen verbleibenden Gegenständen füllen können,
• Z ob die Anzahl der nach dem Befüllen von Truhen und Stapeln verbleibenden Gegenstände.

Beachten Sie, dass:

• 64 Elemente passen in einen Stapel. (Elemente, die auf 16 gestapelt sind, werden ignoriert oder nicht gestapelt.)
• 27 Stapel passen in eine Truhe. (Dies sind einzelne Truhen, keine doppelten Truhen.)

Es würde also niemals Sinn machen, wenn Ymehr als 26 oder Zmehr als 63 sind.

Eine Einschränkung des Formats besteht darin, dass dieser Begriff nicht gedruckt wird, wenn es null von etwas gibt.

• Wenn also zum Beispiel YNull Xund nicht ZNull wäre, würde das Format so aussehen XcZi.

• Ebenso wäre das Format, wenn Yund ZNull und nicht XNull wären Xc.

• Die Ausnahme ist hier, wenn N Null ist. Dann 0iist die Ausgabe eher als eine leere Zeichenfolge.

Sie können davon ausgehen, dass alle N Elemente vom selben Typ sind und daher alle stapelbar sind.

Sie können keine Liste oder ein Tupel von drei Zahlen ausgeben. Sie müssen eine Zeichenfolge mit der genauen "csi" -Notation in dieser Reihenfolge ohne Leerzeichen oder Kommas angeben.

Als Referenz ist hier eine Truhe, die vollständig mit Stapeln von Gegenständen gefüllt ist:

Testfälle

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

Der kürzeste Code in Bytes gewinnt.

Jelly ,  26  24 Bytes

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

Ein vollständiges Programm, das die Nummer aufnimmt und das Ergebnis druckt.
Es scheint mir zu lang ...

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie?

Aktualisierung...

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

Probieren Sie es online! Beinhaltet alle Testfälle mit Ausnahme des letzten, falls es TIO überlastet. Bearbeiten: 7 Bytes dank @MartinEnder gespeichert. Erläuterung:

.+
$*i

Wandle die eingegebene Zahl mit is in unär um .

i{64}
s

64 Gegenstände füllen einen Stapel.

s{27}
c

27 Stapel füllen eine Truhe.

(.)\1*
$.&$1

Konvertieren Sie alle Truhen, Stapel oder verbleibenden Elemente in Dezimalzahlen, lassen Sie den Typ jedoch als Suffix.

^$
0i

Wenn die Eingabe Null war, machen Sie das Ergebnis 0i.

C # 84 86 Bytes

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

Beachten Sie die Inline-Subtraktion. Sie hat nicht erkannt, dass dies möglich ist, hat aber i--Sinn gemacht. Warum also nicht?i-=10

Bearbeiten:

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

für 0 Rand Fall und Vorschlag.

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)

Probieren Sie es online!

05AB1E , 24 Byte

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es hier aus .

Der Code funktioniert auch bei negativen Zahlen einwandfrei. Sie können jetzt Server-OP-Blöcke schulden!

JavaScript (ES6), 77 bis 76 Byte

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

Testfälle

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"

Probieren Sie es hier aus.

CJam , 31 Bytes

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

Probieren Sie es online!

Erläuterung

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'

Snippet:

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

Ich habe Gabor Feketes Kommentar von oben in ein funktionierendes Beispiel umgewandelt:

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)

Probieren Sie es online!

Batch, _{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:>|;

Probieren Sie es online!

Gar nicht golfen, aber es funktioniert

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

Probieren Sie es online!

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

Probieren Sie es online!

T-SQL, 139 134 139 Bytes

Die Eingabe wird in Spalte a der bereits vorhandenen Tabelle t gespeichert .

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

Zeilenumbrüche zur besseren Lesbarkeit, nicht in Bytesumme gezählt. Getestet auf MS SQL Server 2012.

EDIT 1: Mehrfach geändert REPLACEin IIF, um 5 Bytes zu sparen. Finale REPLACEnoch nötig, da STRnervig mit Leerzeichen bis 10 Zeichen aufgefüllt wird.

BEARBEITEN 2: Das Befolgen der Regeln unter Verwendung des genehmigten Eingabetyps für SQL, Werte, die in einer benannten Tabelle gespeichert sind, wurde korrigiert . Diese Kosten für die Bytes FROM, erfordert auch SELECTstatt PRINT. 2 Bytes durch Löschen unnötiger Parens wiederhergestellt.

PowerShell, 113 Bytes

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

Dies trifft eine Reihe von Powershell-Schmerzpunkten sehr genau.

[math]::Floor Dies ist erforderlich, da PS standardmäßig Bankers Rounding durchführt.

Der PS Ternary nimmt im Vergleich zu anderen Sprachen auch eine Menge Bytes in Anspruch, um eine einfache Null-Koalleszenz ( $a="This";$a?$a:"That"oder "This"?:"That") durchzuführen, die wir tun müssen(($a="This"),"That")[$a-ne$null]

dann müssen wir all diese zweimal verwenden und an einigen Stellen aufgrund der standardmäßigen Betriebsreihenfolge von Powershell einen weiteren Satz von Klammern hinzufügen.

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'

Probieren Sie es online!

Gleichstrom , 76 Bytes

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

Probieren Sie es online!