Paul es uno de tus conocidos belgas, y le gustaría que crees un programa que genere al menos una de las siguientes cinco cadenas :

12496=>14288=>15472=>14536=>14264

14264=>12496=>14288=>15472=>14536

14536=>14264=>12496=>14288=>15472

15472=>14536=>14264=>12496=>14288

14288=>15472=>14536=>14264=>12496

Representa a los amigos de los que está más orgulloso y le gustaría comer con ellos. Paul también piensa que el número 6 es perfecto, y ese es el único número que vale la pena usar. Por lo tanto, no puede utilizar ningún otro dígito que no sea "6" en su código (de 0 a 5 y de 7 a 9 están prohibidos). Su programa no puede tomar ninguna entrada. La salida puede contener basura antes y / o después de la cadena, pero debe contener al menos una de las cadenas anteriores.

Por ejemplo, esta es una salida válida:

220frefze
f**14288=>15472=>14536=>14264=>12496**fczfe fz**15472=>14536=>14264=>12496=>14288**zfe
fzehth

"Ligeramente" insinué en la pregunta cómo espero que esto se resuelva, pero ¿cómo sabe? Tal vez hay una mejor manera ... Espero que te diviertas.

Este es el código de golf: gana la puntuación más baja en bytes.

05AB1E , 18 17 bytes

•w[•Y·FDѨO})„=>ý

Pruébalo en línea!

Explicación

•w[•                # base 214 encoding of 12496
    Y·F             # loop 2*2 times
       D            # duplicate top of stack
        Ñ           # push divisors
         ¨          # remove the last element (itself)
          O         # sum
           }        # end loop
            )       # wrap in list
             „=>ý   # join list on "=>"

En resumen, calculamos cada número como f(n+1) = sum(divisors(f(n)) - f(n)

Pyke, 16 bytes

wヰw$VDlsh)J"=>

Pruébalo aquí!

wヰ             -  12496
  w$            -   4
    V    )      -  repeat ^:
     D          -   duplicate(^)
      l         -     factors(^)
       s        -    sum(^)
        h       -   ^ + 1
          J     - v.join(^)
           "=>  -  "=>"

Cada vez que un literal de cadena está al final de un programa, lo intercambia con el token justo antes, guardando 1 byte en casos como este. La factorsfunción de Pyke no incluye el número en sí ni 1. Si se permitieran los números, se podría guardar 1 byte reemplazándolo w$con4

Pyke, 21 bytes

uバ㟐㱰㣈㞸J"=>

Pruébalo aquí!

Crea una lista de los números requeridos y únelos. No es muy interesante aparte del truco con las cuerdas.

MATLAB, 44 bytes

['','=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'-6-6]

Pruébalo en línea!

No he encontrado un patrón en los números (y de todos modos sería difícil usar el patrón para cualquier cosa, ya que no puedo usar números), así que seguiré con el enfoque ingenuo.

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'es la cadena '12496=>14288=>15472=>14536=>14264'cuando se agrega 12 a los valores ASCII. Ahora, ingrese esa cadena, reste 6+6y concatene con la cadena vacía ''para convertirla en una matriz de caracteres.

JavaScript (ES6), 57 bytes / 47 (UTF-8) caracteres

Gracias a user5090812 por 10 B guardar

_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`

Explicación

Primero creamos una matriz y la llenamos con los caracteres de la cadena バ㟐㱰㣈㞸. Luego recorremos la cadena ( atiene el valor del elemento actual) y cambiamos el carácter a su código de carácter. Luego unimos todos los valores en la matriz por =>.

Antiguo: 67 bytes

_=>[6,6,6,6,6].map((_,a)=>`バ㟐㱰㣈㞸`.charCodeAt(a)).join`=>`

Explicación

Primero creamos una matriz de longitud 5. Luego cambiamos los valores de la matriz en cada índice para el código de carácter del personaje en el mismo índice en la cadena バ㟐㱰㣈㞸, que son los números de todos los amigos de Paul en orden. Cuando obtuvimos eso, unimos la matriz y la usamos =>como separador.

Uso

Para usarlo, simplemente ejecute esto:

f=_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`;alert(f())

Salida

12496=>14288=>15472=>14536=>14264

Ruby, 36 bytes (26 caracteres)

p"バ㟐㱰㣈㞸".unpack("U*")*"=>"

Porque, porque no. Aburrido como el infierno.

versión anterior - 53 bytes

p %w(jol mld oim n6b mke).map{|x|x.to_i ~-6*~-6}*'=>'

Explicación: codificar los números en la base 25 da las 5 cadenas libres de seis, para decodificarlas solo tengo que representar el número 25 usando solo 6: (6-1) (6-1) => ~ -6 ~ -6

Perl 6 , 63 59 bytes

{$/=6;$/--;join "=>",<JOL MLD OIM N6B MKE>».parse-base($/*$/)}

{join "=>",<JOL MLD OIM N6B MKE>».parse-base(--($_=6)*$_)}

Decodifica los números de la base 25, porque esa es la única base admitida por .parse-base(2 a 36) donde ninguno de ellos tiene dígitos no válidos.

Gracias a Neil por -3 bytes.

Perl 6 , 82 75 bytes

{my \a="BXS".parse-base(6*6);join "=>",(a,{sum grep $_%%*,^$_}...^{$_==a if $++})}

{my \a="BXS".parse-base(6*6);join "=>",({$/=$_//a;sum grep $/%%*,^$/}...a)}

Decodifica el número 15472en la base 36, y luego genera la secuencia calculando cada número como la suma de los divisores propios del número anterior.

Perl 6 , 69 bytes (47 caracteres) - sin competencia

{"{١٢۴۹6}=>{١۴۲۸۸}=>{١۵۴۷۲}=>{١۴۵۳6}=>{١۴۲6۴}"}

¡No usa ninguno de los dígitos ASCII prohibidos, usa dígitos Unicode del bloque árabe-índico (2 bytes cada uno)! Las { }interpolaciones de cadenas se aseguran de que se analizan como literales de números Perl 6 y luego se encadenan a sus representaciones ASCII.

Bien, esto es trampa - es por eso que no lo usé como mi respuesta principal ... :)

Jalea , 5 4 bytes

ȷṗȷỌ

Imprime las cinco cadenas. Aprovecha el hecho de que se permite la salida "basura" y entierra las cinco cadenas en 10 ³⁰⁰³ caracteres de salida.

Cómo funciona

ȷṗȷỌ  Main link. No arguments.

ȷ     Set the return value to 1000.
 ṗȷ   Cartesian power; form all arrays of length 1000 that consist of integers in
      [1, ..., 1000].
   Ọ  Unordinal; convert all integers to characters.

C, 94 84 77 Bytes

Stoopid simple. Un agradecimiento especial @Neil

g(){char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";for(;*++m;)putchar(*m-66+6);}

f () {printf ("% d =>% d =>% d =>% d =>% d", '~' 'r' - 'd', '~' 'd' - 'h', ' ~ ' ' r '-' L ',' ~ ' ' z '+' d ',' ~ '*' t '-' P ');}

PHP, 73 63 60 bytes

for(;$c="|`*X6H-$*@"[$i];)echo!!$i&++$i?"=>".!!6:"",ord($c);

Corre con -nr.

un poco menos vago: tomó cadena como lista de =>1(ascii)(ascii)
decir: 124, 96, =>1, 42, 88, =>1, 54, 72, =>1, 45, 36,=>1 , 42, 64,
imprimir =>1por índice de cadena, agregar código ASCII

Descompostura

            # loop through string with index $i
for(;$c="|`*X6H-$*@"[$i];)echo
            # string ascii values: 124,96,42,88,54,72,45,36,42,64
    !!$i        # true if $i>0
    &++$i       # odd if (old) $i is 0,2,4,6,8
                # -> true for 2,4,6,8
        ?"=>".!!6   # if true, print "=>1"
        :"",        # else print nothing
    ord($c);    # print ascii value

C ++, 92 bytes

#include <cstdio>
int main(){for(char c:"UVX]ZabUXV\\abUYX[VabUXYWZabUXVZX")putchar(c-6*6);}

PHP, 53 bytes

<?=join('=>',unpack('v*',gzinflate('�`p������s')));

Volcado hexadecimal:

00000000: 3c3f 3d6a 6f69 6e28 273d 3e27 2c75 6e70  <?=join('=>',unp
00000010: 6163 6b28 2776 2a27 2c67 7a69 6e66 6c61  ack('v*',gzinfla
00000020: 7465 2827 bb60 70c1 bcc0 e684 c50e 7300  te('.`p.......s.
00000030: 2729 2929 3b                             ')));

Salida:

12496=>14288=>15472=>14536=>14264

Explicación:

Cada una de las secciones enteras de cinco dígitos se codifica como un pequeño endian corto sin signo, luego se concatenan juntos y el resultado se comprime. Esto produce un byte steam que no tiene caracteres de dígitos ofensivos, que luego se codifica en una cadena. Para extraer, descomprima el flujo, desempaquete los cortos de dos bytes, interprete cada uno como una cadena y únase a ellos >=.

Java 8, 134 bytes

Golfizado:

()->{String s="";for(String a:new String[]{"JOL","MLD","OIM","N6B","MKE"}){if(!s.isEmpty())s+=("=>");s+=Long.valueOf(a,25);}return s;}

Ungolfed, programa completo:

import java.util.function.*;

public class FindFiveFriendsToEatChickenWithPaul {

  public static void main(String[] args) {
    System.out.println(toString(() -> {
      String s = "";
      for (String a : new String[] { "JOL", "MLD", "OIM", "N6B", "MKE" }) {
        if (!s.isEmpty()) s += ("=>");
        s += Long.valueOf(a, 25);
      }
      return s;
    }));

  }

  private static String toString(Supplier<String> s) {
    return s.get();
  }

}

Lote, 191 bytes

@set/as=n=66*(66+66+66+6*6)+66/6+66/6+6,u=6/6
@call:t
@call:t
@echo %s: ==^>%
@exit/b
:t
@call:c
:c
@for /l %%i in (%u%,%u%,%n%)do @set/an-=%%i*!(%n%%%%%i)
@set/an=-n
@set s=%s% %n%

Calculo que tomaría un mínimo de 32 bytes para calcular cada número usando solo 6s más otros 32 para imprimirlos todos, que ya son 192 bytes, por lo que estoy ganando al calcular la cadena amigable. Además, creo que cinco %s seguidos es un récord para mí. Además, el truco ordenado de Batch: %n%se sustituye antes de forevaluar el bucle, por lo que el bucle calcula todos los factores ny los resta n, lo que resulta en la negación del resultado deseado.

Jalea , 12 bytes

“<ọ’ÆṣÐĿj“=>

Imprime la cuarta cadena y nada más.

Pruébalo en línea!

Cómo funciona

“<ọ’ÆṣÐĿj“=>  Main link. No arguments.

“<ọ’          Yield the 1-based indices of '<' and 'ọ' in Jelly's code page, i.e.,
              [61, 222], and convert the array from base 250 to integer.
              This yields 15472.
      ÐĿ      Iteratively call the link to the left until the results are no longer
              unique and return the array of all unique results.
    Æṣ        Compute the proper digit sum of the previous value (initially 15472).
        j“=>  Join, separating by the string "=>".

Python 2, 78 72 bytes

print''.join(chr(ord(x)-6-6)for x in'=@>DDIJ=A@C>IJ=@A?BIJ=@>B@IJ=>@EB')

Editar - Gracias a Stewie Griffin por guardar 6 bytes!

Además, otra solución sería generar todas las permutaciones posibles. OP dice que la basura está bien.

from itertools import permutations
print str(list(permutations(''.join(str(x)+'.'for x in range(int('9'*5)).replace(',','').replace('\'','') 
# also 9 and 5 need to be converted using ord and chr

Hay demasiada redundancia en la conversión de into listhacia str. Supongo que esto sería más fácil en algunos idiomas esotéricos, pero no conozco ninguno de ellos.