Paul è uno dei tuoi conoscenti belgi e vorrebbe che tu creassi un programma che produce almeno una delle seguenti cinque stringhe :

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

Rappresenta gli amici di cui è più orgoglioso e vorrebbe mangiare con loro. Paul pensa anche che il numero 6 sia perfetto e che sia l'unico numero che valga la pena usare. Pertanto non è possibile utilizzare cifre diverse da "6" nel codice (da 0 a 5 e da 7 a 9 sono vietate). Il tuo programma non può accettare alcun input. L'output può contenere immondizia prima e / o dopo la stringa ma dovrebbe contenere almeno una delle stringhe sopra.

Ad esempio questo è un output valido:

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

Ho "delicatamente" accennato alla domanda come mi aspetto che questo venga risolto, ma come lo sa? Forse c'è un modo migliore ... Spero che ti diverta.

Questo è code-golf: vince il punteggio più basso in byte.

05AB1E , 18 17 byte

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

Provalo online!

Spiegazione

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

In breve, calcoliamo ogni numero come f(n+1) = sum(divisors(f(n)) - f(n)

Pyke, 16 byte

wヰw$VDlsh)J"=>

Provalo qui!

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

Ogni volta che un letterale di stringa si trova alla fine di un programma, lo scambia con il token appena prima di esso, salvando 1 byte in casi come questo. La factorsfunzione di Pyke non include il numero stesso né 1. Se i numeri fossero consentiti, è possibile salvare 1 byte sostituendolo w$con4

Pyke, 21 byte

uバ㟐㱰㣈㞸J"=>

Provalo qui!

Crea un elenco dei numeri richiesti e li unisce. Non molto interessante a parte il trucco con le corde.

MATLAB, 44 byte

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

Provalo online!

Non ho trovato uno schema nei numeri (e sarebbe comunque difficile usare lo schema per qualsiasi cosa, dato che non posso usare i numeri), quindi mi limiterò a seguire l'approccio ingenuo.

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'è la stringa '12496=>14288=>15472=>14536=>14264'quando 12 viene aggiunto ai valori ASCII. Ora, inserisci quella stringa, sottrai 6+6e concatena con la stringa vuota ''per convertirla in una matrice di caratteri.

JavaScript (ES6), 57 byte / 47 (UTF-8) caratteri

Grazie all'utente 5090812 per un risparmio di 10 B.

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

Spiegazione

Per prima cosa creiamo un array e lo riempiamo con i caratteri nella stringa バ㟐㱰㣈㞸. Quindi passiamo sopra la stringa ( aha il valore dell'elemento corrente) e cambiamo il carattere nel suo codice carattere. Quindi uniamo tutti i valori nella matrice di=> .

Vecchio: 67 byte

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

Spiegazione

Per prima cosa creiamo una matrice di lunghezza 5. Quindi cambiamo i valori della matrice in ciascun indice per il codice carattere del carattere con quello stesso indice nella stringa バ㟐㱰㣈㞸, che sono i numeri di tutti gli amici di Paul in ordine. Quando l'abbiamo ottenuto, uniamo l'array insieme e lo usiamo =>come separatore.

uso

Per usarlo, esegui semplicemente questo:

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

Produzione

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

Ruby, 36 byte (26 caratteri)

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

Perché, perché no. Noioso da morire.

versione precedente - 53 byte

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

Spiegazione: la codifica dei numeri nella base 25 fornisce le 5 sei stringhe libere, per decodificarle devo solo rappresentare il numero 25 usando solo 6: (6-1) (6-1) => ~ -6 ~ -6

Perl 6 , 63 59 byte

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

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

Decodifica i numeri dalla base 25, poiché questa è l'unica base supportata da .parse-base( da 2 a 36) in cui nessuno di loro ha cifre non valide.

Grazie a Neil per -3 byte.

Perl 6 , 82 75 byte

{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 il numero 15472 nella base 36 e quindi genera la sequenza calcolando ciascun numero come la somma dei divisori propri del numero precedente.

Perl 6 , 69 byte (47 caratteri) - non competitivo

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

Non usa nessuna delle cifre ASCII proibite, usa invece le cifre Unicode dal blocco Arabo-Indic (2 byte ciascuna)! Le { }interpolazioni di stringhe si assicurano che siano analizzate come letterali numerici Perl 6 e che quindi siano stringite alle loro rappresentazioni ASCII.

Ok, questo è barare - ecco perché non l'ho usato come mia risposta principale ... :)

Gelatina , 5 4 byte

ȷṗȷỌ

Stampa tutte e cinque le stringhe. Sfrutta il fatto che l'output "immondizia" è consentito e nasconde le cinque stringhe in 10 ³⁰⁰³ caratteri di output.

Come funziona

ȷṗȷỌ  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 byte

Stoopid semplice. Un ringraziamento speciale a @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 byte

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

Corri con -nr.

un po 'meno pigro: ha preso stringa come elenco di =>1(ascii)(ascii)
esempio: 124, 96, =>1, 42, 88, =>1, 54, 72, =>1, 45, 36, =>1, 42, 64,
stampa =>1per indice di stringa, aggiungi codice ascii

abbattersi

            # 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 byte

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

PHP, 53 byte

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

Discarica esadecimale:

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

Produzione:

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

Spiegazione:

Ciascuna delle sezioni di numeri interi a cinque cifre viene codificata come un piccolo endian senza segno, quindi concatenata insieme e il risultato viene decompresso. Questo accade per produrre un byte steam che non ha caratteri cifra offensivi, che viene quindi codificato in una stringa. Per estrarre, decomprimere lo stream, decomprimere i short a due byte, interpretarli ciascuno come una stringa e unirsi a >=.

Java 8, 134 byte

golfed:

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

Ungolfed, programma 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();
  }

}

Lotto, 191 byte

@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%

Stimo che occorrerebbero almeno 32 byte per calcolare ogni numero usando solo 6s più altri 32 per stamparli tutti, che è già 192 byte, quindi sto vincendo calcolando la catena amichevole. Inoltre, penso che cinque %secondi di fila siano un record per me. Inoltre, accurato trucco Batch: il %n%viene sostituito prima che il forciclo venga valutato, quindi il ciclo calcola tutti i fattori ne li sottrae n, con conseguente negazione del risultato desiderato.

Gelatina , 12 byte

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

Stampa la quarta stringa e nient'altro.

Provalo online!

Come funziona

“<ọ’ÆṣÐĿ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 byte

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

Modifica - Grazie a Stewie Griffin per aver salvato 6 byte!

Inoltre, un'altra soluzione sarebbe quella di produrre tutte le possibili permutazioni. OP dice che la spazzatura va bene.

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

C'è troppa ridondanza nella conversione da into listin str. Immagino che sarebbe più facile in alcune lingue esoteriche, ma non ne conosco nessuna.