"""Language renderers for the original task algebra; no eval/exec."""
LANGS=('python','javascript','cpp','c','lua','csharp','rust')

def scalar_expr(op,x,lang):
    absx={'python':f'abs({x})','javascript':f'Math.abs({x})','cpp':f'std::abs({x})',
          'c':f'llabs({x})','lua':f'math.abs({x})','csharp':f'Math.Abs({x})','rust':f'({x}).abs()'}[lang]
    tern=lambda c,a,b: f'({a} if {c} else {b})' if lang=='python' else (f'(({c}) and {a} or {b})' if lang=='lua' else (f'(if {c} {{ {a} }} else {{ {b} }})' if lang=='rust' else f'(({c}) ? {a} : {b})'))
    div=f'({absx} // 10)' if lang=='python' else (f'math.floor({absx} / 10)' if lang=='lua' else (f'Math.floor({absx} / 10)' if lang=='javascript' else f'({absx} / 10)'))
    return {'double':f'({x} * 2)','negate':f'(-{x})','absolute':absx,'square':f'({x} * {x})',
      'successor':f'({x} + 1)','sign':tern(f'{x} > 0','1',tern(f'{x} < 0','-1','0')),
      'positive':tern(f'{x} > 0',x,'0'),'even':tern(f'{x} % 2 == 0','1','0'),
      'clamp':tern(f'{x} < -5','-5',tern(f'{x} > 5','5',x)),
      'ones':f'({absx} % 10)','tens':f'({div} % 10)',
      'negative':tern(f'{x} < 0','1','0'),'complement':f'(10 - {x})'}[op]

def signature(lang,kind):
    return {
     'python':{'scalar':'def solve(n: int) -> int:','string':'def solve(s: str) -> str:','array':'def solve(values: list[int]) -> int:'},
     'javascript':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)'},
     'cpp':{'scalar':'long long solve(long long n)','string':'std::string solve(std::string s)','array':'long long solve(const std::vector<long long>& values)'},
     'c':{'scalar':'long long solve(long long n)','string':'const char *solve(const char *input)','array':'long long solve(const long long *values, int length)'},
     'lua':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)'},
     'csharp':{'scalar':'public static long Solve(long n)','string':'public static string Solve(string s)','array':'public static long Solve(long[] values)'},
     'rust':{'scalar':'fn solve(mut n: i64) -> i64','string':'fn solve(mut s: String) -> String','array':'fn solve(values: Vec<i64>) -> i64'},
    }[lang][kind]

def wrap(lang,kind,lines):
    sig=signature(lang,kind)
    if lang=='python':return sig+'\n'+''.join('    '+x+'\n' for x in lines)
    if lang=='lua':return sig+'\n'+''.join('  '+x+'\n' for x in lines)+'end\n'
    code=sig+' {\n'+''.join('    '+x+'\n' for x in lines)+'}\n'
    if lang=='csharp':code='public class Solution {\n'+code+'}\n'
    return code

def string_line(op,lang):
    if lang=='python':return 's = '+{
      'upper':'s.upper()','lower':'s.lower()','reverse':'s[::-1]','trim':"s.strip(' ')",
      'letters':"''.join(c for c in s if ('a' <= c <= 'z') or ('A' <= c <= 'Z'))",
      'digits':"''.join(c for c in s if '0' <= c <= '9')",
      'no_vowels':"''.join(c for c in s if c.lower() not in 'aeiou')",
      'no_spaces':"s.replace(' ', '')",'first_half':'s[:len(s)//2]','second_half':'s[len(s)//2:]',
      'swap_case':'s.swapcase()','collapse':"' '.join(part for part in s.split(' ') if part) + (' ' if s.endswith(' ') and s.strip(' ') else '')"}[op] if op!='collapse' else "s = __import__('re').sub(' +', ' ', s)"
    if lang=='javascript':return 's = '+{
      'upper':'s.toUpperCase()','lower':'s.toLowerCase()', 'reverse':"s.split('').reverse().join('')",'trim':"s.replace(/^ +| +$/g, '')",
      'letters':"s.replace(/[^a-zA-Z]/g, '')",'digits':"s.replace(/[^0-9]/g, '')",'no_vowels':"s.replace(/[aeiou]/gi, '')",
      'no_spaces':"s.replace(/ /g, '')",'first_half':'s.slice(0, Math.floor(s.length/2))','second_half':'s.slice(Math.floor(s.length/2))',
      'swap_case':"s.replace(/[a-zA-Z]/g, c => c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase())",
      'collapse':"s.replace(/ +/g, ' ')"}[op]+';'
    if lang=='lua':return 's = '+{
      'upper':'string.upper(s)','lower':'string.lower(s)','reverse':'string.reverse(s)', 'trim':'(s:gsub("^ +", ""):gsub(" +$", ""))',
      'letters':'(s:gsub("[^a-zA-Z]", ""))','digits':'(s:gsub("[^0-9]", ""))','no_vowels':'(s:gsub("[aeiouAEIOU]", ""))',
      'no_spaces':'(s:gsub(" ", ""))','first_half':'s:sub(1, math.floor(#s/2))','second_half':'s:sub(math.floor(#s/2)+1)',
      'swap_case':'(s:gsub("%a", function(c) if c == c:upper() then return c:lower() else return c:upper() end end))',
      'collapse':'(s:gsub(" +", " "))'}[op]
    if lang=='csharp':return 's = '+{
      'upper':'s.ToUpperInvariant()','lower':'s.ToLowerInvariant()','reverse':'new string(s.Reverse().ToArray())','trim':"s.Trim(' ')",
      'letters':"new string(s.Where(c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')).ToArray())",
      'digits':"new string(s.Where(c => c >= '0' && c <= '9').ToArray())",
      'no_vowels':'new string(s.Where(c => !"aeiouAEIOU".Contains(c)).ToArray())',
      'no_spaces':'s.Replace(" ", "")','first_half':'s.Substring(0, s.Length/2)','second_half':'s.Substring(s.Length/2)',
      'swap_case':'new string(s.Select(c => char.IsUpper(c) ? char.ToLowerInvariant(c) : char.ToUpperInvariant(c)).ToArray())',
      'collapse':'System.Text.RegularExpressions.Regex.Replace(s, " +", " ")'}[op]+';'
    if lang=='rust':return 's = '+{
      'upper':'s.to_ascii_uppercase()','lower':'s.to_ascii_lowercase()','reverse':'s.chars().rev().collect()', 'trim':"s.trim_matches(' ').to_string()",
      'letters':'s.chars().filter(|c| c.is_ascii_alphabetic()).collect()', 'digits':'s.chars().filter(|c| c.is_ascii_digit()).collect()',
      'no_vowels':'s.chars().filter(|c| !"aeiouAEIOU".contains(*c)).collect()', 'no_spaces':"s.replace(' ', \"\")",
      'first_half':'s[..s.len()/2].to_string()','second_half':'s[s.len()/2..].to_string()',
      'swap_case':"s.chars().map(|c| if c.is_ascii_uppercase() { c.to_ascii_lowercase() } else { c.to_ascii_uppercase() }).collect()",
      'collapse':"{ let mut t=String::new(); for c in s.chars() { if c != ' ' || !t.ends_with(' ') { t.push(c); } } t }"}[op]+';'
    if lang=='cpp':
        loop={
          'upper':"t += (c >= 'a' && c <= 'z') ? char(c-32) : c;",
          'lower':"t += (c >= 'A' && c <= 'Z') ? char(c+32) : c;",
          'letters':"if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) t += c;",
          'digits':"if (c >= '0' && c <= '9') t += c;",
          'no_vowels':"if (std::string(\"aeiouAEIOU\").find(c) == std::string::npos) t += c;",
          'no_spaces':"if (c != ' ') t += c;",
          'swap_case':"t += (c >= 'a' && c <= 'z') ? char(c-32) : ((c >= 'A' && c <= 'Z') ? char(c+32) : c);",
          'collapse':"if (c != ' ' || t.empty() || t.back() != ' ') t += c;",
        }
        if op in loop:return '{ std::string t; for (char c : s) { '+loop[op]+' } s=t; }'
        return {'reverse':'std::reverse(s.begin(), s.end());','trim':"{ auto a=s.find_first_not_of(' '); auto b=s.find_last_not_of(' '); s=a==std::string::npos ? \"\" : s.substr(a,b-a+1); }",'first_half':'s=s.substr(0,s.size()/2);','second_half':'s=s.substr(s.size()/2);'}[op]
    if lang=='c':
        condition={ 'letters':"(c>='a' && c<='z') || (c>='A' && c<='Z')",'digits':"c>='0' && c<='9'",
             'no_vowels':'strchr("aeiouAEIOU",c)==NULL','no_spaces':"c!=' '",'collapse':"c!=' ' || j==0 || t[j-1]!=' '"}
        change={'upper':"c>='a' && c<='z' ? c-32 : c",'lower':"c>='A' && c<='Z' ? c+32 : c",
             'swap_case':"c>='a' && c<='z' ? c-32 : (c>='A' && c<='Z' ? c+32 : c)"}
        if op in condition:body=f'if ({condition[op]}) t[j++]=c;'
        elif op in change:body=f't[j++]={change[op]};'
        else:body={'reverse':'t[j++]=s[len-1-i];','first_half':'if (i<len/2) t[j++]=c;',
          'second_half':'if (i>=len/2) t[j++]=c;','trim':'if (i>=a && i<b) t[j++]=c;'}[op]
        init="int a=0,b=len; while(a<b && s[a]==' ') a++; while(b>a && s[b-1]==' ') b--; " if op=='trim' else ''
        return '{ int len=(int)strlen(s), j=0; '+init+'for(int i=0;i<len;i++) { char c=s[i]; '+body+' } t[j]=0; strcpy(s,t); }'

def filter_expr(key,lang):
    ab=scalar_expr('absolute','x',lang)
    cond={'all':'true','positive':'x>0','negative':'x<0','even':'x%2==0','odd':'x%2!=0','nonzero':'x!=0',
          'small':ab+'<=3','large':ab+'>3','even_index':'i%2==0','odd_index':'i%2==1'}[key]
    if lang=='python':cond=cond.replace('true','True')
    if lang=='lua':cond=cond.replace('!=','~=')
    return cond

def render(lang,spec):
    kind=spec['kind']
    if kind=='scalar':
        lines=['n = '+scalar_expr(op,'n',lang)+(';' if lang not in ('python','lua') else '') for op in spec['steps']]
        lines+=['return n'+(';' if lang not in ('python','lua') else '')]
        return wrap(lang,kind,lines)
    if kind=='string':
        lines=['static char s[512]; char t[512]; strcpy(s,input);'] if lang=='c' else []
        lines += [string_line(op,lang) for op in spec['steps']]
        return wrap(lang,kind,lines+['return s'+(';' if lang not in ('python','lua') else '')])
    pred=filter_expr(spec['filter'],lang)
    val=scalar_expr(spec['map'],'x',lang) if spec.get('map') else 'x'
    r=spec['reduce']
    if lang=='python':
        lines=[f'a = [{val} for i, x in enumerate(values) if {pred}]']
        if r=='frequency':lines+=['counts = {}','for x in a: counts[x] = counts.get(x, 0) + 1','return max(counts.values(), default=0)']
        elif r=='product':lines+=['result = 1','for x in a: result *= x','return result']
        else:lines+=['return '+{'sum':'sum(a)','count':'len(a)','min':'min(a, default=0)','max':'max(a, default=0)',
             'first':'a[0] if a else 0','last':'a[-1] if a else 0','range':'max(a)-min(a) if a else 0','distinct':'len(set(a))'}[r]]
        return wrap(lang,kind,lines)
    if lang=='javascript':
        lines=[f'const a = values.filter((x,i) => {pred}).map(x => {val});']
        returns={'sum':'a.reduce((s,x)=>s+x,0)','count':'a.length','product':'a.reduce((s,x)=>s*x,1)',
          'min':'a.length ? Math.min(...a) : 0','max':'a.length ? Math.max(...a) : 0','first':'a.length ? a[0] : 0',
          'last':'a.length ? a[a.length-1] : 0','range':'a.length ? Math.max(...a)-Math.min(...a) : 0','distinct':'new Set(a).size'}
        if r=='frequency':lines+=['const counts = new Map();','for (const x of a) counts.set(x, (counts.get(x)||0)+1);','return Math.max(0,...counts.values());']
        else:lines+=['return '+returns[r]+';']
        return wrap(lang,kind,lines)
    if lang=='lua':
        lines=['local a = {}',f'for k,x in ipairs(values) do local i=k-1; if {pred} then a[#a+1]={val} end end']
        if r in ('distinct','frequency'):
            lines+=['local counts = {}; local result = 0','for _,x in ipairs(a) do counts[x]=(counts[x] or 0)+1 end',
             ('for _ in pairs(counts) do result=result+1 end' if r=='distinct' else 'for _,n in pairs(counts) do result=math.max(result,n) end'),'return result']
        elif r in ('sum','product'):lines += ['local result = '+('1' if r=='product' else '0'),f'for _,x in ipairs(a) do result=result {"*" if r=="product" else "+"} x end','return result']
        elif r=='count':lines+=['return #a']
        else:
            lines+=['if #a==0 then return 0 end']
            if r in ('first','last'):lines+=['return a['+('1' if r=='first' else '#a')+']']
            else:lines+=['local lo,hi=a[1],a[1]','for _,x in ipairs(a) do lo=math.min(lo,x); hi=math.max(hi,x) end','return '+{'min':'lo','max':'hi','range':'hi-lo'}[r]]
        return wrap(lang,kind,lines)
    if lang=='csharp':
        lines=[f'var a = values.Where((x,i) => {pred}).Select(x => {val}).ToList();']
        returns={'sum':'a.Sum()','count':'a.Count','product':'a.Aggregate(1L,(s,x)=>s*x)', 'min':'a.Count>0 ? a.Min() : 0',
          'max':'a.Count>0 ? a.Max() : 0','first':'a.Count>0 ? a[0] : 0','last':'a.Count>0 ? a[a.Count-1] : 0',
          'range':'a.Count>0 ? a.Max()-a.Min() : 0','distinct':'a.Distinct().Count()',
          'frequency':'a.Count>0 ? a.GroupBy(x=>x).Max(g=>g.Count()) : 0'}
        return wrap(lang,kind,lines+['return '+returns[r]+';'])
    if lang=='rust':
        lines=['let mut a: Vec<i64> = Vec::new();',f'for (i, &x) in values.iter().enumerate() {{ if {pred} {{ a.push({val}); }} }}']
        returns={'sum':'a.iter().sum()','count':'a.len() as i64','product':'a.iter().product()',
          'min':'*a.iter().min().unwrap_or(&0)','max':'*a.iter().max().unwrap_or(&0)',
          'first':'*a.first().unwrap_or(&0)','last':'*a.last().unwrap_or(&0)',
          'range':'a.iter().max().unwrap_or(&0)-a.iter().min().unwrap_or(&0)',
          'distinct':'{ a.sort(); a.dedup(); a.len() as i64 }',
          'frequency':'{ let mut counts=std::collections::HashMap::new(); for x in a { *counts.entry(x).or_insert(0i64)+=1; } *counts.values().max().unwrap_or(&0) }'}
        return wrap(lang,kind,lines+['return '+returns[r]+';'])
    lines=(['std::vector<long long> a;',f'for(size_t i=0;i<values.size();i++) {{ auto x=values[i]; if({pred}) a.push_back({val}); }}','int size=(int)a.size();'] if lang=='cpp' else
           ['long long a[64]; int size=0;',f'for(int i=0;i<length;i++) {{ long long x=values[i]; if({pred}) a[size++]={val}; }}'])
    if r in ('sum','product'):lines += ['long long result='+('1;' if r=='product' else '0;'),f'for(int i=0;i<size;i++) result {"*=" if r=="product" else "+="} a[i];','return result;']
    elif r=='count':lines+=['return size;']
    elif r in ('distinct','frequency'):
        lines+=['long long result=0;','for(int i=0;i<size;i++) { int count=0, earlier=0; for(int j=0;j<size;j++) { if(a[j]==a[i]) { count++; if(j<i) earlier=1; } } '+('if(!earlier) result++;' if r=='distinct' else 'if(count>result) result=count;')+' }','return result;']
    else:
        lines+=['if(size==0) return 0;']
        if r in ('first','last'):lines+=['return '+('a[0];' if r=='first' else 'a[size-1];')]
        else:lines+=['long long lo=a[0],hi=a[0];','for(int i=0;i<size;i++) { if(a[i]<lo) lo=a[i]; if(a[i]>hi) hi=a[i]; }','return '+{'min':'lo;','max':'hi;','range':'hi-lo;'}[r]]
    return wrap(lang,kind,lines)