Minecraft 1.12 가 내일 출시 될 예정이므로 축하합시다!

Minecraft 의 항목 수를 나타내는 음이 아닌 정수 N을 취하는 코드를 작성하십시오 . 플레이어에게 더 유용한 방식으로 출력하여 상자, 스택 및 항목 N의 수를 제공합니다. 형식을 사용하십시오

XcYsZi

어디에

• X N 개의 아이템으로 완전히 채울 수있는 상자의 개수입니다.
• Y 상자를 채운 후 남은 항목으로 채울 수있는 스택 수입니다.
• Z 상자와 더미를 채운 후 남은 품목의 수

참고 :

• 64 개 품목이 쌓여 있습니다. (우리는 16까지 쌓이거나 쌓이지 않은 아이템은 무시합니다.)
• 27 개의 더미가 가슴에 들어갑니다. (이것은 더블 상자가 아닌 싱글 상자입니다.)

따라서 Y26보다 크거나 Z63 보다 크면 의미가 없습니다 .

형식에 대한주의 사항은 0이 있으면 해당 용어가 인쇄되지 않는다는 것입니다.

• 따라서, 예를 들어, 경우는 Y제로였다 X와 Z제로를, 형식은 같을 것이다 XcZi.

• 마찬가지로 Yand Z가 0이고 X0이 아닌 경우 형식은입니다 Xc.

• N이 0 인 경우는 예외입니다. 그런 다음 0i빈 문자열이 아닌 출력입니다.

모든 N 항목이 동일한 유형이므로 모든 스택 가능하다고 가정 할 수 있습니다.

세 개의 숫자로 된 목록이나 튜플을 출력 할 수 없습니다. 공백이나 쉼표없이 정확한 "csi"표기법이있는 문자열을 순서대로 제공해야합니다.

참고로 다음은 아이템으로 가득 찬 상자입니다.

테스트 케이스

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

바이트 단위의 가장 짧은 코드가 이깁니다.

젤리 ,  26  24 바이트

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

전체 프로그램은 번호를 받아 결과를 인쇄합니다.
너무 길어 보인다 ...

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

방법?

업데이트 중 ...

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)

망막 , 49 48 41 바이트

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

온라인으로 사용해보십시오! TIO에 과부하가 걸린 경우 마지막을 제외한 모든 테스트 사례를 포함합니다. 편집 : @MartinEnder 덕분에 7 바이트가 절약되었습니다. 설명:

.+
$*i

is를 사용하여 입력 번호를 단항으로 변환하십시오 .

i{64}
s

64 개의 아이템이 하나의 스택을 채 웁니다.

s{27}
c

27 개의 더미가 한 상자를 채 웁니다.

(.)\1*
$.&$1

상자, 스택 또는 남은 항목을 10 진수로 변환하지만 유형을 접미사로 남겨 둡니다.

^$
0i

입력이 0이면 결과를 만드십시오 0i.

C #, 84 86 바이트

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

인라인 뺄셈을 주목하십시오. 그것이 가능하지는 않았지만 i--이해가 되었습니까?i-=10

편집하다:

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

0 엣지 케이스 및 제안.

파이썬 3 , 87 바이트

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)

온라인으로 사용해보십시오!

05AB1E , 24 바이트

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

온라인으로 사용해보십시오!

설명

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 바이트

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

여기에서 시도 하십시오 .

코드는 음수에서도 제대로 작동합니다. 이제 서버 OP 블록이 있어야합니다!

자바 스크립트 (ES6), 77 76 바이트

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

테스트 사례

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

자바 8, 86 바이트

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

여기에서 시도하십시오.

CJam , 31 바이트

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

온라인으로 사용해보십시오!

설명

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.

자바 스크립트 (ES6) 71 바이트

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

단편:

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

파이썬 2 , 82 바이트

Gabor Fekete의 의견을 위의 작업 예제로 변환했습니다.

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)

온라인으로 사용해보십시오!

일괄 처리, _{347335283246234202 19919189} 바이트

@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 바이트

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

온라인으로 사용해보십시오!

전혀 골프는 아니지만 작동합니다.

Mathematica, 155 바이트

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 바이트

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

온라인으로 사용해보십시오!

PHP , 93 바이트

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

온라인으로 사용해보십시오!

T-SQL, 139 134 139 바이트

입력은 기존 테이블 t 의 열 a 에 저장됩니다 .

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

바이트 총계로 계산되지 않은 가독성을 위해 줄 바꿈. MS SQL Server 2012에서 테스트되었습니다.

편집 1 : 5 바이트를 저장하기 위해 여러 개로 변경 REPLACE되었습니다 IIF. 귀찮게 공백으로 10자를 채울 수 REPLACE있기 때문에 최종판이 여전히 필요 STR합니다.

편집 2 : 명명 된 테이블에 저장된 SQL에 대한 승인 된 입력 유형을 사용하여 규칙을 따르도록 수정되었습니다 . 의이 비용 바이트 FROM는 SELECT대신을 요구 합니다 PRINT. 불필요한 parens를 삭제하여 2 바이트를 복구했습니다.

PowerShell, 113 바이트

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

이것은 많은 파워 쉘의 고통 지점에 매우 정확하게 맞습니다.

[math]::Floor PS는 기본적으로 Bankers Rounding을 수행하므로이 기능이 필요합니다.

PS Ternary는 다른 언어에 비해 많은 바이트를 차지하여 간단한 null coallescence ( $a="This";$a?$a:"That"또는 "This"?:"That")를 수행합니다.(($a="This"),"That")[$a-ne$null]

Powershell의 기본 작동 순서로 인해이 두 가지를 모두 사용해야하고 일부 위치에 다른 괄호 세트를 추가해야합니다.

파이썬 2 , 77 바이트

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

온라인으로 사용해보십시오!

dc , 76 바이트

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

온라인으로 사용해보십시오!