Nella libreria standard C, i nomi delle intestazioni terminano con un .hsuffisso:

stdio.h

In C ++, questi nomi di intestazione sono disponibili in una forma alternativa, con un cprefisso invece:

cstdio

Scrivi una funzione che converte il primo modulo nel secondo. È possibile eseguire la conversione sul posto oppure lasciare intatta la stringa originale e restituire una nuova stringa. Qualunque cosa sembri naturale nella tua lingua preferita.

Il codice deve essere compilato / interpretato senza errori. Gli avvisi del compilatore sono accettabili.

Ecco la tua soluzione di base C. Ha 70 caratteri e genera un avviso relativo a strlen:

void f(char*h){int i=strlen(h);h[--i]=0;while(--i)h[i]=h[i-1];*h='c';}

Vince la soluzione più breve (misurata in numero di caratteri).

Aggiornamento: se la lingua scelta non supporta le funzioni, sono accettabili anche interi programmi.

Aggiornamento: come suggerito da FUZxxl, ecco un elenco completo dei file di intestazione nella libreria standard C:

assert.h
ctype.h
errno.h
float.h
limits.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h
stdlib.h
string.h
time.h

In particolare, non ci sono nomi di intestazione con più punti al loro interno.

80386 codice macchina, 13 byte

Hexdump del codice:

b0 63 86 01 41 3c 2e 75 f9 c6 01 00 c3

Codice sorgente (può essere compilato da Visual Studio):

__declspec(naked) void __fastcall conv(char s[])
{
    _asm {
        mov al, 'c';            // b0 63
    myloop:
        xchg al, [ecx];         // 86 01
        inc ecx;                // 41
        cmp al, '.';            // 3c 2e
        jne myloop;             // 75 f9
        mov byte ptr [ecx], 0;  // c6 01 00
        ret;                    // c3
    }
}

Converte la stringa sul posto. Il codice è così semplice, non è necessario salvare e ripristinare i registri (utilizzando solo ale ecx, che la fastcallconvenzione consente di bloccare).

Python: 19 caratteri

lambda s:'c'+s[:-2]

CJam, 6 byte

'clW(<

Questo è un programma completo che legge la stringa tramite STDIN

Spiegazione :

'c               "Put character c on stack";
  l              "Read a line from STDIN";
   W             "W is a predefined variable with value -1";
    (            "Decrease the value by 1";
     <           "Remove last 2 characters from the string on stack, the input argument";

Provalo online qui

Java 8 - 25 caratteri

h->"c"+h.replace(".h","")

brainfuck - 25 23 byte

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

Se la tua lingua preferita non supporta le funzioni, sono accettabili anche interi programmi.

Questo è un intero programma che accetta input da STDIN.

,[>,]      get all bytes of input
<-----.    subtract 5 from last byte (always "h"; "h" minus 5 = "c") and print result
<,         set second last byte to 0 by abusing comma
<[<]>      go to first byte
[.>]       print byte and move right until hitting 0

Haskell - 23 caratteri

('c':).takeWhile(/='.')

Haskell - 16 personaggi, come suggerito da nimi

('c':).init.init

C, 38

Vedi su Ideone

f(s,o){snprintf(o,strlen(s),"c%s",s);}

sè un puntatore alla stringa di input ed oè dove l'output deve essere scritto.

Ho trovato un modo di abusare snprintf. La stringa di output è convenientemente più corta di un carattere rispetto all'input e la lunghezza massima della stringa scritta da snprintfè 1 in meno ndell'argomento, quindi taglia .h. Nota: questa tecnica non funzionerà con l'implementazione di Microsoft perché fa la cosa sbagliata e non riesce a terminare null la stringa.

File batch di Windows 11

@echo c%~n1

Il primo parametro passato è% 1. Il modificatore ~ ​​n restituisce solo il nome file senza estensione.

Se è accettabile anche l'eco del comando espanso sullo schermo, è possibile rimuovere l'iniziale @.

Tipo di nodo TIS Architettura T21 - 85 byte

Questa risposta è solo per divertimento; la lingua è nata dopo che questa sfida è stata scritta e quindi non posso vincere con essa. (Non che stavo per farlo.)

Ok, mi sono divertito un po 'con questo. Probabilmente dovrei semplicemente chiamare la lingua "TIS-100", ma perché rompere il personaggio? : D

TIS-100 è un gioco sulla programmazione di un computer con un'architettura assolutamente unica e bizzarra. Ho scritto un puzzle personalizzato per questa sfida, che mi consente di prendere l'input e verificare l'output rispetto a una "stringa" corretta conosciuta. Sfortunatamente, non c'è modo di gestire stringhe o caratteri, quindi questo programma utilizza semplicemente il valore ASCII di ciascun carattere per l'input e l'output.

Se desideri vederlo in azione, puoi utilizzare questo emulatore o semplicemente guardarmi mentre lo eseguo nel gioco reale qui . Si noti che nel video è l'ultima riga del primo nodo D:MOV UP NIL. Dopo aver finito il video, mi sono reso conto che potevo giocare a golf D:ADD UP. Funzionalmente non c'è differenza, perché il valore di ACC viene immediatamente sovrascritto comunque.

Questa è la stringa che ho usato per il mio conteggio di byte:

MOV 99 ANY
MOV -46 ACC
ADD UP
JEZ D
ADD ACC ANY
JRO -5
D:ADD UP
MOV UP ANY
MOV UP ANY

Questo è il testo di ogni nodo non vuoto, separato da newline (aggiungendo effettivamente 1 byte per ogni nodo usato oltre il primo, rispecchiando la nostra regola sul codice in più file).

Dyalog APL (8 personaggi)

'c',¯2↓⊢

Questa soluzione è esattamente la stessa della soluzione J che ho presentato, ma utilizza un carattere in meno a causa di ↓un carattere in meno di }..

J (9 caratteri)

'c',_2}.]

• |yè l' entità di y(chiamato anche valore assoluto)
• x }. yfa cadere gli |xoggetti da y; gli oggetti vengono lasciati cadere dalla parte anteriore se xè positivo, dalla fine se xè negativo.
• x , yaggiunge xe y.
• 'c' , _2 }. yfa la trasformazione che desideri; in tacita notazione questo può essere espresso come 'c' , _2 }. ].

Struzzo 0.6.0 , 8 caratteri

););"c\+

)è l'operatore "uncons giusto". Se applicato a una stringa, si trasforma, ad esempio, `foo`in `fo` `o`. ;viene utilizzato per rimuovere il personaggio in più, e questo viene fatto di nuovo.

Quindi, "cviene spinto. Questa è semplicemente una scorciatoia per `c`.

\+ scambia i primi due elementi dello stack e li concatena.

piet ( 9x11 = 99 8X11 = 88)

un altro tentativo (2x37 = 74)

Difficile renderlo molto più piccolo in quanto deve generare un 99 ('c') e un 46 ('.'), E questo occupa spazio nel piet.

F # - 39 37 31

31 - Perché la typeinference in F # oscilla!

fun s->("c"+s).Replace(".h","")

37

fun(s:string)->"c"+s.Replace(".h","")

39

fun(s:string)->"c"+s.Remove(s.Length-2)

gema, 6

*.h=c*

( Gema è un oscuro linguaggio macro.)

Bash, 18 anni

f()(echo c${1%.*})

Produzione:

$ f stdio.h
cstdio
$ 

GNU sed -r, 14

sed non ha davvero alcun concetto di funzioni, quindi ecco un programma sed completo invece:

s/(.*)../c\1/

Produzione

$ sed -r 's/(.*)../c\1/' <<< stdio.h
cstdio
$ 

La -rè stata inclusa nella partitura come un personaggio in più.

Preludio , 31 caratteri

Poiché gli invii di programmi completi sono apparentemente accettabili, ecco un programma che legge l'intestazione in stile C da STDIN e stampa l'intestazione in stile C ++ su STDOUT:

99+9+(?)###(#
9(1-)       ^)(!)

Ciò richiede un interprete conforme allo standard che stampa l'output come codici carattere. Se stai usando l'interprete Python dovrai impostare NUMERIC_OUTPUT = False.

Richiede anche che non ci sia nuova riga finale su STDIN.

Spiegazione

In Preludio tutte le linee vengono eseguite in parallelo, una colonna alla volta. Ogni riga ha il proprio stack, inizializzato su una quantità infinita di 0s.

99+9+
9(1-)

Questo è il più breve che ho potuto inventare per ottenere uno 99nello stack superiore (il codice carattere di c). Per prima cosa aggiungo 18nello stack superiore e spingo 9a nello stack inferiore. Il fondo quindi conta verso il basso fino a 0in un ciclo, mentre lo stack superiore aggiunge più 9s in su. Questo si aggiunge allo 99stack superiore e lo stack inferiore viene lasciato di 0nuovo con s. Si noti che tutto +9+fa parte del ciclo, quindi in realtà ci sono due operazioni di aggiunta per iterazione, ma questo non è un problema, grazie alla fornitura infinita di0 s sotto.

Ora (?)legge STDIN, un personaggio alla volta e viene inserito nello stack superiore. Il loop termina alla fine dell'ingresso, quando si ?preme uno zero. ###si sbarazza di quello zero, il he il .. Ora il ciclo successivo estrae i numeri dallo stack superiore mentre li copia nello stack inferiore. Questo essenzialmente inverte lo stack. Nota che le parentesi aperte e chiuse sono su linee diverse - questo non è un problema, perché la posizione verticale di )è irrilevante in Preludio, ma mi fa risparmiare un byte sulla prima riga.

Infine, (!)stampa tutti i personaggi fino a quando la pila è vuota.

Pyth, 7 caratteri

L+\cPPb

Spiegazione:

L         def y(b):return
 +\c                      "c" +
    PPb                         b[:-1][:-1]

Prova questo:

L+\cPPb
y"stdio.h

sul compilatore / Executor Pyth online

Se fossero ammessi programmi completi:

Pyth, 6 caratteri

+\cPPQ

C ++ 14, 41 caratteri

[](auto&s){s="c"+s.substr(0,s.size()-2);}

Ispirato da questa altra risposta. L'ho fatta una risposta separata perché qui uso una funzionalità nuova in c ++ 14, lambda generico .

Guardalo in azione qui .

T-SQL - 58 caratteri

CREATE PROC Q(@ VARCHAR(MAX))AS
SELECT'c'+LEFT(@,LEN(@)-2)

Esegui come EXEC Q (la tua stringa qui)

Perl - 20 caratteri

sub{c.pop=~s/..$//r}

Nota come cè una parola nuda e come tale richiede una mancanza di use strict. Deve essere usato come espressione, non come affermazione.

Marbelous, 24

@063
-Z//
3W<C+Z
]]!!
@0

Riceve input tramite STDIN, output su STDOUT.

Funziona controllando ogni byte con .( 0x46). Poiché 0x46non è possibile inserire una singola cifra base-36, sottraggiamo 35 ( Z) prima del confronto e lo aggiungiamo nuovamente prima dell'output.

Ogni marmo è duplicato da 3W ( tre vie, ma il lato sinistro è scartato dal lato del tabellone). Il marmo inviato verso il basso recupera il byte successivo da STDIN. Il marmo a destra viene controllato ., quindi emesso o inviato a!! , che termina il programma.

Il programma inizia passando c ( 0x63) attraverso, che verrà inviato a STDOUT.

Provalo online qui. Le librerie devono essere abilitate, le schede cilindriche devono essere disabilitate.

C, 64

Leggermente più corto del riferimento c:

f(char*h){char*d=strstr(h,".");memmove(h+1,h,d++-h);*d=0;*h=99;}

Probabilmente più golf da fare con questo.

C, 48 (hack di libc)

f(char*h){strcpy(h+1,h);*strstr(h,".")=0;*h=99;}

La strcpymanpage indica esplicitamente "Le stringhe potrebbero non sovrapporsi". Tuttavia, ho scoperto che la libc che sto usando sembra essere codificata in modo sicuro per gestire correttamente tutto lo stesso. Questa è la libreria GNU C (Ubuntu EGLIBC 2.19-0ubuntu6.4) su Ubuntu 14.04.

JavaScript (ES6) 20

Non riesco a credere che ES6 mancasse ancora

s=>'c'+s.slice(0,-2)

Perl, 15 (14 + -p)

s/(.*)\.h/c$1/

mk, 34 caratteri

mk (1) è il sostituto di Plan 9 per make. Solo per divertimento, questo mkfile converte i nomi delle intestazioni C in nomi delle intestazioni C ++:

c%:Q:
    :

%.h:Q: c%
    echo $prereq

C'è una singola scheda prima :e echo. Usa così:

% mk stdio.h
cstdio

CoffeeScript - 16

(x)->"c"+x[..-3]

TI-BASIC 83/84, 15

"c"+sub(Ans,1,length(Ans)-2

R, 33

function(x)sub("(.+)..","c\\1",x)

Questa funzione utilizza espressioni regolari.

Esempio di utilizzo:

> (function(x)sub("(.+)..","c\\1",x))("stdio.h")
[1] "cstdio"