Paul é um dos seus conhecidos belgas e deseja que você crie um programa que produz pelo menos uma das cinco seqüências a seguir :

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 os amigos dos quais ele mais se orgulha e gostaria de comer com eles. Paulo também acha que o número 6 é perfeito, e esse é o único número que vale a pena usar. Portanto, você não pode usar nenhum outro dígito além de "6" no seu código (0 a 5 e 7 a 9 são proibidos). Seu programa não pode receber nenhuma entrada. A saída pode conter lixo antes e / ou após a sequência, mas deve conter pelo menos uma das seqüências acima.

Por exemplo, esta é uma saída válida:

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

Eu "levemente" sugeri a pergunta como eu espero que isso seja resolvido, mas como sabe? Talvez haja uma maneira melhor ... Espero que você se divirta.

Este é o código-golfe: a menor pontuação em bytes vence.

05AB1E , 18 17 bytes

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

Experimente online!

Explicação

•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 "=>"

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

Pyke, 16 bytes

wヰw$VDlsh)J"=>

Experimente aqui!

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

Sempre que um literal de cadeia de caracteres está no final de um programa, ele o troca com o token logo antes, economizando 1 byte em casos como este. A factorsfunção do Pyke não inclui o número em si nem 1. Se os números fossem permitidos, 1 byte poderia ser salvo substituindo-o w$por4

Pyke, 21 bytes

uバ㟐㱰㣈㞸J"=>

Experimente aqui!

Crie uma lista dos números necessários e os junte. Não é muito interessante, além do truque com as cordas.

MATLAB, 44 bytes

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

Experimente online!

Eu não encontrei um padrão nos números (e seria difícil usá-lo para qualquer coisa, pois não posso usar números), por isso vou apenas para a abordagem ingênua.

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'é a sequência '12496=>14288=>15472=>14536=>14264'quando 12 é adicionado aos valores ASCII. Agora, insira essa sequência, subtraia 6+6e concatene com a sequência vazia ''para convertê-la em uma matriz de caracteres.

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

Obrigado ao user5090812 por 10 B de salvamento

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

Explicação

Primeiro, criamos uma matriz e a preenchemos com os caracteres da string バ㟐㱰㣈㞸. Em seguida, fazemos um loop sobre a string ( atem o valor do elemento atual) e alteramos o caractere para seu código de caractere. Em seguida, juntamos todos os valores na matriz por=> .

Antigo: 67 bytes

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

Explicação

Primeiro, criamos uma matriz de comprimento 5. Em seguida, alteramos os valores da matriz em cada índice para o código de caractere no mesmo índice da string バ㟐㱰㣈㞸, que são os números de todos os amigos de Paul em ordem. Quando chegamos a isso, juntamos a matriz e usamos =>como separador.

Uso

Para usá-lo, basta executar o seguinte:

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

Resultado

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

Ruby, 36 bytes (26 caracteres)

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

Porque porque não? Chato como o inferno.

versão mais antiga - 53 bytes

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

Explicação: a codificação dos números na base 25 fornece as 5 seqüências sem seis, para decodificá-las, só tenho que representar o número 25 usando apenas 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 os números da base 25, porque essa é a única base suportada pelo .parse-base (2 a 36) em que nenhum deles possui dígitos inválidos.

Agradecimentos 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 o número 15472 na base 36 e, em seguida, gera a sequência calculando cada número como a soma dos divisores adequados do número anterior.

Perl 6 , 69 bytes (47 caracteres) - não-concorrentes

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

Não usa nenhum dos dígitos ASCII proibidos, usa dígitos Unicode do bloco árabe-indicador (2 bytes cada)! As { }interpolações de strings garantem que sejam analisadas como literais numéricos Perl 6 e, em seguida, strifificadas para suas representações ASCII.

Ok, isso é trapaça - é por isso que eu não a usei como minha principal resposta ... :)

Geléia , 5 4 bytes

ȷṗȷỌ

Imprime todas as cinco cadeias. Aproveita o fato de que a saída de "lixo" é permitida e enterra as cinco seqüências em 10 ³⁰⁰³ caracteres de saída.

Como 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. Agradecimentos especiais @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);

Corra com -nr.

um pouco menos preguiçoso: tomou cordas lista de como =>1(ascii)(ascii)
isto é: 124, 96, =>1, 42, 88, =>1, 54, 72, =>1, 45, 36, =>1, 42, 64,
imprimir =>1por índice de string, acrescentar código ascii

demolir

            # 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')));

Despejo hexagonal:

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                             ')));

Resultado:

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

Explicação:

Cada uma das seções inteiras de cinco dígitos é codificada como um pequeno endian curto não assinado, depois é concatenada e o resultado é compactado em gzip. Isso produz um byte steam que não possui caracteres de dígito incorreto, que é então codificado em uma string. Para extrair, descompacte o gzip do fluxo, descompacte os shorts de dois bytes, interprete cada um como uma sequência e junte-se a ele >=.

Java 8, 134 bytes

Golfe:

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

Programa completo e não-destruído:

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%

Estimo que levaria um mínimo de 32 bytes para calcular cada número usando apenas 6s mais outros 32 para imprimi-los, o que já é 192 bytes, então estou ganhando calculando a cadeia amigável. Além disso, acho que cinco %segundos seguidos é um recorde para mim. Além disso, truque de lote puro: o %n%é substituído antes da foravaliação do loop, para que o loop calcule todos os fatores de ne os subtraia n, resultando na negação do resultado desejado.

Gelatina , 12 bytes

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

Imprime a quarta corda e nada mais.

Experimente online!

Como 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 - Obrigado a Stewie Griffin por salvar 6 bytes!

Além disso, outra solução seria produzir todas as permutações possíveis. O OP diz que o lixo está bom.

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

Há muita redundância na conversão de intou listpara str. Acho que isso seria mais fácil em algumas línguas esotéricas, mas não conheço nenhuma delas.