Votre tâche est simple: écrivez un programme qui reçoit un entier en tant qu'entrée et le sort s'il est impair, et ne fait rien sinon (ne pas arrêter est autorisé). Le défi est que vous ne pouvez utiliser que des octets impairs.

Vous pouvez éventuellement ajouter une nouvelle ligne de fin à la sortie.

C'est code-golf, la réponse la plus courte en octets (impairs) gagne.

Les échappatoires standard sont interdites. De plus, vous ne pouvez pas utiliser de versions de langues, qui sont plus récentes que la publication de ce défi.

Exemple d'entrée> sortie:

13 > 13

42 >

Japt -f , 1 octet

u

ua une valeur de code de caractère de 117.

L'essayer

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520285996319 octets

C'est à peu près égal à 2 duodecillion octets.

Le fichier se traduit par le programme brainfuck suivant:

,[<<+>+>-]<[>>+<<-]+>>[-[->]<]<[<[<]>.<]

Prend l'entrée sous forme de code ASCII, avec une valeur maximale de 256. Utilise un wrapping.

Code machine x86-64, 8 octets

Inspiré par la solution de Bruce Forte , mais légèrement en dessous de la normale. :-)

8D 07          lea      eax, [rdi]    ; put copy of input parameter in EAX
D1 EF          shr      edi, 1        ; shift LSB into CF
             InfiniteLoop:
F3 73 FD       rep jnc  InfiniteLoop  ; test CF; infinite loop back here if input was even
C3             ret                    ; return with original input in EAX if it was odd

Un seul paramètre entier est pris dans le EDIregistre, conformément à la convention d'appel System V AMD64.

Une copie de cette valeur est initialement créée et insérée EAXpour pouvoir être renvoyée le cas échéant. ( LEAest utilisé à la place de la normaleMOV car nous avons besoin d'une instruction avec des octets impairs.)

Ensuite, la valeur dans EDIest décalée de 1, ce qui place le bit décalé dans l'indicateur de retenue (CF). Ce bit sera 0 si le nombre était pair, ou 1 s'il était impair.

Nous testons ensuite CF en utilisant l’ JNCinstruction, qui ne se branche que si CF est 0 (c’est-à-dire que le nombre était pair). Cela signifie que nous allons entrer dans une boucle infinie pour des valeurs paires. Pour les valeurs impaires, nous échouons et la valeur d'origine (in EAX) est renvoyée.

Il y a un petit truc avec l' JNCinstruction, cependant - elle a un REPpréfixe! Normalement, les REPpréfixes ne sont utilisés qu'avec des instructions string, mais comme les manuels d'Intel et d'AMD conviennent que les REPpréfixes non pertinents / superflus / redondants sont ignorés, nous en jetons un sur l'instruction de branche ici pour lui donner une longueur de 3 octets. De cette façon, le décalage relatif encodé dans l'instruction de saut est également impair. (Et, bien sûr, REPest lui-même un préfixe d'octet impair.)

Dieu merci, il RETest encodé avec un octet impair!

Essayez-le en ligne!

Si vous pensez ne pas renvoyer la valeur si elle est impaire ou si vous entrez dans une boucle infinie si elle est paire (pour que vous ne retourniez jamais) satisfait aux exigences de sortie du défi, ou si vous voulez juste quelque chose de plus intéressant, voici une fonction qui envoie la valeur sur un port série (mais seulement si c'est impair, bien sûr).

Code machine x86-64 (sortie sur le port série), 17 octets

8D 07         lea   eax, [rdi]   ; put copy of input parameter (EDI) in EAX

B1 F7         mov   cl, 0xf7     ; put 0xF7 into low-order bits of CX
B5 03         mov   ch, 0x03     ; put 0x03 into high-order bits of CX
FE C1         inc   cl           ; increment low-order bits of CX to 0xF8 (so all together it's now 0x3F8)
0F B7 D1      movzx edx, cx      ; move CX to DX ("MOV DX, CX" would have a 16-bit prefix of 0x66)

D1 EF         shr   edi, 1       ; shift LSB of input parameter into CF
73 01         jnc   IsEven       ; test CF: branch if 0 (even), fall through if 1 (odd)
EF            out   dx, eax      ; output EAX (original input) to I/O port 0x3F8 (in DX)
            IsEven:
C3            ret                ; return

Ce qui rend cela un peu plus intéressant, c'est que le code en fait plus , ce qui signifie qu'il était plus difficile de tout faire en utilisant des instructions codées en utilisant uniquement des octets impairs. Bien sûr, cela signifie aussi que cela échoue au code golf, donc c'est un peu un compromis - voulez-vous un défi intéressant ou exigeant, ou voulez-vous un court-métrage?

Quoi qu'il en soit, cela utilise l' OUTinstruction x86 pour écrire sur le port d'E / S 0x3F8, qui est le port série COM1 standard sur un PC. La partie amusante, bien sûr, réside dans le fait que tous les ports d’E / S standard (série et parallèle) ont même une adresse. Ils ne peuvent donc pas simplement être codés comme des OUTinstructions immédiates pour l’ instruction ou être déplacés directement dans un registre. Vous devez initialiser avec un moins que la valeur réelle, puis incrémenter la valeur dans le registre. Vous êtes également limité à l'utilisation de certains registres pour la manipulation, car vous avez besoin de registres codés en utilisant des octets impairs dans l'instruction lorsqu'ils sont utilisés en tant qu'opérandes.

De plus, je devais initialiser le DXregistre (via le CXregistre) en haut de la boucle, même si cela n’est nécessaire que si la valeur est impair, pour que l’ JNCinstruction ait un décalage impair. Cependant, puisque nous omettons l’ OUTinstruction, ce code ne fait que gaspiller des cycles et des registres de grattage clobber; en réalité , il ne génère rien, il n'enfreint donc pas les règles.

Enfin, cette fonction retournera (après avoir fait ou non la sortie vers le port série) avec la valeur d’entrée laissée EAX. Mais cela n'enfreint aucune règle; toutes les fonctions en langage assembleur renverront une valeur EAX- la question est simplement de savoir s'il s'agit d'une valeur significative ou d'une valeur erronée . Cela est déterminé par la documentation de la fonction (en gros, est-ce qu'elle renvoie une valeur ou est-elle renvoyée void), et dans ce cas, je la documente comme ne renvoyant pas de valeur. :-)

Pas de lien TIO pour celui-ci, car il n'implémente pas la sortie sur les ports série. Vous aurez besoin d'un vrai fer ou d'une imagination.

Gelée , 2 octets

ẋḂ

Ces caractères correspondent aux octets 0xF7 et 0xBF dans la page de code de Jelly .

Essayez-le en ligne!

05AB1E , 3 octets

Éi=

Le code correspond aux valeurs d'octet C9,69,3Dou 201,105,61qui sont toutes impaires.

Essayez-le en ligne!

Explication

É     # input % 2 == 1
 i    # if true
  =   # print without popping

MATL , 3 octets

o?G

MATL utilise des caractères ASCII, donc o?Gcorrespond à octets (en décimal) 111, 63, 71.

Essayez-le en ligne!

Explication

o     % Push (implicit) input modulo 2
?     % If nonzero
  G   %   Push input
      % End (implicit)
      % Display stack contents (implicit)

Haskell , 36 33 octets

c[1]=1;c[m]=1+1+c[m-1-1];o	m=c[m]

Essayez-le en ligne!

Utilisation: o 7yiedls 7, o 8entre dans une boucle infinie.

L'algorithme actuel est

o 1 = 1
o m = 2 + o(m-2)

Le premier problème que j'ai rencontré était le manque d'espace et (, parce qu'une fonction oqui prend un argument mest généralement définie par o m=...ou o(m)=.... Cependant, j’ai découvert qu’un commentaire en ligne {- some comment -}fonctionnait également comme un délimiteur de jeton, de sorte qu’une définition o{--}m=...est possible avec les règles données. Ørjan Johansen a souligné que l'on peut utiliser un caractère de tabulation au lieu d'un espace, en économisant trois octets: o m=...

Le deuxième problème était l'appel récursif o(m-2). -2est juste -1-1, mais ici l’astuce de commentaire ne fonctionne pas car les parenthèses sont obligatoires. Je fixe ce en laissant le travail de la fonction sur une liste singleton contenant un numéro: o[m-2]cependant, que ce n'est pas un moyen standard d'apporter une contribution, j'externalisé le calcul d'une fonction d'assistance cqui fonctionne sur les listes et l' appel cde oqui a le format correct .

Python REPL, 38 octets

Prend l'entrée comme valeur de l'expression précédente en utilisant _. La sortie sera une chaîne (la représentation sous forme de chaîne de l'entier pour impair, ou la chaîne vide pour paire).

'%s'%[['']+[_]][-1][[_%[1+1][-1]][-1]]

Essayez-le en ligne

Pour l'exécuter dans un shell réel, vous pouvez l'essayer ici . Tapez l'entrée, appuyez sur Entrée. Collez le code, appuyez sur Entrée.

Explication:

Cela a pris un certain temps à comprendre. Il n'y a pas de multiplication, pas de branchement, pas de découpage, pas de virgules, pas de points, pas d'importations, pas de parenthèses, non exec, non eval, non printet pas de fonctions. Une solution fonctionnant à l'aide de stderr fonctionnait à cette sortie, mais j'ai alors réalisé que nous devions générer le nombre entier réel, pas seulement une valeur vérité / falsey.

J'utilise des crochets au lieu de parenthèses avec [expression][-1]. Simplifier cela transforme le code ci-dessus en '%s'%(['']+[_])[_%(1+1)].

Puisqu'il ne peut y avoir aucune virgule, j'ai utilisé addition de liste pour créer ['',_]. En utilisant le formatage de chaîne, le résultat souhaité est obtenu.

CJam, 6 octets

q_iY%%

113 95 105 89 37 37

Ce programme prend le mod 2 de l'entrée (appelez-le r ) et imprime chaque r ème caractère de la chaîne d'entrée. Si le nombre saisi est impair, la chaîne entière est imprimée, mais si le programme doit imprimer tous les 0 caractères, le programme génère une erreur.

Essayez-le ici

Cubix , 23 19 17 octets

;;u!I1)%/;O=!;;/;

Essayez le!

@, qui termine un programme Cubix, est ascii 64, donc malheureusement cela ne fait que rentrer dans une boucle infinie après le test de bizarrerie. Pas de lien TIO puisqu'il va expirer.

= (ascii 61) est un no-op dans Cubix.

Il s’agit d’une légère modification de l’algorithme antérieur (même nombre d’octets) qui fonctionne pour les entiers négatifs.

Version Cube:

    ; ;
    u !
I 1 ) % / ; O =
! ; ; / ; . . .
    . .
    . .

Algorithme:

• I (73) : lu en entrée sous forme de numéro
• 1 (49) : poussez 1
• ) (41) : incrément
• % (37) : prenez le mod
• / (47) : tournez à gauche
• ! (33) : saute l'instruction suivante si elle est impaire
  • 1;;/; ;is (59): prépare la pile pour la sortie
  • O (79) : Sortie sous forme de nombre.
  • Ensuite, il rentre dans l'algorithme mais Ilit une 0fin de saisie, nous avons donc la garantie d'entrer dans la branche paire.
• u (117) : demi-tour à droite
• ;;;!I : boucle, ne fait effectivement rien.

Charbon de bois , 9 octets

¿﹪Ｉθ÷χ⁵→θ

Essayez-le en ligne!

Fondamentalement, l’impression est imprimée vers la droite si elle n’est pas un multiple de 10/5 (le caractère ²est même dans la page de code Charcoal ). Les caractères utilisés sont:

• ¿: code BF.
• ﹪: code A5.
• Ｉ: code C9.
• θ: code F1.
• ÷: code AF.
• χ: code E3.
• ⁵: code B5.
• →: code 13.

En fait, la →fin est redondante, mais j’ai vu que la réponse devait avoir une longueur étrange ...

Explication:

¿      if (
 ﹪      Modulo (
  Ｉθ      the input as number,
  ÷χ⁵      χ (predefined value: 10) divided by 5 = 2 ) [is 1])
 →θ      then print rightwards the input as string

Code machine x86_64 (Linux), 12 à 11 octets

Malheureusement, 0x80c'est égal, mais ça marche quand même (en supposant que "ne fait rien" signifie ne pas revenir):

0000000000000000 <odd>:
   0:   8d 07                   lea  (%rdi), %eax
   2:   83 e7 01                and    $0x1, %edi
   5:   83 ff 01                cmp    $0x1, %edi
   8:   75 fb                   jne       5  <odd+0x5>
   a:   c3                      retq

-1 octet, merci @CodyGray!

Essayez-le en ligne!

Mathematica, 20 octets

Semblent être la première solution dans une langue autre que le golf.

a=1+1;g[i_/;!a\[Divides]i]=i

En MacintoshChineseTraditionalencodage de caractères. \[Divides]est {161, 253}(2 octets)

Version alternative (23 octets)

\[CapitalAlpha]=1+1;\[CapitalGamma][\[CapitalChi]_/;\[CapitalAlpha]\[LeftFloor]\[CapitalChi]/\[CapitalAlpha]\[RightFloor]\[NotEqual]\[CapitalChi]]=\[CapitalChi]

ou (affiché en Unicode)

Α=1+1;Γ[Χ_/;Α⌊Χ/Α⌋≠Χ]=Χ

en Symbolencodage de caractères. (utilisez uniquement des caractères de 1 octet)

La solution définit une fonction g(ou Γ) qui, évalue en entrée lorsque l'entrée est impaire, et littéralement "ne fait rien" (n'évalue pas) lorsque l'entrée est paire.

Perl, 54 octets

Nécessite -E.

J'ai vraiment beaucoup aimé ce défi, je pense que j'aimerais essayer d'améliorer cette réponse, mais je pense que c'est peut-être le plus court que je puisse faire pour le moment. Cela fait quelques jours que je joue avec ces réponses, mais je me sens satisfait de la solution à 54 octets!

s//A_=Y[;A_=A_%O?A_W''/;y/#A-_/#-A/;s/[#-}]+/uc/ee;say

Essayez-le en ligne!

Explication

Par défaut, la plupart des fonctions de chaîne de Perl fonctionnent $_, ce qui est vide pour commencer.

Tout d'abord, s//A_=Y[;A_=A_%O?A_W''/remplace la chaîne vide par $_avec A_=Y[;A_=A_%O?A_W'', puis y/#A-_/#-A/remplace les caractères en fonction de la liste suivante (le caractère ci-dessus devient le caractère ci-dessous):

#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
#$%&'()*+,-./0123456789:;<=>?@A

qui met $_à jour pour contenir $_=<>;$_=$_%2?$_:''. Suivant s/[#-}]+/uc/eeremplace tous les caractères [#-}]+avec uc. Sans le /eece serait juste la chaîne uc, mais/ee évalue le contenu de la chaîne deux fois. La première évaluation renvoie le résultat de uc, qui est une version majuscule de $_mais $_ne contient aucun caractère alphabétique, elle renvoie simplement la chaîne entière, puis la seconde /eévalue à nouveau la chaîne, qui est définie $_sur$_ (le nombre d'entrée) ou ''selon que pas le nombre est impair ou pair.

Enfin, depuis $_ contient maintenant ce que nous voulons, nous appelons say(ce qui est -Eau lieu de -e) des impressions $_suivies d’une nouvelle ligne.

Alternative Perl, 93 octets

Code de 92 octets + 1 pour -p , ce qui, à mon avis, le rendrait non concurrentiel.

s//_/g;s//uc/e;y/\x09-\x0b/_/;s/____/}[/;s/___/%C]/;s/_/{''H/;y/'{}1CDGH/'-)1-3+--/;s/[#-}]+/uc/ee

Contient un onglet et un onglet vertical dans le y/// , indiqués par \x09et \x0b.

Essayez-le en ligne!

LOGO , 390 46 52 50 octets

[ask    1   se[make]iseq    1-3 cos ?/ask   1[1/sum 1   179]?]

C'est une liste de modèles qui renvoie l'entrée si l'entrée est impaire et provoque une erreur si l'entrée est paire.

Usage:

show invoke [ask ... (paste code here) ... ] 5

sortie

5

puisque 5 est impair, et

invoke [ask ... (paste code here) ... ] 6

causera une erreur parce que 6 est pair.

TI-BASIC, 14 octets

Input Q
sinֿ¹(gcd(Q²,int(e
Q

Cela jette une erreur de domaine (aucune impression sur l’écran d’accueil) sur un nombre pair.

Input Q             Q is a variable with an odd code. We cannot use "Ans" as it's even.

            int(e   floor(e) = 2; "2" is even.
         Q²         Q may be negative, so we square it which preserves parity.
     gcd(Q²,int(e   1 if Q is odd; 2 if Q is even.
sinֿ¹(gcd(Q²,int(e   Error iff Q is even.

Q                   If there was no error, print Q.

Pyth , 14 11 10 9 octets

I + Q_ + K / Q + 3_1KQ 
I! SIcQ + 3_1Q 
I! U + 1_GQ1Q
? u + 1_GQ1k

Suite de test .

Japt , 4 octets

u)çU

Japt utilise ISO / IEC 8859-1 , donc cela correspond à (en décimal) 117 41 231 85.

Testez-le en ligne!

Explication

Uu)çU   Implicit: U = input integer
Uu)     Return Python-style U % (missing argument = 2). This gives 1 if U is odd, 0 if even.
   çU   Implicitly convert U to a string and repeat it that many times.
        Implicit: output result of last expression

J'ai d'abord essayé des solutions en utilisant p, qui est essentiellement çavec des arguments inversés. Cependant, peffectue une exponentiation si son argument de gauche est un nombre. Nous devons donc le convertir explicitement en chaîne. Cette solution s'avère en réalité être un octet plus court, en plus de ne contenir aucun octet impair.

dc , 21 octets

[c]sa?kKKCI-1;1k%1!=a

Décimal: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

Conformément à cette valeur par défaut d'E / S, ce programme laisse l'entrée sur la pile principale si elle est impaire et vide la pile sinon. Ceci peut être confirmé en ajoutant lef commande debug à la fin du programme, comme c'est le cas sur la page TIO.

Essayez-le en ligne!

Explication

[    # Begin macro definition.
 c   # Clear the main stack.
]sa  # End macro definition and push the macro into register "a".
?k   # Prompt for input and store it into precision parameter "k".
KK   # Push two copies of the input to the main stack.
CI-  # Push C-I = 12-10 = 2 to the main stack  
1;1  # Push the value stored in the first index of array "1" (0 by default) 
     # to the main stack. 
k    # Push 0 into parameter "k" to reset the precision (otherwise the modulus 
     # function will not work correctly).
%    # Push the input (mod 2) to the main stack.
1!=a # If the input (mod 2) does not equal 1, execute the macro in register "a".
f    # OPTIONAL: Output the contents of the main stack.

TI-Basic, 18 octets

2 octets sauvés grâce à lirtosiast

:Prompt Q
:While 5Q/ᴇ1-int(5Q/ᴇ1
:Q

en octets (+2 nouvelles lignes = 3F)

:Prompt Q
 DD     51
:While 5Q/ᴇ1-int(5Q/ᴇ1
 D1    35 3B B1  35 3B  
        51 31     51 31
         83 71     83
:Q
 51

Voir http://tibasicdev.wikidot.com/one-byte-tokens

MathGolf , 3 octets

¥{k

Essayez-le en ligne!

Les octets utilisés sont 157, 123, 107 .

Explication

¥     Input modulo 2
 {    Loop that many times
  k   Push input

Bash , 31 octets

read a
[ $[a%2] = 0 ] ||echo $a

Essayez-le en ligne!

Explication:

read a                   reading the input and define it on the variable a
[ $[a%2] = 0 ]      outputs exit status 0 when a/2 is 0 and exit status 1 if not.
||                           evaluates only when the exit status left of it is 1
echo $a                displays the variable a