Défi

Il existe de nombreux nombres qui peuvent être exprimés comme la différence de deux carrés, ou comme la différence de deux cubes, ou peut-être même des puissances supérieures. En parlant de carrés, il existe différentes façons d'écrire un nombre, disons 75, comme la différence de 2 carrés. Tu peux écrire:

75 = (10)^2 - (5)^2 
   = (14)^2 - (11)^2 
   = (38)^2 - (37)^2         

Parlons donc du défi. Tout d'abord, l'utilisateur entre un nombre puis il saisit une valeur pour n. Vous devez afficher toutes les façons dont ce nombre peut être écrit sous la forme aⁿ - bⁿ.

Entrée et sortie

L'entrée sera le nombre et la valeur de n. Votre sortie doit avoir toutes ces paires de «a» et de «b» telles que la condition susmentionnée est remplie. Le premier nombre de la paire doit être plus grand que le second. Veuillez noter que a, b, n et le numéro d'entrée sont tous des entiers positifs et n> 1 .

Exemples

50, 2 -> (none)

32, 2 -> (9,7), (6, 2)

7, 3 -> (2,1)

665, 6 -> (3, 2)

81, 4 -> (none)

Notation

C'est le code-golf , donc le code le plus court gagne!

Gelée , 8 octets

p*ƓIFẹ+d

Il s'agit d'un lien monadique qui prend le nombre en argument et lit n dans STDIN.

Essayez-le en ligne!

Comment ça marche

p*ƓIFẹ+d  Main link. Argument: k

p         Cartesian product; yield all pairs [b, a] with b and a in [1, ..., k].
  Ɠ       Get; read an integer n from STDIN.
 *        Power; map each [b, a] to [b**n, a**n].
   I      Increments; map each [b**n, a**n] to [a**n-b**n].
    F     Flatten the resulting list of singleton arrays.
     ẹ    Every; find all indices of k in the list we built.
      +   Add k to the indices to correct the offset.
       d  Divmod; map each index j to [j/k, j%k].

Haskell , 42 octets

k#n=[(a,b)|b<-[1..k],a<-[b..k],a^n-b^n==k]

Essayez-le en ligne!

Ungolfed avec UniHaskell et-XUnicodeSyntax

import UniHaskell

f     ∷ Int → Int → [(Int, Int)]
f k n = [(a, b) | b ← 1 … k, a ← b … k, a^n - b^n ≡ k]

Je ne peux pas changer grand chose d'autre ...

05AB1E , 9 octets

Très inefficace pour des valeurs d'entrée plus importantes.

LãDImƹQÏ

Essayez-le en ligne!

Explication

L           # range [1 ... input_1]
 ã          # cartesian product with itself
  D         # duplicate
   Im       # raise each to the power of input_2
     Æ      # reduce each pair by subtraction
      ¹QÏ   # keep only values in the first copy which are true in this copy

MATL , 11 octets

t:i^&-!=&fh

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

t     % Implicit input: M. Duplicate
:     % Range [1 2 ... M]
i     % Input: n
^     % Power, element-wise. Gives [1^n 2^n ... M^n]
&-    % Matrix of pairwise differences (size n×n)
!     % Transpose. Needed so the two numbers in each pair are sorted as required
=     % Is equal? Element-wise. Gives true for entries of the matrix equal to M
&f    % Row and column indices of true entries
h     % Concatenate horizontally. Implicit display

APL (Dyalog) , 21 octets

{o/⍨⍵=-/¨⍺*⍨¨o←,⍳2⍴⍵}

Essayez-le en ligne!

L'argument de gauche est n.

Python 2 , 65 octets

lambda k,n:[(j%k,j/k)for j in range(k,k*k)if(j%k)**n-(j/k)**n==k]

Essayez-le en ligne!

Gelée , 10 octets

*Iċ³
ṗ2çÐf

Une prise de programme complète i, et nqui affiche les paires [b,a]avec une sortie vide quand il n'y en a pas.

Essayez-le en ligne!

Comment?

*Iċ³ - Link 1, isValid?: pair of +ve integers, [b,a]; +ve integer, n
*    - exponentiate             -> [b^n,a^n]
 I   - incremental differences  -> [a^n-b^n]
   ³ - program's third argument -> i
  ċ  - count occurrences        -> 1 if a^n-b^n == i, otherwise 0

ṗ2çÐf - Main link: +ve integer i, +ve integer n
ṗ2    - second Cartesian power = [[1,1],[1,2],...,[1,i],[2,1],...,[2,i],...,[i,i]]
   Ðf - filter keeping if:
  ç   -   call last link (1) as a dyad (left = one of the pairs, right = n)
      - implicit print of Jelly representation of the list

JavaScript (ES7), 64 octets

Une fonction récursive prenant une entrée dans la syntaxe de curry (n)(p). Renvoie une liste de paires d'entiers séparées par des espaces ou une chaîne vide s'il n'existe aucune solution. Utilise le même algorithme que la réponse Python de user202729 .

n=>p=>(g=x=>x--?((y=(x**p+n)**(1/p))%1?[]:[y,x]+' ')+g(x):[])(n)

Ou 60 octets avec des tableaux encapsulés terminés par 0:

n=>p=>(g=x=>x--&&((y=(x**p+n)**(1/p))%1?g(x):[y,x,g(x)]))(n)

Cela produirait [ 9, 7, [ 6, 2, 0 ] ]pour f (32) (2) .

Cas de test

let f =

n=>p=>(g=x=>x--?((y=(x**p+n)**(1/p))%1?[]:[y,x]+' ')+g(x):[])(n)

console.log(f(50)(2))
console.log(f(32)(2))
console.log(f(7)(3))
console.log(f(665)(6))

Pyth , 14 octets

f/.+^RvzTQ^SQ2

Essayez-le ici! , Alternative!

Python 3 , 71 octets

Merci Mr.Xcoder pour avoir sauvé quelques octets!

lambda x,n:[(a,b)for b in range(1,x)for a in[(b**n+x)**(1/n)]if a%1==0]

Essayez-le en ligne!

Python 3 , 69 octets

lambda x,n:[(a,b)for b in range(1,x)for a in range(x)if a**n-b**n==x]

Essayez-le en ligne!

L'approche par force brute x ^ 2 de totallyhuman permet en fait d'économiser des octets.

Octave , 80 octets

function r=f(n,p)[X Y]=meshgrid(1:n,1:n);r=[X(:) Y(:)](X(:).^p-Y(:).^p==n,:);end

Essayez-le en ligne!

Perl 6 , 45 octets

->\k,\n{grep * **n-* **n==k,flat 1..k X 1..k}

Essayez-le en ligne!