Cuenta atrás desde "Infinito"

47

Parece una tarea imposible ¿verdad? Bueno, en realidad no es tan difícil. Si escribimos la palabra Infinitycomo código ASCII binario de 8 bits, obtendremos:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

Esto se puede concatenar y convertir al valor decimal 5291279215216915577. Ahora ese es un número con el que podemos trabajar ...

La forma en que contarás es:

  1. Salida de la cadena original como un número decimal (como se muestra arriba)
  2. Elimine los ceros a la izquierda en su representación binaria (si existe)
  3. Alternar los bits en la representación binaria (1-> 0, 0-> 1)
  4. Salida del número en decimal
  5. Repita los pasos 2-4 como hasta llegar a 0.

Desafío:

Cree un programa o función que tome una cadena como entrada y envíe (en cualquier formato adecuado) los números que obtendrá al realizar el procedimiento anterior.

Caso de prueba:

Creo que el desafío será bastante fácil de entender, aunque solo sea un caso de prueba. Lo usaré en Influgar de Infinitymantener esto bastante corto.

Inf
4812390  (10010010110111001100110)
3576217  ( 1101101001000110011001)
618086   (   10010110111001100110)
430489   (    1101001000110011001)
93798    (      10110111001100110)
37273    (       1001000110011001)
28262    (        110111001100110)
4505     (          1000110011001)
3686     (           111001100110)
409      (              110011001)
102      (                1100110)
25       (                  11001)
6        (                    110)
1        (                      1)
0        (                      0)


Input: Inf 
Output:
4812390, 3576217, 618086, 430489, 93798, 37273, 28262, 4505, 3686, 409, 102, 25, 6, 1, 0 


Input: Infinity
Output:
5291279215216915577, 3932092821637860230, 679593196789527673, 473328307817319302, 103132444486104185, 40982743589751686, 31074850448176249, 4953946570787718, 4053252683953273, 450346943417222, 112603010004089, 28134478351238, 7049893737593, 1746199284614, 452823970937, 96931842950, 40507110521, 28212366214, 6147372153, 2442562438, 1852404857, 295078790, 241792121, 26643334, 6911097, 1477510, 619641, 428934, 95353, 35718, 29817, 2950, 1145, 902, 121, 6, 1, 0

Su código debe admitir cadenas que se puedan representar como un número binario hasta el límite de su idioma. Todas las cadenas solo contendrán caracteres ASCII imprimibles de 32-126 (espacio para tilde).

Tabla de clasificación

Mostrar fragmento de código

code-golf base-conversion counting Stewie Griffin
fuente
31
Chuck Norris , 8 bytes:Inf:-1:0
Luis Mendo
2
@LuisMendo Chuck Norris 'NARS-APL:∞..0
Adám
55
@LuisMendo ¿Estás seguro de que no te refieres a Jon Skeet ?
mbomb007

Respuestas:

12

Jalea , 15 10 bytes

-5 bytes gracias a @Dennis (convertir directamente desde la base 256 después del reparto ordinal)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

¿Cómo?

Oḅ⁹µBCḄµÐĿ - Main link: s                     e.g. "Inf"
O          - cast to ordinals                 e.g. [73,110,102]
 ḅ⁹        - convert from base 256 to integer e.g. 4812390
   µ   µ   - monadic chain separations
    B      -     convert to binary
     C     -     complement
      Ḅ    -     convert to integer
        ÐĿ - loop until no longer unique and collect results
Jonathan Allan
fuente
1
La primera parte es justa Oḅ⁹.
Dennis
Oh Dios mío, ¿cómo me perdí eso?
Jonathan Allan el
11

Python 2, 89 82 77 76 75 bytes

n=0
for c in input():n=n<<8|ord(c)
while 1:print n;n^=2**n.bit_length()-n/n

Pruébalo en Ideone .

Cómo funciona

Después de inicializar n a 0 , la segunda línea realiza la conversión de cadena a entero especificada en los desafíos de la siguiente manera.

En cada paso, n se desplaza 8 unidades hacia la izquierda, luego bit a bit O con el punto de código del siguiente carácter c . Para la entrada Inf , esto es como sigue.

n                                  0
a = n<<8                           0
b = 'I'                      1001001
n = a ^ b                    1001001
a = n<<8             100100100000000
b = 'n'                      1101110
n = a ^ b            100100101101110
a = n<<8     10010010110111000000000
b = 'f'                      1100110
n = a ^ b    10010010110111001100110

Ahora estamos listos para generar la salida. Para invertir los bits de n , procedemos de la siguiente manera.

Primero, calculamos los bits en la representación binaria de n sin ceros a la izquierda. Llamemos al resultado k . Luego, calculamos la potencia k k de 2 , que tiene k + 1 dígitos binarios: un solo 1 , seguido de k 0 's. Restamos 1 del resultado, produciendo un número compuesto por k unos, que luego XOR con n para invertir sus bits. Para la entrada inf esto es como sigue.

n         4812390   10010010110111001100110
k              23 
t = 2**k           100000000000000000000000
t -= 1              11111111111111111111111
n ^= t    3576217    1101101001000110011001
k              22
t = 2**k            10000000000000000000000
t -= 1               1111111111111111111111
n ^= t     618086      10010110111001100110
.
.
.
n               6                       110
k               3
t = 2**k                               1000
t -= 1                                  111
n ^= t          1                         1
k               1
t = 2**k                                 10
t -= 1                                    1
n ^= t          0                         0

Un obstáculo adicional en la implementación es que tenemos que imprimir n antes del primer paso, después del último paso y en todos los pasos intermedios. Python no tiene bucles do-while y una sola declaración de impresión cuesta 8 bytes, por lo que hacemos lo siguiente.

En la implementación directa del paso de actualización, es decir,

while n:print n;n^=2**n.bit_length()-1
print n

reemplazamos el bucle con uno infinito ( while 1) y calculamos el 1en el bucle como n/n. Esto es equivalente mientras n> 0 .

Una vez que n = 0 , nos mantenemos informados, imprimimos el estado una vez más y luego intentamos actualizarlo. Sin embargo, 0/0desencadena un ZeroDivisionError , saliendo del bucle y saliendo con un error. Tenga en cuenta que esto provoca una salida perdida a STDERR, que está permitido de forma predeterminada .

Dennis
fuente
2
Me encanta ese -n/ntruco :-)
ETHproductions
¿Puedes explicar que n/ntruco? Probablemente se haya explicado en otra respuesta en alguna parte, pero no la he encontrado. Que hace aqui
Stewie Griffin
@StewieGriffin n / n es 1 hasta que n es 0, luego arroja un error y hace que el programa se detenga.
jazzpi
Con un mensaje de error (espero)?
Stewie Griffin
1
@StewieGriffin De hecho. Python es dolorosamente detallado cuando se trata de informes de errores. He editado mi respuesta para incorporar una explicación.
Dennis
8

JavaScript, 82 bytes

Guardado un byte gracias a @Arnuald

for(y of prompt(n=0))n=n<<8|y.charCodeAt()
for(;alert(n)|n;)for(i=1;i<=n;i*=2)n^=i
Expandir fragmento

Una de las pocas veces en que un programa completo supera a una función (y ES6 no supera a ES5) ...

Lo anterior admite palabras de hasta 4 letras. Agregue 4 bytes para admitir palabras de hasta 6 letras:

for(y of prompt(n=0))n=n*256+y.charCodeAt()
for(;alert(n)|n;n=i-n-1)for(i=1;i<=n;)i*=2
Expandir fragmento

ETHproducciones
fuente
g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0(-1)
Tito el
@Titus Gracias! No estoy seguro de por qué no pensé en eso
ETHproductions
n<<8|y.charCodeAt()Debería guardar un byte. for(;n;)for(i=!alert(n);i<=n;i*=2)n^=iguardaría otro byte, pero no se mostrará 0, lo que probablemente sea necesario.
Arnauld
@Arnauld Gracias. Pensé en hacerlo n<<8antes, pero decidí que no funcionaría porque se rompería para n con más de 31 bits. Supongo que no importa ahora que ya lo he dividido entre una versión de 31 bits y una versión de 53 bits ... Y lamentablemente, no creo que pueda guardar nada en la alerta mientras alerta a los dos primeros iteración y el último.
ETHproductions
7

En realidad , 14 bytes

2@├¿W■├♂≈♂Y2@¿

Pruébalo en línea!

Explicación:

2@├¿W■├♂≈♂Y2@¿
 @├             encode input in binary
2  ¿            convert from binary to decimal
    W           while the number is not 0:
     ■            print the number without popping
      ├           convert number to binary
       ♂≈         convert each character to an int
         ♂Y       boolean negate each int
           2@¿    convert from binary to decimal
Mego
fuente
6

05AB1E , 18 bytes

Utiliza la codificación CP-1252 .

Çžz+b€¦J[CÐ,_#bS_J

Pruébalo en línea!

Explicación

Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join
Emigna
fuente
4

MATL , 13 bytes

8W:qZA`tB~XBt

Pruébalo en línea!

Explicación

8W:q            % Push array [0 1 ... 255]
    ZA          % Take input string and convert it from the base defined by the
                % alphabet [0 1 ... 255] to decimal
      `         % Do...while
       t        % Duplicate
        B       % Convert to binary
         ~      % Negate
          XB    % Convert to decimal
            t   % Duplicate. Used as loop condition: exit if zero
Luis Mendo
fuente
4

Mathematica, 99 bytes

a=FromDigits;b=IntegerDigits;NestWhileList[a[1-#~b~2,2]&,a[Join@@b[ToCharacterCode@#,2,8],2],#>0&]&

Función anónima. Toma una cadena como entrada y devuelve una lista de números como salida.

LegionMammal978
fuente
4

Haskell, 109 123 118 102 97 bytes

¡Gracias a @nimi por guardar 5 bytes!

c 0=0
c n=1-mod n 2+2*c(div n 2)
(++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum

Uso: (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"

Garantizado para trabajar en números de hasta 29 bits por idioma, generalmente funciona con números de hasta 63 bits en sistemas de 64 bits. Utilice en su map(fromIntegral.fromEnum)lugar (+14 bytes) para admitir números arbitrariamente grandes.

Funciona para el rango unicode [0..255]. Voltea recursivamente bits.

Angs
fuente
1
Se puede reemplazar takeWhile(>0)con fst.span(>0). Si no tiene puntos, puede soltar el nombre f, por lo que su función principal es (++[0]) ... map fromEnum.
nimi
@nimi gracias, soltar el nombre resuelve el problema de inferencia de tipos que tuve con f.
Angs
¿Por qué fromIntegral? Del desafío: "debe admitir ... hasta 63 bits ... o el límite de su idioma", por lo que Intdebería estar bien. Si desea conservarlo, muévalo a map, es decir, su versión anterior de foldl1y map(fromIntegral.fromEnum).
nimi
@nimi OP publicó un comentario aquí (desde que se eliminó), preguntando si esto soportaba 63 bits, así que asumí que esa era su intención. Me gana
Angs
4

PHP, 132 126 123 120 108 107 bytes

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));
  • imprimir 0 después del ciclo en lugar del valor inicial antes del ciclo ahorra 6 bytes.
  • unpacken lugar de str_splitvolverse ord()obsoleto -> -3 bytes
  • subrayado _como separador guarda 3.
  • bindecen lugar de ltrimeliminar los ceros a la izquierda: -12
  • echoen el cuerpo del bucle ahorra 1 byte sobre la printcabeza del bucle.
Titus
fuente
No se $n=$n*256+$i;for(print$n;$n;)puede escribir como for(print$n=$n*256+$i;$n;)? Como la parte de la tarea se ejecutará una vez, esto debería funcionar. Y en lugar de echo _.$n=[...], debes usar echo _,$n=[...]en su lugar. No guardará ningún byte, pero acelerará el código un poquito minúsculo y separará las declaraciones. Eso significa que, por ejemplo, echo _,$a?5:6;se puede escribir en lugar de echo _.($a?5:6);. Esto puede ser útil en el futuro.
Ismael Miguel el
@IsmaelMiguel La parte de la tarea es un bucle. De hecho, uso la coma cuando no necesito el punto; Es un remanente del printen este caso. Solo no vale la pena editarlo; pero gracias.
Titus
Oh, claro ... Está dentro del foreach(unpack("C*",$argv[1])as$i)... tonto ... Y sí, cambiar un punto para que una coma tenga el mismo efecto no vale la pena.
Ismael Miguel
4

Perl, 65 bytes

Código de 53 bytes + 12 para -Mbigint -p.

Gracias a @ Dada por salvarme 13 bytes!

$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0

Enfoque bastante sencillo, solo diferente a la mayoría de estos es que el número se almacena como binario y se imprime en decimal. Estoy seguro de que se puede mejorar, tal vez con el almacenamiento de detalles en una matriz. -MbigintEs un poco incómodo pero necesario.

Uso

echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0
Dom Hastings
fuente
1
¡Desempaca mi amigo, desempaca! perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'(No tengo idea de cómo usar desempaquetar generalmente, tuve suerte al buscar en Google cómo convertir una cadena a binario ;-))
Dada
Ahhh, siempre me olvido de unpackla sintaxis que siempre me deja boquiabierto Voy a actualizar, gracias!
Dom Hastings
Hay perlpacktut que debería ayudar ... ¡He leído las primeras 10 líneas docenas de veces, pero realmente debería tomarme el tiempo para leer el resto!
Dada
@Dada Estoy seguro de que lo he leído muchas veces, simplemente nunca se queda en ... Gracias de nuevo -13 no es poca cosa! Tuve que cambiar echo -nes el único otro cambio.
Dom Hastings
4

Pyth, 12 bytes

.usi!MjN2 2C

Un programa que toma la entrada de una cadena entre comillas e imprime el resultado como una lista de enteros.

Verificar todos los casos de prueba

Cómo funciona

.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print
TheBikingViking
fuente
3

Python 3, 99 95 bytes

x=int.from_bytes(bytes(input(),'utf-8'),'big')
while x:print(x);x^=2**x.bit_length()-1
print(0)

La idea principal es convertir cadenas a bytes a números. Cada iteración imprime la salida y XOR con todos los 1 para avanzar hacia cero.

Jimmy Johnson
fuente
No necesitas paréntesis 2**x.bit_length()-1. El orden de las operaciones de potencia y sustracción es mayor que xor. Además, eso whilepuede estar en una sola línea.
mbomb007
Escriba el bucle while en una línea (elimine la nueva línea y la sangría)
FlipTack el
Intente iniciar el programa con P=printy luego usar en P()lugar deprint()
Cyoce
3

Python 2, 117115 bytes

Ahorro de 2 bytes gracias a Cyoce.

Asume una entrada entre comillas, p. Ej. "Inf"

s=input()
n=sum(ord(s[-i-1])<<i*8for i in range(len(s)))
while n:
 print n;k,m=n,1
 while k:k/=2;m*=2
 n^=m-1
print 0

mcuenta hasta el dígito más alto, por lo que m-1es una máscara XOR para realizar la operación deseada. La parte más larga es convertir la entrada en la secuencia de bits inicial.

Ejemplo:

"Inf"
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

"Infinity"
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0
Karl Napf
fuente
Puede reemplazar -i-1con~i
Cyoce
3

Ruby, 104 101 100 81 80 65 bytes

¡19 bytes guardados gracias a @WayneConrad!
¡15 bytes guardados gracias a @philomory!
1 byte guardado gracias a @LeeW!

p n=$*[0].unpack('B*')[0].to_i(2)
p n^=2**n.bit_length-1while n>0

Toma entrada a través de argumentos de línea de comando.

Inspirado en la respuesta de Python de @ JimmyJohnson

Cyoce
fuente
Es posible que pueda guardar algunos caracteres reemplazándolos i.to_s(2).rjust 8,'0'con"%08b"%i
Wayne Conrad el
Además, creo que inject(:+)se puede reemplazar conjoin
Wayne Conrad
@WayneConrad gracias por la ayuda! No estoy seguro de cómo me olvidé de eso
Cyoce
Me alegro de poder ayudar! Gracias por enseñarme el método #bit_length, que no conocía.
Wayne Conrad el
1
Cambiar a unpackseguido por en [0]lugar de jugar con gsubahorrará 11 bytes. Cambiar a en $*[0]lugar de gets.chop(usando un argumento de línea de comando en lugar de la entrada de la consola) guardará otros 9, la primera línea se convierte p n=$*[0].unpack('B*')[0].to_i(2).
philomory
3

Laberinto , 104 103 bytes

'  )25 }_';:_';_2/;{
''', 6 2 1   1   { (
 ' | / _ _   _}*2_ $
 * _ :!\ }2_\     !:
 652       @'''''''

Pruébalo en línea!

Explicación:

Imagen codificada por colores del código fuente

El puntero de instrucción comienza en el carácter no mural más superior izquierdo (los muros incluyen espacios y cualquier letra excepto v).

Naranja:

Este bucle obtiene la entrada de un carácter a la vez como un código ASCII, agregándolo al valor actual y multiplicando el valor actual por 256.

  • ' No-op
  • ,Empuje el código ascii del siguiente carácter de entrada a la parte superior de la pila o -1 si es EOF. En este punto, si se recibió una entrada, el código girará a la derecha (moviéndose hacia abajo) porque la parte superior de la pila está llena. De lo contrario, girará a la izquierda porque la parte superior de la pila es negativa.
  • | Haga estallar los dos primeros elementos de la pila y presione el resultado de un OR bit a bit.
  • _ Empuje cero
  • 256Cada dígito visto aparece xy empuja x*10+digit. Así que esto se combina con el empuje cero anterior empuje 256 a la parte superior de la pila.
  • *Pop y, pop x, push x*y. En este punto, dado que la parte superior de la pila es positiva, el código girará a la derecha para continuar alrededor del ciclo.

Azul:

  • )Incrementa la parte superior de la pila. Cuando se alcanza el final de la entrada, el código girará a la izquierda para llegar a este punto con un -1 en la pila que se incrementará a cero.
  • 256 Tener la parte superior de la pila 0 nos permite empujar este 256.
  • /Pop y, pop xpush x/y(división entera). Como estábamos multiplicando la entrada por 256 cada ciclo, necesitamos revertir la última multiplicación.
  • : Duplique la parte superior de la pila para que tengamos una copia del valor actual para más adelante.
  • ! Haga estallar la parte superior de la pila e imprima el valor entero en STDOUT.
  • \ Imprime una nueva línea.
  • _2 Empuja un dos a la parte superior de la pila.
  • } Mueva la parte superior de la pila a la parte superior de la pila auxiliar.

Rojo:

Este bucle invierte los bits del valor actual por XOR con un valor particular calculado en el bucle interno (verde). Luego emite el valor actual y sale del programa si el valor actual es cero.

  • _ Empuje cero (flujo de control).
  • ; Deseche la parte superior de la pila (flujo de control).
  • :Duplicar el valor actual. La copia se usará para calcular el XOR.
  • _ Empuje cero (flujo de control).
  • (Lazo verde)
  • $Pop y, pop x, Push x XOR y.
  • :! Duplique el valor actual e imprima la representación entera.
  • Si el valor actual es 0, continuamos directamente @y terminamos .
  • \ Imprime una nueva línea.
  • _2} Presione 2 y muévase a la pila auxiliar.
  • _1 Empuje 1 (flujo de control).

Verde:

Este bucle calcula el valor por el cual necesitamos XOR el valor actual. Esto se hace doblando repetidamente la parte superior de la pila auxiliar mientras reduce a la mitad una copia del valor actual en el tope de la pila principal hasta que llegue a 0.

  • _ Empuje cero (flujo de control).
  • ; Descarte el valor actual que solo se usa para imponer el flujo de control.
  • _2 Presione 2 para reducir a la mitad el valor actual.
  • / Dividir
  • { Mueva la parte superior de la pila auxiliar a la parte superior de la pila principal.
  • _2* Doblar la parte superior de la pila
  • } Mueva la parte superior de la pila principal de nuevo a la pila auxiliar.
  • _1 Presione uno para controlar el flujo.
  • Después de salir del bucle:
  • ; Deseche la izquierda sobre cero para calcular el XOR.
  • { Mueva el XOR calculado a la pila principal.
  • ( Resta uno del valor XOR.
Robert Hickman
fuente
2

PowerShell v2 +, 158 bytes

for($a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)});$a){[convert]::ToInt64($a,2);$a=$a.TrimStart('0')-split0-replace1,0-join1}

Sí, entonces, convertir bases en PowerShell es realmente desagradable . Y podemos hacerlo dos veces aquí.

Bien, esto es solo un forbucle $aactivado, es decir, hacemos un bucle mientras $aexista. Eventualmente llegaremos a una cadena vacía (que es falsey), así es como terminaremos.

La configuración del bucle, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})toma la entrada $args[0], la charconvierte como una matriz y recorre cada personaje. Usamos .NET [convert]::ToString(int,base)para convertir cada uno en una cadena binaria. Sin embargo, eso no incluye ceros a la izquierda, por lo que debemos volver a emitir esa cadena como una [int]y llamar a su .ToString() método con 8ceros como máscara. Luego, esas cadenas se encapsulan en parens y se editan -joinjuntas, luego se guardan en $a.

Dentro del bucle, debemos [convert]::ToInt64(string,base)convertir el número binario en un número decimal. Eso queda en la tubería y luego se vacía cuando el bucle se restablece (y, por lo tanto, se imprime implícitamente). La siguiente sección realiza los cálculos: eliminamos .TrimStart()los ceros -split0a la izquierda, dividimos los ceros y obtenemos una stringserie de 1s, -replacelos que tienen ceros y finalmente -joinla matriz junto con 1s. Entonces, el ciclo comienza de nuevo.

PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0
AdmBorkBork
fuente
2

CJam , 17 16 18 bytes

q256b0{_p2b:!2bj}j

Pruébalo en línea!

q256b   e# read printable ascii to integer
0       e# value for terminal case
{       e# recursive function
  _p    e#   print current number
  2b    e#   create binary representation with no leading zeros
  :!    e#   flip bits
  2b    e#   convert binary back to integer
  j     e#   recursive call
}j      e# end

NOTA: La versión anterior de 16 bytes no se comportaba correctamente con cadenas vacías:

q256b{_p2b:!2b}h

Además, gracias a Dennis por sugerir pqué ahorra 1 byte sobre N\poner nuevas líneas en la pila.

Linus
fuente
_p2b:!2bGuarda un byte. Además, debes usar l; rfallará si la entrada contiene espacios.
Dennis
@ Dennis Gracias, aunque esto ahora me preocupa si una cadena vacía es un problema.
Linus
Derecha. qfuncionará correctamente con cadenas vacías.
Dennis
2

J, 24 bytes

256-.&.#:^:*^:a:@#.a.&i.

¡La explicación vendrá después!

Olius
fuente
2
Bienvenido a PPCG! Enlace permanente para los interesados: ¡ Pruébelo en línea!
Dennis
1

Retina, 116 bytes

El recuento de bytes asume la codificación ISO 8859-1. La línea 5 contiene bytes no imprimibles. Es T`\x00-\xFF.

-2`
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+
$*
+`(1+)\1
${1}0
01
1


{*(`1
01
+`10
011
^0+

)M`1
^0+

T`01`10

Pruébalo en línea

No intente esto con una entrada de más de dos caracteres. (Se agota el tiempo usando el intérprete en línea). Tenemos que convertir el binario a unario antes del decimal. :RE

Desafortunadamente, hay un cero al final y un salto de línea, pero decidí asumir que estaba bien porque el resultado sigue siendo correcto.

Explicación

-2`         # Convert ASCII to decimal (ord)
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+         # Decimal to binary
$*
+`(1+)\1
${1}0
01
1


{*(`1       # Loop; Loop print and undo; Convert binary to unary
01
+`10
011
^0+

)M`1        # Unary to decimal; End print and undo
^0+         # Remove leading zeros

T`01`10     # Flip bits; (implicit loop end)
mbomb007
fuente
1

Ruby - 70 bytes

λ cat inf.rb
n,=$*[0].unpack 'B*';loop{p n.to_i(2);n.tr!('10','01').sub!(/^0*/,'')}
λ ruby inf.rb Hello
310939249775
788572378000
310939249775
238816564112
36061342831
32658133904
1701604463
445879184
90991727
43226000
23882863
9671568
7105647
1282960
814191
234384
27759
5008
3183
912
111
16
15
0
inf.rb:1:in `block in <main>': undefined method `sub!' for nil:NilClass (NoMethodError)
        from inf.rb:1:in `loop'
        from inf.rb:1:in `<main>'

El programa sale con una excepción después de completar, pero entiendo que eso está bien siempre que la salida de error vaya a STDERR en lugar de STDOUT (lo que hace).

philomory
fuente
1

C, 147 135 133 125 122 121 117 115 103 bytes

¡Guardado 5 bytes gracias a @Cyoce!

¡Ahorré 2 bytes gracias a @Cyoce y @cleblanc!

Guardado 12 bytes gracias a @ceilingcat

i,n;main(p,v)char**v;{while(*v[1])i=i*256+*v[1]++;for(;printf("%d\n",n=i),i;i^=p-1)for(p=2;n/=2;)p*=2;}

Sin golf:

int i;
int main (c,v) {
    char**v;
    while (*v[1]) /* put first command line argument into i as binary */
        i = i*256 + *v[1]++;
    while (i != 0) { 
        printf("%d\n",i);
        int p = 2,n = i;
        while (n /= 2) /* calculate smallest power of 2 > i */
            p *= 2;
        i ^= p - 1; /* flip bits */
    }
}
Fideos9
fuente
Creo que puedes dejar de lado las intdeclaraciones
Cyoce
También puede guardar un byte al convertir el último whilebucle en un forbucle
Cyoce
Y puede cambiar while(1)afor(;;)
Cyoce
@Cyoce Intenté eliminar intdeclaraciones en todas partes y obtuve gcc -std=89errores. Pero gracias por el for(;;)consejo. int
Seguiré
lo siento, no lo probé. Creo que funcionará si los mueves a la parte superior ( i;main(c,v)char**v;{...}). En el móvil ahora, así que no puedo estar seguro
Cyoce
0

C, 129 120 117 110 107 105 Bytes

long long i,m,n;f(char*v){for(;*v;i<<=8,i+=*v++);for(;printf("%llu,",i),n=i;i^=m-1)for(m=2;n>>=1;m<<=1);}

Probado con

main (int c, char**v) {
    f(v[1]);
}

salida

5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,
cleblanc
fuente
Creo que puede pasar i=0a la declaración de iy dejar en forblanco la sección de inicialización del ciclo
Cyoce
@Cyoce La función debe funcionar cada vez que se llama y, dado que ies int global implícito, debe inicializarse cada vez que se llama f (...).
cleblanc el
@Cyoce Tenías razón después de todo. La función no sale hasta que isea ​​cero nuevamente, por lo que aún es reutilizable.
cleblanc
102 bytes
ceilingcat
0

C #, 360 359 bytes

using w=System.Console;using q=System.Convert;s={System.Func<int,int,string>S=q.ToString;string t="",f="";for(int i=0;i<s.Length;i++)t+=i>0?S(s[i],2).PadLeft(8,'0'):S(s[i],2);w.WriteLine(q.ToInt64(t,2).ToString());while(t!="0"){f="";foreach(var n in t)f+=n=='0'?'1':'0';t=f.TrimStart(new char[]{'0'});t+=t==""?"0":"";w.WriteLine(q.ToInt64(t,2).ToString());}};

Programa completo:

using w = System.Console;
using q = System.Convert;

class a
{
    static void Main()
    {
        System.Action<string> b = s =>
        {
            System.Func<int,int,string> S = q.ToString;
            string t = "", f = ""; // Var does not work here
            for(int i = 0; i < s.Length; i++)
                t += i > 0 ? S(s[i], 2).PadLeft(8, '0') : S(s[i], 2);
            w.WriteLine(q.ToInt64(t, 2).ToString());
            while(t != "0")
            {
                f = "";
                foreach (var n in t) f += n== '0' ? '1' : '0';
                t = f.TrimStart(new char[] { '0' });
                t += t == "" ? "0" : "";
                w.WriteLine(q.ToInt64(t, 2).ToString());
            }
        };

        b("Inf");
        b("Infinity");
        w.Read(); // prevent close in VS
    }
}
Yodle
fuente
No hago C #, pero puedo var t="";var f="";ser var t="",f=""en su lugar? Ahorra 5 bytes.
corsiKa
@corsiKa Sí, lo intenté pero me dio un error, supongo que es var y no string.
Yodle
En realidad, la cadena ahorra un byte, así que supongo que lo haré de esa manera.
Yodle
¿También puede hacer que una variable az sea cero para guardar esas citas desagradables?
corsiKa
Solo lo intenté, en realidad aumenta el bytecount porque no puedo reemplazar tanto la cadena "0" como el char '0' :(
Yodle