Me di cuenta de que cierto juego tenía un contador de vida peculiar, que en lugar de detenerse 999, ganó un nuevo dígito: el siguiente número era corona cien o 👑00. Después 👑99vino la corona cien coronas ( 👑👑0) y el último número, después 👑👑9, fue la corona cien coronas o 👑👑👑, que sería 1110 en decimal.

Su tarea es escribir un programa o una función que genere este contador.

Dado un entero del rango [0,1110](incluido en ambos extremos), genera una cadena de tres caracteres donde

• cada personaje es de la lista 0123456789👑
• la corona (👑) solo puede aparecer como el carácter más a la izquierda o cuando hay una corona a la izquierda
• cuando este número se lee como un número decimal pero con la corona contando como 10, se obtiene el número original

Casos de prueba

   0 → "000"
  15 → "015"
 179 → "179"
 999 → "999"
1000 → "👑00"
1097 → "👑97"
1100 → "👑👑0"
1108 → "👑👑8"
1110 → "👑👑👑"

Puede usar cualquier carácter no decimal en lugar de la corona. Para fomentar una impresión bonita, el carácter de la corona (secuencia de bytes UTF8 "\ 240 \ 159 \ 145 \ 145") cuenta como un byte en lugar de cuatro. Su programa no tiene que funcionar para números fuera del rango válido.

Este es el código de golf , por lo que gana la respuesta más corta, medida en bytes.

05AB1E , 20 18 bytes

₄‹i₄+¦ëTð.;„1 „  :

Utiliza espacios para coronas.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

₄‹i               # If the (implicit) input is smaller than 1000:
   ₄+             #  Add 1000 to the (implicit) input
     ¦            #  And remove the leading 1 (so the leading zeros are added)
                  #   i.e. 17 → 1017 → "017"
  ë               # Else:
   Tð.;           #  Replace the first "10" with a space " "
                  #   i.e. 1010 → " 10"
                  #   i.e. 1101 → "1 1"
                  #   i.e. 1110 → "11 "
       „1 „  :    #  Replace every "1 " with "  " (until it no longer changes)
                  #   i.e. " 10" → " 10"
                  #   i.e. "1 1" → "  1"
                  #   i.e. "11 " → "   "

JavaScript (Node.js) , 50 bytes

f=(n,p=1e3)=>n<p?(n+p+'').slice(1):'#'+f(n-p,p/10)

Pruébalo en línea!

TIO se basó en la respuesta de Arnauld. Mostrar 👑 como #.

JavaScript (ES6),  62 46  44 bytes

Guardado 2 bytes gracias a @nwellnhof

Emite coronas como xcaracteres.

n=>(n+1e4+'').replace(/1+0/,'xxx').slice(-3)

Pruébalo en línea!

¿Cómo?

$10000$/1+0/xxx . Finalmente, devolvemos los 3 caracteres finales.

Ejemplos:

$$\begin{align}&0 &\rightarrow &\text{ "}\color{red}{\text{10}}\text{000"} &\rightarrow &\text{ "xxx000"} &\rightarrow &\text{ "000"}\\ &123 &\rightarrow &\text{ "}\color{red}{\text{10}}\text{123"} &\rightarrow &\text{ "xxx123"} &\rightarrow &\text{ "123"}\\ &1023 &\rightarrow &\text{ "}\color{red}{\text{110}}\text{23"} &\rightarrow &\text{ "xxx23"} &\rightarrow &\text{ "x23"}\\ &1103 &\rightarrow &\text{ "}\color{red}{\text{1110}}\text{3"} &\rightarrow &\text{ "xxx3"} &\rightarrow &\text{ "xx3"}\\ &1110 &\rightarrow &\text{ "}\color{red}{\text{11110}}\text{"} &\rightarrow &\text{ "xxx"} &\rightarrow &\text{ "xxx"} \end{align}$$

Lenguaje de programación Shakespeare , 763 692 690 689 683 bytes

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy!Ajax:You big big cat.Scene V:.Ajax:Remember the remainder of the quotient betweenI twice the sum ofa cat a big big cat.Ford:You be the quotient betweenyou twice the sum ofa cat a big big cat.Ajax:You be the sum ofyou a pig.Be you nicer zero?If solet usScene V.Ford:You big big cat.[Exit Ajax][Enter Page]Page:Recall.Ford:You be I.Scene X:.Page:Recall.Am I nicer zero?If notopen heart.If notlet usScene L.Ford:You big big big big big cat.Speak thy.Am I worse a cat?If soyou zero.Scene L:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a pig.Is you nicer a cat?[Exit Ajax][Enter Page]Ford:If solet usScene X.

Pruébalo en línea!

Utiliza en " "lugar de coronas. A costa de 4 bytes más, esto podría modificarse para mostrar un carácter "visible" en su lugar.

Explicación:

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]

    Boilerplate, introducing the characters.

Ford:Listen tothy!

    Input a value to Ajax.

Ajax:You big big cat.

    Set Ford's value to 4 (we will be pushing 4 digits from Ajax onto Ford's personal stack).

Scene V:.Ajax:Remember the remainder of the quotient betweenI twice the sum ofa cat a big big cat.Ford:You be the quotient betweenyou twice the sum ofa cat a big big cat.

    DIGIT-PUSHING LOOP: Push Ajax's last digit onto Ford's stack; divide Ajax by 10.

Ajax:You be the sum ofyou a pig.Be you nicer zero?If solet usScene V.

    Decrement Ford; loop until Ford is 0.

Ford:You big big cat.

    Set Ajax's value to 4 (we will pop 3 digits from Ford's stack in the next loop).

[Exit Ajax][Enter Page]Page:Recall.Ford:You be I.

    Pop the top value off Ford's stack, and store that into Page.
    Here, Page will contain 0 if there are no crowns to be drawn,
    and 1 if there are crowns to be drawn.

Scene X:.Page:Recall.Am I nicer zero?If notopen heart.If notlet usScene L.

    DIGIT-DRAWING LOOP: Pop the top value off of Ford's stack and set Ford equal to that value.
    If there are no crowns to be drawn, output Ford's literal value here, and skip the crown-drawing section.

Ford:You big big big big big cat.Speak thy.Am I worse a cat?If soyou zero.

    Draw crown.
    If we are drawing crowns, and Ford contains 0 here, then we are now done drawing crowns, and thus we store 0 into Page.
    (Put in one more "big" for the crown to look like an @ symbol.)

Scene L:.[Exit Page][Enter Ajax]Ford:You be the sum ofyou a pig.Is you nicer a cat?[Exit Ajax][Enter Page]Ford:If solet usScene X.

    Decrement Ajax; loop until Ajax is 1 (i.e. 3 times).

Python 2 , 53 bytes

Me quito el sombrero ante Arnauld por -22 bytes . Sin embargo, la recursión aún gana.

lambda k:re.sub("1+0","CCC",`k+10000`)[-3:]
import re

Pruébalo en línea!

Python 2 , 51 bytes

Esto implementa el método recursivo de tsh . Guardado 2 bytes gracias a los ovs .

f=lambda n,p=1000:n/p and'C'+f(n-p,p/10)or`n+p`[1:]

Pruébalo en línea!

Python 2 , 52 bytes

lambda n:['%03d'%n,'%3s'%`n`.lstrip('1')[1:]][n>999]

Pruébalo en línea!

Retina 0.8.2 , 41 bytes

\b((.)|..)\b
$#2$*00$&
T`d`_#`(?=....)1+0

Pruébalo en línea! Utiliza #s en lugar de 👑s. El enlace incluye casos de prueba. Explicación:

\b((.)|..)\b
$#2$*00$&

Rellene números de 1 y 2 dígitos a tres dígitos.

T`d`_#`(?=....)1+0

Cambie los primeros 1s de números de 4 dígitos a #sy elimine el siguiente 0.

Jalea , 19 bytes - 0 = 19

<ȷ¬ȧDi0ɓ⁶ẋ⁹Ḋ;+ȷDḊṫʋ

Un programa completo que imprime el resultado utilizando un carácter de espacio como corona.
(Como enlace monádico, se obtiene una lista mixta de dígitos enteros y caracteres espaciales)

Pruébalo en línea! O vea el conjunto de pruebas .

... tal vez una implementación recursiva sea más corta.

¿Cómo?

<ȷ¬ȧDi0ɓ⁶ẋ⁹Ḋ;+ȷDḊṫʋ - Main Link: integer, N    e.g. 1010       or   10
 ȷ                  - literal 1000                  1000            1000
<                   - less than?                    0               1
  ¬                 - logical not                   1               0
    D               - to decimal list               [1,0,1,0]       [1,0]
   ȧ                - logical and                   [1,0,1,0]       0
      0             - literal zero                  0               0
     i              - first index - call this I     2               1  (0 treated as [0] by i)
       ɓ            - new dyadic chain with swapped arguments - i.e. f(N, I)
        ⁶           - literal space character       ' '             ' '
          ⁹         - chain's right argument        2               1
         ẋ          - repeat                        [' ',' ']       [' ']
           Ḋ        - dequeue                       [' ']           []
                  ʋ - last four links as a dyad - i.e. f(N, I)
             +ȷ     -   add 1000                    2010            1010
               D    -   to decimal list             [2,0,1,0]       [1,0,1,0]
                Ḋ   -   dequeue                     [0,1,0]         [0,1,0]
                 ṫ  -   tail from index (I)         [1,0]           [0,1,0]
            ;       - concatenate                   [' ',1,0]       [0,1,0]
                    - implicit print                " 10"           "010"

Python 2 , 40 bytes

lambda n:'%3s'%`10000+n`.lstrip('1')[1:]

Pruébalo en línea!

Implementa una idea similar a la respuesta basada en expresiones regulares del Sr. Xcoder pero sin una expresión regular. Eliminamos los primeros 1 10000+ny el siguiente carácter, luego rellenamos con espacios a la longitud 3. El resultado es similar a la solución de ovs usando lstrippero sin necesidad de dos casos.

Limpio , 87 bytes

No emite coronas (usos c).

import StdEnv,Text
$n#i=3-n/1000-n/1100-n/1110
=("ccc"+lpad(""<+n rem(10^i))i'0')%(i,9)

Pruébalo en línea!

$ n                   // function $ of `n`
 # i =                // define `i` as (the number of digits that aren't crowns)
  3 -                 // three minus
  n / 1000 -          // 1 if first digit is crown
  n / 1100 -          // 1 if second digit is crown
  n / 1110            // 1 if third digit is crown
 = (                  // the string formed by
  "ccc" +             // prefixing three crowns to
  lpad (              // the padding of
   "" <+ n rem (10^i) // non-crown digits of `n`
  ) i '0'             // with zeroes
 ) % (i, 9)           // and removing the extra crowns

Limpiar , 99-3 = 96 bytes

Este tiene coronas.

import StdEnv,Text
$n#i=3-n/1000-n/1100-n/1110
=("👑👑👑"+lpad(""<+n rem(10^i))i'0')%(i*4,99)

Pruébalo en línea!

Japt, 20 bytes

Un puerto ingenuo (¡y un poco borracho!) De la solución de Arnauld. Usos "para corona.

U+A³ s r"^21*0"_çQÃÅ

Intentalo

Java 10, 84 83 bytes

n->{for(int p=100,t;p>0;n-=t%12*p,p/=10)System.out.printf("%c",t=n/p>9?46:48+n/p);}

Puerto de @tsh 'C comentario .
Usos. lugar de coronas.

Pruébalo en línea.

Enfoque alternativo (84 (87-3) bytes):

n->f(n,1000)String f(int n,int p){return n<p?(n+p+"").substring(1):"👑"+f(n-p,p/10);}

Puerto de la respuesta de @tsh 'JavaScript .

Pruébalo en línea.

APL (Dyalog Unicode) , 32 bytes

1e3∘{⍵<⍺:1↓⍕⍵+⍺⋄'C',(⍵-⍺)∇⍨⍺÷10}

Pruébalo en línea!

Función directa de prefijo.

Port of @ tsh's JS Answer .

Cómo:

1e3∘{⍵<⍺:1↓⍕⍵+⍺⋄'C',(⍵-⍺)∇⍨⍺÷10} ⍝ Main function, arguments ⍵ and ⍺ (⍵ → input, ⍺ → 1000).
     ⍵<⍺:                          ⍝ If ⍵<⍺
         1↓                        ⍝ Drop (↓) the first element (1) of
           ⍕                       ⍝ Format (⍕); 'stringify'
            ⍵+⍺                    ⍝ ⍵+⍺
               ⋄                   ⍝ else
                'C',               ⍝ Concatenate (,) the literal 'C' with
                         ∇⍨        ⍝ Recursive call (∇) with swapped arguments (⍨)
                    (⍵-⍺)  ⍺÷10    ⍝ New arguments; ⍵ → ⍵-⍺; ⍺ → ⍺÷10

PHP, 71 bytes

for($n=$argn,$x=1e4;1<$x/=10;$n%=$n<$x?$x/10:$x)echo$n<$x?$n/$x*10|0:C;

estampados Cpara la corona. Ejecutar como tubería con -nRo probarlo en línea .

Haskell , 48 bytes

('2'#).show.(+1000)
n#(a:x)|n==a='c':'1'#x|1>0=x

Pruébalo en línea!

C,  84  58 bytes

¡Gracias a @tsh por guardar 25 bytes y gracias a @ceilingcat por guardar un byte!

f(n,p){for(p=1e3;p/=10;)n-=putchar(n/p>9?46:48+n/p)%12*p;}

Pruébalo en línea!

sed , 39

48 bytes, pero la puntuación es 39, ya que cada 👑 cuenta como 1.

/..../s/^1+0/👑👑👑/
s/^/00/
s/.*(...)/\1/

Pruébalo en línea!

Perl 6 , 38 - 9 = 29 bytes

-2 bytes gracias a Jo King

{~m/...$/}o{S/1+0/👑👑👑/}o*+1e4

Pruébalo en línea!

Inspirado en la solución JavaScript de Arnauld.

Limpio , 96 bytes

Creo que Super Mario 3D Land, New Super Mao Bros.2 y Super Mario 3D World tienen este contador de vida.

import StdEnv,Text
$n#i=3-n/1000-n/1100-n/1110
=("👑👑👑"+lpad(""<+n rem(10^i))i'0')%(i*4,99

Estoy de acuerdo con Clean .

Verifica que no estoy haciendo trampa.