Est-ce que n et n ^ 3 ont le même ensemble de chiffres?


52

Étant donné un nombre n (0 <= n <= 2642245), vérifiez si n et n 3 ont le même ensemble de chiffres et émettez une valeur de vérité ou de falsey en conséquence.

Par exemple, vérifions le nombre 100.

100 3 est 1000000.

L'ensemble des chiffres de 100 est {0, 1}.

L'ensemble des chiffres dans 1000000 est {0, 1}.

Par conséquent, 100 devrait donner une valeur de vérité.

Cas de test

0 -> True
1 -> True
10 -> True
107624 -> True
251894 -> True
251895 -> False
102343 -> False

Rappelez-vous que c'est du , donc le code avec le moins d'octets gagne.

OEIS A029795


28
Cas de test proposé: 106239
Dennis

8
Cas de test: 2103869 -> True. Ceci (ou un plus grand) est nécessaire pour tester une langue avec un longtype de données.
mbomb007

5
Dommage que le max soit trop grand pour une langue sans un type entier 64 bits.
Edc65

17
Je pense que vous devriez être explicite sur la base ... en binaire, c'est un peu la moitié du plaisir :-D
The Vee

7
@ ZoltánSchmidt 106239 est le plus petit entier positif n tel que - 1199090390129919 - ne contient pas tous les chiffres de n . Certaines réponses ne vérifiaient que si n contenait tous les chiffres de et obtenait donc un résultat erroné pour 106239 .
Dennis

Réponses:


28

Python 3, 36 32 octets

lambda x:{*str(x)}=={*str(x**3)}

Je pense que cela ne fonctionne que dans Python 3.5 et versions ultérieures. Quatre octets ont disparu, grâce à Copper.


8
En python 2, vous pouvez utiliser backtics comme raccourci pour repr (), ce qui vous permet d'économiser 6 octets. set(`x`)
DenDenDo

9
@DenDenDo Toute entrée plus grande que 2097152( sys.maxint**(1/3.)) et inférieure à celle sys.maxint+1retournée Falsesi vous utilisez repr(). repl.it/EXs2/1 . Longs ont un Là la fin.
mbomb007

9
Non testé, mais vous pouvez probablement le faire lambda x:{*str(x)}=={*str(x**3)}dans Python 3.5+.
Cuivre

1
@BenHoyt C'est plus concis que d'utiliser print (...) et input (). En faire une fonction est plus court que de faire un programme complet.
0WJYxW9FMN

1
Parce que la question dit que le retour d'une valeur de vérité ou de fausseté est suffisant, vous pouvez le remplacer ==par ^. Deux séries égales aboutissent à la {}fausseté.
RemcoGerlich

19

05AB1E , 6 octets

05AB1E utilise le codage CP-1252 .

3mê¹êQ

Essayez-le en ligne!

Explication

3m       # input^3
  ê      # sorted with duplicates removed
     Q   # is equal to
   ¹ê    # input sorted with duplicates removed

1
@PuzomorCroatia: 05AB1E utilise le codage CP-1252 , donc tous ces caractères ont un octet chacun. Il est assez courant que les langues de golf utilisent des pages de code comportant plus de caractères imprimables que UTF-8 ou créent leur propre page de code.
Emigna

7
Merci d'avoir répondu. Malheureusement, en essayant de modifier mon commentaire, je l'ai supprimé. Juste pour clarifier les choses à tout le monde, j'ai posé des questions sur le codage des caractères dans les langages de code de golf
Puzomor Croatie

14

C, 73 octets

k;b(i){k=0;while(i)k|=1<<i%10,i/=10;return k;}f(n){return b(n)-b(n*n*n);}

Crée l'ensemble via des bits. Retourne 0pour le même ensemble, rien pour les autres ensembles.

Ungolfed:

k;
b(i){
  k=0;
  while(i)
    k|=1<<i%10,
    i/=10;
  return k;
}

f(n){
  return b(n)-b(n*n*n);
}

Le code non-loupé est manquant 1 <<lors du paramétrage des bits avec k |= 1 << i % 10. Excellente solution!
1Darco1

1
J'ai utilisé cette idée bitmap pour créer une fonction de code machine x86-64 de 39 octets :)
Peter Cordes

Sommes-nous autorisés à considérer 0comme une vérité? Je suppose strcmpque ça marche comme ça, donc ça semble raisonnable en C.
Peter Cordes

1
Cela ne fonctionne que pour toute la gamme d'entrées requises par la question si elles sont intsupérieures à 64 bits. (Même signé 64 bits ne suffit pas, mais non signé 64 bits est). Donc, je ne connais pas de réelle implémentation de C où cela répond aux exigences de la question. (Cela fonctionne correctement avec unsigned long long, ou seulement unsigned longdans les implémentations où il s’agit d’un type 64 bits). GNU C définit __int128_tsur les machines 64 bits (sans en-têtes) ...
Peter Cordes

8

Perl, 31 + 2 ( -pldrapeau) = 25 21 18 34 33 octets

$_=($==$_**3)!~/[^$_]/*!/[^$=]/

En utilisant:

perl -ple '$_=($==$_**3)!~/[^$_]/*!/[^$=]/' <<< 251894

Sortie: 1\nou 0\n.

Merci à @ Dada pour 3 octets, à Gabriel Benamy pour 1 octet et à @Zaid pour les rapports de bogues.


1
Bonne réponse! Vous pouvez encore sauvegarder quelques (3) octets:perl -pe '$_=$_**3!~/[^$_]/'
Dada

@ Zaid Thanx. Fixé.
Denis Ibaev

Maintenant, il renvoie false pour 10:(
Zaid

@ Zaid Yep. -ldrapeau nécessaire.
Denis Ibaev

2
Changez le &&en *pour enregistrer un octet
Gabriel Benamy

7

Mathematica, 34 octets

f=Union@*IntegerDigits;f@#==f[#^3]&

Implémentation directe (fonction non nommée d'un argument entier).


7

Gelée , 8 octets

,3*\D‘ṬE

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça fonctionne

,3*\D‘ṬE  Main link. Argument: n

,3        Pair; yield [n, 3].
  *\      Cumulative reduce by exponentation. Yields [n, n³].
    D     Decimal; yield the digit arrays of n and n³.
     ‘    Increment, mapping 0 ... 9 to 1 ... 10.
      Ṭ   Untruth (vectorizes); map digit array [a, b, c, ...] to the smallest
          of zeroes with ones at indices a, b, c, ...
       E  Test the results for equality.

6

CJam, 8 octets

l_~3#s^!

Suite de tests.

Explication

l   e# Read input.
_~  e# Duplicate and evaluate.
3#  e# Raise to third power.
s   e# Convert back to string.
^   e# Symmetric set difference. Gives an empty list iff the two sets
    e# are equal.
!   e# Logical NOT.

6

JavaScript ES6, 55 51 octets

Merci à Downgoat pour 3 octets! Vous pouvez enregistrer un octet en convertissant à ES7 et en utilisant à la n**3place de n*n*n.

n=>(f=s=>[...new Set(s+[])].sort()+[])(n)==f(n*n*n)

Assez simple.


c'est terrible qu'il n'y ait pas de moyen plus agréable de comparer des ensembles pour équivalence
njzk2

1
@ njzk2 Eh bien, je dirais que la plus grande tragédie est que ==cela ne fonctionne pas, même sur les tableaux.
Conor O'Brien

Vous pouvez enregistrer un octet en changeant n*n*nsur n**3, mais je suppose que cela pourrait être ES7 et non ES6.
Robert Hickman

1
@Downgoat Merci, cela m'a inspiré pour économiser encore plus d'octets!
Conor O'Brien

3
Cela échoue pour 2103869et le problème nécessite explicitement des solutions pour fonctionner 2642245.
user5090812

6

C #, 241 208 205 201 193 233 222 220 212 203 177 159 octets (109 en remplacement)

I=>{x=s=>{var a=new int[10];foreach(var h in s+"")a[h-'0']++;return a;};var i=x(I);var j=x(I*I*I);for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};

Le lambda doit utiliser spécifiquement le ulongtype:

System.Func<ulong, bool> b; // = I=>{...};
System.Func<ulong, int[]> x; // inner lambda

Merci à @Corak et @Dennis_E pour la sauvegarde de quelques octets et à @TimmyD pour avoir trouvé un problème avec ma solution d'origine. Merci à @SaxxonPike d’avoir signalé le problème ulong / long / decimal / etc (qui m’a également fait économiser des octets).


Il existe également une solution de 109 octets utilisant HashSets, similaire aux réponses Java ici, mais je vais m'en tenir à ma solution originale pour mon score.

using System.Collections.Generic;I=>{return new HashSet<char>(I+"").SetEquals(new HashSet<char>(I*I*I+""));};

Pouvez-vous vérifier p<0au lieu de p==1?
Yytsi,

@TuukkaX l'aurait fait, mais la façon dont je détermine les ensembles utilise maintenant le même tableau d'entiers, incrémentant l'index approprié pour les deux chaînes, donc une valeur de 0 ou 2 est acceptable, mais s'il y en a 1, il devrait retourner faux.
Yodle

Économisez très peu en extrayant la création et le remplissage des tableaux dans un lambda séparé:n=>{Func<string,int[]>x=s=>{var a=new int[10];foreach(var c in s)a[int.Parse(c+"")]++;return a;};var i=x(n);var j=x((long)Math.Pow(int.Parse(n),3)+"");for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};
Corak

Vous pouvez remplacer int.Parse(c+"")parc-'0'
Dennis_E

Échec du test 2103869. J'ai rencontré le même problème. ( longulong
Peu importe

6

Java 8, 154 caractères

a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

Appelé comme ça:

interface Y {
    boolean n(int x);
}

static Y y = a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

public static void main(String[] args) {
    System.out.println(y.n(0));
    System.out.println(y.n(1));
    System.out.println(y.n(10));
    System.out.println(y.n(107624));
    System.out.println(y.n(251894));
    System.out.println(y.n(251895));
    System.out.println(y.n(102343));
}

Les sorties:

true
true
true
true
true
false
false

Une réponse très Java 8-y, utilisant un lambda ainsi que des flux incluant des conversions de nombre à chaînes fantaisistes.

Malheureusement, nous devons utiliser à la BigInteger.pow(3)place de Math.pow(a,3)Math.pow des doubles non précis, qui renvoient des valeurs incorrectes avec des nombres élevés (commençant par 2103869).


Cette static Y ychose est une syntaxe d’initialisation bizarre, est-ce qu’elle est automatiquement assignée à y.nparce que l’interface a exactement un membre?
chat

Je crois que oui. Pour être honnête, je suis nouveau sur Java 8 car mon lieu de travail est toujours sur 7, mais je le perçois comme tel.
Hypino

Le compilateur ajoute automatiquement l' @FunctionalInterfaceannotation (interface avec une seule méthode, voir javadoc), ce qui permet à lambdas de fonctionner à la place de l'instanciation de type anonyme habituelle.
1Darco1

Ceci est essentiellement égal à Y y = new Y() { @Override public boolean n(int x) { return Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray()); } }et le staticmodificateur est uniquement là pour permettre l'appel y.n(int)depuis la méthode main statique.
1Darco1

1
Peu importe, il suffit de lire le meta post à ce sujet et il semble que la communauté est d'accord. Je suppose que je peux voir pourquoi. Je vais mettre à jour.
Hypino

6

FRAPPER, 69, 59 octets

MISE À JOUR

Une autre façon de faire cela en bash est d’utiliser tr (62 octets, mais peut probablement être un peu plus pressé)

T() { m=`bc<<<$1^3`;[ -z "`tr -d $m <<<$1;tr -d $1 <<<$m`" ];}

EDIT: Quelques optimisations supplémentaires (Thx! @Manatwork)

Golfé

T() { S(){ fold -1|sort -u;};bc<<<$1^3|S|diff - <(S<<<$1);}

Tester

TEST() {
 T $1 >/dev/null; echo $?
}

TEST 0
0
TEST 1
0
TEST 11
1
TEST 10
0
TEST 107624
0
TEST 251894
0
TEST 251895
1
TEST 102343
1
TEST 106239
1

0 - en cas de succès (code de sortie) 1 - en cas d'échec (code de sortie)


Je crains que la théorie de base soit complètement fausse ici. Essayez T <<< 11. Disons que les jeux de chiffres sont identiques simplement parce que 11 ** 3 == 1331 contient les chiffres qui ne figurent pas dans le numéro d'origine deux fois.
manatwork

Oui, vous avez raison, corrigé! Merci !
Zeppelin

Ok, mais maintenant quelques espaces supplémentaires laissés dans le code. Vous ne savez pas pourquoi vous avez ajouté -wexplicitement le fold. Si uniqest utilisé sans options, sort -upeut le remplacer. Et alimentez le second appel S avec here-string. Et je pense qu'il n'est pas nécessaire de citer la formule passée bc.
manatwork

@manatwork, thx, j'ai corrigé l'argument fold, supprimé des espaces et fait en sorte que le second argument diff utilise un here-doc. Maintenant, je transforme également le premier argument en diff et ai supprimé les guillemets superflus autour de l' expression bc . > Uniq est utilisé sans options, sort -u peut le remplacer. C'est juste un vestige de la version précédente (était uniq -u )). Merci !
Zeppelin

1
@zeppelin: vous pouvez utiliser au cmplieu de diffet enregistrer 1 octet.
Ipor Sircer

6

Fonction de code machine x86-64, 40 octets.

Ou 37 octets si 0 ou non-zéro est autorisé comme "vérité", comme strcmp.

Grâce à la réponse C de Karl Napf pour l’idée bitmap, ce que x86 peut faire de manière très efficace avec BTS .

Signature de fonction:, _Bool cube_digits_same(uint64_t n);à l’aide de l’ABI System V x86-64. ( nen RDI, valeur de retour booléen (0 ou 1 en AL)).

_Boolest défini par ISO C11 et est généralement utilisé #include <stdbool.h>pour définir boolavec la même sémantique que C ++ bool.

Potentiel d'économies:

  • 3 octets: retour de la condition inverse (différent de zéro s'il y a une différence). Ou depuis inline asm: retour d'une condition de drapeau (ce qui est possible avec gcc6)
  • 1 octet: Si nous pouvions supprimer EBX (cela donnerait à cette fonction une convention d'appel non standard). (pourrait le faire depuis inline asm)
  • 1 octet: l'instruction RET (de inline asm)

Tout cela est possible s'il s'agissait d'un fragment inline-asm au lieu d'une fonction, ce qui en ferait 35 octets pour inline-asm .

0000000000000000 <cube_digits_same>:
   0:   89 f8           mov    eax,edi
   2:   48 f7 e7        mul    rdi          # can't avoid a REX prefix: 2642245^2 doesn't fit in 32 bits
   5:   48 f7 e7        mul    rdi          # rax = n^3, rdx=0
   8:   44 8d 52 0a     lea    r10d,[rdx+0xa]  # EBX would save a REX prefix, but it's call-preserved in this ABI.
   c:   8d 4a 02        lea    ecx,[rdx+0x2]

000000000000000f <cube_digits_same.repeat>:
   f:   31 f6           xor    esi,esi

0000000000000011 <cube_digits_same.cube_digits>:
  11:   31 d2           xor    edx,edx
  13:   49 f7 f2        div    r10         ; rax = quotient.  rdx=LSB digit
  16:   0f ab d6        bts    esi,edx     ; esi |= 1<<edx
  19:   48 85 c0        test   rax,rax     ; Can't skip the REX: (2^16 * 10)^3 / 10 has all-zero in the low 32.
  1c:   75 f3           jne    11 <cube_digits_same.cube_digits>

                                         ; 1st iter:                 2nd iter:                both:
  1e:   96              xchg   esi,eax   ; eax=n^3 bitmap            eax=n bitmap             esi=0
  1f:   97              xchg   edi,eax   ; edi=n^3 bitmap, eax=n     edi=n bmp, eax=n^3 bmp
  20:   e2 ed           loop   f <cube_digits_same.repeat>

  22:   39 f8           cmp    eax,edi
  24:   0f 94 d0        sete   al
                  ;; The ABI says it's legal to leave garbage in the high bytes of RAX for narrow return values
                  ;; so leaving the high 2 bits of the bitmap in AH is fine.
  27:   c3              ret    
0x28: end of function.

LOOP semble être le moyen le plus simple de répéter une fois. J'ai aussi regardé simplement répéter la boucle (sans les préfixes REX et un registre bitmap différent), mais c'est légèrement plus grand. J'ai également essayé d'utiliser PUSH RSI et d'utiliser test spl, 0xf/ jzto en boucle une fois (étant donné que l'ABI exige que RSP soit 16B aligné avant CALL, une poussée l'aligne et une autre l'aligne à nouveau). Il n'y a pas d' test r32, imm8encodage, le plus petit moyen était donc d'utiliser une instruction 4B TEST (incluant un préfixe REX) pour tester uniquement l'octet de poids faible de RSP par rapport à un imm8. Même taille que LEA + LOOP, mais avec les instructions supplémentaires PUSH / POP requises.

Testé pour tous les n de la plage de test, par rapport à la mise en œuvre C de steadybox (car elle utilise un algorithme différent). Dans les deux cas de résultats différents que j'ai examinés, mon code était correct et celui de steadybox, celui qui était incorrect. Je pense que mon code est correct pour tout n.

_Bool cube_digits_same(unsigned long long n);

#include <stdio.h>
#include <stdbool.h>
int main()
{
    for(unsigned n=0 ; n<= 2642245 ; n++) {
        bool c = f(n);
        bool asm_result = cube_digits_same(n);
        if (c!=asm_result)
            printf("%u problem: c=%d asm=%d\n", n, (int)c, (int)asm_result);
    }
}

Les seules lignes imprimées ont c = 1 asm = 0: faux positifs pour l'algorithme C.

Également testé sur une uint64_tversion de l'implémentation C de Karl du même algorithme, et les résultats correspondent pour toutes les entrées.


Code golf en code machine ? C'est la vraie maîtrise!
Chx

@chx: C'est vraiment en langage assembleur, optimisant la taille du code. Je n'écris pas directement les octets hexadécimaux, je sais (ou vérifie) quelle est la taille de chaque instruction. (Ce que j'ai posté provient de l'assemblage avec yasm, puis de l'exécution objdump -drwC -Mintelsur le fichier objet et de la copie des commentaires). C'est un langage où l'optimisation de la taille du code est réellement utile dans la vie réelle. (Mais même dans de rares cas, comme des chargeurs de démarrage ou des démonstrations. Habituellement, il ne vaut la peine de sauvegarder la taille du code que si les performances déjà mises en cache ne sont pas gênantes, mais il est également utile d'éviter les goulots d'étranglement + les erreurs de cache.)
Peter Cordes

@chx: mais oui, jouer au golf en asm me fait me sentir comme un dur à cuire, merci de l'avoir remarqué :) Voir mes autres réponses, ici et sur SO :)
Peter Cordes

Je suis un très vieux chapeau d'assemblage (1987, le Z80 était le premier) mais je n'aurais jamais pensé entrer dans le code golf avec ça. J'aurais pensé impossible.
Chx

@chx: Je ne joue qu'au golf à l'occasion, généralement lorsque je vois une question dans Hot Network Questions qui semble raisonnable pour asm. Habituellement, remplis de chiffres et non de chaînes. Quelques autres personnes jouent au golf à Asm, cependant. Je n'y avais pas pensé moi-même tant que je n'avais pas vu la réponse d'un autre joueur jouer au golf avec un code machine. C’est peut-être celui-là qui m’a fait comprendre que vous pouvez compter les octets de code machine au lieu des caractères source asm pour les réponses asm. anatolyg en a posté, notamment sur cette question.
Peter Cordes

5

Haskell, 47 octets

n%p=[c|c<-['0'..],elem c$show$n^p]
f n=n%1==n%3

Très lent. Testez avec c<-['0'..'9'].

Teste chaque caractère pour l'inclure dans la représentation sous forme de chaîne de n, et dresse une liste de ceux inclus. Fait de même pour n^3et vérifie si les listes sont égales.


Haskell n'a-t-il pas de littéraux définis ou une fonction qui renvoie les éléments uniques d'une liste?
Chat

2
@cat n ° Haskell a nub(obtenir des éléments uniques) et sort, mais les deux nécessitent une importation longue import Data.List. Malgré cela, il est très proche à 48 octets: import Data.List;q=sort.nub.show;f n=q n==q(n^3).
xnor

Pourquoi avoir besoin de trier ...?
chat

1
@cat nubpréserve l'ordre lors de sa première apparition, c'est-à-dire nub [3,1,3,2,1,2] == [3,1,2]. Il ne convertit pas en un type défini (il n'y en a pas), mais donne une liste.
xnor

Oh, je n'avais jamais réalisé que Haskell n'avait pas de type de collection primitif non ordonné, cela a du sens
cat

5

Dyalog APL , 10 octets

⍕≡⍕∪(⍕*∘3)

⍕≡ est la représentation textuelle de l'argument identique à

⍕∪ l'union de la représentation textuelle de l'argument et

(⍕*∘3) la représentation textuelle de l'argument en cube?

TryAPL en ligne!

Remarque: Pour les grands nombres, définissez ⎕PP←34 ⋄ ⎕FR←1287(34 chiffres significatifs, float 128 bits)


1
Vous supposez que les chiffres uniques dans n ^ 3 ne peuvent pas être inférieurs à ceux dans n?
ngn

Pouvez-vous prouver l'existence d'un contre-exemple?
Adám

1
106239, voir les commentaires en haut
ngn


5

Java 7, 185 178 caractères

import java.util.*;
boolean a(int n){return new HashSet(Arrays.asList((n+"").split(""))).equals(new HashSet(Arrays.asList((new java.math.BigInteger(n+"").pow(3)+"").split(""))));}

Appeler comme:

public static void main(String [] args) {
    System.out.println(0 + " -> " + a(0));
    System.out.println(1 + " -> " + a(1));
    System.out.println(10 + " -> " + a(10));
    System.out.println(107624 + " -> " + a(107624));
    System.out.println(2103869 + " -> " + a(2103869));
    System.out.println(251894 + " -> " + a(251894));
    System.out.println(251895 + " -> " + a(251895));
    System.out.println(102343 + " -> " + a(102343));
    System.out.println(106239 + " -> " + a(106239));
}

Sortie:

0 -> true
1 -> true
10 -> true
107624 -> true
2103869 -> true
251894 -> true
251895 -> false
102343 -> false
106239 -> false

(Je ne suis jamais sûr de devoir compter également les importations et les définitions de méthodes ... je l'ai déjà vu de toute façon. Le code lui-même n'aurait toutefois qu'une longueur de 141 octets.)


Les importations / utilisations font en effet partie du nombre d'octets. Vous pouvez supprimer le static si.
Kevin Cruijssen

D'accord merci. Enlevé static.
QBrute

4

Gelée , 8 octets

*3ṢQ⁼ṢQ$

Essayez-le en ligne!

Explication:

       $    # As a monadic (single argument) link:
    ⁼       # Return true if the following are equal
     ṢQ     # The unique sorted elements of 'n'
  ṢQ        # and The unique sorted elements
*3          # of 'n^3'

Cela ne fonctionne pas avec l'entrée 100 .
Dennis

Je comprends pourquoi cela ne fonctionne pas, mais pourquoi cela ne fonctionne- t-il pas ?
DJMcMayhem

1
Parce que Jelly est strictement analysé de gauche à droite, sans priorité de l'opérateur. *3ṢQ⁼ṢQ$fonctionne comme prévu, car les $groupes rapides les deux atomes à sa gauche dans une chaîne monadique.
Dennis

4

Pyth, 10 octets

Parce que nous n’avons pas assez de variété avec les réponses Pyth, n’ajoutons pas une, mais deux autres! Les deux sont de 10 octets et ont été testés avec 106239un exemple d'entrée (auquel d'autres réponses ont échoué).

!s.++Q,`**

Explication:

!s.++Q,`**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       `         repr(Q^3)
      ,      Q   [repr(Q^3),Q]
    +Q           [Q,repr(Q^3),Q]
  .+             Deltas ([Digits in Q but not in Q^3, digits in Q^3 but not in Q])
!s               Are both empty?

Essayez la première réponse en utilisant une suite de tests en ligne.

Deuxième réponse:

qFmS{`d,**

Explication:

qFmS{`d,**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       ,     Q   [Q^3, Q]
  m              map over each element d of [Q^3, Q]:
     `d           the element's string representation
    {             with duplicates removed
   S              and sorted
qF               Fold over equality (are the two the same?)

Essayez la deuxième réponse en utilisant une suite de tests en ligne.


4

Kotlin: 46/88/96 octets

La question ne précise pas d'où provient l'entrée, alors voici les 3 sources d'entrée habituelles.


Fonction: 46 octets

fun f(i:Long)="$i".toSet()=="${i*i*i}".toSet()

main () utilisant le premier argument du programme: 88 octets

fun main(a:Array<String>){val i=a[0].toLong();println("$i".toSet()=="${i*i*i}".toSet())}


main () utilisant l'entrée standard: 96 octets

fun main(a:Array<String>){val i=readLine()!!.toLong();println("$i".toSet()=="${i*i*i}".toSet())}


1
Bienvenue chez PPCG! L'entrée / sortie est spécifiée implicitement à cause du code-golf . Vous pouvez voir les normes de consensus de la communauté ici . Votre nombre de fonctions devrait être suffisant.
AdmBorkBork

4

Haskell, 54 52 octets

Merci @Laikoni pour la sauvegarde de deux octets.

(%)=all.flip elem
k n|[a,b]<-show<$>[n,n^3]=b%a&&a%b

1
Déclarer a%b=all(elem en a)btant que fonction puis appeler avec b%a&&a%bdevrait économiser deux octets.
Laikoni

4

JavaScript (ES6), 44 octets

g=n=>n<1?0:g(n/10)|1<<n%10
n=>g(n)==g(n*n*n)

Excellente réponse en C du port de @ KarlNapf. ES7 enregistre un octet via n**3. Ne fonctionne que jusqu'en 208063 en raison de la précision numérique limitée de JavaScript; si vous n’avez besoin que de travailler jusqu’à 1290, vous pouvez enregistrer un autre octet.


4

Perl 6 , 22 octets

{!(.comb$_³.comb)}

Étendu:

{ # bare block lambda with implicit parameter 「$_」
  !(
    .comb # get a list of the graphemes ( digits )

     # Symmetric Set difference

    $_³.comb # cube and get a list of the graphemes
  )
}

L' opérateur Différence de jeux symétriques ⊖ ⊖ returns renvoie un jeu vide si les deux côtés sont des jeux équivalents (transforme automatiquement une liste en jeu). A ce stade, il ne reste plus qu'à l'inverser logiquement.


Vous pouvez remplacer le $_avec juste.
Jo King

4

C ++, 82 octets

t(int a){int b=a*a*a,c,d;while(a|b)c|=1<<a%10,a/=10,d|=1<<b%10,b/=10;return c==d;}

La fonction t (a) renvoie la réponse. Utilise un int comme un ensemble. Bien imprimé:

t(int a)
{
    int b = a*a*a, c, d;
    while(a|b) c|=1 << a%10, a/=10, d|=1 << b%10, b/=10;
    return c==d;
}

Vous devez inclure #include<set>et using namespace std;dans le code golfé et le nombre d'octets
Cat

@cat #include<set>au lieu dealgorithm
Karl Napf

@KarlNapf oh, je pensais que tous les conteneurs stdlib étaient accessibles par un algorithme - montre ce que je sais du C ++ :)
Cat

Il me semble que la variable locale à la fonction "c" n'est pas initialisée mais utilisée c | = 1 ...
RosLuP

4

R, 65 79 70 octets

Prend nde stdin, divise net n^3en chiffres simples, et compare les deux ensembles. Utilise le gmppaquet pour gérer de grands nombres entiers (merci à Billywob pour avoir signalé cette lacune). Utilise maintenant substringpour couper net n^3, grâce à @MickyT pour la suggestion. ( Les versions précédentes scanet gsubd'une manière aki.)

s=substring
setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e2,p),s(n^3,p,p))

Malheureusement, cela ne fonctionnera pas (pour les grands n), sauf si vous utilisez une sorte de paquet BigInt. Voir ?.Machinepour plus de détails sur le plus grand nombre entier et le flotteur etc. Pour voir cette comparaison par exemple 2600001^3dans R à WolframAlpha
Billywob

Je n'ai jamais eu à l'utiliser moi-même, mais il semble que le gmppaquet puisse résoudre ce problème.
Billywob

Ah, bonne prise! J'ai mis à jour la réponse, il utilise maintenant gmp::as.bigz()pour gérer des entiers de grande taille.
rturnbull

vous pouvez utiliser le fait que la sous-chaîne convertit un caractère pour diviser le nombre, par exemples=substring;setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e4,p),s(n^3,p,p))
MickyT

@MickyT Fantastique suggestion! Je ne savais pas que je substringpouvais être utilisé de cette façon (je ne l'ai jamais utilisé substr). La réponse a été modifiée pour intégrer votre suggestion maintenant.
rturnbull

4

C ++ 14, 93 octets

int b(auto i){int k=0;while(i)k|=1<<i%10,i/=10;return k;}int f(auto n){return b(n)-b(n*n*n);}

Port of my C answer , fonctionne pour les grands nombres (appel avec Lsuffixe).


3

Haskell, 47 octets

import Data.Set
s=fromList.show
f n=s n==s(n^3)

Exemple d'utilisation: f 102343-> False.

Utilise les ensembles du Data.Setmodule. La fonction d'assistance stransforme un nombre en représentation sous forme de chaîne et crée ensuite un jeu de caractères.


Ne pouvez-vous pas enregistrer un octet ici en utilisant s$n^3?

@ ais523: Non, car il se traduit par (s n==s) (n^3)une erreur de type.
nimi

3

Brachylog , 11 octets

doI,?:3^doI

Essayez-le en ligne!

Merci à @DestructibleWatermelon pour avoir signalé un problème avec ma réponse initiale.

Explication

(?)doI,           I is the Input sorted with no duplicates
       ?:3^       Compute Input^3
           doI    Input^3 sorted with no duplicates is I

J'aime le smiley de chat dans ceci: 3
QBrute

3

PowerShell v2 +, 94 93 octets

filter f($n){-join("$n"[0..99]|sort|select -u)}
(f($x=$args[0]))-eq(f("[bigint]$x*$x*$x"|iex))

(Newline pour plus de clarté, non inclus dans bytecount)

La première ligne est définie fcomme un filter(assez similaire à une fonction pour que notre propos ici ne rentre pas dans les détails) qui prend en entrée $net effectue ce qui suit:

filter f($n){-join("$n"[0..99]|sort|select -u)}
       f($n)                                    # Input
                   "$n"                         # Cast as string
                       [0..99]                  # Index as char-array
                              |sort             # Sorted alphabetically
                                   |select -u   # Only select the -Unique elements
             -join(                          )  # Join those back together into a string
                                                 # Implicit return

La deuxième ligne prend l'entrée $args, l'exécute fet vérifie si elle -eqdoit être fexécutée au $xcube. Notez la [bigint]distribution explicite , sinon nous obtiendrons le résultat en notation scientifique, ce qui ne fonctionnera évidemment pas.

Le résultat booléen est laissé sur le pipeline et la sortie est implicite.

PS C:\Tools\Scripts\golfing> 0,1,10,107624,251894,251895,102343,106239,2103869|%{"$_ --> "+(.\do-n-n3-same-digits.ps1 $_)}
0 --> True
1 --> True
10 --> True
107624 --> True
251894 --> True
251895 --> False
102343 --> False
106239 --> False
2103869 --> True

Enregistré un octet grâce à @ConnorLSW


vous pouvez utiliser "$n"[0..99]au lieu de [char[]]"$n"pour sauvegarder un octet, car le plus grand nombre que vous devez traiter est seulement d'environ 20 caractères.
Colsw

@ConnorLSW Il y a encore cette astuce d'indexation. Je vais devoir m'en souvenir.
AdmBorkBork

tant que vous êtes sûr d'utiliser moins de 100 caractères, vous économiserez assez facilement par rapport à la char[]conversion normale , le reste de votre code est aussi performant que possible. S'il existait un moyen simple de comparer des tableaux, vous pourriez utilisez quelque chose comme ("$n"[0..99]|group).Namepour économiser des charges mais comparen'est pas vraiment rapide et facile à jouer au golf.
Colsw

C'est ce que je reçois pour résoudre ce problème sans regarder les réponses ... C'est à peu près la même réponse ;-). Mais vous avez manqué quelques optimisations très évidentes ;-)
Joey

3

Groovy, 35 51 caractères / octets

J'étais triste de ne pas voir Groovy inclus, alors voici ma tentative initiale de 51 octets:

def x(def n){"$n".toSet()=="${n.power(3)}".toSet()}

Réécrit sous forme de fermeture anonyme de 35 octets et avec **une exponentiation, grâce à manatwork:

{"$it".toSet()=="${it**3}".toSet()}

Quelques cas de test pour la fonction d'origine:

println x(0)
println x(1)
println x(10)
println x(107624)
println x(251894)
println x(251895)
println x(102343)

Une fermeture du nom cpourrait être appelé comme ceci: println c.call(107624). La fermeture anonyme de 35 octets pourrait s'appeler comme ceci:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

Les sorties:

true
true
true
true
true
false
false

S'il vous plaît noter: j'ai appris que quelque chose comme le code de golf existe tout à l'heure, alors j'espère que j'ai raison!


Bonjour Rado et Bienvenue sur PPCG! C'est une excellente première réponse, +1!
NoOneIsHere

J'ai réussi à le réduire encore plus à 47 caractères / octets en utilisant une fermeture, mais je ne peux pas modifier ma réponse précédente car je suis nouveau ici, alors le voici:def c={"$it".toSet()=="${it.power(3)}".toSet()}
Rado

1
Les fonctions anonymes sont acceptables. Et utilisez l' **opérateur pour l'exponentiation.
manatwork

Merci @NoOneIsHere! Aussi, appeler la clôture pour les cas tests impliquerait le remplacement x(107624)dec.call(107624)
Rado

Merci @ Manatwork! Utilisation d'une fermeture anonyme et **le réduit à 35 caractères / octets:{"$it".toSet()=="${it**3}".toSet()}
Rado

2

Ruby, 48 octets

->n{(f=->x{x.to_s.chars.uniq.sort})[n]==f[n**3]}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.