Paul est l'une de vos connaissances belges, et il aimerait que vous créiez un programme qui génère au moins l'une des cinq chaînes suivantes :

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

Il représente les amis dont il est le plus fier et il aimerait manger avec eux. Paul pense également que le chiffre 6 est parfait, et c'est le seul chiffre qui mérite d'être utilisé. Donc , vous ne pouvez pas utiliser un autre chiffre que « 6 » dans votre code (0 à 5 et 7 à 9 sont interdits). Votre programme ne peut accepter aucune entrée. La sortie peut contenir des ordures avant et / ou après la chaîne mais doit contenir au moins une des chaînes ci-dessus.

Par exemple, ceci est une sortie valide:

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

J'ai "légèrement" laissé entendre dans la question comment je m'attendais à ce que cela soit résolu, mais comment le sait-on? Peut-être y a-t-il une meilleure façon ... J'espère que vous vous amuserez.

C'est le code-golf: le score le plus bas en octets l'emporte.

05AB1E , 18 17 octets

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

Essayez-le en ligne!

Explication

•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 bref, nous calculons chaque nombre comme f(n+1) = sum(divisors(f(n)) - f(n)

Pyke, 16 octets

wヰw$VDlsh)J"=>

Essayez-le ici!

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

Chaque fois qu'un littéral de chaîne se trouve à la fin d'un programme, il l'échange avec le jeton juste avant lui, économisant 1 octet dans des cas comme celui-ci. La factorsfonction de Pyke n'inclut pas le nombre lui-même ni 1. Si les nombres étaient autorisés, 1 octet pourrait être enregistré en remplaçant w$par4

Pyke, 21 octets

uバ㟐㱰㣈㞸J"=>

Essayez-le ici!

Créez une liste des numéros requis et joignez-les. Pas très intéressant à part l'astuce avec les cordes.

MATLAB, 44 octets

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

Essayez-le en ligne!

Je n'ai pas trouvé de modèle dans les chiffres (et il serait difficile d'utiliser le modèle pour quoi que ce soit de toute façon, car je ne peux pas utiliser de nombres), alors je vais simplement opter pour l'approche naïve.

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'est la chaîne '12496=>14288=>15472=>14536=>14264'lorsque 12 est ajouté aux valeurs ASCII. Maintenant, entrez cette chaîne, soustrayez 6+6et concaténez avec la chaîne vide ''pour la convertir en un tableau de caractères.

JavaScript (ES6), 57 octets / 47 (UTF-8) caractères

Merci à l'utilisateur 5090812 pour 10 B de sauvegarde

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

Explication

Nous créons d'abord un tableau et le remplissons avec les caractères de la chaîne バ㟐㱰㣈㞸. Ensuite, nous bouclons sur la chaîne ( aa la valeur de l'élément actuel) et nous changeons le caractère en son code de caractère. Ensuite, nous joignons toutes les valeurs du tableau par =>.

Ancien: 67 octets

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

Explication

Nous créons d'abord un tableau de longueur 5. Ensuite, nous modifions les valeurs du tableau à chaque index pour le code de caractère du caractère à ce même index dans la chaîne バ㟐㱰㣈㞸, qui sont les numéros de tous les amis de Paul dans l'ordre. Lorsque nous avons obtenu cela, nous joignons le tableau ensemble, et nous utilisons =>comme séparateur.

Usage

Pour l'utiliser, exécutez simplement ceci:

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

Production

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

Ruby, 36 octets (26 caractères)

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

Parce que pourquoi pas. Ennuyeux comme l'enfer.

ancienne version - 53 octets

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

Explication: l'encodage des nombres en base 25 donne les 5 chaînes de six libres, pour les décoder je n'ai qu'à représenter le nombre 25 en utilisant seulement 6: (6-1) (6-1) => ~ -6 ~ -6

Perl 6 , 63 59 octets

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

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

Décode les nombres de la base 25, car c'est la seule base prise en charge par .parse-base(2 à 36) où aucun d'entre eux n'a de chiffres invalides.

Merci à Neil pour -3 octets.

Perl 6 , 82 75 octets

{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)}

Décode le nombre 15472de la base 36, puis génère la séquence en calculant chaque nombre comme la somme des diviseurs appropriés du nombre précédent.

Perl 6 , 69 octets (47 caractères) - sans concurrence

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

N'utilise aucun des chiffres ASCII interdits, utilise à la place des chiffres Unicode du bloc arabe-indicateur (2 octets chacun)! Les { }interpolations de chaînes garantissent qu'elles sont analysées en tant que littéraux numériques Perl 6, puis stringidées en leurs représentations ASCII.

D'accord, c'est de la triche - c'est pourquoi je ne l'ai pas utilisé comme réponse principale ... :)

Gelée , 5 4 octets

ȷṗȷỌ

Imprime les cinq chaînes. Profite du fait que la sortie "poubelle" est autorisée et enterre les cinq chaînes dans 10 ³⁰⁰³ caractères de sortie.

Comment ça fonctionne

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

Stoopid simple. Remerciements spéciaux @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 octets

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

Courez avec -nr.

un peu moins paresseux: a string liste des à =>1(ascii)(ascii)
savoir: 124, 96, =>1, 42, 88, =>1, 54, 72, =>1, 45, 36, =>1, 42, 64;
imprimer =>1par index de chaîne, ajouter du code ascii

panne

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

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

PHP, 53 octets

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

Vidage hexadécimal:

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

Production:

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

Explication:

Chacune des sections entières à cinq chiffres est codée comme un petit endian court non signé, puis concaténée ensemble et le résultat est compressé. Cela se produit pour produire une vapeur d'octets qui n'a pas de caractères numériques incriminés, qui est ensuite codée en dur dans une chaîne. Pour extraire, décompressez le flux, décompressez les courts métrages à deux octets, interprétez chacun comme une chaîne et joignez-le >=.

Java 8, 134 octets

Golfé:

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

Programme complet non golfé:

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

}

Lot, 191 octets

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

J'estime qu'il faudrait au moins 32 octets pour calculer chaque nombre en utilisant uniquement 6 s plus 32 autres pour les imprimer tous, ce qui fait déjà 192 octets, donc je gagne en calculant la chaîne amiable. De plus, je pense que cinq %s d'affilée sont un record pour moi. En outre, astuce Batch soignée: le %n%est substitué avant l' forévaluation de la boucle, de sorte que la boucle calcule tous les facteurs de n, et les soustrait de n, entraînant ainsi la négation du résultat souhaité.

Gelée , 12 octets

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

Imprime la quatrième chaîne et rien d'autre.

Essayez-le en ligne!

Comment ça fonctionne

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

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

Edit - Merci à Stewie Griffin pour avoir économisé 6 octets!

De plus, une autre solution serait de produire toutes les permutations possibles. OP dit que les ordures vont 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

Il y a trop de redondance dans la conversion de intou listvers str. Je suppose que ce serait plus facile dans certaines langues ésotériques, mais je n'en connais aucune.