Scrivi un interprete "Hello"
sfondo
Hello è un linguaggio "scritto" da Anne Veling , che sbaglia se il programma non contiene solo h, e stamperà Hello Worldper ognih
Compito
Devi scrivere un interprete / compilatore per Hello.
Esempio in Python
import os
i = input("Program: ")
for a in i:
if a != 'h':
print("err")
quit()
else:
print("Hello World")
Dettagli
- Se il programma non è solo
hs, deve stampareerroerror(senza distinzione tra maiuscole e minuscole) - Va bene se stampi "Hello World" prima che il tuo programma scopra un non-
hcarattere ed errori, tuttavia, il programma deve fermarsi se un non-h - Puoi lanciare un errore, purché stampi
err/errorprima di lanciare, o usando un errore personalizzato incorporato, comeraise SyntaxError('err')in python. (in pratica, devi intenzionalmente errore conerr/error - Supponiamo che il programma non sarà vuoto
- L'output può avere una nuova riga finale, uno spazio o nulla per separare
Hello Worldi messaggi - Se un programma ha più righe, dovrebbe
\nessere visualizzato un errore (perché non è unh) - Puoi presumere che l'input sarà sempre ASCII 33-126 e 10 (decimale)
- Le
hs sono case sensitive (quindiHnon è un programma valido) viene trovata l'istruzione - Questo è il golf in codice , la risposta più breve vince
Casi test
Input:
h
Output:
Hello World
Input:
hhhhhh
Output:
Hello WorldHello WorldHello WorldHello WorldHello WorldHello World
(again, it doesn't matter whether it's spaces, newlines, or nothing to separate `Hello World`s
Input:
rubbish
Output:
err
Input:
huh
Output:
Hello Worlderr
Or
err
Prima sfida quindi abbi pietà
Risposte
Lenguage , \$1.42 \times 10^{122}\$ byte
meno molti byte grazie a Kevin Cruijssen e Bubbler
hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh...
Questo è 142099843608359281286315447494338058415442968773543757980908246691462388164856076679905341690709953072132211450166077106439 hs, che lo rende anche un programma Hello valido, anche se non uno che vorresti eseguire. Il codice brainfuck originale è 140 135 byte:
,[>-[<-->-----]+<--[>]>[[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++.>>.>.<<<.+++.------.<<-.[>]>>>>,>]<]<[[>++<+++++]>-.+++++++++++++..>]
Questa stampa Hello World ogni volta che vede huna modifica del più breve Hello, World! programma , interrompendo il ciclo e stampando errse vede qualcosa di diverso da un file h.
Python 3 , 49 byte
lambda s:{*s}-{'h'}and'err'or'Hello World'*len(s)
Python 2, 51 byte
lambda s:s.strip('h')and'err'or'Hello World'*len(s)
Python 2, 51 byte
lambda s:['err','Hello World'*len(s)]['h'+s==s+'h']
APL (Dyalog Unicode) , 32 byte ( SBCS )
Funzione di prefisso tacito anonimo.
{'h'=⍵:'Hello World'⋄-⎕←'err'}⍤0
{... }⍤0 sostituisci ogni carattere ( ⍵) con il risultato dell'applicazione del seguente lambda:
'h'=⍵: se il personaggio è h:
'Hello World' restituisce la frase richiesta
⋄ altro:
⎕←'err' print err
- annulla (causando un errore e terminando)
R , 76 byte
function(p,n=nchar(p))ifelse(p==strrep('h',n),strrep("Hello World",n),'err')
Dovrebbe essere un commento https://codegolf.stackexchange.com/a/210520/98085- Non sapevo che potessi fare funzioni del genere! Leggero cambiamento per essere più robusto quando n = 0 e per utilizzare il confronto diretto piuttosto che regex. -1 byte grazie ahttps://codegolf.stackexchange.com/users/90265/zippymagician.
Versione bonus con effetti collaterali (come la ridefinizione della sottrazione) grazie a https://codegolf.stackexchange.com/users/92901/dingus.
R , 71 byte
{`-`=strrep;function(p,n=nchar(p))`if`(p=='h'-n,'Hello world'-n,'err')}
Gema , 23 caratteri
h=Hello World
?=err@end
Esempio di esecuzione:
bash-5.0$ echo -n 'hohoho' | gema 'h=Hello World;?=err@end'
Hello Worlderr
Gema (vecchia versione con errore su codice vuoto), 32 caratteri
\A\Z=err
h=Hello World
?=err@end
codice macchina x86-16, IBM PC DOS, 41 40 byte
Binario:
00000000: be82 00ba 1801 b409 ac3c 0d74 0a3c 6874 .........<.t.<ht
00000010: 02b2 24cd 2174 f1c3 4865 6c6c 6f20 576f ..$.!t..Hello Wo
00000020: 726c 6424 6572 7224 rld$err$
Inserzione:
BE 0082 MOV SI, 82H ; SI to DOS PSP
BA 0118 MOV DX, OFFSET HW ; point to 'Hello World' string
B4 09 MOV AH, 9 ; DOS write string function
CHAR_LOOP:
AC LODSB ; AL = next input byte
3C 0D CMP AL, 0DH ; is a CR (end of input string)?
74 0A JZ DONE ; if so, end
3C 68 CMP AL, 'h' ; is an 'h'?
74 02 JZ WRITE_STR ; if so, write Hello(s)
B2 24 MOV DL, LOW OFFSET ER ; otherwise, point to 'err' string
WRITE_STR:
CD 21 INT 21H ; write string to stdout
74 F1 JZ CHAR_LOOP ; if 'h', keep looping
DONE:
C3 RET ; return to DOS
HW DB 'Hello World$'
ER DB 'err$'
Programma COM eseguibile per PC DOS autonomo. Input tramite riga di comando. Questa versione viene stampata Hello Worlderrse è presente un errore nel codice di input.
E per divertimento (e dato che l'ho fatto prima), questa versione verrà stampata solo errse nel codice è presente un errore.
codice macchina x86-16, IBM PC DOS, 47 45 44 byte
Binario:
00000000: bf80 00ba 1c01 8a0d 4951 abb8 6809 f3ae ........IQ..h...
00000010: 5974 04b2 28b1 01cd 21e2 fcc3 4865 6c6c Yt..(...!...Hell
00000020: 6f20 576f 726c 6424 6572 7224 o World$err$
Inserzione:
BF 0080 MOV DI, 80H ; DI to DOS PSP
BA 011C MOV DX, OFFSET HW ; point to 'Hello World' string
8A 0D MOV CL, BYTE PTR[DI] ; CL = input length
49 DEC CX ; remove leading space from length
51 PUSH CX ; save length for later
AB STOSW ; DI to start of command line input
B8 0968 MOV AX, 0968H ; AL = 'h', AH = 9
F3/ AE REPZ SCASB ; search input for 'h': ZF if Hello, NZ if error
59 POP CX ; restore input length
74 04 JZ HELLO_LOOP ; if no error, write Hello(s)
B2 28 MOV DL, LOW OFFSET ER ; otherwise, point to 'err' string
B1 01 MOV CL, 1 ; only show 'err' once
WRITE_LOOP:
CD 21 INT 21H ; write string to stdout
E2 FC LOOP WRITE_LOOP ; loop until done
C3 RET ; return to DOS
HW DB 'Hello World$'
ER DB 'err$'
Puntelli:
- -1 byte per entrambi grazie a @MatteoItalia per il suggerimento di cambiare solo il byte basso sul puntatore della stringa di errore.
Ruby -0p , 42 ... 35 33 byte
L'idea di utilizzare i -0pflag (invece di -ncome avevo originariamente) è venuta dalla risposta Perl di @ DomHastings , risparmiando 4 byte.
$_=/[^h]/?:err:'Hello World'*~/$/
Legge il programma da STDIN. Una regex viene utilizzata per verificare se il programma contiene caratteri diversi da h. In tal caso, stampa err; in caso contrario, stampare Hello Worldtante volte quanto il numero di caratteri nel programma (dato da ~/$/).
Usare un'espressione regolare letterale come booleano è un Perlism deprecato che (a partire da Ruby 1.9) funziona solo con i flag -no -p.
05AB1E , 17 byte
'hÃQig”Ÿ™‚ï”×ë'‰ë
Grazie mille a @Kevin per il tuo strumento di compressione del dizionario !
E ancora una volta, Kevin ha colpito ed è riuscito a radere 3 byte dalla mia risposta! Quindi i suddetti ringraziamenti devono essere moltiplicati per una grandezza enorme.
Spiegato (vecchio)
Ð'hÃQig”Ÿ™‚ï”и»ë"err
Ð # Triplicate the input. STACK = [input, input, input]
'h # Push the letter 'h'. STACK = [input, input, input, 'h']
à # Keep _only_ the letter h in the input. STACK = [input, input, input.keep('h')]
Q # Compare this with the original input. STACK = [input, 1 OR 0]
i # If the comparison is truthy (i.e. it's only h's):
g # Push the length of the input. STACK = [len(input)]
”Ÿ™‚ï” # Push the compressed string "Hello World". STACK = [len(input), "Hello World"]
и» # Repeat that string length of input times and join upon newlines. STACK = ["\n".join("Hello World" * len(input))]
ë # Else:
"err # Push the string "err" to the stack. STACK = [input, "err"]
# Implicitly output the top of the stack
Haskell (Hugs 2006), 31 byte
mapM(\'h'->putStr"Hello World")
In attesa di una domanda all'OP re "errore" in un messaggio di errore più grande. La specifica dice "deve stampare un errore o un errore", cosa che fa su Hugs 2006, in particolare Raskell 1.0.13 interpreter based on Hugs 2006:
> mapM(\'h'->putStr"Hello World") "huh"
Hello World
Program error: pattern match
failure: ww_v4136 'u'
Arn , 24 byte
ùÝ└ån<⁼aLw$■v&Z(#▄╗└·I╔║
Spiegato
Disimballato: (${="h"})#=#&&'yt bs'^#||"err
Ed è per questo che devo aggiungere un if else ...
( Begin expression
$ Filter
{ Block with index of _
_ Implicit
= Equals
"h" String
} End block
_ Variable initialized to STDIN; implied
) End expression
# Length
= Equals
_ Implied
#
&& Boolean AND
'yt bs' Compressed string equal to "Hello World"
^ Repeated
_ Implied
#
|| Boolean OR
"err
Excel, 63 byte
=IF(SUBSTITUTE(A1,"h","")="",REPT("Hello World",LEN(A1)),"err")
SUBSTITUTE(A1,"h","")=""restituisce TRUEiff A1non contiene altro che h.
REPT("Hello World",LEN(A1))ripete la stringa per tutti i caratteri presenti A1.
=If(Substitute(~)="",REPT(~),"err")restituisce la stringa ripetuta se A1contiene solo he errse contiene qualcos'altro.
SNOBOL4 (CSNOBOL4) , 94 byte
I =INPUT
I NOTANY('h') :S(E)
OUTPUT =DUPL('Hello World',SIZE(I)) :(END)
E OUTPUT ='err'
END
I =INPUT ;* Read input
I NOTANY('h') :S(E) ;* If there is a character that's not 'h' in the input, goto E
OUTPUT =DUPL('Hello World',SIZE(I)) :(END) ;* else print "Hello World" repeatedly and goto END
E OUTPUT ='err' ;* print 'err'
END
Gelatina , 17 byte
14 se possiamo stampare Errcome sottostringa dell'output (es. “½,⁾ẇṭ»€!fƑ?”h TIO ).
“½,⁾ẇṭ»€“¹ṫ»fƑ?”h
Come?
“½,⁾ẇṭ»€“¹ṫ»fƑ?”h - Main Link: program
”h - set right argument to 'h'
? - if...
Ƒ - ...condition: is (program) invariant under?:
f - keep only ('h's)
€ - ...then: for each (c in program):
“½,⁾ẇṭ» - "Hello World"
“¹ṫ» - ...else: "error"
- implicit, smashing print
flessibile , 76 \$\cdots\$ 55 52 byte
%%
h puts("Hello World");
[^h] puts("err");exit(1);
Metti il codice sopra in un file chiamato hello.le crea l'interprete con:
flex hello.l && gcc lex.yy.c -o hello -lfl
Provandolo sul mio terminale:
> echo -n hhh|./hello.exe
Hello World
Hello World
Hello World
Con nuova riga:
> echo hhh|./hello.exe
Hello World
Hello World
Hello World
err
notare il a errcausa della nuova riga finale echonormalmente inviata .
Con non hcarattere:
> echo -n hhhehhh|./hello.exe
Hello World
Hello World
Hello World
err
C (gcc) , 71 65 byte
f(char*p){p=*p-'h'?*p&&puts("err"):f(p+1)||!puts("Hello World");}
- Grazie a @rtpax per averne salvati 6!
f(char*p){p= - funzione virata a programe ritorno con il trucco eax, riutilizzo p.
Chiama se stesso in modo ricorsivo.
La ricorsione avviene prima programdell'esecuzione, quindi se tutti i passaggi sono corretti falseviene restituito un valore e programviene eseguito.
Se si verifica un errore truthy, viene restituito un valore e programnon viene eseguito affatto, viene visualizzato un messaggio di errore.
* p-'h '? `...`: f (p + 1) ||! put ("Hello World");
- controlla ogni carattere nel programma : se h continua la ricorsione e
se il risultato è falso il programma fa il suo lavoro.
p è vero se c'è stato un errore, falso invece.
- se non h ferma la ricorsione e:
* p - se la fine del programma
p è falsa
&& mette ("err") - se non la fine del programma , l'errore di visualizzazione
p è vero .
61 58 byte alternativa soluzione meno interessante che esegue il programma e si ferma quando si verifica un errore
f(char*p){*p&&puts(*p-'h'?"err":"Hello World")>4&&f(p+1);}
- 3 salvati grazie a @rtpax!
JavaScript, 49 byte
-4 byte se possiamo generare un errore invece di emettere una stringa.
f=([c,...a])=>c?c==`h`?`Hello World`+f(a):`err`:a
JavaScript 72 66 byte
-6 byte grazie a @Ismael Miguel
alert(/^h*$/.test(a=prompt())?a.replace(/h/g,'Hello World'):'err')
Pip , 28 27 byte
aRM'h?"err""Hello World"X#a
-1 byte da DLosc.
Se la stringa senza le h è vuota, stampa "Hello World" il numero di volte richiesto.
Altrimenti, errore.
Questo programma genera errori anche su input vuoti.
MathGolf , 23 20 byte
'h-╛æ╖•p0{δ╕○ô 'W╕7ÿ
Spiegazione:
'h- '# Remove all "h" from the (implicit) input-string
╛ # Pop, and if it's now truthy (thus non-empty):
æ # Use the following four characters as single code-block:
╖•p # Push compressed string "err"
0 # And push a 0
{ # Either loop 0 times,
# or loop over each character of the (implicit) input-string:
δ # Titlecase the implicitly pushed current character ("h"→"H")
╕○ô # Push compressed string "ello"
# Push " "
'W '# Push "W"
╕7ÿ # Push compressed string "orld"
# (implicitly output the entire stack joined together as result)
SimpleTemplate 0.84, 92 63 byte
Questa sfida è stata semplice, ma divertente!
Controlla semplicemente se l'input è solo "hhh ...." e restituisce il testo o invia "err" a STDOUT:
{@ifargv.0 matches"@^h+$@"M}{@eachM.0}Hello World{@/}{@else}err
Il grande risparmio di byte è stato dovuto al commento di the-cobalt :
L'output su STDOUT va bene, quindi puoi usare la tua versione a 63 byte.
Ungolfed:
Di seguito è una versione più leggibile del codice:
{@if argv.0 matches "@^h+$@"}
{@each argv.0 as h}
{@echo "Hello World"}
{@/}
{@else}
{@echo "err"}
{@/}
Puoi provarlo su: http://sandbox.onlinephpfunctions.com/code/e35a07dfbf6b3b56c2608aa86028b395ef457129
GFA Basic (Atari ST), 125 byte
INPUT a$
FOR i=1 TO LEN(a$)
b$=MID$(a$,i,1)
IF b$="h"
PRINT "Hello World"
ELSE
PRINT "err"
EXIT IF 1
ENDIF
NEXT I
Java 8, 65 53 byte
s->s.matches("h+")?s.replace("h","Hello World"):"err"
-12 byte grazie a @ corvus_192 .
Spiegazione:
s-> // Method with String as both parameter and return-type
s.matches("h+")? // If the input consists solely of 1 or more "h":
s.replace("h", // Replace all "h" in the input
"Hello World") // with "Hello World"
: // Else:
"err" // Return "err" instead
Pyth , 25 byte
?-Q\h"err"*"Hello World"l
Spiegazione
?-Q\h"err"*"Hello World"l
? // if
-Q\h // input with 'h' removed
"err" // then "err"
*"Hello World"l // else "Hello World" repeated len(input) times
R , 84 byte
function(p,n=nchar(p))`if`(n-lengths(gregexpr("h",p)),"err",strrep("Hello World",n))
Poiché R è la lingua del mese per settembre 2020, diamo il via a una risposta R a questa sfida.
Tuttavia, questa non è ancora la risposta più breve possibile in R , quindi vorrei incoraggiare anche altri giocatori non normalmente R a provare ...
Batch, 64 byte
@set/ps=
@if "%s:h=%"=="" (echo %s:h=Hello World%)else echo err
Accetta input su STDIN. Se la sostituzione della hs nell'input risulta in una stringa vuota, restituisce il risultato della sostituzione della hs con Hello Worldoutput altrimenti err.