Gagnant: la réponse basse de professorfish ! Un entier de 9 octets! Hou la la!

Vous pouvez continuer à envoyer votre réponse, mais vous ne pouvez plus gagner. Poste originale conservée pour la postérité:

Votre objectif est de convertir un nombre entier compris entre 1 et 9 dans le mot qu'il représente.

• Vous n'aurez pas à vous soucier des décimales
• L'utilisateur va entrer un numéro. Supposons qu'ils n'entreront jamais rien de 10 ou plus
• L'utilisateur doit taper le numéro à un moment donné, mais la méthode que le programme le lit n'a pas d'importance. Cela peut être avec stdin, lire un fichier texte, etc., mais l'utilisateur doit appuyer sur le bouton 9 de son clavier (par exemple) à un moment donné.
• Il n'est pas sensible à la casse (c.-à-d. "Un", "un", "on", "un", etc. sont tous acceptables)
• Les requêtes HTTP / etc sont autorisées, mais tout code exécuté par le serveur auquel la requête est adressée compte pour le nombre d'octets de votre code final (par exemple, si un programme C ++ a envoyé une requête HTTP, le code PHP utilisé dans la requête HTTP est pris en compte. )
• Tout ce qui peut compiler et exécuter est acceptable

• Ce concours s'est terminé le 27 juin 2014 (7 jours après l'envoi).
• Ceci est un code-golf , donc le code le plus court gagne

Bash (avec bsdgames), 9

number -l

Lit à partir de l'entrée standard.

Je ne sais pas pourquoi il y a un utilitaire pour cela, mais peu importe.

Python 2, 64

print' ottffssennwhoiieiieoruvxvgn  ere ehe  e   nt'[input()::9]

Voici à quoi ressemble la chaîne avec des espaces supplémentaires (essayez de lire à la verticale):

o t t f f s s e n
n w h o i i e i i
e o r u v x v g n
    e r e   e h e 
    e       n t

Comme expliqué dans les commentaires ci-dessous, [input()::9]commence à l'index donné et sélectionne chaque neuvième caractère suivant.

Common Lisp - 22 octets

En voici un général (pas seulement pour un dix):

(format nil"~R"(read))

Oh, vous voulez des ordinaux (premier, deuxième, ... trois centième ...)? D'accord!

(format nil"~:R"(read))

BASH 51

Alors j'en ai créé une autre en utilisant ma deuxième idée et l'aide des autres:

set one two three four five six seven eight nine

$X

Où "X" est le numéro que vous voulez.

BASH 48 (67)

67 avec \nsauts de ligne

Je ne suis pas sûr que cela compte totalement, car c'est la lecture d'un fichier, mais:

sed -n Xp a

Où "X" est l'entrée et où aest un fichier avec:

one
two
three
four
five
six
seven
eight
nine

Le fichier a 36 caractères et la commande bash est 13.

Comment ça fonctionne:

Chaque ligne du fichier est numérotée, en commençant par 1. Ainsi, «un» est sur la première ligne, «deux» sur la deuxième. La commande, sed -n 'Xp' aindique "Imprimez ce qui est répertorié à la ligne 'X' du fichier 'a' ' sedest un éditeur de flux Unix. -nsignifie être silencieux ou ignorer essentiellement tout le reste. Xpsignifie imprimer ce qui est en ligne 'X'.

C # - 127 (86/46)

Si vous ne prenez que la partie exécutable ...

Console.Write(((HourOfDay)Console.Read()-48));

et si HourOfDaycela aurait fait partie de l'espace de noms System, vous auriez besoin de 46 caractères. Malheureusement, il se trouve dans System.DirectoryServices.ActiveDirectoryce qui le rend 86 ... l'autre bruit le gâte.

Ceci est compilable et exécutable à partir de la ligne de commande (127 caractères):

using System;class P{static void Main(){Console.Write((System.DirectoryServices.ActiveDirectory.HourOfDay)Console.Read()-48);}}

si enregistré dans un fichier nommé cg2.cs

csc cg2.cs /r:System.DirectoryServices.dll  && cg2

Comment cela marche-t-il?

HourOfDay est un type enum afin que nous puissions utiliser des noms au lieu de constantes magiques. Les types Enum ont une implémentation ToString () qui vous donne le nom de la valeur . Vous pouvez lancer un int sur une enum. Console.Read () lit un caractère dans le flux d'entrée représenté sous forme d'entier. taper '1' donne 49 , soustraire 48 pour obtenir 1, cast / box HourOfDaypour retourner 'Un'.

Jetez un coup d'œil à la version Powershell de ce même truc

Befunge 98, 116 105 103 octets

&1-       v
vvvvvvvvvj<
"""""""""
etnxereoe
nheivuewn
igvsiorto
nie"ffh""
"es ""t
 ""   "
>>>>>>>>>4k,@

Befunge n'était pas fait pour ça ...

Explication:

&1-           ;Grab the input number (`n`) and subtract 1 from it
&1-       v   ;Start moving downwards
          <   ;Start moving leftwards
         j    ;Jump `n - 1` characters to the left.
vvvvvvvvvj    ;Redirect each of the possible locations to jump to, sending the IP down.

        "     ;If `n` was 1, push `o, n, e` onto the stack (`o` is at the bottom)
        e
        n
        o
        "

       "      ;If `n` was 2, push `t, w, o` onto the stack
       o
       w
       t
       "

    *
    *
    *

"             ;If `n` was 9, push `n, i, n, e` onto the stack
e
n
i
n
"

>>>>>>>>>     ;Collect all the different possible positions the IP could be in, and send it right
>>>>>>>>>4k,  ;Print the top 5 chars. If there are less than 5, the rest are null characters. This is allowed
            @ ;End of program

Javascript 68

Atob / btoa peut être un outil de compression de l'homme pauvre (mais si vous voulez essayer ceci dans la console, vous ne pouvez pas copier à partir du texte formaté que vous voyez à la fois. Allez dans 'edit' et copiez à partir du panneau source)

L’éditeur Markdown n’aime pas certains caractères de cette réponse: certains caractères sont perdus lors de la sauvegarde. Pourtant, je pense que c'est un problème de l'éditeur, pas le mien. Les caractères perdus sont des caractères Unicode 8 bits parfaitement valables.
(Ou alors je me trompe, si cette question a déjà été débattue en méta, faites le moi savoir) Voici la version avec les caractères fautifs échappés, chaque séquence \ xNN devrait compter 1

alert(btoa("×C§{Dð£Dá­ç´\x16\x8b«ÐX¯{D¢ÇD\x9e½éô\x12(!·Cb\x9dí").split(0)[prompt()])

Test simple

Dans la console Firefox:

[0,1,2,3,4,5,6,7,8,9]
.map(x=>x +',' btoa("×C§{Dð£Dá­ç´\x16\x8b«ÐX¯{D¢ÇD\x9e½éô\x12(!·Cb\x9dí").split(0)[x])

Javascript 73

alert('0one0two0three0four0five0six0seven0eight0nine'.split(0)[prompt()])

69

alert(btoa("ôéÞõ5õ1ëxO_¢êý|Þöȱõ'xß^hSôا{Ý").split(9)[prompt()])

Perl, 55

$_=(nine,eight,seven,six,five,four,three,two,one)[-$_]

Il est exécuté avec une option -p(+1 octet), par exemple:

perl -pe '$_=(nine,eight,seven,six,five,four,three,two,one)[-$_]'

Une entrée est attendue dans STDIN et la sortie est écrite dans STDOUT.

Le code génère simplement un tableau et sélectionne le bon élément. Option -pprend en charge la lecture de la ligne d'entrée $_et imprime le résultat $_.

Variations:

• Avec nouvelle ligne (+3):

  $_=(nine,eight,seven,six,five,four,three,two,one)[-$_].$/

  ou (même nombre d'octets):

  s/./(nine,eight,seven,six,five,four,three,two,one)[-$&]/e

Mise à jour:

• Utiliser des mots nus au lieu de qw[...](merci Zaid).

• L'index négatif enregistre un octet (merci aragaer).

Oracle SQL - 46

select to_char(to_date(&1,'j'),'jsp')from dual

Manifestation

Cela comprend une échappatoire standard , je l’admets, mais le SQL est plus court que Golfscript; Je n'ai pas pu résister!

Cela fonctionne en utilisant les modèles de format de date et d’ heure d’Oracle . TO_DATE(n, 'j')convertit un nombre en un jour julien , le nombre de jours depuis le 1er janvier 4712 av. TO_CHAR(<date>, 'jsp')le reconvertit en entier (bien que sous forme de chaîne). Le sp, est un suffixe d'élément de format qui épelle le nombre. Cela fonctionnera avec beaucoup de chiffres.

Il &1s'agit d'une variable de substitution qui ne fonctionne qu'avec les clients qui l'acceptent, par exemple SQL * Plus.

CJam, 45 43 octets

"^AM-^L8M-xM-^L^US^_M-^WrM-rM- 1M-s^CHM-|M-X^HE,M-qM-^EM-q4"256bKb'ef+'j/li=

Ce qui précède utilise les notations ^ et M-, car certains caractères sont non imprimables.

Au prix de 9 octets supplémentaires, les caractères non imprimables peuvent être évités:

" one two three four five six seven eight nine"S/li=

Essayez-le en ligne.

Comment ça fonctionne

" Convert the string into an integer by considering it a base-256 number.                ";

"^AM-^L8M-xM-^L^US^_M-^WrM-rM- 1M-s^CHM-|M-X^HE,M-qM-^EM-q4"256b

" Convert the integer from above into an array by considering it a base-20 number.       ";

Kb

" Add the ASCII character code of “e” to all elements of that array. This casts to char. ";

'ef+

" So far, we've pushed the string “jonejtwojthreejfourjfivejsixjsevenjeightjnine”.       ";

" Split the the above string where the character “j” occurs.                             ";

'j/

" Read an integer from STDIN and push the corresponding substring.                       ";

li=

Exemple

$ base64 -d > convert.cjam <<< IgGMOPiMFVMfl3LyoDHzA0j82AhFLPGF8TQiMjU2YktiJ2VmKydqL2xpPQ==
$ wc -c convert.cjam
43 convert.cjam
LANG=en_US cjam convert.cjam <<< 5
five

GolfScript, 51 octets

~'
one
two
three
four
five
six
seven
eight
nine'n/=

C'est une simple table de correspondance. L'entrée est évaluée ( ~), un tableau des valeurs est créé et l'index est trouvé.

Essayez-le ici

Perl, 60 octets

$_=(ZOneTwoThreeFourFiveSixSevenEightNine=~/.[a-z]*/g)[$_]

Nécessite le -pcommutateur (deux octets).

Exemple

$ perl -p convert.pl <<< 5
Five

Comment ça fonctionne

• -plit à partir de STDIN et enregistre le résultat dans $_.

• =~/.[a-z]*/g divise le mot clé précédent en sous-chaînes d'une lettre (majuscule) suivies d'un nombre quelconque de lettres minuscules.

• (…) collecte les sous-chaînes dans un tableau.

• [$_] récupère la sous-chaîne correspondant à l'entrée de l'utilisateur.

• $_=…enregistre le résultat dans $_.

• -paffiche la valeur de $_.

Lot de DOS - 162 caractères (sauts de ligne inclus)

Cette réponse a été inspirée par la réponse de @ grc en Python, même si j'avais quelque chose de similaire à l'esprit.

@setlocal enabledelayedexpansion
@set s="ottffssennwhoiieiieoruvxvgn  ere ehe  e   nt
@set /a c=%1
@set z=!s:~%c%,1!
@if _%z%==_ exit /b
@echo %z%
@%0 %c%+9

Usage:

[Nom du fichier] [numéro]

Par exemple, si le code est dans un fichier appelé speak.bat et que vous souhaitez afficher le nombre "cinq", vous l'exécutez comme suit:

speak 5

En outre, la sortie est de haut en bas, pas de gauche à droite! Donc au lieu de

cinq

tu verras

f
i
v
e

Bash + coreutils, 64

Concept de compression non compétitif

xxd -p<<<TàPnàõ:àsÀ~®@ãCN|tr 0-9a-d \\ng-inor-x|sed -n $1p

Certains caractères exotiques peuvent ne pas bien être rendus ici, ce script peut donc être reconstruit à partir de sa représentation en base64:

base64 -d <<< eHhkIC1wPDw8VOCLUIJu4PWWDzrgc8B+rkDjEoBDTnx0ciAwLTlhLWQgXFxuZy1pbm9yLXh8c2VkIC1uICQxcA==

Exemple de sortie

$ ./n.sh 1
one
$ ./n.sh 9
nine
$ 

Explication

Il m'est apparu que la chaîne one two three four five six seven eight ninene contenait que les lettres efghinorstuvwxet un séparateur d'espace - 15 caractères au total. Ainsi, chaque caractère peut potentiellement être représenté sur 4 bits, ou 2 caractères par 1 octet. Nous pouvons utiliser la représentation hexadécimale d'un octet comme moyen facile de scinder chaque octet en deux chiffres hexadécimaux. Nous pouvons ensuite transformer les chiffres hexadécimaux en lettres que nous demandons trou similaires. Comme la chance l'aurait, rstuvwxsont consécutifs, peuvent donc être exprimés r-xà tr. Le codage est agencé de telle sorte eet fsont laissés en l' état , et que les mots sont séparés saut de ligne, de sorte que nous pouvons utiliser sedpour ouptut juste la ligne dont nous avons besoin.

Ce processus de décodage finit par utiliser une quantité d'espace supplémentaire non négligeable. Cette réponse devient donc non compétitive en tant que réponse de type script shell, mais peut constituer un concept utile dans d'autres langues.

(pur) Bash, 64 ans

Prend l’entrée comme premier argument, en supposant une entrée valide.

v=(o one two three four five six seven eight nine)
echo ${v[$1]}

Crée un tableau v, puis accède à l'élément spécifié dans l'entrée. Comme les tableaux sont indexés à zéro, j'ai dû ajouter un élément 0e en tant qu'espace réservé. Alternativement (thnx @DennisWilliamson pour l'avoir signalé):

v=(one two three four five six seven eight nine)
echo ${v[$1-1]}

Python 2.x - 65 64

Pas aussi bon que la réponse de @grc, mais certainement plus lisible :-)

'one two three four five six seven eight nine'.split()[input()-1]

Un personnage de moins, grâce à @flornquake

'nine eight seven six five four three two one'.split()[-input()]

Java 7 - 185

class Num{
public static void main(String[] args) {
    System.out.print("ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".split(",")[(new java.util.Scanner(System.in)).nextInt()-1]);
    }}

C 111

#include <stdio.h>
int main(){printf("%.5s","one  two  threefour five six  seveneightnine"+5*(getchar()-'1'));}

La longueur est soigneusement conçu ici pour que je puisse l' interpréter comme binaire et convertir que en décimal. Avec seulement 7 personnages, je suis convaincu d'avoir un gagnant!

bash say (OS X): 3 8

"Votre objectif est de convertir un nombre entier compris entre 1 et 9 dans le mot qu'il représente"

La dernière fois que j'ai vérifié, les mots parlés sont aussi des mots. Tentative précédente (n'accepte aucune entrée)

say 4

Edit, doit pouvoir lire les entrées:

say|read

Tapez n'importe quel nombre et le mot sort. Je sais que la date de fin est due, mais j’aurais dû gagner le concours.

Exemple de fichier audio: four.aiff

VBScript 98 80 75

msgbox split(" one two three four five six seven eight nine")(inputbox(""))

J - 68 ou 60 57 ou 53 octets

Version interactive (stdin):

>one`two`three`four`five`six`seven`eight`nine{~<:".1!:1]1

Version de la fonction:

f=:one`two`three`four`five`six`seven`eight`nine>@{~<:

Explication:

f=:one`two`three`four`five`six`seven`eight`nine>@{~<:
                                                   <: Decrease by one
                                                 {~   Get the correct string
                                               >@     Unbox

".(1!:1)1 lit une chaîne et la convertit en entier

Perl 36 (58 autonome)

use Number::Spell;say spell_number<>

Ou, sans modules supplémentaires:

say qw(one two three four five six seven eight nine)[<>-1]

En AppleScript; 123 caractères.

{"one","two","three","four","five","six","seven","eight","nine"}'s item((display dialog""default answer"")'s text returned)

Ce script prend l'entrée dans une boîte de dialogue. Ensuite, il donne la sortie dans le résultat AppleScript  .

Exemple :

• Contribution : 6
• Sortie: "six"

Voici une version plus agréable:

set l to {"one","two","three","four","five","six","seven","eight","nine"}
set n to text returned of (display dialog "?" default answer "")
display dialog (l's item n) buttons ("OK") default button 1

Cette version affiche la sortie dans un joli dialogue.

Exemple :

• Contribution : 9
• Sortie: nine

[Réponse modifiée; légèrement amélioré le dialogue pour l'entrée; encore 124 caractères. Réponse modifiée à nouveau; maintenant 1 car moins! ]

Powershell - 91 74

[Enum]::ToObject([System.DirectoryServices.ActiveDirectory.HourOfDay],[Console]::Read()-48)

Découvrez comment utiliser pour supprimer l'appel Enum et ToObject:

[System.DirectoryServices.ActiveDirectory.HourOfDay]([Console]::Read()-48)

Comment cela marche-t-il?

HourOfDay est un type enum, nous pouvons donc utiliser des noms au lieu de constantes magiques. Les types Enum ont une implémentation ToString () qui vous donne le nom de la valeur constante. Vous pouvez lancer un int sur une enum. Console.Read () lit un caractère dans le flux d'entrée représenté sous forme d'entier. taper '1' donne 49, soustraire 48 pour obtenir 1, transtyper en HourOfDay pour renvoyer 'Un'.

Parce que powershell fait une ToString sur tous les objets en cours d'écriture dans le flux de sortie et qu'il n'a pas besoin de fluff pour le transformer en un exécutable, c'est tout ce qui est nécessaire à part PowerShell ...

CJam - 50

Il s'agit d'une solution ASCII standard qui utilise des requêtes HTTP (ceci est autorisé dans la question):

"aj21.com/"r+g

Sur le serveur, il y a 9 fichiers de texte brut nommés 1, 2, ..., 9, chacun contenant le mot correspondant.

Taille totale: 14 + 3 ("un") + 3 ("deux") + 5 + 4 + 4 + 3 + 5 + 5 + 4 = 50.
Il est possible de jouer davantage au golf en utilisant un domaine plus court.

L'interpréteur en ligne ne prend pas en charge les requêtes HTTP. Le programme doit donc être exécuté à l'aide de l' interpréteur Java .

Lot - 86

Beaucoup plus courte que l'autre réponse de lot, et étonnamment compétitive.

for /f "tokens=%1" %%1 in ("one two three four five six seven eight nine") do echo>%%1

Utilisé en tant que filename.bat number, et la sortie est sous la forme d'un fichier avec le nom du numéro correct.

Ruby 64

p %w?one two three four five six seven eight nine?[$*[0].to_i-1]

BASH 9

réplique Linux sans vergogne de la réponse de cousincoicane

spd-say 1

parle un

GolfScript, 50 octets

Je voulais voir si je pouvais battre la solution GolfScript autonome de 51 octets de Quincunx . Il s'avère que, avec assez de ruses, oui, je le peux - d'un octet.

Étant donné que l’un des trucs que j’utilise est l’utilisation d’octets situés en dehors de la plage imprimable ASCII, le programme résultant ne peut pas être directement collé ici. Au lieu de cela, je fournis un vidage hexadécimal de celui-ci; Les utilisateurs de systèmes Unixish peuvent utiliser xxd -rpour reconstruire le programme GolfScript réel sur 50 octets à partir du vidage hexadécimal:

0000000: 7e6e 270b 97eb 442f e166 9894 9f00 c63c  ~n'...D/.f.....<
0000010: 8128 73a3 9b55 5065 a9fb f06a 2727 ff16  .(s..UPe...j''..
0000020: 277b 6261 7365 7d2f 2b6e 2f3d 7b39 392b  '{base}/+n/={99+
0000030: 7d25                                     }%

L'astuce de base utilisée pour générer ce programme est simple: je compresse le littéral de chaîne longue qui constitue la majeure partie du code de Quincunx en soustrayant 99 (le code ASCII de la lettre c) des valeurs de caractère, en interprétant les valeurs résultantes comme un nombre en base 22 (assez pour encoder les lettres jusqu’à x) puis ré-encodez le nombre obtenu en base 255 pour produire la chaîne d’octets non imprimable qui constitue la majeure partie de la première moitié de mon programme. Le reste du programme inverse ensuite ce processus en décodant la chaîne en quelque chose d’imprimable.

(Étant donné que la lettre la plus basse présente dans les noms de numéro est e, j’aurais pu raccourcir davantage la chaîne d’octets en soustrayant 101 des codes ASCII et en utilisant la base 20. Cependant, en soustrayant 101, la lettre aurait été mappée osur une nouvelle ligne, que nJ'utilise comme délimiteur de numéro, car elle est facilement disponible comme constante intégrée dans GolfScript. Cela me coûterait plus que l'octet que sauverait une base inférieure permettrait d'économiser. L'utilisation de l'offset 99 laisse la nouvelle ligne correspondant à la lettre m, qui est commodément absent des noms de nombres.)

Voici une version dé-golfée du programme:

~       # eval the input, turning it into a number
n       # push a newline onto the stack; we'll need it later

# this is the byte string encoding the number names:
"\x0B\x97\xEBD/\xE1f\x98\x94\x9F\x00\xC6<\x81(s\xA3\x9BUPe\xA9\xFB\xF0j"

# convert the encoded string from base 255 to base 22
# (and, incidentally, from a string to an array):
"\xFF\x16" {base}/

+       # prepend the newline pushed earlier to the array, re-stringifying it
n/      # split the resulting string at newlines
=       # pick the substring corresponding to the input number
{99+}%  # add 99 to the character values in the chosen substring