22

Minecraft 1.12 sortira demain, alors célébrons!

Écrivez du code qui prend un entier non négatif N qui représente le nombre d'éléments de quelque chose dans Minecraft . Produisez-le d'une manière plus utile pour les joueurs, en donnant le nombre de coffres, de piles et d'objets N est équivalent à. Utilisez le format

XcYsZi

où

X est le nombre de coffres que vous pouvez remplir complètement avec N objets,
Y est le nombre de piles que vous pouvez remplir avec les objets restants après avoir rempli les coffres,
Z si le nombre d'objets restant après avoir rempli les coffres et les piles.

Notez que:

64 articles peuvent être rangés dans une pile. (Nous ignorerons les éléments qui se cumulent jusqu'à 16 ou ne se cumulent pas.)
27 piles tiennent dans un coffre. (Ce sont des coffres simples, pas des coffres doubles.)

Cela n'aurait donc aucun sens si Yest supérieur à 26 ou s'il Zest supérieur à 63.

Une mise en garde avec le format est que s'il n'y a rien de quelque chose, ce terme n'est pas imprimé.

Ainsi, par exemple, si Yzéro et Xet Znon nul, le format ressemblerait XcZi.
De même, si Yet Zétaient zéro et Xdifférent de zéro, le format serait Xc.
L'exception ici est lorsque N est zéro. Ensuite , 0iest la sortie plutôt que d' une chaîne vide.

Vous pouvez supposer que tous les N éléments sont du même type, donc tous empilables.

Vous ne pouvez pas afficher une liste ou un tuple de trois nombres. Vous devez donner une chaîne avec la notation "csi" exacte, dans cet ordre, sans espace ni virgule.

Pour référence, voici un coffre complètement rempli de piles d'objets:

Cas de 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

Le code le plus court en octets gagne.

— Loisirs de Calvin
source

1

En relation

— Leaky Nun

33

ok apparemment, c'est une enquête sur une scène de crime

— Okx

1

En relation.

— Martin Ender

@Okx J'ai lu le titre et j'ai pensé que ça allait être une forme de Clue / Cluedo mais pour minecraft.

— caird coinheringaahing

@Okx avec toutes les retombées qui ne seraient pas surprenantes. Maintenant, nous avons besoin d'un défi avec le dessin d'un contour à la craie - d'une plante grimpante peut

— Chris H

11

Gelée , 26 24 octets

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

Un programme complet prenant le nombre et imprimant le résultat.
Cela me semble trop long ...

Essayez-le en ligne! ou consultez la suite de tests .

Comment?

mise à jour ...

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
source

7

Rétine , 49 48 41 octets

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

Essayez-le en ligne! Comprend tous les cas de test sauf le dernier, au cas où il surchargerait TIO. Edit: 7 octets enregistrés grâce à @MartinEnder. Explication:

.+
$*i

Convertissez le numéro d'entrée en unaire à l'aide de is.

i{64}
s

64 objets remplissent une pile.

s{27}
c

27 piles remplissent un coffre.

(.)\1*
$.&$1

Convertissez les coffres, piles ou éléments restants en décimal, mais en laissant le type comme suffixe.

^$
0i

Si l'entrée était nulle, faites le résultat 0i.

— Neil
source

Oh mon, est-ce vraiment une conversion en unaire puis un remplacement?

— Jonathan Allan

@JonathanAllan J'ai ajouté une explication (je n'ai pas eu le temps plus tôt désolé). (L'écriture de l'explication m'a donné l'occasion de sauvegarder un octet aussi!)

— Neil

2

Vous pouvez éviter une partie de cette $.&duplication comme celle-ci: tio.run/##FYs9DsIwDIX3d46ASpGq2Ens5ARcAiEQYsjCQNmqnj21Lb9veD@/…

— Martin Ender

@MartinEnder Ah, je me demandais s'il valait la peine de convertir directement en au ilieu de 1, mais je ne pouvais tout simplement pas voir cette simplification, merci!

— Neil

4

C #, 84 86 octets

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

Remarquez la soustraction en ligne, je ne savais pas que c'était possible mais c'était i--logique alors pourquoi pasi-=10

Modifier:

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

pour 0 cas de bord et suggestion.

— LiefdeWen
source

1

+1. Et vous pouvez changer _-=_/1728*1728de _%=1728golf quelques octets.

— Kevin Cruijssen

En outre, vous avez oublié le cas de bord 0, ce qui devrait entraîner 0iet ne génère actuellement rien. L'ajout d'un simplement _>0?...:"0i"résoudrait ce problème.

— Kevin Cruijssen

@KevinCruijssen Ahh, merci.

— LiefdeWen

3

+1 pour >_>dans celui édité

— caird coinheringaahing

3

Python 3 , 87 octets

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)

Essayez-le en ligne!

— Leaky Nun
source

Dans Python 2, cela pourrait être raccourci à 82 octets, en utilisant une division simple ( / au lieu de //) et en utilisant l'opérateur de backtick au lieu destr(...)

— Gábor Fekete

3

05AB1E , 24 octets

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

Essayez-le en ligne!

Explication

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
source

Comment cela fonctionne-t-il dans le 0cas d'entrée, et pourquoi cela imprime-t-il également une nouvelle ligne de fin alors que d'autres entrées ne le font pas?

— Jonathan Allan

@JonathanAllan: Si rien n'a été imprimé, 05AB1E imprime implicitement le haut de la pile à la fin de l'exécution (avec la nouvelle ligne). For-loops sépare les listes et pousse les éléments dans la pile, donc tout élément non imprimé sera ajouté à la pile. À la fin de la boucle dans le 0cas 0isera sur le dessus de la pile ( 0set 0csera en dessous) et sera imprimé.

— Emigna

3

C, 85 87 105 110 111 112 octets

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

Essayez-le ici .

Le code fonctionne même correctement sur les nombres négatifs. Vous pouvez maintenant devoir des blocs OP de serveur!

— Keyu Gan
source

Les fonctions sont acceptées en standard sur PPCG

— Beta Decay

3

JavaScript (ES6), 77 76 octets

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

Cas de test

Afficher l'extrait de code

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

Développer l'extrait

— Arnauld
source

2

Java 8, 86 octets

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

Essayez-le ici.

— Kevin Cruijssen
source

2

CJam , 31 octets

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

Essayez-le en ligne!

Explication

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.

— Chat d'affaires
source

1

JavaScript (ES6) 71 octets

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

Fragment:

Afficher l'extrait de code

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

Développer l'extrait

— Rick Hitchcock
source

1

Python 2 , 82 octets

J'ai converti le commentaire de Gabor Fekete d'en haut en un exemple de travail:

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)

Essayez-le en ligne!

— Andrew U Baker
source

1

Lot, _{347 335 283 246 234 202 199 191} 189 189 octets

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

Vous savez que vous pouvez utiliser la division et le module dans une set/aexpression, n'est-ce pas?

— Neil

@Neil Je sais, je travaille de la même manière en ce moment

— stevefestl

@Neil Je rencontre juste un problème: if %c%==0 (set c=)else remce code me donne " (setn'est pas prévu"

— stevefestl

Huh, cela ne devrait arriver que si c est vide ...

— Neil

1

JFTR ma solution (deux variations légèrement différentes avec la même longueur) est à 122 octets.

— Neil

0

Braingolf , 71 octets

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

Essayez-le en ligne!

Pas du tout golfique, mais ça marche

— Skidsdev
source

0

Mathematica, 155 octets

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
source

0

PHP , 84 octets

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

Essayez-le en ligne!

PHP , 93 octets

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

Essayez-le en ligne!

— Jörg Hülsermann
source

0

T-SQL, 139 134 139 octets

L'entrée est stockée dans la colonne a du tableau préexistant 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

Sauts de ligne pour la lisibilité, non comptés dans le total d'octets. Testé sur MS SQL Server 2012.

EDIT 1: Changé multiple REPLACEpour IIFsauver 5 octets. Final REPLACEtoujours nécessaire carSTR contient des espaces de 10 caractères.

EDIT 2: correction pour suivre les règles en utilisant le type d'entrée approuvé pour SQL, valeurs stockées dans une table nommée . Ce coût en octets pour le FROM, nécessite également SELECTau lieu de PRINT. Récupéré 2 octets en supprimant un parens inutile.

— BradC
source

0

PowerShell, 113 octets

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

Cela frappe très précisément un tas de points faibles de PowerShell.

[math]::Floor est nécessaire pour cela, car PS effectue l'arrondi des banquiers par défaut.

le PS Ternary prend également une charge d'octets par rapport aux autres langages, pour faire une simple coallescence nulle ( $a="This";$a?$a:"That"ou "This"?:"That") que nous devons faire(($a="This"),"That")[$a-ne$null]

nous devons ensuite utiliser tous ces éléments deux fois, et également ajouter un autre ensemble de crochets à certains endroits en raison de l'ordre de fonctionnement par défaut de powershell.

— colsw
source

0

Python 2 , 77 octets

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

Essayez-le en ligne!

— xnor
source

0

dc , 76 octets

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

Essayez-le en ligne!

— R. Kap
source

CSI: Objets Minecraft

Cas de test

Gelée , 26 24 octets

Comment?

Rétine , 49 48 41 octets

C #, 84 86 octets

Modifier:

Python 3 , 87 octets

05AB1E , 24 octets

C, 85 87 105 110 111 112 octets

JavaScript (ES6), 77 76 octets

Cas de test

Java 8, 86 octets

CJam , 31 octets

Explication

JavaScript (ES6) 71 octets

Python 2 , 82 octets

Lot, 347 335 283 246 234 202 199 191 189 189 octets

Braingolf , 71 octets

Mathematica, 155 octets

PHP , 84 octets

PHP , 93 octets

T-SQL, 139 134 139 octets

PowerShell, 113 octets

Python 2 , 77 octets

dc , 76 octets

Lot, _{347 335 283 246 234 202 199 191} 189 189 octets