^{También conocido como la [raíz analógica]}

(¡ Frente a la raíz digital! );)

La raíz digital de un número es la suma continua de sus dígitos hasta que sea un solo dígito, por ejemplo, la raíz digital de 89456 se calcula así:

8 + 9 + 4 + 5 + 6 = 32

3 + 2 = 5

La raíz digital de 89456 es 5.

Dado un dígito como entrada a través de STDIN , imprima / devuelva todos los números de dos dígitos posibles que tengan esa raíz digital. Si lo necesita, puede incluirse, por ejemplo, 05

Estas son todas las posibles entradas y salidas:

(Puedes elegir si incluir o no el cero inicial para el dígito en sí)

I / O

0 => 0 o 00 o nada

1 => 01 y / o 1, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91 - Asegúrese de que 1 no devuelva 100

2 => 02 y / o 2, 11, 20, 29, 38, 47, 56, 65, 74, 83, 92

3 => 03 y / o 3, 12, 21, 30, 39, 48, 57, 66, 75, 84, 93

4 => 04 y / o 4, 13, 22, 31, 40, 49, 58, 67, 76, 85, 94

5 => 05 y / o 5, 14, 23, 32, 41, 50, 59, 68, 77, 86, 95

6 => 06 y / o 6, 15, 24, 33, 42, 51, 60, 69, 78, 87, 96

7 => 07 y / o 7, 16, 25, 34, 43, 52, 61, 70, 79, 88, 97

8 => 08 y / u 8, 17, 26, 35, 44, 53, 62, 71, 80, 89, 98

9 => 09 y / o 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99

No hay lagunas estándar , y es code-golf , por lo que gana la respuesta más corta en bytes.

¡Enhorabuena a Heeby Jeeby Man por su increíble respuesta de 46 bytes para el cerebro!

Pyke, 6 bytes

ITV
9+

Pruébalo aquí!

ITV\n9+ - if input: (don't print anything for 0 case)
 TV\n9+ -  repeat 10 times:
   \n   -    print ^
     9+ -   ^ += 9

JavaScript (ES6), 27 31 30 bytes

Las devoluciones 0para 0o un conjunto de soluciones de otro modo.

n=>n&&[...1e9+''].map(_=>n+=9)

Manifestación

let f =

n=>n&&[...1e9+''].map(_=>n+=9)

for(n = 0; n < 10; n++) {
  console.log(n, JSON.stringify(f(n)));
}

05AB1E , 13 12 9 bytes

-3 bytes gracias a Adnan

тL<ʒSOSOQ

Pruébalo en línea!

Explicación

тL<ʒSOSOQ   Main link. Argument n
тL<         List from 1 to 100, then decrement to get 0 to 99
   ʒ        Filter
    SOSO    Sum of all chars, twice
        Q   Compare to input

Haskell , 21 bytes

f toma un entero y devuelve una lista de enteros.

f d=[d,d+9..99^0^0^d]

Pruébalo en línea!

• Comienza con el dígito dy genera el rango con cada noveno número hasta un límite de 99, a excepción del caso complicado de 0.
• Para detenerse temprano 0, usa ese poder 0^d==1para 0y ==0para todos los demás dígitos. Así 99^0^0^dda 1para 0pero 99para cualquier otra cosa.

Jalea , 8 bytes

11Ḷ×9+ȧ@

Pruébalo en línea!

Algoritmo diferente a mi otra respuesta.

Brain-Flak , 46 bytes

{((()()()()()){}){(({}[()])<(({}{}[]))>)}}{}{}

Pruébalo en línea!

Explicación

Esta respuesta usa una idea de la respuesta de Megatom, es decir, usar la altura de la pila como la diferencia entre el contador de bucle y el incremento. Al igual que las respuestas anteriores, esta respuesta tiene un gran bucle externo para capturar todos los ceros. Dentro del bucle, presionamos 10 para que actúe como un contador, luego iniciamos otro bucle anidado. En este bucle, disminuimos el contador en 1

({}[()])

Luego sacamos los dos primeros elementos, que son el contador y el último elemento que calculamos. Agregamos estos a la altura de la pila para contrarrestar la disminución, luego empujamos esto dos veces, una para la salida y otra para que se pueda consumir para calcular el siguiente resultado. Empujar cosas dos veces significa que accidentalmente empujamos un valor adicional que debe eliminarse al final de la ejecución.

La razón por la que esto apenas supera a Megatom es que la respuesta de Megatom se ve obligada a obtener su altura de pila mientras el último resultado aún está en la pila. Esto significa que se ven obligados a usar un método bastante costoso [()]para disminuir el total en uno. Al mover el duplicado al final del ciclo, puedo evitar tener que usarlo [()]a costa de un adicional {}al final del programa. Si Megatom usara esta estrategia, su respuesta sería la siguiente:

{<>((()()()()()){}){((({}[()])<>{}[]))<>}}<>{}

También 46 bytes.

Brain-Flak , 52 bytes

{((()()()()()){}){({}[()]<(({})((()()())){}{})>)}}{}

Pruébalo en línea!

Explicación

El bucle externo principal crea un caso especial para la entrada de cero. Si se ingresa cero, saltamos sobre el ciclo completo, saltamos cero y luego no sacamos nada. De lo contrario, entramos en el bucle. Aquí empujamos el ciclo 10 veces cada vez agregando 9 a la parte superior de la pila, manteniendo los valores antiguos. Como 9 conserva sumas digitales, esto nos dará el siguiente valor. Una vez que el ciclo ha expirado, usamos el cero que generó para salir del ciclo que luego aparece {}al final.

Brain-Flak , 56 bytes

{([(((()()())){}{})]){({}()<(({})<(({}{}))>)>)}}{}({}{})

Pruébalo en línea!

Explicación

Esta versión funciona de manera muy similar a la anterior, excepto que hacemos un bucle 9 veces en lugar de 10 dejando fuera el valor original. Para hacer esto, tenemos que reorganizar un poco la forma en que manejamos la memoria. Todos los bytes que podríamos haber guardado usando este método se ponen en limpieza.

Python 2 , 29 bytes

lambda n:n and range(n,100,9)

Pruébalo en línea!

Brachylog , 12 bytes

0g|g{t+₉}ᵃ¹⁰

Pruébalo en línea!

Explicación

0g               Input = 0, Output = [0]
  |              Or
   g{   }ᵃ¹⁰     Accumulate 10 times, starting with [Input]
     t+₉         Take the last element, add 9

Bash ,31 27 bytes

seq $1 9 $(($1?99:0))|xargs

Pruébalo en línea!

anterior

eval echo {$1..$(($1?99:0))..9}

Dyalog APL, 15 bytes

{(×⍵)/+\⍵,10⍴9}

¿Cómo?

⍵,10⍴9- concatenar entrada con 10 9s ( ⍵ 9 9 9 9 9 9 9 9 9 9).

+\ - suma acumulativa.

(×⍵)/ - expandir los tiempos de signum - donde signum da 1 para 1-9 y 0 para 0.

Pruébalo en línea!

Dyalog APL, 24 bytes

{⍵/⍨⎕=(⍵≠0)×1+9|⍵-1}⍳100

Requiere ⎕IO←0.

¿Cómo?

                      ⍳100  ⍝ 0 .. 99
              1+9|⍵-1      ⍝ digit sum (⍵-1 mod 9 + 1)
        (⍵≠0)×             ⍝ edge case for 0
     ⎕=                    ⍝ equals to the input
 ⍵/⍨                       ⍝ compress with the range

Brain-Flak , 48 bytes

{<>((()()()()()){}){(({}[()])<>[][()]({}))<>}}<>

Pruébalo en línea!

Puedo agregar una explicación más tarde.

Mathematica, 25 bytes

If[#==0,0,Range[#,99,9]]&

funciona para 0

Jalea , 12 bytes

⁵²Ḷµ,³%9EµÐf

Pruébalo en línea!

Cómo funciona

⁵²Ḷµ,³%9EµÐf
⁵             - literal 10
 ²            - square
  R           - lowered range: 0 to 99 inclusive.
   µ     µÐf  - filter based on:
    ,³          - element and input
      %9        - mod 9
        E       - are equal

En realidad , 18 bytes

╗2╤DR⌠╜-9@%Y⌡░╜;)I

Pruébalo en línea!

Explicación:

╗2╤DR⌠╜-9@%Y⌡░╜;)I
╗                   save input to register 0
 2╤DR               range(1, 100)
     ⌠╜-9@%Y⌡░      elements in range where function returns truthy:
      ╜-              subtract from input
        9@%           mod 9
           Y          is equal to 0
              ╜;)   push a copy of the input on the top and the bottom of the stack
                 I  if input is truthy, return the filtered range, else return the input (special-cases 0)

PHP, 41 bytes

imprime los valores separados por subrayado

for(;100>$a=&$argn;$a+=$a?9:ERA)echo$a._;

ERAes la constante más corto en PHP con el valor 131116. Puede reemplazarlo con la alternativa aburrida 100o finalizar el programa condie

Versión en línea

Brain-Flak , 54 52 bytes

{<>((((()()())){}{})()){({}<(({})<>({}))><>[()])}}<>

Pruébalo en línea!

Mi primera incursión con Brain-Flak, y creo que lo he hecho bastante bien. ¿Alguien con más experiencia tiene consejos?

Cómo funciona:

{ Don't do anything if input is 0
  <>((((()()())){}{})()) Switch to other stack and add 9 and 10
                         10 is the counter, 9 is to add to the current num
  { While counter
     (
       {} Pop the counter
       <(({})<>({}))> Get a copy of the 9, switch to the other stack and add it to a copy of the top of it. Use <...> to make it return 0
       <>[()] Switch to the other stack and decrement the counter
     ) 
  }
}<> Switch to the stack with the values on it

Jalea , 12 bytes

ȷ2ḶDS$ÐL⁼¥Ðf

Pruébalo en línea!

PHP, 35

print_r(range($argn,!!$argn*99,9));

Crea el rango [$argn, 100)con un paso 9como matriz y lo imprime. Si la entrada es 0, crea el rango [0,0]=> array(0).

Python, 48 51 bytes

3 bytes guardados gracias a @WheatWizard

lambda n:[x for x in range(100)if~-n==~-x%9or x==n]

R , 23 bytes

pryr::f(x+0:(10*!!x)*9)

Pruébalo en línea!

El enlace TIO se usa en function(x)lugar de pryr::f, ya que TIO no tiene el pryrpaquete instalado.

Pyke, 6 bytes (versión anterior)

Compromiso de trabajo

TXU#sq

Explicación:

TX     -   10**2
  U    -  range(^)
   #   - filter(^)
    s  -   digital_root(^)
     q -  ^==input

Rubí , 25 bytes.

->a{[*a.step(99,9)]*a|[]}

Pruébalo en línea!

C (gcc) , 55 bytes

f()no es necesario que se llame con ningún argumento; El nestá allí en lugar de fuera de la función para guardar un byte.

f(n){for(scanf("%d",&n);n&&n<100;n+=9)printf("%d ",n);}

Pruébalo en línea!

Carbón , 14 11 bytes

Ｉ∧Ｎ⁺Ｉθ×⁹…¹¹

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: ahorró 2 bytes al no imprimir nada para entrada cero y 1 byte mediante operaciones de vectorización de 3 bytes gracias a @ ASCII-only. Explicación:

         ¹¹ Literal 11
        …   Range
       ⁹    Literal 9
      ×     Vector multiply
     θ      (First) input
    Ｉ       Cast to number
   ⁺        Vector add
  Ｎ         Input digit as a number
 ∧          Logical AND
Ｉ           Cast to string
            Implicitly print on separate lines

Julia 0.6 , 18 bytes

Utilizo un ternario para captar el 0caso y un rango n:9:99para crear los números. En julia, un rango es un AbstractVectory se puede usar en lugar de un número real Vectoren la mayoría de los casos, pero solo se imprimirá ya 1:9:91que no satisface el desafío, así que lo envuelvo [_;]para recopilar el contenido en a Vector.

n->n>0?[n:9:99;]:0

Pruébalo en línea!

Perl 5 , 25 + 1 ( -n) = 26 bytes

say;!$_||($_+=9)>99||redo

Pruébalo en línea!

Clojure, 33 bytes

(fn[n](if(> n 0)(range n 100 9)))

Clojure , 38 bytes

(defn f[n](if(pos? n)(range n 100 9)))

o como función anónima que es de 29 bytes

(#(if(pos? %)(range % 100 9))n)

Pruébalo en línea!

gracias @steadybox

Perl 5, 62 bytes

sub x{$f=$_[0];@x=("0$f",$f);push@x,map$f+$_*10,(1..9)if$f;@x}

Seguramente habrá un camino más corto

Gol> <> , 12 bytes

I:ZhbF:N9+|;

Pruébalo en línea!

Cómo funciona

I:ZhbF:N9+|;

I             Take input as number
 :            Duplicate
  Z           Pop and skip one if nonzero
   h          If zero, print the top as number and halt
              Otherwise...
    bF....|   Repeat these commands 11 times
      :N      Print top as number, with newline
        9+    Add 9
           ;  Halt