Kodtävling Nr 2. Snyggast kod. Minst antal rader. Roligast lösning och språk.

0 ~~~~~~~~~~~~~~ 0v                    p1     p01+1:g01    <
                                                     >:"y"-|
                                               >:"u"-|      
                                         >:"o"-|            
                     >v            >:"i"-|                  
                             >:"e"-|                        
                  >\:|> :"a"-|                              
                     $                                      
                  > v      $\<     <     <     <     <     <
                  ,                                         
                  |:<                                       
                  1                                         
                  0                                         
                  g                                         
                     #                                      
                 v_"yaw" v                                  
                                                            
                 "                                          
                 y                                          
                 a                                          
                 "                                          
      v          <                                          
      1                                                     
      0                                                     
      g                                                     
      :                                                     
     v_     $        > > v                                  
     >v                ,                                    
      1                |:<                                  
      -                @                                    
      1                                                     
      g                                                     
      >10g:1-10p$^

def piglatin(str):
	phrase = ""
	vowels = "aeiouyAEIOUY"
	words = str.split(" ")
	for w in words:
		wcopy = w
		# special characters such as .!,;
		lchar = ""
		if w[-1:] not in string.ascii_letters:
			lchar,w = w[-1:],w[:-1]
		# actual conversion
		if w[0] in vowels:
			w += "way"
		else:
			index = [w.find(i) for i in vowels if w.find(i) != -1]
			if len(index) > 0:
				w = w[index[0]:] + w[:index[0]] + "ay"
		# append
		if wcopy[:1] in string.ascii_uppercase:
			w = w.lower()
			w = w.capitalize()
		phrase += w + lchar + " "
	return phrase

print join" ",map{join"",map{shift(@c)?uc:$_}split //}
map{s/^([^a-z]*)(y?(?:qu|[^aeiouy])*)(.*?)([^a-z]*)$/"$1$3".do{$2||'w'}."ay$4"/e;$_}
map{lc join"",grep{push @c,/[A-Z]/?1:0;1}split //}split /\s/,<STDIN>

<%
' Copyright (C) 2005 Simon Svensson
' 
' This program is free software; you can redistribute it and/or
' modify it under the terms of the GNU General Public License
' as published by the Free Software Foundation; either version 2
' of the License, or (at your option) any later version.
' 
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU General Public License for more details.
' 
' You should have received a copy of the GNU General Public License
' along with this program; if not, write to the Free Software
' Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
' 
' Note: License can be found at http://www.gnu.org/licenses/gpl.txt

' Piglatin Rules:
'  Words starting with vowel:
'    Append "way".
'  Words starting with other character:
'    Move all consonants before first vowel to end, and append "ay"
'      Example: fun > unfay
'  Must handle upper- and lower-case characters.
'  http://www.snowcrest.net/donnelly/piglatin.html

Option Explicit

Function PigLatin(ByVal strIn)
	Dim strOut, strWord
	strOut=""
	Do While Len(strIn)>0
		strOut=strOut & GetData(strIn, false)
		If Len(strIn)=0 Then Exit Do
		strOut=strOut & ChangeWord(GetData(strIn, true))
	Loop
	PigLatin=strOut
End Function

Function IsWovel(ByVal strChar)
	strChar=LCase(strChar)
	Select Case strChar
		Case "a", "e", "i", "o", "u" : IsWovel=True
		Case Else : IsWovel=False
	End Select
End Function

Function GetData(ByRef strString, bolWord)
	Dim RE, objMatches, objMatch, strData
	Set RE=New RegExp
	Re.IgnoreCase=True
	If bolWord Then
		RE.Pattern="^([a-z]*)"
	Else
		RE.Pattern="^([^a-z]*)"
	End If
	
	Set objMatches=Re.Execute(strString)
	strData=objMatches(0)
	
	GetData=strData
	If Len(strData)=Len(strString) Then
		strString=""
	Else
		strString=Mid(strString, Len(strData)+1)
	End If
End Function

Function ChangeWord(ByVal strWord)
	Dim bolWholeUCase, intI
	bolWholeUCase=True
	For intI=1 To Len(strWord)
		bolWholeUCase=bolWholeUCase And Mid(strWord, intI, 1)=UCase(Mid(strWord, intI, 1))
	Next
	bolWholeUCase=bolWholeUCase And Len(strWord)>1
		
	If IsWovel(Mid(strWord, 1, 1)) Then
		strWord=strWord & "way"
	Else

		Dim bolStartUCase, strPrefix
		bolStartUCase=Mid(strWord, 1, 1)=UCase(Mid(strWord, 1, 1))
		strPrefix=""
		
		Do While Len(strWord)>0 And IsWovel(Mid(strWord, 1, 1))=False
			strPrefix=strPrefix & Mid(strWord, 1, 1)
			strWord=Mid(strWord, 2)
		Loop
		
		strWord=strWord & strPrefix & "ay"
		If bolStartUCase Then
			strWord=UCase(Mid(strWord, 1, 1)) & LCase(Mid(strWord, 2))
		Else
			strWord=LCase(strWord)
		End If
	End If
	
	If bolWholeUCase Then strWord=UCase(strWord)
	ChangeWord=strWord	
End Function

Dim strPhrase
Response.Write "<pre>"
Response.Write "<i>""Should be""</i> comes from http://www.snowcrest.net/donnelly/piglatin.html" & vbCrLf & vbCrLf

strPhrase="Hello world, extra fun!"
Response.Write "In:        " & strPhrase & vbCrLf
Response.Write "Out:       " & piglatin(strPhrase) & vbCrLf
Response.Write "Should be: Ellohay orldway, extraway unfay!" & vbCrLf
Response.Write vbCrLf

strPhrase="Push me, and then just touch me, 'til I can get my satisfaction."
Response.Write "In:        " & strPhrase & vbCrLf
Response.Write "Out:       " & piglatin(strPhrase) & vbCrLf
Response.Write "Should be: Ushpay emay, andway enthay ustjay ouchtay emay, 'iltay Iway ancay etgay ymay atisfactionsay." & vbCrLf
Response.Write vbCrLf


%>

Hello world, extra fun! <-- skriv din text här och kör sen med GY@"
 bcdfghjklmnpqrstvwxyz y BCDFGHJKLMNPQRSTVWXYZ p aeiuoåäöAEIOUÅÄÖ u < o 
`a"sP 
W"sxma@q  
hhxW"sxma`kv$h"ty@q 
way
`y^v$h"ry@r 
`ae"sp`a"sxma`jv$h"ty@q 
`agUle"spgul`a"sxma`jv$h"ty@q 
`a"sPe"hp@t
`l/H
w"zyl `glx"zP^v$h"ey@e
`df/ld$"sp^vj$h"wy@w
^kmf2kmdkmukmpkmykmgkv$h"hykmjkmkkmokmlgg^"sxma`f^v$h"qy@q

_root.onLoad = function() {
	trace(toPigLatin("Hello world, extra fun!"));
	trace(toPigLatin("A quiet, yellow style."));
};
function toPigLatin(input) {
	wovels = "aoueiAOUEI";
	punctuation = ".,!?;:";
	textArray = input.split(" ");
	for (i=0; i<textArray.length; i++) {
		punct = "";
		big = false;
		if (punctuation.indexOf(textArray[i].substr(textArray[i].length-1)) != -1) {
			punct = textArray[i].substr(textArray[i].length-1);
			textArray[i] = textArray[i].substr(0, textArray[i].length-1);
		}
		if (textArray[i].substr(0, 1) == textArray[i].substr(0, 1).toUpperCase()) {
			big = true;
		}
		textArray[i] = textArray[i].toLowerCase();
		if (wovels.indexOf(textArray[i].substr(0, 1)) != -1) {
			textArray[i] += "way";
		} else {
			buffer = "";
			prebuff = "";
			while (wovels.indexOf((textArray[i]).substr(0, 1)) == -1) {
				if (buffer != "" and "yY".indexOf((textArray[i]).substr(0, 1)) != -1) {
					break;
				}
				if ((textArray[i]).substr(0, 1)>-1) {
					prebuff += textArray[i].substr(0, 1);
					textArray[i] = textArray[i].substr(1);
				} else if ((textArray[i]).substr(0, 2).toLowerCase() == "qu") {
					buffer += textArray[i].substr(0, 2);
					textArray[i] = textArray[i].substr(2);
				} else {
					buffer += textArray[i].substr(0, 1);
					textArray[i] = textArray[i].substr(1);
				}
			}
			textArray[i] = prebuff+textArray[i]+buffer+"ay";
		}
		if (big) {
			textArray[i] = textArray[i].substr(0, 1).toUpperCase()+textArray[i].substr(1);
		}
		textArray[i] += punct;
	}
	return textArray.join(" ");
}

(setq vokaler "aoåueiyäö")
(setq special ".,;:!?")

(defun konvertera-vokal (ord)
  (concatenate 'string ord "way"))

(defun konvertera-konsonant (ord slut början)
  (let ((ay (if (= (length ord) 1)
		"ay"
	      "")))
  (cond ((tom? ord) (concatenate 'string början slut))
	((find (första ord) special)
	 (konvertera-konsonant (str-resten ord)
			       (concatenate 'string slut "ay" (str-första ord))
			       början))
	((or (find (första ord) vokaler) (> (length början) 0))
	 (konvertera-konsonant (str-resten ord)
			       (concatenate 'string slut ay)
			       (concatenate 'string början (str-första ord))))
	(t (konvertera-konsonant (str-resten ord) 
				 (concatenate 'string slut (str-första ord) ay)
				 början)))))

(defun dela-upp-i-ord (mening)
  (cond
   ((tom? mening) '())
   (t (multiple-value-bind (ord resten) (hitta-ord-och-rest mening '())
	(cons ord (dela-upp-i-ord resten))))))

(defun hitta-ord-och-rest (mening ord)
  (cond
   ((tom? mening) ord)
   ((char= (första mening) #\Space) (values ord (str-resten mening)))
   (t (hitta-ord-och-rest (str-resten mening) (concatenate 'string ord (str-första mening))))))

(defun översätt (lista)
  (if (endp lista) '()
    (let ((nytt-ord (if (find (första (first lista)) vokaler)
			(konvertera-vokal (first lista))
		      (konvertera-konsonant (first lista) "" ""))))
      (cons nytt-ord (översätt (rest lista))))))
   
(defun pig-latin (mening)
  (let ((ny-mening (slå-ihop (översätt (dela-upp-i-ord mening)))))
    (stor-bokstav (string-downcase (subseq ny-mening 0 (- (length ny-mening) 1))))))

(defun tom? (str)
  (eq (length str) 0))

(defun första (str)
  (char str 0))

(defun str-första (str)
  (string (char str 0)))

(defun str-resten (str)
  (subseq str 1 (length str)))

(defun stor-bokstav (str)
  (concatenate 'string (string-upcase (str-första str)) (str-resten str)))

(defun slå-ihop (lista)
  (if (endp lista) '()
    (concatenate 'string (first lista) " " (slå-ihop (rest lista)))))

import re

reVoc = re.compile(r"(\\b[aeiouAEIOU])([a-zA-Z]*)\\b")
reCons = re.compile(r"(\\b[^aeiouyAEIOUY-])([a-zA-Z]*)\\b")

def toPigLatin(text):
    return " ".join([wordToPig(word) for word in text.split()])
        
def wordToPig(word):
    result = reVoc.sub(r"\\1\\2way", word)
    result = result==word and reCons.sub(r"\\2\\1ay", word) or result
    return result.islower() and result or result.capitalize()

print(
    join(" ", map{
        join("", map{
            shift(@case) ? uc : $_;
        } split //);
    }
    map{
        s/^([^a-z]*)(y?(?:qu|[^aeiouy])*)(.*?)([^a-z]*)$/
            "$1$3".do{$2||'w'}."ay$4"/e; 
        $_;
    }
    map{
        lc(join "", grep{
            push @case, (/[A-Z]/?1:0);
            1;
        }split //);
    } split /\s/, <STDIN>));

(*
 * PigLatin.ml
 * Pig Latin in Objective ML (ocaml)
 * (c) Jens Olsson 2005
 *
 * Ocaml can be downloaded freely from http://www.ocaml.net
 *
 * Usage:
 *   piglatin translates each argument to Pig Latin, separated by newlines.
 *   To translate sentances, enclose the sentances within citationmarls ("")
 * 
 * Compiles with: 
 *   Windows: ocamlc -o piglatin.exe str.cma piglatin.ml
 *   Unix: ocamlc -o piglatin str.cma PigLatin.ml
 * 
 * To use with top level system, start it by typing:
 *   ocaml
 * Then load the Str library before loading the actual file
 *   #load "Str.cma";;
 *   #use "PigLatin.ml";;
 *)

(* Constants for matching *)
let wovels = "aeiuoåäöAEIUOÅÄÖ";;
let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";;
let delims = " \t,.!?";;

(* [translateWord s] translates s into Pig Latin. Assumes s is a word with letters only and not uppercase (capitalized is ok though) *)
let translateWord s = 
  (* Special case: check if first letter is uppercase *)
  let c = String.contains (String.uppercase(wovels ^ consonants)) s.[0] in
  
  (* Check if first letter is a wovel and adjust accordingly *)
  let s = if String.contains wovels s.[0] then "w" ^ s else s in
  
  (* Determine where to split word. Splitpoint stored internally, obtained with match_end() *)
  let _ = Str.search_forward (Str.regexp("^["^consonants^"]+")) s 0 in
  
  (* Switch places between first and last part of word and add piglatin extension *)
  let w = String.sub s (Str.match_end()) (String.length s - Str.match_end()) ^ String.sub s 0 (Str.match_end()) ^ "ay" in
  
  (* Adjust for special case if nescessary, ie make first letter uppercase if needed *)
  if c then String.capitalize(String.lowercase w) else w
;;
  
(* [translate s] translates s inte Pig Latin. Delimeters and nonwords are left untouched, words are translated *)
let translate s = match s with Str.Text word -> (try translateWord word with Not_found -> word) | Str.Delim delim -> delim;;   
   
(* [pigLatin s] translates a sentance into Pig Latin. Capitalized words are handled but not uppercase words
   example: "This is a test" is handled correct, "THIS IS A TEST" is not. *)
let pigLatin s = List.fold_left (fun s1 s2 -> s1 ^ (translate s2)) "" (Str.full_split (Str.regexp("[" ^ delims ^ "]+")) s);;

(* Mainloop. Run program with arguments *)
Array.iter (fun s -> print_string((pigLatin s) ^ "\n")) (Array.sub Sys.argv 1 (Array.length(Sys.argv)-1));;