Todos conhecemos a piada clássica do pai que é mais ou menos assim:

1. Alguém diz uma frase para se descrever (por exemplo, I'm tiredou I'm confused).

2. Um entusiasta da piada do pai aparece e responde Hi <adjective>, I'm Dad!, porque as apresentações seguem o mesmo formato ( I'm Petersegue o mesmo formato que I'm hungry).

Seu trabalho é receber uma entrada na forma de um autodescritor e gerar o formulário de piada do pai apropriado, mas em vez de usar a palavra "Pai", você usará o nome da linguagem de programação que está programando no.

Casos de teste (suponha que eles estejam sendo analisados ​​pelo 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!

Agora assuma que esses casos de teste estão sendo analisados ​​pelo 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!

O desafio exato:

1. Pegue uma sequência no formato de auto-descritor ( I'm <adjective>ou I'm a(n) <noun>) usando entrada padrão ou através de uma função.

   • Suponha que não há pontuação final.

   • Suponha que a palavra I'mseja usada e não I am.

2. Converta-o para um formato de piada de pai - veja os exemplos acima para saber exatamente como isso deve ser.

Outras coisas:

• Isso é código-golfe , e a menor contagem de bytes vence.

• Siga as regras padrão das brechas - nenhuma delas, por favor.

• Diverta-se!

Entre os melhores

Você pode visualizar o cabeçalho desta postagem expandindo o widget / snippet abaixo. Para que sua postagem seja incluída na classificação, você precisa de um cabeçalho ( # header text) com as seguintes informações:

• O nome do idioma (termine com vírgula ,ou hífen -), seguido por ...

• A contagem de bytes, como o último número a aparecer no seu cabeçalho.

Por exemplo, JavaScript (ES6), 72 bytesé válido, mas Fortran, 143 bytes (8-bit)é inválido porque a contagem de bytes não é o último número no cabeçalho (sua resposta será reconhecida como 8 bytes - não tire proveito disso).

<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 bytes

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

Experimente online!

Inspirado pela resposta do tsh

Isso tira vantagem do fato de que I'mé arrancado do início da string ao excluir o texto do início e o cola até o final com o <C-r>"modo de inserção.

C (gcc) , 59 42 33 bytes

-17 bytes graças a @Conor O'Brien notando que a importação não era necessária

-9 bytes graças a @tsh indicando uma maneira mais curta e UB de escrever a função

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

Experimente online!

Corta os 3 primeiros caracteres da entrada (remove I'm) e o envolve com o texto desejado.

V , 13 bytes

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

Experimente online!

Novo no V. Só sabia disso há 30 minutos. De qualquer forma, esse idioma é escolhido apenas porque seu nome custa apenas 1 byte. Não tenho certeza de como enviar a <End>chave no V. A maioria dos ambientes vim aceitaria <End>como substituição <Esc>Aneste exemplo. Mas, você sabe, V é 2 caracteres menor que o vim. :)

Graças a @Candy Gumdrop , economiza 1 byte.

Stax , 13 bytes

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

.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_

Mudei o comentário final para cima uma linha, pois nada pode seguir uma literal de seqüência não terminada.

Execute este

brainfuck, 164

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

Experimente online!

O "cérebro!" parte da string é gerada com essa ferramenta, provavelmente pode ser jogada ainda mais à mão.

Excel, 36 33 bytes

-3 bytes graças a Johan du Toit.

A entrada entra em A1.

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

Primeira tentativa:

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

Python 3 , 35 34 bytes

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

Experimente online!

-1 byte graças à Modalidade de Ignorância

Também 34 bytes, usando as novas seqüências de caracteres formatadas, graças a Gábor Fekete:

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

Experimente online!

R 45 44 39 bytes

@Giuseppe Edit

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

@AaronHayman Editar

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

Experimente online!

PHP ,34 32 bytes

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

Experimente online!

Entrada via STDIN, chame com -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 bytes

$ 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!$

Desmontado:

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!$"  

Um programa executável independente do DOS. Entrada da linha de comando, saída para a tela.

Faça o download e teste o DAD.COM .

* O nome exato da "linguagem" aqui é um pouco ambíguo, pois o código da máquina da CPU não é realmente uma linguagem no sentido formal. Indo com "x86" como um nome geralmente aceito e aceito para a plataforma de destino.

Java, 36 bytes

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

Experimente online.

Espaço em branco , 267 bytes

[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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Como o espaço em branco insere um caractere de cada vez, a entrada deve conter uma nova linha à direita, para que ele saiba quando parar de ler os caracteres e a entrada está concluída.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-código:

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

Os caracteres de ", I'm Whitespace!"são empurrados na ordem inversa e, em seguida, impressos em um loop. Todos os valores desses caracteres também são reduzidos em 102, que são adicionados ao loop antes da impressão para salvar bytes. Essa constante 102 para abaixar cada caractere é gerada com este programa Java . Além disso, em vez de empurrar o valor -70para os dois espaços duas vezes, o segundo espaço "!ecapsetihW m'I ,"é copiado do primeiro com o Copy incorporado para salvar alguns bytes.

IBM / Lotus Notes Formula Language, 61 62 bytes

+1 porque eu não havia notado !o final da saída.

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

Fórmula de campo computado que recebe sua entrada de um campo editável i. Seria um fracasso para "Eu sou um eu", mas como isso não faria nenhum sentido, estou assumindo que isso não acontecerá.

Pena que, com 32 bytes, o nome do idioma seja mais da metade do comprimento total da fórmula!

Captura de tela abaixo mostrando um exemplo de entrada e saída:

sed ( -r), 31 28 25 bytes

-3 bytes graças a Shaggy -3 bytes porque -rnão é necessário na saída

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

TIO

Japonês , 18 bytes

`Hi{s3}, I'm Japt!

Quando a biblioteca de compactação de string do Japt atinge uma taxa de compactação de 0% ...

Tente

Outra alternativa de 18 bytes:

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

Oitava , 35 bytes

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

Experimente 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 bytes:

Tentei recuperar o "Octave" de alguma forma, sem escrevê-lo, pois 6 caracteres são bastante comparados a alguns dos outros nomes de idiomas aqui. Infelizmente, só consegui encontrar ver, o que gera uma estrutura com campos separados por vírgula. Leva mais de 6 bytes. :(

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

Experimente online!

Ruby -p , 32 27 26 bytes

-5 bytes, aproveitando a resposta Jelly de Nick Kennedy .

-1 byte da divisão em um ponto diferente na string. Também percebi que meu antigo número de dígitos estava errado.

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

Explicação

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

Experimente online!

Ferrugem , 41 bytes

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

Experimente online!

Lote, 22 + 3 = 25 bytes

@echo Hi %*, %0 Batch!

+3 bytes para nomear este arquivo I'm(com a .batextensão necessária para arquivos em lote). Invoque como I'm hungry, quando ecoará Hi hungry, I'm Batch!.

Perl 6 , 30 28 27 bytes

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

Experimente online!

Perl 5 -p , 31 24 bytes

Corte com base nos esclarecimentos do OP e em uma sugestão do @NahuelFouilleul.

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

Experimente online!

Geléia ,  16  15 bytes

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

Um programa completo que aceita um argumento de string (formatado em Python) que imprime o resultado.

Experimente online!

Quão?

Ḋ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...funciona também.

Geléia , 20 17 bytes

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

Experimente online!

Um link monádico tomando a entrada como argumento e retornando uma sequência Jelly.

Explicação

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

VBA (Excel), 27 28 bytes

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

A entrada entra na célula A1 da Planilha Ativa no Excel, execute o código na Janela Imediata

Tira proveito do fato de que "SomeString"SomeValuee SomeValue"SomeString"vai implicitamente concatenate, e que omitir o terceiro argumento da MIDfunção irá tomar todas as personagens do fim da entrada - transformando-o em um "dump caracteres iniciais" função

(-1 byte graças a Shaggy, mas +1 quando OP confirmou que todas as respostas deveriam terminar com um ponto de exclamação)
(-1 byte graças a Taylor Scott, lembrando-me que a citação dupla final era opcional)

J , 22 bytes

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

Experimente online!

05AB1E , 23 21 bytes

Guardado 2 bytes graças a Kevin Cruijssen

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

Experimente online!

Explicação

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

QuadR , 22 bytes

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

Experimente online!

Isso substitui:

^... três caracteres iniciais
e
$ o final de linha

com

Hi
e
,I'm QuadR
respectivamente

Retina , 22 21 bytes

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

Experimente online! O link inclui casos de teste. Não funciona no Retina 0.8.2, portanto, adapte a resposta QuadR do @ Adám. Explicação: O padrão está vazio, portanto, corresponde em todas as posições na sequência de entrada. Porém, só precisamos do terceiro (ou quarto funcionaria). A substituição é então aplicada a essa partida. Dentro dessa substituição, $'refere-se ao restante da cadeia e $`refere-se ao início da cadeia.

Retina 0.8.2 , 26 25 23 bytes

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

-1 byte graças a @attinat .
-2 bytes, portando a resposta QuadR de @ Adám , por isso não deixe de votar nele !!

PS: @Neil postou uma resposta mais curta do Retina na nova versão , então mudei essa resposta para o Retina 0.8.2 explicitamente.

Experimente online.

Explicação:

Substitua os três primeiros caracteres por "Oi":

^...
Hi

E depois acrescente um ", eu sou Retina!" (substituindo o final da sequência):

$
, I'm Retina!

bash, 24 bytes

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

TIO