Section des voleurs

La section des flics peut être trouvée ici .

Défi

Votre tâche est de outgolf les observations des policiers dans la même langue et la même version (par exemple, Python 3.5 ≠ Python 3.4 , de sorte que n'est pas autorisé). Une soumission est décodée lorsque la longueur en octets est plus courte que la soumission d'origine. Vous devez seulement jouer au moins 1 octet pour pouvoir soumettre une soumission. Par exemple, si la tâche consistait à exécuter 2 × n et si la soumission était la suivante:

print(2*input())

Vous pouvez surpasser le flic en procédant comme suit:

print 2*input()

Ou même ceci (puisque les lambda sont autorisés):

lambda x:2*x

Postez ceci avec l'en-tête suivant:

##{language name}, <s>{prev byte count}</s> {byte count}, {cop's submission + link}

Par exemple:

Python 2, 16 12 octets, Adnan (+ lien vers la soumission)

lambda x:2*x

Calcule A005843 , (offset = 0).

Dans ce cas, vous avez déchiffré la soumission.

Notation

La personne avec qui a craqué le plus de soumissions est le gagnant.

Règles

• La soumission de crack doit être dans la même langue que la soumission de flic.
• La même entrée doit aboutir à la même sortie (donc il faut que 4 (4) en reste 4).
• Pour des langages tels que Python, vous pouvez importer des bibliothèques standard incluses dans le langage. (Donc, pas de numpy / sympy etc.)
• L'entrée et la sortie sont toutes les deux en décimal (base 10).

Remarque

Ce défi est terminé. Le gagnant de la section Robbers est feersum . Les scores finaux de la CnR sont indiqués ci-dessous:

• feersum : 16 fissures
• Dennis : 12 fissures
• Nun qui fuit : 6 fissures
• Lynn : 4 fissures
• miles : 3 fissures
• Martin Ender : 2 fissures
• Emigna : 2 fissures
• jimmy23013 : 1 fissure
• Sp3000 : 1 fissure
• randomra : 1 fissure
• Alephalpha : 1 fissure
• nimi : 1 crack
• Pastèque Destructible : 1 crack
• Dom Hastings : 1 fissure

Cheddar, 7 à 6 octets, Downgoat

(<<)&1

Cela semble fonctionner, mais il est toujours possible que je ne comprenne pas bien la langue.

Gelée ,54 octets , George V. Williams

RÆḊḞ

Essayez ici.

Une fonctionnalité cachée!

Si je me souvenais bien, ÆḊ(A) = sqrt (det (AA ^T )) est n! fois la mesure de Lebesgue à n dimensions d'un simplexe formé par n point d'entrée et l'origine dans m espace dimensionnel. Lorsque n = 1, il dégénère à la distance euclidienne. Pas si bizarre après tout ...

Hexagony , 91 33 octets, bleu

1""?{\>{+/</+'+./_'..@'~&/!}'+=($

Déplié:

    1 " " ?
   { \ > { +
  / < / + ' +
 . / _ ' . . @
  ' ~ & / ! }
   ' + = ( $
    . . . .

Essayez-le en ligne!

Ca a toujours l'air un peu golfable mais je me suis dit que je le posterais avant que FryAmTheEggman ne me batte. ;)

Explication

Voici quelques chemins d’exécution codés par couleur:

Cependant, ceux-ci sont inutilement compliqués à cause du golf. Voici le même code avec une mise en page plus saine:

C'est mieux. Et enfin, voici un diagramme de mémoire, où la flèche rouge indique la position et l'orientation initiales du pointeur de mémoire (MP):

L'essentiel est que je itérativement le calcul de nombres de Fibonacci sur les trois arêtes marquées f (i) , f (i + 1) et f (i + 2) tout en gardant trace de l'itérateur sur les bords A , B et C . Ce faisant, les rôles de ces arêtes sont permutés cycliquement après chaque itération. Voyons comment cela se passe ...

Le code commence sur le chemin gris qui effectue une configuration initiale. Notez que f (i) a déjà sa valeur initiale correcte de 0.

1   Set edge f(i+1) to 1.
""  Move the MP to edge A.
?   Read input n into edge A.
)   Increment n.

Maintenant, le chemin vert est la boucle principale. _et ne >sont que des miroirs.

(     Decrement n.
<     If the result is zero or less, continue on the red path, otherwise
      perform another iteration of the main loop.
{     Move the MP to edge f(i+2).
+     Add edges f(i) and f(i+1) into this edge, computing the next Fibonacci number.
'     Move the MP to the edge opposite A.
~     Multiply by -1 to ensure that it's non-positive (the edge may have a positive
      value after a few iterations).
&     Copy the current value of n from A.
'     Move back and to the right again.
+     Copy n by adding it to zero. Since we know that the other adjacent edge
      is always zero, we no longer need to use ~&.
'+'+  Repeat the process twice, moving n all the way from A to B.
=     Reverse the orientation of the MP so that it points at f(i) which now
      becomes f(i+2) for the next iteration.

De cette façon, le PM se déplace autour du triplet intérieur des arêtes, calculant les nombres de Fibonacci successifs jusqu'à natteindre zéro. Enfin, le chemin rouge est exécuté:

{}    Move the MP to f(i).
!     Print it.
@     Terminate the program.

Diagrammes générés avec HexagonyColorer et EsotericIDE de Timwi .

Haskell, 5 à 4 octets, xnor

(^)1

Curry simple.

Stack Cats, 14 13 octets, feersum

^]T{_+:}_

avec les -nmdrapeaux pour +4 octets. Essayez-le en ligne!

Ok, cette boucle était dingue. J'ai essayé plusieurs approches, telles que forcer brutalement sur un alphabet réduit et forcer brutalement 3x+2ou 5x+4et essayer de l'étendre, mais je ne m'attendais pas à ce que la solution contienne réellement une boucle.

La meilleure façon de voir comment cela fonctionne consiste à ajouter un Dindicateur pour le débogage (donc exécuter avec -nmD) et à activer le débogage pour le lien TIO ci-dessus. Une {}boucle rappelle le haut de la pile au début de la boucle et se ferme lorsque le haut de la pile redevient cette valeur. L'intérieur de la boucle effectue de manière amusante la soustraction et le cycle des trois principaux éléments de la pile, ce qui permet à la boucle de s'exécuter pendant de nombreuses itérations.

Sesos, 14 à 11 octets, nonne qui fuit

Calcule n ² . Essayez ici.

Décharge Hex:

0000000: 16c0f7 959d9b 26e83e ce3d                         ......&.>.=

À partir de l'assemblée:

set numin
set numout
get
jmp
  jmp, sub 1, fwd 1, add 1, fwd 1, add 2, rwd 2, jnz
  fwd 2, sub 1
  rwd 1, sub 1
  jmp, sub 1, rwd 1, add 1, fwd 1, jnz
  rwd 1
jnz
fwd 2
put

On dirait que 776 759 octets, pastèque destructible

| |||||||| | |
|| |||||| |
||| |||| |
|||| || |
||||| || |
|||| |||| |
||| |||||| |
|| |||||||| |
| |||||||||| |
|| |||||||| |
||| ||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
||||||||| |
||||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |
|| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |
||||||| |
|||||| |
||||||| |
|||||||| |
||||||||| |
|||||||||| |
||||||||||| |
|||||||||||| |
||||||||||| |
|||||||||| |
||||||||| |
|||||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
| |
| |
| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
|| |
|| |
|| |
|| |

J'ai essayé de lire le code source de cette langue, mais c'était trop déroutant. D'une part, ip[1]est un numéro de ligne tandis que ip[0]est le numéro de colonne, tandis que les cpcoordonnées sont utilisées dans l'autre sens. Pourtant, parfois, la valeur de cpest attribuée à ip. J'ai renoncé à essayer de comprendre ce que fait le programme et j'ai trouvé un moyen de coder la même séquence d'instructions en utilisant moins de barres.

Brachylog , 27 21 octets, Fatalize

yrb:1a:+a:[1]c*.
:2/.

Essayez-le en ligne!

J, 17 12 octets, miles

+/@(]!2*-)i:

À peu près la même chose que l'original, juste plus golfée. :)

i:avoir une +1portée comparée à i.est utile (et bizarre). Si vous utilisez i.ici, ce n=0sera incorrect, mais heureusement, cela i:résout le problème.

Essayez-le en ligne ici.

M, 10 6 octets, Dennis

R×\³¡Ṫ

Compte tenu de n , il calcule la n ^ième -level factoriel de n . C'était un exercice amusant!

Le code est capable de fonctionner en tant que gelée afin que vous puissiez l' essayer en ligne .

Explication

R×\³¡Ṫ  Input: n
R       Create the range [1, 2, ..., n]
   ³¡   Repeat n times starting with that range
 ×\       Find the cumulative products
     Ṫ  Get the last value in the list
        Return implicitly

Bonhomme de neige, 50 44 octets, poignée de porte

((}#2nMNdE0nR1`wRaC2aGaZ::nM;aF;aM:`nS;aF*))

Essayez-le en ligne!

Haskell, 15 à 14 octets, xnor

until odd succ

J'ai passé deux heures infructueuses à apprendre à déchiffrer une syntaxe "inutile" ... untilJe l'ai trouvée à la place.

Ou pour un 13 octets moins mélodieuses, until odd(+1).

Python 2, 43 40, xsot

g=lambda n:n<2or-~sum(map(g,range(n)))/3

Pyke, 11 à 9 octets, poisson vaseux

hVoeX*oe+

Essayez-le ici!

Comment ça marche

          Implicit input: n (accumulator), n (iterations)
h         Increment the number of iterations.
 V        Do the following n + 1 times.
  o         Iterator. Pushes its value (initially 0) and increments it.
   e        Perform integer division by 2.
            This pushes 0 the first time, then 1, then 2, etc.
    X       Square the result.
     *      Multiply the accumulator and the result.
      oe    As before.
        +   Add the result to the accumulator.
            This sets the accumulator to a(0) = 0 in the first iteration and
            applies the recursive formula in all subsequent ones.

05AB1E , 7 4, Emigna

LnOx

De la formule pour la somme des carrés des entiers positifs 1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ... + n ^ 2 = n (n + 1) (2 * n + 1) / 6, si on multiplie Les deux côtés par 2 nous obtenons Sum_ {k = 0..n} 2 * k ^ 2 = n (n + 1) (2 * n + 1) / 3, qui est une formule alternative pour cette séquence. - Mike Warburton (mikewarb (AT) gmail.com), 8 septembre 2007

Jelly, 22 21 octets, Dennis

_²×c×Ḥc¥@÷⁸÷’{S
‘µR+ç

J'ai passé plusieurs heures à lire le dernier code source de Jelly, je pourrais donc aussi bien utiliser cette "compétence". J'espère que @Dennis partagera avec nous ses découvertes mathématiques permettant une formule plus courte (en supposant qu'il y ait quelque chose et pas seulement des tours de Jelly bizarres!).

J, 20 19 octets, miles

[:+/2^~+/@(!|.)\@i.

Ceci calcule le produit en tant que somme des nombres de Fibonacci au carré, qui sont calculés en tant que somme des coefficients binomiaux.

Heureusement, @miles lui-même a posté le code pour générer des nombres de Fibonacci dans ce commentaire .

Acc !! , 526 525 octets, DLosc

N
Count x while _%60-46 {
(_+_%60*5-288)*10+N
}
_/60
Count i while _/27^i {
_+27^i*(_/27^i*26-18)
}
_*3+93
Count i while _/27^i/27%3 {
_-i%2*2+1
Count j while _/3^(3*j+2-i%2)%3 {
_+3^(1+i%2)
Count k while _/3^(3*k+1+i%2)%3-1 {
_+3^(3*k+1+i%2)*26
}
}
}
Count i while _/27^i/3 {
_-_/27^i/3%27*27^i*3+_/3^(3*i+1+_%3)%3*3
}
_/3
Count i while _/100^i {
_*10-(_%100^i)*9
}
Count i while _/100^i/10 {
_+_/100^i/10%10
Count j while i+1-j {
_+(_%10-_/100^(j+1)%10)*(100^(j+1)-1)
}
}
_/100
Count j while _/100^j {
Write _/100^j%10+48
}

Je ne sais pas du tout comment cela fonctionne, mais j'ai pu constater une toute petite amélioration.

24c24
< _+_/100^i*100^i*9
---
> _*10-(_%100^i)*9

Haskell, 10 octets, xnor

gcd=<<(2^)

Exemple d'utilisation: map ( gcd=<<(2^) ) [1..17]-> [1,2,1,4,1,2,1,8,1,2,1,4,1,2,1,16,1].

Comment ça marche: A partir de la page OEIS , nous voyons que a(n) = gcd(2^n, n)ou écrit dans la syntaxe Haskell: a n = gcd (2^n) n. Fonctions avec le modèle f x = g (h x) xpeut être tourné vers le point sans via la fonction =<<: f = g =<< h, donc gcd=<<(2^)qui reconvertit gcd (2^x) x.

Sesos, 14 à 9 octets, nonne qui fuit

Calcule n mod 16 . Essayez ici.

Hex:

0000000: 17f84a 750e4a 7d9d0f                              ..Ju.J}..

Assemblée:

set numin
set numout
set mask
get
jmp, sub 1, fwd 1, add 16, rwd 1, jnz
fwd 1
jmp, sub 16, fwd 1, add 1, rwd 1, jnz
fwd 1
put

Python, 39 17 octets, melon d'eau destructible

lambda n:n*-~n>>1

05AB1E, 9 4 octets, Emigna

>n4÷

Essayez-le en ligne!

Calcule cette fonction à la place:

Hexagonie , 7 à 6 octets, Adnan

?!/$(@

Déplié:

 ? ! 
/ $ (
 @ .

Essayez-le en ligne!

Même idée, mise en page légèrement différente.

MATL, 11 à 10 octets, Luis Mendo

YftdAwg_p*

Au lieu de faire -1 longueur (tableau), il convertit les éléments en valeurs booléennes (toujours égales à 1), les annule et prend le produit des éléments.

Jelly, 11 10, Dennis

Ḥ’_Rc’*@RP

Version vectorisée de la même approche.

Essayez-le en ligne!

05AB1E, dix 8 octets, Adnan

µNÂÂQ>i¼

Essayez-le en ligne .

Brachylog, 11 à 10 octets, Fatalize

yb:AcLrLc.

Essayez-le en ligne!

Explication

Brachylog est un langage dérivé de Prolog, dont la plus grande capacité est de prouver des choses.

Ici, nous prouvons ces déclarations:

yb:AcLrLc.
yb:AcL       Inclusive range from 1 to input, concatenated with A, gives L
     LrL     L reversed is still L
       Lc.   L concatenated is output

Jelly, 9 8 octets, Dennis

œċr0$L€Ḅ

Désolé! Je n'ai pas pu trouver votre solution.

Cela repose sur le fait qu'il C(n+k-1, k)s'agit du nombre de façons de choisir des kvaleurs navec remplacement.

Remarque: Ceci est inefficace car il génère les ensembles possibles afin de les compter, essayez donc d'éviter d'utiliser de grandes valeurs de n en ligne.

Essayez-le en ligne ou vérifiez jusqu'à n .

J'ai par la suite trouvé une autre version de 8 octets suffisamment efficace pour calculer n = 1 000. Cela calcule les valeurs à l'aide du coefficient binomial et évite de générer les listes.

Ḷ+c’Ṛ;1Ḅ

Essayez-le en ligne ou vérifiez jusqu'à n .

Explication

œċr0$L€Ḅ  Input: n
  r0$     Create a range [n, n-1, ..., 0]
œċ        Create all combinations with replacement for
          (n, n), (n, n-1), ..., (n, 0)
     L€   Find the length of each
       Ḅ  Convert it from binary to decimal and return

Ḷ+c’Ṛ;1Ḅ  Input: n
Ḷ         Creates the range [0, 1, ..., n-1]
 +        Add n to each in that range
   ’      Get n-1
  c       Compute the binomial coefficients between each
    Ṛ     Reverse the values
     ;1   Append 1 to it
       Ḅ  Convert it from binary to decimal and return

M, 9 8 octets, Dennis

Ḥrc’ḊḄḤ‘

QBasic, 30 29 octets, DLosc

INPUT n:?(n MOD 2)*(n+.5)+n/2