Conosciamo tutti la classica battuta di papà che va in questo modo:

1. Qualcuno dice una frase per descrivere il proprio io (es. I'm tiredO I'm confused).

2. Arriva un appassionato di papà e risponde Hi <adjective>, I'm Dad!, perché le presentazioni seguono lo stesso formato ( I'm Petersegue lo stesso formato I'm hungry).

Il tuo compito è quello di inserire un input sotto forma di autodescrizione e di generare il modulo papà-scherzo appropriato, ma invece di usare la parola "Papà", userai il nome del linguaggio di programmazione che stai programmando nel.

Casi di test (supponiamo che vengano analizzati da Python):

I'm amazing                  Hi amazing, I'm Python!
I'm tired                    Hi tired, I'm Python!
I'm hungry                   Hi hungry, I'm Python!
I'm fat                      Hi fat, I'm Python!

Ora supponiamo che questi casi di test vengano analizzati da Golfscript:

I'm a programmer             Hi a programmer, I'm Golfscript!
I'm a question-writer        Hi a question-writer, I'm Golfscript!
I'm a Stack-Overflow-er      Hi a Stack-Overflow-er, I'm Golfscript!

La sfida esatta:

1. Accetta una stringa nel formato auto-descrittivo ( I'm <adjective>o I'm a(n) <noun>) usando l'input standard o tramite una funzione.

   • Supponiamo che non ci sia punteggiatura finale.

   • Supponiamo che la parola I'msia usata e non I am.

2. Convertilo in un formato papà - guarda gli esempi sopra per esattamente come dovrebbe apparire.

Altre cose:

• Questo è code-golf , quindi vince il conteggio dei byte più breve.

• Segui le regole standard della scappatoia - nessuna di queste, per favore.

• Divertiti!

Classifica

Puoi visualizzare la classifica per questo post espandendo il widget / snippet di seguito. Affinché il tuo post sia incluso nelle classifiche, è necessario un header ( # header text) con le seguenti informazioni:

• Il nome della lingua (termina con una virgola ,o un trattino -), seguito da ...

• Il conteggio dei byte, come l'ultimo numero da visualizzare nell'intestazione.

Ad esempio, JavaScript (ES6), 72 bytesè valido, ma Fortran, 143 bytes (8-bit)non è valido perché il conteggio dei byte non è l'ultimo numero nell'intestazione (la risposta verrà riconosciuta come 8 byte, non approfittarne).

<iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=185872" width="100%" height="100%" style="border: none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>

V , 13 byte

cEHi<esc>A, <C-r>" V!

Provalo online!

Ispirato dalla risposta di tsh

Questo sfrutta il fatto che I'mviene strappato dall'inizio della stringa quando si elimina il testo dall'inizio e lo incolla fino alla fine con <C-r>"in modalità di inserimento.

C (gcc) , 59 42 33 byte

-17 byte grazie a @Conor O'Brien notando che l'importazione non era necessaria

-9 byte grazie a @tsh sottolineando un modo UB più breve di scrivere la funzione

a(x){printf("Hi%s, I'm C!",x+3);}

Provalo online!

Taglia i primi 3 caratteri dell'input (rimuove I'm) e lo circonda con il testo desiderato.

V , 13 byte

cEHi<Esc>A, <C-O>p V!

Provalo online!

Nuovo a V. Lo sapevo solo circa 30 minuti fa. Comunque, questa lingua viene scelta solo perché il suo nome costa solo 1 byte. Non sono sicuro di come inviare la <End>chiave in V. La maggior parte dell'ambiente vim accetterebbe <End>in sostituzione di <Esc>Aquesto esempio. Ma, sai, V ha 2 caratteri in meno di VIM. :)

Grazie a @Candy Gumdrop , salva 1 byte.

Stax , 13 byte

â∞¿φ‼0▲(─ƒSqÄ

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

.Hip        print "Hi" with no newline
3tp         trim 3 characters from start of input and print with no newline
            final line is to print the unterminated compressed literal ", I'm stax!"
`dYgAwg_

Ho spostato il commento finale di una riga poiché nulla può seguire una stringa non terminata letterale.

Esegui questo

brainfuck, 164

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

Provalo online!

Il "brainfuck!" parte della stringa viene generata con questo strumento, probabilmente può essere ulteriormente golfata a mano.

Excel, 36 33 byte

-3 byte grazie a Johan du Toit.

L'ingresso va in A1.

="Hi "&MID(A1,4,99)&", I'm Excel"

Primo tentativo:

=REPLACE(A1,1,3,"Hi")&", I'm Excel!"

Python 3 , 35 34 byte

lambda s:"Hi%s, I'm Python!"%s[3:]

Provalo online!

-1 byte grazie a Embodiment of Ignorance

Anche 34 byte, utilizzando le più recenti stringhe formattate, grazie a Gábor Fekete:

lambda s:f"Hi{s[3:]}, I'm Python!"

Provalo online!

R 45 44 39 byte

@Giuseppe Edit

sub("I'm(.*)","Hi\\1, I'm R",scan(,""))

@AaronHayman Edit

function(s)sub("I'm (.*)","Hi \\1, I'm R",s)

Provalo online!

PHP ,34 32 byte

Hi<?=substr($argn,3)?>, I'm PHP!

Provalo online!

Inserire tramite STDIN, chiamare con -F.

$ echo I'm a Stack-Overflow-er|php -F dad.php
Hi a Stack-Overflow-er, I'm PHP!

$ echo I'm hungry|php -F dad.php
Hi hungry, I'm PHP!

x86 ,37 36 byte

$ xxd DAD.COM
00000000: d1ee ac8a d8c6 0024 adc7 0448 698b d6b4  .......$...Hi...
00000010: 09cd 21ba 1901 cd21 c32c 2049 276d 2078  ..!....!., I'm x
00000020: 3836 2124                                86!$

smontato:

D1 EE       SHR  SI, 1                  ; point SI to DOS PSP (080H)
AC          LODSB                       ; load string length into AL, advance SI
8A D8       MOV  BL, AL                 ; put string length into BL
C6 40 24    MOV  BYTE PTR[BX][SI], '$'  ; add string terminator to end of string
AD          LODSW                       ; advance SI two chars
C7 04 6948  MOV  WORD PTR[SI], 'iH'     ; replace second and third char with 'Hi'
8B D6       MOV  DX, SI                 ; load string address for INT 21H string function
B4 09       MOV  AH, 9                  ; display a '$' terminated string function
CD 21       INT  21H                    ; call DOS API
BA 0119     MOV  DX, OFFSET S           ; load address for second part of string
CD 21       INT  21H                    ; call DOS API
C3          RET                         ; return to DOS
S  DB ", I'm x86!$"  

Un programma DOS eseguibile autonomo. Input dalla riga di comando, output sullo schermo.

Scarica e prova DAD.COM .

* Il nome esatto di "linguaggio" qui è un po 'ambiguo in quanto il codice macchina della CPU non è in realtà un linguaggio in senso formale. Andare con "x86" come nome generalmente compreso e accettato per la piattaforma di destinazione.

Java, 36 byte

s->"Hi"+s.substring(3)+", I'm Java!"

Provalo online.

Spazio bianco , 267 byte

[S S S T    S S T   S S S N
_Push_72_H][T   N
S S _Print_as_character][S S S T    T   S T S S T   N
_Push_105_i][T  N
S S _Print_as_character][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   N
T   S _Read_STDIN_as_character][T   N
T   S _Read_STDIN_as_character][N
S S N
_Create_Label_INPUT_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S S S T S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_TRAILING][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_INPUT_LOOP][N
S S S N
_Create_Label_TRAILING][S N
N
_Discard_top][S S T T   S S S T S T N
_Push_-69_!][S S T  T   N
_Push_-1_e][S S T   T   T   N
_Push_-3_c][S S T   T   S T N
_Push_-5_a][S S S T S T S N
_Push_10_p][S S S T T   S T N
_Push_13_s][S S T   T   N
_Push_-1_e][S S S T T   T   S N
_Push_14_t][S S S T T   N
_Push_3_i][S S S T  S N
_Push_2_h][S S T    T   T   T   T   N
_Push_-15_W][S S T  T   S S S T T   S N
_Push_-70_space][S S S T    T   T   N
_Push_7_m][S S T    T   T   T   T   T   T   N
_Push_-63_'][S S T  T   T   T   S T N
_Push_-29_I][S T    S S T   T   N
_Copy_0-based_3rd_-70_space][S S T  T   T   T   S T S N
_Push_-58_,][N
S S T   N
_Create_Label_PRINT_TRAILING_LOOP][S S S T  T   S S T   T   S N
_Push_102][T    S S S _Add][T   N
S S _Print_as_character][N
S N
T   N
_Jump_to_Label_PRINT_TRAILING_LOOP]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Poiché Whitespace inserisce un carattere alla volta, l'input dovrebbe contenere una nuova riga finale in modo che sappia quando interrompere la lettura dei caratteri e l'input viene eseguito.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

Print "Hi"
Read three characters from STDIN, and do nothing with them
Start INPUT_LOOP:
  Character c = STDIN as character
  If(c == '\n'):
    Call function PRINT_TRAILING
  Print c as character
  Go to next iteration of INPUT_LOOP

function PRINT_TRAILING:
  Discard the top of the stack (the c='\n' that was still on the stack)
  Push "!ecapsetihW m'I ," one character at a time
  Start PRINT_TRAILING_LOOP:
    Print as character
    Go to next iteration of PRINT_TRAILING_LOOP

I caratteri di ", I'm Whitespace!"vengono inseriti in ordine inverso e quindi stampati in un ciclo. Tutti i valori di questi caratteri vengono inoltre ridotti di 102, che vengono aggiunti nel ciclo prima della stampa per salvare byte. Questa costante 102 per abbassare ogni carattere è generata con questo programma Java . Inoltre, invece di premere -70due volte il valore per entrambi gli spazi, il secondo spazio "!ecapsetihW m'I ,"viene copiato dal primo con il comando Copia incorporato per salvare alcuni byte.

Linguaggio formula IBM / Lotus Notes, 61 62 byte

+1 perché non avevo notato il !alla fine dell'output.

"Hi"+@Right(i;"I'm")+", I'm IBM/Lotus Notes Formula Language!"

Formula di campo calcolata che accetta l'input da un campo modificabile i. Non avrebbe funzionato per "I'm an I'm", ma dal momento che non avrebbe alcun senso, suppongo che non accadrà.

Peccato che a 32 byte, il nome della lingua sia più della metà della lunghezza totale della formula!

Schermata seguente che mostra un esempio di input e output:

sed ( -r), 31 28 25 byte

-3 byte grazie a Shaggy -3 byte perché -rnon necessari nell'output

s/I'm(.*)/Hi\1, I'm sed!/

TIO

Japt , 18 byte

`Hi{s3}, I'm Japt!

Quando la libreria di compressione string di Japt raggiunge una compressione 0% ...

Provalo

Un'altra alternativa a 18 byte:

`Hi{Ť}, {¯4}Japt!

Ottava , 35 byte

@(s)["Hi" s(4:end) ", I'm Octave!"]

Provalo online!

@(s)                                 % Anonymous function taking a string input
    [                             ]  % Concatenate everything inside the brackets
     "Hi"          ", I'm Octave!"]  % The fixed parts of the output string
          s(4:end)                   % The input, except "I'm"

                                     % Returns the concatenated string

42 byte:

Ho provato a recuperare "Octave" in qualche modo, senza scriverlo, dal momento che 6 caratteri è parecchio paragonato ad altri nomi di altre lingue qui. Sfortunatamente, ho potuto solo trovare ver, che genera uno struct con campi separati da virgola. Richiede più di 6 byte. :(

@(s)["Hi" s(4:end) ", I'm " {ver.Name}{1}]

Provalo online!

Rubino -p , 32 27 26 byte

-5 byte sfruttando la risposta Jelly di Nick Kennedy .

-1 byte dalla divisione in un punto diverso nella stringa. Ho anche capito che il mio vecchio byte era sbagliato.

~/m/;$_="Hi#$', I'm Ruby!"

Spiegazione

                            # -p gets line of input and saves to $_
~/m/;                       # Find first 'm' in $_ using regex
     $_="Hi#$', I'm Ruby!"  # Save modified string to $_
                            # ($' is the string AFTER the most recent regex match)
                            # -p outputs $_ to screen

Provalo online!

Ruggine , 41 byte

|x:&str|print!("Hi{}, I'm Rust!",&x[3..])

Provalo online!

Lotto, 22 + 3 = 25 byte

@echo Hi %*, %0 Batch!

+3 byte per la denominazione di questo file I'm(con l' .batestensione richiesta per i file batch). Invoca come I'm hungry, quando risuonerà Hi hungry, I'm Batch!.

Perl 6 , 30 28 27 byte

{S/.../Hi/~", I'm Perl 6!"}

Provalo online!

Perl 5 -p , 31 24 byte

Riduzione in base ai chiarimenti dell'OP e a un suggerimento di @NahuelFouilleul.

/ /;$_="Hi $', $` Perl!"

Provalo online!

Gelatina ,  16  15 byte

Ḋa⁾Hi“'ṫṗḶ/÷!Ṗ»

Un programma completo che accetta un argomento di stringa (formattato in Python) che stampa il risultato.

Provalo online!

Come?

Ḋa⁾Hi“'ṫṗḶ/÷!Ṗ» - Link: list of characters    e.g. "I'm a programmer"
Ḋ               - dequeue                          "'m a programmer"
  ⁾Hi           - pair of characters               "Hi"
 a              - logical AND (vectorises)         "Hi a programmer"
     “'ṫṗḶ/÷!Ṗ» - list of characters               ", I'm Jelly!"
                -  - since this is a new leading constant chain the previous result
                -    is implicitly printed (with no trailing newline)
                - program result is implicitly printed (again with no trailing newline)

Nota: Ḋ⁾Hio...funziona anche.

Gelatina , 20 17 byte

ṫ4;“'ṫṗḶ/÷!Ṗ»⁾Hi;

Provalo online!

Un collegamento monadico che prende l'input come argomento e restituisce una stringa Jelly.

Spiegazione

ṫ4                | everything from 4th character on
  ;“'ṫṗḶ/÷!Ṗ»     | concatenate ", I’m Jelly!" to the end
             ⁾Hi; | concatenate "Hi" to the beginning

VBA (Excel), 27 28 byte

?"Hi"Mid([A1],4)", I'm VBA!

L'input va nella cella A1 del foglio attivo in Excel, esegui il codice nella finestra immediata

Sfrutta il fatto che "SomeString"SomeValueeSomeValue"SomeString" si concatenerà implicitamente e che omettendo il terzo argomento dalla MIDfunzione prenderà tutti i caratteri dalla fine dell'input, trasformandolo in una funzione "dump iniziale di caratteri"

(-1 byte grazie a Shaggy, ma +1 quando OP ha confermato che tutte le risposte dovrebbero terminare con un punto esclamativo)
(-1 byte grazie a Taylor Scott che mi ricorda che la doppia virgoletta finale era facoltativa)

J , 22 byte

', I''m J!',~'Hi',3}.]

Provalo online!

05AB1E , 23 21 byte

Salvato 2 byte grazie a Kevin Cruijssen

',«#À„Hiš"05AB1E!"ªðý

Provalo online!

Spiegazione

',«                    # append ","
   #                   # split on spaces
    À                  # rotate left
     „Hiš              # prepend "Hi"
         "05AB1E!"ª    # append the language name
                   ðý  # join on spaces

QuadR , 22 byte

^...
$
Hi
, I'm QuadR!

Provalo online!

Questo sostituisce:

^... tre caratteri iniziali
e
$ la fine della riga

con

Hi
e
,I'm QuadR
rispettivamente

Retina , 22 21 byte

3L$`
Hi$', $` Retina!

Provalo online! Il link include casi di test. Non funziona in Retina 0.8.2, quindi adatta invece la risposta QuadR di @Adám. Spiegazione: Il modello è vuoto, quindi corrisponde in ogni posizione nella stringa di input. Tuttavia abbiamo solo bisogno della terza (o quarta soluzione). La sostituzione viene quindi applicata a quella partita. All'interno di quella sostituzione, si $'riferisce al resto della stringa e $`all'inizio della stringa.

Retina 0.8.2 , 26 25 23 byte

^...
Hi
$
, I'm Retina!

-1 byte grazie a @attinat .
-2 byte eseguendo il porting della risposta QuadR di @Adám , quindi assicurati di votarlo !!

PS: @Neil ha pubblicato una risposta Retina più breve nella nuova versione , quindi ho modificato esplicitamente questa risposta in Retina 0.8.2.

Provalo online.

Spiegazione:

Sostituisci i primi tre caratteri con "Ciao":

^...
Hi

E poi aggiungi un finale ", sono Retina!" (sostituendo la fine della stringa):

$
, I'm Retina!

bash, 24 byte

echo Hi ${@:2}, $1 bash!

TIO