Vincitore: la risposta bash di professorfish ! Un intero 9 byte! Wow!

Puoi continuare a inviare la tua risposta, tuttavia non puoi più vincere. Posta originale conservata per i posteri:

Il tuo obiettivo è convertire un numero intero compreso tra 1 e 9 nella parola che rappresenta.

• Non dovrai preoccuparti dei decimali
• L'utente inserirà un numero. Supponiamo che non inseriranno mai nulla di 10 o superiore
• L'utente deve digitare il numero a un certo punto, tuttavia il metodo che il programma legge non ha importanza. Può essere con stdin, leggere un file di testo, ecc. Tuttavia l'utente deve premere il pulsante 9 sulla tastiera (ad esempio) ad un certo punto
• Non fa distinzione tra maiuscole e minuscole (vale a dire, "uno", "Uno", "oNe", "OnE", ecc. Sono tutti accettabili)
• Sono consentite richieste HTTP / etc, tuttavia qualsiasi codice eseguito dal server per cui viene fatta la richiesta viene conteggiato ai fini del conteggio byte del codice finale (ad es. Se un programma C ++ avesse effettuato una richiesta HTTP, il codice PHP utilizzato nei conteggi richieste HTTP )
• Tutto ciò che può essere compilato ed eseguito è accettabile

• Questo concorso si è concluso il 27 giugno 2014 (7 giorni dalla pubblicazione).
• Questo è un codice-golf , quindi vince il codice più corto

Bash (con bsdgames), 9

number -l

Legge da input standard.

Non so perché ci sia un'utilità per questo, ma comunque.

Python 2, 64

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

Ecco come appare la stringa con alcuni spazi bianchi extra (prova a leggere in 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

Come spiegato nei commenti seguenti, [input()::9]inizia dall'indice indicato e seleziona ogni nono carattere successivo.

Lisp comune - 22 byte

Eccone uno generale (non solo per uno-dieci):

(format nil"~R"(read))

Oh, vuoi ordinali (primo, secondo, ... trecentesimo ...)? Ok!

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

BASH 51

Quindi ne ho realizzato un altro usando la mia seconda idea più l'aiuto di altri:

set one two three four five six seven eight nine

$X

Dove "X" è il numero desiderato.

BASH 48 (67)

67 con \ninterruzioni di riga

Non sono sicuro se questo conta davvero, perché sta leggendo da un file, ma:

sed -n Xp a

Dove "X" è l'input e dove si atrova un file con:

one
two
three
four
five
six
seven
eight
nine

Il file è di 36 caratteri e il comando bash è 13.

Come funziona:

Ogni riga nel file è numerata, a partire da 1. Quindi 'one' è sulla 1a riga, 'two' sulla 2a. Il comando, sed -n 'Xp' adice "Stampa ciò che è elencato sulla riga 'X' del file 'a'" sedè un editor di stream Unix. -nsignifica tacere o essenzialmente ignorare tutto il resto. Xpsignifica stampare ciò che è in linea 'X'.

C # - 127 (86/46)

Se prendi solo la parte eseguibile ...

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

e se HourOfDayfosse stato parte dello spazio dei nomi di sistema avresti bisogno di 46 caratteri. Sfortunatamente si trova nel System.DirectoryServices.ActiveDirectoryche lo rende 86 ... l'altro rumore lo rovina.

Questo è compilabile ed eseguibile dalla riga di comando (127 caratteri):

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

se salvato in un file chiamato cg2.cs

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

Come funziona?

HourOfDay è un tipo enumico quindi possiamo usare nomi invece di costanti magiche. I tipi di Enum hanno un'implementazione ToString () che ti dà il nome del valore . Puoi lanciare un int in un enum. Console.Read () legge un carattere dal flusso di input rappresentato come numero intero. digitando '1' si ottiene 49 , sottrai 48 per ottenere 1, cast / box HourOfDayper restituire 'One'.

Dai un'occhiata alla versione Powershell di questo stesso trucco

Befunge 98, 116 105 103 byte

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

Befunge non è stato creato per questo ...

Spiegazione:

&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 può essere uno strumento di compressione per un uomo povero (ma se vuoi provarlo in console, non puoi copiare dal testo formattato che vedi in una sola volta. Vai su "modifica" e copia dal pannello sorgente)

L'editor di Markdown non ama alcuni dei personaggi in questa risposta: alcuni personaggi si perdono durante il salvataggio. Tuttavia, penso che sia un problema dell'editor, non mio. I personaggi persi sono caratteri Unicode a 8 bit perfettamente validi.
(Oppure mi sbaglio, se questo problema è già stato discusso in meta, fammi sapere) Ecco la versione con caratteri offensivi fuggiti, ogni sequenza \ xNN dovrebbe contare 1

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

Test semplice

Nella console di 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)[-$_]

Viene eseguito con l'opzione -p(+1 byte), ad esempio:

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

L'ingresso è previsto in STDIN e l'output è scritto in STDOUT.

Il codice genera solo un array e seleziona l'elemento giusto. L'opzione -psi occupa della lettura della riga di input $_e stampa il risultato $_.

variazioni:

• Con la nuova riga finale (+3):

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

  o (stesso conteggio byte):

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

Aggiornare:

• Usando parole nude invece di qw[...](grazie Zaid).

• L'indice negativo salva un byte (grazie aragaer).

Oracle SQL - 46

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

Dimostrazione

Ciò include una scappatoia standard , lo ammetto, ma l'SQL è più corto di Golfscript; Non ho resistito!

Funziona con (ab) utilizzando i modelli di formato datetime di Oracle . TO_DATE(n, 'j')converte un numero in un giorno giuliano , il numero di giorni dal 1 ° gennaio 4712 a.C. TO_CHAR(<date>, 'jsp')lo converte nuovamente nell'intero (anche se come una stringa). Il sp, è un suffisso di elemento di formato che indica il numero. Funzionerà effettivamente con un bel numero di numeri.

Il &1è una variabile di sostituzione che sarà solo lavoro con i clienti che accettano, ad esempio SQL * Plus.

CJam, 45 43 byte

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

Quanto sopra usa la notazione ^ e M, poiché alcuni caratteri non sono stampabili.

Al costo di altri 9 byte, è possibile evitare i caratteri non stampabili:

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

Provalo online.

Come funziona

" 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=

Esempio

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

GolfScript, 51 byte

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

È una semplice tabella di ricerca. L'input viene valutato ( ~), viene creata una matrice di valori e viene trovato l'indice.

Provalo qui

Perl, 60 byte

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

Richiede l' -popzione (due byte).

Esempio

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

Come funziona

• -plegge da STDIN e salva il risultato in $_.

• =~/.[a-z]*/g divide la parola nuda precedente in sottostringhe di una lettera (maiuscola) seguita da un numero qualsiasi di lettere minuscole.

• (…) raccoglie le sottostringhe in un array.

• [$_] recupera la sottostringa corrispondente all'input dell'utente.

• $_=…salva il risultato in $_.

• -pstampa il valore di $_.

DOS Batch - 162 caratteri (incl. Interruzioni di riga)

Questa risposta è stata ispirata dalla risposta Python di @grc, anche se avevo in mente qualcosa di simile.

@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

Uso:

[Nome file] [numero]

Ad esempio, se il codice si trova in un file chiamato speak.bat e si desidera vedere il numero "cinque", lo si eseguirà come:

speak 5

Inoltre, l'output è dall'alto verso il basso, non da sinistra a destra! Quindi invece di

cinque

vedrai

f
i
v
e

Bash + coreutils, 64

Concetto di compressione non competitiva

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

Alcuni dei personaggi esotici qui potrebbero non essere riprodotti bene, quindi questa sceneggiatura potrebbe essere ricostruita dalla sua rappresentazione base64:

base64 -d <<< eHhkIC1wPDw8VOCLUIJu4PWWDzrgc8B+rkDjEoBDTnx0ciAwLTlhLWQgXFxuZy1pbm9yLXh8c2VkIC1uICQxcA==

Esempio di output

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

Spiegazione

Mi è venuto in mente che la stringa one two three four five six seven eight ninecontiene solo le lettere efghinorstuvwxe un separatore di spazi - 15 valori di caratteri in totale. Pertanto, ogni carattere può potenzialmente essere rappresentato in 4 bit o 2 caratteri per 1 byte. Possiamo usare la rappresentazione esadecimale di un byte come un modo semplice per dividere ogni byte in due cifre esadecimali. Possiamo quindi trasformare le cifre esadecimali in lettere necessarie tro simili. Come sarebbe fortuna, rstuvwxsono consecutivi, quindi può essere espresso come r-xa tr. La codifica è disposto in modo tale che ee fsono lasciati così com'è, e che le parole sono linea-break separati, in modo da poter utilizzare sedper Ouptut solo la linea abbiamo bisogno.

Questo processo di decodifica finisce per usare una buona quantità di spazio extra, quindi rende questa risposta non competitiva come una risposta in stile shell-script, ma può essere un concetto utile in altre lingue.

(puro) Bash, 64

Prende l'input come primo argomento, assumendo input validi.

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

Crea un array v, quindi accede all'elemento specificato sull'input. Poiché le matrici sono indicizzate a zero, ho dovuto aggiungere un 0 ° elemento come segnaposto. In alternativa (thnx @DennisWilliamson per averlo segnalato):

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

Python 2.x - 65 64

Non buono come la risposta di @grc, ma sicuramente più leggibile :-)

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

Un carattere in meno, grazie a @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 lunghezza qui è accuratamente progettato in modo da posso interpretarlo come binario e convertito che in decimale. Con solo 7 personaggi, sono sicuro di avere un vincitore!

bash dire (OS X): 3 8

"Il tuo obiettivo è convertire un numero intero tra 1-9 nella parola che rappresenta"

L'ultima volta che ho controllato, anche le parole pronunciate sono parole. Tentativo precedente (non accetta input)

say 4

Modifica, deve essere in grado di leggere l'input:

say|read

Digita un numero qualsiasi e la parola esce. So che la data di fine è prevista, ma secondo me avrei dovuto vincere il concorso.

Esempio di file audio: four.aiff

VBScript 98 80 75

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

J - 68 o 60 57 o 53 byte

Versione interattiva (stdin):

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

Versione di funzione:

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

Spiegazione:

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

".(1!:1)1 legge una stringa e la converte in numero intero

Perl 36 (58 standalone)

use Number::Spell;say spell_number<>

Oppure, senza moduli aggiuntivi:

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

In AppleScript; 123 caratteri.

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

Questo script accetta l'input in una finestra di dialogo. Quindi fornisce l'output nel risultato di AppleScript  .

Esempio :

• Input: 6
• Produzione : "six"

Ecco una versione migliore:

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

Questa versione visualizza l'output in una bella finestra di dialogo.

Esempio :

• Input: 9
• Produzione : nine

[Risposta modificata; leggermente migliorato il dialogo per l'input; ancora 124 caratteri. Risposta modificata di nuovo; ora 1 carattere in meno! ]

Powershell - 91 74

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

Scopri come eseguire il cast per rimuovere la chiamata Enum e ToObject:

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

Come funziona?

HourOfDay è un tipo enum, quindi possiamo usare nomi invece di costanti magiche. I tipi di enum hanno un'implementazione ToString () che ti dà il nome del valore costante. Puoi lanciare un int in un enum. Console.Read () legge un carattere dal flusso di input rappresentato come numero intero. digitando '1' si ottiene 49, si sottrae 48 per ottenere 1, si lancia in HourOfDay per restituire 'One'.

Poiché PowerShell esegue una ToString su tutti gli oggetti scritti nel flusso di output e non ha bisogno della lanugine per trasformarlo in un eseguibile, tutto ciò che è necessario oltre a PowerShell ...

CJam - 50

Questa è una semplice soluzione ASCII che utilizza richieste HTTP (ciò è consentito nella domanda):

"aj21.com/"r+g

Sul server ci sono 9 file di testo semplice denominati 1, 2, ..., 9, ciascuno contenente la parola corrispondente.

Dimensione totale: 14 + 3 ("uno") + 3 ("due") + 5 + 4 + 4 + 3 + 5 + 5 + 4 = 50.
Si può giocare a golf più usando un dominio più corto.

L'interprete online non supporta le richieste HTTP, quindi il programma deve essere eseguito utilizzando l' interprete java .

Lotto - 86

Molto più breve dell'altra risposta in lotti, e in realtà sorprendentemente competitivo.

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

Usato come filename.bat numbere l'output è sotto forma di un file con il nome del numero corretto.

Ruby 64

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

BASH 9

spudorata replica Linux della risposta di cousincoicane

spd-say 1

ne parla uno

GolfScript, 50 byte

Volevo vedere se riuscivo a battere la soluzione GolfScript autonoma di 51 byte di Quincunx . Si scopre che, con abbastanza trucchi, sì, posso - di un byte.

Poiché uno dei trucchi che sto usando è l'uso di byte al di fuori dell'intervallo ASCII stampabile, il programma risultante non può essere incollato direttamente qui. Invece, sto fornendo una discarica esadecimale; gli utenti dei sistemi Unixish possono utilizzare xxd -rper ricostruire il vero programma GolfScript a 50 byte dal dump esadecimale:

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                                     }%

Il trucco di base utilizzato per generare questo programma è semplice: comprimo il letterale stringa lunga che costituisce la maggior parte del codice di Quincunx sottraendo 99 (il codice ASCII della lettera c) dai valori dei caratteri, interpretando i valori risultanti come un numero nella base 22 (abbastanza per codificare le lettere fino a x) e quindi ricodificare il numero risultante in base 255 per produrre la stringa di byte non stampabile che costituisce la maggior parte della prima metà del mio programma. Il resto del programma inverte quindi questo processo, decodificando la stringa in qualcosa di stampabile.

(Dato che la lettera più bassa effettivamente presente nei nomi dei numeri è e, avrei potuto abbreviare ulteriormente la stringa di byte sottraendo 101 dai codici ASCII e usando la base 20. Tuttavia, sottraendo 101 avrei mappato la lettera osu una nuova riga, che ho nsto usando come delimitatore di numeri perché è convenientemente disponibile come costante incorporata in GolfScript. Lavorare intorno mi costerebbe di più di un byte che risparmierebbe usando una base inferiore. L'uso dell'offset 99 lascia la nuova riga corrispondente alla lettera m, che è convenientemente assente dai nomi dei numeri.)

Ecco una versione decodificata del programma:

~       # 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